openxava / documentación / Modelo

Componente de negocio

• Modelo: Estrutura de datos, validaciones, calculos, etc.
• Vista: Cómo se puede mostrar el modelo al usuario.
• Datos tabulares: Cómo se muestra los datos de este componentes en modo lista (en formato tabular).
• Mapeo objeto/relacional: Cómo grabar y leer el estado de los objetos desde la base de datos.

Entidad

@Entity // 1
@EntityValidator // 2
@RemoveValidator // 3
public class NombreEntidad { // 4
 // Propiedades // 5
 // Referencias // 6
 // Colecciones // 7
 // Métodos // 8
 // Buscadores // 9
 // Métodos de retrollamada // 10
}

1. @Entity (JPA, uno, obligado): Indica que esta clase es una entidad JPA, con otras palabras, sus instancias serán objetos persistentes.
2. @EntityValidator (OX, varios, opcional): Ejecuta una validación a nivel de modelo. Este validador puede recibir el valor de varias propiedades del modelo. Para validar una sola propiedad es preferible poner el validador a nivel de propiedad.
3. @RemoveValidator (OX, varios, opcional): Se ejecuta antes de borrar, y tiene la posibilidad de vetar el borrado del objeto.
4. Declaración de la clase: Como en un clase de Java convencional. Podemos usar extends e implements.
5. Propiedades: Propiedades de Java convencionales. Representan el estado principal del objeto.
6. Referencias: Referencias a otras entidades o clases incrustables.
7. Colecciones: Colecciones de referencias a otras entidades o clases incrustables.
8. Métodos: Métodos Java con lógica de negocio.
9. Buscadores: Los buscadores son métodos estáticos que hacen búsquedas usando las prestaciones de consulta de JPA.
10. Métodos de retrollamada: Los métodos JPA de retrollamada (callbacks) para insertar lógica al crear, modificar, cargar, borrar, etc

Clases incrustables (Embeddable)

@Embeddable // 1
public class NombreIncrustada { // 2
 // Propiedades // 3
 // Referencias // 4
 // Metodos // 5
}
 

1. @Embeddable (JPA, una, requerido): Indica que esta clase es una clase incrustada de JPA, en otras palabras, sus instancias serán parte de objetos persistente.
2. Declaración de la clase: Como una clase Java convencional. Podemos uar extends y implements.
3. Propiedades: Propiedades Java convencionales.
4. Referencias: Referencias a entidades o clases incrustables.
5. Métodos: Métodos Java con lógica de negocio.

Propiedades

@Stereotype                                                                //  1
@Column(length=) @Column(precision=) @Max @Length(max=) @Digits(integer=)  //  2
@Digits(integer=) @Digits(fraction=)                                       //  3
@Required @Min @Range(min=) @Length(min=)                                  //  4
@Id                                                                        //  5
@Hidden                                                                    //  6
@SearchKey                                                                 //  7
@Version                                                                   //  8
@Formula                                                                   //  9  Nuevo en v3.1.4
@Calculation                                                               // 10  Nuevo en v5.7
@DefaultValueCalculator                                                    // 11
@PropertyValidator                                                         // 12
private tipo nombrePropiedad;                                              // 13
public tipo getNombrePropiedad() { ... }                                   // 13
public void setNombrePropiedad(tipo nuevoValor) { ... }                    // 13

1. @Stereotype (OX, opcional): Permite especificar un comportamiento especial para cierta propiedades.
2. @Column(length=) (JPA), @Max (BV), @Length(max=) (HV), @Digits(integer=) (BV): opcional, normalmente solo se usa una): Longitud en caracteres de la propiedad, excepto para @Max que es el valor máximo. Especialmente útil a la hora de generar interfaces gráficas. Si no especificamos longitud asume un valor por defecto asociado al tipo o estereotipo que se obtiene de default-size.xml o longitud-defecto.xml. @Max y @Digits son de Bean Validation (nuevo en v4.1) o de Hibernate Validator (hasta v5.2.x).
3. @Column(scale=) (JPA), @Digits(fraction=) (BV): Escala (tamaño de la parte decimal) de la propiedad. Sólo aplica a propiedades numéricas. Si no se usa @Column o @Digits se asume un valor por defecto, si se usa @Column sin scale se asume un valor por defecto, sin embargo si se usa @Digits sin fraction se asume 0. El valor por defecto asociado al tipo o estereotipo que se obtiene de default-size.xml o longitud-defecto.xml. @Digits es de Bean Validation (new in v4.1) o de Hibernate Validator (hasta v5.2.x).
4. @Required (OX), @Min (BV), @Range(min=) (HV), @Length(min=) (HV) (opcional, normalmente solo se usa una): Indica si esa propiedad es requerida. En el caso de @Min, @Range y @Length tenemos que poner un valor mayor que cero para min para que se asuma la propiedad como requerida. Por defecto es true para las propiedades clave ocultas (nuevo en v2.1.3) y false en todos los demás casos. Al grabar OpenXava comprobará si las propiedades requeridas están presentes, si no lo están no se producirá la grabación y se devolverá una lista de errores de validación. La lógica para determinar si una propiedad está presente o no se puede configurar creando un archivo validators.xml o validadores.xml en nuestro proyecto. Podemos ver la sintaxis en OpenXava/xava/default-validators.xml. @Required y @Min son restricciones de Bean Validation desde v5.3 y eran restricciones de Hibernate Validator hasta v5.2.x.
5. @Id (JPA, opcional): Para indicar si una propiedad forma parte de la clave. Al menos una propiedad (o referencia) ha de ser clave. La combinación de propiedades (y referencias) clave se debe mapear a un conjunto de campos en la base de datos que no tengan valores repetidos, típicamente con la clave primaria.
6. @Hidden (OX, opcional): Una propiedad oculta es aquella que tiene sentido para el desarrollador pero no para el usuario. Las propiedades ocultas se excluyen cuando se generan interfaces gráficas automáticas, sin embargo a nivel de código generado están presentes y son totalmente funcionales, incluso si se les hace alusión explicita podrían aparecer en una interfaz gráfica.
7. @SearchKey (OX, optional): Las propiedades clave de búsqueda se usan por los usuarios para buscar los objetos. Son editables en la interfaz de usuario de las referencias permitiendo al usuario teclear su valor para buscar. OpenXava usa las propiedades clave (@Id) para buscar por defecto, y si la propiedades clave (@Id) están ocultas usa la primera propiedad en la vista. Con @SearchKey podemos elegir las propiedades para buscar explicitamente.
8. @Version (JPA, opcional): Una propiedad versión se usa para el control de concurrencia optimista. Si queremos control de concurrencia solo necesitamos tener una propiedad marcada como @Version en nuestra entidad. Solo podemos especificar una propiedad de versión por entidad. Los siguientes tipos son soportados para propiedades versión: int, Integer, short, Short, long, Long, Timestamp. Las propiedades de versión también se consideran ocultas.
9. @Formula (HA, opcional): (Nuevo en v3.1.4) Para calcular el valor de la propiedad usando la base de datos. Tiene que ser un fragmento válido de SQL.
10. @Calculation (OX, uno, opcional): (Nuevo en v5.7) Expresión aritmética para calcular el valor de la propiedad. El cálculo se hace en la interfaz de usuario cuando alguno de los operandos cambia.
11. @DefaultValueCalculator (OX, uno, optional): Para implementar la lógica para calcular el valor inicial de la propiedad. Una propiedad con @DefaultValueCalculator sí tiene setter y es persistente.
12. @PropertyValidator (OX, varios, opcional): Indica la lógica de validación a ejecutar sobre el valor a asignar a esta propiedad antes de crear o modificar.
13. Declaración de la propiedad: Una declaración de propiedad Java normal y corriente con getters y setters. Podemos crear una propiedad calculada usando solo un getter sin campo ni setter. Cualquier tipo legal para JPA está permitido, solo hemos de proveer un Hibernate Type para grabar en la base de datos y un editor OpenXava para dibujar como HTML.

Estereotipo

• DINERO, MONEY
• FOTO, PHOTO, IMAGEN, IMAGE
• TEXTO_GRANDE, MEMO, TEXT_AREA
• ETIQUETA, LABEL
• ETIQUETA_NEGRITA, BOLD_LABEL
• HORA, TIME
• FECHAHORA, DATETIME
• GALERIA_IMAGENES, IMAGES_GALLERY (instrucciones)
• RELLENADO_CON_CEROS, ZEROS_FILLED
• TEXTO_HTML, HTML_TEXT (texto con formato editable)
• TEXTO_HTML_SIMPLE, SIMPLE_HTML_TEXT (nuevo en v5.6, como TEXT_HTML pero con una interfaz simplificada)
• ETIQUETA_IMAGEN, IMAGE_LABEL (imagen que depende del contenido de la propiedad)
• EMAIL
• TELEFONO, TELEPHONE
• WEBURL
• IP
• ISBN
• TARJETA_CREDITO, CREDIT_CARD
• LISTA_EMAIL, EMAIL_LIST
• LIBRERIA_DOCUMENTOS, DOCUMENT_LIBRARY (nuevo en v4m6, sólo funciona dentro de Liferay)
• CONTRASENA, PASSWORD (nuevo en v4.1)
• MAC (nuevo en v4.8)
• ARCHIVO, FILE (nuevo en v5.0) (instrucciones)
• ARCHIVOS, FILES (nuevo en v5.1) (instrucciones)
• ICONO, ICON (nuevo en v5.5)
• DISCUSION, DISCUSSION (nuevo en v5.6) (instrucciones)

<editor url="editorNombrePersona.jsp">
 <para-estereotipo estereotipo="NOMBRE_PERSONA"/>
</editor>

<para-estereotipo nombre="NOMBRE_PERSONA" longitud="40"/>

<validador-requerido>
 <clase-validador clase="org.openxava.validators.NotBlankCharacterValidator"/>
 <para-estereotipo estereotipo="NOMBRE_PERSONA"/>
</validador-requerido>

@Stereotype("PERSON_NAME")
private String nombre;

Estereotipo GALERIA_IMAGENES

@Stereotype("GALERIA_IMAGENES")
private String fotos;

CREATE TABLE IMAGENES (
 ID VARCHAR(32) NOT NULL PRIMARY KEY,
 GALLERY VARCHAR(32) NOT NULL,
 IMAGE BLOB);
CREATE INDEX IMAGENES01
 ON IMAGENES (GALLERY);
 

<hibernate-configuration>
 <session-factory>
 ...
 <mapping resource="GalleryImage.hbm.xml"/>
 ...
 </session-factory>
</hibernate-configuration>

Estereotipos ARCHIVO (nuevo en v5.0) y ARCHIVOS (nuevo en v5.1)

@Stereotype("ARCHIVO")
@Column(length=32)
private String documento;

@Stereotype("ARCHIVOS")
@Column(length=32)
private String documentos;

Almacenamiento en el Sistema de Archivos

Almacenamiento en Base de Datos

• Configurar en xava.properties de nuestro proyecto la propiedad filePersistorClass.

filePersistorClass=org.openxava.web.editors.JPAFilePersistor
...

• Modificar el persistence.xml de nuestro proyecto.

<persistence-unit name="default">
 <provider>org.hibernate.ejb.HibernatePersistence</provider>
 <non-jta-data-source>java:comp/env/jdbc/OpenXavaTestDS</non-jta-data-source>
 <class>org.openxava.session.GalleryImage</class>
 <class>org.openxava.web.editors.AttachedFile</class>
  ...
</persistence-unit>
 
        ...
 
<persistence-unit name="junit">
 <provider>org.hibernate.ejb.HibernatePersistence</provider>
 <class>org.openxava.web.editors.AttachedFile</class>
 ....
</persistence-unit>

• Al generar nuestra base de datos se creará la tabla OXFILES:

CREATE TABLE OXFILES (
 ID VARCHAR(32) NOT NULL PRIMARY KEY,
 NAME VARCHAR(255),
 DATA LONGVARBINARY,
 LIBRARYID VARCHAR(32)
);

Estereotipo DISCUSION (nuevo en v5.6)

@Stereotype("DISCUSION")
@Column(length=32)
private String discusion;

@PreRemove
private void borrarDiscusion() {
    DiscussionComment.removeForDiscussion(discusion);
}

<persistence-unit name="default">
 <provider>org.hibernate.ejb.HibernatePersistence</provider>
 <non-jta-data-source>java:comp/env/jdbc/OpenXavaTestDS</non-jta-data-source>
 <class>org.openxava.session.GalleryImage</class>
 <class>org.openxava.web.editors.DiscussionComment</class> <!-- AÑADE ESTA LÍNEA -->
  ...
</persistence-unit>
 

CREATE TABLE OXDISCUSSIONCOMMENTS (
    ID VARCHAR(32) NOT NULL,
    COMMENT CLOB(16777216),
    DISCUSSIONID VARCHAR(32),
    TIME TIMESTAMP,
    USERNAME VARCHAR(30),
    PRIMARY KEY (ID)
);
 
