The following is the code for the Customer class, Customer.java :

package ejb30.entity;
import java.io.Serializable;
import java.util.Collection;
import javax.persistence.*;
@Entity
public class Customer implements Serializable {
private int id;
private String firstName;
private String lastName;
private Referee referee;
private Collection<Address> addresses;
private Collection<Account> accounts;
public Customer() {}
@Id
public int getId() { return id; }
public void setId(int id) { this.id = id; }
public String getFirstName() { return firstName; }
public void setFirstName(String firstName) {
this.firstName = firstName;
}
public String getLastName() { return lastName; }
public void setLastName(String lastName) {
this.lastName = lastName;
}
@OneToOne
public Referee getReferee() { return referee; }
public void setReferee(Referee referee) {
this.referee = referee;
}
@OneToMany
public Collection<Account> getAccounts() {
return accounts;
}
public void setAccounts(Collection<Account> accounts) {
this.accounts = accounts;
}
@ManyToMany
public Collection<Address> getAddresses() {
return addresses;
}
public void setAddresses(Collection<Address> addresses) {
this.addresses = addresses;
}
public String toString() {
return "[Customer Id =" + id + ",first name=" +
firstName + ",last name=" + lastName +
", referee=" + referee + ",addresses=" +
addresses + ",accounts=" + accounts + "]";
}
}

The @Entity annotation, as we have seen, indicates that this entity is to be mapped onto a database by the EntityManager. We have not used a @Table annotation. The default table name that is generated is the entity name in upper case, namely CUSTOMER. The @Id annotation indicates that the following field is the primary key. We have not used the @Column annotation with the id field, so the default is the field name in upper case, namely ID. Recall from Chapter 3 that Java primitive types are mapped onto relational database column types according to JDBC to SQL mapping rules. These resulting SQL types will depend on the database. In the case of the Derby database embedded with GlassFish, fields of type int are mapped to a database type of INTEGER. A primary key cannot have NULL values so the id field is mapped to:

ID INTEGER NOT NULL, PRIMARY KEY (ID)

The firstName property is a String type for which the default Derby mapping is VARCHAR(255).

The @OneToOne annotation indicates there is a one-to-one mapping between the Customer and Referee entities. In this case the CUSTOMER table will contain a foreign key to the REFEREE table. The default name for the foreign key column is a concatenation of the following 3 items:

In this example the resulting foreign key column name is REFEREE_ID. The type of REFEREE_ID is the same as the primary key column of the referenced REFEREE table, namely INTEGER. If we want to override these defaults we need to use the @JoinColumn annotation, which we will cover later in this chapter. To summarize, the default CUSTOMER table will be:

The @OneToMany annotation indicates that there is a one-to-many relationship between the Customer entity, the owner entity, and the Account entity, the inverse or owned entity. The default behavior is to map onto a join table named CUSTOMER_ACCOUNT (owner table name + underscore + inverse table name). The join table consists of two foreign key columns, Customer_ID and accounts_ID. The first foreign key is the concatenation of the following:

The type of this foreign key column is the same as the type of the CUSTOMER table primary key column, namely INTEGER. The second foreign key column is the concatenation of the following:

The type of this foreign key column is the same as the type of ACCOUNT table primary key column, namely INTEGER. To summarize the resulting default join table will be:

Later in this chapter we will show how to override these defaults with the @JoinTable annotation.

The @ManyToMany annotation indicates there is a many-to-many relationship between the Customer and the Address entity. Recall this is a unidirectional relationship where Customer references Address, but Address does not reference Customer. In such cases Customer is regarded as the owning entity and Address the owned or inverse entity. The default behavior is to map onto a join table named CUSTOMER_ADDRESS (owner table name + underscore + inverse table name). The join table consists of two foreign key columns, Customer_ID and addresses_ID. The procedure for naming these columns is the same as the unidirectional one-to-many case described above. The resulting default join table will be:

Finally the Customer class contains an overridden toString() method which is used when printing out the values of the Customer object from a client application.

Because our model is unidirectional and the only references between entities are those from Customer, no relationship annotations are required for the remaining classes.

The code for the Account class, Account.java is listed below:

package ejb30.entity;
import java.io.Serializable;
import javax.persistence.*;
@Entity
public class Account implements Serializable {
private int id;
private double balance;
private String accountType;
public Account() {}
@Id
public int getId() { return id; }
public void setId(int id) { this.id = id; }
public double getBalance() { return balance; }
public void setBalance(double balance) {
this.balance = balance;
}
public String getAccountType() { return accountType; }
public void setAccountType(String accountType) {
this.accountType = accountType;
}
public String toString() {
return "[account id =" + id + ",balance=" +
balance + ",account type=" + accountType + "]";
}
}

The only item to note is the default mapping of the balance field. The database type to which a field is mapped depends on the underlying database. In the case of the GlassFish embedded Derby database, a field of type double is mapped to a FLOAT database type. The default table that the Account entity is mapped to is:

The code for Address class, Address.java is listed below:

package ejb30.entity;
import java.io.Serializable;
import javax.persistence.*;
@Entity
public class Address implements Serializable {
private int id;
private String addressLine;
private String country;
private String postCode;
public Address() {}
@Id
public int getId() { return id; }
public void setId(int id) { this.id = id; }
public String getAddressLine() { return addressLine; }
public void setAddressLine(String addressLine) {
this.addressLine = addressLine;
}
public String getCountry() { return country; }
public void setCountry(String country) {
this.country = country;
}
public String getPostCode() { return postCode; }
public void setPostCode(String postCode) {
this.postCode = postCode;
}
public String toString() {
return "[address id=" + id + ",address=" +
addressLine + ",country=" +country +
",post code=" + postCode +"]";
}
}

The default mapping rules that we have already described apply here, and the resulting default mapped table is:

The code for the Referee class, Referee.java is listed below:

package ejb30.entity;
import java.io.Serializable;
import javax.persistence.*;
@Entity
public class Referee implements Serializable {
private int id;
private String name;
private String comments;
public Referee() {}
@Id
public int getId() { return id; }
public void setId(int id) { this.id = id; }
public String getName() { return name; }
public void setName(String name) { this.name = name; }
public String getComments() { return comments; }
public void setComments(String comments) {
this.comments = comments;
}
public String toString() {
return "[referee id=" + id + ",name=" + name +
",comments=" + comments + "]";
}
}

No new mapping rules apply here, and the default mapped table is: