便捷的数据读写-spring batch(5)结合beetlSql进行数据读写

最新推荐文章于 2022-06-07 12:02:36 发布

masonlee32

最新推荐文章于 2022-06-07 12:02:36 发布

阅读量1.5k

点赞数

分类专栏： Spring Batch入门与实践文章标签： springbatch

本文链接：https://blog.csdn.net/masson32/article/details/91369997

版权

Spring Batch入门与实践专栏收录该内容

9 篇文章 20 订阅

订阅专栏

便捷的数据读写-spring batch(5)结合beetlSql进行数据读写

tags： springbatch

1.引言

上一篇文章《决战数据库-spring batch(4)数据库到数据库》使用Spring Batch内置的读、写组件，对数据库间的数据进行同步。相对来说，这个数据读取和数据写入是基于jdbc进行读写的(数据对象的映射需要我们自己处理，如UserRowMapper)，我们现在开发一般都使用上层一点的ORM框架，如Hibernate,MyBatis,BeetlSQL。对于Hibernate,Spring Batch有默认的HibernateCursorItemReader和HibernateItemWriter，也可以实现自行使用MyBatis和BeetlSQL。个人感觉，从易用性和学习曲线上看，BeetlSQL会更容易上手，社区也挺活跃，因此，本文介绍一下使用Spring Batch结合BeetlSQL进行数据库到数据库的数据同步。

2.开发环境

JDK: jdk1.8
Spring Boot: 2.1.4.RELEASE
Spring Batch:4.1.2.RELEASE
BeetlSQL: 1.1.77.RELEASE
开发IDE: IDEA
构建工具Maven: 3.3.9
日志组件logback:1.2.3
lombok:1.18.6

3.BeetlSQL简要说明

按官方文档，BeetlSQL是一个全功能DAO工具，同时具有Hibernate优点 & Mybatis优点功能，适用于承认以SQL为中心，同时又需求工具能自动能生成大量常用的SQL的应用。详细可参考官方文档。从最近一段时间的使用过程中，感觉从开发效率、维护性、易用性，都比较优秀。

4.使用BeetlSQL读写数据库

本示例依然是基于上一篇文章的示例功能，从源数据库中读取test_user表的数据，然后经过处理，再写入到目标数据库的test_user表中。只是不是使用Spring Batch内置的JdbcCursorItemReader和JdbcBatchItemWriter，改为使用BeetlSQL进行读写。完整示例可参考代码

4.1 引入BeetlSQL依赖

BeetlSQL提供了Spring Boot的starter来实现自动配置，在pom.xml添加以下依赖即可：

<!-- orm框架: beetlsql -->
<dependency>
	<groupId>com.ibeetl</groupId>
	<artifactId>beetl-framework-starter</artifactId>
	<version>1.1.77.RELEASE</version>
</dependency>

添加后，会添加两个依赖，分别是beetl-2.9.9，和beetlsql-2.11.2，如下图：

beetlsql

4.2 编写多数据源的dao

4.2.1 添加配置文件

由于我们是使用多数据源进行读写，关于多数据源的配置，上一篇文章已经进行了描述，此处不再说明。BeetlSQL对多数据源有较好的支持，只需要简单的配置即可。具体可参考官方文档。下面对此做简单说明。在application.properties文件中添加以下配置：

#beetlsql配置
#默认/sql，可不设置
#beetlsql.sqlPath=/sql
#dao文件的后缀
beetlsql.daoSuffix=Repository
#自动加载和查找的dao文件所在包
beetlsql.basePackage=me.mason.springbatch
#默认org.beetl.sql.core.db.MySqlStyle，可不设置
#beetlsql.dbStyle=org.beetl.sql.core.db.MySqlStyle
#多数据源dao文件所在位置，以包区分读写数据源
beetlsql.ds.datasource.basePackage=me.mason.springbatch.dao.local
beetlsql.ds.originDatasource.basePackage=me.mason.springbatch.dao.origin
beetlsql.ds.targetDatasource.basePackage=me.mason.springbatch.dao.target
beetlsql.mutiple.datasource=datasource,originDatasource,targetDatasource

说明：

beetlsql.daoSuffix表示Dao文件的后缀，BeetlSql会根据此后缀加载Dao。
beetlsql.mutiple.datasource数据源名与数据源的配置一致。

4.2.2 添加dao文件

添加上述配置后，由于使用包名来区分读写数据源的Dao，因此需要创建对应的包，分别在工程中me.mason.springbatch下创建dao.local,dao.origin，dao.target三个包，分别存放需要读取的三个数据源对应的Dao。在本示例中，仅使用源数据库和目标数据库，因此，仅需要在dao.origin中添加OriginUserRepository进行源数据读操作，在dao.target中添加TargetUserRepository进行写操作即可。（注意，由于配置中指定是使用后缀Repository，因此此处的类名需要使用它作为后缀）。如下：

OriginUserRepository.java

@Repository
public interface OriginUserRepository extends BaseMapper<User> {
    List<User> getOriginUser(Map<String,Object> params);
}

