ShardingSphere快速开始与核心概念

最新推荐文章于 2024-10-06 19:00:36 发布
最新推荐文章于 2024-10-06 19:00:36 发布
阅读量1k 收藏 6
点赞数
分类专栏： ShardingSphere 文章标签： mongodb nosql 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_15270521/article/details/122891903
版权
本文介绍了ShardingSphere作为数据库中间件的功能，包括Sharding-JDBC的客户端直连特性、Sharding-Proxy的透明代理，以及如何在Spring Boot和Mybatis环境中快速集成。涵盖了分库分表、读写分离、主从策略和配置示例。
摘要由CSDN通过智能技术生成

定位

ShardingSphere定位为关系型数据库中间件

功能列表：

 

 核心三套件

Sharding-JDBC

客户端直连数据库，以jar包形式提供服务，无需额外部署和依赖，可理解为增强版的 JDBC驱动，完全兼容JDBC和各种ORM框架。

  • 适用于任何基于JDBC的ORM框架：JPA, Hibernate, Mybatis, Spring JDBC Template或直 接使用JDBC。
  • 支持任何第三方的数据库连接池：DBCP, C3P0, BoneCP, Druid, HikariCP等。 支持任意实现JDBC规范的数据库。
  • 支持MySQL，Oracle，SQLServer，PostgreSQL等遵循 SQL92标准的数据库。 

Sharding-Proxy

透明化的数据库代理端，兼容所有MySQL/PostgreSQL协议的访问客户端。

向应用程序完全透明，可直接当做MySQL/PostgreSQL使用。

核心概念 

逻辑表

水平拆分的数据库（表）的相同逻辑和数据结构表的总称。例：订单数据根据主键尾数 拆分为10张表，分别是t_order_0到t_order_9，他们的逻辑表名为t_order。

真实表

在分片的数据库中真实存在的物理表。即上个示例中的t_order_0到t_order_9。

数据节点

数据分片的最小单元。由数据源名称和数据表组成，例：ds_0.t_order_0。

绑定表

分片规则一致的主表和子表。例如：t_order表和t_order_item表，均按照order_id分 片，则此两张表互为绑定表关系。绑定表之间的多表关联查询不会出现笛卡尔积关联，关联 查询效率将大大提升。

广播表

指所有的分片数据源中都存在的表，表结构和表中的数据在每个数据库中均完全一致。 适用于数据量不大且需要与海量数据的表进行关联查询的场景。字典表就是典型的场景。

ShardingSphere快速启动

shardingsphere+springboot+mybatis集成使用

1、引入项目依赖

<dependencies>
        <!-- springboot-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <version>2.0.5.RELEASE</version>
        </dependency>
        <!-- mybatis -->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.0.1</version>
            <exclusions>
                <exclusion>
                    <artifactId>spring-boot-starter</artifactId>
                    <groupId>org.springframework.boot</groupId>
                </exclusion>
            </exclusions>
        </dependency>
        <!-- shardingsphere-jdbc,这里使用的版本为apache孵化版本，4.0之前
        都是没有捐献给apache基金会的版本,之前的版本都在-->
        <dependency>
            <groupId>org.apache.shardingsphere</groupId>
            <artifactId>sharding-jdbc-spring-boot-starter</artifactId>
            <version>4.1.1</version>
        </dependency>
        <!-- mysql 驱动 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.28</version>
        </dependency>
        <!-- 可选，工具类 -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.16.20</version>
            <scope>provided</scope>
            分库不分表配置
        </dependency>
    </dependencies>

分库不分表配置

# 配置ds0 和ds1两个数据源,这里有个坑(使用下划线可能会有异常产生，字符不支持,如：ds_0)
spring.shardingsphere.datasource.names=ds0,ds1

#ds0 配置
spring.shardingsphere.datasource.ds0.type=com.zaxxer.hikari.HikariDataSource
spring.shardingsphere.datasource.ds0.driver-class-name=com.mysql.jdbc.Driver
spring.shardingsphere.datasource.ds0.jdbc-url=jdbc:mysql://192.168.241.198:3306/shop_ds_0?serverTimezone=UTC&useSSL=false&useUnicode=true&characterEncoding=UTF-8
spring.shardingsphere.datasource.ds0.username=root
spring.shardingsphere.datasource.ds0.password=root
#ds1 配置
spring.shardingsphere.datasource.ds1.type=com.zaxxer.hikari.HikariDataSource
spring.shardingsphere.datasource.ds1.driver-class-name=com.mysql.jdbc.Driver
spring.shardingsphere.datasource.ds1.jdbc-url=jdbc:mysql://192.168.241.198:3306/shop_ds_1?serverTimezone=UTC&useSSL=false&useUnicode=true&characterEncoding=UTF-8
spring.shardingsphere.datasource.ds1.username=root
spring.shardingsphere.datasource.ds1.password=root

# 分库策略 根据id取模确定数据进哪个数据库
spring.shardingsphere.sharding.default-database-strategy.inline.sharding-column=user_id
spring.shardingsphere.sharding.default-database-strategy.inline.algorithm-expression=ds$->{user_id % 2}
spring.shardingsphere.sharding.binding-tables=t_order,t_order_item
spring.shardingsphere.sharding.broadcast-tables=t_address

# t_order表策略
spring.shardingsphere.sharding.tables.t_order.actual-data-nodes=ds$->{0..1}.t_order
# 使用SNOWFLAKE算法生成主键
spring.shardingsphere.sharding.tables.t_order.key-generator.column=order_id
spring.shardingsphere.sharding.tables.t_order.key-generator.type=SNOWFLAKE
#spring.shardingsphere.sharding.tables.t_order.key-generator.props.worker.id=123
# t_order_item表策略
spring.shardingsphere.sharding.tables.t_order_item.actual-data-nodes=ds$->{0..1}.t_order_item
# 使用SNOWFLAKE算法生成主键
spring.shardingsphere.sharding.tables.t_order_item.key-generator.column=order_item_id
spring.shardingsphere.sharding.tables.t_order_item.key-generator.type=SNOWFLAKE
#spring.shardingsphere.sharding.tables.t_order_item.key-generator.props.worker.id=123

分库分表

# 配置ds0 和ds1两个数据源
spring.shardingsphere.datasource.names=ds0,ds1

#ds0 配置
spring.shardingsphere.datasource.ds0.type=com.zaxxer.hikari.HikariDataSource
spring.shardingsphere.datasource.ds0.driver-class-name=com.mysql.jdbc.Driver
spring.shardingsphere.datasource.ds0.jdbc-url=jdbc:mysql://127.0.0.1:3306/shop_ds_0?serverTimezone=UTC&useSSL=false&useUnicode=true&characterEncoding=UTF-8
spring.shardingsphere.datasource.ds0.username=root
spring.shardingsphere.datasource.ds0.password=root
#ds1 配置
spring.shardingsphere.datasource.ds1.type=com.zaxxer.hikari.HikariDataSource
spring.shardingsphere.datasource.ds1.driver-class-name=com.mysql.jdbc.Driver
spring.shardingsphere.datasource.ds1.jdbc-url=jdbc:mysql://127.0.0.1:3306/shop_ds_1?serverTimezone=UTC&useSSL=false&useUnicode=true&characterEncoding=UTF-8
spring.shardingsphere.datasource.ds1.username=root
spring.shardingsphere.datasource.ds1.password=root

# 分库策略 根据id取模确定数据进哪个数据库
spring.shardingsphere.sharding.default-database-strategy.inline.sharding-column=user_id
spring.shardingsphere.sharding.default-database-strategy.inline.algorithm-expression=ds$->{user_id % 2}
spring.shardingsphere.sharding.binding-tables=t_order,t_order_item
spring.shardingsphere.sharding.broadcast-tables=t_address

# 具体分表策略
# 节点 ds0.t_order_0,ds0.t_order_1,ds1.t_order_0,ds1.t_order_1
spring.shardingsphere.sharding.tables.t_order.actual-data-nodes=ds$->{0..1}.t_order_$->{0..1}
# 分表字段id
spring.shardingsphere.sharding.tables.t_order.table-strategy.inline.sharding-column=order_id
# 分表策略 根据id取模,确定数据最终落在那个表中
spring.shardingsphere.sharding.tables.t_order.table-strategy.inline.algorithm-expression = t_order_$->{order_id % 2}
# 使用SNOWFLAKE算法生成主键
spring.shardingsphere.sharding.tables.t_order.key-generator.column=order_id
spring.shardingsphere.sharding.tables.t_order.key-generator.type=SNOWFLAKE
#spring.shardingsphere.sharding.tables.t_order.key-generator.props.worker.id=123

# 节点 ds0.t_order_item_0,ds0.t_order_item_1,ds1.t_order_item_0,ds1.t_order_item_1
spring.shardingsphere.sharding.tables.t_order_item.actual-data-nodes=ds$->{0..1}.t_order_item_$->{0..1}
# 分表字段id
spring.shardingsphere.sharding.tables.t_order_item.table-strategy.inline.sharding-column=order_id
# 分表策略 根据id取模,确定数据最终落在那个表中
spring.shardingsphere.sharding.tables.t_order_item.table-strategy.inline.algorithm-expression=t_order_item_$->{order_id % 2}
# 使用SNOWFLAKE算法生成主键
spring.shardingsphere.sharding.tables.t_order_item.key-generator.column=order_item_id
spring.shardingsphere.sharding.tables.t_order_item.key-generator.type=SNOWFLAKE
#spring.shardingsphere.sharding.tables.t_order_item.key-generator.props.worker.id=123

读写分离

#shardingsphere 读写分离,master-slave,可以一主多从
spring.shardingsphere.datasource.names=ds-master,ds-slave0
#主库
spring.shardingsphere.datasource.ds-master.type=com.zaxxer.hikari.HikariDataSource
spring.shardingsphere.datasource.ds-master.driver-class-name=com.mysql.jdbc.Driver
spring.shardingsphere.datasource.ds-master.jdbc-url=jdbc:mysql://192.168.241.198:3306/shop_ds_master?serverTimezone=UTC&useSSL=false&useUnicode=true&characterEncoding=UTF-8
spring.shardingsphere.datasource.ds-master.username=root
spring.shardingsphere.datasource.ds-master.password=root
#从库0
spring.shardingsphere.datasource.ds-slave0.type=com.zaxxer.hikari.HikariDataSource
spring.shardingsphere.datasource.ds-slave0.driver-class-name=com.mysql.jdbc.Driver
spring.shardingsphere.datasource.ds-slave0.jdbc-url=jdbc:mysql://192.168.241.199:3306/shop_ds_slave?serverTimezone=UTC&useSSL=false&useUnicode=true&characterEncoding=UTF-8
spring.shardingsphere.datasource.ds-slave0.username=root
spring.shardingsphere.datasource.ds-slave0.password=root
#从库1
#spring.shardingsphere.datasource.ds-slave1.type=com.zaxxer.hikari.HikariDataSource
#spring.shardingsphere.datasource.ds-slave1.driver-class-name=com.mysql.jdbc.Driver
#spring.shardingsphere.datasource.ds-slave1.jdbc-url=jdbc:mysql://192.168.241.199:3306/shop_ds_slave1?serverTimezone=UTC&useSSL=false&useUnicode=true&characterEncoding=UTF-8
#spring.shardingsphere.datasource.ds-slave1.username=root
#spring.shardingsphere.datasource.ds-slave1.password=root

#读写分离主从规则设置，当有2个以上从库时，从库读采用轮询的负载均衡机制
spring.shardingsphere.masterslave.load-balance-algorithm-type=round_robin
spring.shardingsphere.masterslave.name=ms
spring.shardingsphere.masterslave.master-data-source-name=ds-master
spring.shardingsphere.masterslave.slave-data-source-names=ds-slave0

读写分离+分库分表

#shardingsphere 读写分离+分库分表,master-slave-sharding,可以一主多从
spring.shardingsphere.datasource.names=ds-master0,ds-slave0,ds-master1,ds-slave1
#主库0
spring.shardingsphere.datasource.ds-master0.type=com.zaxxer.hikari.HikariDataSource
spring.shardingsphere.datasource.ds-master0.driver-class-name=com.mysql.jdbc.Driver
spring.shardingsphere.datasource.ds-master0.jdbc-url=jdbc:mysql://192.168.241.198:3306/shop_ds_master?serverTimezone=UTC&useSSL=false&useUnicode=true&characterEncoding=UTF-8
spring.shardingsphere.datasource.ds-master0.username=root
spring.shardingsphere.datasource.ds-master0.password=root
#从库0
spring.shardingsphere.datasource.ds-slave0.type=com.zaxxer.hikari.HikariDataSource
spring.shardingsphere.datasource.ds-slave0.driver-class-name=com.mysql.jdbc.Driver
spring.shardingsphere.datasource.ds-slave0.jdbc-url=jdbc:mysql://192.168.241.199:3306/shop_ds_slave?serverTimezone=UTC&useSSL=false&useUnicode=true&characterEncoding=UTF-8
spring.shardingsphere.datasource.ds-slave0.username=root
spring.shardingsphere.datasource.ds-slave0.password=root
#主库1
spring.shardingsphere.datasource.ds-master1.type=com.zaxxer.hikari.HikariDataSource
spring.shardingsphere.datasource.ds-master1.driver-class-name=com.mysql.jdbc.Driver
spring.shardingsphere.datasource.ds-master1.jdbc-url=jdbc:mysql://192.168.241.198:3306/shop_ds_master1?serverTimezone=UTC&useSSL=false&useUnicode=true&characterEncoding=UTF-8
spring.shardingsphere.datasource.ds-master1.username=root
spring.shardingsphere.datasource.ds-master1.password=root
#从库1
spring.shardingsphere.datasource.ds-slave1.type=com.zaxxer.hikari.HikariDataSource
spring.shardingsphere.datasource.ds-slave1.driver-class-name=com.mysql.jdbc.Driver
spring.shardingsphere.datasource.ds-slave1.jdbc-url=jdbc:mysql://192.168.241.199:3306/shop_ds_slave1?serverTimezone=UTC&useSSL=false&useUnicode=true&characterEncoding=UTF-8
spring.shardingsphere.datasource.ds-slave1.username=root
spring.shardingsphere.datasource.ds-slave1.password=root

