分库分表shardingJDBC

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

1 n个数据源配置


import javax.sql.DataSource;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Component;

import com.alibaba.druid.pool.DruidDataSource;

@Component
@Configuration
@ConfigurationProperties(prefix = "database0")
public class Database0Config {
    private String url;
    private String username;
    private String password;
    private String driverClassName;
    private String databaseName;

    public DataSource createDataSource() {
        DruidDataSource result = new DruidDataSource();
        result.setDriverClassName(getDriverClassName());
        result.setUrl(getUrl());
        result.setUsername(getUsername());
        result.setPassword(getPassword());
        return result;
    }
}
import javax.sql.DataSource;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Component;

import com.alibaba.druid.pool.DruidDataSource;

@Component
@Configuration
@ConfigurationProperties(prefix = "database1")
public class Database1Config {
    private String url;
    private String username;
    private String password;
    private String driverClassName;
    private String databaseName;

    public DataSource createDataSource() {
        DruidDataSource result = new DruidDataSource();
        result.setDriverClassName(getDriverClassName());
        result.setUrl(getUrl());
        result.setUsername(getUsername());
        result.setPassword(getPassword());
        return result;
    }
}

2 分库策略

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 org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.Collection;
import java.util.LinkedHashSet;

/**
 * 这里使用的都是单键分片策略 示例分库策略是： GoodsId<=20使用database0库 其余使用database1库
 * 
 * @author yangyang
 * @date 2019/1/30
 */
@Component
public class DatabaseShardingAlgorithm implements SingleKeyDatabaseShardingAlgorithm<Long> {

	@Autowired
	private Database0Config database0Config;

	@Autowired
	private Database1Config database1Config;

	public String doEqualSharding(Collection<String> availableTargetNames, ShardingValue<Long> shardingValue) {
		Long value = shardingValue.getValue();
		if (value %2==0) {
			return database0Config.getDatabaseName();
		} else {
			return database1Config.getDatabaseName();
		}
	}

	public Collection<String> doInSharding(Collection<String> availableTargetNames, ShardingValue<Long> shardingValue) {
		Collection<String> result = new LinkedHashSet<String>(availableTargetNames.size());
		for (Long value : shardingValue.getValues()) {
			if (value %2==0) {
				result.add(database0Config.getDatabaseName());
			} else {
				result.add(database1Config.getDatabaseName());
			}
		}
		return result;
	}

	public Collection<String> doBetweenSharding(Collection<String> availableTargetNames,
			ShardingValue<Long> shardingValue) {
		Collection<String> result = new LinkedHashSet<String>(availableTargetNames.size());
		Range<Long> range = shardingValue.getValueRange();
		for (Long value = range.lowerEndpoint(); value <= range.upperEndpoint(); value++) {
			if (value %2==0) {
				result.add(database0Config.getDatabaseName());
			} else {
				result.add(database1Config.getDatabaseName());
			}
		}
		return result;
	}
}

3 分表策略

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 org.springframework.stereotype.Component;

import java.util.Collection;
import java.util.LinkedHashSet;

/**
 * 这里使用的都是单键分片策略
 * 示例分表策略是：
 * GoodsType为奇数使用goods_1表
 * GoodsType为偶数使用goods_0表
 * @author yangyang
 * @date 2019/1/30
 */
@Component
public class TableShardingAlgorithm implements SingleKeyTableShardingAlgorithm<Long> {

    public String doEqualSharding(final Collection<String> tableNames, final ShardingValue<Long> shardingValue) {
        for (String each : tableNames) {
            if (each.endsWith(shardingValue.getValue() % 2 + "")) {
                return each;
            }
        }
        throw new IllegalArgumentException();
    }

    public Collection<String> doInSharding(final Collection<String> tableNames, final ShardingValue<Long> shardingValue) {
        Collection<String> result = new LinkedHashSet<String>(tableNames.size());
        for (Long value : shardingValue.getValues()) {
            for (String tableName : tableNames) {
                if (tableName.endsWith(value % 2 + "")) {
                    result.add(tableName);
                }
            }
        }
        return result;
    }

    public Collection<String> doBetweenSharding(final Collection<String> tableNames,
                                                final ShardingValue<Long> shardingValue) {
        Collection<String> result = new LinkedHashSet<String>(tableNames.size());
        Range<Long> range = 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;
    }
}

4 数据源设置

import java.sql.SQLException;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;

