הכירו את EJB

במאמר זה נסתכל על EJB - Enterprise JavaBeans. טכנולוגיה זו היא חלק ממפרט Java EE. ניגע בנושאים כגון:

• מה זה EJB;
• מהי ההיסטוריה של EJB;
• אילו סוגי EJB קיימים?

נכתוב גם אפליקציה קטנה של HelloWorld באמצעות EJB ו-servlets. מאמר זה יהיה שימושי לקוראים שהפכו בנוח עם Java SE ומתחילים ללמוד Java EE. כדי להבין היטב את החלק המעשי של מאמר זה, מומלץ לקרוא תחילה את המאמר " הקמת הסביבה המקומית ".

היסטוריה קצרה של EJB

עוד בשנת 1996, כאשר מחבר המאמר הזה היה בן 5, ג'אווה כבר הייתה פופולרית בקרב מפתחים. הסיבה לכך הייתה ה-API הידידותי, איסוף אשפה אוטומטי וכו'. Java היה בשימוש נרחב במערכות האחראיות ל-backend. עם זאת, למרות כל תענוגות השפה, מתכנתים של אז נזקקו לפונקציונליות מסוימת שעדיין לא הוטמעה ב-JDK. צרכים אלו היו:

• הבטחת התמדה של נתונים;
• שלמות העסקה
• גישה תחרותית לנתונים (בקרת ריבוי פתילים);
• וכנראה משהו אחר.

כל זה הוביל לגידול טבעי באוכלוסיית ספריות ביתיות, שנכתבו בעצמן, סגורות. במילים אחרות, כל אחד מילא את צרכיו כמיטב יכולתו. זאת עד ש-IBM יצאה עם הסלוגן, "כולם צריכים לענות על הצרכים שלהם באותו אופן", ושחררה את מפרט ה-Enterprise Java Bean (EJB) ב-1997. זה איפשר לאחד את תהליך הפיתוח ולקחת את הפתרון לבעיות טיפוסיות (מתוארות לעיל כצרכים) למסגרת. Sun התאימה את פרי מוחו של IBM כבר שנתיים, ובשנת 1999 פרסמה את מפרט ה-EJB 1.0. כך נולדה הטכנולוגיה, עליה נדון בהמשך ברוח יישומית יותר.

מה זה EJB

EJB במובן מסוים הוא מונח קולקטיבי, שבהתאם להקשר, יכול להיות או לטכנולוגיית Enterprise JavaBeans עצמה באופן כללי, או לרכיב תוכנה ספציפי Enterprise JavaBean (שעועית) שהוא חלק מטכנולוגיית EJB. ההגדרה של EJB כטכנולוגיה ניתנת בוויקיפדיה: Enterprise JavaBeans (המשמש לעתים קרובות גם כקיצור EJB) הוא מפרט של טכנולוגיה לכתיבה ותמיכה ברכיבי שרת המכילים לוגיקה עסקית. זה חלק מ-Java EE. טכנולוגיה זו משמשת בדרך כלל כאשר ההיגיון העסקי דורש לפחות אחד מהשירותים הבאים, ולרוב את כולם:

• תמיכה בהתמדה נתונים: הנתונים צריכים להיות בטוחים גם לאחר הפסקת התוכנית. לרוב מושגת באמצעות מסד נתונים;
• תמיכה בעסקאות מבוזרות;
• תמיכה בשינוי נתונים מקבילים ו-multithreading;
• תמיכה באירועים;
• תמיכה בשמות וספריות (JNDI);
• אבטחה והגבלת גישה לנתונים;
• תמיכה בהתקנה אוטומטית בשרת היישומים;
• גישה מרחוק.

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

סוגי EJB

בואו נסכם. EJB הוא מחלקה רגילה של Java המסומנת באחת ההערות המיוחדות. שיעורים כאלה נקראים שעועית. תלוי באיזה ביאור מסומן הכיתה, הוא יהיה נציג של סוג כזה או אחר של EJB (שעועית). ישנם שלושה סוגים עיקריים של שעועית:

• הודעות מונעות שעועית (שעועית מונעת הודעה);
• Entity Beans - מוגדר במפרט JPA (Java Persistence API) ומשמש לאחסון נתונים;
• שעועית מושב.

האחרון (שעועית סשן) מחולקים למספר תת-סוגים:

• חסר מדינה (ללא מדינה);
• stateful (עם תמיכה במצב ההפעלה הנוכחי);
• singleton (אובייקט אחד לכל האפליקציה; החל מ-EJB 3.1).

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

שעועית מושב

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

• מקומית, על ידי כיתה אחרת באותו JVM כמו שעועית הפגישה;
• מרחוק, דרך הרשת, מ-JVM אחר, באמצעות טכנולוגיית Java RMI (Remote Method Invocation).

המילה "סשן" מרמזת שהשעועית זמינה רק בזמן שהשרת מבצע משימה מסוימת ונהרסת באופן בלתי הפיך במקרה של כשל או כיבוי של השרת. מחזור החיים של מופע שעועית הפעלה נשלט על ידי מיכל EJB (תוכל לקרוא עוד על מיכלי EJB בהרצאה הראשונה של הסדרה ). שעועית סשן חסרת מדינה אינה אוגרת מידע על מצבם. סוג זה של רכיב יכול לשמש לקוחות שונים. שעועית חסרת מדינה משמשת ליישם תהליכים עסקיים שניתן להשלים בפעולה אחת. לדוגמה, בדיקת היסטוריית האשראי של הלקוחות. מכיוון שניתן להשתמש במופע שעועית בודד על ידי לקוחות מרובים, המפתח חייב לספק גישה בטוחה לחוט לנתוני השעועית. יצירת שעועית מסוג זה (כמו גם כל שאר השעועית) היא די פשוטה. זהו מחלקת Java רגילה עם הערה @Stateless. בוא ניתן דוגמה להלן:

import javax.ejb.Stateless;

@Stateless
public class StatelessEjbExample {
    public String sayHi() {
        return "Hi, I'm Stateless EJB!";
    }
}

Session beans התומכים במצב ההפעלה הנוכחי (Stateful) שומרים מידע על מצבם בין שיחות אליו מאותו לקוח ומפסיקים את קיומם על פי בקשה מפורשת מהלקוח. זה מושג הודות לעובדה שהשעועית הממלכתית היא ייחודית לכל לקוח. דוגמה למשימה שסוג זה של שעועית יכול להיות אחראי עליה היא שמירת עגלת הקניות בחנות מקוונת מעודכנת עבור כל משתמש. מחזור החיים של שעועית אלו מנוהל על ידי מיכל EJB. שעועית אלה נהרסת גם כאשר הלקוח יוצא. שעועית כזו גם די קלה ליצירה. זוהי מחלקת Java המסומנת עם ההערה Stateful. דוגמה למטה:

import javax.ejb.Stateful;

@Stateful
public class StatefulEjbExample {
    public String sayHi() {
        return "Hi, I,m Stateful EJB";
    }
}

שעועית Singleton session מופעלת פעם אחת במהלך חיי היישום וקיימת לכל חיי היישום. שעועית כזו מיועדת למצבים שבהם יש לחלוק מדינה אחת בין כל הלקוחות. כמו שעועית חסרת מדינה, בשעועית עצמאית המפתח צריך לוודא שהסביבה בתוך השעועית מאורגנת בצורה בטוחה לחוטים. בוא ניתן דוגמה של שעועית סינגלטון, שקל ליצור אותה כמו מקבילותיה, שנדונו לעיל. קל לנחש שזו מחלקת Java עם ההערה @Singleton. עם זאת, במקרה זה אתה צריך להיות זהיר. ישנן שתי הערות, זהות בתחביר, אך שונות בתכלית וממוקמות בחבילות שונות:

• javax.ejb.Singleton
• javax.inject.Singleton

כדי ליצור EJB, עליך להשתמש בהערה מה- javax.ejb. דוגמה למטה:

import javax.ejb.Singleton;

@Singleton
public class SingletonEjbExample {
    public String sayHi() {
        return "Hi, I'm Singleton EJB!";
    }
}

הודעות מונעות שעועית

שעועית מונעת מסרים, או MDBs, או שעועית מונעת מסרים, כמו שעועית הפעלה, מיישמים היגיון עסקי מסוים. אבל בניגוד לקרובים שלה, ל-MDB יש הבדל אחד חשוב. לקוחות אף פעם לא מתקשרים ישירות לשיטות MDB. שעועית כזו משמשת לרוב כמאזינים להודעות JMS (Java Message Service) ומשמשת לארגון חילופי הודעות אסינכרוניים בין חלקי המערכת. דוגמה להודעה כזו תהיה בקשה למשלוח מלאי ממערכת קמעונאית אוטומטית למערכת ניהול אספקה. להלן דוגמה של שעועית MDB. שלא כמו שעועית סשן, היצירה שלו קצת יותר מעניינת:

