读写分离实现 | 第二节 springboot2+mybatis+mysql配置

最新推荐文章于 2021-11-04 12:22:08 发布
最新推荐文章于 2021-11-04 12:22:08 发布
阅读量281 收藏 1
点赞数
文章标签： mysql spring boot mybatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45849208/article/details/103565198
版权

注意：该项目基于上一节mysql主从配置

一. 主要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:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.3.RELEASE</version>
    </parent>

    <groupId>com.lzr</groupId>
    <artifactId>study-readwrite-separation</artifactId>
    <version>1.0-SNAPSHOT</version>

    <name>读写分离项目</name>
    <description>mysql 读写分离项目 测试</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>
        <!-- https://mvnrepository.com/artifact/commons-beanutils/commons-beanutils -->
        <dependency>
            <groupId>commons-beanutils</groupId>
            <artifactId>commons-beanutils</artifactId>
            <version>1.7.0</version>
        </dependency>
        <!--分页工具类-->
        <dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper-spring-boot-starter</artifactId>
            <version>1.2.5</version>
        </dependency>
        <!--mysql驱动包-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.35</version>
        </dependency>
        <!-- Hikaricp数据库连接池 -->
        <dependency>
            <groupId>com.zaxxer</groupId>
            <artifactId>HikariCP</artifactId>
        </dependency>
        <!-- 使用Hikaricp数据库连接池所需的jdbc包 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <!-- 提供了大量mybatis操作的方法 -->
        <dependency>
            <groupId>tk.mybatis</groupId>
            <artifactId>mapper-spring-boot-starter</artifactId>
            <version>2.1.0</version>
        </dependency>
        <!-- redis -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <!--用于编译jsp-->
        <dependency>
            <groupId>org.apache.tomcat.embed</groupId>
            <artifactId>tomcat-embed-jasper</artifactId>
            <!--<scope>provided</scope>-->
        </dependency>
        <!-- 二维码工具包 -->
        <dependency>
            <groupId>com.google.zxing</groupId>
            <artifactId>core</artifactId>
            <version>3.2.0</version>
        </dependency>

        <dependency>
            <groupId>com.google.zxing</groupId>
            <artifactId>javase</artifactId>
            <version>3.2.0</version>
        </dependency>

        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jstl</artifactId>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.0</version>
            <scope>provided</scope>
        </dependency>

        <dependency>
            <groupId>cn.afterturn</groupId>
            <artifactId>easypoi-base</artifactId>
            <version>4.0.0</version>
        </dependency>
        <dependency>
            <groupId>cn.afterturn</groupId>
            <artifactId>easypoi-web</artifactId>
            <version>4.0.0</version>
        </dependency>
        <dependency>
            <groupId>cn.afterturn</groupId>
            <artifactId>easypoi-annotation</artifactId>
            <version>4.0.0</version>
        </dependency>
        <!-- 热更新依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <optional>true</optional>
        </dependency>
        <!-- Jsoup是用于解析HTML，就类似XML解析器用于解析XML -->
        <dependency>
            <groupId>org.jsoup</groupId>
            <artifactId>jsoup</artifactId>
            <version>1.10.2</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>1.4.2.RELEASE</version>
                <configuration>
                    <mainClass>com.lzr.ReadWriteSeparationApplication</mainClass>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.mybatis.generator</groupId>
                <artifactId>mybatis-generator-maven-plugin</artifactId>
                <version>1.3.5</version>
                <configuration>
                    <!-- 是否覆盖 -->
                    <overwrite>true</overwrite>
                    <!--允许移动生成的文件 -->
                    <verbose>true</verbose>
                    <!-- 自动生成的配置,${basedir}表示项目根目录 ,configurationFile默认在resource目录下-->
                    <configurationFile>${basedir}/src/main/resources/mybatis/mybatis-generator.xml</configurationFile>
                </configuration>
                <dependencies>
                    <!--mysql驱动包-->
                    <dependency>
                        <groupId>mysql</groupId>
                        <artifactId>mysql-connector-java</artifactId>
                        <version>5.1.35</version>
                        <scope>runtime</scope>
                    </dependency>
                    <dependency>
                        <groupId>tk.mybatis</groupId>
                        <artifactId>mapper</artifactId>
                        <version>3.5.3</version>
                    </dependency>
                    <dependency>
                        <groupId>org.mybatis.generator</groupId>
                        <artifactId>mybatis-generator-core</artifactId>
                        <version>1.3.5</version>
                    </dependency>
                </dependencies>
            </plugin>
            <!-- 忽略无web.xml警告 -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-war-plugin</artifactId>
                <configuration>
                    <failOnMissingWebXml>false</failOnMissingWebXml>
                </configuration>
            </plugin>
        </plugins>
        <!-- 注意：如果有这个，则不能使用mybatis-generator生成，必须先注释下面的resources配置才行 -->
        <resources>
            <resource>
                <directory>src/main/webapp</directory>
                <targetPath>META-INF/resources</targetPath>
                <includes>
                    <include>**/**</include>
                </includes>
            </resource>
            <!--<resource>-->
            <!--<directory>src/main/java</directory>-->
            <!--<includes>-->
            <!--<include>**/*.yml</include>-->
            <!--<include>**/*.properties</include>-->
            <!--<include>**/*.xml</include>-->
            <!--</includes>-->
            <!--<filtering>false</filtering>-->
            <!--</resource>-->
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/**</include>
                </includes>
                <filtering>false</filtering>
            </resource>
        </resources>
    </build>

</project>

二. application.yml配置

spring:
  # Hikaricp数据库连接池
  datasource:
    # 主配置(端口3306)
    master:
      type: com.zaxxer.hikari.HikariDataSource
      jdbc-url: jdbc:mysql://localhost:3306/readwriteseparation?useUnicode=true&characterEncoding=UTF-8&allowMultiQueries=true
      username: root
      password: root
      driver-class-name: com.mysql.jdbc.Driver
      read-only: false
      connection-test-query: SELECT 1
      idle-timeout: 600000
      max-lifetime: 3000000
      connection-timeout: 3000
      maximum-pool-size: 5
      minimum-idle: 5
    # 从配置(端口3307)(最好设置只读账户)
    slave1:
      type: com.zaxxer.hikari.HikariDataSource
      jdbc-url: jdbc:mysql://localhost:3307/readwriteseparation?useUnicode=true&characterEncoding=UTF-8&allowMultiQueries=true
      username: onlyRead
      password: root
      driver-class-name: com.mysql.jdbc.Driver
      read-only: true
      idle-timeout: 600000
      max-lifetime: 3000000
      connection-timeout: 2000
      maximum-pool-size: 5
      minimum-idle: 5
    # 从配置(端口3307)(最好设置只读账户)
    slave2:
      type: com.zaxxer.hikari.HikariDataSource
      jdbc-url: jdbc:mysql://localhost:3307/readwriteseparation?useUnicode=true&characterEncoding=UTF-8&allowMultiQueries=true
      username: onlyRead
      password: root
      driver-class-name: com.mysql.jdbc.Driver
      read-only: true
      idle-timeout: 600000
      max-lifetime: 3000000
      connection-timeout: 2000
      maximum-pool-size: 5
      minimum-idle: 5
  # Spring boot视图配置
  mvc:
    view:
      prefix:
      suffix: .jsp
  # 数据时间格式处理
  jackson:
    date-format: yyyy-MM-dd HH:mm:ss
    time-zone: GMT+8
# 全局配置
server:
  port: 8080
  tomcat:
    uri-encoding: UTF-8
# 配置pageHelper分页插件的内容
pagehelper:
  auto-dialect: mysql
  reasonable: true
  support-methods-arguments: true
  params: count=countSql
# 日志配置文件
logging:
  config: classpath:logback.xml

三. 日志logback.xml配置

<?xml version="1.0" encoding="UTF-8"?>
<configuration scan="true" scanPeriod="60 seconds" debug="false">
    <contextName>logback</contextName>
    <property name="log.path" value="logs/study-readwriteseparation/logback/" />
    <property name="log.file" value="logs/study-readwriteseparation/logback.log" />

    <!-- 彩色日志 -->
    <!-- 彩色日志依赖的渲染类 -->
    <conversionRule conversionWord="clr" converterClass="org.springframework.boot.logging.logback.ColorConverter" />

    <!-- 彩色日志格式 -->
    <property name="CONSOLE_LOG_PATTERN" value="%d{yyyy-MM-dd HH:mm:ss.SSS} %clr(%contextName) [%thread] %clr(%-5level) %logger{36} - %msg%n" />

    <!--输出到控制台 -->
    <appender name="console" class="ch.qos.logback.core.ConsoleAppender">
        <!-- <filter class="ch.qos.logback.classic.filter.ThresholdFilter"> <level>ERROR</level>
            </filter> -->
        <encoder>
            <pattern>${CONSOLE_LOG_PATTERN}</pattern>
            <charset>UTF-8</charset>
        </encoder>
    </appender>

    <!--输出到文件 -->
    <appender name="file" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <file>${log.file}</file>
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <fileNamePattern>${log.path}%d{yyyy-MM-dd_HH}.log</fileNamePattern>
            <maxHistory>30</maxHistory>
            <!-- 指定日志文件的上限大小，例如设置为1GB的话，那么到了这个值，就会删除旧的日志 -->
            <totalSizeCap>1GB</totalSizeCap>
        </rollingPolicy>
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} %contextName [%thread] %-5level %logger{36} - %msg%n</pattern>
        </encoder>
    </appender>

    <root level="info">
        <appender-ref ref="console" />
        <appender-ref ref="file" />
    </root>

    <!-- dao层日志为debug,可以打印执行的sql语句 -->
    <logger name="com.lzr.dao" level="DEBUG"/>

</configuration>

四. 代码配置

注意：我这里只贴出主要代码

1. 切面处理

package com.lzr.config.datasourceconfig;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.core.Ordered;
import org.springframework.stereotype.Component;

/**
 * 使用切面处理
 * 如果在service层设置数据源
 * 必须在事务AOP之前执行，所以实现PriorityOrdered,其中order的值越小，越先执行
 * 如果一旦开始切换到写库，则之后的读都会走写库
 * 注：AOP ，内部方法之间互相调用时，如果是this.xxx()这形式，不会触发AOP拦截
 */
