Relación unidireccional en Entity-Bean (JPA)

Question

¿Cómo hacer una relación unidireccional en EJB 3.0 Entity-Beans (JPA)?

Por ejemplo, el cliente conoce el pedido pero el pedido no tiene ningún método para el cliente. usando (@OneToMany o @OneToOne o @ManyToMany)

Saludos

Answer 1

te mostramos cómo hacer una @OneToMany relación unidireccional usando JPA 2.0 Aquí:

@Entity 
public class Customer { 
    @Id 
    @Column(name="cust_id") 
    private long id; 
    ... 
    @OneToMany 
    @JoinColumn(name="owner_id", referencedColumnName="cust_id") 
    private List<Order> order; 
    ... 
} 

@Entity 
public class Order { 
    @Id 
    @Column(name="order_id") 
    private long id; 
    ... 
} 

base de datos relacional:

Cliente:

+---------+---------+------+-----+---------+-------+ 
| Field | Type | Null | Key | Default | Extra | 
+---------+---------+------+-----+---------+-------+ 
| cust_id | int(11) | NO | PRI | NULL |  | 
+---------+---------+------+-----+---------+-------+ 

Orden:

+----------+---------+------+-----+---------+-------+ 
| Field | Type | Null | Key | Default | Extra | 
+----------+---------+------+-----+---------+-------+ 
| order_id | int(11) | NO | PRI | NULL |  | 
| owner_id | int(11) | NO | MUL | NULL |  | 
+----------+---------+------+-----+---------+-------+ 

Answer 2

saliente "unidireccional" lado por el momento, se podría modelar una relación cliente-Orden de la siguiente manera.

@Entity 
public class Customer { 
    // ... 
    @Id @GeneratedValue 
    int id; 
    @OneToMany(cascade = CascadeType.ALL, mappedBy = "customer") 
    Set<Order> orders; 
    // ... 
} 

@Entity 
public class Order { 
    // ... 
    @ManyToOne(optional = false) 
    Customer customer; 
    // ... 
} 

Aquí supongo que cada pedido tiene exactamente un cliente. En la base de datos, la tabla de pedidos tendría una columna "customer_id" con una clave externa a la columna "id" de la tabla Customer. El DDL se parecería a lo siguiente.

CREATE TABLE Customer (
    id INT NOT NULL, 
    ... 
    PRIMARY KEY (id) 
); 

CREATE TABLE Order (
    ... 
    customer_id INT NOT NULL, 
    ... 
    FOREIGN KEY (customer_id) REFERENCES Customer (id) 
); 

Aunque la clase Cliente contiene una colección de pedidos, esto en realidad no afecta la estructura de la base de datos de ninguna manera; es solo una forma conveniente de recuperar/administrar pedidos que pertenecen al cliente. Por ejemplo, puede eliminar el miembro de "pedidos" del cliente y confiar en las consultas para recuperar estos registros.

El punto que estoy tratando de hacer es que, desde la perspectiva de la base de datos , realmente no existe una relación "unidireccional". El ejemplo reverendgreen proporcionado producirá clases Java donde no hay directa forma de obtener un objeto Cliente de un objeto Orden, pero la estructura resultante de la base de datos será idéntica (ignorando las diferencias menores en los nombres de las columnas). Siempre puede encontrar al cliente para un pedido determinado mediante una consulta.