Developing a Web Service using apache CXF

apache cxf  מאפשרות לנו בקלות להגדיר web service באמצעות pojo objects

שלב א הגדרת ה Contract

package learn.cfx.ws    ;
import javax.jws.WebService;
@WebService
public interface IUserDataRepository {
      @WebMethod
      void SetUserData ( UserData pUserData);

      @WebMethod
      UserData GetUserDataByID ( int  pID);
}

שימוש ב @WebService על מנת לציין שה interface  מגדיר service endpoint interface  או contract  בלשון wcf

הattribute  של @WebMethod מאפשר לעשות קסטומיזציה על הגדרת ה methods  של ה interface  כגון שם הmethod  ב wsdl וכד

שלב ב הגדרת ה payload  של UserData

package learn.cfx.ws;
import javax.xml.bind.annotation.XmlRootElement;
@XmlRootElement(name = "UserData")
public class UserData {
 private String mName;
 private String mID;

 public UserData() {
 }

 public int getID() {
   return mID;
 }

 public void setID(int pID) {
   this.mID = pID;
 }

 public int getName() {
 return mName;
}

public void setID(int pName {
 this.mName = pName;
 }
}    

שימוש בספריית Java Architecture for XML Binding

(JAXB)

האנוטציה @XmlRootElement מגדירה את ה root  של ה xml  המתאר את userdata  

ניתן לבצע קסטומיזציה של כל אחד מה properties  באמצעות @XmlElement

שלב ג הגדרת  ה Service

package learn.cfx.ws    ;
import javax.jws.WebService;

@WebService
public class UserDataRepositoryImpl implements IUserDataRepository {

public UserDataRepositoryImpl(){
}
        
public void SetUserData ( UserData pUserData){
    //do nothing 
}


@WebMethod
UserData GetUserDataByID ( int  pID){
    UserData RetValue = new UserData();
    RetValue.setName ("Shaaf Peer");
    RetValue.setID (2);
    return RetValue;

}
}

שלב ד הגדרת ה Binding  באמצעות spring

<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:jaxws="http://cxf.apache.org/jaxws"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://cxf.apache.org/jaxws http://cxf.apache.org/schemas/jaxws.xsd">
<import resource="classpath:META-INF/cxf/cxf.xml" />
<import resource="classpath:META-INF/cxf/cxf-extension-soap.xml" />
<import resource="classpath:META-INF/cxf/cxf-servlet.xml" />
<jaxws:endpoint
id="UserDataRepository"
implementor="learn.cfx.ws.UserDataRepositoryImpl"
address="/UserDataRepository" />
</beans>

אני בדרך כלל חובב maven  על פני ant  לכן יש להוריד את ה pom  המתאים מהמרשתת על מנת לקבל pom עם מספר הגירסה המעודכן ביותר של cxf

אך בלילה בלילה חולם ב++c ית

השבוע דיברתי עם גל הילד שלי על זה שהוא חייב בתיכון לבחור שפה שלישית אידיש אל אף עתיקותה יש דברים שאפשריים רק באידיש בעיקר הומור זה החוזק והבלעדיות של השפה וכמה שיתפחו  או ישקיעו בעברית או כל שפה אחרת זה לעולם לא יהיה זה .

כיום מיקרוסופט נותנת boost ל c++  שפה שהיקף השימוש בה ירד עם השנים לטובת שפות דינמיות יותר ויותר .עדיין משחקים ותוכנת רציניות נכתבו ב c++ מיקרוסופט מעולם לא נטשה את ה c++ וחלק ניכר מה products  שלה נשאר native בשפת c++  .אבל ציבור המפתחים שבשנים 1992 ראה ב c++  את העתיד עם היחלשותן של cobol   fortran  ו pascal  די נטש אותה עם השניים לjava , c# ואח"כ לשפות יותר דינמיות של python , ruby , php וכד.

C++  עם השנים הביאה רעננות ויכולות חדשות לשפה בהרבה מאוד תחומים .

תחביר ל lambda expression   וanonymous functions  .

ספריות סטנדרטיות לטיפול ב strings (שהיו קימות כבר ממזמן אבל התפתחו להם )

ספריית <thread>  שעוטפת את השימוש ב threads  

עטיפה ל Direct compute  בספריית amp  המאפשרת להאיץ קוד על ה GPU

הגדרת function pointers  יותר קלה .

Tuples

ועוד

בתור מפתח קשיש אני מברך על שובו של ה c++ ,בימים אילו שnode.js מביאה את ה javascript לשרת יש בc++  כוח ויכולות בהן יש לה יתרונות על שפות אחרות בעיקר במערכות embed  , Drivers  עבודה עם opengl  ו directx  .

BeagleBoard

BeagleBoard הינו כרטיס של embeded computer המשמש אותנו לצרכי ביצוע poc מהירים .האח הבוגר החכם והחזק של beaglebone השכיח אצל חובבנים בתחום .


אנו משתמשים בפלטפורמה linuxית ממספר סיבות העיקריות בהן הינה שבניגוד ל windows embeded  הכל חינם.וגם עצם זה שזה קוד פתוח מאפשר לנו לגשת למחוזות שהיו סגורים בפנינו ב windows embeded.
מבחינה ארכיטקטונית הפתרונות שלנו בד”כ נראים כך :

המערכת מורכבת מ
1.כרטיס beagleboard שהוא הembeded computer שמריץ את כל הלוגיקה של הפעלת ה device
2.מDriver שלנו שעיקרו המרות מתחים בין ה Beagleboard ל Device המופעל ,לפעמים הוא גם מכיל לוגיקות real time שקשה או מיותר להעמיס את הbeagleboard בהם .החיבור הינו באמצעות קווי io מה beagleboard בד”כ למרות שלפעמים החיבור מתבצע באמצעות יציאות אחרות .
Device .3
4.מחשב שתפקידו שו”בי בעיקר כגון תיכנון משימה ב offline בצגת גרפיקה מאוד מורכבת וכד ממשק משתמש חכם הקישור ל beagleboard  מתבצע באמצעות lan למעט מקרה אחד בה החיבור היה באמצעות usb המחשב לא תמיד מחובר למערכת.המחשב לא מריץ בהכרך linux בזמן העבודה למרות שבפיתוח תמיד אנו עובדים במערכת linux ית  לצרכי פיתוח הקוד .

תצורה נוספת שלפעמים אנו משתמשים בה הינה :


בה החיבור לתצוגה הינה ישירות מהכרטיס ליציאת S-Video של ה Beaglebourd.קוד התצוגה נכתב ב QT ובד”כ מתקבל באיכות מעולה

mef vs dynamic class loading from configuration

השבוע יצא לי להשתתף ב architecture design review בו הוצג פיתרון לבעיה הבאה:

תיאור הבעיה

מרחב הבעיה הנו מערכת לעיבוד אות וידאו הכתובה ב dot net אשר צריך לממש בה את החיבור למקורות וידיאו שונים .

הארכיטקטורה נדרשת להגדיר את החיבור בין assembly שמכיל אלגוריתם לעיבוד וידיאו ל assembyמתאם למצלמה .כאשר יש דרישה שאהיה decoupling בין שני הassemblies נוכל להחליף את המתאם המצלמה הנוכחי במתאם אחר מבלי לשנות דבר בassembly של עיבוד הוידאו .

ארכיטקטורת הפתרון המוצא

ארכיטקטורת הפתרון שהוצגה התבססה על שימוש ב microsoft mef על מנת לבצע את החיבור בין ה assembles

