jpa整合sharding-jdbc不分库分表（包括id主键生成策略的使用）

最新推荐文章于 2024-07-16 14:58:14 发布
最新推荐文章于 2024-07-16 14:58:14 发布
阅读量1.7k 收藏 5
点赞数 1
分类专栏： 笔记 文章标签： hibernate java 数据库 sharding-jdbc SpringDataJpa
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_47615289/article/details/126986522
版权
  1. 首先将官网地址与有用的博文奉献给大家在这里致谢贡献者：

https://shardingsphere.apache.org/document/5.2.0/en/overview/
https://blog.csdn.net/weixin_28979369/article/details/112540611
shardign-jdbc底层逻辑

  1. maven依赖
<!--        数据库连接jar 可以换成自己想用的版本-->
       <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>
<!--        分库分表-->
        <dependency>
            <groupId>com.dangdang</groupId>
            <artifactId>sharding-jdbc-core</artifactId>
            <version>1.5.4.1</version>
        </dependency>
        <!-- druid -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.20</version>
        </dependency>
  1. 配置数据源（数据库）.yml文件类型的配置
server:
  port: 2805
logging:
  pattern:
    file: "%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n"
    console: "%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n"
  file:
    path: "./logs/"
  file.max-size: 10MB
  level:
    org.hibernate.SQL: TRACE
    org.hibernate.type.description.sql: TRACE
    org.hibernate.type.descriptor.sql.BasicBinder: TRACE
spring:
  jpa:
    properties:
      hibernate:
        format_sql: true
        #integrator_provider: com.zgy.handle.userService.service.auto.InsertEventIntegratorProvider
    hibernate:
      ddl-auto: none #必须自己建表了！！！！必须none
      naming:
        physical-strategy: org.hibernate.boot.model.naming.PhysicalNamingStrategyStandardImpl
    open-in-view: false
    # 以下是重点sharding-jdbc的数据源会用到，上面的配置根据你的数据库情况而定这里我只做分表所以就有一个数据库
database0: # 这个随便取这是用来配置类里读属性的标识
  url: jdbc:mysql://localhost:3306/material?useUnicode=true&characterEncoding=UTF-8&autoReconnect=true&zeroDateTimeBehavior=convertToNull&useSSL=false
  username: root # 必有
  password: 123456 # 必有
  driver-class-name: com.mysql.jdbc.Driver #数据库连接驱动必有
  max-wait: 10000
  min-idle: 2
  initial-size: 2
  validation-query: SELECT 1
  test-on-borrow: false
  test-while-idle: true
  time-between-eviction-runs-millis: 18800
  databaseName: material #数据库名必有跟url中数据库名一致

4.新建Database0Config类（dataSource数据源配置类）

package com.szc.material.analysisService.confg.shardingjdbc;

import com.alibaba.druid.pool.DruidDataSource;
import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

import javax.sql.DataSource;

@Data
@ConfigurationProperties(prefix = "database0")//读.yml文件中的属性值
@Component
public class Database0Config {
    private String url;
    private String username;
    private String password;
    private String driverClassName;
    private int maxwait;
    private int  minidle;
    private int   initialsize;
    private String  validationquery;
    private boolean testonborrow;
    private boolean testwhileidle;
    private int timebetweenevictionrunsmillis;
    private String databaseName;
    public DataSource createDataSource() {
        DruidDataSource result = new DruidDataSource();
        result.setDriverClassName(getDriverClassName());
        result.setUrl(getUrl());
        result.setUsername(getUsername());
        result.setPassword(getPassword());
        result.setMaxWait(maxwait);
        result.setMinIdle(minidle);
        result.setInitialSize(initialsize);
        result.setValidationQuery(validationquery);
        result.setTestOnBorrow(testonborrow);
        result.setTestWhileIdle(testwhileidle);
        result.setTimeBetweenEvictionRunsMillis(timebetweenevictionrunsmillis);
        return result;
    }

}
  1. 新建TableShardingAlgorithm类（自定义分表的规则）
    在这里插入图片描述
