dozerbeanmapper - java beans example
¿Alternativas JavaBeans? (11)
Mira mis anotaciones de Bean en
http://code.google.com/p/javadude/wiki/Annotations
Básicamente haces cosas como:
@Bean(
properties={
@Property(name="name"),
@Property(name="phone", bound=true),
@Property(name="friend", type=Person.class, kind=PropertyKind.LIST)
}
)
public class Person extends PersonGen {}
en lugar de definir todos esos métodos extra get / set, etc.
Hay otros atributos para definir equals / hashCode, observadores, delegados, mixins, etc.
Es un conjunto de anotaciones y un procesador de anotaciones que se ejecuta en eclipse o en una compilación de línea de comandos (por ejemplo, en hormiga). El procesador genera una superclase para contener todo el código generado (los procesadores de anotación no pueden cambiar la clase que contiene las anotaciones, por cierto)
Odio el patrón de JavaBeans con una pasión que arde como el fuego de mil soles. ¿Por qué?
- Verbose Es 2009. No debería tener que escribir 7 LOC para una propiedad. Si tienen oyentes de eventos, aferra tu sombrero.
- No hay referencias de tipo seguro . No hay una forma segura de tipo para hacer referencia a una propiedad. El objetivo de Java es que es seguro y su patrón más popular no es en absoluto seguro.
Lo que me gustaría es algo así como:
class Customer {
public Property<String> name = new Property();
}
Principalmente soy desarrollador web, por lo que necesito el soporte de JPA y Wicket.
¡Ayúdenme a bajar del tren javabean!
Es posible que desee comprobar Groovy - un lenguaje de tipo dinámico, basado en JVM (y completamente compatible con Java) con propiedades "reales".
También puedes construir un generador de código que crea tus clases .java desde una DSL que escribes. Podría tener algún tipo de marcado que describa el nombre de su clase, las propiedades que desea y sus tipos. Luego, procese ese archivo con un programa que genere sus JavaBeans. O puede usar la anotación y postprocesar los archivos de clase usando algo como ASM para inyectar los accessors y mutators. También creo que Spring ofrece algunas de estas características, pero no las he usado.
Creo que estás muy cerca con la declaración que tienes allí (mira abajo un boceto). Sin embargo, al utilizar un enfoque que no sea frijoles, es probable que pierda el soporte proporcionado por la mayoría de las herramientas que asumen que el protocolo JavaBeans está en vigencia. Por favor se amable. El siguiente código está fuera de mi cabeza ...
public class Property<T> {
public final String name;
T value;
private final PropertyChangeSupport support;
public static <T> Property<T> newInstance(String name, T value,
PropertyChangeSupport support) {
return new Property<T>(name, value, support);
}
public static <T> Property<T> newInstance(String name, T value) {
return newInstance(name, value, null);
}
public Property(String name, T value, PropertyChangeSupport support) {
this.name = name;
this.value = value;
this.support = support;
}
public T getValue() { return value; }
public void setValue(T value) {
T old = this.value;
this.value = value;
if(support != null)
support.firePropertyChange(name, old, this.value);
}
public String toString() { return value.toString(); }
}
y luego seguir y usarlo:
public class Customer {
private final PropertyChangeSupport support = new PropertyChangeSupport();
public final Property<String> name = Property.newInstance("name", "", support);
public final Property<Integer> age = Property.newInstance("age", 0, support);
... declare add/remove listenener ...
}
Customer c = new Customer();
c.name.setValue("Hyrum");
c.age.setValue(49);
System.out.println("%s : %s", c.name, c.age);
Por lo tanto, ahora declarar una propiedad es una sola línea de código y se incluye soporte de cambio de propiedad. Llamé a los métodos setValue () y getValue () por lo que todavía se vería como un bean codificar como Rhino y esas cosas, pero para ser sucintos, podrías agregar simplemente get () y set (). El resto queda como ejercicio para el lector:
- Manejar adecuadamente la serialización
- Manejar una comprobación de valor nulo
- Tal vez agregue una especialización para tipos atómicos si le importa la sobrecarga de autoboxing.
- ?? Estoy seguro de que hay más errores
También tenga en cuenta que puede subclase (generalmente como una clase anónima) y anular setValue () para proporcionar una verificación de parámetros adicional.
No creo que puedas alejarte de las "referencias de cadenas" ya que de eso se trata bastante el reflejo.
Lamentablemente, en este día y edad, esto todavía es como programar en ensamble ... Groovy, C #, etc., etc. aún pueden ser una mejor opción, si puedes elegir.
Prueba el framework SEAM de JBoss, te gustará.
Una vez que probé esto:
interface IListenable {
void addPropertyChangeListener( PropertyChangeListener listener );
void removePropertyChangeListener( PropertyChangeListener listener );
}
abstract class MyBean extends IListenable {
public abstract void setName(String name);
public abstract String getName();
// more things
}
public class JavaBeanFactory {
public <T> Class<T> generate(Class<T> clazz) {
// I used here CGLIB to generate dynamically a class that implements the methods:
// getters
// setters
// addPropertyChangeListener
// removePropertyChangeListener
}
}
Lo usé como esto (es solo un ejemplo):
public class Foo {
@Inject
public Provider<MyBean> myBeanProvider;
public MyBean createHook(MyBean a) {
final MyBean b = myBeanProvider.get();
a.addPropertyChangeListener(new PropertyChangeListener() {
public void propertyChange(PropertyChangeEvent evt) {
b.setName((String) evt.getNewValue());
}
});
return b;
}
}
Use el marco de primavera. Su propósito es simplificar el desarrollo de Java al abstraer mucho de la base sobre la que te quejas.
Puede usarlo con Hibernate para facilitar la interacción con las fuentes de datos.
Sitios útiles:
www.springsource.org/download
www.hibernate.org/
Cuando utilicé C # las primeras veces, me gustaron las propiedades, pero ahora, después de un tiempo utilizándolas con VS 2008, debo decir que prefiero los métodos set / get.
El punto principal es mi forma personal de trabajar. Cuando tengo una nueva clase y me gustaría saber qué puedo hacer con ella, simplemente escribo classname.set y Eclipse me muestra qué "propiedades" puedo cambiar. Lo mismo ocurre con get. Tal vez es solo la forma de los pobres VS, pero ahí tengo que buscar en una larga lista de itelisense (donde todo está mezclado, en vez de mostrar propiedades primero) solo para descubrir después de compilar que la propiedad que quería establecer es de solo lectura. .. ¡Dios!
Sí, en Java necesitas muchas líneas, pero solo escribo mis atributos y le digo al IDE "por favor crea getters y setters para mí". Pero esos métodos tienden a usar mucho espacio, por eso también me gustaría tener regiones en Java que puedan doblarse en el IDE.
Utilizo mucho las propiedades de JavaBean en mis entidades modelo (anotadas con JPA) para poder enlazarlas a una UI (con JFace).
Desafortunadamente no tengo una solución para el segundo problema (tal vez excepto para definir las constantes que contienen los nombres de las propiedades).
Lo que hago para generar el texto repetitivo del oyente es hacer que mis entidades modelo se extiendan desde una superclase AbstractJavaBean que lo maneja mediante la reflexión. Entonces puedo usar la forma predeterminada de crear getters / setters, excepto que los setters necesitan ser reescritos como:
public void setRemarks(String remarks) {
set("remarks", remarks);
}
AbstractJavaBean.set utiliza el reflejo (mediante beanutils de Apache commons) para leer el valor anterior de la propiedad "observaciones" a través de su getter, establece el nuevo valor en un campo llamado "observaciones" y desencadena un evento de cambio de propiedad utilizando los valores antiguos y nuevos . De hecho, esta idea se puede ampliar para permitir que las propiedades dependientes "derivadas" automáticamente activen los cambios de propiedad cuando una de las propiedades se basa en cambios como "edad" que se cambian cuando se cambia la propiedad "fecha de nacimiento". Toda esta lógica puede codificarse en un lugar dentro de AbstractJavaBean y ser usada por cualquier objeto modelo.
Estaba buscando lo mismo y realmente me sorprendió que no pudiera encontrar una biblioteca adecuada. Desde que sentí el dolor con regularidad comencé un pequeño proyecto que aborda estos problemas hace 2 años: Propertly
Está disponible en: https://github.com/aditosoftware/propertly . Lo estamos utilizando en nuestro producto ahora.
Da tipado estático con genéricos, oyentes en diferentes niveles, navegación por el árbol, modelos dinámicos y más. Las principales ventajas son que las descripciones de los modelos se realizan de forma estática, por lo que la información está siempre disponible y está diseñada teniendo en cuenta la extensibilidad. Así que puede, por ejemplo, usar sus propias anotaciones para la verificación o definir dónde se leen y almacenan los datos.
Ejemplo de uso:
Un simple IPropertyPitProvider. Las propiedades son primer nombre, apellido y edad.
// Generics describe parent, self and children
public class StudentPropertyPitProvider
extends AbstractPPP<IPropertyPitProvider, StudentPropertyPitProvider, Object>
{
// IPropertyDescription gives static access to an IProperty''s meta data like name and type.
public static final IPropertyDescription<StudentPropertyPitProvider, String> FIRST_NAME =
PD.create(StudentPropertyPitProvider.class);
public static final IPropertyDescription<StudentPropertyPitProvider, String> LAST_NAME =
PD.create(StudentPropertyPitProvider.class);
public static final IPropertyDescription<StudentPropertyPitProvider, Integer> AGE =
PD.create(StudentPropertyPitProvider.class);
// Getters and setters can of course still be used for easier access.
public String getFirstName()
{
// getValue and setValue is available at AbstractPPP. That class is used for easier access.
// Propertly can be used without inheriting from that class, too.
return getValue(FIRST_NAME);
}
public void setFirstName(String pFirstName)
{
setValue(FIRST_NAME, pFirstName);
}
public String getLastName()
{
return getValue(LAST_NAME);
}
public void setLastName(String pLastName)
{
setValue(LAST_NAME, pLastName);
}
public Integer getAge()
{
return getValue(AGE);
}
public void setAge(Integer pAge)
{
setValue(AGE, pAge);
}
}
Usando el proveedor definido:
public class Sample
{
public static void main(String[] args)
{
// Hierarchy is necessary to initialize the IPropertyPitProviders and for advanced features.
Hierarchy<StudentPropertyPitProvider> hierarchy =
new Hierarchy<>("student1", new StudentPropertyPitProvider());
// The created student can be accessed from the hierarchy.
StudentPropertyPitProvider student = hierarchy.getValue();
// Listeners can be added.
student.addPropertyEventListener(new PropertyPitEventAdapter()
{
@Override
public void propertyChanged(IProperty pProperty, Object pOldValue, Object pNewValue)
{
System.out.println(pProperty.getName() + "=" + pNewValue);
}
});
// The following calls will cause
// FIRST_NAME=Nils
// LAST_NAME=Holgersson
// AGE=32
// to be printed on console through the listener.
student.setFirstName("Nils");
student.setLastName("Holgersson");
student.setAge(32);
}
}