import javax.sql.DataSource;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import com.dangdang.ddframe.rdb.sharding.api.ShardingDataSourceFactory;
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;
/**
 * 分库分表设置
 * @author admin
 *
 */
@Configuration
public class DataSourceConfig {

    @Autowired
    private Database0Config database0Config;

    @Autowired
    private Database1Config database1Config;

    @Autowired
    private DatabaseShardingAlgorithm databaseShardingAlgorithm;

    @Autowired
    private TableShardingAlgorithm tableShardingAlgorithm;

    @Bean
    public DataSource getDataSource() throws SQLException {
        //分库设置
        Map<String, DataSource> dataSourceMap = new HashMap<String, DataSource>(2);
        //添加两个数据库database0和database1
        dataSourceMap.put(database0Config.getDatabaseName(), database0Config.createDataSource());
        dataSourceMap.put(database1Config.getDatabaseName(), database1Config.createDataSource());
        //设置默认数据库
        DataSourceRule dataSourceRule = new DataSourceRule(dataSourceMap, database0Config.getDatabaseName());

        //分表设置，大致思想就是将查询虚拟表Goods根据一定规则映射到真实表中去
        TableRule orderTableRule = TableRule.builder("goods")
                .actualTables(Arrays.asList("goods_0", "goods_1"))
                .dataSourceRule(dataSourceRule)
                .build();

        //分库分表策略
        ShardingRule shardingRule = ShardingRule.builder()
                .dataSourceRule(dataSourceRule)
                .tableRules(Arrays.asList(orderTableRule))
                .databaseShardingStrategy(new DatabaseShardingStrategy("goodsId", databaseShardingAlgorithm))
                .tableShardingStrategy(new TableShardingStrategy("goodsType", tableShardingAlgorithm)).build();
        DataSource dataSource = ShardingDataSourceFactory.createDataSource(shardingRule);
        return dataSource;
    }
}

5 mapper映射

import java.util.List;

import org.apache.ibatis.annotations.Mapper;
import org.springframework.stereotype.Repository;

import com.sample.pojo.Goods;

@Mapper
@Repository
public interface GoodsMapper{
    Integer insert(Goods goods);
    Integer updateById(Goods goods);
    Integer delete(Integer id);
    List<Goods> list();
}
<?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.sample.mapper.GoodsMapper">

	<resultMap id="BaseResultMap" type="com.sample.pojo.Goods">
		<result column="goodsId" property="goodsId" />
		<result column="goodsName" property="goodsName" />
		<result column="goodsType" property="goodsType" />
	</resultMap>

	<sql id="Base_Column_List">
		goodsId,
		goodsName,
		goodsType
	</sql>

	<insert id="insert" parameterType="com.sample.pojo.Goods">
		INSERT INTO goods
		<trim prefix="(" suffix=")" suffixOverrides=",">
			<if test='null != goodsId'>
				goodsId,
			</if>
			<if test='null != goodsName'>
				goodsName,
			</if>
			<if test='null != goodsType'>
				goodsType
			</if>
		</trim>
		<trim prefix="values (" suffix=")" suffixOverrides=",">
			<if test='null != goodsId'>
				#{goodsId},
			</if>
			<if test='null != goodsName'>
				#{goodsName},
			</if>
			<if test='null != goodsType'>
				#{goodsType}
			</if>
		</trim>
	</insert>

	<delete id="delete">
		DELETE FROM goods
		WHERE goodsId = #{goodsId}
	</delete>

	<update id="updateById" parameterType="com.sample.pojo.Goods">
		UPDATE goods
		<set>
			<if test='null != goodsName'>
				#{goodsName},
			</if>
			<if test='null != goodsType'>
				#{goodsType}
			</if>
		</set>
		WHERE id = #{goodsId}
	</update>

	<select id="list" resultMap="BaseResultMap">
		SELECT
		<include refid="Base_Column_List" />
		FROM goods
		order by goodsId
	</select>


</mapper>

6 service

import java.util.List;

import com.sample.pojo.Goods;

public interface DatasourceServiceDemo {
	Integer insert(Goods goods);
    Integer updateById(Goods goods);
    Integer delete(Integer id);
    List<Goods> list();
}

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.sample.mapper.GoodsMapper;
import com.sample.pojo.Goods;
import com.sample.service.DatasourceServiceDemo;