package com.szc.material.analysisService.confg.shardingjdbc;

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;
//这里每个方法中的 %20 是我的分片策略改成你们的，建议你们也用id分表这样下面的代码只改 “%你分的表的个数”
//我有一个material数据库其中有一个analysis_formal_data_attribute表，我将其复制了20个做为analysis_formal_data_attribute的实际数据库表，原来的analysis_formal_data_attribute表就删掉了，向数据库存数据时会用 分片值%20来确定数据要存入哪张表
@Component
public class TableShardingAlgorithm implements SingleKeyTableShardingAlgorithm<Long> {
        /**
     *根据分片值和SQL的=运算符计算分片结果名称集合.
     * 参数:
     * availableTargetNames - 所有的可用目标名称集合, 一般是数据源或表名称
     * shardingValue - 分片值
     * 返回:
     * 分片后指向的目标名称, 一般是数据源或表名称
     */
    @Override
    public String doEqualSharding(Collection<String> collection, ShardingValue<Long> shardingValue) {
        for (String each : collection) {
            if (each.endsWith(shardingValue.getValue() % 20 + "")) {
                return each;
            }
        }
        throw new IllegalArgumentException();
    }
       /**
     *根据分片值和SQL的IN运算符计算分片结果名称集合.
     * 参数:
     * availableTargetNames - 所有的可用目标名称集合, 一般是数据源或表名称
     * shardingValue - 分片值
     * 返回:
     * 分片后指向的目标名称集合, 一般是数据源或表名称
     */
    @Override
    public Collection<String> doInSharding(Collection<String> collection, ShardingValue<Long> shardingValue) {
        Collection<String> result = new LinkedHashSet<>(collection.size());
        for (Long value : shardingValue.getValues()) {
            for (String tableName : collection) {
                if (tableName.endsWith(value % 20 + "")) {
                    result.add(tableName);
                }
            }
        }
        return result;

    }
         /**
     *根据分片值和SQL的BETWEEN运算符计算分片结果名称集合.
     * 参数:
     * availableTargetNames - 所有的可用目标名称集合, 一般是数据源或表名称
     * shardingValue - 分片值
     * 返回:
     * 分片后指向的目标名称集合, 一般是数据源或表名称
     */
    @Override
    public Collection<String> doBetweenSharding(Collection<String> collection, ShardingValue<Long> shardingValue) {
        Collection<String> result = new LinkedHashSet<>(collection.size());
        Range<Long> range = shardingValue.getValueRange();
        for (Long i = range.lowerEndpoint(); i <= range.upperEndpoint(); i++) {
            for (String each : collection) {
                if (each.endsWith(i % 20 + "")) {
                    result.add(each);
                }
            }
        }
        return result;

    }
}
  1. 新建DataSourceConfig类在里面将数据源类，表的分片规则类进行配置（sharding-jdbc主配置类，注意我这里没有分库，做分库的话也是在这配的）
package com.szc.material.analysisService.confg.shardingjdbc;

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.table.TableShardingStrategy;
import com.dangdang.ddframe.rdb.sharding.keygen.DefaultKeyGenerator;
import com.dangdang.ddframe.rdb.sharding.keygen.KeyGenerator;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

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

@Configuration
public class DataSourceConfig {
    @Autowired
    private Database0Config database0Config;

    @Autowired
    private TableShardingAlgorithm tableShardingAlgorithm;

    @Bean
    public DataSource getDataSource() throws SQLException {
        return buildDataSource();
    }

