Java 使用Mongodb的Spring引导和数据库默认数据

我有一个使用Mongodb的Spring Boot项目。因此，在我的pom中，我有这种依赖性：

<dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-mongodb</artifactId>
</dependency>

org.springframework.boot
spring启动程序数据mongodb

因此，我可以使用此存储库类访问数据库：

package it.de.marini.server.dal;

import org.springframework.data.mongodb.repository.MongoRepository;

import it.de.marini.server.model.Role;

public interface RoleRepository extends MongoRepository<Role, String> {

}

package it.de.marini.server.dal；
导入org.springframework.data.mongodb.repository.MongoRepository；
导入it.de.marini.server.model.Role；
公共接口角色库扩展了MongoRepository{
}

---

我需要对Mongodb数据库中的数据进行序列化，例如使用默认角色。Spring Boot framework中最好的方法是什么？

有几种方法可以做到这一点，我建议您使用

CommandlineRunner

尝试：

否则，您可以使用

@PostConstruct

启动它

---

如果您需要类似于RDBMS的

liquibase

，请查看mongobee:

As@Jaiwo99，我知道没有这样做的标准。所以我决定用springbatch来完成这项工作。我实现了一个从CSV文件加载的批处理。我的应用程序的角色和权限

@Configuration
@EnableBatchProcessing
public class BatchConfiguration {

@Autowired
public JobBuilderFactory jobBuilderFactory;

@Autowired
public StepBuilderFactory stepBuilderFactory;

@Autowired
public MongoTemplate mongoTemplate;

@Bean
public PlatformTransactionManager transactionManager() {
    return new ResourcelessTransactionManager();
}

@Bean
public Tasklet defaultRolePermissionTasklet() {
    return new DefaultRolePermissionTasklet();
}


public <T> FlatFileItemReader<T> readerFile(String fileName,String[] fields,Class<T> type)  {

    FlatFileItemReader<T> reader = new FlatFileItemReader<T>();
    reader.setStrict(false);
    reader.setResource(new ClassPathResource(fileName));
    reader.setLineMapper(new DefaultLineMapper<T>() {
        {
            setLineTokenizer(new DelimitedLineTokenizer() {
                {
                    setNames(fields);
                    setStrict(false);
                }
            });
            setFieldSetMapper(new BeanWrapperFieldSetMapper<T>() {
                {
                    setTargetType(type);
                }
            });
        }
    });
    return reader;

}

@Bean
public PermissionItemProcessor permissionProcessor() {
    return new PermissionItemProcessor();
}

@Bean
public RoleItemProcessor roleProcessor() {
    return new RoleItemProcessor();
}

@Bean
public Job initAuthenticationData(JobCompletionNotificationListener listener) {
    return jobBuilderFactory.get("initAuthenticationData").incrementer(new RunIdIncrementer()).listener(listener)
            .start(stepPermission())
            .next(stepRole())
            .next(stepDefaultRolePermissions())
            .build();
}

@Bean
public Step stepDefaultRolePermissions() {
    return stepBuilderFactory.get("stepDefaultRolePermissions").tasklet(defaultRolePermissionTasklet()).build();
}


@Bean
public Step stepPermission() {

    MongoItemWriter<Permission> writer = new MongoItemWriter<Permission>();
    writer.setTemplate(mongoTemplate);




    return stepBuilderFactory.get("stepPermission").<Permission, Permission>chunk(20)
            .reader(readerFile("permission-data.csv",new String[] {"name","description"},Permission.class))
            .processor(permissionProcessor())
            .writer(writer)
            .build();
}

@Bean
public Step stepRole() {
    MongoItemWriter<Role> writer = new MongoItemWriter<Role>();
    writer.setTemplate(mongoTemplate);

    return stepBuilderFactory.get("stepRole").<Role, Role>chunk(20)
            .reader(readerFile("role-data.csv",new String[] {"name","description"},Role.class))
            .processor(roleProcessor())
            .writer(writer)
            .build();
    }
}

