spring boot + mysql +mybatis +redis（二级缓存）实例

最新推荐文章于 2021-08-03 11:13:40 发布
最新推荐文章于 2021-08-03 11:13:40 发布
阅读量1.4k 收藏 4
点赞数 2
分类专栏： JAVA Mysql spring boot SSM学习 WEB 文章标签： spring mysql redis mybatis spring-boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/JasonHector/article/details/78802772
版权

配置了好几天才算配置好

个人感觉spring boot版本间兼容不好

一、创建maven项目并添加 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>
    <groupId>1</groupId>
    <artifactId>1</artifactId>
    <version>1.0-SNAPSHOT</version>

    <!-- Inherit defaults from Spring Boot -->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.3.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>


    <!--项目编码格式以及JDK版本指定-->
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>


    <!-- Add typical dependencies for a web application -->

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.3.0</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>

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

        <!--alibaba.fastjson-->
        <!-- https://mvnrepository.com/artifact/com.alibaba/fastjson -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.41</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->

        //spring 包 很容易与spring boot 版本冲突 注意
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>4.3.12.RELEASE</version>
        </dependency>




    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>



</project>

二、yml 配置文件

################################
######                     #####
######     应用通用配置     #####
######                     #####
################################

spring:
# 应用名称
  application:
    name: MavenDemoProject

# 多环境配置
  profiles:
    active: dev

# http请求编码配置
  http:
    encoding:
      charset: UTF-8
      force: true
      enabled: true

# mysql数据库配置
  datasource:
#    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.jdbc.Driver
    #url,username,password动态配置
    url: jdbc:mysql://localhost:3306/test?useUnicode:true&characterEncoding:utf-8
    username: root
    password: ****
    dbcp2:
       #最大空闲连接
       max-idle: 100
       #最小空闲连接
       min-idle: 10
       #最大连接数
       max-total: 200
       #最大等待时间
       max-wait-millis: 5000
       #检测周期 单位毫秒
       time-between-eviction-runs-millis: 30000
       #连接池足校生存时间
       min-evictable-idle-time-millis: 1800000
#       test-on-borrow: true
#       validation-query: SELECT 1
#       test-while-idle: true
#       num-tests-per-eviction-run: 100


# redis缓存配置
  redis:
     #host，password，port，database动态配置
    host: *******
    password: *****
    port: 6379
    database: 0
    timeout: 2000
    pool:
        # 连接池中的最大空闲连接
        max-idle: 80
        # 连接池中的最小空闲连接
        min-idle: 1
        # 连接池最大连接数（使用负值表示没有限制）
        max-active: 80
        # 连接池最大阻塞等待时间（使用负值表示没有限制）
        max-wait: 10