CREATE INDEX OXDISCUSSIONCOMMENTS_DISCUSSIONID_INDEX
    ON OXDISCUSSIONCOMMENTS (DISCUSSIONID);

Concurrencia y propiedad versión

@Version
private Integer version;

Enums

private Distancia distancia;
public enum Distancia { LOCAL, NACIONAL, INTERNACIONAL };

Enums con icono (nuevo en v6.3)

public enum Prioridad implements IIconEnum { 

	BAJA("transfer-down"), MEDIA("square-medium"), ALTA("transfer-up");

	private String icon;

	private Priority(String icon) {
		this.icon = icon;
	}

	public String getIcon() {
		return icon;
	} 
		
};
private Prioridad prioridad;

Propiedades calculadas

@Depends("precioUnitario") // 1
@Max(9999999999L) // 2
public BigDecimal getPrecioUnitarioEnPesetas() {
 if (precioUnitario == null) return null;
 return precioUnitario.multiply(new BigDecimal("166.386"))
 .setScale(0, BigDecimal.ROUND_HALF_UP);
}
 

Producto producto = ...
producto.setPrecioUnitario(2);
BigDecimal resultado = producto.getPrecioUnitarioEnPesetas();
 

@Max(999)
public int getCantidadLineas() {
 // Un ejemplo de uso de JDBC
 Connection con = null;
 try {
 con = DataSourceConnectionProvider.getByComponent("Factura").getConnection(); // 1
 String tabla = MetaModel.get("LineaFactura").getMapping().getTable();
 PreparedStatement ps = con.prepareStatement("select count(*) from " + tabla +
 " where FACTURA_AÑO = ? and FACTURA_NUMERO = ?");
 ps.setInt(1, getAño());
 ps.setInt(2, getNumero());
 ResultSet rs = ps.executeQuery();
 rs.next();
 Integer result = new Integer(rs.getInt(1));
 ps.close();
 return result;
 }
 catch (Exception ex) {
 log.error("Problemas al calcular cantidad de líneas de una Factura", ex);
 // Podemos lanzar cualquier RuntimeException aquí
 throw new SystemException(ex);
 }
 finally {
 try {
 con.close();
 }
 catch (Exception ex) {
 }
 }
}
 

private long codigo;
 
@Id @Column(length=10) // Anotamos el getter,
public long getCodigo() { // por tanto JPA usará acceso basado en propiedades para nuestra clase
 return codigo;
}
public void setCodigo(long codigo) {
 this.codigo = codigo;
}
 
@Transient // Hemos de anotar como Transient nuestra propiedad calculada
public String getZoneOne() { // porque usamos acceso basado en propiedades
 return "En ZONA 1";
}
 

Formula (nuevo en v3.1.4)

@org.hibernate.annotations.Formula("PRECIOUNITARIO * 1.16")
private BigDecimal precioUnitarioConIVA;
public BigDecimal getPrecioUnitarioConIVA() {
 return precioUnitarioConIVA;
}

Calculador valor por defecto

@DefaultValueCalculator(CurrentYearCalculator.class)
private int año;
 

package org.openxava.calculators;
 
import java.util.*;
 
/**
 * @author Javier Paniza
 */
public class CurrentYearCalculator implements ICalculator {
 
 public Object calculate() throws Exception {
 Calendar cal = Calendar.getInstance();
 cal.setTime(new java.util.Date());
 return new Integer(cal.get(Calendar.YEAR));
 }
 
}
 

@DefaultValueCalculator(
 value=org.openxava.calculators.StringCalculator.class,
 properties={ @PropertyValue(name="string", value="BUENA") }
)
private String relacionConComercial;

@DefaultValueCalculator(
 value=org.openxava.test.calculadores.CalculadorObservacionesTransportista.class,
 properties={
 @PropertyValue(name="tipoPermisoConducir", from="permisoConducir.tipo")
 }
)
private String observaciones;

@DefaultValueCalculator(value=CalculadorPrecioDefectoProducto.class, properties=
 @PropertyValue(name="codigoFamilia")
)

@DefaultValueCalculator(value=CalculadorCantidadLineas.class,
 properties= {
 @PropertyValue(name="año"),
 @PropertyValue(name="numero"),
 }
)
private int cantidadLineas;
 

package org.openxava.test.calculadores;
 
import java.sql.*;
 
import org.openxava.calculators.*;
import org.openxava.util.*;
 
/**
 * @author Javier Paniza
 */
public class CalculadorCantidadLineas implements IJDBCCalculator { // 1
 
 private IConnectionProvider provider;
 private int año;
 private int numero;
 
 public void setConnectionProvider(IConnectionProvider provider) { // 2
 this.provider = provider;
 }
 
 public Object calculate() throws Exception {
 Connection con = provider.getConnection();
 try {
 PreparedStatement ps = con.prepareStatement(
 "select count(*) from XAVATEST.LINEAFACTURA “ +
 “where FACTURA_AÑO = ? and FACTURA_NUMERO = ?");
 ps.setInt(1, getAño());
 ps.setInt(2, getNumero());
 ResultSet rs = ps.executeQuery();
 rs.next();
 Integer result = new Integer(rs.getInt(1));
 ps.close();
 return result;
 }
 finally {
 con.close();
 }
 }
 
 public int getAño() {
 return año;
 }
 
 public int getNumero() {
 return numero;
 }
 
 public void setAño(int año) {
 this.año = año;
 }
 
 public void setNumero(int numero) {
 this.numero = numero;
 }
 
}

Valores por defecto al crear

@Id @Hidden
@GeneratedValue(strategy=GenerationType.IDENTITY)
private Integer id;
 

@SequenceGenerator(name="SIZE_SEQ", sequenceName="SIZE_ID_SEQ", allocationSize=1 )
@Hidden @Id @GeneratedValue(strategy=GenerationType.SEQUENCE, generator="SIZE_SEQ")
private Integer id;
 

@Id @GeneratedValue(generator="system-uuid") @Hidden
@GenericGenerator(name="system-uuid", strategy = "uuid")
private String oid;
 

@PrePersist
private void calcularContador() {
 contador = new Long(System.currentTimeMillis()).intValue();
}
 

Validador de propiedad

@PropertyValidator(value=ValidadorExcluirCadena.class, properties=
    @PropertyValue(name="cadena", value="MOTO")
)
@PropertyValidator(value=ValidadorExcluirCadena.class, properties=
    @PropertyValue(name="cadena", value="COCHE"),
    onlyOnCreate=true
)
private String descripcion;

@PropertyValidators ({ // Sólo necesario hasta v6.0.2
    @PropertyValidator(value=ValidadorExcluirCadena.class, properties=
        @PropertyValue(name="cadena", value="MOTO")
    ),
    @PropertyValidator(value=ValidadorExcluirCadena.class, properties=
        @PropertyValue(name="cadena", value="COCHE"),
        onlyOnCreate=true
    )
})
private String descripcion;

package org.openxava.test.validadores;
 
import org.openxava.util.*;
import org.openxava.validators.*;
 
/**
 * @author Javier Paniza
 */
 
public class ValidadorExcluirCadena implements IPropertyValidator { // 1
 
