0
0

深入理解Spring Boot结合MyBatis调用MySQL，并实现主从复制读写分离

深入理解Spring Boot结合MyBatis调用MySQL，并实现主从复制读写分离

MyBatis作为一款灵活的持久层框架，与Spring Boot结合使用，可以为开发者提供高效、简洁的数据库访问层。本文将详细讲解如何在Spring Boot项目中结合MyBatis调用MySQL，并实现主从复制的读写分离。我们将以电商交易系统为案例，通过实际代码示例展示如何进行配置和实现。

第1章 Spring Boot项目中集成MyBatis
1.1 Maven依赖配置

在Spring Boot项目中集成MyBatis，首先需要在

  1. pom.xml

文件中引入相关的Maven依赖。以下是最基本的依赖配置：

  1. xml复制代码<dependencies>
  2.     <!-- Spring Boot Starter MyBatis -->
  3.     <dependency>
  4.         <groupId>org.mybatis.spring.boot</groupId>
  5.         <artifactId>mybatis-spring-boot-starter</artifactId>
  6.         <version>2.1.4</version>
  7.     </dependency>
  9.     <!-- MySQL Driver -->
  10.     <dependency>
  11.         <groupId>mysql</groupId>
  12.         <artifactId>mysql-connector-java</artifactId>
  13.         <scope>runtime</scope>
  14.     </dependency>
  16.     <!-- Spring Boot Starter Web -->
  17.     <dependency>
  18.         <groupId>org.springframework.boot</groupId>
  19.         <artifactId>spring-boot-starter-web</artifactId>
  20.     </dependency>
  21. </dependencies>

上述依赖确保了Spring Boot能够自动配置MyBatis和MySQL驱动，从而简化了数据库访问的配置工作。

1.2 MyBatis配置

在Spring Boot中，MyBatis的配置通常通过

  1. application.properties

或

  1. application.yml

文件进行。以下是

  1. application.properties