@Aspect
@Component
public class DataSourceAop implements Ordered {

    @Before("@annotation(com.lzr.annotation.Slave)")
    public void read() {
        DBContextHolder.slave();
    }

    @Before("@annotation(com.lzr.annotation.Master)")
    public void write() {
        DBContextHolder.master();
    }

    /**
     * 值越小，越优先执行
     * 需要优于事务的执行
     * 在启动类中加上了@EnableTransactionManagement(order = 10)
     * @return
     */
    @Override
    public int getOrder() {
        return 1;
    }
}

2. 数据源配置

package com.lzr.config.datasourceconfig;

import com.lzr.response.enums.DBTypeEnum;
import lombok.extern.log4j.Log4j2;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.jdbc.DataSourceBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

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

/**
 * 数据源配置
 */
@Log4j2
@Configuration
public class DataSourceConfig {

	// 也可以new HikariDataSource(),但是DataSourceBuilder.create().build()会去寻找依赖
    // 当我们修改连接池的时候，就不需要修改本地的java代码了
    @Bean
    @ConfigurationProperties("spring.datasource.master")
    public DataSource masterDataSource() {
        return DataSourceBuilder.create().build();
    }

    @Bean
    @ConfigurationProperties("spring.datasource.slave1")
    public DataSource slave1DataSource() {
        return DataSourceBuilder.create().build();
    }