 private String cadena;
 
 public void validate(
 Messages errores, // 2
 Object valor, // 3
 String nombreObjecto, // 4
 String nombrePropiedad) // 5
 throws Exception {
 if (valor==null) return;
 if (valor.toString().indexOf(getCadena()) >= 0) {
 errores.add("excluir_cadena",
 nombrePropiedad, nombreObjeto, getCadena());
 }
 }
 
 public String getCadena() {
 return cadena==null?"":cadena;
 }
 
 public void setCadena(String cadena) {
 this.cadena = cadena;
 }
 
}

1. Messages errores: Un objeto de tipo Messages que representa un conjunto de mensajes (una especie de colección inteligente) y es donde podemos añadir los problemas de validación que encontremos.
2. Object valor: El valor a validar.
3. String nombreObjeto: Nombre del objeto al que pertenece la propiedad a validar. Útil para usarlo en los mensajes de error.
4. String nombrePropiedad: Nombre de la propiedad a validar. Útil para usarlo en los mensajes de error.

excluir_cadena={0} no puede contener {2} en {1}

@PropertyValidator(value=ValidadorTituloLibro.class, message="{libro_rpg_no_permitido}")
private String titulo;

public class ValidadorTituloLibro implements IPropertyValidator, IWithMessage {
 
    private String message;
 
    public void setMessage(String message) throws Exception {
        this.message = message; // Este es message de @PropertyValidator
    }
 
    public void validate(Messages errors, Object value, String propertyName, String modelName) {
       if (((String)value).contains("RPG")) {
           errors.add(message); // Podemos añadir el mensaje directamente
       }
    }
 
}

Validador por defecto (nuevo en v2.0.3)

<validadores>
 <validador-defecto>
 <clase-validador
 clase="org.openxava.test.validadores.ValidadorNombrePersona"/>
 <para-estereotipo stereotipo="NOMBRE_PERSONA"/>
 </validador-defecto>
</validadores>

@Required @Stereotype("NOMBRE_PERSONA")
private String nombre;

Cálculo (nuevo en v5.7)

@Calculation("((horas * trabajador.precioHora) + desplazamiento - descuento) * porcentajeIVA / 100")
private BigDecimal total;

Referencias

Cliente cliente = ...
cliente.getComercial().getNombre();
 

@Required // 1
@Id // 2
@SearchKey // 3 Nuevo en v3.0.2
@DefaultValueCalculator // 4
@ManyToOne( // 5
 optional=false // 1
)
private tipo nombreReferencia; // 5
public tipo getNombreReferencia() { ... } // 5
public void setNombreReferencia(tipo nuevoValor) { ... } // 5

1. @ManyToOne(optional=false) (JPA), @Required (OX) (opcional, el JPA es el preferido): Indica si la referencia es requerida. Al grabar OpenXava comprobará si las referencias requeridas están presentes, si no lo están no se producirá la grabación y se devolverá una lista de errores de validación.
2. @Id (JPA, opcional): Para indicar si la referencia forma parte de la clave. La combinación de propiedades y referencias clave se debe mapear a un conjunto de campos en la base de datos que no tengan valores repetidos, típicamente con la clave primaria.
3. @DefaultValueCalculator (OX, one, opcional): Para implementar la lógica para calcular el valor inicial de la referencia. Este calculador ha de devolver el valor de la clave, que puede ser un dato simple (solo si la clave del objeto referenciado es simple) o un objeto clave (un objeto especial que envuelve la clave primaria).
4. @SearchKey (OX, optional): (Nuevo en v3.0.2) Las referencias clave de búsqueda se usan por los usuarios para buscar los objetos. Son editables en la interfaz de usuario de las referencias permitiendo al usuario teclear su valor para buscar. OpenXava usa los miembros clave (@Id) para buscar por defecto, y si los miembros clave (@Id) están ocultos usa la primera propiedad en la vista. Con @SearchKey podemos elegir referencias para buscar explícitamente.
5. Declaración de la referencia: Una declaración de referencia convencional de Java con sus getters y setters. La referencia se marca con @ManyToOne (JPA) y el tipo ha de ser otra entidad.

@ManyToOne
private Comercial comercial; // 1
public Comercial getComercial() {
 return comercial;
}
public void setComercial(Comercial comercial) {
 this.comercial = comercial;
}
 
@ManyToOne(fetch=FetchType.LAZY)
private Comercial comercialAlternativo; // 2
public Comercial getComercialAlternativo() {
 return comercialAlternativo;
}
public void setComercialAlternativo(Comercial comercialAlternativa) {
 this.comercialAlternativo = comercialAlternativo;
}
 

1. Una referencia llamada comercial a la entidad Comercial.
2. Una referencia llamada comercialAlternativo a la entidad Comercial. En este caso usamos fetch=FetchType.LAZY, de esta manera los datos son leidos de la base de datos bajo demanda. Este es el enfoque más eficiente, pero no es el valor por defecto en JPA, por tanto es aconsejable usar siempre fetch=FetchType.LAZY al declarar las referencias.

Cliente cliente = ...
Comercial comercial = cliente.getComercial();
Comercial comercialAlternativo = cliente.getComercialAlternativo();
 

Calculador valor por defecto en referencias

@ManyToOne(optional=false, fetch=FetchType.LAZY) @JoinColumn(name="FAMILY")
@DefaultValueCalculator(value=IntegerCalculator.class, properties=
 @PropertyValue(name="value", value="2")
)
private Familia familia;

public Object calculate() throws Exception {
 return new Integer(value);
}
 

@ManyToOne(fetch=FetchType.LAZY)
@JoinColumns({
 @JoinColumn(name="ZONA", referencedColumnName="ZONA"),
 @JoinColumn(name="ALMACEN", referencedColumnName="CODIGO")
})
@DefaultValueCalculator(CalculadorDefectoAlmacen.class)
private Almacen almacen;

package org.openxava.test.calculadores;
 
import org.openxava.calculators.*;
 
/**
 * @author Javier Paniza
 */
public class CalculadorDefectoAlmacen implements ICalculator {
 