# mybatis配置
mybatis:
  #config-location: classpath:/mybatis-config.xml
  type-aliases-package: com.frank.dao.*
  mapper-locations: classpath:/mapper/*.xml
#  configuration:
#    #延时加载
#    lazy-loading-enabled: true
#    map-underscore-to-camel-case: true
#    use-column-label: true

需要在mapper xml 文件中声明二级缓存 如下

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.weixin.dao.student.StudentMapper">
    <!--开启二级缓存-->
<cache type="com.weixin.config.RedisConfig"/>
    <select id="get" resultType="com.weixin.model.Student">

        SELECT * FROM student

        WHERE id = #{id}

    </select>

    <update id="update" parameterType="com.weixin.model.Student">

        UPDATE student SET

        name = #{name},

        age = #{age}

        WHERE id = #{id}

    </update>

</mapper>

bean类型 需要实现Serializable接口

package com.weixin.model;

import java.io.Serializable;

public class Student implements Serializable {
    private int id;
    private String name;
    private int age;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getAge() {
        return age;
    }
}

三、Redis 配置类

package com.weixin.config;

import org.apache.ibatis.cache.Cache;
import org.slf4j.Logger;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class RedisConfig implements Cache {
    private static final Logger logger = org.slf4j.LoggerFactory.getLogger(RedisConfig.class);

    private final ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    private  String id; // cache instance id
    private RedisTemplate redisTemplate;
    private static final long EXPIRE_TIME_IN_MINUTES = 30; // redis过期时间
    private static final String DEFAULT_ID = "default_id";


    public RedisConfig(String id) {
        if (id == null) {
            id = DEFAULT_ID;
        }
        this.id = id;
    }



    public void setId(String id ){

        this.id = id;
    }
    @Override
    public String getId() {
        return id;
    }

    /**
     * Put query result to redis
     *
     * @param key
     * @param value
     */
    @Override
    @SuppressWarnings("unchecked")
    public void putObject(Object key, Object value) {
        try {
            RedisTemplate redisTemplate = getRedisTemplate();
            ValueOperations opsForValue = redisTemplate.opsForValue();
            opsForValue.set(key, value, EXPIRE_TIME_IN_MINUTES, TimeUnit.MINUTES);
            logger.debug("Put query result to redis");
        } catch (Throwable t) {
            logger.error("Redis put failed", t);
        }
    }

    /**
     * Get cached query result from redis
     *
     * @param key
     * @return
     */
    @Override
    public Object getObject(Object key) {
        try {
            RedisTemplate redisTemplate = getRedisTemplate();
            ValueOperations opsForValue = redisTemplate.opsForValue();
            logger.debug("Get cached query result from redis");
            return opsForValue.get(key);
        } catch (Throwable t) {
            logger.error("Redis get failed, fail over to db", t);
            return null;
        }
    }

    /**
     * Remove cached query result from redis
     *
     * @param key
     * @return
     */
    @Override
    @SuppressWarnings("unchecked")
    public Object removeObject(Object key) {
        try {
            RedisTemplate redisTemplate = getRedisTemplate();
            redisTemplate.delete(key);
            logger.debug("Remove cached query result from redis");
        } catch (Throwable t) {
            logger.error("Redis remove failed", t);
        }
        return null;
    }

    /**
     * Clears this cache instance
     */
    @Override
    public void clear() {
        RedisTemplate redisTemplate = getRedisTemplate();
        redisTemplate.execute((RedisCallback) connection -> {
            connection.flushDb();
            return null;
        });
        logger.debug("Clear all the cached query result from redis");
    }

    /**
     * This method is not used
     *
     * @return
     */
    @Override
    public int getSize() {
        return 0;
    }

    @Override
    public ReadWriteLock getReadWriteLock() {
        return readWriteLock;
    }

    private RedisTemplate getRedisTemplate() {
        if (redisTemplate == null) {
            redisTemplate = ApplicationContextHolder.getBean("redisTemplate");
        }
        //spring-data-redis的RedisTemplate<K, V>模板类在操作redis时默认使用JdkSerializationRedisSerializer来进行序列化
        //一下修改为String类型序列化 解决redis库中 K V 出现 xAC\xED\x00\x05t\x00\x04 问题
        RedisSerializer stringSerializer = new StringRedisSerializer();
        redisTemplate.setKeySerializer(stringSerializer);
//        redisTemplate.setValueSerializer(stringSerializer);
        redisTemplate.setHashKeySerializer(stringSerializer);
//        redisTemplate.setHashValueSerializer(stringSerializer);

        return redisTemplate;
    }
}

ApplicationContextHolder 类

package com.weixin.config;

import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;

@Component
public class ApplicationContextHolder implements ApplicationContextAware {
    private static ApplicationContext applicationContext;

    @Override
    public void setApplicationContext(ApplicationContext ctx) throws BeansException {
        applicationContext = ctx;
    }

    /**
     * Get application context from everywhere
     *
     * @return
     */
    public static ApplicationContext getApplicationContext() {
        return applicationContext;
    }

    /**
     * Get bean by class
     *
     * @param clazz
     * @param <T>
     * @return
     */
    public static <T> T getBean(Class<T> clazz) {
        return applicationContext.getBean(clazz);
    }

    /**
     * Get bean by class name
     *
     * @param name
     * @param <T>
     * @return
     */
    @SuppressWarnings("unchecked")
    public static <T> T getBean(String name) {
        return (T) applicationContext.getBean(name);
    }
}

上面需要用到spring-context jar 包，需要注意版本，版本不同可能冲突

注意：

 RedisSerializer stringSerializer = new StringRedisSerializer();
        redisTemplate.setKeySerializer(stringSerializer);
//        redisTemplate.setValueSerializer(stringSerializer);
        redisTemplate.setHashKeySerializer(stringSerializer);
//        redisTemplate.setHashValueSerializer(stringSerializer);

