sharding-jdbc实现分库分表

最新推荐文章于 2023-10-25 20:47:01 发布
最新推荐文章于 2023-10-25 20:47:01 发布
阅读量588 收藏 1
点赞数 1
分类专栏： 分库分表 文章标签： 分库分表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/P397226804/article/details/109097393
版权

      项目初期版本使用当当sharding-jdbc进行数据库的分库分表操作，后续项目存储更换为自研弹性数据库。总结学习当当数据库中间件sharding-jdbc，并完成demo，可运行，下面列出demo代码说明：

       建表sql  

/*
Navicat MySQL Data Transfer 在Navicat中直接运行本sql文件创建表
* 两个库：test_msg1   包含两个表： t_order_0   t_order_1
*         test_msg2  包含两个表： t_order_0   t_order_1
*  建表sql如下
*/
 
SET FOREIGN_KEY_CHECKS=0;
 
-- ----------------------------
-- Table structure for `users`
-- ----------------------------
DROP TABLE IF EXISTS `t_order_0`;
CREATE TABLE `t_order_0` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键id',
  `order_id` varchar(32) DEFAULT NULL COMMENT '顺序编号',
  `user_id` varchar(32) DEFAULT NULL COMMENT '用户编号',
  `userName` varchar(32) DEFAULT NULL COMMENT '用户名',
  `passWord` varchar(32) DEFAULT NULL COMMENT '密码',
  `user_sex` varchar(32) DEFAULT NULL,
  `nick_name` varchar(32) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=28 DEFAULT CHARSET=utf8;

pom文件 

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
 
    <groupId>com.chun</groupId>
    <artifactId>spring-boot-mybatis-sharding-jdbc</artifactId>
    <version>1.0-SNAPSHOT</version>
 
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.4.2.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
 
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <java.version>1.8</java.version>
    </properties>
 
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.1.1</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <optional>true</optional>
        </dependency>
 
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
 
        <!--sharding-jdbc -->
        <dependency>
            <groupId>com.dangdang</groupId>
            <artifactId>sharding-jdbc-core</artifactId>
            <version>1.5.4</version>
        </dependency>
 
        <!--<dependency>-->
            <!--<groupId>javax.persistence</groupId>-->
            <!--<artifactId>persistence-api</artifactId>-->
            <!--<version>1.0</version>-->
        <!--</dependency>-->
    </dependencies>
 
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <fork>true</fork>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

分库分表最主要有几个配置：

  1. 有多少个数据源
  2. 每张表的逻辑表名和所有物理表名
  3. 用什么列进行分库以及分库算法
  4. 用什么列进行分表以及分表算法
    分为两个库：test_msg1 , test_msg2，
    每个库都包含两个表: t_order_0 , t_order_1
    使用user_id作为分库列；
    使用order_id作为分表列；

配置文件：

application.properties

配置数据源相关数据属性。

mybatis.config-locations=classpath:mybatis/mybatis-config.xml
 
#datasource
spring.devtools.remote.restart.enabled=false
 
#data source1
spring.datasource.test1.driverClassName=com.mysql.jdbc.Driver
spring.datasource.test1.url=jdbc:mysql://127.0.0.1:3306/test_msg1
spring.datasource.test1.username=root
spring.datasource.test1.password=root
 
#data source2
spring.datasource.test2.driverClassName=com.mysql.jdbc.Driver
spring.datasource.test2.url=jdbc:mysql://127.0.0.1:3306/test_msg2
spring.datasource.test2.username=root
spring.datasource.test2.password=root

Application

Application.java
package com.chun;
 
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
import org.springframework.transaction.annotation.EnableTransactionManagement;
 
/**
 * Created by Kane on 2018/1/17.
 */
@SpringBootApplication
@EnableAutoConfiguration(exclude={DataSourceAutoConfiguration.class}) //排除DataSourceConfiguratrion
@EnableTransactionManagement(proxyTargetClass = true)   //开启事物管理功能
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

Entity 定义实体类

UserEntity.java
package com.chun.entity;
 
import com.chun.enums.UserSexEnum;
import java.io.Serializable;
 
/**
 * Created by Kane on 2018/1/17.
 */