    private DataSource buildDataSource() throws SQLException {
         // https://blog.csdn.net/u012014505/article/details/108844887 这里面有讲到 多个库的设置
        //分库设置 （我这只有一个库初始容量就设为1了）
        Map<String, DataSource> dataSourceMap = new HashMap<>(1);
        //添加数据库database0 （我只有一个库）
        dataSourceMap.put(database0Config.getDatabaseName(), database0Config.createDataSource());
        //设置默认数据库（我只有一个库，我怕其他的表没设分片策略会报错我就把我这一个库设为了默认库）
        DataSourceRule dataSourceRule = new DataSourceRule(dataSourceMap, database0Config.getDatabaseName());
        //分表设置，大致思想就是将查询虚拟表数据根据一定规则映射到真实表中去，使用sharding-jdbc后sql中的表名用这个虚拟表名analysis_formal_data_attribute
        //数据库中建分表是有规则的 例如我这个analysis_formal_data_attribute分了20个
        //analysis_formal_data_attribute_$
        //$从零开始到分的总表数减一
        TableRule orderTableRule = TableRule.builder("analysis_formal_data_attribute")
                .actualTables(Arrays.asList("analysis_formal_data_attribute_0",
                        "analysis_formal_data_attribute_1",
                        "analysis_formal_data_attribute_2",
                        "analysis_formal_data_attribute_3",
                        "analysis_formal_data_attribute_4",
                        "analysis_formal_data_attribute_5",
                        "analysis_formal_data_attribute_6",
                        "analysis_formal_data_attribute_7",
                        "analysis_formal_data_attribute_8",
                        "analysis_formal_data_attribute_9",
                        "analysis_formal_data_attribute_10",
                        "analysis_formal_data_attribute_11",
                        "analysis_formal_data_attribute_12",
                        "analysis_formal_data_attribute_13",
                        "analysis_formal_data_attribute_14",
                        "analysis_formal_data_attribute_15",
                        "analysis_formal_data_attribute_16",
                        "analysis_formal_data_attribute_17",
                        "analysis_formal_data_attribute_18",
                        "analysis_formal_data_attribute_19"))
                .dataSourceRule(dataSourceRule)
                .build();

        //分库分表策略（我这里只有分表的策略，分库的话也在这配）
        ShardingRule shardingRule = ShardingRule.builder()
                .dataSourceRule(dataSourceRule)
                .tableRules(Arrays.asList(orderTableRule))
                .tableShardingStrategy(new TableShardingStrategy("id", tableShardingAlgorithm)).build();
        DataSource dataSource = ShardingDataSourceFactory.createDataSource(shardingRule);
        return dataSource;
    }
    //主键生成策略jpa自动生成id值会用到最后会讲的
    @Bean
    public KeyGenerator keyGenerator() {
        return new DefaultKeyGenerator();
    }

}
  1. 上面就是整个配置了你可以写个测试类了
package com.szc.material.analysisService;

import com.szc.material.analysisService.model.formalDataAttribute.FormalDataAttribute;
import com.szc.material.analysisService.model.templateAttribute.TemplateAttribute;
import com.szc.material.analysisService.repository.formalDataAttribute.FormalDataAttributeUpdateRepository;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;



@RunWith(SpringRunner.class)
@SpringBootTest(classes = AnalysisApplication.class)
public class FTest {
    @Autowired
    FormalDataAttributeUpdateRepository formalDataAttributeUpdateRepository;
    //查询测试
    @Test
    public void a(){

        for (FormalDataAttribute dataAttribute : formalDataAttributeUpdateRepository.findAll()) {
            System.out.println(dataAttribute);
        }

    }
    //保存测试
    @Test
    public void b(){
        TemplateAttribute templateAttribute = new TemplateAttribute();
        templateAttribute.setId(27903867563803298L);
        FormalDataAttribute formalDataAttribute = new FormalDataAttribute();
        formalDataAttribute.setCode("真尼玛离谱");
       formalDataAttributeUpdateRepository.save(formalDataAttribute);
    }
}
  1. 到这里你成功了吗，哈哈到这里是可以成功的如果没成功接着看，我到这里没有成功因为我的实体类在保存时是有id自动生成策略的，之前我这个项目的自动生成策略用的是Hibernate的下面的配置方法，经过我不断查资料打断点得知可能是sharding-jdbc不兼容下面generate方法中的sqll代码
package com.szc.material.analysisService.model.hibernate;

