• 全网最全最详细的Sharding-JDBC入门

    背景

    面对日益增加的系统访问量，数据库的吞吐量面临着巨大瓶颈。对于同一时刻有大量并发读操作和较少写操作类型的应用系统来说，将数据库拆分为主库和从库，主库负责处理事务性的增删改操作，从库负责处理查询操作，能够有效的避免由数据更新导致的行锁，使得整个系统的查询性能得到极大的改善。

    如图，将数据库执行读写操作由一台变成两台：

    Sharding-JDBC介绍

    Sharding-JDBC定位为轻量级Java框架,在Java的JDBC层提 供的额外服务。它使用客户端直连数据库,以jar包形式提供服务，无需额外部署和依赖，可理解为增强版的JDBC驱动，完全兼容JDBC和各种ORM框架。

    使用Sharding-JDBC可以在程序中轻松的实现数据库读写分离。

    1、适用于任何基于JDBC的ORM框架，如: JPA, Hibernate, Mybatis, Spring JDBC Template或直接使用JDBC。

    2、支持任何第三方的数据库连接池，如: DBCP, C3PO, BoneCP, Druid, HikariCP等。

    3、支持任意实现JDBC规范的数据库。目前支持MySQL, Oracle, SQLServer, PostgreSQL以及任何遵循SQL92标准的数据库。

    Sharding-JDBC入门案例

    准备工作，MySQL必须实现主从复制

    1、安装MySQL：

    Linux-18-软件安装_安装MySQL_哔哩哔哩_bilibili

    2、实现主从复制：

    项目优化Day2-03-MySQL主从复制_配置主库Master&从库Slave_哔哩哔哩_bilibili

    开始使用Sharding-JDBC实现读写分离

    1、创建一个maven工程，导入maven坐标

    1. "1.0" encoding="UTF-8"?>
    2. <project xmlns="http://maven.apache.org/POM/4.0.0"
    3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    5.     <modelVersion>4.0.0modelVersion>
    6.  
    7.     <parent>
    8.         <groupId>org.springframework.bootgroupId>
    9.         <artifactId>spring-boot-starter-parentartifactId>
    10.         <version>2.4.5version>
    11.         <relativePath/>
    12.         
    13.     parent>
    14.  
    15.     <groupId>com.sjgroupId>
    16.     <artifactId>sharding-jdbcartifactId>
    17.     <version>1.0-SNAPSHOTversion>
    18.  
    19.     <properties>
    20.         <java.version>1.8java.version>
    21.     properties>
    22.  
    23.     <dependencies>
    24.         <dependency>
    25.             <groupId>org.springframework.bootgroupId>
    26.             <artifactId>spring-boot-starter-webartifactId>
    27.             <scope>compilescope>
    28.         dependency>
    29.         <dependency>
    30.             <groupId>org.projectlombokgroupId>
    31.             <artifactId>lombokartifactId>
    32.             <version>1.18.20version>
    33.         dependency>
    34.         <dependency>
    35.             <groupId>com.alibabagroupId>
    36.             <artifactId>fastjsonartifactId>
    37.             <version>1.2.76version>
    38.         dependency>
    39.         <dependency>
    40.             <groupId>commons-langgroupId>
    41.             <artifactId>commons-langartifactId>
    42.             <version>2.6version>
    43.         dependency>
    44.         <dependency>
    45.             <groupId>mysqlgroupId>
    46.             <artifactId>mysql-connector-javaartifactId>
    47.             <scope>runtimescope>
    48.         dependency>
    49.         <dependency>
    50.             <groupId>com.baomidougroupId>
    51.             <artifactId>mybatis-plus-boot-starterartifactId>
    52.             <version>3.4.2version>
    53.         dependency>
    54.         <dependency>
    55.             <groupId>com.alibabagroupId>
    56.             <artifactId>druid-spring-boot-starterartifactId>
    57.             <version>1.1.23version>
    58.         dependency>
    59.         <dependency>
    60.             <groupId>org.apache.shardingspheregroupId>
    61.             <artifactId>sharding-jdbc-spring-boot-starterartifactId>
    62.             <version>4.0.0-RC1version>
    63.         dependency>
    64.     dependencies>
    65.  
    66.     <build>
    67.         <plugins>
    68.             <plugin>
    69.                 <groupId>org.springframework.bootgroupId>
    70.                 <artifactId>spring-boot-maven-pluginartifactId>
    71.                 <version>2.4.5version>
    72.             plugin>
    73.         plugins>
    74.     build>
    75.     
    76. project>

    2、编写yml配置文件

    1. server:
    2.   port: 7777
    3. spring:
    4.   shardingsphere:
    5.     datasource:
    6.       names:
    7.         master,slave
    8.       # 主数据源
    9.       master:
    10.         type: com.alibaba.druid.pool.DruidDataSource
    11.         driver-class-name: com.mysql.cj.jdbc.Driver
    12.         url: jdbc:mysql://192.168.11.101:3306/test?characterEncoding=utf-8
    13.         username: root
    14.         password: root
    15.       # 从数据源
    16.       slave:
    17.         type: com.alibaba.druid.pool.DruidDataSource
    18.         driver-class-name: com.mysql.cj.jdbc.Driver
    19.         url: jdbc:mysql://192.168.11.102:3306/test?characterEncoding=utf-8
    20.         username: root
    21.         password: root
    22.     masterslave:
    23.       # 读写分离配置
    24.       load-balance-algorithm-type: round_robin  #轮询
    25.       # 最终数据源名称
    26.       name: dataSource
    27.       # 主库数据源名称
    28.       master-data-source-name: master
    29.       # 从库数据源名称列表，多个逗号隔开
    30.       slave-data-source-names: slave
    31.     props:
    32.       sql:
    33.         #开启sql显示，默认为false
    34.         show: true
    35.   main:
    36.     allow-bean-definition-overriding: true
    37. mybatis-plus:
    38.   configuration:
    39.     #在映射实体或者属性时，将数据库中表名和字段名中的下划线去掉，按照驼峰命名法映射
    40.     map-underscore-to-camel-case: true
    41.     log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
    42.   global-config:
    43.     db-config:
    44.       id-type: ASSIGN_ID
    45.

    3、编写dao层，pojo层，service层，controller层，启动类进行测试

    dao层：

    1. package com.sj.dao;
    2.  
    3. import com.baomidou.mybatisplus.core.mapper.BaseMapper;
    4. import com.sj.pojo.User;
    5. import org.apache.ibatis.annotations.Mapper;
    6.  
    7. @Mapper
    8. public interface UserMapper extends BaseMapper {
    9. }

    pojo层：

    1. package com.sj.pojo;
    2.  
    3. import lombok.Data;
    4.  
    5. import java.io.Serializable;
    6.  
    7. @Data
    8. public class User implements Serializable {
    9.     private static final long serialVersionUID = 1L;
    10.     private Long id;
    11.     private String name;
    12.     private Integer age;
    13.     private String address;
    14. }

    service层：

    1. package com.sj.service;
    2.  
    3. import com.baomidou.mybatisplus.extension.service.IService;
    4. import com.sj.pojo.User;
    5.  
    6. import java.util.List;
    7.  
    8. public interface UserService extends IService {
    9.  
    10.     User saveUser(User user);
    11.  
    12.     String deleteUser(Long id);
    13.  
    14.     String updateUser(User user);
    15.  
    16.     User getUserById(Long id);
    17.  
    18.     List listUsers(User user);
    19. }
    20.  
    1. package com.sj.service.impl;
    2.  
    3. import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
    4. import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
    5. import com.sj.dao.UserMapper;
    6. import com.sj.pojo.User;
    7. import com.sj.service.UserService;
    8. import org.springframework.beans.factory.annotation.Autowired;
    9. import org.springframework.stereotype.Service;
    10.  
    11. import javax.annotation.Resource;
    12. import javax.sql.DataSource;
    13. import java.util.List;
    14.  
    15. @Service
    16. public class UserServiceImpl extends ServiceImpl implements UserService {
    17.  
    18.     @Autowired
    19.     private DataSource dataSource;
    20.  
    21.     @Resource
    22.     private UserMapper userMapper;
    23.  
    24.     /**
    25.      * 新增用户
    26.      * @param user
    27.      * @return
    28.      */
    29.     @Override
    30.     public User saveUser(User user) {
    31.         userMapper.insert(user);
    32.         return user;
    33.     }
    34.  
    35.     /**
    36.      * 删除用户
    37.      * @param id 用户id
    38.      */
    39.     @Override
    40.     public String deleteUser(Long id) {
    41.         int deleteUser = userMapper.deleteById(id);
    42.         return deleteUser > 0 ? "删除用户成功！！！" : "删除用户失败！！！";
    43.     }
    44.  
    45.     /**
    46.      * 修改用户信息
    47.      * @param user
    48.      * @return
    49.      */
    50.     @Override
    51.     public String updateUser(User user) {
    52.         int updateUser = userMapper.updateById(user);
    53.         return updateUser > 0 ? "修改用户成功！！！" : "修改用户失败！！！";
    54.     }
    55.  
    56.     /**
    57.      * 根据id查询用户信息
    58.      * @param id 用户id
    59.      * @return
    60.      */
    61.     @Override
    62.     public User getUserById(Long id) {
    63.         return userMapper.selectById(id);
    64.     }
    65.  
    66.     /**
    67.      * 根据条件查询用户信息
    68.      * @param user
    69.      * @return
    70.      */
    71.     @Override
    72.     public List listUsers(User user) {
    73.         LambdaQueryWrapper queryWrapper = new LambdaQueryWrapper<>();
    74.         queryWrapper.eq(user.getId()!=null,User::getId,user.getId());
    75.         queryWrapper.eq(user.getName()!=null,User::getName,user.getName());
    76.         return userMapper.selectList(queryWrapper);
    77.     }
    78. }

    controller层：

    1. package com.sj.controller;
    2.  
    3. import com.sj.pojo.User;
    4. import com.sj.service.UserService;
    5. import org.springframework.beans.factory.annotation.Autowired;
    6. import org.springframework.web.bind.annotation.*;
    7.  
    8. import java.util.List;
    9.  
    10. @RestController
    11. @RequestMapping("/user")
    12. public class UserController {
    13.  
    14.     @Autowired
    15.     private UserService userService;
    16.  
    17.     @PostMapping
    18.     public User saveUser(User user) {
    19.         return userService.saveUser(user);
    20.     }
    21.  
    22.     @DeleteMapping("/{id}")
    23.     public String deleteUser(@PathVariable Long id) {
    24.         return userService.deleteUser(id);
    25.     }
    26.  
    27.     @PutMapping
    28.     public String updateUser(User user){
    29.         return userService.updateUser(user);
    30.     }
    31.  
    32.     @GetMapping("/{id}")
    33.     public User getUserById(@PathVariable Long id){
    34.         return userService.getUserById(id);
    35.     }
    36.  
    37.     @GetMapping("/list")
    38.     public List listUsers(User user){
    39.         return userService.listUsers(user);
    40.     }
    41. }

    启动类：

    1. package com.sj;
    2.  
    3. import lombok.extern.slf4j.Slf4j;
    4. import org.springframework.boot.SpringApplication;
    5. import org.springframework.boot.autoconfigure.SpringBootApplication;
    6.  
    7. @Slf4j
    8. @SpringBootApplication
    9. public class ShardingJdbcApplication {
    10.     public static void main(String[] args) {
    11.         SpringApplication.run(ShardingJdbcApplication.class,args);
    12.         log.info("项目启动成功......");
    13.     }
    14. }

    查询测试：

    localhost:7777/user/123

    新增测试：

    localhost:7777/user?name=陈东&age=19

    修改测试：

    localhost:7777/user?name=东升&age=19&id=1588946291784720386

    删除测试：

    localhost:7777/user/1588946291784720386

     

  • 相关阅读:
    51.HarmonyOS鸿蒙系统 App(ArkUI)通知
    最快的 TCP 拥塞控制算法
    C# - readonly 和 const 关键字
    async和await用法介绍
    Android GPU版本和占用
    java计算机毕业设计HTML5互动游戏新闻网站设计与实现源码+mysql数据库+系统+lw文档+部署
    CentOS7安装Docker遇到的问题笔记
    [蓝桥杯 2022 省 A] 求和
    重新认识下JVM级别的本地缓存框架Guava Cache(2)——深入解读其容量限制与数据淘汰策略
    Java 日期格式(yyyy-MM-dd 与YYYY-MM-dd 区别
  • 原文地址：https://blog.csdn.net/weixin_55076626/article/details/127711780