# 分库策略 根据id取模确定数据进哪个数据库
spring.shardingsphere.sharding.default-database-strategy.inline.sharding-column=user_id
spring.shardingsphere.sharding.default-database-strategy.inline.algorithm-expression=ds_$->{user_id % 2}
spring.shardingsphere.sharding.binding-tables=t_order,t_order_item
spring.shardingsphere.sharding.broadcast-tables=t_address

#分表策略
spring.shardingsphere.sharding.tables.t_order.actual-data-nodes=ds_$->{0..1}.t_order_$->{0..1}
spring.shardingsphere.sharding.tables.t_order.table-strategy.inline.sharding-column=order_id
spring.shardingsphere.sharding.tables.t_order.table-strategy.inline.algorithm-expression=t_order_$->{order_id % 2}
spring.shardingsphere.sharding.tables.t_order.key-generator.column=order_id
spring.shardingsphere.sharding.tables.t_order.key-generator.type=SNOWFLAKE
#spring.shardingsphere.sharding.tables.t_order.key-generator.props.worker.id=123
spring.shardingsphere.sharding.tables.t_order_item.actual-data-nodes=ds_$->{0..1}.t_order_item_$->{0..1}
spring.shardingsphere.sharding.tables.t_order_item.table-strategy.inline.sharding-column=order_id
spring.shardingsphere.sharding.tables.t_order_item.table-strategy.inline.algorithm-expression=t_order_item_$->{order_id % 2}
spring.shardingsphere.sharding.tables.t_order_item.key-generator.column=order_item_id
spring.shardingsphere.sharding.tables.t_order_item.key-generator.type=SNOWFLAKE
#spring.shardingsphere.sharding.tables.t_order_item.key-generator.props.worker.id=123

#读写分离数据源0
spring.shardingsphere.sharding.master-slave-rules.ds_0.master-data-source-name=ds-master0
spring.shardingsphere.sharding.master-slave-rules.ds_0.slave-data-source-names=ds-slave0
#读写分离主从规则设置，当有2个以上从库时，从库读采用轮询的负载均衡机制
spring.shardingsphere.sharding.master-slave-rules.ds_0.load-balance-algorithm-type=ROUND_ROBIN

#读写分离数据源1
spring.shardingsphere.sharding.master-slave-rules.ds_1.master-data-source-name=ds-master1
spring.shardingsphere.sharding.master-slave-rules.ds_1.slave-data-source-names=ds-slave1
#读写分离主从规则设置，当有2个以上从库时，从库读采用轮询的负载均衡机制
spring.shardingsphere.sharding.master-slave-rules.ds_1.load-balance-algorithm-type=ROUND_ROBIN

主配置

server.port=8080

# 实体类路径
mybatis.type-aliases-package=com.tl.it.edu.entity

#打印出sql语句
#spring.shardingsphere.props.sql.show = true
#加载配置-分库不分表
#spring.profiles.active=sharding-databases
#分表不分库
#spring.profiles.active=sharding-tables
#加载配置-分库也分表
spring.profiles.active=sharding-databases-tables
# 主从master-slave，读写分离
#spring.profiles.active=sharding-master-slave
# 读写分离+数据分片
#spring.profiles.active=sharding-masterslave-databases-tables
#使用后端代理-实现分库分表
#spring.profiles.active=sharding-proxy

mybatis相关代码

@Configuration
public class CommonConfiguration {

    //注册到容器中
    @Bean
    public ConfigurationCustomizer configurationCustomizer(){
        return new ConfigurationCustomizer(){
            @Override
            public void customize(org.apache.ibatis.session.Configuration configuration) {
                //开启驼峰命名规则
                configuration.setMapUnderscoreToCamelCase(true);
            }
        };
    }

}

Mapper

@Mapper
public interface OrderMapper {

    @Options(useGeneratedKeys = true,keyProperty = "orderId",keyColumn = "order_id")
    @Insert("INSERT INTO t_order (user_id, address_id, status) VALUES (#{userId,jdbcType=INTEGER}," +
            " #{addressId,jdbcType=BIGINT}, #{status,jdbcType=VARCHAR})")
    long insert(Order order) throws SQLException;

    @Delete("DELETE FROM t_order WHERE order_id = #{orderId}")
    void delete(long orderId) throws SQLException;

    @Select("SELECT * FROM t_order")
    List<Order> selectAll() throws SQLException;

    @Select("SELECT * FROM t_order WHERE order_id BETWEEN #{start} AND #{end}")
    List<Order> selectRange(@Param("start") long start,@Param("end") long end) throws SQLException;

    @Select("SELECT * FROM t_order order by order_id limit #{offset},#{size}")
    List<Order> selectPageList(@Param("offset") long offset,@Param("size") long size) throws SQLException;

    @Update("update t_order set status = #{status} where order_id = #{orderId}")
    int update(@Param("orderId") long orderId, @Param("status") String status) throws SQLException;
}

@Mapper
public interface OrderItemMapper {

    @Options(useGeneratedKeys = true,keyProperty = "orderItemId",keyColumn = "order_item_id")
    @Insert("INSERT INTO t_order_item (order_id, user_id, status) VALUES (#{orderId,jdbcType=INTEGER}," +
            " #{userId,jdbcType=INTEGER}, #{status,jdbcType=VARCHAR})")
    long insert(OrderItem order) throws SQLException;

    @Delete("DELETE FROM t_order_item WHERE order_id = #{orderId}")
    void delete(long orderId) throws SQLException;

    /**
     * 查询所有数据
     * @return
     * @throws SQLException
     */
    @Select("SELECT i.* FROM t_order o, t_order_item i WHERE o.order_id = i.order_id")
    List<OrderItem> selectAll() throws SQLException;

    /**
     * 绑定表,避免无笛卡尔积查询现象，
     * @param start
     * @param end
     * @return
     * @throws SQLException
     */
    @Select("SELECT i.* FROM t_order o JOIN t_order_item i ON o.order_id=i.order_id WHERE o.order_id = 0 or o.order_id = 1")
    List<OrderItem> selectWithInCondition(@Param("start") long start,@Param("end") long end) throws SQLException;

    /**
     * 不支持该路由规则
     */
    @Select("SELECT i.* FROM t_order o, t_order_item i WHERE o.order_id = i.order_id" +
            " AND o.user_id BETWEEN #{start} AND #{end}")
    List<OrderItem> selectRange(@Param("start") int start,@Param("end") int end) throws SQLException;

    @Update("update t_order_item set status = #{status} where order_id = #{orderId}")
    int update(@Param("orderId") long orderId,@Param("status") String status) throws SQLException;
}

@Mapper
public interface AddressMapper {
}

@Mapper
public interface UserMapper {
}

service

@Slf4j
@Service
public class OrderServiceImpl {

    @Autowired
    OrderMapper orderMapper;

    @Autowired
    OrderItemMapper orderItemMapper;

    @Transactional
    public long confirmOrder(int sequenceId){
        //创建订单
        Order order = new Order();
        order.setAddressId(sequenceId);
        order.setUserId(sequenceId);
        order.setStatus("创建订单");
        try {
            orderMapper.insert(order);
            //订单对应产品
            OrderItem item = new OrderItem();
            item.setOrderId(order.getOrderId());
            item.setUserId(sequenceId);
            item.setOrderItemId(sequenceId);
            item.setStatus("创建订单");
            orderItemMapper.insert(item);
        } catch (SQLException e) {
            log.info(e.getMessage(),e.getCause());
            throw new RuntimeException("SQLException",e.getCause());
        }
        return order.getOrderId();
    }

    public OrderInfoDto selectAll(){
        try {
            return new OrderInfoDto(orderMapper.selectAll(),orderItemMapper.selectAll());
        } catch (SQLException e) {
            log.info(e.getMessage(),e.getCause());
        }
        return null;
    }

    @Transactional
    public String deleteData(long orderId){
        try {
            orderMapper.delete(orderId);
            orderItemMapper.delete(orderId);
            return "delete data success";
        } catch (SQLException e) {
            log.info(e.getMessage(),e.getCause());
        }
        return "failure";
    }

    @Transactional
    public int updateOrder(long orderId,String status) {
        try {
            return orderMapper.update(orderId,status);
        } catch (SQLException e) {
            log.info(e.getMessage(),e.getCause());
            throw new RuntimeException("exception is happenning, tx will be rollback",e.getCause());
        }
    }

    public OrderInfoDto selectOrderRange(long start,long end){
        try {
            return new OrderInfoDto(orderMapper.selectRange(start,end),null);
        } catch (SQLException e) {
            log.info(e.getMessage(),e.getCause());
        }
        return null;
    }

    public OrderInfoDto selectOrderItemRange(int start,int end){
        try {
            return new OrderInfoDto(null,orderItemMapper.selectRange(start,end));
        } catch (SQLException e) {
            log.info(e.getMessage(),e.getCause());
        }
        return null;
    }

    public OrderInfoDto selectOrderItemWithIn(long start,long end){
        try {
            return new OrderInfoDto(null,orderItemMapper.selectWithInCondition(start,end));
        } catch (SQLException e) {
            log.info(e.getMessage(),e.getCause());
        }
        return null;
    }

