lote de primavera con la anotación

Question

soy nuevo en el lote de primavera, buscando algún ejemplo desarrollado lote de primavera con la anotación concepto.

Este enlace (click) habla de lotes de primavera, pero no surge por lotes con el concepto de anotación. Como se discutió en la documentación del enlace dado, no está claro. Estoy usando el último framework de Spring. Quiero evitar la configuración xml

¿El lote de muelles es una herramienta muy buena para el procesamiento por lotes? o ¿Hay mejores herramientas disponibles para el procesamiento por lotes en lugar del lote de Spring?

¿Hay alguna limitación en el lote de Spring?

Answer 1

El lote de primavera solo admite una funcionalidad limitada que puede configurar mediante anotaciones. Principalmente, estas son las devoluciones de llamada de los oyentes, como @BeforeStep o @AfterChunk. El uso de estas anotaciones le brinda la opción de implementar las interfaces correspondientes o utilizar métodos anotados. El bean anotado debe inyectarse en el trabajo, paso o fragmento (reader, processor, writer, retry-policy, skip-policy o listeners) en configuración XML, que no puede evitar.

Answer 2

Tener nos fijamos en http://www.joshlong.com/jl/blogPost/java_configuration_with_spring_batch.html

Si ha definido todo el objeto "frijol" necesario, en el procedimiento principal, se puede obtener sólo en el contexto de aplicación.

ApplicationContext ctx = new AnnotationConfigApplicationContext(MainConfig.class); 
job = (Job) ctx.getBean("SOME JOB"); 
jobLauncher = (JobLauncher) ctx.getBean("jobLauncher"); 
jobLauncher.run(job, jobParams); 

Answer 3

I utilizarse siguientes tecnologías para este ejemplo: primavera lote 3.0.5.RELEASE,

JDK 1.7,

Eclipse Marte Release (4.5.0),

Maven 3.3 .3,

Springframework 4.0.5.RESTA.

Paso 1: Crear POJO simple, Employee.java

public class Employee { 

private String name; 
private String empId; 
public String getName() { 
    return name; 
} 
public void setName(String name) { 
    this.name = name; 
} 
public String getEmpId() { 
    return empId; 
} 
public void setEmpId(String empId) { 
    this.empId = empId; 
} 
@Override 
public String toString() { 
    return "Employee [name=" + name + ", empId=" + empId + "]"; 
} 
} 

Paso 2: Crear clase java, ClassReader.java

package com.batch.main; 

import org.springframework.batch.item.ItemReader; 
import org.springframework.batch.item.NonTransientResourceException; 
import org.springframework.batch.item.ParseException; 
import org.springframework.batch.item.UnexpectedInputException; 
import org.springframework.context.annotation.Scope; 
import org.springframework.stereotype.Component; 
import com.batch.beans.Employee; 

@Component("classReader") 
public class ClassReader implements ItemReader<Employee> { 

@Override 
public Employee read() throws Exception, UnexpectedInputException,   ParseException, NonTransientResourceException { 

    Employee emp=new Employee(); 
    //Set values in Employee object 
    emp.setEmpId("123456"); 
    emp.setName("Manohar"); 
    System.out.println("Inside ClassReader..." + emp); 
    return emp; 
} 

} 

Paso 3: Crear clase java , ClassProcessor.java

package com.batch.main; 

import org.springframework.batch.item.ItemProcessor; 
import org.springframework.context.annotation.Scope; 
import org.springframework.stereotype.Component; 
import com.batch.beans.Employee; 

@Component("classProcesser") 
public class ClassProcessor implements ItemProcessor<Employee, Employee>{ 

@Override 
public Employee process(Employee emp) throws Exception { 
    System.out.println("Inside ClassProcessor..." + emp); 
    return emp; 
} 

} 

Paso 4: Crear clase java, ClassWriter.java

package com.batch.main; 

import java.util.List; 
import org.springframework.batch.item.ItemWriter; 
import org.springframework.context.annotation.Scope; 
import org.springframework.stereotype.Component; 
import com.batch.beans.Employee; 

@Component("classWriter") 
public class ClassWriter implements ItemWriter<Employee> { 

@Override 
public void write(List<? extends Employee> arg0) throws Exception { 

    System.out.println("Inside ClassWriter..." + arg0); 

} 

} 

Paso 5: Crear context.xml

<?xml version="1.0" encoding="UTF-8"?> 
<beans xmlns="http://www.springframework.org/schema/beans" 
xmlns:tx="http://www.springframework.org/schema/tx"    xmlns:context="http://www.springframework.org/schema/context" 
xmlns:jdbc="http://www.springframework.org/schema/jdbc" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
xsi:schemaLocation=" 
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd 
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd 
http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-3.0.xsd"> 

<bean id="transactionManager" 
class="org.springframework.batch.support.transaction. 
ResourcelessTransactionMana ger" /> 

<bean id="jobRepository" 
class="org.springframework.batch.core.repository.support. 
MapJobRepositoryFactoryBean"> 
<property name="transactionManager" ref="transactionManager" /> 
</bean> 