  public Object calculate() throws Exception {
    Almacen clave = new Almacen();
    clave.setNumber(4);
    clave.setZoneNumber(4);
    return clave;
  }
 
}

Usar referencias como clave

@Entity
@IdClass(DetalleAdicionalKey.class)
public class DetalleAdicional {
 
 // JoinColumn se especifica también en DetalleAdicionalKey por un
 // bug de Hibernate, ver http://opensource.atlassian.com/projects/hibernate/browse/ANN-361
 @Id @ManyToOne(fetch=FetchType.LAZY)
 @JoinColumn(name="SERVICIO")
 private Servicio servicio;
 
 @Id @Hidden
 private int contador;
 
 ...
 
}

public class DetalleAdicionalKey implements java.io.Serializable {
 
 @ManyToOne(fetch=FetchType.LAZY)
 @JoinColumn(name="SERVICIO")
 private Servicio servicio;
 
 @Hidden
 private int contador;
 
 // equals, hashCode, toString, getters y setters
 ...
 
 }

Referencias incrustadas

@Embedded
private Direccion direccion;
 

package org.openxava.test.model;
 
import javax.persistence.*;
import org.openxava.annotations.*;
 
/**
 *
 * @author Javier Paniza
 */
 
@Embeddable
public class Direccion implements IConPoblacion {
 
 @Required @Column(length=30)
 private String calle;
 
 @Required @Column(length=5)
 private int codigoPostal;
 
 @Required @Column(length=20)
 private String poblacion;
 
 // ManyToOne dentro de un Embeddable no está soportado en JPA 1.0 (ver en 9.1.34),
 // pero la implementación de Hibernate lo soporta.
 @ManyToOne(fetch=FetchType.LAZY, optional=false) @JoinColumn(name="STATE")
 private Provincia provincia;
 
 public String getPoblacion() {
 return poblacion;
 }
 
 public void setPoblacion(String poblacion) {
 this.poblacion = poblacion;
 }
 
 public String getCalle() {
 return calle;
 }
 
 public void setCalle(String calle) {
 this.calle = calle;
 }
 
 public int getCodigoPostal() {
 return codigoPostal;
 }
 
 public void setCodigoPostal(int codigoPostal) {
 this.codigoPostal = codigoPostal;
 }
 
 public Provincia getProvincia() {
 return provincia;
 }
 
 public void setProvincia(Provincia provincia) {
 this.provincia = provincia;
 }
 
}

Cliente cliente = ...
Direccion direccion = cliente.getDireccion();
direccion.getCalle(); // para obtener el valor

// para establecer una nueva dirección
Direccion direccion = new Direccion();
direccion.setCalle(“Mi calle”);
direccion.setCodigoPostal(46001);
direccion.setMunicipio(“Valencia”);
direccion.setProvincia(provincia);
cliente.setDireccion(direccion);

Colecciones

Colecciones de entidades

@Size // 1
@Condition // 2
@OrderBy // 3
@XOrderBy // 4
@OrderColumn // 5
@OneToMany/@ManyToMany // 6
private Collection<TuEntidad> nombreColeccion; // 5
public Collection<TuEntidad> getNombreColeccion() { ... } // 5
public void setNombreColeccion(Collection<TuEntidad> nuevoValor) { ... } // 5
 

1. @Size (BV, HV, opcional): Cantidad mínima (min) y/o máxima (max) de elementos esperados. Esto se valida antes de grabar.
2. @Condition (OX, opcional): Para restringir los elementos que aparecen en la colección.
3. @OrderBy (JPA, opcional): Para que los elementos de la colección aparezcan en un determinado orden.
4. @XOrderBy (OX, opcional): @OrderBy de JPA no permite usar propiedades calificadas (propiedades de referencias). @XOrderBy sí lo permite.
5. @OrderColumn (JPA, opcional): (Nuevo en v5.3) El orden de los elementos en la colección se guarda en la base de datos. Una columna especial se crea en la tabla para mantener este orden. La colección ha de ser una java.util.List. La interfaz de usuario permite al usuario reordenar los elementos de la colección.
6. Declaracion de la colección: Una declaración de colección convencional de Java con sus getters y setters. La colección se marca con @OneToMany (JPA) o @ManyToMany (JPA) y el tipo ha de ser otra entidad.

@OneToMany (mappedBy="factura")
private Collection<Albaran> albaranes;
public Collection<Albaran> getAlbaranes() {
 return albaranes;
}
public void setAlbaranes(Collection<Albaran> albaranes) {
 this.albaranes = albaranes;
}
 

Factura factura = ...
for (Albaran albaran: factura.getAlbaranes()) {
 albaran.hacerAlgo();
}

@OneToMany (mappedBy="factura", cascade=CascadeType.REMOVE) // 1
@OrderBy("tipoServicio desc") // 2
@org.hibernate.validator.Size(min=1) // 3
private Collection<LineaFactural> facturas;

1. Usar REMOVE como tipo de cascadaas cascade type hace que cuando el usuario borra una factura sus líneas también se borran.
2. Con @OrderBy obligamos a que las lineas se devuelvan ordenadas por tipoServicio.
3. La restricción de @Size(min=1) hace que sea obligado que haya al menos una línea para que la factura sea válida.

@Condition(
 "${almacen.codigoZona} = ${this.almacen.codigoZona} AND " +
 "${almacen.codigo} = ${this.almacen.codigo} AND " +
 "NOT (${codigo} = ${this.codigo})"
)
public Collection<Transportista> getCompañeros() {
 return null;
}

public Collection<Transportista> getCompañeros() {
 Query query = XPersistence.getManager().createQuery("from Transportista t where " +
 "t.almacen.codigoZona = :zona AND " +
 "t.almacen.codigo = :codigoAlmacen AND " +
 "NOT (t.codigo = :codigo) ");
 query.setParameter("zona", getAlmacen().getCodigoZona());
 query.setParameter("codigoAlmacen", getAlmacen().getCodigo());
 query.setParameter("codigo", getCodigo());
 return query.getResultList();
}

@OneToMany(mappedBy="comercial")
private Collection<Cliente> clientes;

@Entity
public class Cliente {
 ...
 @ManyToMany
 private Collection<Provincia> provincias;
 ...
}
 

Colecciones incrustadas

@OneToMany (mappedBy="factura", cascade=CascadeType.REMOVE)
private Collection<LineaFactura> lineas;

package org.openxava.test.model;
 
import java.math.*;
 
import javax.persistence.*;
 
import org.hibernate.annotations.Columns;
import org.hibernate.annotations.Type;
import org.hibernate.annotations.Parameter;
import org.hibernate.annotations.GenericGenerator;
import org.openxava.annotations.*;
import org.openxava.calculators.*;
import org.openxava.test.validators.*;
 
/**
 *
 * @author Javier Paniza
 */
 
@Entity
@EntityValidator(value=ValidadorLineaFactura.class,
 properties= {
 @PropertyValue(name="factura"),
 @PropertyValue(name="oid"),
 @PropertyValue(name="producto"),
 @PropertyValue(name="precioUnitario")
 }
)
public class LineaFactura {
 