TargetUserRepository.java

@Repository
public interface TargetUserRepository extends BaseMapper<User> {
}

说明：

使用注解@Repository标注是数据读写dao
继承BaseMapper，以使用BeetlSQL内置的增删改查能力
对于OriginUserRepository，getOriginUser是自定义的数据读取操作，此操作具体实现是使用写在sql/user.md中的sql语句（sql语句在后面将说明）。

4.3 编写sql文件

根据BeetlSql的功能，开发者可以自定义sql语句进行数据库操作，而sql语句是以markdown文件的形式保存，支持beetl的语法，支持参数化语句，逻辑判断等操作，这就有点像Mybatis中的xml语句，但显示和修改会更友好。具体sql文件更详细的使用功能，读者可到官文档查阅。

本示例中，上面OriginUserRepository自定义了getOriginUser函数，以此函数名即可编写sql进行读数据（当然，由于此sql比较简单，完全可以不写到markdown文件也可以实现，此处仅做示例展示此功能而已）。如下所示：

getOriginUser
===
* 查询user数据

select * from test_user

接着就是写数据需要用到的sql，insertUser是这条语句的名称，在插入数据时会使用到：

insertUser
===
* 插入数据

insert into test_user(id,name,phone,title,email,gender,date_of_birth
    ,sys_create_time,sys_create_user,sys_update_time,sys_update_user)
values (#id#,#name#,#phone#,#title#,#email#,#gender#,#dateOfBirth#
    ,#sysCreateTime#,#sysCreateUser#,#sysUpdateTime#,#sysUpdateUser#)

由上面的sql可见，这跟我们平时写sql没有区别，其中以##包括的是参数，即实体User的字段。

4.4 编写读组件ItemReader

经过上面的配置和添加的dao类，我们已经有了读和写数据的能力。使用OriginUserRepository，可以编写Spring Batch的ItemReader。读取数据后在内存中，在read()时返回。如下所示：

@Slf4j
public class UserItemReader implements ItemReader<User> {
    protected List<User> items;

    protected Map<String,Object> params;
    @Autowired
    private OriginUserRepository originUserRepository;

    @Override
    public User read() throws Exception, UnexpectedInputException, ParseException, NonTransientResourceException {
        if(Objects.isNull(items)){
            //使用beetlsql的md执行sql
            items = originUserRepository.getOriginUser(params);
            if(items.size() > 0){
                return items.remove(0);
            }
        }else{
            if (!items.isEmpty()) {
                return items.remove(0);
            }
        }
        return null;
    }

    public Map<String, Object> getParams() {
        return params;
    }

    public void setParams(Map<String, Object> params) {
        this.params = params;
    }
}

说明：

originUserRepository.getOriginUser执行的是user.md的getOriginUser查询语句。
查询后数据保存在List<User>，在read()时返回其中的数据。全部返回后会返回null，以表示结束。
BeetlSql支持使用Map来传参，本示例暂时没有使用。

4.5 编写写组件ItemWriter

读取到数据后，使用TargetUserRepository，执行上面编写的insertUser来插入数据。如下所示

public class UserItemWriter implements ItemWriter<User> {
    @Autowired
    private TargetUserRepository targetUserRepository;

    @Override
    public void write(List<? extends User> items) throws Exception {
        targetUserRepository.getSQLManager().updateBatch("user.insertUser",items);
    }
}

说明：

使用SQLManager的updateBatch批量写数据
user.insertUser中，user是markdown文件的名称，也是实体名称，insertUser是写的sql语句。

4.6 组装完整任务

新建BeetlsqlBatchConfig.java，作为Spring Batch的任务配置

4.6.1 注入读写组件

使用上面已写的Reader和Writer，使用Bean注解加入，如下：

@Bean
public ItemReader beetlsqlItemReader() {
    UserItemReader userItemReader = new UserItemReader();
    //设置参数，当前示例可不设置参数
    Map<String,Object> params = CollUtil.newHashMap();
    userItemReader.setParams(params);
    return userItemReader;
}

@Bean
public ItemWriter beetlsqlWriter() {
    return new UserItemWriter();
}

4.6.2 组装任务

使用Step和Job，实现完整的任务配置，如下：

@Bean
public Job beetlsqlJob(Step beetlsqlStep,JobExecutionListener beetlsqlListener){
    String funcName = Thread.currentThread().getStackTrace()[1].getMethodName();
    return jobBuilderFactory.get(funcName)
            .listener(beetlsqlListener)
            .flow(beetlsqlStep)
            .end().build();
}
@Bean
public Step beetlsqlStep(ItemReader beetlsqlItemReader ,ItemProcessor beetlsqlProcessor
        ,ItemWriter beetlsqlWriter){
    String funcName = Thread.currentThread().getStackTrace()[1].getMethodName();
    return stepBuilderFactory.get(funcName)
            .<User,User>chunk(10)
            .reader(beetlsqlItemReader)
            .processor(beetlsqlProcessor)
            .writer(beetlsqlWriter)
            .build();
}