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.
Customer.java
@Entity
public class Customer
{
@Id String id;
String firstName;
String surname;
String address;
String phoneNumber;
}
Item.java
@Entity
public class Item
{
@Id String id;
String description;
long quantityOnHand;
double price;
}
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;
}
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.
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.