Spring Boot 集成Redis

最新推荐文章于 2023-09-19 13:50:22 发布
最新推荐文章于 2023-09-19 13:50:22 发布
阅读量134 收藏
点赞数 2
分类专栏： Spring Boot Redis 文章标签： spring boot redis mysql java mybatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_53284329/article/details/112367628
版权

Redis 介绍(来自于百度百科)

redis是一个key-value存储系统。

它和Memcached类似，它支持存储的value类型相对更多，包括string(字符串)、list(链表)、set(集合)、zset(sorted set --有序集合)和hash（哈希类型）。

这些数据类型都支持push/pop、add/remove及取交集并集和差集及更丰富的操作，而且这些操作都是原子性的。
在此基础上，redis支持各种不同方式的排序。与memcached一样，为了保证效率，数据都是缓存在内存中。区别的是redis会周期性的把更新的数据写入磁盘或者把修改操作写入追加的记录文件，并且在此基础上实现了master-slave(主从)同步。

redis的出现，很大程度补偿了memcached这类key/value存储的不足，在部 分场合可以对关系数据库起到很好的补充作用。它提供了Java，C/C++，C#，PHP，JavaScript，Perl，Object-C，Python，Ruby，Erlang等客户端，使用很方便。

Redis支持主从同步。数据可以从主服务器向任意数量的从服务器上同步，从服务器可以是关联其他从服务器的主服务器。
这使得Redis可执行单层树复制。存盘可以有意无意的对数据进行写操作。由于完全实现了发布/订阅机制，使得从数据库在任何地方同步树时，可订阅一个频道并接收主服务器完整的消息发布记录。同步对读取操作的可扩展性和数据冗余很有帮助。

Spring Boot介绍(来自于百度百科)

SpringBoot是由Pivotal团队在2013年开始研发、2014年4月发布第一个版本的全新开源的轻量级框架。它基于Spring4.0设计，不仅继承了Spring框架原有的优秀特性，而且还通过简化配置来进一步简化了Spring应用的整个搭建和开发过程。另外SpringBoot通过集成大量的框架使得依赖包的版本冲突，以及引用的不稳定性等问题得到了很好的解决。

接下来我们使用Spring Boot 集成Redis
怎么配置Redis 可查看此篇博客 https://blog.csdn.net/weixin_53284329/article/details/112275460

首先第一步我们在pom 文件中加入所需要的依赖:

<dependencies>
	<!-- spring boot 缓存 -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-cache</artifactId>
		</dependency>
		<!-- 集成redis -->
		<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <!-- web --> 
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
		<!-- Spring Boot -->
		<dependency>
			<groupId>org.mybatis.spring.boot</groupId>
			<artifactId>mybatis-spring-boot-starter</artifactId>
			<version>2.1.4</version>
		</dependency>
		<!-- 热部署 -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-devtools</artifactId>
			<scope>runtime</scope>
			<optional>true</optional>
		</dependency>
		<!-- MySQL -->
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<scope>runtime</scope>
		</dependency>
		<!-- get/set -->
		<dependency>
			<groupId>org.projectlombok</groupId>
			<artifactId>lombok</artifactId>
			<optional>true</optional>
		</dependency>
		<!-- 可不加 -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
	</dependencies>

然后写配置


spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/sys?serverTimezone=UTC&nullCatalogMeansCurrent=true
spring.datasource.username=root
spring.datasource.password=123456

