SpringBoot + xxl-job 多数据源异构数据增量同步

最新推荐文章于 2024-03-20 21:06:13 发布
最新推荐文章于 2024-03-20 21:06:13 发布
阅读量1.8k 收藏 6
点赞数 3
分类专栏： 数据库 SpringBoot 文章标签： spring boot mybatis-plus 多数据源 异构数据增量同步 xxl-job
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lfp528136199/article/details/127122697
版权

SpringBoot + xxl-job 多数据源异构数据增量同步

文章目录

一、概述

​ 前段时间有一项目，需要同步第三方平台的Oracle数据库数据到我们自己SQL Server库，一开始我想着用datax结合datax-web直接创建同步任务，分分钟搞定，然鹅，查看DataX SqlServerWriter 文档注意事项：

注意：

  1. 目的表所在数据库必须是主库才能写入数据；整个任务至少需具备 insert into…的权限，是否需要其他权限，取决于你任务配置中在 preSql 和 postSql 中指定的语句。
    2.SqlServerWriter和MysqlWriter不同，不支持配置writeMode参数。

SqlServerWriter和MysqlWriter不同，不支持配置writeMode参数。也就是说，该writer不支持增量更新，每次只能全量更新(在preSql中写delete 或 TRUNCATE 语句，清空表，再插入)，这数据量一大的话，就太费劲了。

​ 因此，我通过SpringBoot项目，结合xxl-job，使用多数据源的方式，开发定时同步任务，从Oracle 增量拉取数据，再插入或更新到SQL Server库中。由于是老系统，部分照片数据都直接存储在数据库中，因此，增量更新非常有必要！

二、实现步骤

2.1 项目搭建

我们只需要开发xxl-job任务执行器模块即可，工程pom如下：

<properties>
    <java.version>1.8</java.version>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
    <spring-boot.version>2.3.7.RELEASE</spring-boot.version>

    <xxl-job-version>2.3.0</xxl-job-version>
    <hutool-version>5.8.7</hutool-version>
    <mybatis-plus.version>3.5.2</mybatis-plus.version>
    <orai18n.version>12.1.0.2.0</orai18n.version>
    <dynamic-datasource.version>3.4.0</dynamic-datasource.version>
</properties>

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <!-- sqlserver 驱动 -->
    <dependency>
        <groupId>com.microsoft.sqlserver</groupId>
        <artifactId>mssql-jdbc</artifactId>
        <scope>runtime</scope>
    </dependency>
    <!-- oracle 驱动 -->
    <dependency>
        <groupId>com.oracle.database.jdbc</groupId>
        <artifactId>ojdbc8</artifactId>
        <scope>runtime</scope>
    </dependency>
    <!-- 解决Oracle 字符集支持问题 -->
    <dependency>
        <groupId>cn.easyproject</groupId>
        <artifactId>orai18n</artifactId>
        <version>${orai18n.version}</version>
    </dependency>
    <!-- mysql 驱动 -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <scope>runtime</scope>
    </dependency>

    <!--mybatis plus-->
    <dependency>
        <groupId>com.baomidou</groupId>
        <artifactId>mybatis-plus-boot-starter</artifactId>
        <version>${mybatis-plus.version}</version>
    </dependency>

    <!-- 多数据源 starter -->
    <dependency>
        <groupId>com.baomidou</groupId>
        <artifactId>dynamic-datasource-spring-boot-starter</artifactId>
        <version>${dynamic-datasource.version}</version>
    </dependency>

    <!-- xxl-job-core -->
    <dependency>
        <groupId>com.xuxueli</groupId>
        <artifactId>xxl-job-core</artifactId>
        <version>${xxl-job-version}</version>
    </dependency>

    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>

    <dependency>
        <groupId>cn.hutool</groupId>
        <artifactId>hutool-all</artifactId>
        <version>${hutool-version}</version>
    </dependency>

    <!--测试包-->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
        <exclusions>
            <exclusion>
                <groupId>org.junit.vintage</groupId>
                <artifactId>junit-vintage-engine</artifactId>
            </exclusion>
        </exclusions>
    </dependency>
