הטמעת מטמון שכבה שנייה של Hibernate עם NCache

בהדרכה זו, נחקור את ההגדרה של מאגר ההקצאה השני בHibernate בעזרת NCache.

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

בסיסים

לפני שאנחנו נעבור ליישום, בואו נבין את הבסיסים של Hibernate, NCache והמאגר ההקצאה השני של Hibernate.

Hibernate

Hibernate הוא פרטי פתוח למיפוי מערכת-עיצוב (ORM) עבור יישומי Java. הוא מפשט את הפיתוח של אינטראקציות בסיס נתונים על ידי התאמת אובייקטים Java לטבלות בסיס נתונים ובהפך.

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

1. אחסון רמה ראשונה

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

האחסון רמה ראשונה מוגבל לקנה המידה של ההפגנה ואינו משותף להפגנות אחרות.

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

2. אחסון רמה שניה

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

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

NCache

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

NCache תומך בטופולוגיות מטמון שונות כמו שכפול, מחולק ומטמון לקוח.

אפשר להשתמש ב-NCache כמטמון של הרמה השנייה ב-Hibernate כדי לאחסן ולשחזר אובייקטים מהמטמון במקום לפנות למסד הנתונים.

קוד הגדרה

נתחיל ביצירת יישום Java ובהגדרת Hibernate כדי לתקשר עם מסד הנתונים.

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

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

תלות

נתחיל על ידי הוספת התלות הנדרשות עבור Hibernate ו-NCache בקובץ pom.xml:

<dependencies>
    <!-- Hibernate dependencies -->
    <dependency>
        <groupId>org.hibernate</groupId>
        <artifactId>hibernate-core</artifactId>
        <version>6.6.1.Final</version>
    </dependency>
    <!-- NCache dependencies -->
    <dependency>
        <groupId>com.alachisoft.ncache</groupId>
        <artifactId>ncache-hibernate</artifactId>
        <version>5.3.3</version>     </dependency>
</dependencies>

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

קלאס Entity

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

@Entity
@Cacheable
@org.hibernate.annotations.Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE, region = "CustomerRegion")
public class Customer {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    // getters and setters
}

הקלאס Customer מסומן באנוטציות @Entity ו-@Cacheable כדי להגדיר אותו כישות המשמשת למטמון. יש לשדה id אנוטציות @Id ו-@GeneratedValue כדי ליצור מזהה ייחודי באופן אוטומטי.

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

NONSTRICT_READ_WRITE מודיע ל-Hibernate לעדכן את המטמון כאשר הנתונים נקראים או נכתבים עם עדיין ותיקון.

המאפיין region מציין את אזור המטמון שבו הנתונים יאוחסנו.

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

תצורת Hibernate

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

ניצור קובץ hibernate.cfg.xml בתיקיית src/main/resources עם התצורה הבאה:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <session-factory>
        <property name="hibernate.connection.driver_class">oracle.jdbc.driver.OracleDriver</property>
        <property name="hibernate.connection.url">jdbc:oracle:thin:@localhost:1521:xe</property>
        <property name="hibernate.connection.username">root</property>
        <property name="hibernate.connection.password">password</property>
        <property name="hibernate.dialect">org.hibernate.dialect.Oracle12cDialect</property>
        <property name="hibernate.hbm2ddl.auto">update</property>
        <property name="hibernate.show_sql">true</property>
    </session-factory>
</hibernate-configuration>

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

קלאס Client

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

public class HibernateClient {
    public static void main(String[] args) {
        SessionFactory sessionFactory = new Configuration().configure().buildSessionFactory();
        Session session = sessionFactory.openSession();
        Transaction transaction = session.beginTransaction();

        Customer customer = new Customer();
        customer.setName("John Doe");

        session.save(customer);
        transaction.commit();
        session.close();

        session = sessionFactory.openSession();
        transaction = session.beginTransaction();

        Customer retrievedCustomer = session.get(Customer.class, customer.getId());
        System.out.println("Retrieved Customer: " + retrievedCustomer.getName());

        transaction.commit();
        session.close();

        session = sessionFactory.openSession();
        transaction = session.beginTransaction();

        retrievedCustomer = session.get(Customer.class, customer.getId());
        System.out.println("Retrieved Customer: " + retrievedCustomer.getName());

        transaction.commit();
        session.close();
    }
}

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

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

נשים לב שמסד הנתונים נקרא פעמיים כדי לשלוף את אותו אובייקט:

כפי שניתן לראות, שאילתת ה-Hibernate מופעלת פעמיים.

הגדרת השרת של NCache

כדי להשתמש ב-NCache כמטמון מדור שני ב-Hibernate, עלינו להגדיר שרת NCache ולהגדיר אותו כדי לאחסן את הנתונים המטמונים.