  [Export(typeof(ICameraControl))]   
  public class CameraTypeBAdapter : ICameraControl   
  { 
         public byte [] GetNextFrame() 
         {
                 return theNextFrame;      
         } 
   }

בצד של ה client

class CameraController
{
    [Import(typeof(ICameraControl))]
    public ICameraControl CameraControl { get; set; }

    public void Init()
    {
        try
        {
            AggregateCatalog aggregatecatalogue = new AggregateCatalog();

            aggregatecatalogue.Catalogs.Add(new DirectoryCatalog(
                AppDomain.CurrentDomain.BaseDirectory));

            CompositionContainer container = new CompositionContainer(
                aggregatecatalogue);
            container.ComposeParts(this);

        }

        catch (CompositionException cex)
        {
            Console.WriteLine(cex.Message);
        }
    }

    public byte[] GetNextFrame()
    {
        return CameraControl.GetNextFrame();
    }
}

נדרש שה server לא יהיה singleton דבר אשר יכול להישלט על ידי attribute של

[PartCreationPolicy (CreationPolicy.NonShared)]

על הclass של ה server.

בחינת ה Domain של הבעיה מראה שכרגע קימות שתי מצלמות שצריך לתמוך בהן לא הוגדר שבעתיד יצטרכו לתמוך במצלמת אחרות וההחלטה לבנות תשתית שתתמוך בתהליך כזה התבשלה אצל המפתחים של הפרויקט האפשרות שבאתר ה production כל מה שיצטרכו לעשות על מנת להחליף סוג מצלמה זה להחליף dll לא היתה חלק מה domain .

לפעמים מפתחים מכניסים תשתיות שאין בהן צורך. הדבר מייקר ומסבך את הפיתרון סתם.

באותה מידה יכלו המפתחים להחליט שהחלפת המצלמה תהייה on the fly .חשוב ב desgins review לרדת לעומקו של מרחב הdomain של הבעיה אותה מנסים לפתור לפני שצוללים לפתרון ברמה טכנולוגית .

ההמלצה שלי

אין כל סיבה כאן לשימוש במיקרוסופט mef אשר תסבך את הארכיטקטורה .

mef לא נותנת כאן ערך מוסף לפתרון אלא רק מגבילה אותו :

1.לא נוכל להפיץ שני adapters במקביל באותו bungle של assemblies .
2.שליטה על תהליך ה יצירה של ה class ים הנו מוגבל ב mef

לפי דעתי שימוש ב קונפיגורציה להצבעה על ה assembly וה type הנה פתרון פשוט וגמיש יותר .
מבחינת ביצועים לא צריכה להתבצע סריקה של כל ה type במערכת על מנת לבצע את הקישור בין ה client והserver
כמו כן מתן אפשרות שליטה למשתמש המערכת לבחור את הקונפיגורציה הרצויה יותר פשוטה .
מפתח המערכת צריך להכניס קוד שקורא מקונפיגורציה את ה assembly וה type וליצור את ה class זה לא קוד מורכב או מסובך .

spring framework לפי דעתי נותנת כלים טובים ופשוטים לפתרונות בעיות אילו
דוגמה בspring לפתרון הבעיה