</dependencies>

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-dependencies</artifactId>
            <version>${spring-boot.version}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

<build>    
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.8.1</version>
            <configuration>
                <source>1.8</source>
                <target>1.8</target>
                <encoding>UTF-8</encoding>
            </configuration>
        </plugin>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <version>2.3.7.RELEASE</version>
            <configuration>
                <mainClass>com.lifp.DynamicDatasourceApplication</mainClass>
            </configuration>
            <executions>
                <execution>
                    <id>repackage</id>
                    <goals>
                        <goal>repackage</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

项目涉及三个数据库：Oracle、SQL Server 、MySQL，需要分别引入他们的驱动，另外需要引入多数据源模块dynamic-datasource-spring-boot-starter。此外，需要集成分布式定时任务调度模块核心依赖：xxl-job-core

2.2 接口开发

使用MyBatis-Plus，来开发，不详细介绍，只贴核心代码。

2.2.1 SQL Server接口开发
2.2.1.1 实体类

示例表ms_demo，只有如下三个字段。

@Data
@TableName(value = "ms_demo")
public class MsDemo {
    @TableId(value = "id", type = IdType.INPUT)
    private Long id;

    /**
     * 姓名
     */
    @TableField(value = "name")
    private String name;
    
    /**
     * 照片
     */
    @TableField(value = "Photo")
    private byte[] photo;
    
    /**
     * 时间戳，不存表，只用来封装Oracle中时间戳数据
     */
    @TableField(exist = false)
    private Long timeStamp;
}
2.2.1.2 service接口

SQL Server端，只是批量插入或更新，直接使用MyBatis-Plus基础接口即可， 无需再做额外开发。

public interface MsDemoService extends IService<MsDemo> {
}
2.2.1.3 service接口实现

使用多数据源后，可以在类和方法上标注@DS()注解，标明要使用的数据源

@DS("sqlserver")
@Service
public class MsDemoServiceImpl extends ServiceImpl<MsDemoServiceMapper, MsDemo> implements MsDemoService{
}
2.2.1.4 其他

mapper接口和mapper.xml省略…

2.2.2 Oracle 接口开发

Oracle端的接口，需要从库中查出数据，提供给SQL Server端接口。但是，两端的表结构不一样，而且Oracle端需要从3张表组合查询，最终同步到SQL Server端一张表中。因此，Oracle端最终查询结果，可以直接用SQL Server端目标表实体对象来接收，具体如下。

2.2.2.1 service接口
public interface OracleMsDemoService extends IService<MsDemo> {
    /**
    *@Description 准备待同步的数据
    *@param timeStamp 同步时间戳，为上次同步数据最大时间戳，记录与Job表中
    *@Return 
    */
    List<MsDemo> prepareSyncData(String timeStamp);
}
2.2.2.2 service接口实现

此处是Oracle端接口，使用@DS(“oracle”)注解标明使用配置文件自定义oracle数据源

@DS("oracle")
@Service
public class OracleMsDemoServiceImpl extends ServiceImpl<OracleMsDemoPhotoMapper, MsDemo> implements OracleMsDemoService {

    @Override
    public List<MsDemo> prepareSyncData(String timeStamp) {
        return baseMapper.prepareSyncData(timeStamp);
    }
}
2.2.2.3 mapper接口
public interface OracleMsDemoPhotoMapper extends BaseMapper<MsDemo> {