    public OrderInfoDto selectOrderPageList(long offset,long size){
        try {
            return new OrderInfoDto(orderMapper.selectRange(offset,size),null);
        } catch (SQLException e) {
            log.info(e.getMessage(),e.getCause());
        }
        return null;
    }

}

entity

public class Order implements Serializable {
    
    private static final long serialVersionUID = 661434701950670670L;
    
    private long orderId;
    
    private int userId;
    
    private long addressId;
    
    private String status;
    
    public long getOrderId() {
        return orderId;
    }
    
    public void setOrderId(final long orderId) {
        this.orderId = orderId;
    }
    
    public int getUserId() {
        return userId;
    }
    
    public void setUserId(final int userId) {
        this.userId = userId;
    }
    
    public String getStatus() {
        return status;
    }
    
    public void setStatus(final String status) {
        this.status = status;
    }
    
    public long getAddressId() {
        return addressId;
    }
    
    public void setAddressId(final long addressId) {
        this.addressId = addressId;
    }
    
    @Override
    public String toString() {
        return String.format("order_id: %s, user_id: %s, address_id: %s, status: %s", orderId, userId, addressId, status);
    }
}

public class OrderItem implements Serializable {
    
    private static final long serialVersionUID = 263434701950670170L;
    
    private long orderItemId;
    
    private long orderId;
    
    private int userId;
    
    private String status;
    
    public long getOrderItemId() {
        return orderItemId;
    }
    
    public void setOrderItemId(final long orderItemId) {
        this.orderItemId = orderItemId;
    }
    
    public long getOrderId() {
        return orderId;
    }
    
    public void setOrderId(final long orderId) {
        this.orderId = orderId;
    }
    
    public int getUserId() {
        return userId;
    }
    
    public void setUserId(final int userId) {
        this.userId = userId;
    }
    
    public String getStatus() {
        return status;
    }
    
    public void setStatus(final String status) {
        this.status = status;
    }
    
    @Override
    public String toString() {
        return String.format("order_item_id:%s, order_id: %s, user_id: %s, status: %s", orderItemId, orderId, userId, status);
    }
}

public class Address {
    
    private static final long serialVersionUID = 661434701950670670L;
    
    private Long addressId;
    
    private String addressName;
    
    public Long getAddressId() {
        return addressId;
    }
    
    public void setAddressId(final Long addressId) {
        this.addressId = addressId;
    }
    
    public String getAddressName() {
        return addressName;
    }
    
    public void setAddressName(final String addressName) {
        this.addressName = addressName;
    }
}

public class User implements Serializable {
    
    private static final long serialVersionUID = 263434701950670170L;
    
    private int userId;
    
    private String userName;
    
    private String userNamePlain;
    
    private String pwd;
    
    private String assistedQueryPwd;
    
    public int getUserId() {
        return userId;
    }
    
    public void setUserId(final int userId) {
        this.userId = userId;
    }
    
    public String getUserName() {
        return userName;
    }
    
    public void setUserName(final String userName) {
        this.userName = userName;
    }
    
    public String getUserNamePlain() {
        return userNamePlain;
    }
    
    public void setUserNamePlain(final String userNamePlain) {
        this.userNamePlain = userNamePlain;
    }
    
    public String getPwd() {
        return pwd;
    }
    
    public void setPwd(final String pwd) {
        this.pwd = pwd;
    }
    
    public String getAssistedQueryPwd() {
        return assistedQueryPwd;
    }
    
    public void setAssistedQueryPwd(final String assistedQueryPwd) {
        this.assistedQueryPwd = assistedQueryPwd;
    }
    
    @Override
    public String toString() {
        return String.format("user_id: %d, user_name: %s, user_name_plain: %s, pwd: %s, assisted_query_pwd: %s", userId, userName, userNamePlain, pwd, assistedQueryPwd);
    }
}

dto

@AllArgsConstructor
@RequiredArgsConstructor
@Setter
@Getter
public class OrderInfoDto {

    private List<Order> order;

    private List<OrderItem> item;

}

controller

@Slf4j
@RestController
public class ShardingController {

    @Autowired
    OrderServiceImpl orderService;

    @GetMapping("/confirm_order")
    public String confirmOrder(int sequenceId){
        long id = orderService.confirmOrder(sequenceId);
        return "创建订单成功:订单ID = " + id;
    }

    @GetMapping("/order_histroy_list")
    public OrderInfoDto orderHistoryList(){
        return orderService.selectAll();
    }

    /**
     * 删除历史订单
     * @param orderId
     * @return
     */
    @GetMapping("/delete_histroy_order")
    public String deleteHistroyOrder(long orderId){
        return orderService.deleteData(orderId);
    }

