springboot系类代码：spring-boot-mybatis-sharding-jdbc-masterslave-springframework

最新推荐文章于 2023-12-21 12:53:50 发布
最新推荐文章于 2023-12-21 12:53:50 发布
阅读量169 收藏
点赞数
分类专栏： SpringBoot(TomcatJettyServlet) 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/blog_programb/article/details/106338924
版权
  • 读写分离特别适用于读多写少的场景下，通过分散读写到不同的数据库实例上来提高性能，缓解单机数据库的压力:

Name Remark
DQL 数据查询语言，比如select查询语句
DML 数据操纵语言，比如insert、delete、update更新语句
DDL 数据定义语言，比如create/drop/alter等语句
DCL 数据控制语言，比如grant/rollback/commit等语句

  • Sharding-JDBC是一个开源的分布式数据库中间件解决方案。它在Java的JDBC层以对业务应用零侵入的方式额外提供数据分片，读写分离，柔性事务和分布式治理能力。并在其基础上提供封装了MySQL协议的服务端版本，用于完成对异构语言的支持。
  • 基于JDBC的客户端版本定位为轻量级Java框架，使用客户端直连数据库，以jar包形式提供服务，无需额外部署和依赖，可理解为增强版的JDBC驱动，完全兼容JDBC和各种ORM框架。
  • 封装了MySQL协议的服务端版本定位为透明化的MySQL代理端，可以使用任何兼容MySQL协议的访问客户端(如：MySQL Command
    Client, MySQL Workbench等)操作数据，对DBA更加友好。
package com.programb.springboot.mybatis.shardingjdbc.masterslave;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;


@SpringBootApplication
public class Application {

	public static void main(String[] args) throws InterruptedException {
		SpringApplication.run(Application.class, args);
		Thread.sleep(Long.MAX_VALUE);
	}
}


package com.programb.springboot.mybatis.shardingjdbc.masterslave.config;

import com.alibaba.druid.pool.DruidDataSource;
import com.programb.springboot.mybatis.shardingjdbc.masterslave.constants.DataSourceConstants;

import io.shardingjdbc.core.api.ShardingDataSourceFactory;
import io.shardingjdbc.core.api.config.MasterSlaveRuleConfiguration;
import io.shardingjdbc.core.api.config.ShardingRuleConfiguration;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;

import javax.sql.DataSource;
import java.sql.SQLException;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;


public class DataSourceConfig {

    private String url;

    private String username;

    private String password;

    @Bean(name = "mybatisDataSource")
    public DataSource getDataSource() throws SQLException {
        Map<String, DataSource> dataSourceMap = new HashMap<>();

        DataSource masterDataSource0 = mybatisDataSource("ds_master_0");
        DataSource slaveDataSource00 = mybatisDataSource("ds_master_0_slave_0");
        DataSource slaveDataSource01 = mybatisDataSource("ds_master_0_slave_1");
        dataSourceMap.put("masterDataSource0", masterDataSource0);
        dataSourceMap.put("slaveDataSource00", slaveDataSource00);
        dataSourceMap.put("slaveDataSource01", slaveDataSource01);

        DataSource masterDataSource1 = mybatisDataSource("ds_master_1");
        DataSource slaveDataSource10 = mybatisDataSource("ds_master_1_slave_0");
        DataSource slaveDataSource11 = mybatisDataSource("ds_master_1_slave_1");
        dataSourceMap.put("masterDataSource1", masterDataSource1);
        dataSourceMap.put("slaveDataSource10", slaveDataSource10);
        dataSourceMap.put("slaveDataSource11", slaveDataSource11);

        // 构建读写分离配置
        MasterSlaveRuleConfiguration masterSlaveRuleConfig0 = new MasterSlaveRuleConfiguration();
        masterSlaveRuleConfig0.setName("ds_0");
        masterSlaveRuleConfig0.setMasterDataSourceName("masterDataSource0");
        masterSlaveRuleConfig0.getSlaveDataSourceNames().add("slaveDataSource00");
        masterSlaveRuleConfig0.getSlaveDataSourceNames().add("slaveDataSource01");

        MasterSlaveRuleConfiguration masterSlaveRuleConfig1 = new MasterSlaveRuleConfiguration();
        masterSlaveRuleConfig1.setName("ds_1");
        masterSlaveRuleConfig1.setMasterDataSourceName("masterDataSource1");
        masterSlaveRuleConfig1.getSlaveDataSourceNames().add("slaveDataSource10");
        masterSlaveRuleConfig1.getSlaveDataSourceNames().add("slaveDataSource11");

        // 通过ShardingSlaveDataSourceFactory继续创建ShardingDataSource
        ShardingRuleConfiguration shardingRuleConfig = new ShardingRuleConfiguration();
        shardingRuleConfig.getMasterSlaveRuleConfigs().add(masterSlaveRuleConfig0);
        shardingRuleConfig.getMasterSlaveRuleConfigs().add(masterSlaveRuleConfig1);

        DataSource dataSource = ShardingDataSourceFactory.createDataSource(dataSourceMap, shardingRuleConfig);
        return dataSource;
    }

    private DataSource mybatisDataSource(final String dataSourceName) throws SQLException {
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setDriverClassName(DataSourceConstants.DRIVER_CLASS);
        dataSource.setUrl(String.format(url, dataSourceName));
        dataSource.setUsername(username);
        dataSource.setPassword(password);

        /* 配置初始化大小、最小、最大 */
        dataSource.setInitialSize(1);
        dataSource.setMinIdle(1);
        dataSource.setMaxActive(20);

        /* 配置获取连接等待超时的时间 */
        dataSource.setMaxWait(60000);

        /* 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒 */
        dataSource.setTimeBetweenEvictionRunsMillis(60000);

        /* 配置一个连接在池中最小生存的时间，单位是毫秒 */
        dataSource.setMinEvictableIdleTimeMillis(300000);

        dataSource.setValidationQuery("SELECT 'x'");
        dataSource.setTestWhileIdle(true);
        dataSource.setTestOnBorrow(false);
        dataSource.setTestOnReturn(false);

        dataSource.setPoolPreparedStatements(false);
        dataSource.setMaxPoolPreparedStatementPerConnectionSize(20);

        /* 配置监控统计拦截的filters */
        dataSource.setFilters("stat,wall,log4j");
        return dataSource;
    }


    @Bean(name = "mybatisTransactionManager")
    public DataSourceTransactionManager mybatisTransactionManager(@Qualifier("mybatisDataSource") DataSource dataSource) throws SQLException {
        return new DataSourceTransactionManager(dataSource);
    }

    @Bean(name = "mybatisSqlSessionFactory")
    public SqlSessionFactory mybatisSqlSessionFactory(@Qualifier("mybatisDataSource") DataSource mybatisDataSource)
            throws Exception {
        final SqlSessionFactoryBean sessionFactory = new SqlSessionFactoryBean();
        sessionFactory.setDataSource(mybatisDataSource);
        return sessionFactory.getObject();
    }

    public String getUrl() {
        return url;
    }

    public void setUrl(String url) {
        this.url = url;
    }

    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;
    }

}


package com.programb.springboot.mybatis.shardingjdbc.masterslave.constants;


public abstract class DataSourceConstants {


    public static final String DATASOURCE_PREFIX = "mybatis.datasource";


    public static final String DRIVER_CLASS = "com.mysql.jdbc.Driver";


    public static final String MAPPER_PACKAGE = "com.programb.springboot.mybatis.shardingjdbc.masterslave.mapper";

}


package com.programb.springboot.mybatis.shardingjdbc.masterslave.constants;


public abstract class SqlConstants {


    public static final String USER_CREATE_SQL = "CREATE TABLE IF NOT EXISTS `t_user` (`id` bigint(20) AUTO_INCREMENT, `user_id` bigint(20) NOT NULL COMMENT '用户id',`city_id` int(11) DEFAULT NULL COMMENT '城市id',`user_name` varchar(15) DEFAULT NULL,`age` int(11) DEFAULT NULL COMMENT '年龄',`birth` date DEFAULT NULL COMMENT '生日',PRIMARY KEY (`id`))";

    public static final String GET_ALL_SQL = "SELECT * FROM t_user";

    public static final String GET_ONE_SQL = "SELECT * FROM t_user WHERE user_id = #{userId}";

    public static final String GET_LIMIT_ONE_SQL = "SELECT * FROM t_user LIMIT 1";

    public static final String INSERT_SLAVE_SQL = "INSERT INTO t_user(city_id,user_name,age,birth) VALUES(#{cityId}, #{userName}, #{age}, #{birth})";

    public static final String UPDATE_SQL = "UPDATE t_user SET user_name=#{userName},age=#{age},birth=#{birth} WHERE user_id =#{userId}";

    public static final String DELETE_SQL = "DELETE FROM t_user WHERE user_id =#{userId}";

    public static final String DELETE_ALL_SQL = "DELETE FROM t_user";

}


package com.programb.springboot.mybatis.shardingjdbc.masterslave.druid;

import com.alibaba.druid.support.http.StatViewServlet;
import com.alibaba.druid.support.http.WebStatFilter;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.boot.web.servlet.ServletRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;


@Configuration
public class DruidStatsConfig {


    @Bean
    public ServletRegistrationBean registrationBean() {
        ServletRegistrationBean bean = new ServletRegistrationBean(new StatViewServlet(), "/druid-stats/*");
        //白名单
        bean.addInitParameter("allow", "127.0.0.1");
        //IP黑名单 (存在共同时，deny优先于allow) : 如果满足deny的话提示:Sorry, you are not permitted to view this page.
        bean.addInitParameter("deny", "192.168.125.12");
        //登录查看信息的账号密码.
        bean.addInitParameter("loginUsername", "programb");
        bean.addInitParameter("loginPassword", "springboot");
        //是否能够重置数据.
        bean.addInitParameter("resetEnable", "false");
        return bean;
    }


    @Bean
    public FilterRegistrationBean druidStatFilter() {
        FilterRegistrationBean bean = new FilterRegistrationBean(new WebStatFilter());
        //添加过滤规则.
        bean.addUrlPatterns("/*");
        //添加不需要忽略的格式信息.
        bean.addInitParameter("exclusions","*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid-stats/*");
        return bean;
    }

}


package com.programb.springboot.mybatis.shardingjdbc.masterslave.entity;

import java.io.Serializable;
import java.util.Date;


public class UserEntity implements Serializable {

    private Integer id;

    private Long userId;

    private Integer cityId;

    private String userName;

    private Integer age;

    private Date birth;

    private static final long serialVersionUID = 1L;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public Long getUserId() {
        return userId;
    }

    public void setUserId(Long userId) {
        this.userId = userId;
    }

    public Integer getCityId() {
        return cityId;
    }

    public void setCityId(Integer cityId) {
        this.cityId = cityId;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public Date getBirth() {
        return birth;
    }

    public void setBirth(Date birth) {
        this.birth = birth;
    }

    @Override
    public String toString() {
        return "UserEntity{" +
                "id=" + id +
                ", userId=" + userId +
                ", cityId=" + cityId +
                ", userName='" + userName + '\'' +
                ", age=" + age +
                ", birth=" + birth +
                '}';
    }
}

package com.programb.springboot.mybatis.shardingjdbc.masterslave.mapper;

import org.apache.ibatis.annotations.Mapper;

import com.programb.springboot.mybatis.shardingjdbc.masterslave.entity.UserEntity;


@Mapper
public interface UserMapper {

    void createIfNotExistsTable();

    void truncateTable();

    Long insert(UserEntity model);

    UserEntity find(Long userId);

    void delete(Long userId);

    void dropTable();

}


package com.programb.springboot.mybatis.shardingjdbc.masterslave.mapper;

import org.apache.ibatis.annotations.*;

import com.programb.springboot.mybatis.shardingjdbc.masterslave.constants.SqlConstants;
import com.programb.springboot.mybatis.shardingjdbc.masterslave.entity.UserEntity;

import java.util.List;


public interface UserRepository {

    @Select(SqlConstants.GET_ALL_SQL)
    @Results(id = "userResultMap", value = {
            @Result(property = "userId", column = "user_id"),
            @Result(property = "cityId", column = "city_id"),
            @Result(property = "userName", column = "user_name"),
            @Result(property = "age", column = "age"),
            @Result(property = "birth", column = "birth")
    })
    List<UserEntity> selectAll();

    @Select(SqlConstants.GET_ONE_SQL)
    @ResultMap(value = "userResultMap")
    UserEntity find(Long userId);

    @Insert(SqlConstants.INSERT_SLAVE_SQL)
    @Options(useGeneratedKeys = true, keyProperty = "userId")
    int insert(UserEntity user);

    @Update(SqlConstants.UPDATE_SQL)
    int update(UserEntity user);

    @Delete(SqlConstants.DELETE_SQL)
    int delete(Long userId);

    @Delete(SqlConstants.DELETE_ALL_SQL)
    void truncate();

}


spring.application.name=spring-boot-mybatis-sharding-jdbc-masterslave
server.context-path=/springboot

mybatis.config-location=classpath:mybatis-config.xml

mybatis.datasource.url=jdbc:mysql://127.0.0.1:3306/%s?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=false
mybatis.datasource.username=travis
mybatis.datasource.password=

sharding.jdbc.datasource.names=ds_master_0,ds_master_1,ds_master_0_slave_0,ds_master_0_slave_1,ds_master_1_slave_0,ds_master_1_slave_1

sharding.jdbc.datasource.ds_master_0.type=com.alibaba.druid.pool.DruidDataSource
sharding.jdbc.datasource.ds_master_0.driverClassName=com.mysql.jdbc.Driver
sharding.jdbc.datasource.ds_master_0.url=jdbc:mysql://127.0.0.1:3306/ds_master_0?useSSL=false
sharding.jdbc.datasource.ds_master_0.username=travis
sharding.jdbc.datasource.ds_master_0.password=

sharding.jdbc.datasource.ds_master_0_slave_0.type=com.alibaba.druid.pool.DruidDataSource
sharding.jdbc.datasource.ds_master_0_slave_0.driverClassName=com.mysql.jdbc.Driver
sharding.jdbc.datasource.ds_master_0_slave_0.url=jdbc:mysql://127.0.0.1:3306/ds_master_0_slave_0?useSSL=false
sharding.jdbc.datasource.ds_master_0_slave_0.username=travis
sharding.jdbc.datasource.ds_master_0_slave_0.password=
sharding.jdbc.datasource.ds_master_0_slave_1.type=com.alibaba.druid.pool.DruidDataSource
sharding.jdbc.datasource.ds_master_0_slave_1.driverClassName=com.mysql.jdbc.Driver
sharding.jdbc.datasource.ds_master_0_slave_1.url=jdbc:mysql://127.0.0.1:3306/ds_master_0_slave_1?useSSL=false
sharding.jdbc.datasource.ds_master_0_slave_1.username=travis
sharding.jdbc.datasource.ds_master_0_slave_1.password=

sharding.jdbc.datasource.ds_master_1.type=com.alibaba.druid.pool.DruidDataSource
sharding.jdbc.datasource.ds_master_1.driverClassName=com.mysql.jdbc.Driver
sharding.jdbc.datasource.ds_master_1.url=jdbc:mysql://127.0.0.1:3306/ds_master_1?useSSL=false
sharding.jdbc.datasource.ds_master_1.username=travis
sharding.jdbc.datasource.ds_master_1.password=

sharding.jdbc.datasource.ds_master_1_slave_0.type=com.alibaba.druid.pool.DruidDataSource
sharding.jdbc.datasource.ds_master_1_slave_0.driverClassName=com.mysql.jdbc.Driver
sharding.jdbc.datasource.ds_master_1_slave_0.url=jdbc:mysql://127.0.0.1:3306/ds_master_1_slave_0?useSSL=false
sharding.jdbc.datasource.ds_master_1_slave_0.username=travis
sharding.jdbc.datasource.ds_master_1_slave_0.password=
sharding.jdbc.datasource.ds_master_1_slave_1.type=com.alibaba.druid.pool.DruidDataSource
sharding.jdbc.datasource.ds_master_1_slave_1.driverClassName=com.mysql.jdbc.Driver
sharding.jdbc.datasource.ds_master_1_slave_1.url=jdbc:mysql://127.0.0.1:3306/ds_master_1_slave_1?useSSL=false
sharding.jdbc.datasource.ds_master_1_slave_1.username=travis
sharding.jdbc.datasource.ds_master_1_slave_1.password=

sharding.jdbc.config.sharding.default-database-strategy.inline.sharding-column=city_id
sharding.jdbc.config.sharding.default-database-strategy.inline.algorithm-expression=ds_${city_id % 2}

sharding.jdbc.config.sharding.tables.t_user.actualDataNodes=ds_${0..1}.t_user_${0..1}
sharding.jdbc.config.sharding.tables.t_user.tableStrategy.inline.shardingColumn=user_id
sharding.jdbc.config.sharding.tables.t_user.tableStrategy.inline.algorithmExpression=t_user_${user_id % 2}
sharding.jdbc.config.sharding.tables.t_user.keyGeneratorColumnName=user_id

sharding.jdbc.config.sharding.master-slave-rules.ds_0.masterDataSourceName=ds_master_0
sharding.jdbc.config.sharding.master-slave-rules.ds_0.slaveDataSourceNames=ds_master_0_slave_0, ds_master_0_slave_1
sharding.jdbc.config.sharding.master-slave-rules.ds_1.masterDataSourceName=ds_master_1
sharding.jdbc.config.sharding.master-slave-rules.ds_1.slaveDataSourceNames=ds_master_1_slave_0, ds_master_1_slave_1

#logging.level.com.alibaba.druid=debug

<?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>
        <package name="com.programb.springboot.mybatis.shardingjdbc.masterslave.entity"/>
    </typeAliases>
    <mappers>
        <mapper resource="mapper/UserMapper.xml"/>
    </mappers>
</configuration>

<?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">
    <parent>
        <artifactId>spring-boot-programb-examples</artifactId>
        <groupId>com.programb</groupId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>spring-boot-mybatis-sharding-jdbc-masterslave</artifactId>

