Tutorial do Entity Manager: Esquema da Entidade Order

Crie quatro classes de entidade utilizando relacionamentos únicos e bidirecionais, listas ordenadas e relacionamentos de chave estrangeira. As APIs do EntityManager são utilizadas para persistir e localizar as entidades. Com base nas entidades Order e Customer que estão nas partes anteriores do tutorial, esta etapa do tutorial inclui mais duas entidades: as entidades Item e OrderLine.

Sobre Esta Tarefa

Figura 1. Esquema da Entidade Order. Uma entidade Order possui uma referência para um cliente e zero ou mais OrderLines. Cada entidade OrderLine possui uma referência para um único item e inclui a quantidade solicitada.
Esquema de Entidade Order

Procedimento

  1. Crie a entidade customer, que é semelhante aos exemplos anteriores.
    Customer.java
    @Entity
    public class Customer
    {
        @Id String id;
        String firstName;
        String surname;
        String address;
        String phoneNumber;
    }
  2. Crie a entidade Item, que contém informações sobre um produto que está incluído no inventário da loja, como a descrição do produto, a quantidade e o preço.
    Item.java
    @Entity
    public class Item
    {
        @Id String id;
        String description;
        long quantityOnHand;
        double price;
    }
  3. Crie a entidade OrderLine. Cada Order possui zero ou mais OrderLines, que identificam a quantidade de cada item no pedido. A chave para a OrderLine é uma chave composta que consiste no Order que possui o OrderLine e um número inteiro que designa um número para a linha do pedido. Inclua o modificador de persistência em cascata em cada relacionamento em suas entidades.
    OrderLine.java
    @Entity
    public class OrderLine
    {
        @Id @ManyToOne(cascade=CascadeType.PERSIST) Order order;
        @Id int lineNumber;
        @OneToOne(cascade=CascadeType.PERSIST) Item item;
        int quantity;
        double price;
    }
  4. Criar o Order Object final, que possui uma referência ao Customer para a ordem e uma coleta de objetos OrderLine.
    Order.java
    @Entity
    public class Order {
        @Id String orderNumber;
        java.util.Date date;
        @ManyToOne(cascade=CascadeType.PERSIST) Customer customer;
        @OneToMany(cascade=CascadeType.ALL, mappedBy="order") 
    			@OrderBy("lineNumber") List<OrderLine> lines;  } 

    ALL em cascata é utilizado como o modificador para as linhas. Esse modificador sinaliza o EntityManager para exibir em cascata a operação PERSIST e a operação REMOVE. Por exemplo, se a entidade Order for persistida ou removida, então, todas as entidades OrderLine também são persistidas ou removidas.

    Se uma entidade OrderLine for removida da lista de linhas no objeto de Pedido, a referência então será quebrada. No entanto, a entidade OrderLine não será removida do cache. Você deve utilizar a API de remoção do EntityManager para remover entidades do cache. A operação REMOVE não é utilizada na entidade do cliente ou na entidade de item de OrderLine. Como resultado, a entidade do cliente permanece mesmo que o item ou o item seja removido quando a OrderLine for removida.

    O modificador mappedBy indica um relacionamento inverso com a entidade de destino. O modificador identifica qual atributo na entidade de destino refere-se à entidade de origem, e o lado pertencente de um relacionamento um para um ou muitos para muitos. Geralmente, é possível omitir o modificador. Entretanto, um erro é exibido para indicar que ele deve ser especificado se WebSphere eXtreme Scale não puder descobrí-lo automaticamente. Uma entidade OrderLine que contém dois tipos de atributos Order em uma relacionamento muitos para um normalmente causa o erro.

    A anotação @OrderBy especifica a ordem na qual cada entidade OrderLine deve estar na lista de linhas. Se a anotação não for especificada, então, as linhas são exibida em uma ordem arbitrária. Embora as linhas sejam incluídas na entidade Order emitindo ArrayList, o que preserva o pedido, o EntityManager não necessariamente reconhecerá a pedido. Quando você emite o método de localização para recuperar o objeto Order do cache, o objeto de lista não é um objeto ArrayList.

  5. Crie o aplicativo. O exemplo a seguir ilustra o objeto Order final, que possui uma referência para o Customer para o pedido e uma coleta de objetos OrderLine.
    1. Encontre os Itens a serem ordenados, que podem se tornar entidades Gerenciadas.
    2. Crie a OrderLine e anexe-a a cada Item.
    3. Crie o Pedido e associe-o a cada OrderLine e ao cliente.
    4. Persista o pedido, que persiste automaticamente cada OrderLine.
    5. Confirme a transação, que desconecta cada entidade e sincroniza o estado das entidades com o cache.
    6. Imprima as informações do pedido. As entidades OrderLine são armazenadas automaticamente pelo ID da OrderLine.
    Application.java
    
    static public void main(String [] args)
            throws Exception
        {
            ...
    
            // Add some items to our inventory.
            em.getTransaction().begin();
            createItems(em);
            em.getTransaction().commit();
    
            // Create a new customer with the items in his cart.
            em.getTransaction().begin();
            Customer cust = createCustomer();
            em.persist(cust);
    
            // Create a new order and add an order line for each item.
            // Each line item is automatically persisted since the 
    				// Cascade=ALL option is set.
            Order order = createOrderFromItems(em, cust, "ORDER_1", 
    					new String[]{"1", "2"}, new int[]{1,3});
            em.persist(order);
            em.getTransaction().commit();
    
            // Print the order summary
            em.getTransaction().begin();
            order = (Order)em.find(Order.class, "ORDER_1");
            System.out.println(printOrderSummary(order));
            em.getTransaction().commit();
        }
    
        public static Customer createCustomer() {
            Customer cust = new Customer();
            cust.address = "Main Street";
            cust.firstName = "John";
            cust.surname = "Smith";
            cust.id = "C001";
            cust.phoneNumber = "5555551212";
            return cust;
        }
    
        public static void createItems(EntityManager em) {
            Item item1 = new Item();
            item1.id = "1";
            item1.price = 9.99;
            item1.description = "Widget 1";
            item1.quantityOnHand = 4000;
            em.persist(item1);
    
            Item item2 = new Item();
            item2.id = "2";
            item2.price = 15.99;
            item2.description = "Widget 2";
            item2.quantityOnHand = 225;
            em.persist(item2);
    
        }
    
        public static Order createOrderFromItems(EntityManager em, 
    			Customer cust, String orderId, String[] itemIds, int[] qty) {
    
            Item[] items = getItems(em, itemIds);
    
            Order order = new Order();
            order.customer = cust;
            order.date = new java.util.Date();
            order.orderNumber = orderId;
            order.lines = new ArrayList<OrderLine>(items.length);          
    			 for(int i=0;i<items.length;i++){
    						OrderLine line = new OrderLine();
                line.lineNumber = i+1;
                line.item = items[i];
                line.price = line.item.price;
                line.quantity = qty[i];
                line.order = order;
                order.lines.add(line);
            }
            return order;
        }
    
        public static Item[] getItems(EntityManager em, String[] itemIds) {
            Item[] items = new Item[itemIds.length];
            for(int i=0;i<items.length;i++){
    			 items[i] = (Item) em.find(Item.class, itemIds[i]);
            }
            return items;
        }
    A próxima etapa é excluir uma entidade. A interface EntityManager possui um método de remoção que marca um objeto como excluído. O aplicativo deve remover a entidade de qualquer coleta de relacionamento antes de chamar o método de remoção. Edite as referências e emita o método de remoção ou em.remove(object), como uma etapa final.