lotto di primavera con annotazione

Question

Sono nuovo al lotto di primavera, in cerca di qualche esempio sviluppato lotto di primavera con annotazione concetto.

Questo collegamento (click) parla del lotto di primavera, ma non batch di primavera con il concetto di annotazione. Come discusso nella documentazione di collegamento fornita non è chiaro. Sto usando l'ultimo framework di Spring. Voglio evitare la configurazione xml.

Il batch di Spring è uno strumento molto valido per l'elaborazione in batch? oppure È disponibile uno strumento migliore per l'elaborazione batch invece del lotto Spring?

Esiste qualche limite nel lotto di primavera?

Answer 1

Il batch di primavera supporta solo funzionalità limitate che è possibile configurare utilizzando le annotazioni. Principalmente questi sono callback listener, come @BeforeStep o @AfterChunk. L'utilizzo di queste annotazioni offre la possibilità di implementare interfacce corrispondenti o di utilizzare metodi annotati. Il bean annotato deve essere iniettato in lavoro, passaggio o blocco (reader, processor, writer, retry-policy, skip-policy o listeners) in configurazione XML, che non è possibile evitare.

Answer 2

Avere si guarda http://www.joshlong.com/jl/blogPost/java_configuration_with_spring_batch.html

Se è stato definito tutto l'oggetto "fagiolo" necessaria, nel metodo principale, si può semplicemente ottenere nel contesto applicativo.

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

Answer 3

ho usato seguenti tecnologie per questo esempio: primavera lotto 3.0.5.RELEASE,

JDK 1.7,

Eclipse Mars rilascio (4.5.0),

Maven 3.3 .3,

Springframework 4.0.5.ReLEASE.

Fase 1: creare semplici POJO, 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 + "]"; 
} 
} 

Fase 2: Creare classe 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; 
} 

} 

Fase 3: Creare classe 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; 
} 

} 

Fase 4: Creare classe 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); 

} 

} 

Passo 5: Creare 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> 

Passo 6: Creare lavoro.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>--> 

Passo 7: Infine creare 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()); 
     } 
} 

Ora lanciate sopra programma come applicazione Java, si vedrà l'output su console.

Per ulteriori dettagli, consultare http://manohark.com/simple-spring-batch-example-using-annotations/.

Answer 4

Si prega di dare un'occhiata al mio tutorial insieme con il repository github, forse sarà utile per voi.

Spring Batch come qualsiasi altro strumento ha una propria limitazione ma è comunque abbastanza flessibile. Lo sto utilizzando in un progetto reale con 1500 diversi lavori in esecuzione e penso che sia abbastanza buono e copre molti casi d'uso nelle applicazioni di elaborazione batch.

Answer 5

Ho affrontato lo stesso problema quando stavo leggendo le annotazioni sul lotto di primavera. Il posto migliore dove leggere le annotazioni Spring è la documentazione the reference. I concetti sono gli stessi per il batch, indipendentemente dal fatto che venga utilizzato XML o Java.

Vorrei suggerire la seguente procedura:

• studio sui concetti di batch
• cercare di rendere semplici applicazioni batch (la lettura da un database e il salvataggio in formato CSV)
• Una volta confortevole con i concetti di base, studiare da libri come Spring Batch Pro.
• Se si verifica un problema, cercare online il codice e quindi fare un riferimento incrociato con la suddetta documentazione Spring.