文件中的基本配置示例：

  1. # 数据源配置
  2. spring.datasource.url=jdbc:mysql://localhost:3306/ecommerce?useSSL=false&serverTimezone=UTC
  3. spring.datasource.username=root
  4. spring.datasource.password=yourpassword
  5. spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
  7. # MyBatis配置
  8. mybatis.mapper-locations=classpath:mapper/*.xml
  9. mybatis.type-aliases-package=com.example.ecommerce.model
  • spring.datasource.url：指定数据库连接URL。
  • spring.datasource.username：数据库用户名。
  • spring.datasource.password：数据库密码。
  • spring.datasource.driver-class-name：JDBC驱动类名。
  • mybatis.mapper-locations：指定MyBatis的XML映射文件路径。
  • mybatis.type-aliases-package：指定MyBatis的别名包路径，用于简化实体类的配置。
1.3 创建实体类与Mapper接口

首先，我们需要定义实体类来映射数据库表，例如定义一个

  1. Order

类来映射订单表：

  1. package com.example.ecommerce.model;
  3. import java.io.Serializable;
  5. public class Order implements Serializable {
  6.     private Long id;
  7.     private String orderNumber;
  8.     private Double totalAmount;
  10.     // getters and setters
  11. }

接下来，定义一个Mapper接口，该接口用于声明数据库操作方法：

  1. package com.example.ecommerce.mapper;
  3. import com.example.ecommerce.model.Order;
  4. import org.apache.ibatis.annotations.Mapper;
  5. import org.apache.ibatis.annotations.Select;
  7. import java.util.List;
  9. @Mapper
  10. public interface OrderMapper {
  11.     
  12.     @Select("SELECT * FROM orders")
  13.     List<Order> findAllOrders();
  15.     void insertOrder(Order order);
  16. }

在MyBatis中，可以使用注解或XML文件定义SQL语句。上述示例中，

  1. findAllOrders

方法使用注解定义了一个简单的查询语句。

1.4 配置XML映射文件

如果希望使用XML文件来管理SQL语句，可以在

  1. resources/mapper

目录下创建一个

  1. OrderMapper.xml

文件：

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" 
  3.   "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  4. <mapper namespace="com.example.ecommerce.mapper.OrderMapper">
  6.     <resultMap id="OrderResultMap" type="com.example.ecommerce.model.Order">
  7.         <id column="id" property="id"/>
  8.         <result column="order_number" property="orderNumber"/>
  9.         <result column="total_amount" property="totalAmount"/>
  10.     </resultMap>
  12.     <select id="findAllOrders" resultMap="OrderResultMap">
  13.         SELECT * FROM orders
  14.     </select>
  16.     <insert id="insertOrder">
  17.         INSERT INTO orders (order_number, total_amount) 
  18.         VALUES (#{orderNumber}, #{totalAmount})
  19.     </insert>
  21. </mapper>
1.5 Service层与Controller层

在Service层，我们可以通过依赖注入的方式调用

  1. OrderMapper

进行业务逻辑处理：

  1. package com.example.ecommerce.service;
  3. import com.example.ecommerce.mapper.OrderMapper;
  4. import com.example.ecommerce.model.Order;
  5. import org.springframework.beans.factory.annotation.Autowired;
  6. import org.springframework.stereotype.Service;
  8. import java.util.List;
  10. @Service
  11. public class OrderService {
  13.     @Autowired
  14.     private OrderMapper orderMapper;
  16.     public List<Order> getAllOrders() {
  17.         return orderMapper.findAllOrders();
  18.     }
  20.     public void createOrder(Order order) {
  21.         orderMapper.insertOrder(order);
  22.     }
  23. }

在控制层，我们定义一个

  1. OrderController

来处理HTTP请求：

  1. package com.example.ecommerce.controller;
  3. import com.example.ecommerce.model.Order;
  4. import com.example.ecommerce.service.OrderService;
  5. import org.springframework.beans.factory.annotation.Autowired;
  6. import org.springframework.web.bind.annotation.*;
  8. import java.util.List;
  10. @RestController
  11. @RequestMapping("/orders")
  12. public class OrderController {
  14.     @Autowired
  15.     private OrderService orderService;
  17.     @GetMapping
  18.     public List<Order> getAllOrders() {
  19.         return orderService.getAllOrders();
  20.     }
  22.     @PostMapping
  23.     public void createOrder(@RequestBody Order order) {
  24.         orderService.createOrder(order);
  25.     }
  26. }
第2章 实现主从复制和读写分离
2.1 主从复制概述

主从复制是一种常见的数据库架构，其中一个数据库实例作为主库，负责处理所有的写操作；而一个或多个从库负责复制主库的数据，并处理读操作。这种架构的主要优点在于可以分担数据库的读写压力，提升系统的性能和可靠性。

2.2 主从复制的配置

首先，我们需要在MySQL中配置主从复制。假设我们有两台MySQL服务器，分别作为主库和从库：

  • 主库（Master）：IP地址为192.168.0.1
  • 从库（Slave）：IP地址为192.168.0.2

在主库上执行以下步骤：

  1. 修改my.cnf配置文件：
  1. [mysqld]
  2. log-bin=mysql-bin
  3. server-id=1
  1. 重启MySQL服务，并创建一个用于复制的用户：
  1. CREATE USER 'replication'@'%' IDENTIFIED BY 'password';
  2. GRANT REPLICATION SLAVE ON *.* TO 'replication'@'%';
  3. FLUSH PRIVILEGES;
  1. 查看主库状态，获取二进制日志文件名和位置：
  1. SHOW MASTER STATUS;

在从库上执行以下步骤：

  1. 修改my.cnf配置文件：
  1. [mysqld]
  2. server-id=2
  1. 重启MySQL服务，并配置复制：
  1. CHANGE MASTER TO 
  2. MASTER_HOST='192.168.0.1', 
  3. MASTER_USER='replication', 
  4. MASTER_PASSWORD='password', 
  5. MASTER_LOG_FILE='mysql-bin.000001', 
  6. MASTER_LOG_POS=120;
  7. START SLAVE;
  1. 查看从库状态，确保复制正常进行：
  1. SHOW SLAVE STATUS\G;
2.3 在Spring Boot中实现读写分离

在Spring Boot中实现读写分离，可以通过自定义

  1. DataSource

并基于

  1. AbstractRoutingDataSource

类进行动态数据源路由。以下是一个示例配置：

  1. package com.example.ecommerce.config;
  3. import org.springframework.beans.factory.annotation.Qualifier;
  4. import org.springframework.boot.autoconfigure.jdbc.DataSourceBuilder;
  5. import org.springframework.context.annotation.Bean;
  6. import org.springframework.context.annotation.Configuration;
  7. import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;
  9. import javax.sql.DataSource;
  10. import java.util.HashMap;
  11. import java.util.Map;
  13. @Configuration
  14. public class DataSourceConfig {
  16.     @Bean(name = "masterDataSource")
  17.     public DataSource masterDataSource() {
  18.         return DataSourceBuilder.create()
  19.             .url("jdbc:mysql://192.168.0.1:3306/ecommerce?useSSL=false&serverTimezone=UTC")
  20.             .username("root")
  21.             .password("yourpassword")
  22.             .build();
  23.     }
  25.     @Bean(name = "slaveDataSource")
  26.     public DataSource slaveDataSource() {
  27.         return DataSourceBuilder.create()
  28.             .url("jdbc:mysql://192.168.0.2:3306/ecommerce?useSSL=false&serverTimezone=UTC")
  29.             .username("root")
  30.             .password("yourpassword")
  31.             .build();
  32.     }
  34.         @Bean
  35.     public DataSource routingDataSource(
  36.             @Qualifier("masterDataSource") DataSource masterDataSource,
  37.             @Qualifier("slaveDataSource") DataSource slaveDataSource) {
  39.         AbstractRoutingDataSource routingDataSource = new AbstractRoutingDataSource() {
  40.             @Override
  41.             protected Object determineCurrentLookupKey() {
  42.                 // 这里可以根据实际情况选择数据源
  43.                 return DataSourceContextHolder.getDataSourceType();
  44.             }
  45.         };
  47.         Map<Object, Object> dataSourceMap = new HashMap<>();
  48.         dataSourceMap.put(DataSourceType.MASTER, masterDataSource);
  49.         dataSourceMap.put(DataSourceType.SLAVE, slaveDataSource);
  51.         routingDataSource.setTargetDataSources(dataSourceMap);
  52.         routingDataSource.setDefaultTargetDataSource(masterDataSource);
  54.         return routingDataSource;
  55.     }
  56. }

在上述配置中，

  1. routingDataSource

是一个路由数据源，能够根据当前的上下文选择使用主库或从库。

  1. DataSourceContextHolder

用于存储和切换当前线程使用的数据源类型。

2.4 创建数据源上下文管理类

为了实现读写分离，我们需要创建一个管理类

  1. DataSourceContextHolder

，用于动态切换数据源：

  1. package com.example.ecommerce.config;
  3. public class DataSourceContextHolder {
  5.     private static final ThreadLocal<DataSourceType> contextHolder = new ThreadLocal<>();
  7.     public static void setDataSourceType(DataSourceType dataSourceType) {
  8.         contextHolder.set(dataSourceType);
  9.     }
  11.     public static DataSourceType getDataSourceType() {
  12.         return contextHolder.get();
  13.     }
  15.     public static void clearDataSourceType() {
  16.         contextHolder.remove();
  17.     }
  18. }

这里的

  1. DataSourceType

是一个枚举类，用于区分主库和从库：

  1. package com.example.ecommerce.config;
  3. public enum DataSourceType {
  4.     MASTER, SLAVE;
  5. }
2.5 创建数据源切换的AOP切面

为了自动切换数据源，可以创建一个AOP切面，通过注解来控制具体的读写操作应该使用的数据库：

  1. package com.example.ecommerce.aspect;
  3. import com.example.ecommerce.config.DataSourceContextHolder;
  4. import com.example.ecommerce.config.DataSourceType;
  5. import org.aspectj.lang.annotation.Aspect;
  6. import org.aspectj.lang.annotation.Before;
  7. import org.springframework.stereotype.Component;
  9. @Aspect
  10. @Component
  11. public class DataSourceAspect {
  13.     @Before("@annotation(com.example.ecommerce.annotation.Master)")
  14.     public void setMasterDataSource() {
  15.         DataSourceContextHolder.setDataSourceType(DataSourceType.MASTER);
  16.     }
  18.     @Before("@annotation(com.example.ecommerce.annotation.Slave)")
  19.     public void setSlaveDataSource() {
  20.         DataSourceContextHolder.setDataSourceType(DataSourceType.SLAVE);
  21.     }
  22. }

在这个切面类中，我们通过

  1. @Before

注解拦截带有

  1. @Master

和

  1. @Slave

注解的方法，分别将数据源设置为主库或从库。

2.6 定义自定义注解

接下来，我们需要定义用于标记读写操作的方法的自定义注解

  1. @Master

和

  1. @Slave

：

  1. package com.example.ecommerce.annotation;
  3. import java.lang.annotation.ElementType;
  4. import java.lang.annotation.Retention;
  5. import java.lang.annotation.RetentionPolicy;
  6. import java.lang.annotation.Target;
  8. @Target(ElementType.METHOD)
  9. @Retention(RetentionPolicy.RUNTIME)
  10. public @interface Master {
  11. }
  13. @Target(ElementType.METHOD)
  14. @Retention(RetentionPolicy.RUNTIME)
  15. public @interface Slave {
  16. }

通过以上配置，我们已经完成了基于MyBatis和Spring Boot的主从复制读写分离的实现。

第3章 主从复制与读写分离的优势与劣势
3.1 优势
  1. 性能提升：通过将读写操作分离到不同的数据库实例中，可以显著提高数据库的并发处理能力和响应速度，特别是在读操作占多数的场景下，从库可以分担大量的读取请求，从而减轻主库的压力。
  2. 数据冗余：主从复制的从库不仅可以用于读操作，还可以作为主库的备份，一旦主库发生故障，从库可以迅速提升为主库，从而提高系统的可用性。
  3. 扩展性强：通过增加从库的数量，可以轻松地扩展系统的读取能力，而不需要对应用程序进行大的调整，具有很好的水平扩展性。
3.2 劣势
  1. 数据一致性：由于主从复制过程中存在延迟，从库中的数据并不是实时更新的，这可能导致读取到的不是最新的数据。因此，系统设计时需要考虑数据一致性的问题。
  2. 系统复杂度增加：实现主从复制和读写分离需要配置多个数据源和路由逻辑，增加了系统的复杂性，维护和监控工作也相对较为繁琐。
  3. 开发复杂度增加：在开发过程中，开发者需要明确哪些操作是读操作，哪些是写操作，并且要使用相应的注解或逻辑来保证操作的正确性，增加了开发的复杂度。
第4章 代码示例与完整案例

在本章中，我们将结合前面的配置和代码示例，展示一个完整的电商交易系统中如何使用Spring Boot和MyBatis实现主从复制和读写分离。

4.1 配置文件

首先，回顾一下

  1. application.properties

中的配置：

  1. # 主库数据源配置
  2. spring.datasource.master.url=jdbc:mysql://192.168.0.1:3306/ecommerce?useSSL=false&serverTimezone=UTC
  3. spring.datasource.master.username=root
  4. spring.datasource.master.password=yourpassword
  5. spring.datasource.master.driver-class-name=com.mysql.cj.jdbc.Driver
  7. # 从库数据源配置
  8. spring.datasource.slave.url=jdbc:mysql://192.168.0.2:3306/ecommerce?useSSL=false&serverTimezone=UTC
  9. spring.datasource.slave.username=root
  10. spring.datasource.slave.password=yourpassword
  11. spring.datasource.slave.driver-class-name=com.mysql.cj.jdbc.Driver
  13. # MyBatis配置
  14. mybatis.mapper-locations=classpath:mapper/*.xml
  15. mybatis.type-aliases-package=com.example.ecommerce.model
4.2 服务层代码

在服务层，我们使用自定义注解

  1. @Master

和

  1. @Slave

来标识数据库操作的类型：

  1. package com.example.ecommerce.service;
  3. import com.example.ecommerce.annotation.Master;
  4. import com.example.ecommerce.annotation.Slave;
  5. import com.example.ecommerce.mapper.OrderMapper;
  6. import com.example.ecommerce.model.Order;
  7. import org.springframework.beans.factory.annotation.Autowired;
  8. import org.springframework.stereotype.Service;
  10. import java.util.List;
  12. @Service
  13. public class OrderService {
  15.     @Autowired
  16.     private OrderMapper orderMapper;
  18.     @Slave
  19.     public List<Order> getAllOrders() {
  20.         return orderMapper.findAllOrders();
  21.     }
  23.     @Master
  24.     public void createOrder(Order order) {
  25.         orderMapper.insertOrder(order);
  26.     }
  27. }

在这个示例中，

  1. getAllOrders

方法使用了从库进行读取操作，而

  1. createOrder

方法则使用主库进行写入操作。

4.3 测试与验证

为了验证读写分离的效果，可以在主库和从库上分别观察数据的变化情况。通常，我们可以使用以下步骤进行验证：

  1. 在系统中创建一个新的订单，通过调用createOrder方法。
  2. 观察主库，确保数据已经成功写入。
  3. 调用getAllOrders方法，通过从库读取数据，并确认从库中的数据与主库一致。
第5章 结论

通过本文的详细介绍，我们已经学会了如何在Spring Boot项目中结合MyBatis来调用MySQL，并实现主从复制和读写分离。虽然实现读写分离的过程增加了系统的复杂性，但对于提高系统性能和可扩展性有着显著的优势。在实际应用中，开发者需要根据具体的业务场景来权衡数据一致性和系统性能之间的关系，选择合适的架构方案。

标签： spring boot mybatis mysql
本文转载自: https://blog.csdn.net/weixin_39996520/article/details/141906769
版权归原作者 J老熊 所有， 如有侵权，请联系我们删除。
登录后发布评论

“深入理解Spring Boot结合MyBatis调用MySQL，并实现主从复制读写分离”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

网络安全法-网络运行安全

使用selenium/drissionpage时如何阻止chrome自动跳转http到https

docker desktop 里部署的Open WebUI 管理员密码忘记了的处理方法

在ubuntu20.04中搭建onsite比赛运行环境

利用开源的低代码表单设计器FcDesigner高效管理和渲染复杂表单结构

Kafka学习笔记

【前端】浏览器输入url到页面呈现发生了什么？

文章导航
没有找到文章内容分段。。。