public class UserEntity implements Serializable {
 
    private static final long serialVersionUID = 1L;
    private Long id;
    private Long order_id;
    private Long user_id;
    private String userName;
    private String passWord;
    private UserSexEnum userSex;
    private String nickName;
 
    public Long getId() {
        return id;
    }
 
    public void setId(Long id) {
        this.id = id;
    }
 
 
    public Long getOrder_id() {
        return order_id;
    }
 
    public void setOrder_id(Long order_id) {
        this.order_id = order_id;
    }
 
    public Long getUser_id() {
        return user_id;
    }
 
    public void setUser_id(Long user_id) {
        this.user_id = user_id;
    }
 
    public String getUserName() {
        return userName;
    }
 
    public void setUserName(String userName) {
        this.userName = userName;
    }
 
    public String getPassWord() {
        return passWord;
    }
 
    public void setPassWord(String passWord) {
        this.passWord = passWord;
    }
 
    public UserSexEnum getUserSex() {
        return userSex;
    }
 
    public void setUserSex(UserSexEnum userSex) {
        this.userSex = userSex;
    }
 
    public String getNickName() {
        return nickName;
    }
 
    public void setNickName(String nickName) {
        this.nickName = nickName;
    }
 
}

UserSexEnum.java

package com.chun.enums;
 
/**
 * Created by Kane on 2018/1/17.
 */
public enum UserSexEnum {
    MAN, WOMAN
}

Service层

User1Service.java
package com.chun.service;
 
import com.chun.entity.UserEntity;
import com.chun.mapper.User1Mapper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
 
import java.util.List;
 
/**
 * Created by Kane on 2018/1/17.
 */
@Slf4j
@Service
public class User1Service {
 
    @Autowired
    private User1Mapper user1Mapper;
 
    public List<UserEntity> getUsers() {
        List<UserEntity> users=user1Mapper.getAll();
        return users;
    }
 
//    @Transactional(value="test1TransactionManager",rollbackFor = Exception.class,timeout=36000)  //说明针对Exception异常也进行回滚，如果不标注，则Spring 默认只有抛出 RuntimeException才会回滚事务
    public void updateTransactional(UserEntity user) {
        try{
            user1Mapper.insert(user);
            log.error(String.valueOf(user));
        }catch(Exception e){
            log.error("find exception!");
            throw e;   // 事物方法中，如果使用trycatch捕获异常后，需要将异常抛出，否则事物不回滚。
        }
 
    }
}

Mapper层

User1Mapper.java
package com.chun.mapper;
 
import com.chun.entity.UserEntity;
 
import java.util.List;
 
/**
 * Created by Kane on 2018/1/17.
 */
public interface User1Mapper {
 
    List<UserEntity> getAll();
 
    void update(UserEntity user);
 
}

数据源配置及Mybatis配置：

配置多个数据源，数据源的名称最好要有一定的规则，方便配置分库的计算规则；
配置数据源规则，即将多个数据源交给sharding-jdbc管理，并且可以设置默认的数据源，当表没有配置分库规则时会使用默认的数据源；
分库：
user_id % 2 = 0的数据存储到test_msg1 ，为1的数据存储到test_msg0
分表：
order_id % 2 = 0的数据存储到 t_order_0，为1的数据存储到t_order_1

DataSourceConfig.java
package com.chun;
 
 
import com.chun.strategy.ModuloDatabaseShardingAlgorithm;
import com.chun.strategy.ModuloTableShardingAlgorithm;
import com.dangdang.ddframe.rdb.sharding.api.ShardingDataSourceFactory;
import com.dangdang.ddframe.rdb.sharding.api.rule.BindingTableRule;
import com.dangdang.ddframe.rdb.sharding.api.rule.DataSourceRule;
import com.dangdang.ddframe.rdb.sharding.api.rule.ShardingRule;
import com.dangdang.ddframe.rdb.sharding.api.rule.TableRule;
import com.dangdang.ddframe.rdb.sharding.api.strategy.database.DatabaseShardingStrategy;
import com.dangdang.ddframe.rdb.sharding.api.strategy.table.TableShardingStrategy;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.SqlSessionTemplate;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.jdbc.DataSourceBuilder;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
 
