【SpringBoot】Spring data JPA整合ShardingSphere-JDBC静态读写分离实现

已于 2023-12-22 12:35:47 修改
阅读量691 收藏 8
点赞数 9
分类专栏： # SpringBoot 文章标签： spring boot java mysql
于 2023-12-22 11:23:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36762765/article/details/135148260
版权

大佬栽树，我乘凉

许大仙老师：【yuque.com/fairy-era/yg511q/ud9uli67b6gxgdh7】

开整

数据库准备

一主两从
在这里插入图片描述

数据库脚本

CREATE DATABASE IF NOT EXISTS dbtest CHARACTER SET 'utf8mb4' COLLATE 'utf8mb4_general_ci';
USE dbtest;
-- 创建表
CREATE TABLE t_user ( 
    id INT PRIMARY KEY AUTO_INCREMENT, 
	uname VARCHAR (30)
);

创建SpringBoot工程

  • SpringBoot 2.7.3
  • ShardingSphere 5.2.1

项目结构

在这里插入图片描述

依赖引入

父工程
<?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">
    <modelVersion>4.0.0</modelVersion>

    <groupId>pers.kw</groupId>
    <artifactId>ShardingSphere</artifactId>
    <version>1.0-SNAPSHOT</version>
    <modules>
        <module>ShardingSphere-hello</module>
        <module>ShardingSphere-mybatis-plus</module>
    </modules>
    <packaging>pom</packaging>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
        <skipTests>true</skipTests>

        <spring-boot.version>2.7.3</spring-boot.version>

        <minio.version>8.2.2</minio.version>
    </properties>

    <!-- 依赖声明 -->
    <dependencyManagement>
        <dependencies>
            <!-- SpringBoot 依赖配置 -->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>${spring-boot.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>

            <!--服务监控-->
            <dependency>
                <groupId>de.codecentric</groupId>
                <artifactId>spring-boot-admin-starter-server</artifactId>
                <version>2.3.0</version>
            </dependency>
            <dependency>
                <groupId>de.codecentric</groupId>
                <artifactId>spring-boot-admin-starter-client</artifactId>
                <version>2.3.0</version>
            </dependency>

            <dependency>
                <groupId>org.springframework.security</groupId>
                <artifactId>spring-security-jwt</artifactId>
                <version>1.0.9.RELEASE</version>
            </dependency>

            <dependency>
                <groupId>cn.hutool</groupId>
                <artifactId>hutool-all</artifactId>
                <version>5.7.20</version>
            </dependency>

            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>fastjson</artifactId>
                <version>1.2.83</version>
            </dependency>

            <!--链路追踪-->
            <dependency>
                <groupId>org.apache.skywalking</groupId>
                <artifactId>apm-toolkit-logback-1.x</artifactId>
                <version>8.8.0</version>
            </dependency>
            <dependency>
                <groupId>org.apache.skywalking</groupId>
                <artifactId>apm-toolkit-trace</artifactId>
                <version>8.8.0</version>
            </dependency>

            <!--数据源依赖-->
<!--            <dependency>-->
<!--                <groupId>com.alibaba</groupId>-->
<!--                <artifactId>druid-spring-boot-starter</artifactId>-->
<!--                <version>1.2.6</version>-->
<!--            </dependency>-->
            <dependency>
                <groupId>org.mybatis.spring.boot</groupId>
                <artifactId>mybatis-spring-boot-starter</artifactId>
                <version>2.1.4</version>
            </dependency>
            <dependency>
                <groupId>com.github.pagehelper</groupId>
                <artifactId>pagehelper-spring-boot-starter</artifactId>
                <version>1.4.7</version>
            </dependency>
            <dependency>
                <groupId>com.github.pagehelper</groupId>
                <artifactId>pagehelper</artifactId>
                <version>5.1.8</version>
                <scope>compile</scope>
            </dependency>

            <!--swagger配置-->
            <dependency>
                <groupId>io.springfox</groupId>
                <artifactId>springfox-swagger2</artifactId>
                <version>2.9.2</version>
            </dependency>
            <dependency>
                <groupId>com.github.xiaoymin</groupId>
                <artifactId>swagger-bootstrap-ui</artifactId>
                <version>1.9.3</version>
            </dependency>
            <dependency>
                <groupId>io.swagger</groupId>
                <artifactId>swagger-annotations</artifactId>
                <version>1.5.20</version>
            </dependency>
            <dependency>
                <groupId>io.swagger</groupId>
                <artifactId>swagger-models</artifactId>
                <version>1.5.20</version>
            </dependency>

            <!--bean转换-->
            <dependency>
                <groupId>net.sf.dozer</groupId>
                <artifactId>dozer-spring</artifactId>
                <version>5.5.1</version>
            </dependency>
            <dependency>
                <groupId>net.sf.dozer</groupId>
                <artifactId>dozer</artifactId>
                <version>5.5.1</version>
            </dependency>

            <dependency>
                <groupId>org.redisson</groupId>
                <artifactId>redisson</artifactId>
                <version>3.11.6</version>
            </dependency>

            <dependency>
                <groupId>javax.servlet</groupId>
                <artifactId>servlet-api</artifactId>
                <version>2.5</version>
            </dependency>

            <dependency>
                <groupId>commons-io</groupId>
                <artifactId>commons-io</artifactId>
                <version>2.11.0</version>
            </dependency>
            <dependency>
                <groupId>org.apache.poi</groupId>
                <artifactId>poi-ooxml</artifactId>
                <version>4.1.2</version>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <dependencies>

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

        <dependency>
            <artifactId>commons-lang3</artifactId>
            <groupId>org.apache.commons</groupId>
            <version>3.12.0</version>
        </dependency>


        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
        </dependency>

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

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.6.0</version>
                <configuration>
                    <source>${java.version}</source>
                    <target>${java.version}</target>
                    <encoding>${project.build.sourceEncoding}</encoding>
                </configuration>
            </plugin>
        </plugins>
        <pluginManagement>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                    <version>2.7.7</version>
                    <executions>
                        <execution>
                            <goals>
                                <goal>repackage</goal>
                            </goals>
                        </execution>
                    </executions>
                </plugin>
            </plugins>
        </pluginManagement>
    </build>

</project>
子工程
<?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>ShardingSphere</artifactId>
        <groupId>pers.kw</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>
    <packaging>jar</packaging>

    <artifactId>ShardingSphere-hello</artifactId>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

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

        <dependency>
            <groupId>org.apache.skywalking</groupId>
            <artifactId>apm-toolkit-logback-1.x</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.skywalking</groupId>
            <artifactId>apm-toolkit-trace</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper-spring-boot-starter</artifactId>
        </dependency>

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

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

        <dependency>
            <groupId>org.yaml</groupId>
            <artifactId>snakeyaml</artifactId>
            <version>1.33</version>
        </dependency>

        <dependency>
            <groupId>org.apache.shardingsphere</groupId>
            <artifactId>shardingsphere-jdbc-core-spring-boot-starter</artifactId>
            <version>5.2.1</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.26</version>
        </dependency>
    </dependencies>

</project>

yaml配置

server:
  port: 8080
spring:
  application:
    name: ShardingSphere-hello
  jpa:
    database-platform: org.hibernate.dialect.MySQL8Dialect
    show-sql: true
    hibernate:
      ddl-auto: none
  shardingsphere:
    mode:
      type: Standalone # 单机模式
      repository:
        type: JDBC # JDBC
    datasource:
      names: m1,s1,s2
      m1: # 配置第一个主机
        type: com.zaxxer.hikari.HikariDataSource
        driverClassName: com.mysql.cj.jdbc.Driver
        jdbcUrl: jdbc:mysql://10.211.55.88:3306/dbtest?serverTimezone=UTC&useSSL=false&useUnicode=true&characterEncoding=UTF-8
        username: root
        password: 123456
      s1: # 配置第一个从机
        type: com.zaxxer.hikari.HikariDataSource
        driverClassName: com.mysql.cj.jdbc.Driver
        jdbcUrl: jdbc:mysql://10.211.55.88:3307/dbtest?serverTimezone=UTC&useSSL=false&useUnicode=true&characterEncoding=UTF-8
        username: root
        password: 123456
      s2: # 配置第二个从机
        type: com.zaxxer.hikari.HikariDataSource
        driverClassName: com.mysql.cj.jdbc.Driver
        jdbcUrl: jdbc:mysql://10.211.55.88:3309/dbtest?serverTimezone=UTC&useSSL=false&useUnicode=true&characterEncoding=UTF-8
        username: root
        password: 123456
    rules:
      readwrite-splitting:
        data-sources:
          readwrite_ds: # 读写分离逻辑数据源名称
            staticStrategy: # 读写分离类型为静态读写分离
              writeDataSourceName: m1
              readDataSourceNames:
                - s1
                - s2
            loadBalancerName: alg_round # 负责均衡算法的名称
        load-balancers:
          alg_round: # 负载均衡算法的名称
            type: ROUND_ROBIN # 轮询负载均衡算法
    props:
      sql-show: true # 打印 SQL

#分页插件
#pagehelper:
#  helper-dialect: mysql
#  reasonable: true
#  support-methods-arguments: true
#  params: count=countSql
#mybatis:
#  type-aliases-package: pers.kw.**.dto
#  mapper-locations: classpath*:mapper/**/*.xml
#  configuration:
#    map-underscore-to-camel-case: true
#    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

实体类

package pers.kw.persist.entity;

import lombok.Data;

import javax.persistence.*;

@Data
@Entity
@Table(name = "t_user")
public class User {

    @Basic
    @Column(name = "id")
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(name = "uname")
    private String uname;
}

dao

package pers.kw.persist.dao;

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import pers.kw.persist.entity.User;

import java.util.List;

public interface UserDao extends JpaRepository<User, Long> {

    @Query("from User")
    List<User> listUser();
}

service

package pers.kw.service;

import com.alibaba.fastjson.JSON;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import pers.kw.persist.dao.UserDao;
import pers.kw.persist.entity.User;

import javax.annotation.Resource;
import java.util.List;

@Slf4j
@Service
public class UserService {

    @Resource
    private UserDao userDao;

    @Transactional(rollbackFor = Exception.class)
    public void addUser() {
        User user = new User();
        user.setUname("kw");
        userDao.save(user);
    }

    public void readWrite1() {
        User user = new User();
        user.setUname("杜甫");
        userDao.save(user);
        List<User> all = userDao.listUser();
        log.info("list:{}", JSON.toJSONString(all));
    }

    @Transactional(rollbackFor = Exception.class)
    public void readWrite2() {
        User user = new User();
        user.setUname("李白");
        userDao.save(user);
        List<User> all = userDao.listUser();
        log.info("list:{}", JSON.toJSONString(all));
    }

    public void readLb() {
        List<User> all = userDao.listUser();
        log.info("list1 listUser:{}", JSON.toJSONString(all));

        List<User> l2 = userDao.listUser();
        log.info("list2 listUser:{}", JSON.toJSONString(l2));

        List<User> l3 = userDao.listUser();
        log.info("list3 listUser:{}", JSON.toJSONString(l3));
    }

    public void readLb2() {
        //查询的还是主库 SimpleJpaRepository
        List<User> all = userDao.findAll();
        log.info("list1 listUser:{}", JSON.toJSONString(all));

        List<User> l2 = userDao.findAll();
        log.info("list2 listUser:{}", JSON.toJSONString(l2));

        List<User> l3 = userDao.findAll();
        log.info("list3 listUser:{}", JSON.toJSONString(l3));
    }

}

controller

package pers.kw.controller;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import pers.kw.service.UserService;

import javax.annotation.Resource;

@RestController
public class UserController {

    @Resource
    private UserService userService;

    @RequestMapping("/addUser")
    public String addUser() {
        userService.addUser();
        return "ok";
    }

    @RequestMapping("/readWrite1")
    public String readWrite1() {
        userService.readWrite1();
        return "ok";
    }

    @RequestMapping("/readWrite2")
    public String readWrite2() {
        userService.readWrite2();
        return "ok";
    }

    @RequestMapping("/readLb")
    public String readLb() {
        userService.readLb();
        return "ok";
    }

    @RequestMapping("/readLb2")
    public String readLb2() {
        userService.readLb2();
        return "ok";
    }
}

http脚本

### 读写分离
POST http://localhost:8080/addUser
Content-Type: application/x-www-form-urlencoded


### 无事务，读写
POST http://localhost:8080/readWrite1
Content-Type: application/x-www-form-urlencoded


### 有事务读写
POST http://localhost:8080/readWrite2
Content-Type: application/x-www-form-urlencoded


### 自写查询方法，负载均衡
POST http://localhost:8080/readLb
Content-Type: application/x-www-form-urlencoded


### jpa自带查询方法，负载均衡
POST http://localhost:8080/readLb2
Content-Type: application/x-www-form-urlencoded


###

测试

读写分离

在这里插入图片描述

事务

无事务注解

没加事务注解的情况，save方法是主库，查询方法是从库
在这里插入图片描述

有事务注解

加事务注解的情况，save方法是主库，查询方法也是主库
在这里插入图片描述

负载均衡

自写查询方法

可以看到，分别查询了s1,s2,s1
在这里插入图片描述

Jpa自带的查询方法

查询的均是主库
在这里插入图片描述
原因是自带的查询方法是SimpleJpaRepository实现的，此类默认开启只读事务。
在这里插入图片描述

自写查询方法，增加事务注解

@Transactional(readOnly = true)
    public void readLb() {
        List<User> all = userDao.listUser();
        log.info("list1 listUser:{}", JSON.toJSONString(all));

        List<User> l2 = userDao.listUser();
        log.info("list2 listUser:{}", JSON.toJSONString(l2));

        List<User> l3 = userDao.listUser();
        log.info("list3 listUser:{}", JSON.toJSONString(l3));
    }

测试查下看是否还是从库?
查询的均为主库
在这里插入图片描述

KAI丶
关注
  • 9
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
shardingsphere-jdbc之JPA boundary range分片算法
Lance
02-28 981
介绍 基于shardingsphere-jdbc 5.1.0 进行单库分表. 基于分片边界的范围分片算法 类型：BOUNDARY_RANGE 属性名称 数据类型 说明 默认值 sharding-ranges String 分片的范围边界，多个范围边界以逗号分隔 - 1. maven项目依赖 <dependencies> <dependency> <groupId>org.apache.sha
ShardingSphere-JDBC整合SpringBoot JPA读写分离失败
椰汁菠萝
05-16 696
ShardingSphere JDBC 整合Spring Boot JPA读写分离失败
SpringBoot+JPA整合ShardingShpere实现分表
quest101的博客
05-23 2381
ShardingShpere 分表 ​ ShardingShpere 提供来了根据某个字段分表的功能。 ShardingShpere 源码 版本依赖 JDK 8 SpringBoot 2.4.3 ShardingShpere 5.0 创建一个数据库和两张表， CREATE DATABASE `shop` CHARACTER SET utf8 COLLATE utf8_general_ci; CREATE TABLE `user_0` ( `id` int(11) NOT NULL, `ema
springboot、JPA整合shardingsphere实现读写分离和分表
not_say的博客
06-30 722
springboot、JPA整合shardingsphere实现读写分离和分表
个人学习系列 - Spring Boot + ShardingSphere + JPA 实现读写分离
xiuaiba的博客
08-03 1021
最近想要学习一下分库分表，可是分库分表之前可以先用数据库的读写分离来过渡一下，当然这还需要主从服务器来配合。今天就先写数据库的读写分离，以后再介绍主从服务器。。。 Mysql 1. 新建三个数据库 CREATE DATABASE database0; USE database0; DROP TABLE IF EXISTS `user`; CREATE TABLE `user`( id bigint(64) not null auto_increment, city varchar(20) not n.
SpringBoot集成Spring Data JPA及读写分离
08-30
SpringBoot集成Spring Data JPA及读写分离是现代Java Web应用程序中常见的技术组合，用于高效地管理和处理数据库操作。Spring Boot简化了应用的初始化和配置，而Spring Data JPA则进一步降低了使用Java Persistence ...
SpringBoot整合spring-data-jpa的方法
08-19
SpringBoot是一个基于Java的微服务框架，而spring-data-jpa是Spring基于Java持久层（Java Persistence API，简称JPA）的一种实现。spring-data-jpa提供了一个简洁的方式来访问数据库，使得开发者可以更方便地与...
SpringBoot使用Spring-Data-Jpa实现CRUD操作
08-27
主要为大家详细介绍了SpringBoot使用Spring-Data-Jpa实现CRUD操作，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
SpringBoot中使用Spring-data-jpa分页查询
04-27
SpringBoot是一款基于Spring框架的开发框架，而Spring-data-JPA是在Hibernate的基础上实现JPA规范的ORM框架。使用SpringBoot和Spring-data-jpa进行分页查询可以大大简化编码流程并提高开发效率。 在使用Spring-data...
idea下整合springboot+spring data jpa
02-02
Spring Boot提供了快速启动和配置的机制，而Spring Data JPA则是Spring框架的一部分，专注于数据库交互，使得开发者可以使用更加高级、抽象的方式来操作数据库，无需编写大量的JDBC代码。本文将详细介绍如何在...
Springboot2+JPA|MyBatis+Sharding-JDBC示例
07-24
Springboot2+JPA|MyBatis+Sharding-JDBC示例源码，可直接运行。
shardingsphere-jdbc之Mybatis分库
Lance
02-20 1058
介绍 基于shardingsphere-jdbc进行数据库分库。水平分片又称为横向拆分。 相对于垂直分片，它不再将数据根据业务逻辑分类，而是通过某个字段（或某几个字段），根据某种规则将数据分散至多个库或表中，每个分片仅包含数据的一部分。 例如：根据主键分片，偶数主键的记录放入 0 库（或表），奇数主键的记录放入 1 库（或表） 1. maven项目依赖 <dependencies> <dependency> <groupId>org.ap
shardingsphere-jdbc之Mybatis class_based自定义分片算法
Lance
03-05 1356
介绍 基于shardingsphere-jdbc 5.1.0 进行单库分表.自定义分表规则 自定义类分片算法 通过配置分片策略类型和算法类名，实现自定义扩展。 类型：CLASS_BASED 属性名称 数据类型 说明 默认值 strategy String 分片策略类型，支持 STANDARD、COMPLEX 或 HINT（不区分大小写） - algorithmClassName String 分片算法全限定名 - 1. maven项
shardingsphere-jdbc之Mybatis复合分片算法
Lance
02-23 997
介绍 基于shardingsphere-jdbc 5.1.0 进行单库分表. 复合行表达式分片算法 类型：COMPLEX_INLINE 属性名称 数据类型 说明 默认值 sharding-columns (?) String 分片列名称，多个列用逗号分隔。如不配置无法则不能校验 - algorithm-expression String 分片算法的行表达式 - allow-range-query-with-inline-shardin
ShardingSphere+JPA+Druid实现分表操作
dames的博客
03-21 794
在配置文件中配置了主键生成策略和分片算法，此处@GeneratedValue不能选IDENTITY，要选AUTO，由jpa自动选择。@Table的值为主表的表名。要在SpringBoot项目中实现分表操作，本文使用的是ShardingSphere+JPA+Druid实现。过程中出现问题记录一下。原因是配置文件的数据源处的数据库URL的键应为“url”而不是“jdbc-url”！（3中提供的是正确的配置）这里的分片算法是根据id字段能否被2整除来分，分到两张从表中。改成url后，重新启动，运行正常。
springboot+jpa+sharding-jdbc分表
jared_he2017的博客
09-21 3694
1. 引入依赖： &lt;dependency&gt;             &lt;groupId&gt;com.dangdang&lt;/groupId&gt;             &lt;artifactId&gt;sharding-jdbc-core&lt;/artifactId&gt;             &lt;version&gt;1.5.4&lt;/version&gt
ShardingSphere5.1.0 +JPA的分表配置
04-12 1580
模拟场景，公司表（不分表）， 员工表与人员表根据租户标志分为多个表 项目主要根据官方文档编写 官方文档 建议大家根据官方文档配置其他的分库，读写分离等 项目pom信息 <?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:sche
Springboot2.x +JPA 集成 Apache ShardingSphere 分库分表
Gblfy_Blog
02-25 559
文章目录一、配置容器环境1. 创建并启动主库 容器2. 创建并启动从库 容器3. 查看启动的容器二、主服务器 数据库配置2.1. 首先进入主库容器内部2.2. 修改 my.cnf2.3. 登录主库mysql数据库2.4. 在主库上创建同步用户并授权2.4. 创建用户并赋予权限2.4. 修复远程登录异常2.5. 查询master的状态三、配置从数据库3.1. 首先进入从库容器内部3.2. 修改 my.cnf3.3. 登录从库mysql数据库3.4. 配置从服务器Slave3.5. 查询slave的状态3.6
shardingsphere-jdbc之Mybatis读写分离
Lance
02-19 1114
介绍 支持项 提供一主多从的读写分离配置，可独立使用，也可配合数据分片使用 事务中的数据读写均用主库 基于 Hint 的强制主库路由 不支持项 主库和从库的数据同步 主库和从库的数据同步延迟导致的数据不一致 主库多写 主从库间的事务一致性。主从模型中，事务中的数据读写均用主库 1. maven项目依赖 <dependencies> <dependency> <groupId>org.apache.shardingsphere&
spring-boot-starter-jpa 与spring-boot-starter-jdbc 区别
最新发布
04-17
spring-boot-starter-jpa和spring-boot-starter-jdbc是Spring Boot框架中用于数据库访问的两个常用依赖库，它们在数据库访问方式和功能上有一些区别。 spring-boot-starter-jpa是基于Java Persistence API（JPA）的依赖库，它提供了一种面向对象的方式来进行数据库访问。JPA是Java EE的一部分，它定义了一套标准的API和规范，用于实现对象关系映射（ORM）。使用spring-boot-starter-jpa可以方便地进行实体类与数据库表之间的映射，通过简单的注解和配置，可以实现数据库的增删改查操作。同时，spring-boot-starter-jpa还提供了一些高级特性，如事务管理、缓存等。 相比之下，spring-boot-starter-jdbc是基于Java Database Connectivity（JDBC）的依赖库。JDBC是Java语言访问关系型数据库的标准API，它提供了一套用于执行SQL语句和处理结果集的方法。使用spring-boot-starter-jdbc可以直接使用JDBC API进行数据库操作，需要手动编写SQL语句和处理结果集。相对于JPA，JDBC更加底层，更加灵活，可以直接操作数据库的细节。 总结一下区别： 1. 数据库访问方式：spring-boot-starter-jpa使用面向对象的方式进行数据库访问，而spring-boot-starter-jdbc使用基于SQL的方式进行数据库访问。 2. 抽象程度：spring-boot-starter-jpa提供了更高级的抽象，通过注解和配置可以实现对象关系映射，而spring-boot-starter-jdbc需要手动编写SQL语句和处理结果集。 3. 功能特性：spring-boot-starter-jpa提供了一些高级特性，如事务管理、缓存等，而spring-boot-starter-jdbc相对较为简单，功能相对较少。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值