上面表示redis中的key值设置为String类型，这样能更清楚的找到key值，但是如果开启二级缓存的话，执行sql语句时查找的对象不会进行redis存储，因为查找到对象key为Object值，控制台会报错，如图

这里写图片描述

可以改成 key.toString() 进行存储，但是出现文件分级，如图：

这里写图片描述

所以说还要按照实际情况进行设置

四、controller层进行使用

package com.weixin.controller;

import com.alibaba.fastjson.JSONObject;
import com.weixin.config.RedisConfig;
import com.weixin.model.Student;
import com.weixin.service.student.StudentService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/test")
public class SpringBootTest {

    @Autowired
    private StudentService studentService;


    @RequestMapping("/one")
    public JSONObject test() {
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("code", "success");
        //id 没有实际价值 只是为了更好确认
        RedisConfig redisConfig = new RedisConfig("100");
        redisConfig.putObject("1000","hello i m frank!");

        return jsonObject;
    }

    /**
     * 根据id获取对象
     *
     * @param id
     * @return
     */
    @GetMapping("/{id}")
    public JSONObject get(@PathVariable("id") int id) {

        Student student = studentService.get(id);
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("id", student.getId());
        jsonObject.put("age", student.getAge());
        jsonObject.put("name", student.getName());
        RedisConfig redisConfig = new RedisConfig("100");
        redisConfig.putObject("frank",jsonObject);
        return jsonObject;

    }

    /**
     * 更新对象
     *
     * @return
     */
    @RequestMapping("/update")
    public String put() {

        Student student = new Student();
        student.setId(1);
        student.setAge(22);
        student.setName("new frank");
        studentService.update(student);

        return "success";

    }

    @RequestMapping("/getRedis")

    public JSONObject get() {

        RedisConfig redisConfig = new RedisConfig("100");

        return  (JSONObject) redisConfig.getObject("frank");

    }
}

五、运行查看

这里写图片描述

查看redis

这里写图片描述

添加JSON value 值

这里写图片描述

显示情况

这里写图片描述

如果想显示String的话 可以在RedisConfig中 setValueSerializer 进行设置

获取value值

这里写图片描述

五、项目总体结构

这里写图片描述

项目下载

http://download.youkuaiyun.com/download/jasonhector/10158450