 @ManyToOne // 'Lazy fetching' produce un falla al borrar una linea desde la factura
 private Factura factura;
 
 @Id @GeneratedValue(generator="system-uuid") @Hidden
 @GenericGenerator(name="system-uuid", strategy = "uuid")
 private String oid;
 
 private TipoServicio tipoServicio;
 public enum TipoServicio { ESPECIAL, URGENTE }
 
 @Column(length=4) @Required
 private int cantidad;
 
 @Stereotype("DINERO") @Required
 private BigDecimal precioUnitario;
 
 @ManyToOne(fetch=FetchType.LAZY, optional=false)
 private Producto producto;
 
 @DefaultValueCalculator(CurrentDateCalculator.class)
 private java.util.Date fechaEntrega;
 
 @ManyToOne(fetch=FetchType.LAZY)
 private Comercial vendidoPor;
 
 @Stereotype("MEMO")
 private String observaciones;
 
 @Stereotype("DINERO") @Depends("precioUnitario, cantidad")
 public BigDecimal getImporte() {
 return getPrecioUnitario().multiply(new BigDecimal(getCantidad()));
 }
 
 public boolean isGratis() {
 return getImporte().compareTo(new BigDecimal("0")) <= 0;
 }
 
 @PostRemove
 private void postRemove() {
 factura.setComentario(factura.getComentario() + "DETALLE BORRADO");
 }
 
 public String getOid() {
 return oid;
 }
 public void setOid(String oid) {
 this.oid = oid;
 }
 public TipoServicio getTipoServicio() {
 return tipoServicio;
 }
 public void setTipoServicio(TipoServicio tipoServicio) {
 this.tipoServicio = tipoServicio;
 }
 public int getCantidad() {
 return cantidad;
 }
 public void setCantidad(int cantidad) {
 this.cantidad = cantidad;
 }
 public BigDecimal getPrecioUnitario() {
 return precioUnitario==null?BigDecimal.ZERO:precioUnitario;
 }
 public void setPrecioUnitario(BigDecimal precioUnitario) {
 this.precioUnitario = precioUnitario;
 }
 
 public Product getProducto() {
 return producto;
 }
 
 public void setProducto(Producto producto) {
 this.producto = producto;
 }
 
 public java.util.Date getFechaEntrega() {
 return fechaEntrega;
 }
 
 public void setFechaEntrega(java.util.Date fechaEntrega) {
 this.fechaEntrega = fechaEntrega;
 }
 
 public Comercial getVendidoPor() {
 return vendidoPor;
 }
 
 public void setVendidoPor(Comercial vendidoPor) {
 this.vendidoPor = vendidoPor;
 }
 
 public String getObservaciones() {
 return observaciones;
 }
 
 public void setObservaciones(String observaciones) {
 this.observaciones = observaciones;
 }
 
 public Invoice getFactura() {
 return factura;
 }
 
 public void setFactura(Factura factura) {
 this.factura = factura;
 }
 
}

Colecciones de elementos (nuevo en v5.0)

@Size // 1
@OrderBy // 2
@OrderColumn // 3  Nuevo en v5.3
@ElementCollection // 4
private Collection<TuClaseIncrustable> nombreColeccion; // 3
public Collection<TuClaseIncrustable> getNombreColeccion() { ... } // 3
public void setNombreColeccion<TuClaseIncrustable> nuevoValor) { ... } // 3

1. @Size (BV, HV, opcional): Cantidad mínima (min) y/o máxima (max) de elementos esperados. Esto se valida antes de grabar.
2. @OrderBy (JPA, opcional): Para que los elementos de la colección aparezcan en un determinado orden.
3. @OrderColumn (JPA, opcional): (Nuevo en v5.3) El orden de los elementos en la colección se guarda en la base de datos. Una columna especial se crea en la tabla para mantener este orden. La colección ha de ser una java.util.List. La interfaz de usuario permite al usuario reordenar los elementos de la colección.
4. Collection declaration: Una declaración de colección Java convencional con sus getters y setters. La colección se marca con @ElementCollection (JPA). Los elementos tienes que ser clases incrustables.

@Entity
public class Presupuesto extends Identifiable {
    ...
    @ElementCollection
    private Collection<LineaPresupuesto> lineas;
 
    public Collection<LineaPresupuesto> getLineas() {
        return lineas;
    }
    public void setLineas(Collection<LineaPresupuesto> lineas) {
        this.lineas = lineas;
    }
    ...
}

@Embeddable
public class LineaPresupuesto {
 
    @ManyToOne(fetch=FetchType.LAZY, optional=false) // 1
    private Producto producto;
 
    @Required // 2
    private BigDecimal precioUnitario;
 
    @Required
    private int cantidad;
 
    private Date fechaDisponibilidad;
 
    @Column(length=30)
    private String comentarios;
 
    @Column(precision=10, scale=2)
    @Depends("precioUnitario, cantidad")
    public BigDecimal getImporte() { // 3
        return getPrecioUnitario().multiply(new BigDecimal(getCantidad()));
    }
    ...
}

Listas con @OrderColumn (nuevo en v5.3)

@OneToMany(mappedBy="proyecto", cascade=CascadeType.ALL)
@OrderColumn
private List<TareaProyecto> tareas;

ALTER TABLE TAREAPROYECTO
ADD TAREAS_ORDER INTEGER

Métodos

public void incrementarPrecio() {
 setPrecioUnitario(getPrecioUnitario().multiply(new BigDecimal("1.02")).setScale(2));
}

Buscadores

public static Cliente findByCodigo(int codigo) throws NoResultException {
 Query query = XPersistence.getManager().createQuery(
 "from Cliente as o where o.codigo = :codigo");
 query.setParameter("codigo", codigo);
 return (Cliente) query.getSingleResult();
}
 
public static Collection findTodos() {
 Query query = XPersistence.getManager().createQuery("from Cliente as o");
 return query.getResultList();
}
 
