Middleware Technology (J2EE/EJB) Entity Bean (JBoss EJB 3.0 tutorial)

Middleware Technology (J2EE/EJB)Entity Bean

(JBoss EJB 3.0 tutorial)

2

Entity Beans

• Entity beans represent (persistent) data• Every application has data

– It is often the case that this data naturally exists as objects• e.g. In a Banking application: Account, Customer, Transaction

– Applications need a way to map these objects to their database (often an RDBMS)

• They can write code themselves (e.g. JDBC)

• They can use an Object-Relational Mapping (ORM) framework

3

Object-Relational Mapping (ORM)

• There are several ORM frameworks available for Java:– Hibernate (JBoss) – TopLink (Oracle)– ObJect-relational Bridge - OJB (Apache)– Java Data Objects – JDO (Sun)– Java Persistence (Sun) – The ORM technology used by EJB

4


• There are several ORM frameworks available for Java:– Hibernate (JBoss)

• Open source framework released by JBoss in 2001• Ported for .NET as NHibernate• Uses an object-based query language called Hibernate-QL

– TopLink (Oracle)– ObJect-relational Bridge - OJB (Apache)– Java Data Objects – JDO (Sun)– Java Persistence (Sun) – The ORM technology used by EJB

5


• There are several ORM frameworks available for Java:– Hibernate (JBoss) – TopLink (Oracle)

• TopLink was released by The Object People (TOP) in 1994 for SmallTalk

• TopLink was re-released in 1997 for Java• Oracle acquired TopLink in 2002• TopLink uses expressions for querying

– ObJect-relational Bridge - OJB (Apache)– Java Data Objects – JDO (Sun)– Java Persistence (Sun) – The ORM technology used by EJB

6


• There are several ORM frameworks available for Java:– Hibernate (JBoss) – TopLink (Oracle)– ObJect-relational Bridge - OJB (Apache)

• OJB is an implementation of JDO provided for free by Apache

– Java Data Objects – JDO (Sun)– Java Persistence (Sun) – The ORM technology used by EJB

7


• There are several ORM frameworks available for Java:– Hibernate (JBoss)

– TopLink (Oracle)

– ObJect-relational Bridge - OJB (Apache)

– Java Data Objects – JDO (Sun)

• An ORM standard developed by Sun (released: 2002)

• Can be used in any JVM

• Use an object-based query language called JDO-QL

– Java Persistence (Sun) – The ORM technology used by EJB

8


• There are several ORM frameworks available for Java:– Hibernate (JBoss) – TopLink (Oracle)– ObJect-relational Bridge - OJB (Apache)– Java Data Objects – JDO (Sun)– Java Persistence (Sun) – The ORM technology used by EJB

• This technology grew out of the previous technologies– Thus, it is very similar in API to the other technologies discussed

• The aim is to provide a transparent framework for persisting entities (that are Plain Old Java Objects – POJOs)

• Java Persistence uses an object-based query language called EJB-QL (also called Java Persistence Query Language)

9

Object-Relational Mapping

• An application has instances of classes (entities):

public class Customer {private String firstName;private String lastName;… other fields omitted …

}

• …which need to be stored in RDBMSs:

FirstName LastName BirthDate Company Balance

Robert Smith 02/16/1956 IBM 1500.00

Susan Jones 06/07/1968 BEA 0.00

Felicia Alvarez 12/31/1977 Sun 100.00

10

Java Persistence Features

• When using Java Persistence, the container handles:– Relationships between entities

– Persistence of the entity’s data

• All this is in addition to the container’s responsibilities for all EJBs:– Transactions

– Security

11

Entity: The Bean

import javax.persistence.Entity;import javax.persistence.Id;

@Entitypublic class Customer {

@Id public int customerID; // primary keypublic String firstName;public String lastName;… other fields omitted …

}

• The @Entity annotation marks this class as an entity• The @Id annotation marks the customerID field as the primary key for the entity

(mapped directly to the database primary key)• The data will be persisted to a table with the same name, and the fields will be pe

rsisted to columns with the same name

12