@Service
@Transactional
public class DatasourceServiceDemoImpl implements DatasourceServiceDemo {
	@Autowired
	private GoodsMapper goodsMapper;
	public Integer insert(Goods goods) {
		return goodsMapper.insert(goods);
	}
	public Integer updateById(Goods goods){
		return goodsMapper.updateById(goods);
	}
	public Integer delete(Integer id){
		return goodsMapper.delete(id);
	}
	public List<Goods> list(){
		return goodsMapper.list();
	}
}

7 测试controller

import java.util.List;
import java.util.Random;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;

import com.sample.pojo.Goods;
import com.sample.service.DatasourceServiceDemo;
import com.sample.service.DubboDemoService;

@Controller
public class ServiceDemoController {
	@Autowired
	private DatasourceServiceDemo datasourceServiceDemo;
	public static Long id=1l;
	public static Random rand = new Random();
	@ResponseBody
	@RequestMapping("/insert")
	public Goods insert() {
		Goods goods=new Goods();
		goods.setGoodsId(id++);
		goods.setGoodsName("goods"+id);
		goods.setGoodsType((long) rand.nextInt(5));
		datasourceServiceDemo.insert(goods);
		return goods;
	}
    @ResponseBody
	@RequestMapping("/list")
    public List<Goods> list(){
		return datasourceServiceDemo.list();
	}
}

参考来源：https://www.cnblogs.com/dalaoyang/p/10345388.html

感谢@dalaoyang

:)