import javax.sql.DataSource;
import java.sql.SQLException;
import java.util.*;
 
/**
 *  数据源及分表配置
 * Created by Kane on 2018/1/17.
 */
@Configuration
@MapperScan(basePackages = "com.chun.mapper", sqlSessionTemplateRef  = "test1SqlSessionTemplate")
public class DataSourceConfig {
 
 
    /**
     * 配置数据源0，数据源的名称最好要有一定的规则，方便配置分库的计算规则
     * @return
     */
    @Bean(name="dataSource0")
    @ConfigurationProperties(prefix = "spring.datasource.test1")
    public DataSource dataSource0(){
        return DataSourceBuilder.create().build();
    }
    /**
     * 配置数据源1，数据源的名称最好要有一定的规则，方便配置分库的计算规则
     * @return
     */
    @Bean(name="dataSource1")
    @ConfigurationProperties(prefix = "spring.datasource.test2")
    public DataSource dataSource1(){
        return DataSourceBuilder.create().build();
    }
 
    /**
     * 配置数据源规则，即将多个数据源交给sharding-jdbc管理，并且可以设置默认的数据源，
     * 当表没有配置分库规则时会使用默认的数据源
     * @param dataSource0
     * @param dataSource1
     * @return
     */
    @Bean
    public DataSourceRule dataSourceRule(@Qualifier("dataSource0") DataSource dataSource0,
                                         @Qualifier("dataSource1") DataSource dataSource1){
        Map<String, DataSource> dataSourceMap = new HashMap<>(); //设置分库映射
        dataSourceMap.put("dataSource0", dataSource0);
        dataSourceMap.put("dataSource1", dataSource1);
        return new DataSourceRule(dataSourceMap, "dataSource0"); //设置默认库，两个库以上时必须设置默认库。默认库的数据源名称必须是dataSourceMap的key之一
    }
 
    /**
     * 配置数据源策略和表策略，具体策略需要自己实现
     * @param dataSourceRule
     * @return
     */
    @Bean
    public ShardingRule shardingRule(DataSourceRule dataSourceRule){
        //具体分库分表策略
        TableRule orderTableRule = TableRule.builder("t_order")
                .actualTables(Arrays.asList("t_order_0", "t_order_1"))
                .tableShardingStrategy(new TableShardingStrategy("order_id", new ModuloTableShardingAlgorithm()))
                .dataSourceRule(dataSourceRule)
                .build();
 
        //绑定表策略，在查询时会使用主表策略计算路由的数据源，因此需要约定绑定表策略的表的规则需要一致，可以一定程度提高效率
        List<BindingTableRule> bindingTableRules = new ArrayList<BindingTableRule>();
        bindingTableRules.add(new BindingTableRule(Arrays.asList(orderTableRule)));
        return ShardingRule.builder()
                .dataSourceRule(dataSourceRule)
                .tableRules(Arrays.asList(orderTableRule))
                .bindingTableRules(bindingTableRules)
                .databaseShardingStrategy(new DatabaseShardingStrategy("user_id", new ModuloDatabaseShardingAlgorithm()))
                .tableShardingStrategy(new TableShardingStrategy("order_id", new ModuloTableShardingAlgorithm()))
                .build();
    }
 
    /**
     * 创建sharding-jdbc的数据源DataSource，MybatisAutoConfiguration会使用此数据源
     * @param shardingRule
     * @return
     * @throws SQLException
     */
    @Bean(name="dataSource")
    public DataSource shardingDataSource(ShardingRule shardingRule) throws SQLException {
        return ShardingDataSourceFactory.createDataSource(shardingRule);
    }
 
    /**
     * 需要手动配置事务管理器
     * @param dataSource
     * @return
     */
    @Bean
    public DataSourceTransactionManager transactitonManager(@Qualifier("dataSource") DataSource dataSource){
        return new DataSourceTransactionManager(dataSource);
    }
 