NCache מספק פתרון למטמון מחולק שניתן להתקין בשרתי Windows ו-Linux. אנחנו נצור אשף מטמון באמצעות NCache ונגדיר אותו. לאחר שאשף המטמון מוגדר, נוכל להתחבר אליו מיישום ה-Java שלנו.

הפעלת NCache כמטמון מדור שני ב-Hibernate

לאחר הגדרת שרת ה-NCache, נוכל להגדיר את Hibernate כך שישתמש ב-NCache כספק המטמון מדור שני. נעדכן את קובץ התצורה של Hibernate ונציין את הגדרות המטמון כדי להפעיל את המטמון.

הפעלת אזורי מטמון

בואו נעדכן את הגדרות התא בקוד בקובץ hibernate.cfg.xml כדי לאפשר את ה-NCache כספק התא השני ברמה:

<hibernate-configuration>
    <session-factory>
        <property name="hibernate.cache.use_second_level_cache">true</property>
        <property name="hibernate.cache.region.factory_class">com.alachisoft.ncache.NCacheRegionFactory</property>
        ...
    </session-factory>
</hibernate-configuration>

כאן, אנחנו מגדירים את המוצעת hibernate.cache.use_second_level_cache ל true כדי להפעיל את התא השני ברמה. אנחנו גם מספקים את המוצעת hibernate.cache.region.factory_class כדי להשתמש ב NCacheRegionFactory, המימוש של JCacheRegionFactory, כספק התא.

הגדרת תכונות NCache

NCache מספק מערך של תכונות עבור הגדרת הגדרות התא ב Hibernate. אנחנו יכולים לספק אותם בקובץ ncache-hibernate.xml:

<configuration>
    <application-config application-id="myapp" enable-cache-exception="true" default-region-name="DefaultRegion"
                        key-case-sensitivity="false">
        <cache-regions>
            <region name="CustomerRegion" cache-name="demoCache" priority="AboveNormal" expiration-type="Sliding"
                    expiration-period="8"/>
            <region name="DefaultRegion" cache-name="demoCache" priority="default" expiration-type="None" expiration-period="0"/>
        </cache-regions>
        <database-dependencies>
            <dependency entity-name="hibernator.BLL.Customer" type="oledb"
                        sql-statement="SELECT CustomerID FROM Customers WHERE CustomerID ='?';"
                        cache-key-format="Customers#[pk]"
                        connection-string="Provider=SQLOLEDB;Data Source=20.200.20.40,1433;Initial Catalog=Northwind;User ID=john;Password=1234;"/>
        </database-dependencies>
    </application-config>
</configuration>

בקובץ הגדרות הזה, אנחנו מגדירים את אזור התא CustomerRegion עם שמו התא, סדר העדיפויות, סוג ההתפשטות ותוך זמן ההתפשטות. אנחנו מגדירים את expiration-type ל Sliding עם תוך זמן ההתפשטות של 8 שניות. זה אומר שמידע המאגר ייעלם לאחר 8 שניות של ביטיחות חסרה וייהרסה מהמאגר.

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

הקישור באזורי התא הרבים מאפשר לנו להגדיר את הגדרות התא השונות ליצוגים שונים בהתאמה לדרישותם.

בהמשך, אנחנו מגדירים תלוית במסדר הגלובלים עבור האנtity Customers. זה משמש לשמירת הקישור עם המסדר הגלובלים ולעדכון/להסירה מהקישור של הנתונים בהתאמה לשינויים במסדר הגלובלים.

אנחנו מספקים את הביטוי הSQL עבור הבאת את הCustomerID מהטבלה Customers וקישור החיבור למסדר הגלובלים.

פורמט המפתח של הקישור מספר איך המפתח מיוצר על פי מפתח העיקרי של האנtity.

בדיקה

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

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

הרווחים של השימוש בNCache עם Hibernate

השימוש בNCache כקישור משנה בHibernate מעניק סברבר התועלות:

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

סיכום

במדריך זה, ניהלנו מבט על הגדלת מאגר רמה שנייה בHibernate בעזרת NCache עבור יישומים Java.

התחלנו על הבניית הבסיסים

על ידי שימוש בNCache עם Hibernate, מפתחים יכולים להתגבר על הביצועים, הסקالיביות והאמינות של היישומים שלהם על ידי ניצול את הכח של האחסון המבוזר. NCache מעניק פתרון אחסון חזק שמשתלם בהיבט של מושלמות עם Hibernate ועם מערכות ג 'אבה אחרות בעלות בשימוש בהן, וזה מהווה את הבחירה המושלמת עבור אחסון מידע ביישומים Java.