Lernprogramm zum EntityManager: Entitätsbeziehungen erstellen

Erstellen Sie eine einfache Beziehung zwischen Entitäten, indem Sie zwei Entitätsklassen mit einer Beziehung erstellen, die Entitäten beim ObjectGrid registrieren und die Entitätsinstanzen im Cache speichern.

Vorgehensweise

  1. Erstellen Sie die Entität customer, die zum Speichern von Kundendetails, unabhängig vom Order-Objekt, verwendet wird. Es folgt ein Beispiel für die Entität customer:
    Customer.java
    @Entity
    public class Customer
    {
        @Id String id;
        String firstName;
        String surname;
        String address;
        String phoneNumber;
    }
    Diese Klasse enthält Informationen zum Kunden, wie z. B. den Namen, die Adresse und die Telefonnummer.
  2. Erstellen Sie das Order-Objekt, das dem Order-Objekt im Abschnitt Lernprogramm zum EntityManager: Entitätsklasse erstellen gleicht. Es folgt ein Beispiel für das Order-Objekt:
    Order.java
    
    @Entity
    public class Order
    {
        @Id String orderNumber;
        Date date;
        @ManyToOne(cascade=CascadeType.PERSIST) Customer customer;
        String itemName;
        int quantity;
        double price;
    }
    In diesem Beispiel ersetzt eine Referenz auf ein Customer-Objekt das Attribut "customerName". Die Referenz hat eine Annotation, die eine Viele-zu-eins-Beziehung anzeigt. Eine Viele-zu-eins-Beziehung zeigt an, dass jeder Auftrag genau einen Kunden hat, aber mehrere Aufträge auf denselben Kunden verweisen können. Der Annotationsmodifikator "cascade" zeigt an, dass bei der persistenten Definition des Order-Objekts durch den EntityManager auch das Customer-Objekt als persistent definiert werden muss. Wenn Sie die Option "cascade persist" (die Standardoption) nicht setzen, müssen Sie das Customer-Objekt mit dem Order-Objekt manuell als persistent definieren.
  3. Definieren Sie mit den Entitäten die Maps für die ObjectGrid-Instanz. Jede Map wird für eine bestimmte Entität definiert, und eine Entität erhält den Namen "Order" und die andere den Namen "Customer". Die folgende Beispielanwendung veranschaulicht, wie ein Kundenauftrag gespeichert und abgerufen wird:
    Application.java
    
    public class Application
    {
        static public void main(String [] args)
            throws Exception
        {
            ObjectGrid og = 
    					ObjectGridManagerFactory.getObjectGridManager().createObjectGrid();
            og.registerEntities(new Class[] {Order.class});
    
            Session s = og.getSession();
            EntityManager em = s.getEntityManager();
    
            em.getTransaction().begin();
    
            Customer cust = new Customer();
            cust.address = "Main Street";
            cust.firstName = "John";
            cust.surname = "Smith";
            cust.id = "C001";
            cust.phoneNumber = "5555551212";
    
            Order o = new Order();
            o.customer = cust;
            o.date = new java.util.Date();
            o.itemName = "Widget";
            o.orderNumber = "1";
            o.price = 99.99;
            o.quantity = 1;
    
            em.persist(o);
            em.getTransaction().commit();
            em.getTransaction().begin();
            o = (Order)em.find(Order.class, "1");
            System.out.println("Found order for customer: " 
    					+ o.customer.firstName + " " + o.customer.surname);
            em.getTransaction().commit();	// Close the session (optional in Version 7.1.1 and later) for improved performance
    	s.close();
        }
    }
    Diese Anwendung gleicht der Beispielanwendung im vorherigen Schritt. Im vorherigen Beispiel wird nur eine einzige Klasse "Order" registriert. WebSphere eXtreme Scale erkennt und schließt die Referenz auf die Entität "Customer" automatisch ein. Es wird eine Customer-Instanz für John Smith erstellt und vom neuen Order-Objekt referenziert. Daraufhin wird der neue Kunde automatisch als persistent definiert, weil die Beziehung zwischen zwei Aufträgen den Modifikator "cascade" enthält, der erfordert, dass jedes Objekt als persistent definiert wird. Wenn das Order-Objekt gefunden wird, sucht der EntityManager automatisch das zugehörige Customer-Objekt und fügt eine Referenz auf das Objekt ein.