הבלוג של מגהסופט

עבר זמן מאז כתבתי פה ודברים קצת התעדכנו. אז בשנתיים האחרונות החבילה המומלצת שלנו מתבססת על Node.js. מהיר, פשוט, קל להתקנה לתחזוקה ולדיבוג, הרבה פחות מסורבל לעומת ג'אווה ומאפשר תאימות וחלקי קוד משותפים בין השרת לקליינט. כמובן שJava עדיין מככבת בפרוייקטים שלנו, במיוחד בפרוייקטים הוותיקים וגם סתם אצל לקוחות שבוחרים לפתח בשפה זו אבל כשאנחנו נדרשים להקים מערכת מאפס ולבחור ארכיטקטורה node הוא בהחלט הבחירה שלנו. בפוסטים הבאים נעלה טיפים, רעיונות, פתרונות וPatterns לבעיות נפוצות.

אחרי שנים ארוכות שבהן חטאתי ונשארתי נאמן לwindows הישן והטוב, מצאתי לנכון סוף סוף לפרמט את המחשב ולהתקין אובונטו על הלפטופ האישי שלי (ליתד דיוק Kubuntu כי אני לא אוהב את ממשק הUnity). אז מה גרם לי לעבור? אולי כדאי קודם לשאול מה גרם לי להתקין מערכת הפעלה בתשלום?

התשובה פשוטה:

הwindows מגיע עם המחשב וקשה היום לקנות לפטופ נורמלי בלי ערכת הפעלה מותקנת מראש. זה נראה לי מטופש לזרוק 100 דולר לפח אז נשארתי עם מה שיש.

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

אז למה בכל זאת עברתי?

קודם כל, כי windows 8 כל כך מזעזעת, לא ידידותית ולא אינטואיטיבית שלא יכולתי לסבול את המחשבה לעבור אליה

דבר שני, מיקרוסופט פתחה את צוואר הבקבוק ומאז שיש אופיס בענן (Office 365) אז כבר לא צריך התקנה מקומית של אופיס. מקסימום משלמים כמה דולרים לחודש.

לסיום: כמתכנת, העלות עלתה על התועלה. רוצה להתקין רובי? בהצלחה עם windows. פיתון? חצי מהספריות לא מתאימות במיוחד כל מה שקשור לסיסטם. להריץ דברים שכתבתי לרסברי פיי על חלונות? נו באמת .Hadoop? צריך מליון מעקפים שאפילו לא ניסיתי. לקמפל דברים עם GCC או להריץ דברים בCygwin ממש לא בא לי על windows.

גם להריץ VM ולהקריב את ביצועי המכונה אני לא רוצה מה גם שעם דיסק SSD אני מוגבל במקום הפנוי וכל MB הוא יקר.

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