    List<MsDemo> prepareSyncData(@Param("timeStamp") String timeStamp);
}
2.2.2.3 mapper xml
<mapper namespace="com.lifp.mapper.OracleMsDemoPhotoMapper">
  <resultMap id="BaseResultMap" type="com.lifp.entity.MsDemo">
    <!--@mbg.generated-->
    <!--@Table ms_demo-->
    <id column="Id" jdbcType="VARCHAR" property="id" />
    <result column="Name" jdbcType="VARCHAR" property="name" />
    <result column="Photo" jdbcType="BLOB" property="photo" />    
  </resultMap>
    
  <select id="prepareSyncData" resultMap="BaseResultMap">
      select .....
      from ....
      <if test="timeStamp != null and timeStamp != ''">
          <!--根据时间戳，获取增量更新的数据（目标时间戳以后的数据）-->
          <![CDATA[ and GREATEST(t.sjc,t.sjtbsjc)> #{timeStamp} ]]>
      </if>
  </select>
</mapper>
2.2.3 xxl-job 任务接口开发

​ Oracle库每张表都有时间戳字段，记录数据更新时间，后期增量更新也是基于该字段做增量更新，即每次拉取数据，都只获取目标时间戳以后的数据。

​ 但是，每次拉取完数据后，这批数据中最大时间戳记录在哪里呢？

​ 由于使用xxl-job去调度定时任务，那么我们可以在xxl_job_info表中添加一列，记录当前数据同步 job 的最大时间戳。每次调度时，首先从表中获取当前任务上一次执行后的最大时间戳，用它去Oracle中查询数据，查询到数据后，再将所查询数据中的最大时间戳更新到xxl_job_info表当前任务记录上去即可。因此首先需要改造该表，然后再创建其操作接口。

2.2.3.1 xxl_job_info 实体

xxl_job_info 表中添加了incremental_update_date字段，用来记录增量时间戳。

@Data
@TableName(value = "xxl_job_info")
public class XxlJobInfo {
    @TableId(value = "id", type = IdType.AUTO)
    private Integer id;

    /**
     * 执行器主键ID
     */
    @TableField(value = "job_group")
    private Integer jobGroup;

    @TableField(value = "job_desc")
    private String jobDesc;

    @TableField(value = "add_time")
    private Date addTime;

    @TableField(value = "update_time")
    private Date updateTime;

    /**
     * 作者
     */
    @TableField(value = "author")
    private String author;

    /**
     * 报警邮件
     */
    @TableField(value = "alarm_email")
    private String alarmEmail;

    /**
     * 调度类型
     */
    @TableField(value = "schedule_type")
    private String scheduleType;

    /**
     * 调度配置，值含义取决于调度类型
     */
    @TableField(value = "schedule_conf")
    private String scheduleConf;

    /**
     * 调度过期策略
     */
    @TableField(value = "misfire_strategy")
    private String misfireStrategy;

    /**
     * 执行器路由策略
     */
    @TableField(value = "executor_route_strategy")
    private String executorRouteStrategy;

    /**
     * 执行器任务handler
     */
    @TableField(value = "executor_handler")
    private String executorHandler;

    /**
     * 执行器任务参数
     */
    @TableField(value = "executor_param")
    private String executorParam;

    /**
     * 阻塞处理策略
     */
    @TableField(value = "executor_block_strategy")
    private String executorBlockStrategy;

    /**
     * 任务执行超时时间，单位秒
     */
    @TableField(value = "executor_timeout")
    private Integer executorTimeout;

    /**
     * 失败重试次数
     */
    @TableField(value = "executor_fail_retry_count")
    private Integer executorFailRetryCount;

    /**
     * GLUE类型
     */
    @TableField(value = "glue_type")
    private String glueType;

    /**
     * GLUE源代码
     */
    @TableField(value = "glue_source")
    private String glueSource;

    /**
     * GLUE备注
     */
    @TableField(value = "glue_remark")
    private String glueRemark;

    /**
     * GLUE更新时间
     */
    @TableField(value = "glue_updatetime")
    private Date glueUpdatetime;

    /**
     * 子任务ID，多个逗号分隔
     */
    @TableField(value = "child_jobid")
    private String childJobid;

    /**
     * 调度状态：0-停止，1-运行
     */
    @TableField(value = "trigger_status")
    private Byte triggerStatus;

    /**
     * 上次调度时间
     */
    @TableField(value = "trigger_last_time")
    private Long triggerLastTime;

    /**
     * 下次调度时间
     */
    @TableField(value = "trigger_next_time")
    private Long triggerNextTime;

    /**
     * 增量更新时间(时间戳)
     */
    @TableField(value = "incremental_update_date")
    private Long incrementalUpdateDate;
}
2.2.3.2 xxl_job_info 接口
public interface XxlJobInfoService extends IService<XxlJobInfo>{
}
2.2.3.3 xxl_job_info 接口实现

xxl-job部署于本地，连接的是MySQL数据库，在此使用@DS(“xxljob”)指定使用自定义配置数据源xxljob

@DS("xxljob")
@Service
public class XxlJobInfoServiceImpl extends ServiceImpl<XxlJobInfoMapper, XxlJobInfo> implements XxlJobInfoService{
}
2.2.4 xxl-job 任务执行器接口开发

创建任务类，在该类中创建数据同步任务方法，然后用@XxlJob()注解，标明执行器名称（后面配置同步任务时使用）

@Component
@Slf4j
public class MsDemoSyncJob {
    @Autowired
    private XxlJobInfoService xxlJobInfoService;
    @Autowired
    private OracleMsDemoService oracleMsDemoService;
    @Autowired
    private MsDemoService msDemoService;



    @XxlJob("msDemoSyncJob")
    public void msDemoSyncJob() throws Exception {

        //1、根据当前任务id，查询任务信息
        XxlJobInfo jobInfo = xxlJobInfoService.getById(XxlJobHelper.getJobId());

        //上次调度时间（时间戳），作为本次增量起始时间
        //xxl-job job表需要添加incremental_update_date（增量更新时间(时间戳)，varchar类型，初始可为空）
        Long incrementalUpdateDate = jobInfo.getIncrementalUpdateDate();
        //自定义参数
        //String param = XxlJobHelper.getJobParam();

        //2、根据起始时间戳，查询待增量同步数据
        List<MsDemo> msDemoList = oracleMsDemoService.prepareSyncData(incrementalUpdateDate);
        
        if(msDemoList.size()>0){
            //3、执行插入或更新操作
            msDemoService.saveOrUpdateBatch(msDemoList);

            //数据同步后，使用stream API统计所获取数据的时间戳
            LongSummaryStatistics statistics = msDemoList.stream().mapToLong(item -> {
                return item.getTimeStamp();//获取每条数据的时间戳
            }).summaryStatistics();
            
            //从stream统计信息获取最大时间戳
            long maxTimeStamp = statistics.getMax();

            //4、更新时间戳（只有成功调度，才更新）
            jobInfo.setIncrementalUpdateDate(maxTimeStamp);
            xxlJobInfoService.updateById(jobInfo);
            
            XxlJobHelper.log("当前任务同步数据，最大时间戳已更新至xxl_job_info表，时间戳为：{}",max);
        }

        XxlJobHelper.log("数据同步任务（msDemoSyncJob），同步了{}条数据",msDemoList.size());
    }

}

2.3 配置文件编写

2.3.1 自定义xxl-job配置类
@Component
@ConfigurationProperties(prefix = "xxl.job")
@Data
public class XxlJobConfig {
    private Logger logger = LoggerFactory.getLogger(XxlJobConfig.class);

    //调度中心部署跟地址 [选填]：如调度中心集群部署存在多个地址则用逗号分隔。执行器将会使用该地址进行"执行器心跳注册"和"任务结果回调"；为空则关闭自动注册；
    // eg: http://127.0.0.1:8089/xxl-job-admin
    private String adminAddresses;

    //执行器通讯TOKEN [选填]：非空时启用；
    private String accessToken;

    // 执行器AppName [选填]：执行器心跳注册分组依据；为空则关闭自动注册
    private String appname;

    //执行器注册 [选填]：优先使用该配置作为注册地址，为空时使用内嵌服务 ”IP:PORT“ 作为注册地址。从而更灵活的支持容器类型执行器动态IP和动态映射端口问题。
    private String address;

    //执行器IP [选填]：默认为空表示自动获取IP，多网卡时可手动设置指定IP，该IP不会绑定Host仅作为通讯实用；地址信息用于 "执行器注册" 和 "调度中心请求并触发任务"；
    private String ip;

    //执行器端口号 [选填]：小于等于0则自动获取；默认端口为9999，单机部署多个执行器时，注意要配置不同执行器端口；
    private int port;

    //执行器运行日志文件存储磁盘路径 [选填] ：需要对该路径拥有读写权限；为空则使用默认路径；
    private String logPath;

    //执行器日志文件保存天数 [选填] ： 过期日志自动清理, 限制值大于等于3时生效; 否则, 如-1, 关闭自动清理功能；
    private int logRetentionDays;


    @Bean
    public XxlJobSpringExecutor xxlJobExecutor() {
        logger.info(">>>>>>>>>>> xxl-job config init.");
        XxlJobSpringExecutor xxlJobSpringExecutor = new XxlJobSpringExecutor();
        xxlJobSpringExecutor.setAdminAddresses(adminAddresses);
        xxlJobSpringExecutor.setAppname(appname);
        xxlJobSpringExecutor.setAddress(address);
        xxlJobSpringExecutor.setIp(ip);
        xxlJobSpringExecutor.setPort(port);
        xxlJobSpringExecutor.setAccessToken(accessToken);
        xxlJobSpringExecutor.setLogPath(logPath);
        xxlJobSpringExecutor.setLogRetentionDays(logRetentionDays);

        return xxlJobSpringExecutor;
    }

    /**
     * 针对多网卡、容器内部署等情况，可借助 "spring-cloud-commons" 提供的 "InetUtils" 组件灵活定制注册IP；
     *
     *      1、引入依赖：
     *          <dependency>
     *             <groupId>org.springframework.cloud</groupId>
     *             <artifactId>spring-cloud-commons</artifactId>
     *             <version>${version}</version>
     *         </dependency>
     *
     *      2、配置文件，或者容器启动变量
     *          spring.cloud.inetutils.preferred-networks: 'xxx.xxx.xxx.'
     *
     *      3、获取IP
     *          String ip_ = inetUtils.findFirstNonLoopbackHostInfo().getIpAddress();
     */


}
2.3.2 项目配置文件

需要注意：

  • spring.datasource.dynamic.datasource.xxx 为多数据源配置

    spring:
  datasource:
    dynamic:
      primary: xxljob
      datasource:
      	#配置名称为 xxljob的数据源
        xxljob:
          url: jdbc:mysql://localhost:3306/xxl_job?characterEncoding=UTF-8&serverTimezone=UTC&useUnicode=true&nullCatalogMeansCurrent=true&useSSL=false
          username: root
          password: root
          driver-class-name: com.mysql.cj.jdbc.Driver

server:
  port: 8889

spring:
  application:
    name: data-sync


  #多数据源
  datasource:
    dynamic:
      #默认的数据源名称为 master，可以根据实际情况自定义
      primary: xxljob
      datasource:
        #配置名称为 xxljob的数据源
        xxljob:
          url: jdbc:mysql://localhost:3306/xxl_job?characterEncoding=UTF-8&serverTimezone=UTC&useUnicode=true&nullCatalogMeansCurrent=true&useSSL=false
          username: root
          password: root
          driver-class-name: com.mysql.cj.jdbc.Driver

        #配置名称为sqlserver的数据源
        sqlserver:
          url: jdbc:sqlserver://192.168.109.128:1433;database=datax
          username: SA
          password: Abc12345
          driver-class-name: com.microsoft.sqlserver.jdbc.SQLServerDriver
        #配置名称为oracle的数据源
        oracle:
          url: jdbc:oracle:thin:@xx.xx.xx.xx:1521:ORCL
          username: xxxxxx
          password: xxxxxx@123
          driver-class-name: oracle.jdbc.driver.OracleDriver

mybatis-plus:
  #configuration:
    #log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

  #默认位置 classpath*:/mapper/**/*.xml
  mapper-locations: classpath*:/mapper/**/*.xml


# xxl job相关配置
xxl:
  job:
    # xxl job管理端地址
    admin-addresses: http://127.0.0.1:8088/xxl-job-admin
    appname: data-sync
    log-retention-days: 30

2.3 项目部署

完成以上开发后，就可以进行项目测试，然后打包部署了。

  • 首先，要先启动xxl-job管理端，例如启动后服务端地址为：http://127.0.0.1:8088/xxl-job-admin；

  • 然后启动本项目；

  • 登录管理端，在执行器中添加本执行器；

  • 创建bean类型的任务，jobHandler名称为：msDemoSyncJob

  • 测试

2.4 项目总结

该项目中，使用多数据源，结合xxl-job，实现异构数据库之间数据同步。通过xxl-job进行任务调度，数据同步频率、策略配置更灵活，适用于datax不满足的情况下来使用。

三、关于多数据源

dynamic-datasource-spring-boot-starter 是一个基于springboot的快速集成多数据源的启动器

特性

  • 支持 数据源分组 ，适用于多种场景 纯粹多库 读写分离 一主多从 混合模式。
  • 支持数据库敏感配置信息 加密 ENC()。
  • 支持每个数据库独立初始化表结构schema和数据库database。
  • 支持无数据源启动，支持懒加载数据源（需要的时候再创建连接）。
  • 支持 自定义注解 ，需继承DS(3.2.0+)。
  • 提供并简化对Druid，HikariCp，BeeCp，Dbcp2的快速集成。
  • 提供对Mybatis-Plus，Quartz，ShardingJdbc，P6sy，Jndi等组件的集成方案。
  • 提供 自定义数据源来源 方案（如全从数据库加载）。
  • 提供项目启动后 动态增加移除数据源 方案。
  • 提供Mybatis环境下的 纯读写分离 方案。
  • 提供使用 spel动态参数 解析数据源方案。内置spel，session，header，支持自定义。
  • 支持 多层数据源嵌套切换 。（ServiceA >>> ServiceB >>> ServiceC）。
  • 提供 基于seata的分布式事务方案。
  • 提供 本地多数据源事务方案。 附：不能和原生spring事务混用。

约定

  1. 本框架只做 切换数据源 这件核心的事情，并不限制你的具体操作，切换了数据源可以做任何CRUD。
  2. 配置文件所有以下划线 _ 分割的数据源 首部 即为组的名称，相同组名称的数据源会放在一个组下。
  3. 切换数据源可以是组名，也可以是具体数据源名称。组名则切换时采用负载均衡算法切换。
  4. 默认的数据源名称为 master ，你可以通过 spring.datasource.dynamic.primary 修改。
  5. 方法上的注解优先于类上注解。
  6. DS支持继承抽象类上的DS，暂不支持继承接口上的DS。

使用方法

  1. 引入dynamic-datasource-spring-boot-starter。 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-agAQR9ec-1664518235894)(https://img.shields.io/maven-central/v/com.baomidou/dynamic-datasource-spring-boot-starter.svg)]

    <dependency>
  <groupId>com.baomidou</groupId>
  <artifactId>dynamic-datasource-spring-boot-starter</artifactId>
  <version>${version}</version>
</dependency>

  2. 配置数据源

    spring:
  datasource:
    dynamic:
      primary: master #设置默认的数据源或者数据源组,默认值即为master
      strict: false #严格匹配数据源,默认false. true未匹配到指定数据源时抛异常,false使用默认数据源
      datasource:
        master:
          url: jdbc:mysql://xx.xx.xx.xx:3306/dynamic
          username: root
          password: 123456
          driver-class-name: com.mysql.jdbc.Driver # 3.2.0开始支持SPI可省略此配置
        slave_1:
          url: jdbc:mysql://xx.xx.xx.xx:3307/dynamic
          username: root
          password: 123456
          driver-class-name: com.mysql.jdbc.Driver
        slave_2:
          url: ENC(xxxxx) # 内置加密,使用请查看详细文档
          username: ENC(xxxxx)
          password: ENC(xxxxx)
          driver-class-name: com.mysql.jdbc.Driver
          
       #......省略
       #以上会配置一个默认库master，一个组slave下有两个子库slave_1,slave_2

  3. 使用 @DS 切换数据源。

    @DS 可以注解在方法上或类上，同时存在就近原则 方法上注解 优先于 类上注解。

    注解结果
    没有@DS默认数据源
    @DS(“dsName”)dsName可以为组名也可以为具体某个库的名称
    @Service
@DS("slave")
public class UserServiceImpl implements UserService {

  @Autowired
  private JdbcTemplate jdbcTemplate;

  public List selectAll() {
    return  jdbcTemplate.queryForList("select * from user");
  }
  
  @Override
  @DS("slave_1")
  public List selectByCondition() {
    return  jdbcTemplate.queryForList("select * from user where age >10");
  }
}
几多心跳
关注
  • 3
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
xxl-job任务调度中心实现数据同步
weixin_42905671的博客
11-21 2141
继续上一篇Spring Boot + Mybatis-Plus实现多数据源的内容。 本次选用的xxl-job版本为2.1.1 目前我们分别有master库与local库，并且都拥有一张users表。但只有master库中存在数据 需求：将master库中的数据，同步更新到local库 是不是特别简单，先查master，再插入local。无则插入，有则检查更新。 问题： 1、我不想手动run来实现该功能，如何自定义执行时间，使其自动运行呢？ 2、每次执行，我应该从master中获取多少条数据来进行操作呢.
springboot：通过http动态操作xxl-job任务
拒绝熬夜啊的博客
08-03 2182
springboot：通过http动态操作xxl-job任务
完整Demo：springboot集成多数据源
07-28
完整Demo：springboot集成多数据源，是一个完整的项目，直接下载下来导入eclipse或idea，启动后运行即可。
SpringBoot整合Xxl-Job
最新发布
林知屿的博客
03-20 3332
这样就表示Xxl-Job成功运行了。确保运行没问题后，就可以开始下一步。注意:在运行之前，需要把2的sql脚本执行完毕，并修改数据库连接池。可以不用eureka，这里我的项目中用到eureka所以增加该配置。第三、确实非常容易上手且轻量化(轻量化的一个体现就是非侵入式)第一、团队里有好几个人上一家公司或上上家公司用过。第二、这个生态比较丰富且开源。用户名默认为admin。
JAVA、SpringBoot实现多数据源同时处理数据。
weixin_49341379的博客
06-26 1200
Spring实现多数据源同时操作数据。
springboot配置多数据源并且保证主从一致
delete_bug的博客
07-10 831
springboot配置多数据源以及主从同步快速上手
springboot多数据源配置
07-28
springboot多数据源配置
xxl-job-springboot_xxl-job_
10-03
xxl-job的源代码包，springboot-xxl-job
dataX+xxl-job+openjdk11+默认执行器+python
07-07
dataX+xxl-job+openjdk11+默认执行器+python
SpringCloud+MybatisPlus+XXL-JOB+redis+Vue前后端分离、分布式、微服务架构Java商城系统
04-24
Spring Cloud +MybatisPlus+XXL-JOB+redis+Vue的前后端分离、分布式、微服务架构的Java商城系统，采用稳定框架开发及优化核心，减少依赖，具备出色的执行效率，扩展性、稳定性高，H5/小程序/APP三端合一数据打通，...
springboot集成xxl-job
02-15
springboot集成xxl-job
xxl-job数据库配置文件
07-19
xxl-job数据库配置文件
SpringBoot整合XXL-JOB项目，以及附带使用xxl-job邮件定时发送。
08-17
SpringBoot整合XXL-JOB项目，以及附带使用xxl-job邮件定时发送，一个特别好用的demo，一看就懂。企业级规范。
Spring-boot 双数据源实现数据同步，批量插入数据
qq_39608433的博客
07-21 4463
最近在搞一个数据同步的模块，然后我就用到了mybatis-plus 批量插入数据 pom.xml 引入了这两个jar 包 <dependency> <groupId>org.mybatis.spring.boot</groupId> <artifactId>mybatis-spring-boot-starter</artifactId> <version>1.2.0</version> &.
菜鸟开发之任务调度--不同数据源数据同步
LCUANDEMUBAI的博客
04-14 836
多数据源配置解决不同数据源之间的数据问题
基于SpringBoot的XXL-JOB集成mybatis-plus+druid多数据源配置
花开不败才是姿态
12-16 3831
一、简介 二、过程 新建一个SpringBoot项目，或使用现有的SpringBoot项目； maven配置pom.xml，导入相关的依赖 编写application.yml，如：项目路径名及端口，mybatisplus配置，mysql多数据源配置。 新建DataSourceContextHolder 用于设置，获取，清空 当前线程内的数据源变量。 新建 MultipleDataSource 实现 AbstractRoutingDataSource 类。重写determineCurren..
Spring Boot 整合多数据源，这才叫优雅
Trouvailless的博客
08-13 163
afterOpt()方法在方法执行之后执行，清除掉ThreadLocal中的KEY，保证了如果不切换数据源，则用默认的数据源。多数据源的情况下并不是多个数据源并存的，Spring提供了AbstractRoutingDataSource这样一个抽象类，使得能够在多数据源的情况下任意切换，相当于一个动态路由的作用，作者称之为动态数据源。以上构建的两个数据源，一个是默认的数据源，一个是需要切换到的数据源(targetDataSources)，这样就组成了动态数据源了。其实这仅仅是一种方式，下面介绍另外一种方式。.
基于SpringBoot集成DATAX、XXL-JOB实现离线数据定时同步实践
热门推荐
HIT的专栏
02-02 1万+
在很多实际应用中，需要实现离线数据定时同步，比如生产库和运营库分离之后，在运营库实现离线数据对账。 本文介绍一种实现方式，完成基于SpringBoot集成DATAX、XXL-JOB实现离线数据定时同步。 一、集成XXL-JOB 集成XXL-JOB，需要添加xxl-job-admin、xxl-job-core模块。在主工程配置中添加: <modules> <module&g...
千万数据接口同步
北漂猿
08-01 1140
一、背景 公众号迁移，需要把A服务器的粉丝数据迁移到B的服务器,采取HTTP的方式传输 数据大概500多万 耗时大概25个小时 二、技术方案 调用端：A 采用PHP脚本调用api A服务器上传PHP脚本，从数据库每次查出1000条数据后调用api执行一次操作 通过ID分段同时启用三个进程同时跑 接收端：B服务器 采用thinkPHP5框架 通信加密采用openssl 一次500条数据批量插入 有抛错我会把错误的批次数据写入一个文件，把抛错信息写入另一个文件 数据跑完后用脚本单独处理抛错的批次数据，逐
SpringBoot+xxl-job 代码
05-10
以下是一个简单的 Spring Boot 集成 xxl-job 的示例代码： 1. 在 pom.xml 中添加依赖： ```xml <dependency> <groupId>com.xuxueli</groupId> <artifactId>xxl-job-core</artifactId> <version>${xxl.job.version}</version> </dependency> ``` 2. 在 application.properties 中添加配置： ```properties # xxl-job admin 地址 xxl.job.admin.addresses=http://localhost:8080/xxl-job-admin # 执行器名称 xxl.job.executor.appname=myJobExecutor # 执行器 IP xxl.job.executor.ip=127.0.0.1 # 执行器端口 xxl.job.executor.port=9999 # 执行器日志路径 xxl.job.executor.logpath=/data/applogs/xxl-job/jobhandler # 执行器日志保留天数 xxl.job.executor.logretentiondays=30 ``` 3. 创建一个 JobHandler 类： ```java @Component public class MyJobHandler extends IJobHandler { @Override public ReturnT<String> execute(String param) throws Exception { // 业务逻辑 return ReturnT.SUCCESS; } } ``` 4. 在启动类中添加 xxl-job 的配置和初始化： ```java @SpringBootApplication @EnableXxlJob public class MyApplication { public static void main(String[] args) { SpringApplication.run(MyApplication.class, args); } @Bean public XxlJobSpringExecutor xxlJobExecutor() { XxlJobSpringExecutor executor = new XxlJobSpringExecutor(); executor.setAdminAddresses("http://localhost:8080/xxl-job-admin"); executor.setAppName("myJobExecutor"); executor.setIp("127.0.0.1"); executor.setPort(9999); executor.setLogPath("/data/applogs/xxl-job/jobhandler"); executor.setLogRetentionDays(30); return executor; } } ``` 5. 在 xxl-job-admin 中创建一个任务，并指定执行器为 myJobExecutor，JobHandler 类为 MyJobHandler。 以上就是一个简单的 Spring Boot 集成 xxl-job 的示例代码，你可以根据自己的需求进行修改和扩展。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值