Mon travail principal ne lit que les opérations et l’autre écrit, mais sur MyISAM engine
, qui ignore les transactions. Par conséquent, je n’exigerais pas nécessairement de prise en charge des transactions. Comment puis-je configurer Spring Batch
pour avoir sa propre source de données pour la JobRepository
, distincte de celle contenant les données de l'entreprise? La configuration initiale de la source de données se fait comme suit:
@Configuration
public class StandaloneInfrastructureConfiguration {
@Autowired
Environment env;
@Bean
public LocalContainerEntityManagerFactoryBean entityManagerFactory() {
LocalContainerEntityManagerFactoryBean em = new LocalContainerEntityManagerFactoryBean();
em.setDataSource(dataSource());
em.setPackagesToScan(new String[] { "org.podcastpedia.batch.*" });
JpaVendorAdapter vendorAdapter = new HibernateJpaVendorAdapter();
em.setJpaVendorAdapter(vendorAdapter);
em.setJpaProperties(additionalJpaProperties());
return em;
}
Properties additionalJpaProperties() {
Properties properties = new Properties();
properties.setProperty("hibernate.hbm2ddl.auto", "none");
properties.setProperty("hibernate.dialect", "org.hibernate.dialect.MySQL5Dialect");
properties.setProperty("hibernate.show_sql", "true");
return properties;
}
@Bean
public DataSource dataSource(){
return DataSourceBuilder.create()
.url(env.getProperty("db.url"))
.driverClassName(env.getProperty("db.driver"))
.username(env.getProperty("db.username"))
.password(env.getProperty("db.password"))
.build();
}
@Bean
public PlatformTransactionManager transactionManager(EntityManagerFactory emf){
JpaTransactionManager transactionManager = new JpaTransactionManager();
transactionManager.setEntityManagerFactory(emf);
return transactionManager;
}
}
et ensuite, il est importé dans la classe de configuration de la Job
où l'annotation @EnableBatchProcessing
l'utilise automatiquement. Ma pensée initiale était d’essayer de définir la classe de configuration pour étendre la DefaultBatchConfigurer
, mais j’obtiens un
BeanCurrentlyInCreationException (org.springframework.beans.factory.BeanCurrentlyInCreationException: erreur lors de la création du bean avec le nom jobBuilders: le bean demandé est actuellement en cours de création: existe-t-il une référence circulaire insoluble?):
@Configuration
@EnableBatchProcessing
@Import({StandaloneInfrastructureConfiguration.class, NotifySubscribersServicesConfiguration.class})
public class NotifySubscribersJobConfiguration extends DefaultBatchConfigurer {
@Autowired
private JobBuilderFactory jobBuilders;
@Autowired
private StepBuilderFactory stepBuilders;
@Autowired
private DataSource dataSource;
@Autowired
Environment env;
@Override
@Autowired
public void setDataSource(javax.sql.DataSource dataSource) {
super.setDataSource(batchDataSource());
}
private DataSource batchDataSource(){
return DataSourceBuilder.create()
.url(env.getProperty("batchdb.url"))
.driverClassName(env.getProperty("batchdb.driver"))
.username(env.getProperty("batchdb.username"))
.password(env.getProperty("batchdb.password"))
.build();
}
@Bean
public ItemReader<User> notifySubscribersReader(){
JdbcCursorItemReader<User> reader = new JdbcCursorItemReader<User>();
String sql = "select * from users where is_email_subscriber is not null";
reader.setSql(sql);
reader.setDataSource(dataSource);
reader.setRowMapper(rowMapper());
return reader;
}
........
}
Toutes les pensées sont plus que bienvenues. Le projet est disponible sur GitHub - https://github.com/podcastpedia/podcastpedia-batch
Merci beaucoup.
Ok, c'est étrange mais ça marche. Déplacer les sources de données vers sa propre classe de configuration fonctionne parfaitement et on est capable de filer automatiquement.
L'exemple est une version multi-sources de données de Exemple de service Spring Batch :
DataSourceConfiguration:
public class DataSourceConfiguration {
@Value("classpath:schema-mysql.sql")
private Resource schemaScript;
@Bean
@Primary
public DataSource hsqldbDataSource() throws SQLException {
final SimpleDriverDataSource dataSource = new SimpleDriverDataSource();
dataSource.setDriver(new org.hsqldb.jdbcDriver());
dataSource.setUrl("jdbc:hsqldb:mem:mydb");
dataSource.setUsername("sa");
dataSource.setPassword("");
return dataSource;
}
@Bean
public JdbcTemplate jdbcTemplate(final DataSource dataSource) {
return new JdbcTemplate(dataSource);
}
@Bean
public DataSource mysqlDataSource() throws SQLException {
final SimpleDriverDataSource dataSource = new SimpleDriverDataSource();
dataSource.setDriver(new com.mysql.jdbc.Driver());
dataSource.setUrl("jdbc:mysql://localhost/spring_batch_example");
dataSource.setUsername("test");
dataSource.setPassword("test");
DatabasePopulatorUtils.execute(databasePopulator(), dataSource);
return dataSource;
}
@Bean
public JdbcTemplate mysqlJdbcTemplate(@Qualifier("mysqlDataSource") final DataSource dataSource) {
return new JdbcTemplate(dataSource);
}
private DatabasePopulator databasePopulator() {
final ResourceDatabasePopulator populator = new ResourceDatabasePopulator();
populator.addScript(schemaScript);
return populator;
}
}
BatchConfiguration:
@Configuration
@EnableBatchProcessing
@Import({ DataSourceConfiguration.class, MBeanExporterConfig.class })
public class BatchConfiguration {
@Autowired
private JobBuilderFactory jobs;
@Autowired
private StepBuilderFactory steps;
@Bean
public ItemReader<Person> reader() {
final FlatFileItemReader<Person> reader = new FlatFileItemReader<Person>();
reader.setResource(new ClassPathResource("sample-data.csv"));
reader.setLineMapper(new DefaultLineMapper<Person>() {
{
setLineTokenizer(new DelimitedLineTokenizer() {
{
setNames(new String[] { "firstName", "lastName" });
}
});
setFieldSetMapper(new BeanWrapperFieldSetMapper<Person>() {
{
setTargetType(Person.class);
}
});
}
});
return reader;
}
@Bean
public ItemProcessor<Person, Person> processor() {
return new PersonItemProcessor();
}
@Bean
public ItemWriter<Person> writer(@Qualifier("mysqlDataSource") final DataSource dataSource) {
final JdbcBatchItemWriter<Person> writer = new JdbcBatchItemWriter<Person>();
writer.setItemSqlParameterSourceProvider(new BeanPropertyItemSqlParameterSourceProvider<Person>());
writer.setSql("INSERT INTO people (first_name, last_name) VALUES (:firstName, :lastName)");
writer.setDataSource(dataSource);
return writer;
}
@Bean
public Job importUserJob(final Step s1) {
return jobs.get("importUserJob").incrementer(new RunIdIncrementer()).flow(s1).end().build();
}
@Bean
public Step step1(final ItemReader<Person> reader,
final ItemWriter<Person> writer, final ItemProcessor<Person, Person> processor) {
return steps.get("step1")
.<Person, Person> chunk(1)
.reader(reader)
.processor(processor)
.writer(writer)
.build();
}
}
J'ai mes sources de données dans une classe de configuration séparée. Dans la configuration par lots, nous étendons DefaultBatchConfigurer et remplaçons la méthode setDataSource, en transmettant la base de données spécifique à utiliser avec Spring Batch avec un @Qualifier. Je ne pouvais pas obtenir que cela fonctionne avec la version constructeur, mais la méthode setter fonctionnait pour moi.
Mes lecteurs, processeurs et écrivains sont dans leurs propres classes, avec les étapes.
Ceci utilise Spring Boot 1.1.8 et Spring Batch 3.0.1.Remarque:Nous avions une configuration différente pour un projet utilisant Spring Boot 1.1.5 qui ne fonctionnait pas de la même manière sur la nouvelle version.
package org.sample.config.jdbc;
import javax.sql.DataSource;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.core.env.Environment;
import com.atomikos.jdbc.AtomikosDataSourceBean;
import com.mysql.jdbc.jdbc2.optional.MysqlXADataSource;
/**
* The Class DataSourceConfiguration.
*
*/
@Configuration
public class DataSourceConfig {
private final static Logger log = LoggerFactory.getLogger(DataSourceConfig.class);
@Autowired private Environment env;
/**
* Siphon data source.
*
* @return the data source
*/
@Bean(name = "mainDataSource")
@Primary
public DataSource mainDataSource() {
final String user = this.env.getProperty("db.main.username");
final String password = this.env.getProperty("db.main.password");
final String url = this.env.getProperty("db.main.url");
return this.getMysqlXADataSource(url, user, password);
}
/**
* Batch data source.
*
* @return the data source
*/
@Bean(name = "batchDataSource", initMethod = "init", destroyMethod = "close")
public DataSource batchDataSource() {
final String user = this.env.getProperty("db.batch.username");
final String password = this.env.getProperty("db.batch.password");
final String url = this.env.getProperty("db.batch.url");
return this.getAtomikosDataSource("metaDataSource", this.getMysqlXADataSource(url, user, password));
}
/**
* Gets the mysql xa data source.
*
* @param url the url
* @param user the user
* @param password the password
* @return the mysql xa data source
*/
private MysqlXADataSource getMysqlXADataSource(final String url, final String user, final String password) {
final MysqlXADataSource mysql = new MysqlXADataSource();
mysql.setUser(user);
mysql.setPassword(password);
mysql.setUrl(url);
mysql.setPinGlobalTxToPhysicalConnection(true);
return mysql;
}
/**
* Gets the atomikos data source.
*
* @param resourceName the resource name
* @param xaDataSource the xa data source
* @return the atomikos data source
*/
private AtomikosDataSourceBean getAtomikosDataSource(final String resourceName, final MysqlXADataSource xaDataSource) {
final AtomikosDataSourceBean atomikos = new AtomikosDataSourceBean();
atomikos.setUniqueResourceName(resourceName);
atomikos.setXaDataSource(xaDataSource);
atomikos.setMaxLifetime(3600);
atomikos.setMinPoolSize(2);
atomikos.setMaxPoolSize(10);
return atomikos;
}
}
package org.sample.settlement.batch;
import javax.sql.DataSource;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.batch.core.Job;
import org.springframework.batch.core.Step;
import org.springframework.batch.core.configuration.annotation.DefaultBatchConfigurer;
import org.springframework.batch.core.configuration.annotation.EnableBatchProcessing;
import org.springframework.batch.core.configuration.annotation.JobBuilderFactory;
import org.springframework.batch.core.configuration.annotation.StepBuilderFactory;
import org.springframework.batch.core.launch.support.RunIdIncrementer;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.transaction.PlatformTransactionManager;
/**
* The Class BatchConfiguration.
*
*/
@Configuration
@EnableBatchProcessing
public class BatchConfiguration extends DefaultBatchConfigurer {
private final static Logger log = LoggerFactory.getLogger(BatchConfiguration.class);
@Autowired private JobBuilderFactory jobs;
@Autowired private StepBuilderFactory steps;
@Autowired private PlatformTransactionManager transactionManager;
@Autowired @Qualifier("processStep") private Step processStep;
/**
* Process payments job.
*
* @return the job
*/
@Bean(name = "processJob")
public Job processJob() {
return this.jobs.get("processJob")
.incrementer(new RunIdIncrementer())
.start(processStep)
.build();
}
@Override
@Autowired
public void setDataSource(@Qualifier("batchDataSource") DataSource batchDataSource) {
super.setDataSource(batchDataSource);
}
}
Avez-vous déjà essayé quelque chose comme ça?
@Bean(name="batchDataSource")
public DataSource batchDataSource(){
return DataSourceBuilder.create()
.url(env.getProperty("batchdb.url"))
.driverClassName(env.getProperty("batchdb.driver"))
.username(env.getProperty("batchdb.username"))
.password(env.getProperty("batchdb.password"))
.build();
}
puis marquez l'autre source de données avec un @Primary et utilisez un @Qualifier dans votre configuration de lot pour indiquer que vous souhaitez autoriser le bean batchDataSource.
Per https://docs.spring.io/spring-boot/docs/current/reference/htmlsingle/#howto-two-datasources :
@Bean
@Primary
@ConfigurationProperties("app.datasource.first")
public DataSourceProperties firstDataSourceProperties() {
return new DataSourceProperties();
}
@Bean
@Primary
@ConfigurationProperties("app.datasource.first")
public DataSource firstDataSource() {
return firstDataSourceProperties().initializeDataSourceBuilder().build();
}
@Bean
@ConfigurationProperties("app.datasource.second")
public DataSourceProperties secondDataSourceProperties() {
return new DataSourceProperties();
}
@Bean
@ConfigurationProperties("app.datasource.second")
public DataSource secondDataSource() {
return secondDataSourceProperties().initializeDataSourceBuilder().build();
}
Dans les propriétés de l'application, vous pouvez utiliser des propriétés de source de données standard:
app.datasource.first.type=com.zaxxer.hikari.HikariDataSource
app.datasource.first.maximum-pool-size=30
app.datasource.second.url=jdbc:mysql://localhost/test
app.datasource.second.username=dbuser
app.datasource.second.password=dbpass
app.datasource.second.max-total=30
En supposant que vous disposiez de 2 sources de données, une pour les métadonnées de lot de ressort, telles que les détails du travail [disons CONFIGDB] et l’autre pour vos données d’entreprise [disons AppDB]:
Injectez CONFIGDB dans jobRepository, comme ceci:
<bean id="jobRepository"
class="org.springframework.batch.core.repository.support.JobRepositoryFactoryBean">
<property name="transactionManager" ref="transactionManager" />
<property name="dataSource" ref="CONFIGDB" />
<property name="databaseType" value="db2" />
<property name="tablePrefix" value="CONFIGDB.BATCH_" />
</bean>
Vous pouvez maintenant injecter la source de données AppDB dans les OR écrivains de votre DAO, le cas échéant.
<bean id="DemoItemWriter" class="com.demoItemWriter">
<property name="dataSource" ref="AppDB" />
</bean>
OR
vous pouvez définir une ressource et injecter cette AppDB avec la recherche jndi dans la classe où elle est nécessaire, par exemple:
public class ExampleDAO {
@Resource(lookup = "Java:comp/env/jdbc/AppDB")
DataSource ds;
}