Spring batch 需要Spring批处理Mongo DB Java配置来使用Spring引导从DB读取数据

这是我的

Spring

Mongo

配置，用于普通

Spring

项目。我想知道如何为

Spring批处理

编辑它

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.security.KeyManagementException;
import java.security.KeyStore;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.UnrecoverableKeyException;
import java.security.cert.CertificateException;
import java.util.ArrayList;
import java.util.List;

import javax.net.ssl.KeyManagerFactory;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSocketFactory;
import javax.net.ssl.TrustManagerFactory;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Profile;
import org.springframework.core.io.ResourceLoader;
import org.springframework.data.mongodb.MongoDbFactory;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.SimpleMongoDbFactory;
import org.springframework.data.mongodb.core.convert.DbRefResolver;
import org.springframework.data.mongodb.core.convert.DefaultDbRefResolver;
import org.springframework.data.mongodb.core.convert.DefaultMongoTypeMapper;
import org.springframework.data.mongodb.core.convert.MappingMongoConverter;
import org.springframework.data.mongodb.core.mapping.MongoMappingContext;

import com.mongodb.MongoClient;
import com.mongodb.MongoClientOptions;
import com.mongodb.MongoCredential;
import com.mongodb.ServerAddress;



@Configuration
public class MongoConfiguration
{

    @Autowired
    ResourceLoader       resourceLoader;

    @Value("${mongodb.keyStoreFilePath}")
    private String       keyStoreFilePath;

    @Value("${mongodb.keyStoreType}")
    private String       keyStoreType;

    @Value("${mongodb.keyStorePassword}")
    private String       keyStorePassword;

    @Value("${mongodb.databasePort}")
    private String       databasePort;

    @Value("${mongodb.databaseName}")
    private String       databaseName;

    @Value("${mongodb.dbUserName}")
    private String       dbUserName;

    @Value("${mongodb.dbPassword}")
    private String       dbPassword;

    @Value("#{'${mongodb.seeds}'.split(',')}")
    private List<String> seeds;


    @Bean
    @Profile("default")
    public MongoTemplate mongoTemplate() throws UnrecoverableKeyException, KeyManagementException, KeyStoreException,
            NoSuchAlgorithmException, CertificateException, IOException
    {
        DbRefResolver dbRefResolver = new DefaultDbRefResolver(mongoDbFactory());
        MappingMongoConverter converter = new MappingMongoConverter(dbRefResolver, new MongoMappingContext());
        converter.setTypeMapper(new DefaultMongoTypeMapper(null));
        return new MongoTemplate(mongoDbFactory(), converter);
    }



    @Bean
    @Profile("default")
    public MongoDbFactory mongoDbFactory() throws UnrecoverableKeyException, KeyManagementException, KeyStoreException,
            NoSuchAlgorithmException, CertificateException, IOException
    {
        return new SimpleMongoDbFactory(mongoClient(), databaseName);

    }


    @Bean
    @Profile("default")
    public MongoClient mongoClient() throws IOException, KeyStoreException, NoSuchAlgorithmException,
            CertificateException, UnrecoverableKeyException, KeyManagementException
    {

        try (InputStream readStream = new FileInputStream(keyStoreFilePath))
        {
            KeyStore ksClient = KeyStore.getInstance(keyStoreType);
            ksClient.load(readStream, keyStorePassword.toCharArray());
            KeyManagerFactory kmf = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
            kmf.init(ksClient, keyStorePassword.toCharArray());

            KeyStore ksCACert = KeyStore.getInstance(KeyStore.getDefaultType());
            ksCACert.load(new FileInputStream(keyStoreFilePath), keyStorePassword.toCharArray());

            TrustManagerFactory tmf = TrustManagerFactory.getInstance("X509");
            tmf.init(ksCACert);

            SSLContext context = SSLContext.getInstance("TLS"); // We now
                                                                // provide
                                                                // our alternate
                                                                // KeyManager
            context.init(kmf.getKeyManagers(), tmf.getTrustManagers(), null);
            SSLSocketFactory sslSocketFactory = context.getSocketFactory();

            MongoClientOptions mongoClientOptions =
                    MongoClientOptions.builder().sslEnabled(true).socketFactory(sslSocketFactory).build();

            List<ServerAddress> seedList = new ArrayList<>();
            for (String ip : seeds)
            {
                seedList.add(new ServerAddress(ip, Integer.parseInt(databasePort)));
            }
            return new MongoClient(seedList,
                    MongoCredential.createCredential(dbUserName, databaseName, dbPassword.toCharArray()),
                    mongoClientOptions);
        }

    }

}

基本上，这是从Oracle到MongoDB的迁移

对于从Oracle读取，您可以使用例如

JdbcCursorItemReader

（或Spring Batch提供的其他DB读取器）：

然后定义一个面向块的步骤，从Oracle读取数据并写入MongoDB

希望这有帮助

编辑：添加mongo reader示例：

@Bean
public MongoItemReader<Foo> mongoItemReader() { 
    Query query; // specify your mongo query
    return new MongoItemReaderBuilder<Foo>()
        .template(mongoTemplate())
        .targetType(Foo.class)
        .query(query)
        .build();
}

@Bean
公共MongoItemReader MongoItemReader（）{
Query Query；//指定您的mongo查询
返回新的MongoItemReaderBuilder（）
.template（mongoTemplate（））
.targetType（Foo.class）
.query（查询）
.build（）；
}

但我想使用mongo db阅读器，而不是其他阅读器。我应该在配置类中添加什么和所有配置啊，好吧，我知道你说“从oracle迁移到MongoDB”时是在读oracle。在这种情况下，mongo阅读器也使用mongo模板。我编辑了这个问题以包含mongo reader示例。我想知道是否应该配置JobRepository？以及setTargettype和setCollection-->的使用请告诉我它使用了我们在此中实际设置的内容如果您想将Spring元数据持久化到持久化存储中，那么是的，否则不需要配置它，默认情况下将使用（内存中）基于映射的作业存储库。

@Bean
public JdbcCursorItemReader<Foo> itemReader() {
    return new JdbcCursorItemReaderBuilder<Foo>()
        .dataSource(batchDataSource()) // change accordingly if you use another data source
        .name("fooReader")
        .sql("SELECT * FROM FOO")
        .beanRowMapper(Foo.class)
        .build();
}

@Bean
public MongoItemWriter<String> itemWriter() {
    return new MongoItemWriterBuilder<String>()
        .template(mongoTemplate())
        .build();
}

@Bean
public MongoItemReader<Foo> mongoItemReader() { 
    Query query; // specify your mongo query
    return new MongoItemReaderBuilder<Foo>()
        .template(mongoTemplate())
        .targetType(Foo.class)
        .query(query)
        .build();
}