    <dependencies>
        <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>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
        </dependency>

        <dependency>
            <groupId>io.shardingjdbc</groupId>
            <artifactId>sharding-jdbc-core</artifactId>
        </dependency>

        <dependency>
            <groupId>io.shardingjdbc</groupId>
            <artifactId>sharding-jdbc-spring-boot-starter</artifactId>
        </dependency>

        <dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
        </dependency>

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

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
            <plugin>
                <groupId>org.jacoco</groupId>
                <artifactId>jacoco-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>
Bol5261
关注
专栏目录
springboot系类代码：spring-boot-mybatis-sharding-jdbc-masterslave
BLOG域名:programb.blog.csdn.net
05-21 300
读写分离，就是将DML交给主数据库去执行，将更新结果同步至各个从数据库保持主从数据一致，DQL分发给从数据库去查询，从数据库只提供读取查询操作。读写分离特别适用于读多写少的场景下，通过分散读写到不同的数据库实例上来提高性能，缓解单机数据库的压力: Name Remark DQL 数据查询语言，比如select查询语句 DML 数据操纵语言，比如insert、delete、update更新语句 DDL 数据定义语言，比如create/drop/alter等语句 DCL 数据控制语言，比如grant/
SpringBoot2.x集成Sharding-JDBC实现分库分表
热门推荐
u010391342的博客
04-25 2万+
概述 ShardingSphere，它由Sharding-JDBC、Sharding-Proxy和Sharding-Sidecar（计划中）这3款相互独立的产品组成。定位为轻量级Java框架。其实就是一个增强版的JDBC驱动，完全兼容JDBC和各种ORM框架。内部改写了SQL的添加和查询规则。适用于任何基于Java的ORM框架，如：JPA, Hibernate, Mybatis, Spring ...
SpringBoot & Sharding-JDBC MasterSlave Example
weixin_34247032的博客
07-08 157
概述 读写分离，简单来说，就是将DML交给主数据库去执行，将更新结果同步至各个从数据库保持主从数据一致，DQL分发给从数据库去查询，从数据库只提供读取查询操作。读写分离特别适用于读多写少的场景下，通过分散读写到不同的数据库实例上来提高性能，缓解单机数据库的压力: Name Remark DQL 数据查询语言，比如select查询语句 DML 数据操纵语言，比如insert、del...
springboot系类代码：spring-boot-mybatis-sharding-jdbc
BLOG域名:programb.blog.csdn.net
05-25 229
Apache ShardingSphere 是一套开源的分布式数据库中间件解决方案组成的生态圈，它由Sharding-JDBC、Sharding-Proxy和Sharding-Sidecar（规划中）这3款相互独立，却又能够混合部署配合使用的产品组成。它们均提供标准化的数据分片、分布式事务和数据库治理功能，可适用于如Java同构、异构语言、云原生等各种多样化的应用场景。 ShardingSphere定位为关系型数据库中间件，旨在充分合理地在分布式的场景下利用关系型数据库的计算和存储能力，而并非实现一个全新.
springboot数据库主从方案
weixin_30820151的博客
09-17 589
本篇分享数据库主从方案，案例采用springboot+mysql+mybatis演示；要想在代码中做主从选择，通常需要明白什么时候切换数据源，怎么切换数据源，下面以代码示例来做阐述； 搭建测试环境(1个master库2个slave库) DataSource多数据源配置 设置mybatis数据源 拦截器+注解设置master和slave库选择 选出当前请求要使用的slave从...
Mysql主从同步搭建，Springboot读写分离实现
qq_33806267的博客
06-24 1589
*** 该类是自定义数据源，由于必须将系统的数据源给替换掉。*/// 加载自定义配置数据源@Bean// 加载自定义配置数据源@Bean// 将自定义数据源配置到 AbstractRoutingDataSource 实现类中@Bean//设置默认数据源//注册所有数据源/*** 当自定义数据源，用户必须覆盖SqlSessionFactory创建* @return*/@Bean/**
spring+mybatis+druid数据源+sharding-jdbc分库分表
aty
11-23 2万+
spring+mybatis+druid数据源+sharding-jdbc分库分表
sharding-jdbc整合mybatis-plus生产实践
最新发布
咖啡攻城狮的博客
12-21 2086
sharding-jdbc整合mybatis-plus生产实践
Sharding-JDBC教程：Spring Boot整合Sharding-JDBC实现读写分离.docx
08-26
<groupId>org.springframework.boot <artifactId>spring-boot-starter-web <groupId>org.mybatis.spring.boot <artifactId>mybatis-spring-boot-starter <version>1.3.2 <groupId>mysql <artifactId>...
Redis（十二）SpringBoot集群搭建redis【主从复制&哨兵模式】
Vinjcent
07-10 6756
使用springboot框架搭建redis集群，并实现哨兵模式以及主从复制
ShardingSphere + spring boot 读写分离，自定义负载均衡算法
Crystalqy的博客
07-18 1万+
ShardingSphere是一套开源的分布式数据库中间件解决方案组成的生态圈，Sharding-JDBC是其中一个独立的产品，定位为轻量级Java框架，在Java的JDBC层提供的额外服务。 它使用客户端直连数据库，以jar包形式提供服务，无需额外部署和依赖，可理解为增强版的JDBC驱动，完全兼容JDBC和各种ORM框架。我们使用Sharding-JDBC实现读写分离的功能 适用于任何基于Ja...
sharding-jdbc读写分离的使用详解
.... 永远年轻，永远热泪盈眶
12-28 1万+
一、不使用Spring 1、引入Maven依赖 &lt;dependency&gt; &lt;groupId&gt;io.shardingsphere&lt;/groupId&gt; &lt;artifactId&gt;sharding-jdbc-core&lt;/artifactId&gt; &lt;version&gt;${sharding-sphere.version...
springboot集成sharding-jdbc错误：Missing the data source name: ‘null‘
10-21 2272
springboot集成sharding-jdbc错误：Missing the data source name: 'null'插件版本pom文件以及yaml文件问题和解决方式 插件版本 springboot 2.1.4集成sharding-jdbc3.1.0+mybatis-plus。 pom文件以及yaml文件 <!-- 集成sharding-jdbc --> <dependency> <groupId>io.sharding
SpringBoot 配置数据库主从 shardingsphere
qq_34819372的博客
08-31 1463
spring: shardingsphere: props.sql.show: true datasource: names: master,slave1 master: type: com.zaxxer.hikari.HikariDataSource driver-class-name: com.mysql.jdbc.Driver jdbc-url: jdbc:mysql://192.168.1.101:3306.
读写分离，单库分表，分库分表（一）——springboot+sharding-JDBC篇
蜗牛敲代码的博客
09-07 1087
文章目录前言读写分离读写分离+单库分表 前言   该篇讲述如何通过sharding-JDBC实现mysql数据库读写分离，单库分表，分库分表，在此之前，如果你不知道或对mysql数据库拆分模糊可以先看我前几篇文章，数据库主从同步与读写分离和 数据库分库分表架构设计。这两篇讲述的已经很清楚了，该篇只是进行实际的操作。关于sharding-JDBC的具体流程和操作官方文档写的也是蛮简单明了的。官方文档...
Spring Boot 属性配置 ConfigurationProperties 详解
Allen技术小站
06-28 1万+
在Spring中使用@Value可以对单个属性进行注入配置，但如果有很多配置属性或者配置属性本身拥有层级结构时，Spring Boot提供了基于类型安全的配置方式。本文系统的带大家了解一下基于类型安全的属性配置。 @ConfigurationProperties 通过@ConfigurationProperties将properties属性和一个Bean及其属性关联，从而实现类型安全配置。 就像上面说的，如果在实践的过程中如果有很多配置，通过@Value逐一配置不仅麻烦，还不太符合面向对象的编程思想。
MyBatis、MyBatisPlus多数据源集成shardingJdbc
士兵76的博客
11-09 7747
1.介绍 本篇的数据源是指，一个核心业务库、一个订单明细库，两个库没有重复的表，核心业务库没有任何分表策略，订单明细库将使用shardingJdbc进行分表管理。 数据访问层采用MybatisPlus，说一下MybatisPlus，它只是一个Mybaits上的插件，具体配置的时候和Mybatis基本一致。 2.依赖 主要依赖就是下面这两个starter &lt;depe...
springboot2.x 整合mybatis-plus sharding-jdbc实现读写分离
太多的虚幻
07-19 7613
首先，导入依赖，下面只展示核心依赖 &lt;dependency&gt; &lt;groupId&gt;com.baomidou&lt;/groupId&gt; &lt;artifactId&gt;mybatis-plus-boot-starter&lt;/artifactId&gt; &lt;version&gt...
Spring Boot 集成Mybatis实现主从（多数据源）分离方案
oNianShao的博客
06-21 1899
本文将介绍使用Spring Boot集成Mybatis并实现主从库分离的实现（同样适用于多数据源）。延续之前的Spring Boot 集成MyBatis。项目还将集成分页插件PageHelper、通用Mapper以及Druid。 新建一个Maven项目，最终项目结构如下： 多数据源注入到sqlSessionFactory POM增加如下依赖： dependency
Spring Boot与Sharding-JDBC+Mybatis-Plus整合实现分库分表
"本文主要讲解如何使用Spring Boot集成Sharding-JDBC和Mybatis-Plus来实现数据库的分库分表功能。文中通过实例代码详细展示了整个集成过程，并提供了项目的结构和POM配置信息。" 在分布式系统中，随着数据量的增长...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Bol5261

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值