<bean id="jobLauncher" 
class="org.springframework.batch.core.launch.support.SimpleJobLauncher"> 
<property name="jobRepository" ref="jobRepository" /> 
</bean> 


</beans> 

Paso 6: Crear trabajo.xml

<?xml version="1.0" encoding="UTF-8"?> 
<beans xmlns="http://www.springframework.org/schema/beans" 
xmlns:batch="http://www.springframework.org/schema/batch"  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
xmlns:task="http://www.springframework.org/schema/task"  xmlns:tx="http://www.springframework.org/schema/tx" 
xmlns:context="http://www.springframework.org/schema/context" 
xmlns:util="http://www.springframework.org/schema/util"  xmlns:crypt="http://springcryptoutils.com/schema/crypt" 
xsi:schemaLocation=" 
http://www.springframework.org/schema/beans  http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 
http://www.springframework.org/schema/batch  http://www.springframework.org/schema/batch/spring-batch-3.0.xsd 
http://www.springframework.org/schema/tx  http://www.springframework.org/schema/tx/spring-tx-3.0.xsd 
http://www.springframework.org/schema/context  http://www.springframework.org/schema/context/spring-context-3.0.xsd 
http://www.springframework.org/schema/util  http://www.springframework.org/schema/util/spring-util-3.0.xsd 
http://springcryptoutils.com/schema/crypt  http://springcryptoutils.com/schema/crypt.xsd 
http://www.springframework.org/schema/task  http://www.springframework.org/schema/task/spring-task-3.2.xsd"> 

<import resource="/context.xml" /> 

<context:component-scan base-package="com.batch" /> 

<batch:job id="loadJob" xmlns="http://www.springframework.org/schema/batch"> 
    <batch:step id="step1" > 
    <batch:tasklet> 
    <batch:chunk reader="classReader" writer="classWriter" 
    processor="classProcesser" commit-interval="1" /> 
    </batch:tasklet> 
    </batch:step> 
</batch:job> 

<!-- <bean id="classReader" class="com.batch.main.ClassReader" > 

</bean> 

<bean id="classWriter" class="com.batch.main.ClassWriter" ></bean> 

<bean id="classProcesser" class="com.batch.main.ClassProcessor" > </bean>--> 

Paso 7: Finalmente crear Main.java

package com.batch.main; 

import org.springframework.batch.core.Job; 
import org.springframework.batch.core.JobExecution; 
import org.springframework.batch.core.JobParameters; 
import org.springframework.batch.core.JobParametersInvalidException; 
import org.springframework.batch.core.launch.JobLauncher; 
import  org.springframework.batch.core.repository.JobExecutionAlreadyRunningException; 
import  org.springframework.batch.core.repository.JobInstanceAlreadyCompleteException; 
import org.springframework.batch.core.repository.JobRestartException; 
import  org.springframework.context.annotation.AnnotationConfigApplicationContext; 
import org.springframework.context.annotation.Configuration; 
import org.springframework.context.annotation.ImportResource; 


@Configuration 
@ImportResource({"classpath:/com/spring/job/job.xml"})//load configuration  file from classpath 
public class Main { 

public static void main(String[] args) throws    JobExecutionAlreadyRunningException, 
JobRestartException,   
JobInstanceAlreadyCompleteException, JobParametersInvalidException { 
@SuppressWarnings("resource") 
AnnotationConfigApplicationContext context = new    AnnotationConfigApplicationContext(); 
    context.register(Main.class); 
    context.refresh(); 
    //load jobLauncher details from context.xml file 
     JobLauncher jobLauncher = (JobLauncher) context.getBean("jobLauncher"); 
     //load Job details from job.xml file 
     Job job = (Job) context.getBean("loadJob"); 
     //run job 
     JobExecution execution = jobLauncher.run(job, new JobParameters()); 
     System.out.println("Exit Status : " + execution.getStatus()); 
     } 
} 

Ahora corre por encima de programa como aplicación Java, verá la salida en la consola.

Consulte http://manohark.com/simple-spring-batch-example-using-annotations/ para obtener detalles completos.

Answer 4

Mire mi tutorial junto con el repositorio github, quizás le sea útil.

Spring Batch como cualquier otra herramienta tiene su propia limitación, pero aún así es bastante flexible. Lo estoy usando en un proyecto real con 1500 trabajos diferentes en ejecución y creo que es bastante bueno y cubre una gran cantidad de casos de uso en las aplicaciones de procesamiento por lotes.

Answer 5

Me enfrenté al mismo problema cuando estaba leyendo acerca de las anotaciones de Spring Batch. El mejor lugar donde puede leer sobre las anotaciones de Spring es la documentación de the reference. Los conceptos son los mismos para el lote, ya sea que se use XML o Java.

Yo sugeriría siguiendo estos pasos:

• Estudio sobre los conceptos de lote
• tratar de hacer que las aplicaciones por lotes simples (lectura de una base de datos y guardar en CSV)
• Una vez cómodo con los conceptos básicos, estudio de libros como Spring Batch Pro.
• Si encuentra un problema, busque el código en línea y luego haga una referencia cruzada con la documentación de Spring antes mencionada.