import javax.annotation.Resource;
import javax.ejb.MessageDriven;
import javax.ejb.MessageDrivenContext;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageListener;
import javax.jms.TextMessage;

@MessageDriven(mappedName = "jms/TestQueue")
public class MessageDrivenEjbExample implements MessageListener {

    @Resource
    private MessageDrivenContext messageDrivenContext;

    public void onMessage(Message message) {
        try {
            if (message instanceof TextMessage) {
                TextMessage msg = (TextMessage) message;
                msg.getText();
            }
        } catch (JMSException e) {
            messageDrivenContext.setRollbackOnly();
        }
    }

}

ההערה MessageDrivenהופכת את שיעור ה-MDB שלנו לשעועית. בתוך ההערה, באמצעות JNDI (קראו כאן על JNDI ), נקבע שם הפצת ה-JMS, אליה הופכת הכיתה שלנו למאזינה. בנוסף, הכיתה שלנו מיישמת את הממשק MessageListenerואת השיטה שלו onMessage. שיטה זו תיקרא כאשר הודעה כלשהי תגיע מהתור/הפצה עם השם המוגדר בתוך ההערה MessageDriven.

שעועית ישות

חלק מטכנולוגיית EJB הוא מפרט JPA. JPA, או Java Persistence API, הוא מפרט המספק מיפוי יחסי אובייקט (ORM) של אובייקטי Java (שעועית Entity) ומספק API לאחסון, אחזור וניהול אובייקטים כאלה. JPA מאפשר לך לייצג נתונים ממסד נתונים כאובייקטי Java, כמו גם לשמור אובייקטי Java כרשומות במסד הנתונים. לא כל מחלקה יכולה לפעול כאובייקט כזה, אלא שעועית Entity. Entity Bean היא מחלקת Java המייצגת טבלה במסד נתונים. תצוגה (מיפוי) מושגת באמצעות שימוש בהערות מיוחדות. בעזרתם משווים מחלקת Java עם טבלה במסד הנתונים, כמו כן משווים השדות של מחלקת Java עם השדות של טבלת מסד נתונים. הנה דוגמה ל-Entity bean, עם הערות בקוד:

@Entity // Делает данный класс Entity бином
@Table(name = "employee") // "Связывает" данный класс с таблицей employee в БД
public class Employee implements Serializable {

    @Id // Говорит о том, что поле ниже является первичным ключом
    @GeneratedValue(strategy = GenerationType.AUTO) // Определяет тип генерации значений первичного ключа
    private int id;

    @Column(name="name") // "Связывает" поле ниже с полем name в таблице employee в БД
    private String name;

    @Column (name="age") // "Связывает" поле ниже с полем age в таблице employee в БД
    private int age;

    // getters and setters...
}

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

כתיבת בקשה: EJB HelloWorld

בחלק זה, נכתוב אפליקציית Java EE HelloWorld קטנה, אותה נפרוס על שרת GlassFish. לפני קריאת מאמר זה, מומלץ מאוד לקרוא את המאמר על הגדרת הסביבה המקומית שלך .

1. צור פרויקט חדש של Maven ב- IntelliJ IDEA.

   קובץ -> חדש -> פרויקט...

2. הקש "הבא .

3. מלא את הפרמטרים של פרויקט Maven:

4. לחץ על סיום

5. הפרויקט נוצר ויש לו את המבנה הבא:

הקובץ pom.xml נראה כך: קודם כל, עלינו להוסיף תלות ב-Java EE API, וגם לציין את האריזה של הפרויקט שלנו בצורה של ארכיון אפליקציות אינטרנט (war). כדי לעשות זאת, עליך לשנות את קוד pom.xml לטופס הבא:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.javarush.lectures</groupId>
    <artifactId>ejb_demo</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>war</packaging>

    <dependencies>
        <dependency>
            <groupId>javax</groupId>
            <artifactId>javaee-api</artifactId>
            <version>7.0</version>
        </dependency>
    </dependencies>

</project>