public static Collection findByNombreLike(String nombre) {
 Query query = XPersistence.getManager().createQuery(
 "from Cliente as o where o.nombre like :nombre order by o.nombre desc");
 query.setParameter("nombre", nombre);
 return query.getResultList();
}

Cliente cliente = Cliente.findByCodigo(8);
Collection javieres = Cliente.findByNombreLike(“%JAVI%”);

Validador de entidad

@EntityValidator(
 value=clase, // 1
 onlyOnCreate=(true|false), // 2
 properties={ @PropertyValue ... } // 3
)

1. value (opcional, obligada si no se especifica nombre): Clase que implementa la validación. Ha de ser del tipo IValidator.
2. onlyOnCreate (opcional): Si true el validador es ejecutado solo cuando estamos creando un objeto nuevo, no cuando modificamos uno existente. El valor por defecto es false.
3. properties (varios @PropertyValue, opcional): Para establecer valor a las propiedades del validador antes de ejecutarse.

@EntityValidator(value=org.openxava.test.validadores.ValidadorProductoBarato.class, properties= {
 @PropertyValue(name="limite", value="100"),
 @PropertyValue(name="descripcion"),
 @PropertyValue(name="precioUnitario")
})
public class Producto {

package org.openxava.test.validadores;
 
import java.math.*;
 
/**
 * @author Javier Paniza
 */
 
public class ValidadorProductoBarato implements IValidator { // 1
 
 private int limite;
 private BigDecimal precioUnitario;
 private String descripcion;
 
 public void validate(Messages errores) { // 2
 if (getDescripcion().indexOf("CHEAP") >= 0 ||
 getDescripcion().indexOf("BARATO") >= 0 ||
 getDescripcion().indexOf("BARATA") >= 0) {
 if (getLimiteBd().compareTo(getPrecioUnitario()) < 0) {
 errors.add("producto_barato", getLimiteBd()); // 3
 }
 }
 }
 
 public BigDecimal getPrecioUnitario() {
 return precioUnitario;
 }
 
 public void setPrecioUnitario(BigDecimal decimal) {
 precioUnitario = decimal;
 }
 
 public String getDescripcion() {
 return descripcion==null?"":descripcion;
 }
 
 public void setDescripcion(String string) {
 descripcion = string;
 }
 
 public int getLimite() {
 return limite;
 }
 
 public void setLimite(int i) {
 limite = i;
 }
 
 private BigDecimal getLimiteBd() {
 return new BigDecimal(Integer.toString(limite));
 }
 
}
 

@EntityValidator(value=org.openxava.test.validadores.ValidadorProductoBarato.class, properties= {
    @PropertyValue(name="limite", value="100"),
    @PropertyValue(name="descripcion"),
    @PropertyValue(name="precioUnitario")
})
@EntityValidator(value=org.openxava.test.validadores.ValidadorProductoCaro.class, properties= {
    @PropertyValue(name="limite", value="1000"),
    @PropertyValue(name="descripcion"),
    @PropertyValue(name="precioUnitario")
})
@EntityValidator(value=org.openxava.test.validadores.ValidadorPrecioProhibido.class,
    properties= {
        @PropertyValue(name="precioProhibido", value="555"),
        @PropertyValue(name="precioUnitario")
    },
    onlyOnCreate=true
)
public class Product {

@EntityValidators({ // Sólo necesario hasta v6.0.2
    @EntityValidator(value=org.openxava.test.validadores.ValidadorProductoBarato.class, properties= {
        @PropertyValue(name="limite", value="100"),
        @PropertyValue(name="descripcion"),
        @PropertyValue(name="precioUnitario")
    }),
    @EntityValidator(value=org.openxava.test.validadores.ValidadorProductoCaro.class, properties= {
        @PropertyValue(name="limite", value="1000"),
        @PropertyValue(name="descripcion"),
        @PropertyValue(name="precioUnitario")
    }),
    @EntityValidator(value=org.openxava.test.validadores.ValidadorPrecioProhibido.class,
        properties= {
            @PropertyValue(name="precioProhibido", value="555"),
            @PropertyValue(name="precioUnitario")
        },
        onlyOnCreate=true
    )
})
public class Product {

Validador al borrar

@RemoveValidator(
 value=clase, // 1
 properties={ @PropertyValue ... } // 2
)
 

1. clase (obligada): Clase que implementa la validación. Ha de ser del tipo IRemoveValidator.
2. properties (varios @PropertyValue, opcional): Para establecer valor a las propiedades del calculador antes de ejecutarse.

@RemoveValidator(value=ValidadorBorrarTipoAlbaran.class,
 properties=@PropertyValue(name="codigo")
)
public class TipoAlbaran {

package org.openxava.test.validadores;
 
import org.openxava.test.model.*;
import org.openxava.util.*;
import org.openxava.validators.*;
 
/**
 * @author Javier Paniza
 */
public class ValidadorBorrarTipoAlbaran implements IRemoveValidator { // 1
 
 private TipoAlbaran tipoAlbaran;
 private int codigo; // Usamos esto (en vez de obtenerlo de tipoAlbaran)
 // para probar @PropertyValue con propiedades simples
 
 public void setEntity(Object entidad) throws Exception { // 2
 this.tipoAlbaran = (TipoAlbaran) entidad;
 }
 
 public void validate(Messages errores) throws Exception {
 if (!tipoAlbaran.getAlbaranes().isEmpty()) {
 errores.add("no_borrar_tipo_albaran_si_albaranes", new Integer(getCodigo())); // 3
 }
 }
 
 public int getCodigo() {
 return codigo;
 }
 
 public void setCodigo(int codigo) {
 this.codigo = codigo;
 }
 
}

Métodos de retrollamada de JPA

@PrePersist
private void antesDeCrear() {
 setDescripcion(getDescripcion() + " CREADO");
}

@PreUpdate
private void antesDeModificar() {
 setDescripcion(getDescripcion() + " MODIFICADO");
}

Métodos de retrollamada de OX (nuevo en V4.0.1)

public onPreCreate {
 // Crea automaticamente un cliente
 if (getCliente() == null) {
 Cliente clte = new Cliente();
 clte.setNombre(getNombre());
 clte.setDireccion(getDireccion());
 clte = XPersistence.getManager().merge(clte);
 setCliente(clte);
 }
}
 

Herencia

package org.openxava.test.model;
 
import javax.persistence.*;
 
import org.hibernate.annotations.*;
import org.openxava.annotations.*;
 
/**
 * Clase base para definir entidades con un oid UUID. <p>
 *
 * @author Javier Paniza
 */
 
@MappedSuperclass
public class Identificable {
 