    /**
     * 更改历史订单状态
     * @param orderId
     * @param status
     * @return
     */
    @GetMapping("/update_histroy_order")
    public int updateHistoryOrderStatus(long orderId,String status){
        return orderService.updateOrder(orderId,status);
    }

    /**
     * range orderid {200000000000000000 - 400000000000000000}
     * @param start
     * @param end
     * @return
     */
    @GetMapping("/order_range_list")
    public OrderInfoDto orderRangeList(long start,long end){
        return orderService.selectOrderRange(start,end);
    }

    /**
     * range userid {1-20}
     * @param start
     * @param end
     * @return
     */
    @GetMapping("/item_range_list")
    public OrderInfoDto orderItemRangeList(int start,int end){
        return orderService.selectOrderItemRange(start,end);
    }

    /**
     * 笛卡尔积测试
     * @param start
     * @param end
     * @return
     */
    @GetMapping("/item_range_in_list")
    public OrderInfoDto orderItemRangeInList(long start,long end){
        return orderService.selectOrderItemWithIn(start,end);
    }

    @GetMapping("/item_page_list")
    public OrderInfoDto orderPageList(long offset,long size){
        return orderService.selectOrderPageList(offset,size);
    }
}

启动类

@MapperScan(basePackages = "com.tl.it.edu.mapper")
@SpringBootApplication
public class TlShopApplication {

    public static void main(String[] args) {
        SpringApplication.run(TlShopApplication.class,args);
    }

}

 