    @Bean
    @ConfigurationProperties("spring.datasource.slave2")
    public DataSource slave2DataSource() {
        return DataSourceBuilder.create().build();
    }

    @Bean
    public DataSource myRoutingDataSource(@Qualifier("masterDataSource") DataSource masterDataSource,
                                          @Qualifier("slave1DataSource") DataSource slave1DataSource,
                                          @Qualifier("slave2DataSource") DataSource slave2DataSource) {
        log.info("开始配置多数据源");
        Map<Object, Object> targetDataSources = new HashMap<>();
        targetDataSources.put(DBTypeEnum.MASTER, masterDataSource);
        targetDataSources.put(DBTypeEnum.SLAVE1, slave1DataSource);
        targetDataSources.put(DBTypeEnum.SLAVE2, slave2DataSource);
        MyRoutingDataSource myRoutingDataSource = new MyRoutingDataSource();
        // 默认执行数据源
        myRoutingDataSource.setDefaultTargetDataSource(masterDataSource);
        // 目标执行数据源集合
        myRoutingDataSource.setTargetDataSources(targetDataSources);
        log.info("多数据源配置完成");
        return myRoutingDataSource;
    }

}

3. 上下文key值处理设置类

package com.lzr.config.datasourceconfig;


import com.lzr.response.enums.DBTypeEnum;
import lombok.extern.log4j.Log4j2;