Entity: The Bean (Alternative #1)

import javax.persistence.*;

@Entity@Table(name=“CustomerData”)public class Customer {

@Id@Column(name=“CustID”, primaryKey=true)public int customerID;

@Column(name=“FName”)public String firstName;

@Column(name=“LName”)public String lastName;… other fields omitted …

}

• Here, the mapped table and column names are explicitly declared• This example uses public fields for the entity’s properties

13

Entity: The Bean (Alternative #2)


@Entity@Table(name=“CustomerData”)public class Customer {

@Id@Column(name=“CustID”, primeyKey=true)public int getCustomerID() { … };public void setCustomerID(int value) { … };private int customerID;

@Column(name=“FName”)public String getFirstName() { … };public void setFirstName(String value) { … };private String firstName;

… other fields omitted …}

• Here, the entity’s properties are accessed using get/set methods– The actual fields used can now be private, preserving encapsulation

@Id表示该字段为主键

14

Entity Clients

• Entity clients, since EJB 3.0, are most often session beans– Sometimes, developers create a session façade for the entity

• This is a session bean whose sole purpose is to act as the CRUD (Create/Read/Update/Destroy) for the entity

• The core of the entity client is the EntityManager– This object can be used to acquire, search for, update, create, an

d delete entities– An EntityManager can be injected into a session façade

15

CRUDs

• Objects whose purpose is to provide the following functions on an entity:– Create – Create and persist new instances of entities– Read – Find individual entities (by primary key) and search for

groups of entities (querying)– Update – Modify entities (locally and in the persistent store)– Destroy – Delete entities (locally and in the persistent store)

• In Java EE, CRUD functions are provided by the EntityManager class

16

EntityManager: Create

• An entity is pretty much a POJO– It can, therefore, be created in the normal way– However, the entity is not persistent until the EntityManager is told to persist

the object:

@PersistenceContext EntityManager entityManager;public Customer createCustomer(String fn, String ln) {

Customer customer = new Customer();customer.setFirstName(fn);customer.setLastName(ln);// customer is not persistent hereentityManager.persist(customer);// customer is persistent herereturn customer;

}

17

EntityManager: Read #1 (Individual)

• A specific entity can be found using its primary key:

@PersistenceContext EntityManager entityManager;

public Customer getCustomer(int customerID) {

return entityManager.find(Customer.class, customerID);

}

18

EntityManager: Read #2 (Search)

• A search can be performed using a query:

@PersistenceContext EntityManager entityManager;public List<Customer> getAllCustomers() {

// this query is EJB-QL, which is similar to SQLString queryString = “select c from Customer c”;Query query = entityManager.createQuery(queryString);return query.getResultList();

}

19


• Queries can also take parameters:

@PersistenceContext EntityManager entityManager;public List<Customer> getCustomersWithLastName(String la

stName) {// this query is EJB-QL, which is similar to SQLString queryString = “select c from Customer c where c.lastName = :lastName”;Query query = entityManager.createQuery(queryString);query.setParameter(“lastName”, lastName);return query.getResultList();

}

20


• The EJB-QL is sophisticated, and has many features of SQL (e.g. group by/having):

@PersistenceContext EntityManager entityManager;public List<Customer> getCustomersByNameKeyword(String keyword) {

// this query is EJB-QL, which is similar to SQLString queryString = “select c from Customer c where c.lastName like :keyword1 or c.firstName like :keyword2”;Query query = entityManager.createQuery(queryString);query.setParameter(“keyword1”, keyword);query.setParameter(“keyword2”, keyword);return query.getResultList();

}

21

EntityManager: Read #5 (Entity)

• A developer can also create named queries in the EJB itself:


@Entity@Table(name=“CustomerData”)@NamedQueries({@NamedQuery(name="FindByCity",

queryString=" select c from Customer c where c.city = ?1")}) public class Customer {

@Id@Column(name=“CustID”, primeyKey=true)public int getCustomerID() { … };… the remainder is no different from previous versions …

22


• The named queries can be referenced from the client– Notice that no EJB-QL needs to be embedded in this client, whi

ch is good for maintenance

@PersistenceContext EntityManager entityManager;public List<Customer> getCustomersByCity(String city) {

Query query = entityManager.createNamedQuery(“FindByCity”);query.setParameter(0, city);return query.getResultList();

}

23

EntityManager: Update

• Once an entity is persisted, it becomes managed– Changes to managed entities are automatically recorded to the persistent stor

e

– Changes will no doubt be cached for efficiency, but you can flush() an entityManager to force the changes to be carried out immediately

• Usually, this is unnecessary

entityManager.flush(); // flush all updates

• The latest database data can also be retrieved into an entity, using the refresh() method:

entityManager.refresh(customer1); // update customer1

24

EntityManager: Destroy

• The EntityManager can also be used to delete an entity

@PersistenceContext EntityManager entityManager;

public void deleteCustomer(int customerID) {

Customer customer = manager.find(Customer.class, customerID);

manager.remove(customer);

}

25

Entity Beans Example

• Entity beans are not remotable and must be access through the new javax.persistence.EntityManager service. JBoss's EJB 3.0 implementation is built on top of Hibernate.

26

Order and LineItem

• two related Entity beans. Order and LineItem. These two beans form a one to many relationship and automatic table generation is used to generate the database tables.

• all getter/setter methods will be treated as persistence properties.

• Entity Bean Class definition@Entity @Table(name = "PURCHASE_ORDER") public class Order implements java.io.Serializable

persitence.xml<persistence>

<persistence-unit name="tempdb"> <jta-data-source>java:/DefaultDS</jta-data-source> <properties> <property name="hibernate.hbm2ddl.auto"

value="create-drop"/> </properties> </persistence-unit>

</persistence>

27

Order Field definition

private int id; private double total; private Collection<LineItem> lineItems;

@Id @GeneratedValue(strategy=GenerationType.AUTO) primary keypublic int getId()

@OneToMany(cascade = CascadeType.ALL, fetch = FetchType.EAGER, mappedBy="order")

public Collection<LineItem> getLineItems()

Order LineItem1 *

Note: The mappedBy attribute specifies that this is a bi-directional relationship that is managed by the order property on the LineItem entity bean.

Foreign Key

28

LineItem

private Order order;

@ManyToOne

@JoinColumn(name = “order_id”) bi-directional, foreign key

public Order getOrder() { return order; }

The @JoinColumn specifies the foreign key column within the LineItem table.

Note： LineItem (owner side) corresponds to the table with foreign key， while Order is the target side. There is a member variable (order) in class LineItem, which is related to the foreign key order_id in the table.

Code: entity

29

JBoss Console: manage entity beans

34

Entity Detachment and Reattachment Example

• @Column annotation@Column(name = "FIRST")

public String getFirst()

• Find by primary keypublic Customer find(int id) {

return manager.find(Customer.class, id); }

• Find by other fieldspublic List findByLastName(String name) {

return manager.createQuery("select c from Customer c where c.last = :name").setParameter("name", name).getResultList(); }

Code: merge

35

ManyToMany and OneToOne Relationships Example

• OneToOne – Customer vs. Address

• ManyToMany – Customer vs. Flight

36

OneToOne Customer vs. Address

class Customer (contains the foreign key field: address)

@OneToOne(cascade = {CascadeType.ALL})

@JoinColumn(name = "ADDRESS_ID")

public Address getAddress() {

return address;

}

37

ManyToMany Customer vs. Flight

• There is a many to many relationship between Customer and Flight. In order to have a many to many relationship there needs to be a distinct join table (关联表 ) that maps the many to many relationship. This is called an association table.

• So there is no join column (foreign key) on both sides (table), and we could not distinguish the owner side from the target side.

• Customer side@ManyToMany(cascade = {CascadeType.PERSIST, CascadeType.MERGE}, fetch = FetchType.EAGER, mappedBy="customers")

• Flight side@ManyToMany(cascade = {CascadeType.PERSIST, CascadeType.MERGE}, fetch = FetchType.EAGER) @JoinTable(table = @Table(name = "flight_customer_table"), joinColumns = {@JoinColumn(name = "FLIGHT_ID")}, inverseJoinColumns = {@JoinColumn(name = "CUSTOMER_ID")}) public Set<Customer> getCustomers() {

return customers; }

In the above example, Flight is selected as the owner side. In the join table (flight_customer_table, FLIGHT_ID is the foreign key.

38

Dependency Injection Example

• Field definition

@EJB private Calculator calculator;

• Set method private Calculator set; @EJB(beanName="org.jboss.tutorial.injection.bean.CalculatorBean")

public void setCalculator(Calculator c) {

set = c;

}

Note: beanName(class name), mappedName (JNDI)

39

Composite Primary Keys Example

• The EJB 3.0 specification allows you to define a primary key class as a @Embeddable and use it as the primary key of your Entity bean. One or more properties can be used as members of the primary key.

@Embeddable public class CustomerPK implements java.io.Serializable

mapping the primary key in Customer bean class@EmbeddedId

public CustomerPK getPk() { return pk;

}

40

Timer Service Example

• An EJB bean can register a timer with the EJB Timer service.

• In the EJB 2.1 specification it was required to implement an interface to get ejbTimeout callbacks.

• It is still being debated in the EJB 3.0 EG on whether an interface or annotation should be used to specify this callback.

• In JBoss EJB 3 Preview, it is implemented as an annotation. All you have to define is a method annotated with javax.ejb.Timeout. This is the same with other callbacks like @PrePassviate, @PostRemove, etc... No interface is needed to be implemented, just declare the methods as you need them.

Middleware Technology (J2EE/EJB) Entity Bean (JBoss EJB 3.0 tutorial)

Documents

Transcript of Middleware Technology (J2EE/EJB) Entity Bean (JBoss EJB 3.0 tutorial)