小毛贼_哪里逃
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
sharding-jdbc之——分库分表实例完整源码
02-25
sharding-jdbc之——分库分表实例完整源码，详情请参见博文：http://blog.csdn.net/l1028386804/article/details/79368021
sharding-jdbc按月分表样例2
05-28
Sharding-JDBC作为阿里巴巴开源的轻量级Java框架，是实现分库分表的一种优秀选择。本文将深入探讨基于Sharding-JDBC的按月动态分表策略，并结合提供的“sharding-jdbc-demo”样例进行解析。 首先，了解Sharding-...
sharding-jdbc分库分表
qq_34815027的博客
05-20 240
1.gradle构建方式加载依赖包 compile group: 'io.shardingsphere', name: 'sharding-jdbc-core', version: '3.0.0' 2.TestSourceConfiguration文件类配置数据库 @Configuration() @MapperScan(annotationClass = Mapper.class, b...
ShardingSphere的ShardingJDBC简单使用与理解
计算机王的博客
08-19 741
ShardingJDBC ShardingJDBC可以理解为一个加强版的jdbc 可以使用它进行数据库的连接与执行命令 ShardingJDBC可以帮我们实现分库分表的功能 实现功能有几个概念 逻辑表：逻辑表就是ShardingJDBC操作的表具体数据会根据我们的配置进行存储到那张表 就是我们有一个mysql数据库把表user分成了两个分别叫user_1、user_2而ShardingJDBC的逻辑表可以理解为 一个可以代表user_1、user_2这两个表的一个名字就称为逻辑表 我们使用ShardingJ
Sharding-JDBC对不需要分库分表的普通表如何配置数据源
xycf0的博客
07-14 5060
在我们使用Sharding-JDBC实现分库分表时，更多的表是不需要分库分表的，此时我们需要配置默认数据库，让不需要分库分表的表，使用默认数据源。 yml配置：
海量数据分库分表方案（二）技术选型与sharding-jdbc实现
地藏Kelvin
09-19 768
上一章已经讲述分库分表算法选型，本章主要讲述分库分表技术选型 文中关联上一章，若下文出现提及其时，可以点击 分库分表算法方案与技术选型（一） 主要讲述 框架比较 sharding-jdbc、zdal 代码实现样例，如需源码可在后文中查看 主键生成策略 可以按需阅读文章 常见框架 除了原生JDBC，网上常见分库分表框架有： 当当网 sharding-jdbc alibaba.cobar ...
Java+Springboot+mybatis+sharding jdbc 实现分库分表
10-28
本项目基于Java、SpringBoot、MyBatis以及ShardingJDBC实现了一个分库分表的解决方案，旨在帮助开发者理解并掌握这一技术。以下是关于这些技术的详细介绍： **Java**： Java是一种广泛使用的面向对象的编程语言，...
SpringBoot 2.0 整合sharding-jdbc中间件实现数据分库分表
08-25
SpringBoot 2.0 整合sharding-jdbc中间件实现数据分库分表 SpringBoot 2.0 整合sharding-jdbc中间件实现数据分库分表是指在 Spring Boot 2.0 框架下使用 sharding-jdbc 中间件来实现数据分库分表的技术方案。在这个...
ShardingJDBC5.1.1按月分库分表、读写分离、自动创表完整demo
06-17
《使用ShardingJDBC5.1.1实现按月分库分表、读写分离与自动创表的全面实战》 在现代企业级应用中，数据量的快速增长使得数据库的性能优化成为至关重要的环节。ShardingJDBC作为一款轻量级的Java框架，能够有效地...
Spring Boot中整合Sharding-JDBC读写分离示例
weixin_34095889的博客
08-31 607
在我《Spring Cloud微服务-全栈技术与案例解析》书中，第18章节分库分表解决方案里有对Sharding-JDBC的使用进行详细的讲解。 之前是通过XML方式来配置数据源，读写分离策略，分库分表策略等，之前有朋友也问过我，有没有Spring Boot的方式来配置，既然已经用Spring Boot还用XML来配置感觉有点不协调。 其实吧我个人觉得只要能用，方便看，看的懂就行了，mybatis...
初次接触Sharding-JDBC并实际应用
m0_73311735的博客
11-03 826
对于海量数据的存储，sharding-jdbc确实是一个不错的解决方案，可以通过分表分库的方式减轻Mysql服务压力。业务中，可以根据具体的需求制定具体的分库或分表方案。但是需要注意的是，在分库分表的情况下有可能需要考虑分布式事务的问题，如果使用case when中包含子查询或者使用逻辑表名会出现报错的情况，具体有哪些不支持的情况可以参考官方文档。
Sharding-JDBC（七）update报错：Can not update sharding key
ACGkaka的博客
01-27 4987
update报错：Can not update sharding key
分库分表之当当开源中间件sharding-jdbc体验
caicongyang
03-02 1万+
分库分表之当当开源中间件sharding-jdbc体验
Sharding-JDBC实现分库分表
summer_fish的专栏
10-09 623
Sharding-JDBC实现分库分表
【学习】MybatisPlus + ShardingSphere 分表对象使用updateById方法自动补齐分表属性
qq171563857的博客
12-03 5497
问题: 当使用ShardingSphere进行分表时,在使用MybatisPlus的iService扩展的updateById方法会导致报错 异常信息:Can not update sharding key, logic table [表名],column[属性名] 异常来源:ShardingUpdateStatementValidator.class#validate 原因:当执行update操作时,如果涉及分表对象,则会执行分表属性校验,校验的原理是判断where条件里是否包含分表属性...
SpringBoot使用Sharding-JDBC分库分表
weixin_33938733的博客
02-01 1999
本文介绍SpringBoot使用当当Sharding-JDBC进行分库分表。 1.有关Sharding-JDBC 有关Sharding-JDBC介绍这里就不在多说，之前Sharding-JDBC是当当网自研的关系型数据库的水平扩展框架，现在已经捐献给Apache，具体可以查看Github，地址是：shardingsphere.apache.org/document/cu… shardingsp...
sharding-jdbc 实现动态分表（按年按月）
热门推荐
jiejiegua的博客
01-13 1万+
1、 项目中我们希望 能够按照时间、类别来添加表。但是sharding-jdbc 是固定配置 的actual-data-nodes 参数。 也就是说我们需要提前创建好分表或者分库。那么我们需要如何来实现动态创建表，并且动态刷新actual-data-nodes 呢。 2、思路 就是 写个定时器来动态创建表 ，在创建表的时候 动态刷新actual-data-nodes 实现动态创建表被shard加载。注意的是，我的任务 采用xxl-job （主要是我们的项目是分布式项目）你们如果是单体也可以直接...
springboot动态数据源用shardingjdbc按时间分表
lixiaoyi01的博客
09-19 2027
1、背景： 原有项目架构 springboot mybatis-plus dynamic-datasource（动态数据源、mybatis-plus拓展) druid 连接池 根据业务数据不断增加，需要进行对业务量大的数据表行分表，因为以前的业务都是动态数据源管理datasource，改造可以顺势而为，把shardingjdbc的数据源也交给 dynamic-datasource 来管理，默认走以前不分表的逻辑，并且不由sharding管理，兼...
分库分表shardingjdbc
最新发布
08-25
ShardingJDBC是一个开源的Java分库分表中间件，它提供了对分库分表的支持。使用ShardingJDBC可以轻松地实现数据库的水平拆分，将数据分布到不同的数据库和表中。ShardingJDBC通过在应用层面的透明化处理，将SQL语句...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值