import java.util.concurrent.atomic.AtomicInteger;

/**
 * 上下文key值处理设置类
 */
@Log4j2
public class DBContextHolder {

    // 初始化数字
    private static final Integer initNum = new Integer(0);

    private static final ThreadLocal<DBTypeEnum> threadLocal = new ThreadLocal<>();

    private static final AtomicInteger atomicInteger = new AtomicInteger(initNum);

    public static void set(DBTypeEnum dbType) {
        threadLocal.set(dbType);
    }

    public static DBTypeEnum get() {
        return threadLocal.get();
    }

    public static void master() {
        set(DBTypeEnum.MASTER);
        log.info("切换到master");
    }

    public static void slave() {
        //  处理两个从库切换方式
        int index = atomicInteger.getAndIncrement();
        if (index>>10 > 1) {// 最大请求2048次
            atomicInteger.set(initNum);
        }
        if (index>>1 == 0) {
            set(DBTypeEnum.SLAVE1);
            log.info("切换到"+DBTypeEnum.SLAVE1.name());
        }else {
            set(DBTypeEnum.SLAVE2);
            log.info("切换到"+DBTypeEnum.SLAVE2.name());
        }
    }

}

4. mybatis 配置类

package com.lzr.config.datasourceconfig;

import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;

import javax.annotation.Resource;
import javax.sql.DataSource;

/**
 * mybatis 配置类
 */
@EnableTransactionManagement
@Configuration
public class MyBatisConfig {

    @Resource(name = "myRoutingDataSource")
    private DataSource myRoutingDataSource;

    /**
     * 工厂设置
     * @return
     * @throws Exception
     */
    @Bean
    public SqlSessionFactory sqlSessionFactory() throws Exception {
        SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
        sqlSessionFactoryBean.setDataSource(myRoutingDataSource);
        sqlSessionFactoryBean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath:mapper/*.xml"));// 映射文件
        sqlSessionFactoryBean.setTypeAliasesPackage("com.lzr.model,com.lzr.vo,com.lzr.dto");// 别名扫描包
        org.apache.ibatis.session.Configuration configuration = new org.apache.ibatis.session.Configuration();
        configuration.setCallSettersOnNulls(true);// 为空时也设置数据
        configuration.setMapUnderscoreToCamelCase(true);// 开启驼峰转换
        sqlSessionFactoryBean.setConfiguration(configuration);
        return sqlSessionFactoryBean.getObject();
    }

    /**
     * 事务设置
     * @return
     */
    @Bean
    public PlatformTransactionManager platformTransactionManager() {
        return new DataSourceTransactionManager(myRoutingDataSource);
    }
}

5. 对应的key值获取配置类

获取当前路由数据源key

package com.lzr.config.datasourceconfig;

import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;
import org.springframework.lang.Nullable;

/**
 * 获取database对应的key值
 * DataSourceConfig中配置的key
 */
public class MyRoutingDataSource extends AbstractRoutingDataSource {
    /**
     * 在DBContextHolder中获取当前请求对应的database的key值
     * @return
     */
    @Nullable
    @Override
    protected Object determineCurrentLookupKey() {
        return DBContextHolder.get();
    }

}

6. 两个注解Master与Slave

6.1 自定义Master注解

package com.lzr.annotation;

/**
 * 走主库
 * @author lzr
 * @date 2019/12/13 0013 15:57
 */
public @interface Master {
}

6.2 自定义Slave注解

package com.lzr.annotation;

/**
 * 走从库
 * @author lzr
 * @date 2019/12/13 0013 15:57
 */
public @interface Slave {
}

7. 自定义枚举类型

package com.lzr.response.enums;

/**
 * 主从库 枚举类型 可以当做别名(也可以使用application.yml设置别名)
 */
public enum DBTypeEnum {