לאחרונה החלטנו להתחיל לפתח ברובי וליתר דיוק ברובי און ריילס. אלפי מאמרים נכתבו בנושא זה, מפרטים ומדגימים את היתרונות בטכנולוגיה זו ואת הקלות והמהירות בה ניתן לפתח מערכות Web. ובכל זאת, לאחר כמעט עשור של תכנות בJava ובעיקר בJ2EE וחלופותיו הפתוחות (Spring, Hibernate וכו') אני מוצא לנכון לפרוס את הסיבות למעבר לרובי.

כי נמאס מהסירבול של Java

אני עובד בג'אווה, בונה אפליקציה יפה עם כמה מסכים. כמות הJars שאני צריך להביא, תהליך בניית האפליקציה (הWAR) והDeploy הארוך גוזלים זמן יקר בכל פעם שרוצים לשנות אפילו שדה אחד מסכן. זה מתחיל בבנייה ארוכה בMaven שתוצאתו קובץ ענק של עשרות MB, ואז צריך להעלות את הקובץ לשרת מה שיכול לקחת דקות ארוכות כשמדובר בCloud, מה שגורם לאתחול האפליקציה (עוד כמה דקות) ולבסוף לבדוק ולגלות ששוב צריך לשנות משהו. התהליך הזה בלתי נסבל. אמנם יש דרכים לעקוף את זה כמו העתקת קובץ JSP ישירות לשרת אבל זה עובד רק בתנאים מסויימים ובוודאי שזו לא דרך מומלצת.

כי האובייקטים בג'אווה הם Strong typed

אני רוצה דבר פשוט: לשלוח אובייקט מJavaScript לשרת, לבצע פעולה כלשהי בשרת ולשלוח בחזרה תשובה לJS. עם JSON זה אמור להיות קל. הstring הופך לאובייקט JavaScript ולהפך. אבל בג'אווה אי אפשר ליצור אובייקט בלי להגדיר לו מחלקה מתאימה מראש. זה אומר או לפרסר את הJSON עם parser כלשהו, או להגדיר קלאס עם שדות ואנוטציות מתאימות ולהשתמש בפרימוורק כמו Jackson. זה אומר שכל שינוי בשדות של הJSON יחייב שינוי בקוד של הג'אווה. הסירבול והסיבוך במעבר מידע בין קליינט לסרבר הוא בעייתי ולא כדאי.

כי ריבוי הפרימוורקים והשכבות מסבך את העבודה

נסו לחבר את Spring וHibernate. לא מסובך מאוד למי שיודע מה הוא עושה. נסו לחבר את זה לGWT, זה כבר כן מסובך כי אין דרך סטנדרטית. עכשיו בואו נגדיר שדה בHibernate, נשתמש בו בDAO (מוזרק דרך ספרינג, אלא מה?), שמתמפה לשדה בטופס GWT. זה כבר מצריך לא מעט עבודה. הטכנולוגיות כל כך רבות, השכבות השונות והחיבורים בינהם מויאים את החשק לפתח. כולם כותבים MVC אבל מה עם Model שמתחבר באופן טבעי לView שמדבר בצורה נורמלית עם הController?

בשביל פיתוח סטנדרטי, יותר מדי טכנולוגיות רק מזיקות

ג'אווה נהדרת. יש אינספור טכנולוגיות, פרימוורקים וספריות. אני יכול לאנדקס מסמכים בLucene, להריץ חישובים מבוזרים בHadoop, לשמור מידע בMySQL או בnoSQL או בGoogle App Engine או במליון דרכים אחרות. אבל בואו נודה בזה, חלק גדול מהאפליקציות דורשות פחות או יותר אותו דבר: קצת לוגיקה בשרת, UI משובח מבוסס JS וAJAX, ושמירת מידע בRDBMS. לא מדובר על מדע טילים ולא צריך אלף פרימוורוקים מתוחכמים בשביל זה. לכן אני מוותר על הגמישות והתשתיות של ג'אווה לטובת סטנדרט אחיד ופשוט, אינגרטיבי באופן מלא, קריא, קליל, מהיר ונוח.

אז מה עם ג'אווה בכל זאת?

Java בהחלט לא הולכת לפח. היא תשאר שפה חשובה וחזקה והטכנולוגיות הרבות שפותחו סביבה ימשיכו לשרת אחרים ואותי עוד שנים ארוכות. בהחלט אשקול פיתוח פרוייקטים בג'אווה במקרה הצורך אבל כשמדובר בפיתוח WEB פשוט, אני אבחר במשהו קליל ומהיר יותר וכרגע Ruby On Rails עונה בדיוק על הדרישות.

אתרים שונים מספקים API חיצוני על מנת לאפשר למפתחים לכתוב אפליקציות ותוכנות המתממשקות לאתר. הידועים שבהם: פייסבוק, גוגל, טוויטר וכו' מאפשרות למפתחים חיצוניים לגשת לפרופיל של המשתמש הרשום, לבצע פעולות בשמו, לקבל מידע, לבצע עדכונים וכו'. על מנת לנהל את ההתממשקות וההרשאות של משתמשי הAPI נעשה שימוש במנגנון אישור בשם oAuth. במאמר זה נסקור את הטכניקה הזו ואת היישום שלה בפועל בAPI של Facebook. נושא זה הכרחי כמעט לכל Facebook Application Developer ולמעשה לכל מי שרוצה לפתח אפליקצייה לפייסבוק או אתרים דומים (גוגל, טוויטר ועוד).

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

הדרך לפתרון שמציע oAuth עובד בצורה הבאה:

מפתחי האתר כותבים אפליקציית פייסבוק ריקה (ללא תוכן). באפליקציה זו מגדירים את הדברים הבאים:

• אילו הרשאות האפליקציה מבקשת מהמשתמש? (צפייה, עדכון, וכו')
• הדומיין של האתר mydomain.com

כשהמשתמש רוצה לאפשר לאתר שימוש בAPI, האתר מפעיל לינק בדפדפן במבנה הבא:

https://www.facebook.com/dialog/oauth?client_id=YOUR_APP_ID&redirect_uri=YOUR_URL&scope=email,read_stream

הפעלת הלינק הזה על ידי הדפדפן (redirect פשוט) תעלה למשתמש את המסך כניסה לפייסבוק:

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

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

כעת פייסבוק יודע שהמשתמש אישר לאתר לבצע פעולות מסויימות.

במידה והמשתמש אישר את האפליקציה, פייסבוק יעשו redirect לכתובת שצויינה בבקשה המקורית (הועבר כפרמטר בURL). הURL שפייסבוק שולח יכלול פרמטר בשם code. עם הפרמטר הזה נפנה לפייסבוק על מנת לקבל את הaccess_token, שהוא הקוד הסופי שמאפשר קריאות API לפייסבוק.

https://graph.facebook.com/oauth/access_token?client_id=YOUR_APP_ID&redirect_uri=YOUR_URL&client_secret=YOUR_APP_SECRET&code=THE_CODE_FROM_ABOVE

פייסבוק יאשר את הקוד וישלח לכתובת שמצויינת בredirect_uri את התשובה: access_token שייראה בערך כך:

הקוד הזה ישמש אותנו לקריאות API. כל קריאת API (מבוססת REST) מאפשרת שירשור של הaccess_token כפרמטר. כך אנו יכולים לבצע קריאות לפייסבוק ופעולות על משתמש מסויים, לאחר שאישר אותנו מבלי לבקש פרטי משתמש. פייסבוק יאפשרו פעולות רק מתוך הדומיין שהוגדר באפליקציה כדי למנוע מצבים בסגנון cross site scripting. הaccess_token תקף למשך הזמן שהוגדר לו. אפשר גם ליצור token שאינו פג לעולם, תלוי בהגדרות.

בפוסט זה אדגים כיצד לבנות פרוייקט end-to-end בטכנולוגיות: Spring MVC, Hibernate קומפילציה באמצעות Maven והרצה כWAR על Tomcat או כל שרת אפליקציות ג'אווה אחר. הפרוייקט יכלול בסיס נתונים MySQL עם טבלה השומרת פרטי לקוחות, דף JSP שמציג נתונים מהטבלה, שרות REST מבוסס Spring MVC לקבלה ושליחת נתונים ופעולות מול הDatabase באמצעות Hibernate.

ראשית נקים את התשתיות באמצעות הגדרת הpom.xml של הMaven. למען הנוחות, הפרוייקט יכלול מודול יחיד עם כל הקוד. מומלץ לפצל פרוייקטים אמיתיים למספר מודולים כמו: persistence, dao, web וכו'.

לגרסה האנגלית: Maven, Spring, Hibernate Web Tutorial

להלן הקוד של הpom.xml:

<!--?xml version="1.0"?-->
<project xsi:schemalocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
    <modelversion>4.0.0</modelversion>

    <repositories>
        <repository>
            <id>jboss-public-repository-group</id>
            <name>JBoss Public Repository Group</name>
            <url>https://repository.jboss.org/nexus/content/repositories/releases/</url>
        </repository>

        <repository>
            <id>SpringSource Enterprise Bundle Repository – External Bundle Milestones</id>
            <url>http://repository.springsource.com/maven/bundles/milestone</url>
        </repository>
        <repository>
            <id>SpringSource Enterprise Bundle Repository – SpringSource Bundle Releases</id>
            <url>http://repository.springsource.com/maven/bundles/release</url>
        </repository>
        <repository>
            <id>SpringSource Enterprise Bundle Repository – External Bundle Releases</id>
            <url>http://repository.springsource.com/maven/bundles/external</url>
        </repository>

        <repository>
            <id>Maven</id>
            <url>http://repo1.maven.org/maven2/</url>
        </repository>

    </repositories>

    <groupid>il.co.megasoft</groupid>
    <artifactid>spring-seminar</artifactid>
    <packaging>war</packaging>
    <version>app</version>
    <name>spring-seminar</name>
    <url>http://maven.apache.org</url>
    <properties>
        <maven.compiler.source>1.5</maven.compiler.source>
        <maven.compiler.target>1.5</maven.compiler.target>
        <webappdirectory>${project.build.directory}/${project.build.finalName}</webappdirectory>
        <project.build.sourceencoding>UTF-8</project.build.sourceencoding>
        <hibernate.version>3.6.0.Final</hibernate.version>
        <org.springframework.version>3.0.5.RELEASE</org.springframework.version>
    </properties>
    <dependencies>
        <dependency>
            <groupid>junit</groupid>
            <artifactid>junit</artifactid>
            <version>4.8.1</version>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupid>org.apache.openejb</groupid>
            <artifactid>commons-dbcp-all</artifactid>
            <version>1.3</version>
        </dependency>

        <dependency>
            <groupid>taglibs</groupid>
            <artifactid>standard</artifactid>
            <version>1.1.2</version>
        </dependency>
        <dependency>
            <groupid>javax.servlet</groupid>
            <artifactid>jstl</artifactid>
            <version>1.1.2</version>
        </dependency>

        <dependency>
            <groupid>net.sf.ehcache</groupid>
            <artifactid>ehcache</artifactid>
            <version>[2.0.0,]</version>
            <type>pom</type>
        </dependency>

        <dependency>
            <groupid>org.hibernate</groupid>
            <artifactid>hibernate-c3p0</artifactid>
            <version>3.3.1.GA</version>
        </dependency>

        <dependency>
            <groupid>com.google.gwt</groupid>
            <artifactid>gwt-servlet</artifactid>
            <version>2.2.0</version>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupid>com.google.gwt</groupid>
            <artifactid>gwt-user</artifactid>
            <version>2.2.0</version>
            <scope>provided</scope>
        </dependency>

        <dependency>
            <groupid>commons-lang</groupid>
            <artifactid>commons-lang</artifactid>
            <version>2.6</version>
        </dependency>

        <dependency>
            <groupid>org.hibernate</groupid>
            <artifactid>hibernate-core</artifactid>
            <version>${hibernate.version}</version>
        </dependency>

        <dependency>
            <groupid>org.hibernate</groupid>
            <artifactid>hibernate-entitymanager</artifactid>
            <version>${hibernate.version}</version>
        </dependency>

        <dependency>
            <groupid>org.hibernate</groupid>
            <artifactid>hibernate-validator</artifactid>
            <version>4.1.0.Final</version>
        </dependency>

        <dependency>
            <groupid>mysql</groupid>
            <artifactid>mysql-connector-java</artifactid>
            <version>5.1.16</version>
        </dependency>

        <dependency>
            <groupid>org.springframework</groupid>
            <artifactid>spring-context</artifactid>
            <version>3.0.0.RELEASE</version>
            <scope>runtime</scope>
            <exclusions>
                <exclusion>
                    <groupid>commons-logging</groupid>
                    <artifactid>commons-logging</artifactid>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupid>org.slf4j</groupid>
            <artifactid>jcl-over-slf4j</artifactid>
            <version>1.5.8</version>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupid>org.slf4j</groupid>
            <artifactid>slf4j-api</artifactid>
            <version>1.5.8</version>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupid>org.slf4j</groupid>
            <artifactid>slf4j-log4j12</artifactid>
            <version>1.5.8</version>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupid>log4j</groupid>
            <artifactid>log4j</artifactid>
            <version>1.2.14</version>
        </dependency>

        <!-- Hibernate uses slf4j for logging, for our purposes here use the simple
            backend -->

        <dependency>
            <groupid>org.slf4j</groupid>
            <artifactid>slf4j-simple</artifactid>
            <version>1.5.3</version>
        </dependency>

        <!-- Hibernate gives you a choice of bytecode providers between cglib and
            javassist -->
        <dependency>
            <groupid>javassist</groupid>
            <artifactid>javassist</artifactid>
            <version>3.8.0.GA</version>
        </dependency>

        <dependency>
            <groupid>javax.transaction</groupid>
            <artifactid>jta</artifactid>
            <version>1.1</version>
        </dependency>
        <dependency>
            <groupid>javax.transaction</groupid>
            <artifactid>transaction-api</artifactid>
            <version>1.1</version>
        </dependency>

        <dependency>
            <groupid>org.springframework</groupid>
            <artifactid>spring-core</artifactid>
            <version>${org.springframework.version}</version>
        </dependency>
        <dependency>
            <groupid>org.springframework</groupid>
            <artifactid>spring-beans</artifactid>
            <version>${org.springframework.version}</version>
        </dependency>
        <dependency>
            <groupid>org.springframework</groupid>
            <artifactid>spring-aop</artifactid>
            <version>${org.springframework.version}</version>
        </dependency>
        <dependency>
            <groupid>org.springframework</groupid>
            <artifactid>spring-context</artifactid>
            <version>${org.springframework.version}</version>
        </dependency>
        <dependency>
            <groupid>org.springframework</groupid>
            <artifactid>org.springframework.oxm</artifactid>
            <version>${org.springframework.version}</version>
        </dependency>
        <dependency>
            <groupid>org.springframework</groupid>
            <artifactid>org.springframework.web.servlet</artifactid>
            <version>${org.springframework.version}</version>
        </dependency>
        <dependency>
            <groupid>org.springframework</groupid>
            <artifactid>spring-context-support</artifactid>
            <version>${org.springframework.version}</version>
        </dependency>
        <dependency>
            <groupid>com.google.collections</groupid>
            <artifactid>google-collections</artifactid>
            <version>1.0-rc4</version>
        </dependency>
        <dependency>
            <groupid>org.springframework</groupid>
            <artifactid>spring-tx</artifactid>
            <version>${org.springframework.version}</version>
        </dependency>
        <dependency>
            <groupid>org.springframework</groupid>
            <artifactid>spring-jdbc</artifactid>
            <version>${org.springframework.version}</version>
        </dependency>
        <dependency>
            <groupid>org.springframework</groupid>
            <artifactid>spring-orm</artifactid>
            <version>${org.springframework.version}</version>
        </dependency>
        <dependency>
            <groupid>org.springframework</groupid>
            <artifactid>spring-web</artifactid>
            <version>${org.springframework.version}</version>
        </dependency>
        <dependency>
            <groupid>org.springframework</groupid>
            <artifactid>spring-webmvc</artifactid>
            <version>${org.springframework.version}</version>
        </dependency>
        <dependency>
            <groupid>org.springframework</groupid>
            <artifactid>spring-test</artifactid>
            <version>${org.springframework.version}</version>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupid>org.springframework.security</groupid>
            <artifactid>spring-security-parent</artifactid>
            <version>${org.springframework.version}</version>
            <type>pom</type>
        </dependency>

        <dependency>
            <groupid>org.springframework.security</groupid>
            <artifactid>spring-security-config</artifactid>
            <version>${org.springframework.version}</version>
        </dependency>

        <dependency>
            <groupid>org.springframework.security</groupid>
            <artifactid>org.springframework.security.web</artifactid>
            <version>3.0.3.RELEASE</version>
        </dependency>

        <dependency>
            <groupid>commons-fileupload</groupid>
            <artifactid>commons-fileupload</artifactid>
            <version>1.2.2</version>
            <type>jar</type>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupid>commons-io</groupid>
            <artifactid>commons-io</artifactid>
            <version>1.4</version>
            <type>jar</type>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupid>org.apache.poi</groupid>
            <artifactid>poi</artifactid>
            <version>3.8-beta3</version>
            <type>jar</type>
            <scope>compile</scope>
        </dependency>

        <dependency>
            <groupid>org.apache.poi</groupid>
            <artifactid>poi</artifactid>
            <version>3.8-beta4</version>
            <type>jar</type>
            <scope>compile</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupid>org.apache.maven.plugins</groupid>
                <artifactid>maven-war-plugin</artifactid>
                <version>2.1.1</version>
                <executions>
                    <execution>
                        <phase>compile</phase>
                        <goals>
                            <goal>exploded</goal>
                        </goals>
                    </execution>
                </executions>
                <configuration>
                    <webappdirectory>${webappDirectory}</webappdirectory>
                    <warsourcedirectory>WebContent</warsourcedirectory>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>