import org.hibernate.HibernateException;
import org.hibernate.MappingException;
import org.hibernate.engine.spi.SharedSessionContractImplementor;
import org.hibernate.id.Configurable;
import org.hibernate.id.IdentifierGenerator;
import org.hibernate.service.ServiceRegistry;
import org.hibernate.type.Type;

import javax.persistence.Id;
import java.io.Serializable;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.Properties;

public class UUIDGenerator implements IdentifierGenerator, Configurable {
    private final String sql = "select uuid_short()";
    @Override
    public void configure(Type type, Properties properties, ServiceRegistry serviceRegistry) throws MappingException {

    }

    @Override
    public Serializable generate(SharedSessionContractImplementor sharedSessionContractImplementor, Object o) throws HibernateException {
        synchronized (this){
            Long result;
            try {
                Long id = null;
                Field[] declaredFields = o.getClass().getDeclaredFields();
                int size = declaredFields.length;
                for (int i = 0; i < size; i++){
                    Field field = declaredFields[i];
                    Id annotation = (Id)field.getAnnotation(Id.class);
                    if (annotation != null){
                        try {
                            Method method = o.getClass().getMethod("get" + field.getName().substring(0,1).toUpperCase() + field.getName().substring(1));
                            Object invoke = method.invoke(o);
                            id = (Long)invoke;
                        }catch (Exception ex){
                            ex.printStackTrace();
                        }
                        break;
                    }
                }
                if (id == null){
                    PreparedStatement st = sharedSessionContractImplementor.connection().prepareStatement("select uuid_short()");
                    try{
                        ResultSet rs = st.executeQuery();

                        long resultx;
                        try{
                            rs.next();
                            resultx = rs.getLong(1);
                        }finally {
                            rs.close();
                        }
                        return resultx;
                    }finally {
                        st.close();
                    }
                }
                result = id;
            }catch (Exception ex){
                return null;
            }
            return result;
        }
    }
}

之后我就用上面Sharding-jdbc的配置中的以下代码自动生成了id

@Bean
public KeyGenerator keyGenerator() {
    return new DefaultKeyGenerator();
}

改出了最后针对我这一个分表，的自动生成id的策略，废话少说上代码

package com.szc.material.analysisService.model.hibernate;

import com.dangdang.ddframe.rdb.sharding.keygen.DefaultKeyGenerator;
import org.hibernate.HibernateException;
import org.hibernate.MappingException;
import org.hibernate.engine.spi.SharedSessionContractImplementor;
import org.hibernate.id.Configurable;
import org.hibernate.id.IdentifierGenerator;
import org.hibernate.service.ServiceRegistry;
import org.hibernate.type.Type;



import java.io.Serializable;

import java.util.Properties;
public class UUIDGenerator_FormalDataAttribute implements IdentifierGenerator, Configurable {

    private final String sql = "select uuid_short()";
    DefaultKeyGenerator defaultKeyGenerator=new DefaultKeyGenerator();
    @Override
    public void configure(Type type, Properties properties, ServiceRegistry serviceRegistry) throws MappingException {

    }

    @Override
    public Serializable generate(SharedSessionContractImplementor sharedSessionContractImplementor, Object o) throws HibernateException {
        synchronized (this){
            return defaultKeyGenerator.generateKey().longValue();
        }
    }
}

将上面的成功策略放入@GenericGenerator中strategy 中如下图
在这里插入图片描述
这回表也分完了，id策略也配了，应该没事了，散会！！！关注我，豪杰带大家填坑！！！