mybatis.type-aliases-package=com.example.domain
mybatis.mapper-locations=classpath:mapper/*.xml

logging.level.com.example.dao=debug

#可加可不加
spring.cache.type=redis

## Redis 配置
## Redis数据库索引（默认为0）
spring.redis.database=0
## Redis服务器地址
spring.redis.host=127.0.0.1
## Redis服务器连接端口
spring.redis.port=6379
## Redis服务器连接密码（默认为空）
spring.redis.password=
## 连接池最大连接数（使用负值表示没有限制）
spring.redis.pool.max-active=8
## 连接池最大阻塞等待时间（使用负值表示没有限制）
spring.redis.pool.max-wait=-1
## 连接池中的最大空闲连接
spring.redis.pool.max-idle=8
## 连接池中的最小空闲连接
spring.redis.pool.min-idle=0
## 连接超时时间（毫秒）
spring.redis.timeout=0

实体类：

package com.example.domain;

import java.io.Serializable;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class User implements Serializable{
	private Integer id;
	private String username;
	private String password;
}

下面需要一个Redis配置类如下：

package com.example.config;

import java.net.UnknownHostException;

import java.time.Duration;

import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import com.fasterxml.jackson.databind.ObjectMapper;

import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.annotation.JsonAutoDetect;


@Configuration
@EnableCaching // 开启注解式缓存
public class RedisConfig {

	@Bean
	public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory)
			throws UnknownHostException {
			//创建一个redis操作模板
			RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
			//设置一个工厂
			redisTemplate.setConnectionFactory(redisConnectionFactory);
			//json的序列化器
			Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
			redisTemplate.setDefaultSerializer(jackson2JsonRedisSerializer);
			//返回redis操作模板
		return redisTemplate;

	}

	/**
	 * 缓存管理器，将默认的缓存管理器设置成自定义的缓存管理器
	 * @param factory
	 * @return
	 */
	@Bean
	public CacheManager cacheManager(RedisConnectionFactory factory) {
		RedisSerializer<String> redisSerializer = new StringRedisSerializer();
        Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);

        //解决查询缓存转换异常的问题
        ObjectMapper om = new ObjectMapper();
        //序列列化所有属性PropertyAccessor.ALL
        //所有的属性包含私有的等 JsonAutoDetect.Visibility.ANY
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);

        // 配置序列化（解决乱码的问题）,过期时间30秒
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(Duration.ofSeconds(30))
                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(redisSerializer))
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(jackson2JsonRedisSerializer))
                .disableCachingNullValues();

        RedisCacheManager cacheManager = RedisCacheManager.builder(factory)
                .cacheDefaults(config)
                .build();
        return cacheManager;
	}
}

控制器：

package com.example.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import com.example.domain.User;
import com.example.service.UserService;

@RestController
@RequestMapping("/user")
public class UserController {
	@Autowired
	private UserService userservice;
	
	
	@RequestMapping("/findUserByid")
	public User findUserByid(int id) {
		return userservice.findUserByid(id);

	}
}

Service:

package com.example.service;

import com.example.domain.User;

public interface UserService {
	
	User findUserByid(int id);
}


package com.example.serviceImpl;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.example.dao.UserMapper;
import com.example.domain.User;
import com.example.service.UserService;
@Service
@Transactional
public class UserServiceImpl implements UserService{
	
	
	@Autowired
	private UserMapper usermapper;
	
	@Override
	@Cacheable(value = "user",key = "#id",unless = "#result == null")
	public User findUserByid(int id) {
		return usermapper.findUserByid(id);
	}

}

dao 层：

package com.example.dao;

import com.example.domain.User;

public interface UserMapper {
	User findUserByid(int id);
}


<?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.example.dao.UserMapper">
	<select id="findUserByid" resultType="user"  parameterType="int">
		select * from sys_user where id = #{id}
	</select>
</mapper>

接下来我们来测试一下：
在这里插入图片描述
看一下sql 执行情况：
在这里插入图片描述
再看一下redis
在这里插入图片描述
东西已经存进来了，我们再刷新一下页面，可以看到
有点模糊，将就一点
我们可以看到第二次执行查询的时候是没有sql 执行情况的

写了查询，我们把修改和删除也写一下

controller :

package com.example.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import com.example.domain.User;
import com.example.service.UserService;

@RestController
@RequestMapping("/user")
public class UserController {
	@Autowired
	private UserService userservice;
	
	
	@RequestMapping("/findUserByid")
	public User findUserByid(int id) {
		return userservice.findUserByid(id);

	}

	@RequestMapping("/update")
	public int update(User user) {
		return userservice.update(user)==null?0:1;
	}
	
	@RequestMapping("/delete")
	public int delete(int id) {
		return userservice.deleteStudent(id);
	}
}

Service:

package com.example.service;

import com.example.domain.User;

public interface UserService {
	
	User findUserByid(int id);

	Object update(User user);

	int deleteStudent(int id);
}

package com.example.serviceImpl;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.CachePut;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.example.dao.UserMapper;
import com.example.domain.User;
import com.example.service.UserService;
@Service
@Transactional
public class UserServiceImpl implements UserService{
	
	
	@Autowired
	private UserMapper usermapper;
	
