pojobuilder
PojoBuilder 4.3.0
Autor: Michael Karneim
Página de inicio del proyecto: http://github.com/mkarneim/pojobuilder
El generador PojoBuilder es un procesador de anotaciones compatible con Java 6 que genera una clase de creación fluida para POJO (objeto Java antiguo simple).
El constructor generado proporciona
A continuación se muestra un ejemplo de cómo podría utilizar un generador de pojo generado a partir de su código:
Contact james = new ContactBuilder ()
. withSurname ( "Bond" )
. withFirstname ( "James" )
. withEmail ( "[email protected]" )
. build ();Los constructores son bastante útiles, por ejemplo, para crear datos de prueba, donde solo desea establecer las propiedades de datos relevantes.
Para más información sobre
El código fuente ubicado en el directorio "src" está en el DOMINIO PÚBLICO. Para obtener más información, lea el archivo COPIAR.
PojoBuilder es un generador de código puro. No agrega ninguna dependencia de tiempo de ejecución a su proyecto.
Sin embargo, PojoBuilder agrega la siguiente dependencia en tiempo de compilación a su proyecto, que tiene su propia licencia:
PojoBuilder es de código abierto. El código fuente está disponible en http://github.com/mkarneim/pojobuilder. Para versiones anteriores y un registro de cambios, consulte la página del historial de versiones.
Los binarios de PojoBuilder están disponibles para descargar en Sonatype OSS Maven Repository y Maven Central.
Si no utiliza ninguna herramienta de automatización de compilación que admita repositorios de Maven, es posible que desee descargar pojobuilder-4.3.0-jar-with-dependencies.jar para completar PojoBuilder con todas las bibliotecas dependientes incluidas.
El generador PojoBuilder utiliza un procesador de anotaciones para generar constructores de pojo. Tiene las siguientes opciones para activar la generación de código:
Para generar una clase constructora para un pojo, puede anotar uno de sus constructores con @GeneratePojoBuilder .
Echemos un vistazo al siguiente ejemplo de pojo:
public class Contact {
private final String surname ;
private final String firstname ;
private String email ;
@ GeneratePojoBuilder
public Contact ( String surname , String firstname ) {
this . surname = surname ;
this . firstname = firstname ;
}
public String getEmail () {
return email ;
}
public void setEmail ( String email ) {
this . email = email ;
}
public String getSurname () {
return surname ;
}
public String getFirstname () {
return firstname ;
}
} La anotación @GeneratePojoBuilder le dice al procesador de anotaciones que cree un nuevo archivo fuente Java con el nombre ContactBuilder . Eche un vistazo a ContactBuilder.java para ver el código fuente generado.
Tenga en cuenta que el constructor debe ser público o accesible de otro modo para el constructor generado; por ejemplo, si está protegido, el constructor generado debe residir en el mismo paquete.
Y también tenga en cuenta que los nombres de los parámetros del constructor deben coincidir exactamente con los nombres de las propiedades del pojo.
Se puede utilizar una anotación @ConstructorProperties opcional para especificar la asignación de los nombres de los parámetros del constructor a los nombres de las propiedades del bean correspondientes en el pojo si difieren.
public class Contact {
private final String surname ;
private final String firstname ;
private String email ;
@ GeneratePojoBuilder
@ ConstructorProperties ({ "surname" , "firstname" })
public Contact ( String arg1 , String arg2 ) {
this . surname = arg1 ;
this . firstname = arg2 ;
}
public String getEmail () {
return email ;
}
public void setEmail ( String email ) {
this . email = email ;
}
public String getSurname () {
return surname ;
}
public String getFirstname () {
return firstname ;
}
} Si su pojo no tiene constructor (o un constructor público predeterminado), puede anotar su clase con @GeneratePojoBuilder .
Echemos un vistazo al siguiente ejemplo de pojo:
@ GeneratePojoBuilder
public class User {
private String name ;
private char [] password ;
public String getName () {
return name ;
}
public void setName ( String name ) {
this . name = name ;
}
public char [] getPassword () {
return password ;
}
public void setPassword ( char [] password ) {
this . password = password ;
}
} Eche un vistazo a UserBuilder.java para ver el código fuente generado.
Alternativamente, si no tienes acceso al código fuente del pojo, o si no eres fanático de anotar un pojo, puedes anotar un método de fábrica:
public class UrlFactory {
@ GeneratePojoBuilder ( withName = "UrlBuilder" , intoPackage = "samples" )
public static URL createUrl (
String protocol , String host , int port , String file , URLStreamHandler handler )
throws MalformedURLException {
return new URL ( protocol , host , port , file , handler );
}
} Eche un vistazo a UrlBuilder.java para ver el código fuente generado.
Tenga en cuenta que el método de fábrica debe ser público y estático . Los nombres de los parámetros del método deben coincidir exactamente con los nombres de las propiedades del pojo.
Se puede utilizar una anotación @FactoryProperties opcional para especificar la asignación de los nombres de los parámetros del método de fábrica a los nombres de las propiedades del bean correspondientes en el pojo si difieren.
public class FileFactory {
@ GeneratePojoBuilder ( intoPackage = "samples" )
@ FactoryProperties ({ "path" })
public static File createFile ( String arg1 ) {
return new File ( arg1 );
}
} Eche un vistazo a FileBuilder.java para ver el código fuente generado.
A partir de PojoBuilder 4.3, puede anotar un tipo de registro Java 17:
@ GeneratePojoBuilder
public record MyRecord ( int x , int y , String blah ) {}Los siguientes elementos de @GeneratePojoBuilder se pueden utilizar para configurar la salida del proceso de generación de código.
Fluent*Builder se convertirá en FluentContactBuilder si el nombre del pojo es Contact . El patrón predeterminado es *Builder .Visibility.PUBLIC .*.util se convertirá en com.example.util si el paquete del pojo es com.example . El patrón predeterminado es * .Object.class .Address.java , Builder.java y AddressBuilder.java . El valor predeterminado es Void.class , lo que significa que no se debe implementar ninguna interfaz.Recipient.java , Builder.java y RecipientBuilder.java . El valor predeterminado es false .InputSourceFactory.java y InputSourceBuilder.java . El valor predeterminado es * .CalendarFactory.java y GregorianCalendarBuilder.java . El valor predeterminado es la matriz vacía.Player.java , PlayerBuilder.java y AbstractPlayerBuilder.java . El valor predeterminado es false .TextEmail.java y TextEmailBuilder.java . El valor predeterminado es false .com.google.common.base.Optional y java.util.Optional de Google Guava introducidos con Java 8. El valor predeterminado es Void.class , lo que significa que no se generan métodos de configuración basados en opciones.with* .validate que tenga un parámetro que sea compatible con el tipo de pojo. Si la validación falla, el método debe generar alguna excepción de tiempo de ejecución (o una de sus subclases). Para ver un ejemplo, consulte Credentials.java , CredentialsValidator.java y CredentialsBuilder.java .Task.java y TaskBuilder.java . El valor predeterminado es "" lo que significa que no se genera este método.A partir de la versión 3, PojoBuilder admite metaanotaciones . Es decir, puedes colocar @GeneratePojoBuilder en otra anotación y se heredará.
Las ventajas son:
El siguiente ejemplo define @AppPojo que se puede aplicar a nivel de clase y encapsula las anotaciones de tres fuentes diferentes (PojoBuilder, Lombok y JSR-305).
@ GeneratePojoBuilder ( withName = "Fluent*Builder" )
@ lombok . experimental . Value // class-level annotation from Lombok
@ javax . annotation . concurrent . Immutable // class-level annotation from JSR-305
@ Target ({ ElementType . TYPE , ElementType . ANNOTATION_TYPE })
public @interface AppPojo {
}Esto se puede colocar en cada uno de tus pojos:
@ AppPojo
public class Contact {
public String name ;
} PojoBuilder generará FluentContactBuilder en función de las directivas heredadas de la anotación @AppPojo .
Los valores predeterminados heredados de las metanotaciones se pueden anular mediante anotaciones @GeneratePojoBuilder más 'locales':
@ AppPojo
@ GeneratePojoBuilder ( intoPackage = "builder" )
public class Contact {
public String name ;
} Esto generará FluentContactBuilder como antes pero en el builder de paquetes.
La wiki de PojoBuilder proporciona un libro de recetas sobre el uso del Generador PojoBuilder, por ejemplo, para crear un lenguaje de dominio específico para pruebas automatizadas.
Para ver algunos ejemplos de código completos, consulte la carpeta src/testdata/java/samples.
Para ejecutar el procesador de anotaciones PojoBuilder, solo necesita colocarlo en la ruta de clase en tiempo de compilación. Durante el tiempo de ejecución no se requieren bibliotecas ya que la política de retención de las anotaciones de PojoBuilder es CLASS .
Aquí hay una lista de descripciones breves sobre cómo ejecutar PojoBuilder con
El compilador javac detectará automáticamente la presencia de PojoBuilder si pojobuilder-*.jar está incluido en el classpath.
Por ejemplo:
javac -cp pojobuilder-4.3.0-jar-with-dependencies.jar Contact.java
generará un ContactBuilder si Contact está anotado con @GeneratePojoBuilder .
Para obtener más información, consulte la documentación de javac.
Agregue lo siguiente al pom.xml de su proyecto para configurar el procesador de anotaciones PojoBuilder.
net.karneim
pojobuilder
4.3.0
provided
Notas:
${project.build.directory}/generated-sources/annotations .target , configure el generatedSourcesDirectory del maven-compiler-plugin . Vea el ejemplo de Maven pom para ver un ejemplo.Este es un pequeño script de compilación que muestra cómo ejecutar el procesador de anotaciones PojoBuilder con Gradle.
apply plugin : ' java '
repositories {
mavenCentral()
}
dependencies {
compile ' net.karneim:pojobuilder:4.3.0 '
}Tenga en cuenta que esto no solo agrega PojoBuilder y sus dependencias a su classpath en tiempo de compilación, sino también a su classpath en tiempo de ejecución.
Alternativamente, puede usar el siguiente script para agregar PojoBuilder solo a la ruta de clases en tiempo de compilación:
apply plugin : ' java '
repositories {
mavenCentral()
}
configurations {
codeGeneration
}
dependencies {
codeGeneration ' net.karneim:pojobuilder:4.3.0 '
compileOnly ' net.karneim:pojobuilder:4.3.0:annotations '
}
compileJava . classpath + = configurations . codeGeneration
compileTestJava . classpath + = configurations . codeGeneration En ambos casos, las fuentes generadas se colocarán en el directorio estándar build/classes .
Si desea colocarlos en otro lugar, simplemente especifique el destino de esta manera:
compileJava . options . compilerArgs + = [ ' -s ' , ' src/generated/java ' ]La wiki contiene un script Gradle extendido que distingue completamente entre tareas de generación y compilación de código.
Hay otro script de Gradle que habilita PojoBuilder para Eclipse IDE.
Con Gradle 5.0, ningún procesador de anotaciones en el classpath ya no se ejecuta. Para que pojobuilder vuelva a funcionar, reemplace el alcance de dependencia usado con annotationProcessor
dependencies {
annotationProcessor ' net.karneim:pojobuilder:4.3.0 '
} Aquí hay un fragmento de código de un script de compilación ANT de muestra que ejecuta el procesador de anotaciones PojoBuilder dentro de la tarea javac .
< fileset id = " libs.fileset " dir = " ${basedir}/lib " >
< include name = " *.jar " />
fileset >
< path id = " class.path " >
< fileset refid = " libs.fileset " />
path >
< target name = " compile " depends = " init "
description = " Compile java sources and run annotation processor " >
< mkdir dir = " ${src.gen.java.dir} " />
< mkdir dir = " ${build.classes.dir} " />
< javac classpathref = " class.path " destdir = " ${build.classes.dir} " >
< src path = " ${src.main.java.dir} " />
< compilerarg line = " -s ${src.gen.java.dir} " />
javac >
target > También puede configurar Eclipse para ejecutar el procesador de anotaciones PojoBuilder durante el ciclo de compilación. Se invocará cada vez que guarde archivos que contengan fuentes anotadas con @GeneratePojoBuilder .
Haga lo siguiente para habilitar PojoBuilder para su proyecto Eclipse:
pojobuilder-4.3.0-annotations.jar a la ruta de clase de su proyectopojobuiler-4.3.0-jar-with-dependencies.jarSi desea compilar las fuentes de este proyecto usted mismo, puede usar Gradle (consulte build.gradle).