mybatis二级缓存（侧重于springboot整合mybatis）
weixin_58993861的博客
03-02 794
1.引入依赖 <!--mybatis--> <dependency> <groupId>org.mybatis.spring.boot</groupId> <artifactId>mybatis-spring-boot-starter</artifactId> <version>2.1.3</version&gt
Springboot+Mybatis+redis实现二级缓存
qq_38040765的博客
03-19 352
Mybatis的二级缓存是多个SqlSession共享的，作用于是mapper配置文件中同一个namespace，不同的SqlSession两次执行相同namespace下的sql语句且参数如果也一样则最终执行的sql语句是相同的。每次查询都会先看看缓存中是否有对应查询结果，如果有就从缓存拿，如果没有就执行sql语句从数据库中读取，从而提高查询效率。Mybatis默认开启的是一级缓存，所以二级缓存...
springboot +mybatis+redis二级缓存 使用效果
dingxingmei的专栏
05-23 1449
1 先看核心代码打印出效果图 2springboot +mybatis+redis二级缓存小demo 1 先看核心代码打印出效果图 打印输出内容如下： 调用Redis缓存Key : com.sun.proxy.$Proxy77getAccountCheckStatisticsAccountCheckStatisticsPageDto(pageNum...
Springboot+Mybatis+Redis实现二级缓存
二萌偏的博客
07-30 645
二级缓存是多个SqlSession共享的，其作用域是mapper的同一个namespace，不同的sqlSession两次执行相同namespace下的sql语句且向sql中传递参数也相同即最终执行相同的sql语句，第一次执行完毕会将数据库中查询的数据写到缓存（内存），第二次会从缓存中获取数据将不再从数据库查询，从而提高查询效率。 1.添加pom依赖 &lt;dependency&gt; ...
Spring boot + mybatis + Vue.js + ElementUI 实现数据的增删改查实例代码(二)
10-19
5. `spring-boot-starter-redis`: 引入Redis的支持，这里可能是为了解决缓存或session问题，但在这个基本的CRUD实例中，可能并未涉及。 在实际开发中，实现数据的分页通常需要以下几个步骤： 1. 在后端（Spring ...
Spring Boot整合MyBatis和Redis二级缓存实例教程
结合标题和描述所提及的实例，这应该是一个通过Spring Boot整合MySQL和MyBatis，并在MyBatis中使用Redis作为二级缓存的应用程序实例。 - **整合Spring Boot和MyBatis**: 这通常涉及在Spring Boot项目中添加MyBatis...
基于springboot+vue+mysql+mybatis的博客系统源码+数据库
最新发布
01-28
这是一个基于Spring Boot、Vue.js、MySQL和MyBatis技术栈构建的博客系统源码，包含完整的数据库设计。让我们深入探讨一下这些技术以及它们在构建博客系统中的应用。 **Spring Boot** Spring Boot是Spring框架的一个...
数据库课程设计实践指南：Spring Boot+MyBatis+Redis集成
资源摘要信息:"该数据库课程设计资源合集包含了多个基于Spring Boot框架、MyBatis持久层框架、Redis缓存数据库以及Maven构建工具的后端项目。这些项目旨在为学习者提供真实的数据库应用开发经验，帮助学习者掌握...
springboot2.x整合redis做mybatis的二级缓存
07-18
springboot整合redis做mybatis的二级缓存，含有自定义key，自定义过期时间，自定义序列化方式
springboot-mybatis-mysql-redis demo
04-28
springboot-mybatis-mysql-redis 集成 demo 啦啦啦啦啦啦啦啦啦啦啦啦啦
springboot-shiros-mybatis-redis+mysql(前后分离)
09-16
springboot-shiros-mybatis-redis+mysql 仅仅是个dmoe 自带部署脚本 不懂的 联系本人。
Springboot+mybatis+mysql+redis
09-04
这是一个java WEB小项目，用 Maven Springboot+mybatis+mysql+redis集成的小项目例子，可供新手进行参考学习，数据库是mysql 5.5 ,只是一个简单的小参考例子，测试过可以正常运行
springboot案例，springboot+mybatis整合，springboot+mybatis+redis集群
09-08
Spring Boot是一个全新框架，能够简化spring配置文件，相比springmvc功能更加简单，能够提高开发效率。其设计目的是用来简化新Spring应用的初始搭建以及开发过程。本篇文件中介绍了以下内容： springboot简单案例入门。 springboot+mybatis整合开发。 springboot+mybatis+redis整合开发。
Java+MySQL+redis缓存
12-18
案例中数据来自MySQL数据库，对查询出来的数据缓存到redis,redis缓存工具可以将缓存string，bean,list，map等类型，代码中有详细的注释，而且还将要缓存的数据进行了序列化，大家可以借鉴，进而更改成自己想要的格式。数据库配置使用了xml和propertis两种配置方式，redis缓存采用非切片和切片两种配置，大家可以自选择
mysql二级缓存redis_SpringBoot+Mybatis+redis(二级缓存)搭建
weixin_35668334的博客
02-08 162
刚刚开始接触Spring Boot，因为极简单的配置开发，搭建一个通用的Spring Boot+Mybaitis+redis的开发框架。一、用maven构建项目，pom.xml文件如下：org.springframework.bootspring-boot-starter-parent1.5.1.RELEASEorg.springframework.bootspring-boot-startero...
springBoot中配置mybatis的二级缓存（注解版）
jieepre的博客
12-06 955
参考 参考文章
redis mysql mybatis_springboot +mybatis+mysql+redis
weixin_34921325的博客
01-19 318
一、准备工作进入springboot的环境搭建页面https://start.spring.io/输入需要集成的项目，例如集成springboot的web、redis、mysql、mybatis，如下图所示：点击Generate Project 按钮，生成springboot的基础代码springboot 的pom.xml内容如下1 2 3 xsi:schemaLocation="http://m...
SpringBoot+Mybatis一级缓存和二级缓存详解
殷华隆的博客
08-03 674
众所周知，Mybatis 的一级缓存是 sqlSession 级别的，它的作用域为一次 sqlSession 会话，什么是一次 sqlSession 会话呢？举个例子说明一下。 public static void selectAllStudent() { SqlSessionFactory sqlSessionFactory = getSession(); SqlSession session = sqlSessionFactory.openSession(); StudentMapper mapp
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值