小强同志
关注
专栏目录
sharding-sphere 快速开始与核心概念
z785495295的博客
01-24 2862
Sharding-sphere： Github：https://github.com/sharding-sphere/sharding-sphere 官网：http://shardingsphere.io/index_zh.html   ShardingSphere是一套开源的分布式数据库中间件解决方案组成的生态圈，它由Sharding-JDBC、Sharding-Proxy和Shardi...
分库分表利器——sharding-sphere
weixin_34390996的博客
10-05 295
2019独角兽企业重金招聘Python工程师标准>>> ...
ShardingJDBC分库分表配置文件详解
最新发布
V_i_n_g的博客
10-06 980
ShardingJDBC分库分表配置文件详解
(一)ShardingSphere入门基础概念
woshiwjma956的博客
06-09 506
基本概念 个人观点，数据库能不切分就不切分，在需要切分之前先采用缓存，读写分离，索引，SQL优化等方式尝试能不能将业务性能提高，实在不行了再考虑数据库切分。数据库切分会带来维护麻烦，找错麻烦等问题，建议能在不切分情况下解决问题就不要切分。 数据库切分就是将原来一个大量数据的数据库分散存放到不同主机或者不同的表上。 数据库切分分成垂直切分和水平切分 垂直切分：按照不同的表（或者Schema）切分到不同的数据库（主机）上。一个数据库由很多表构成，每张表对应不同的业务，垂直切分是按照业务将表进行分类，分布到不同
ShardingSphere介绍
一起coding，一起嗨。
02-22 3526
Apache ShardingSphere 是一款分布式的数据库生态系统， 可以将任意数据库转换为分布式数据库，并通过数据分片、弹性伸缩、加密等能力对原有数据库进行增强。Apache ShardingSphere 设计哲学为 Database Plus，旨在构建异构数据库上层的标准和生态。它关注如何充分合理地利用数据库的计算和存储能力，而并非实现一个全新的数据库。它站在数据库的上层视角，关注它们之间的协作多于数据库自身。正在上传…重新上传取消。
学习shardingSphere
qq_45191937的博客
11-25 507
1.shardingSphere简介 Apache ShardingSphere 是一套开源的分布式数据库解决方案组成的生态圈，它由 JDBC、Proxy 和 Sidecar（规划中）这 3 款既能够独立部署，又支持混合部署配合使用的产品组成。 它们均提供标准化的数据水平扩展、分布式事务和分布式治理等功能，可适用于如 Java 同构、异构语言、云原生等各种多样化的应用场景。 Apache ShardingSphere 旨在充分合理地在分布式的场景下利用关系型数据库的计算和存储能力，而并非实现一个全新的关系型
ShardingSphere快速开始与核心概念-图灵杨过1
08-03
ShardingSphere的核心概念包括： - 逻辑表：逻辑表是水平拆分后的数据库（表）的逻辑表示，具有相同的结构。例如，一个名为t_order的逻辑表可能被拆分为10张实际的表t_order_0到t_order_9。 - 真实表：在数据库中...
Apache ShardingSphere 分布式SQL事务与查询引擎
01-13
项目的核心概念包括：连接（Connect）、增强（Enhance）和插件化（Pluggable）。 连接（Connect）：灵活适应数据库协议、SQL方言以及数据库存储方式，可以快速实现应用程序与异构数据库之间的连接。 增强（Enhance...
shardingsphere_docs_cn.pdf
11-16
#### 四、核心概念与功能解析 - **数据分片**： - **背景**：随着数据量的快速增长，单个数据库服务器难以满足业务需求，因此需要通过数据分片来实现水平扩展。 - **垂直分片**：按照业务逻辑的不同将数据分割到...
Apache ShardingSphere：分库分表指南与快速入门
该文档涵盖了ShardingSphere的主要组件、使用方法、概念以及核心功能。 1. **简介**：文档首先介绍了ShardingSphere的核心组件，包括： - **ShardingSphere-JDBC**：提供了一个Java JDBC驱动，允许开发者在连接池...
ShardingSphere学习
mei_gogogo的博客
12-12 1274
shardingsphere学习
sharding-sphere-demo:sharding-shere的demo程序
05-13
这是sharding-sphere的demo程序，基于sharding-shphere3.x版本 sharding-jdbc-demo sharding-jdbc-demo:针对sharding-jdbc组件的demo程序 master-slave-01: 基于JPA的读写分离demo master-slave-02: 基于mybatis的读写分离demo master-slave-03: 基于mybatis-plus的读写分离demo sharding-demo-01: 基于JPA的数据分片demo sharding-demo-02: 基于mybatis的数据分片demo sharding-demo-03: 基于mybatis-plus的数据分片demo sharding-masterslave-01: 基于JPA的数据分片+读写分离demo sharding-masterslave-0
ShardingSphere 简介（一）
u012736401的专栏
10-27 3523
shardingphere 简介（一）
ShardingSphere(一)ShardingSphere简单介绍及相关概念
liuhenghui5201的专栏
02-01 1304
一、ShardingSphere简单介绍 出现背景：当数据库数据巨大时，数据库读写性能将变得很低，为了解决此问题，设计时，可以将数据进行分别存储于不同数据库、不同表中，以降低单表量数量大问题；ShardingSphere它是一套开源的分布式数据库中间件。同于统筹协调分库分表下的数据读写，而让业务开发人员只关注数据层之外的工作，而不用去用业务代码判断操作那个库，那个表。 Apache ShardingSphere 是一套开源的分布式数据库中间件解决方案组成的生态圈，它由 JDBC、Proxy 和 Side
03 分布式 07 sharding-sphere：ShardingSphere简介
好刹那的专栏
12-13 252
ShardingSphere是一套开源的分布式数据库中间件解决方案组成的生态圈。 它由Sharding-JDBC、Sharding-Proxy和Sharding-Sidecar（计划中）这3款相互独立的产品组成，shardingSphere定位为关系型数据库中间件。 1. Sharding-JDBC Sharding-JDBC是Sharding-Sphere的第一个产品，也是Sharding-...
面试三连问：你这个数据量多大？分库分表怎么做？用的哪个组件？
码猿技术专栏
12-11 2102
点击上方蓝色“码猿技术专栏”，选择“设为星标”来源：cnblogs.com/cjsblog/p/13154158.html1. 概述1.1. ShardingSphere-JDBC1....
ShardingSphere之HiKariCP和Druid
sinat_38247666的博客
06-18 3277
场景 由于需要对人员信息的个别字段进行加密处理，所以我们使用了ShardingSphere相应的加密功能。 在压测人员信息查询的接口时，使用了1000个线程，每个线程请求100次，在10分钟完成。压测开始前几分钟还是好好的，但是后面会报500的错误，并且响应时长都在1s以上，错误原因是服务调用超时(我们使用的微服务架构)，我们尝试的方法如下： 通过扩容会好一点点，但是不能明显减少错误和相应时间； 扩大连接池数，和扩容的效果相似。 解决方法 将原来的数据库链接池由Druid改为了HiKariCP，不仅没有
SpringBoot下使用ShardingShere实现分表操作
GuessHat的博客
10-29 615
SpringBoot下使用ShardingShere实现分表操作 表结构： 因为后面使用了雪花算法保证生成的id唯一性，所以id列设置为bigInt类型 项目结构： 1.pom依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId>
ShardingSphere集成SpringBoot实现分库分表(一)-分库
weixin_39643007的博客
07-18 3062
项目中主要用到Sharding-JDBC，Sharding-JDBC定位为轻量级Java框架，在Java的JDBC层提供的额外服务。它使用客户端直连数据库，以jar包形式提供服务，无需额外部署和依赖，可理解为增强版的JDBC驱动，完全兼容JDBC和各种ORM框架的使用。actual-data-nodesds-$->{0..1}.user$会被大括号中的{0…1}所替换生成对应的结果为ds-0.user和ds-1.user。通过Sharding-JDBC，应用可以。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

小强同志

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

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

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

打赏作者

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

抵扣说明：

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

余额充值