 <bean id="CameraControl" class="com.zvika.camera.services.CameraControlB">
           
 </bean>

הקוד לטעינת ה bean

ConfigurableApplicationContext context = 
            new ClassPathXmlApplicationContext(new String[] {"Camera-Adapter.xml"});
    

ICameraControl theCameraControl = (ICameraControl)context.getBean("CameraControl");
        
theCameraControl.GetNextFrame ();

אז זהו התייאשתי מלכתוב במערכת הבלוגים של מיקרוסופט  .שנים היה לי שמה בלוג שעודכן לפעמים בעיקר בתקופות שאין לחץ בעבודה או יצאה טכנולוגיה חדשה לעולם שהיתי מוכרח לכתוב עליה .

יש הרבה סיבות שעזבתי את הבלוגיה של מיקרוסופט ואולי המשמעותית ביותר הינה שאחרי שמיקרוסופט נתנה בעיטה בתחת לציבור המפתחים שלה בעקבות המתת ה Silverlight התחלנו לזלוג יותר ויותר ממצב של רק מיקרוסופט ואף אחד אחר לא קיים .לטכנולוגיות אחרות אם זה linux  בעיקר בהפצת ubuntu ,  וכן php java spring python opengl android ועוד .

אני מאמין שמאתר בלוגים שלא של מיקרוסופט יהיה לי יותר קל לכתוב על טכנולוגיות אילו .

סיבה נוספת הנה שאחרי שאתר הבלוגים של מיקרוסופט שודרג סגרו לי את האפשרות לערוך ולהוסיף בלוגים חדשים מבלי כוונה זו או אחרת אבל אף אחד שמה לא מצא זמן אל אף פניותיי הרבות .

בכל מקרה אני הולך להמשיך מפה ולדבר בעיקר על טכנולוגיה גם מיקרוסופטית לא זנחנו את הפרויקטים ב Direct3d11 , ב surface , wpf , wcf ,wf , SQL Server

וגם על טכנולוגיות שאינן מיקרוסופטיות  אליהם נכנסו בשנתיים האחרונות .

בתור מוביל טכנולוגי וארכיטקט מערכת של קבוצה ענקי, עם מגוון פעילויות רב ביותר אני עובד עם מגוון טכנולוגיות עצום החל מטכנולוגיות web ,  אני שר ומגנן jquery

Asp mvc , php spring mvc 

בסיסי נתונים sql server ו mysql ,  מנועי nosql כדוגמת mongodb ו RavenDB

directx , opengl , מנועים גרפיים 

android 

linux , embeded linux 

hadoop 

wpf , QT , swing 

sharepoint  

ועוד ואפילו עוד הרבה .