@配置
@启用批处理
公共类批处理配置{
@自动连线
公共建筑商建筑商工厂；
@自动连线
公共StepBuilderFactory StepBuilderFactory；
@自动连线
公共MongoTemplate MongoTemplate；
@豆子
公共平台transactionManager transactionManager（）{
返回新的ResourcesTransactionManager（）；
}
@豆子
公共Tasklet defaultRolePermissionTasklet（）{
返回新的DefaultRolePermissionTasklet（）；
}
公共FlatFileItemReader读取器文件（字符串文件名、字符串[]字段、类类型）{
FlatFileItemReader=新的FlatFileItemReader（）；
reader.setStrict（假）；
setResource（新类路径资源（文件名））；
reader.setLineMapper（新的DefaultLineMapper（）{
{
setLineTokenizer（新的DelimitedLineTokenizer（）{
{
设置名称（字段）；
setStrict（假）；
}
});
setFieldSetMapper（新的BeanRapperFieldSetMapper（）{
{
setTargetType（类型）；
}
});
}
});
返回读取器；
}
@豆子
public PermissionItemProcessor permissionProcessor（）{
返回新的PermissionItemProcessor（）；
}
@豆子
公共角色处理器角色处理器（）{
返回新的RoleItemProcessor（）；
}
@豆子
公共作业initAuthenticationData（JobCompletionNotificationListener侦听器）{
返回jobBuilderFactory.get（“initAuthenticationData”）.incrementer（新RunIdIncrementer（））.listener（listener）
.start（stepPermission（））
.next（stepRole（））
.next（stepDefaultRolePermissions（））
.build（）；
}
@豆子
公共步骤stepDefaultRolePermissions（）{
返回stepBuilderFactory.get（“stepDefaultRolePermissions”）.tasklet（defaultRolePermissionTasklet（））.build（）；
}
@豆子
公共步骤{
MongoItemWriter=新的MongoItemWriter（）；
作者：setTemplate（mongoTemplate）；
返回stepBuilderFactory.get（“stepPermission”）.chunk（20）
.reader（readerFile（“permission data.csv”，新字符串[]{“name”，“description”}，permission.class））
.processor（permissionProcessor（））
.作者（作者）
.build（）；
}
@豆子
公共步骤stepRole（）{
MongoItemWriter=新的MongoItemWriter（）；
作者：setTemplate（mongoTemplate）；
返回stepBuilderFactory.get（“stepRole”）.chunk（20）
.reader（readerFile（“role data.csv”，新字符串[]{“name”，“description”}，role.class））
.processor（角色处理器（））
.作者（作者）
.build（）；
}
}

至少，还有一种方法可以使用Spring Boot初始化Mongodb中的数据。您可以在配置中创建如下内容：

@Configuration
public class AppConfiguration {

    @Autowired
    public void prepare(ReactiveMongoOperations mongoOperations,
                        UserRepository userRepository) {
        mongoOperations.createCollection("users",
                CollectionOptions.empty()
                        .maxDocuments(1_000)
                        .size(1024 * 8)
                        .capped()).block();
        userRepository
                .insert(List.of(
                        User.builder()
                                .name("Joe Doe")
                                .build()
                ))
                .blockLast();
    }
}

当然，您必须检查集合是否不存在，以便在数据库已经创建的情况下不创建集合

@Configuration
public class AppConfiguration {

    @Autowired
    public void prepare(ReactiveMongoOperations mongoOperations,
                        UserRepository userRepository) {
        mongoOperations.createCollection("users",
                CollectionOptions.empty()
                        .maxDocuments(1_000)
                        .size(1024 * 8)
                        .capped()).block();
        userRepository
                .insert(List.of(
                        User.builder()
                                .name("Joe Doe")
                                .build()
                ))
                .blockLast();
    }
}