    @Bean(name = "test1SqlSessionFactory")
    @Primary
    public SqlSessionFactory testSqlSessionFactory(@Qualifier("dataSource") DataSource dataSource) throws Exception {
        SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
        bean.setDataSource(dataSource);
        bean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath:mybatis/mapper/*.xml"));
        return bean.getObject();
    }
 
    @Bean(name = "test1SqlSessionTemplate")
    @Primary
    public SqlSessionTemplate testSqlSessionTemplate(@Qualifier("test1SqlSessionFactory") SqlSessionFactory sqlSessionFactory) throws Exception {
        return new SqlSessionTemplate(sqlSessionFactory);
    }
}

分库策略实现：

ModuloDatabaseShardingAlgorithm.java
package com.chun.strategy;
 
import com.dangdang.ddframe.rdb.sharding.api.ShardingValue;
import com.dangdang.ddframe.rdb.sharding.api.strategy.database.SingleKeyDatabaseShardingAlgorithm;
import com.google.common.collect.Range;
 
import java.util.Collection;
import java.util.LinkedHashSet;
 
/**
 * 分库策略的简单实现
 * Created by Kane on 2018/1/22.
 */
public class ModuloDatabaseShardingAlgorithm implements SingleKeyDatabaseShardingAlgorithm<Long> {
 
    @Override
    public String doEqualSharding(Collection<String> databaseNames, ShardingValue<Long> shardingValue) {
        for (String each : databaseNames) {
            if (each.endsWith(Long.parseLong(shardingValue.getValue().toString()) % 2 + "")) {
                return each;
            }
        }
        throw new IllegalArgumentException();
    }
 
    @Override
    public Collection<String> doInSharding(Collection<String> databaseNames, ShardingValue<Long> shardingValue) {
        Collection<String> result = new LinkedHashSet<>(databaseNames.size());
        for (Long value : shardingValue.getValues()) {
            for (String tableName : databaseNames) {
                if (tableName.endsWith(value % 2 + "")) {
                    result.add(tableName);
                }
            }
        }
        return result;
    }
 
    @Override
    public Collection<String> doBetweenSharding(Collection<String> databaseNames, ShardingValue<Long> shardingValue) {
        Collection<String> result = new LinkedHashSet<>(databaseNames.size());
        Range<Long> range = (Range<Long>) shardingValue.getValueRange();
        for (Long i = range.lowerEndpoint(); i <= range.upperEndpoint(); i++) {
            for (String each : databaseNames) {
                if (each.endsWith(i % 2 + "")) {
                    result.add(each);
                }
            }
        }
        return result;
    }
}

debug方法doEqualSharding会发现：

 

分库代码.png

doEqualSharding参数.png

根据user_id的值返回路由的库的名称。
分库：
user_id % 2 = 0的数据存储到test_msg1 ，为1的数据存储到test_msg0，

分表策略的基本实现

分表逻辑类需要实现SingleKeyTableShardingAlgorithm接口的三个方法doBetweenSharding、doEqualSharding、doInSharding

ModuloTableShardingAlgorithm.java
package com.chun.strategy;
 
import com.dangdang.ddframe.rdb.sharding.api.ShardingValue;
import com.dangdang.ddframe.rdb.sharding.api.strategy.table.SingleKeyTableShardingAlgorithm;
import com.google.common.collect.Range;
 
import java.util.Collection;
import java.util.LinkedHashSet;
 
/**
 * 分表策略的基本实现
 * Created by Kane on 2018/1/22.
 */
public class ModuloTableShardingAlgorithm implements SingleKeyTableShardingAlgorithm<Long> {
 
    @Override
    public String doEqualSharding(Collection<String> tableNames, ShardingValue<Long> shardingValue) {
        for (String each : tableNames) {
            if (each.endsWith(shardingValue.getValue() % 2 + "")) {
                return each;
            }
        }
        throw new IllegalArgumentException();
    }
 
    @Override
    public Collection<String> doInSharding(Collection<String> tableNames, ShardingValue<Long> shardingValue) {
        Collection<String> result = new LinkedHashSet<>(tableNames.size());
        for (Long value : shardingValue.getValues()) {
            for (String tableName : tableNames) {
                if (tableName.endsWith(value % 2 + "")) {
                    result.add(tableName);
                }
            }
        }
        return result;
    }
 
    @Override
    public Collection<String> doBetweenSharding(Collection<String> tableNames, ShardingValue<Long> shardingValue) {
        Collection<String> result = new LinkedHashSet<>(tableNames.size());
        Range<Long> range = (Range<Long>) shardingValue.getValueRange();
        for (Long i = range.lowerEndpoint(); i <= range.upperEndpoint(); i++) {
            for (String each : tableNames) {
                if (each.endsWith(i % 2 + "")) {
                    result.add(each);
                }
            }
        }
        return result;
    }
}

Controller层

UserController.java
package com.chun.web;
 
import com.chun.entity.UserEntity;
import com.chun.enums.UserSexEnum;
import com.chun.service.User1Service;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
 
import java.util.List;
 
/**
 * Created by Kane on 2018/1/17.
 */
@Service
@RestController
public class UserController {
 
    @Autowired
    private User1Service user1Service;
 
    @RequestMapping("/getUsers")
    public List<UserEntity> getUsers() {
        List<UserEntity> users=user1Service.getUsers();
        return users;
    }
 
    //测试
    @RequestMapping(value="insert1")
    public String updateTransactional(@RequestParam(value = "id") Long id,
                                    @RequestParam(value = "user_id") Long user_id,
                                    @RequestParam(value = "order_id") Long order_id,
                                    @RequestParam(value = "nickName") String nickName,
                                    @RequestParam(value = "passWord") String passWord,
                                    @RequestParam(value = "userName") String userName
                                    ) {
        UserEntity user2 = new UserEntity();
        user2.setId(id);
        user2.setUser_id(user_id);
        user2.setOrder_id(order_id);
        user2.setNickName(nickName);
        user2.setPassWord(passWord);
        user2.setUserName(userName);
        user2.setUserSex(UserSexEnum.WOMAN);
        user1Service.updateTransactional(user2);
        return "test";
    }
}

Mybatis 配置文件

resources/mybatis/mapper/UserMapper.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.chun.mapper.User1Mapper" >
    <resultMap id="BaseResultMap" type="com.chun.entity.UserEntity" >
        <id column="id" property="id" jdbcType="BIGINT" />
        <result column="order_id" property="order_id" jdbcType="BIGINT" />
        <result column="user_id" property="user_id" jdbcType="BIGINT" />
        <result column="userName" property="userName" jdbcType="VARCHAR" />
        <result column="passWord" property="passWord" jdbcType="VARCHAR" />
        <result column="user_sex" property="userSex" javaType="com.chun.enums.UserSexEnum"/>
        <result column="nick_name" property="nickName" jdbcType="VARCHAR" />
    </resultMap>
 
    <sql id="Base_Column_List" >
        id, userName, passWord, user_sex, nick_name
    </sql>
 
    <select id="getAll" resultMap="BaseResultMap"  >
        SELECT
        <include refid="Base_Column_List" />
        FROM t_order
    </select>
 
    <insert id="insert" parameterType="com.chun.entity.UserEntity" >
        INSERT INTO
        t_order
        (order_id,user_id,userName,passWord,user_sex)
        VALUES
        (#{order_id},#{user_id},#{userName}, #{passWord}, #{userSex})
    </insert>
 
</mapper>
resources/mybatis/mybatis-config.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <typeAliases>
        <typeAlias alias="Integer" type="java.lang.Integer" />
        <typeAlias alias="Long" type="java.lang.Long" />
        <typeAlias alias="HashMap" type="java.util.HashMap" />
        <typeAlias alias="LinkedHashMap" type="java.util.LinkedHashMap" />
        <typeAlias alias="ArrayList" type="java.util.ArrayList" />
        <typeAlias alias="LinkedList" type="java.util.LinkedList" />
    </typeAliases>
</configuration>

如果报错： jdbcUrl is required with driverClassName，按照下面解决：

springboot2.0配置多数据源：

spring.datasource.primary.url=jdbc:mysql://localhost:3306/study?useUnicode=true&characterEncoding=utf-8&useSSL=true
spring.datasource.primary.username=root
spring.datasource.primary.password=root
spring.datasource.primary.driver-class=com.mysql.cj.jdbc.Driver

spring.datasource.secondary.url=jdbc:mysql://localhost:3306/study?useUnicode=true&characterEncoding=utf-8&useSSL=true
spring.datasource.secondary.username=root
spring.datasource.secondary.password=root
spring.datasource.secondary.driver-class=com.mysql.cj.jdbc.Driver

改为：

spring.datasource.primary.jdbc-url=jdbc:mysql://localhost:3306/study?useUnicode=true&characterEncoding=utf-8&useSSL=true
spring.datasource.primary.username=root
spring.datasource.primary.password=root
spring.datasource.primary.driver-class-name=com.mysql.cj.jdbc.Driver

spring.datasource.secondary.jdbc-url=jdbc:mysql://localhost:3306/study?useUnicode=true&characterEncoding=utf-8&useSSL=true
spring.datasource.secondary.username=root
spring.datasource.secondary.password=root
spring.datasource.secondary.driver-class-name=com.mysql.cj.jdbc.Driver

 

spring.datasource.url 数据库的 JDBC URL。

spring.datasource.jdbc-url 用来重写自定义连接池

官方文档的解释是：

因为连接池的实际类型没有被公开，所以在您的自定义数据源的元数据中没有生成密钥，而且在IDE中没有完成(因为DataSource接口没有暴露属性)。另外，如果您碰巧在类路径上有Hikari，那么这个基本设置就不起作用了，因为Hikari没有url属性(但是确实有一个jdbcUrl属性)。在这种情况下，您必须重写您的配置如下:

原文地址：https://blog.csdn.net/newbie_907486852/article/details/81391525

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

Wuli波板糖
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【项目实战】基于分库分表神器 Sharding-JDBC实现分表
本本本添哥
03-29 245
}SERVER_PORT : 9999 } spring : #数据库连接配置 application : name : sharding - jdbc datasource : driver-class-name : com.mysql.cj.jdbc.Driver username : $ {
sharding分库分表demo
12-02
主要技术有: springboot shardingsphere swagger mybatis-plus mysql
Sharding-JDBC（九）5.3.0版本，实现按月分表、自动建表、自动刷新节点
ACGkaka的博客
08-30 3753
Sharding-JDBC（九）5.3.0版本，实现按月分表、自动建表、自动刷新节点
SharDingJDBC-5.1.0按月水平分表+读写分离，自动创表、自动刷新节点表
m0_54850467的博客
06-12 4653
4升到5过后还是解决了许多问题，4版本的跨库和子查询问题都可以了，性能也提高了 实现自动创建表，动态获取节点表，配置如下 建表语句可以使用下面这句，解决很多麻烦问题 CREATE TABLE newName LIKE oldName 读写分离需要配置数据库有主从同步 分片策略实现类 和4版本不一样，5版本更新和查询合并在一起了 实现 StandardShardingAlgorithm 缓存工具类，自动创建表，放入缓存中， 项目启动就加载缓存 更新和查询数据直接从缓存中读取表名 时间工具类 自动刷新节点表，也
springBoot使用ShardingJDBC实现分表
lockie的博客
02-23 2219
springBoot使用ShardingJDBC实现分表
Spring Boot 集成 Sharding-JDBC + Mybatis-Plus 实现分库分表功能
09-07
主要介绍了Spring Boot 集成 Sharding-JDBC + Mybatis-Plus 实现分库分表功能,本文通过实例代码给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下
集成sharding-jdbc实现分库分表.zip
12-19
集成sharding-jdbc实现分库分表.zip
SpringBoot_shardDB_shardTable:SpringBoot集成Sharding-JDBC实现分库分表，自定义分片算法，基于一致性hash算法，易于扩容
05-31
整合了 Sharding-JDBC ，实现了 分库分表，并且在分库分表中实现了自定义的分片算法; 一致性Hash算法，易于扩容；添加了 单元测试，使用Spring提供的RestTemplate调用RestFul风格的API接口；整合了 quartz 定时任务...
基于yml 配置方式 ，实现springBoot+sharding-jdbc+mybatis-plus 实现分库分表，读写分离，以及全局表，子表的配置
10-26
1、基于yml 配置方式 ，实现springBoot+sharding-jdbc+mybatis-plus 实现分库分表，读写分离，以及全局表，子表的配置。 2、实现mybatis-plus 整合到springboot 详细使用请看 测试用例
sharding-jdbc之——分库分表实例完整源码
02-25
sharding-jdbc之——分库分表实例完整源码，详情请参见博文：http://blog.csdn.net/l1028386804/article/details/79368021
分库分表利器——shardingJdbc
少年Dream
11-19 995
把一张表的一部分字段存在一张新表里面，将另一部分字段存在另一张新表中。
SharDingJDBC-5.1.1+Druid+Mybaits-P按月水平分表+读写分离，自动创表、自动刷新节点表
热门推荐
weixin_51216079的博客
06-17 60万+
5.1.0的可以直接升级,此次代码比较完整，可以正常使用！ SpringBoot、Mybaits-Plus、Druid 解决druid启动报错的问题 中文社区—————————— 官方网站 YML 自定义策略类 缓存工具类，项目启动就会加载 项目启动就执行.......................................
sharding-jdbc-4.1.1按月分表方案，自动建表，启动刷新配置为数据库真实存在的表
weixin_43080166的博客
08-30 851
2内存中的节点跳过配置规则，从数据库获取真实存在的表（解决全局搜索，规则配置时间跨度过大，表不存在问题）DatePreciseShardingAlgorithm 精准分片，每月自动建表和规则的刷新从这开始触发。between 边界查询使用，表多时可进一步优化。1每月自动进行建表，同时刷新节点规则。总体代码入侵挺多，不过能跑就行 =_=初始化刷新节点规则获取真实存在的表。
ShardingJDBC分表以及自动化建表方案（避坑攻略）
he__xu的博客
07-27 7772
前言 最近死磕…应该是磕死在了分表上，因为做的学校项目，对学校每学期数据会达到千万级别的表需要做分表处理，刚开始分表工具方案的选取，有试过mysql自带的表分区功能，Mycat，因为项目需要根据学期来进行自动分表，而且数据表需要程序根据学期的更新来自动创建，就是说比如原表为A，当监听到学期发生改变时，若改变为2020-202102学年学期，则需要自动创建一张A202102的历史表，分表路径的表名也需要根据学期自动化拼接。所以最后采用了ShardingJdbc，可以实现复杂情况下的路由键表名拼接，不需要对原项
excel怎么把竖排变成横排_Excel柱状图看不清？3种方法，立马变直观！
weixin_39823299的博客
11-10 1946
大家先来看看，这个图表有什么问题？很明显，问题在于文本横坐标轴「数据系列名称」过长，导致其出现倾斜状况。由于文本倾斜，我们阅读时也有点吃力。那么，对于文本倾斜，我们又该怎么办呢？今天就来一起看看吧~这里主要介绍 3 种方法：❶ 更改图表类型为条形图；❷ 利用【Alt+Enter】对系列名称强制换行；❸ 强制转换文本方向。首先，数据系列比较多的情况下，我们一般选用条形图而不是柱形图。更改图表类型为条...
sharingjdbc5.x多数据源分库分表读写分离自动创表实现（pgsql）(一)
u014730578的博客
02-02 682
shardingjdbc 分库分表读写分离
如何让柱状图的柱子不紧挨坐标轴
super帅的博客
06-20 1779
如何让柱状图的柱子不紧挨坐标轴
Sharding-JDBC（三）4.0.0-RC1版本，实现按月分表、动态建表、自动刷新节点
ACGkaka的博客
12-20 2318
按月分表、自动建表
Sharding-JDBC-5.1.0 实现按月分表、动态建表
最新发布
abc_xian的博客
10-25 1830
Sharding-JDBC-5.1.0 实现按月分表、自动建表、自动刷新节点
使用sharding-jdbc分库分表
07-28
Sharding-JDBC是一个开源的分库分表中间件，它提供了一种简单、高效、灵活的方式来实现数据库的分片和分表。 要使用Sharding-JDBC进行分库分表，你需要进行以下步骤： 1. 引入Sharding-JDBC的依赖：在你的项目中...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值