Spring Batch无法打开JPA EntityManager进行事务处理; 嵌套异常是java.lang.IllegalStateException：事务已处于活动状态

Question

My Spring Batch job is started every 5 minutes - basically it reads a string, uses the string as a parameter in a sql query, and prints out the resulting sql result list. Mostly it seems to be running ok, but I notice sporadic errors in my logs every 5-10 runs

2017-05-05 11:13:26.101  INFO 9572 --- [nio-8081-exec-8] c.u.r.s.AgentCollectorServiceImpl    : Could not open JPA E
ntityManager for transaction; nested exception is java.lang.IllegalStateException: Transaction already active

My job is started like from my AgentCollectorServiceImpl class

@Override
public void addReportIds(List<Integer> reportIds) {
    try {
            .toJobParameters();
        jobLauncher.run(job, jobParameters);
    } catch (Exception e) {
        log.info(e.getMessage());
    }
}

My BatchConfig class looks like

@Configuration
@EnableBatchProcessing
@Import(AppConfig.class)
public class BatchConfig {

    @Autowired
    private JobBuilderFactory jobBuilderFactory;

    @Autowired
    private StepBuilderFactory stepBuilderFactory;

    @Autowired
    private AppConfig appConfig;

    @Bean
    public Reader reader() {
        return new Reader();
    }

    @Bean
    public Processor processor() {
        return new Processor();
    }

    @Bean
    public Writer writer() {
        return new Writer();
    }

    @Bean
    public Job job() {
        return jobBuilderFactory.get("job")
            .incrementer(new RunIdIncrementer())
            .flow(step1())
            .end()
            .build();
    }

    @Bean
    public Step step1() {
        return stepBuilderFactory.get("step1")
            .<String, String> chunk(1)
            .reader(reader())
            .processor(processor())
            .writer(writer())
            .build();
    }
}

My AppConfig class looks like

@Configuration
@PropertySource("classpath:application.properties")
@ComponentScan
public class AppConfig {


    @Bean
    public LocalContainerEntityManagerFactoryBean entityManagerFactory() {
        LocalContainerEntityManagerFactoryBean em = new LocalContainerEntityManagerFactoryBean();
        em.setDataSource(organizationDataSource());
        em.setPackagesToScan(new String[]{"com.organization.agentcollector.model"});
        JpaVendorAdapter vendorAdapter = new HibernateJpaVendorAdapter();
        em.setJpaVendorAdapter(vendorAdapter);
        em.setJpaProperties(additionalProperties());

        return em;
    }

    Properties additionalProperties() {
        Properties properties = new Properties();
        properties.setProperty("hibernate.dialect", "com.organization.agentcollector.config.SQLServerDialectOverrider");
        return properties;
    }
    @Bean
    JpaTransactionManager transactionManager(final EntityManagerFactory emf) {
        JpaTransactionManager transactionManager = new JpaTransactionManager();
        transactionManager.setEntityManagerFactory(entityManagerFactory().getObject());
        return transactionManager;
    }

My Processor class looks like

public class Processor implements ItemProcessor<String, String> {

    private final Logger log = LoggerFactory.getLogger(Processor.class);

    @Autowired
    EventReportsDAOImpl eventReportsDAOImpl;

    @Override
    public String process(String reportIdsJson) throws Exception {

        String eventReportsJson = eventReportsDAOImpl.listEventReportsInJsonRequest(reportIdsJson);
        //System.out.println(returnContent+"PROCESSOR");
        return eventReportsJson;
    }

}

My DAOImpl class looks like

@Component
@Transactional
public class EventReportsDAOImpl implements EventReportsDAO {

    @PersistenceContext
    private EntityManager em;

    @Override
    public EventReports getEventReports(Integer reportId) {
        return null;
    }

    @Override
    public String listEventReportsInJsonRequest(String reportIds) {

        System.out.println("Event Report reportIds processing");
        ArrayList<EventReports> erArr = new ArrayList<EventReports>();
        String reportIdsList = reportIds.substring(1, reportIds.length() - 1);
        //System.out.println(reportIdsList);

        try {
            StoredProcedureQuery q = em.createStoredProcedureQuery("sp_get_event_reports", "eventReportsResult");
            q.registerStoredProcedureParameter("reportIds", String.class, ParameterMode.IN);
            q.setParameter("reportIds", reportIdsList);
            boolean isResultSet = q.execute();  
            erArr = (ArrayList<EventReports>) q.getResultList();
        } catch (Exception e) {
            System.out.println("No event reports found for list " + reportIdsList);
        }

        return erArr.toString();
    }

I thought Spring would manage transactions automatically. The error seems to suggest that a transaction is not being properly closed?

One thing I tried was removing all @Transactional annotations from my code as I read that @EnableBatchProcessing already injects a Transaction Manager into each step - but when I did this, I saw the 'transaction already active' error much more frequently.

Any advice appreciated on how to fix this, thank you!

Answer 1

The @Transactional notation establishes a transactional scope that dictates when a transaction starts and ends, also called its boundary. If you operate outside of this boundary you'll receive errors.

First off, I found this bit of documentation the most helpful on Spring transactions: http://docs.spring.io/spring-framework/docs/4.2.x/spring-framework-reference/html/transaction.html specifically this section

Secondly, you may wish to enable trace level logs and potentially the SQL statements to help debug this. In order to do so I added the following to my application.properties :

spring.jpa.properties.hibernate.show_sql=false
spring.jpa.properties.hibernate.use_sql_comments=true
spring.jpa.properties.hibernate.format_sql=true
spring.jpa.properties.hibernate.type=trace
spring.jpa.show-sql=true
logging.level.org.hibernate=TRACE

There will be ALOT of output here, but you'll get a good idea of whats happening behind the scenes.

Third, and the most important part for me in learning how to use @Transactional is that every call to the DAO creates a new session -or- reuses the existing session if within the same transactional scope. Refer to the documentation above for examples of this.