 @Id @GeneratedValue(generator="system-uuid") @Hidden
 @GenericGenerator(name="system-uuid", strategy = "uuid")
 private String oid;
 
 public String getOid() {
 return oid;
 }
 
 public void setOid(String oid) {
 this.oid = oid;
 }
 
}
 

package org.openxava.test.model;
 
import javax.persistence.*;
 
import org.openxava.annotations.*;
 
/**
 * Clase base para entidades con una propiedad 'nombre'. <p>
 *
 * @author Javier Paniza
 */
@MappedSuperclass
public class ConNombre extends Identifiable {
 
 @Column(length=50) @Required
 private String nombre;
 
 public String getNombre() {
 return nombre;
 }
 
 public void setNombre(String nombre) {
 this.nombre = nombre;
 }
 
}
 

package org.openxava.test.model;
 
import javax.persistence.*;
 
/**
 *
 * @author Javier Paniza
 */
 
@Entity
@DiscriminatorColumn(name="TYPE")
@DiscriminatorValue("HUM")
@Table(name="PERSONA")
@AttributeOverrides(
 @AttributeOverride(name="name", column=@Column(name="PNOMBRE"))
)
public class Humano extends ConNombre {
 
 @Enumerated(EnumType.STRING)
 private Sexo sexo;
 public enum Sexo { MASCULINO, FEMENINO };
 
 public Sexo getSexo() {
 return sexo;
 }
 public void setSexo(Sexo sexo) {
 this.sexo = sexo;
 }
 
}
 

package org.openxava.test.model;
 
import javax.persistence.*;
 
/**
 *
 * @author Javier Paniza
 */
 
@Entity
@DiscriminatorValue("PRO")
public class Programador extends Humano {
 
 @Column(length=20)
 private String lenguajePrincipal;
 
 public String getLenguajePrincipal() {
 return lenguajePrincipal;
 }
 
 public void setLenguajePrincipal(String lenguajePrincipal) {
 this.lenguajePrincipal = lenguajePrincipal;
 }
 
}
 

Clave múltiple

Clase id

package org.openxava.test.model;
 
import javax.persistence.*;
 
import org.openxava.annotations.*;
import org.openxava.jpa.*;
 
/**
 *
 * @author Javier Paniza
 */
 
@Entity
@IdClass(AlmacenKey.class)
public class Almacen {
 
 @Id
 // Column también se especifica en AlmacenKey por un bug en Hibernate, ver
 // http://opensource.atlassian.com/projects/hibernate/browse/ANN-361
 @Column(length=3, name="ZONA")
 private int codigoZona;
 
 @Id @Column(length=3)
 private int codigo;
 
 @Column(length=40) @Required
 private String nombre;
 
 
 public String getNombre() {
 return nombre;
 }
 
 public void setNombre(String nombre) {
 this.nombre = nombre;
 }
 
 public int getCodigo() {
 return codigo;
 }
 
 public void setCodigo(int codigo) {
 this.codigo = codigo;
 }
 
 public int getCodigoZona() {
 return codigoZona;
 }
 
 public void setCodigoZona(int codigoZona) {
 this.codigoZona = codigoZona;
 }
 
}
 

package org.openxava.test.model;
 
import java.io.*;
import javax.persistence.*;
 
/**
 *
 * @author Javier Paniza
 */
 
public class AlmacenKey implements Serializable {
 
 @Column(name="ZONE")
 private int codigoZona;
 private int codigo;
 
 @Override
 public boolean equals(Object obj) {
 if (obj == null) return false;
 return obj.toString().equals(this.toString());
 }
 
 @Override
 public int hashCode() {
 return toString().hashCode();
 }
 
 @Override
 public String toString() {
 return "AlmacenKey::" + codigoZona + ":" + codigo;
 }
 
 public int getCodigo() {
 return codigo;
 }
 
 public void setCodigo(int codigo) {
 this.codigo = codigo;
 }
 
 public int getCodigoZona() {
 return codigoZona;
 }
 
 public void setCodigoZona(int codigoZona) {
 this.codigoZona = codigoZona;
 }
 
}

Id inscrustado

package org.openxava.test.model;
 
import javax.persistence.*;
 
import org.openxava.annotations.*;
 
/**
 *
 * @author Javier Paniza
 */
 
@Entity
public class Almacen {
 
 @EmbeddedId
 private AlmacenKey clave;
 
 @Column(length=40) @Required
 private String nombre;
 
 public AlmacenKey getClave() {
 return clave;
 }
 
 public void setClave(AlmacenKey clave) {
 this.clave = clave;
 }
 
 public String getNombre() {
 return nombre;
 }
 
 public void setNombre(String nombre) {
 this.nombre = nombre;
 }
 
}
 

package org.openxava.test.model;
 
import javax.persistence.*;
 
/**
 *
 * @author Javier Paniza
 */
 
@Embeddable
public class AlmacenKey implements java.io.Serializable {
 
 
 @Column(length=3, name="ZONA")
 private int codigoZona;
 
 @Column(length=3)
 private int codigo;
 
 public int getCodigo() {
 return codigo;
 }
 
 public void setCodigo(int codigo) {
 this.codigo = codigo;
 }
 
 public int getCodigoZona() {
 return codigoZona;
 }
 
 public void setCodigoZona(int codigoZona) {
 this.codigoZona = codigoZona;
 }
 
}

Bean Validation

@AssertTrue

import javax.persistence.*;
import org.openxava.annotations.*;
import org.openxava.model.*
import javax.validation.constraints.*;
 
@Entity
public class Conductor extends Identifiable{
 
 @Required
 @Column(length = 40)
 private String nombre;
 
 @AssertTrue(message = "{no_puede_conducir}")
 private boolean puedeConducir;
 
 //getters y setters...
}

no_puede_conducir=Conductor {nombre} no puede ser registrado: debe aprobar el examen de conducir

import javax.persistence.*;
import org.openxava.annotations.*;
import org.openxava.model.*;
import javax.validation.constraints.*;
 
@Entity
public class Vehiculo extends Identifiable{
 
 @Required
 @Column(length = 15)
 private String tipo;
 
 @Required
 @Column(length = 7)
 private String placa;
 
 private boolean puedeCircular;
 
 @ManyToOne
 private Conductor conductor;
 
 @AssertTrue(message="{no_puede_circular}")
 private boolean isAptoParaCircular(){
     return driver == null || roadworthy;
 }
 
 //getters y setters...
}

no_puede_circular={tipo} de placa {placa} no es apto para circular. No se puede asignar al conductor {conductor.nombre}

Hibernate Validator (nuevo en v3.0.1)