张毫洁
关注
专栏目录
shardingjdbc + jpa 完成读写分离配置及数据分片
yh_852974543的博客
12-26 709
1、环境介绍 虚拟机中新建6台服务器，分别配置成两个一主两从模式的数据库集群，主从同步上一篇详解。 注意：创建克隆需要修改静态IP地址、mysql 的server-id、以及server-uuid参数，每台服务器必须不同。 2、数据库建表 3、数据库映射的实体类 4、读写分离配置 # 配置6个数据源 spring.shardingsphere.datasource.names=master0,slave0,slave1,master1,slave2,slave3 spring.sha
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使用JPA集成sharding-jdbc进行分表
士兵76的博客
09-04 1万+
1. 本文目标 1.1 使用sharding-sphere提供的 sharding-jdbc-spring-boot-starter 分表组件去和JPA项目集成。 1.2 实现自己的分表算法(使用行表达式取模+自定义算法两种)。 1.3 分库本文不做研究，原理都一样。 2. 项目搭建 application.properties: spring.jpa.hibernate.ddl-a...
Jpa-sharding-jdbc（有git demo）
分享技术，记录问题，努力学习
08-17 448
SpringBoot-Jpa-sharding-jdbc 测试sharding-jdbc分库和分表，只需引入jpa和sharding-jdbc依赖即可，确实对应用侵入很低。 我分别测试了两张表，分两个库，每个库一张表，做分表策略时一定要注意数据均匀分配，否则就会出现某些表中永远没有数据的情况 #这种配置就不满足我下面要说的情况，这种配置会导致，每个库中都必须存在冗余表，如果删除会报错 spring.shardingsphere.sharding.tables.user.actual-data-nodes=
Springboot2+JPA|MyBatis+Sharding-JDBC示例
07-24
Springboot2+JPA|MyBatis+Sharding-JDBC示例源码，可直接运行。
springboot集成jpa使用 sharding-jdbc进行数据库分片
zhang_adrian的博客
10-28 3541
一、集成jpa 这篇文章 从上篇文章： springboot 集成jpa 基础上修改而来，所以首先数据库orm还是使用jpa，连接池也还是使用druid。 这部分内容不变 二、修改pom 依赖项 在上一篇的基础上，需要添加 sharding-jdbc的依赖，完整的pom如下： <?xml version="1.0" encoding="UTF-8"?> <project xmln...
SpringBoot整合Sharding-JDBC实现水平分表
桐花思雨
01-12 1368
目录数据库的水平分表需求说明 数据库的水平分表 关于水平分表可以参考文章：https://blog.csdn.net/weixin_38192427/article/details/122441366 需求说明 创建两张表 t_order_1 和 t_order_2，这两张表是订单表水平拆分后的表，通过 Sharding-JDBC 向订单表插入数据， 按照一定的分片规则，主键为偶数的进入 t_order_1，主键为奇数进入 t_order_2，通过 Sharding-JDBC 查询数据，根据 SQL 语句的
springboot整合sharding-jdbc实现按年分库按月分表
weixin_47077809的博客
02-05 1万+
springboot整合sharding-jdbc实现按年分库按月分表 1.前言： ​ 此方案为适用对时间依赖度较高的数据进行水平切分，如果你正好符合，那么你可以看看此篇，不符合也可以看看，毕竟sharding-jdbc对分库分表的方案实现度很高，可根据自身实际情况进行数据切分 2.分库分表概念 ​ 在做实现之前，我们需要了解到何为分库分表，为何要这样做，这样做有何利弊？ ​ 由于关系型数据库的先天特性，在单表数据量达到一定体量的时候，就会出现性能瓶颈，至于具体是多少，此篇不做研究，说法众多，后期有时
解读分库分表中间件Sharding-JDBC与实现分库分表功能
KHOST的博客
04-28 333
分库分表适用场景 分库分表用于应对当前互联网常见的两个场景——大数据量和高并发。通常分为垂直拆分和水平拆分两种。 垂直拆分是根据业务将一个库（表）拆分为多个库（表）。如：将经常和不常访问的字段拆分至不同的库或表中。由于与业务关系密切，目前的分库分表产品均使用水平拆分方式。 水平拆分则是根据分片算法将一个库（表）拆分为多个库（表）。如：按照ID的最后一位以3取余，尾数是1的放入第1个库（表），...
Sharding-JDBC基本使用，Springboot实现分库分表，读写分离
gp16674213804的博客
10-29 1159
一、Sharding-JDBC介绍 1、这里引用官网上的介绍： 定位为轻量级Java框架，在Java的JDBC层提供的额外服务。 它使用客户端直连数据库，以jar包形式提供服务，无需额外部署和依赖，可理解为增强版的JDBC驱动，完全兼容JDBC和各种ORM框架。 适用于任何基于JDBC的ORM框架，如：JPA, Hibernate, Mybatis, Spring JDBC Template或直接使用JDBC。 支持任何第三方的数据库连接池，如：DBCP, C3P0, BoneCP, Druid,
ShardingJDBC+JPA分表查询时物理表采用MySQL自增主键产生的查询BUG排查
u013244613的博客
01-16 2439
很懒，不爱写东西，这次BUG排查印象深刻，过程有点痛苦，仅作为笔记形式供自己和大家参考，避免在以后遇到同类问题时继续踩坑... 背景 云PASS平台需要统计各租户的客户端使用者每天发送的各种消息类型的消息量，根据使用量生成账单展示给租户方便客户对账。使用量统计服务（DATA服务）作为微服务架构中的独立服务，消费上游服务推送至kafka的消息记录，将消息处理后暂存至Redis，然后在空闲时间将数据保存至数据库。由于平台使用量较大，每天产生的kafka消息在10亿以上，平台30万租户，每天产生的数据库记录在
shardingsphere-jdbc之Mybatis分表
Lance
02-21 875
介绍 基于shardingsphere-jdbc进行单库分表 1. maven项目依赖 <dependencies> <dependency> <groupId>org.apache.shardingsphere</groupId> <artifactId>shardingsphere-jdbc-core-spring-boot-starter</artifactId>
Sharding-JDBC分表不分库
最新发布
Crzep的博客
07-16 1075
Sharding-JDBC分表
Sharding-JDBC 分库分表实战 springboot+sharding-jdbc+jpa+druid
shouhuhuise的专栏
08-19 2217
分库分表前言
Sharding-JDBC对不需要分库分表的普通表如何配置数据源
xycf0的博客
07-14 5469
在我们使用Sharding-JDBC实现分库分表时，更多的表是不需要分库分表的，此时我们需要配置默认数据库，让不需要分库分表的表，使用默认数据源。 yml配置：
shardingjdbc不参与分库分表的配置处理方式
liaomingwu的专栏
01-03 8049
shardingjdbc不参与分库分表的配置处理方式。
sharding-datasource之JPA基于AbstractRoutingDataSource动态切换数据源
Lance
03-10 1953
介绍 基于sharding-datasource, jpa进行分库操作, 实现AbstractRoutingDataSource动态切换数据源 SaaS服务多租户介绍，每个租户的资源都是独立的，从入口到应用部署到数据，都是完全隔离的。每个租户相当于“托管”在提供服务的公司里面，公司做的其实是统一运维。好处在于，这个隔离非常彻底，基本不太会有相互影响；如果有特殊客户要求的定制化，也没啥处理难度。缺陷在于，很容易因为隔离和定制，导致版本不统一，资源也浪费比较大，因为是“代运维”的模式，因此服务成本也比较高。
ShardingJDBC——基于JPA的读写分离实战
庄小焱
09-01 512
本博文主要介绍基于JPA的读写分离实战，帮助大家更好的学会使用读写分离。透明化读写分离所带来的影响，让使用方尽量像使用一个数据库一样使用主从数据库集群，是ShardingSphere读写分离模块的主要设计目标。
Sharding-JDBC
HGW的博客
08-29 554
首先为大家介绍一下ShardingSphere，ShardingSphere定位为关系型数据库中间件，旨在充分合理地在分布式的场景下利用关系型数据库的计算和存储能力，而并非实现一个全新的关系型数据库。在实际使用场景中，随着数据库数据量增加 ，不要首先考虑做水平切分，应当首先考虑缓存处理、读写分离、优化SQL等方式，如果这些方式不能根本解决问题，再考虑做水平分库和水平分表。而切分之后，数据可能分布在不同的节点上，此时Join带来的问题就比较麻烦了，考虑到性能，尽量避免使用Join查询。从而提升了数据库性能。.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值