    MASTER, SLAVE1, SLAVE2;

}

8. 启动类

package com.lzr;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.transaction.annotation.EnableTransactionManagement;
import tk.mybatis.spring.annotation.MapperScan;

/**
 * @author lzr
 * @date 2019/12/11 0011 17:43
 */
@SpringBootApplication
@MapperScan(basePackages = "com.lzr.dao")
@EnableTransactionManagement(order = 10)// 配置事务优先级为10 (不设置order，则默认最大integer数值)
public class ReadWriteSeparationApplication {

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

}

9. service中测试图

在这里插入图片描述
当然，如果你不加注解，则会走默认库。
由于在类上加上了事务注解，所以在自定义aop中需要设置拦截order，需要在事务之前处理好当前线程所要走的库，不然，会先连接默认库。

五. 大致项目结构图

注意：此图非完整项目结构，如果需要，则拉取下面的git路径
在这里插入图片描述

六. 项目git地址

git地址：读写分离项目git地址
若有疑问，请在评论区留言，谢谢

鱼有刺
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
spring-boot2-mybatis-druid-读写分离-swagger2
11-15
这几天因为工作需要，学习研究了一下spring-boot。spring-boot2+mybatis+druid+读写分离+swagger2进行一个整合，做了一个demo。自己已经充分测试，过程中也踩了不少的坑。 前两天刚上传一个demo。事物有点问题，非常抱歉。建议大家选择spring-boot 2.0版本以上，jdk8以上，低版本问题较多。
采用最新版本SpringBoot2+MyBatis+Mysql+Apollo+Redis+Rabbitmq集成例子
03-13
采用最新版本SpringBoot2+MyBatis+Mysql+Apollo+Redis+Rabbitmq集成例子
SpringBoot2整合MyBatis实现读写分离
程序带给我们的思考
11-02 707
一、CentOS7搭建MariaDB主从环境 CentOS7搭建MariaDB主从 二、新建SpringBoot项目 目录结构如下： 三、pom.xml文件如下 <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmln...
Spring Boot2.X-整合mybatis+mysql
那些疯狂到以为自己能够改变世界的人，才能真正改变世界！
09-26 260
1.linux安装mysql8.0 参考：https://blog.csdn.net/young_0609/article/details/109015666 2.安装mysql客户端Navicat Premium 12
springboot2+两种方式：(读写分离、动态DataSource、事务懒处理)+sharding-jdbc.zip
07-09
1、AbstractRoutingDataSource （1）、AbstractRoutingDataSource注册多数据源，AOP实现读写分离、读写源自动切换 （2）、一主多从，多个从库的负载均衡策略可以自定义。（双主多从、故障转移因mysql环境为一主一从，所以代码未实现，不难实现，需要实现的代码位置已标记） （3）、非注解方式，业务代码侵入基本为零 （4）、懒事务处理方式，service层使用@Transactional注解的方法或者类只能走默认库（写库） （5）、AOP根据Dao层的方法名来判断读写库的切换，超出判断规则的只能走默认库（写库） 2、sharding-jdbc （1）、实现多种模式的读写分离 （2）、支持事务 （3）、配置中心化 （4）、存储过程不能正常解析 ———————————————— 版权声明：本文为CSDN博主「毛豆有毛没豆」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。 原文链接：https://blog.csdn.net/qq_22049773/article/details/107237955
springboot +mybatis+oracle 配置多个数据源,配置两个数据库信息
12-25
2. **配置第二个数据源** 要添加第二个数据源，我们可以创建一个新的配置类，使用`@ConfigurationProperties`注解来绑定配置文件中的属性。例如，我们可以命名为`secondary-datasource`： ```java @...
springboot 学习mybatis+mysql读写分离(一写多读)+事务.zip
02-22
本教程将带你深入理解如何在SpringBoot项目中结合Mybatis和MySQL实现读写分离，并且探讨事务管理。以下是相关知识点的详细说明： 1. **SpringBoot框架**：SpringBoot简化了Spring应用的初始搭建以及开发过程，它...
JAVA智能停车场管理系统源码+数据库，基于SpringBoot +Mybatis+node.js+mysql，计算机毕业设计
01-13
这个系统基于一系列先进的技术和框架构建，如SpringBoot、Mybatis、Node.js和MySQL，这些技术的组合使得系统具有高性能、易维护和扩展性强的特点。 1. **SpringBoot**：SpringBoot是Spring框架的延伸，简化了Java ...
基于SpringBoot+Mybatis开发的Steam商城项目源码+项目说明+sql数据库.zip
最新发布
05-06
* 首页及其他页面因为读多写少，利用Mysql主从复制实现读写分离，写入在主Mysql下进行，读取在从Mysql进行 * 关于数据的不一致性，可以在写入的时候先写入缓存，读取的时候也先在缓存中读取，这样就可以避免数据的不...
springboot+mybatis多数据源配置下载
07-21
当涉及到多数据源配置时，这通常是大型系统为了实现数据隔离、读写分离或者高可用性而采取的策略。下面将详细介绍如何在Spring Boot项目中集成MyBatis并配置多个数据源。 首先，我们来看标题中的"springboot+...
springboot基于Mybatis mysql实现读写分离
08-25
主要介绍了springboot基于Mybatis mysql实现读写分离,需要的朋友可以参考下
spring boot配置读写分离的完整实现步骤
08-26
数据库配置主从之后，如何在代码层面实现读写分离？所以下面这篇文章主要给大家介绍了关于spring boot配置读写分离的完整步骤，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友可以参考下
springboot2.0+mybatis主从数据库双数据源。
04-26
springboot2.0+mybatis主从数据库双数据源，测试了事务，事务是单独分开的。回滚只回滚主库的事务。
springboot2+mybatis+mysql
07-20
springboot2+mybatis+mysql 很好的小例子，适合初学者。
springboot2.0+mybatis实现读写分离
xiaoxiaoxiao_Ming的博客
11-04 344
一、application.yml配置文件 server: port: 8080 servlet: context-path: /cm spring: datasource: type: com.alibaba.druid.pool.DruidDataSource druid: master: driver-class-name: com.mysql.cj.jdbc.Driver username: username
SpringBoot配置多数据源，结合AOP实现读写分离(二)
佳豪的博客
07-21 501
## 读写分离：缓解数据库的压力，让主数据库处理事务性增、改、删操作，而从数据库处理查询操作。 **一、**首先要部署两个Mysql数据库并实现主从复制，详情请参考我之前的文章 dokcer容器环境实现mysql主从复制 **二、**在pom文件中添加如下依赖： <dependencies> <dependency> <groupId>com.alibaba</groupId> <artif
SpringBoot2.X (二十五)：SpringBoot整合 Mybatis + MySQL CURD 示例
大痴小乙的博客
10-21 6698
文章目录工程结构图1、maven 依赖：2、yml 配置文件：3、核心代码：User.javaMyBatisConfig.javaUserController.javaUserService.javaUserServiceImpl.javaUserMapper.java4、测试1)、查询2）添加3）移除4）修改总结： 话不多数，直接开始撸代码… 工程结构图 开始之前先放张工程结构图 1、mave...
springboot2.X+mybatisplus读写分离整合
步派微信小程序
05-11 326
源码下载地址 https://github.com/double-hill/master-slave-mybitis-plus.git
SpringBoot 2.0集成MySQL+mybatis+Druid配置
mm490000133的博客
04-21 2841
本文采用的springboot版本为2.1.4，mybatis版本为1.3.2，Druid版本为1.1.10 springboot项目骨架生成不在赘述，idea可以用spring initializr生成，或者直接到spring官网https://start.spring.io生成，下载之后导入到idea中。 1.引入jar包，pom文件如下： <?xml version="1.0"...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值