	@Override
	@Cacheable(value = "user",key = "#id",unless = "#result == null")
	public User findUserByid(int id) {
		return usermapper.findUserByid(id);
	}
	
	@Override
	@CachePut(value = "user",key = "#user.id",unless="#result == null")
	public Object update(User user) {
		int row=usermapper.update(user);
		if(row==0) {
			return null;
		}else {
			return this.findUserByid(user.getId());
		}
	}

	@Override
    @CacheEvict(value = "user", key = "#id")//删除数据之后，清除缓存
	public int deleteStudent(int id) {
		// TODO Auto-generated method stub
		return usermapper.deleteUserById(id);
	}

}

Dao:

package com.example.dao;

import com.example.domain.User;

public interface UserMapper {
	User findUserByid(int id);

	int update(User user);

	int deleteUserById(int id);
}


<?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.example.dao.UserMapper">
	<select id="findUserByid" resultType="user"  parameterType="int">
		select * from sys_user where id = #{id}
	</select>
	
	<update id="update" parameterType="user">
		update sys_user
		<trim prefix="set" suffixOverrides=",">
		  <if test="username!=null and username!=''">username=#{username},</if>
		  <if test="password!=null and password!=''">password=#{password},</if>
		 </trim>
		 where id=#{id}
	</update>
	
	<delete id="deleteUserById" parameterType="int">
		delete from sys_user where id=#{id}
	</delete>
</mapper>

效果大家就自己试吧