לאחר מכן, תוכל לעבור לקוד Java. האפליקציה שלנו תהיה הפשוטה ביותר. יהיה לנו סרבל אחד ו-1 EJB. זו תהיה שעועית סשן חסרת מדינה. בתוך ה-EJB נגדיר רק שיטה 1 שתחזיר את המחרוזת "Hello World". קודם כל, בואו ניצור חבילה com.javarush.lectures. לאחר מכן, בתוך החבילה com.javarush.lectures, ניצור את השעועית שלנו - DemoEJB. קוד השעועית ניתן להלן:

import javax.ejb.Stateless;

@Stateless
public class DemoEJB {
    public String helloWorld() {
        return "Hello world!";
    }
}

כפי שנאמר קודם, הכל די פשוט. הצעד הבא שלנו הוא ליצור servlet שיעביר את הערך מה-EJB כתגובה לבקשת HTTP. ראוי לציין שסרבלטים הם לא הנושא של מאמר זה, אבל עדיין תצטרך להשתמש בהם כדי להדגים EJB. לשם כך, בואו ניצור servlet חדש DemoServletבאותה חבילה כמו ה-EJB. הקוד שלו למטה:

@WebServlet("/helloWorld")
public class DemoServlet extends HttpServlet {

    @EJB
    private DemoEJB ejb;

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.getWriter().write(ejb.helloWorld());
    }
}

הנה כמה הערות קצרות על הקוד. Abstract @WebServlet("/helloWorld")- מגדיר את המחלקה שלנו בתור servlet שיעבד בקשות HTTP לנקודת הקצה /helloWorld. לכיתה שלנו יש תחום אחד - DemoEJB ejb. זו השעועית שלנו שהוגדרה קודם לכן. הערה מעל שדה מחלקה - @EJBמבצעת הזרקת תלות (DI). הָהֵן. משתנה ejb מאותחל אוטומטית עם מופע חדש בעת הצורך. הכיתה שלנו היא צאצא של HttpServlet ודובר על אחת משיטות הסופר-class - doGet. שיטה זו מעבדת בקשות HTTP GET ולוקחת שני פרמטרים - HttpServletRequestו- HttpServletResponse. HttpServletRequestמשמש להשגת מידע על בקשת HTTP נכנסת. HttpServletResponseהדרוש ליצירת תגובה לבקשה. בתוך השיטה, אנו מקבלים את האובייקט PrintWriterמאובייקט התגובה ( HttpServletResponse), באמצעות ה- getWriter(). לאחר מכן, נוכל לכתוב ערך כלשהו לאובייקט המתקבל באמצעות ה- write. וזה, למעשה, מה שאנחנו משתמשים בו על ידי כתיבת PrintWriterלאובייקט -a את הערך שהתקבל מה-EJB שהגדרנו (הערך הוא המחרוזת "Hello World!"). הלקוח ששלח את בקשת ה-HTTP יקבל ערך זה כתגובה לבקשתו. השלב הבא הוא להפעיל את האפליקציה בשרת GlassFish Java EE. לשם כך, ניצור תצורה חדשה, כפי שמתואר במאמר על הגדרת הסביבה המקומית . להלן צילום מסך של התצורה המוגמרת עבור הפרויקט הנוכחי. ודא שמותקן אצלך את שרת GlassFish לפני שתתחיל: לאחר יצירת תצורת ההשקה, הפעל את היישום באמצעות התפריט Run -> Run 'ejb_demo' או באמצעות מקשי הקיצור Shift+F10 . לאחר ההשקה, ניתן לראות את היומנים שלו: וגם את הדפדפן שנפתח: כל זה מעיד שהאפליקציה פועלת כמתוכנן.

סיכום

במאמר זה הכרנו עם EJB - Enterprise JavaBeans. שקלנו שאלות כמו:

• מה זה EJB?
• היסטוריה של EJB
• סוגים שונים של EJBs

זכור כי EJBs מגיעים בסוגים הבאים:

• הודעות מונעות שעועית (שעועית מונעת הודעה);
• Entity Beans - מוגדר במפרט הישויות JPA (Java Persistence API) ומשמש לאחסון נתונים;
• שעועית הפעלה:
  • חסר מדינה (ללא מדינה)
  • מצבי (עם תמיכה במצב ההפעלה הנוכחי)
  • יחיד (אובייקט אחד לכל האפליקציה; החל מ-EJB 3.1)

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