吴彦祖_Java
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Python 操作Redis
Charge8的博客
03-03 7074
Python 操作Redis
Python连接Redis（简单连接、连接池连接、存取数据示例）
最新发布
分享式获得也是一种学习的态度
06-14 2160
每个人都有惰性，但不断学习是好好生活的根本，共勉！
python redis 操作_python操作redis
weixin_39940714的博客
11-28 147
一redis 简介redis是一个key-value存储系统。和Memcached类似，它支持存储的value类型相对更多，包括string(字符串)、list(链表)、set(集合)、zset(sorted set --有序集合)和hash（哈希类型）。这些数据类型都支持push/pop、add/remove及取交集并集和差集及更丰富的操作，而且这些操作都是原子性的。在此基础上，redis支持各...
pycharm如何 连接redis数据库
qq_42467563的博客
11-08 2995
import redis # 创建Redis对象 # decode_responses：返回值是否解码 r = redis.Redis(host='localhost', port=6379, db=1, decode_responses=True) # 终端的命在代码中都是函数 r.set('name', 'xiaoming') print(r.get('name')) 返回：xi...
Python 链接redis
Lastvil的博客
09-19 324
Redis（Remote Dictionary Server ，远程字典服务） 是一个使用ANSI C编写的开源、支持网络、基于内存、可选持久性的键值对存储数据库，是NoSQL数据库。redis的出现主要是为了替代早期的Memcache缓存系统的。map内存型(数据存放在内存中)的非关系型(nosql)key-value(键值存储)数据库，
Spring Boot集成redis
weixin_44914784的博客
04-14 180
redis简介 redis介绍 (1)redis是一个key-vlue 存储系统。和Memcached 类似，它支持存储的value 类型相对更多，包括String(字符串)，list（链表），hash（散表），set（集合），zset(有序集合)，这些数据类型都支持 puush/pop，add/remove及取交集并集和差集及更丰富的操作，而且这些操作都是原子性的。 (2)在此基础上redis支...
spring boot 集成redis
zzdcomeon的专栏
09-18 133
1、注入依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> ...
spring boot 集成redis代码
10-26
综上所述，Spring Boot集成Redis主要涉及添加依赖、配置连接信息、注入RedisTemplate以及根据业务需求进行操作。通过这种方式，我们可以充分利用Redis的高效特性，为应用程序提供快速的数据访问和缓存功能。在实际...
Spring boot集成redis lettuce代码实例
08-19
Spring Boot集成Redis Lettuce代码实例 Spring Boot是一款流行的Java框架，用于快速构建基于Spring的应用程序。Redis是一个开源的、基于内存的数据结构存储系统，可以作为数据库、缓存和消息代理等使用。Lettuce是...
Spring Boot集成Redis实战操作功能
08-26
Spring Boot集成Redis实战操作功能详解 一、 Redis简介 Redis是一个高性能的key-value数据库，支持存储的value类型很多，包括string、list、set、zset和hash等等。Redis具有很多优点，如异常快、支持丰富的数据...
Spring Boot集成Redis实现缓存机制(从零开始学Spring Boot)
08-30
Spring Boot集成Redis实现缓存机制是一项常见的优化技术，它能够提高数据访问速度，减少数据库压力。Redis是一款高性能的键值存储系统，适用于处理大量数据的快速读取和写入操作，特别适合用作缓存解决方案。 集成...
Spring boot 集成 redis （解决String类型乱码） 缓存用redis
06-22
本文将详细讲解如何在Spring Boot项目中集成Redis，并解决String类型的乱码问题。 首先，我们需要在项目中引入Redis的相关依赖。在`pom.xml`（如果你使用的是Maven）或`build.gradle`（如果你使用的是Gradle）文件...
使用 Python 操作 Redis 数据库
很酷的站长的博客
01-30 2752
redis 是 python 访问 Redis 数据库的模块。在第 5 行，使用方法 hdel(‘person’, ‘gender’) 删除哈希表 ‘person’ 中的键 ‘gender’在第 6 行，redis 数据库返回的是字节对象 b’ZhangSan’，而不是字符串 ‘ZhangSan’在第 1 行，使用方法 sismember(‘set’, ‘b’) 检查集合 ‘set’ 是否包含 ‘b’在第 3 行，使用方法 sismember(‘set’, ‘d’) 检查集合 ‘set’ 是否包含 ‘d’
Python常用模块 之 redis：连接和操作redis数据库
热门推荐
孤寒者的博客
08-27 6万+
python操作Redis数据库—redis库（可直接使用的模板通用操作）
Python操作Redis方法
专注于Python编程技术的分享与交流，致力于帮助开发者提升编程技能，解决实际问题，探索Python的无限可能。
06-21 1万+
Redis（Remote Dictionary Server）是一个高性能的键值存储数据库，它支持各种数据结构，如字符串、哈希表、列表、集合和有序集合。Redis 通常被用作缓存、消息队列、实时统计等场景。本教程介绍了使用 Python 操作 Redis 的基本操作，包括键值对、哈希表、列表、集合、有序集合和发布/订阅等数据操作，以及事务操作、过期时间、持久化、分布式锁、缓存和性能优化等高级功能和用例。
python 连接redis
菜鸟吴de博客
04-17 617
通常情况下, 当我们需要做redis操作时, 会创建一个连接, 并基于这个连接进行redis操作, 操作完成后, 释放连接,一般情况下, 这是没问题的, 但当并发量比较高的时候, 频繁的连接创建和释放对性能会有较高的影响。于是, 连接池就发挥作用了。连接池的原理是, 通过预先创建多个连接, 当进行redis操作时, 直接获取已经创建的连接进行操作, 而且操作完成后, 不会释放, 用于后续的其他redis操作。这样就达到了避免频繁的redis连接创建和释放的目的, 从而提高性能。
【Redis—12】Redis发布和订阅（Python实现）
我是一只程序⚪的技术交流平台
04-13 1056
一、什么是发布订阅 在软件架构中，发布订阅是一种消息范式，消息的发送者（称为发布者）不会将消息直接发送给特定的接收者（称为订阅者）。而是将发布的消息分为不同的类别，无需了解哪些订阅者（如果有的话）可能存在。同样的，订阅者可以表达对一个或多个类别的兴趣，只接收感兴趣的消息，无需了解哪些发布者（如果有的话）存在。 Redis 发布订阅(pub/sub)是一种消息通信模式：发送者(publish)发...
python连接redis的三种方式
qq_43022682的博客
01-27 1551
python连接redis的三种方式。
tomcat 配置域名
吴彦祖的博客
06-13 2894
首先找到conf下面的server.xml 把Connector 标签中的端口改成80 然后把添加一个Host name为域名appBase为路径 如下 Engine 标签也是 最后在C盘 windows\System32\drivers\etc 下面的hosts添加下面这行 127.0.0.1 www.test.com重新启动tomcat 就可以...
spring boot集成redis
06-28
Spring Boot可以很方便地集成Redis，只需要在pom.xml中添加相应的依赖，配置Redis连接信息，就可以使用RedisTemplate等工具类来操作...以上就是Spring Boot集成Redis的基本步骤，具体使用可以根据实际需求进行调整。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

吴彦祖_Java

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值