ssm实现redis缓存

最新推荐文章于 2023-05-26 14:24:56 发布
最新推荐文章于 2023-05-26 14:24:56 发布
阅读量335 收藏 1
点赞数
文章标签： ssm redis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45068048/article/details/111149613
版权

1.redis 的xml文件配置（aop切面的方式）

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	   xmlns:aop="http://www.springframework.org/schema/aop"
	   xmlns:p="http://www.springframework.org/schema/p"
	   xmlns:tx="http://www.springframework.org/schema/tx"
	   xmlns:context="http://www.springframework.org/schema/context"
	   xmlns:mvc="http://www.springframework.org/schema/mvc"
	   xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
                http://www.springframework.org/schema/aop 
                http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
                http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
                http://www.springframework.org/schema/context
                http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/mvc 
                http://www.springframework.org/schema/mvc/spring-mvc.xsd">

<!--Redis连接池-->
	<bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">
		<property name="maxIdle" value="${redis.maxIdle}"/>
		<property name="maxWaitMillis" value="${redis.maxWait}"/>
	</bean>
<!--	创建Redis连接工厂-->
	<bean id="jeditConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
		<property name="poolConfig" ref="poolConfig"/>
		<property name="hostName" value="${redis.host}"/>
		<property name="port" value="${redis.port}"/>
		<property name="timeout" value="${redis.timeout}"/>
	</bean>
<!--	如果操作对象，是复杂类型 用 jdkSerializationRedisSerializer  将对象转化成数组  -->
	<bean id="jdkSerializationRedisSerializer" class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer">
		
	</bean>
<!--操作字符串用 stringReadisSerializer-->
	<bean id="stringReadisSerializer" class="org.springframework.data.redis.serializer.StringRedisSerializer">
	</bean>
	<!--	创建一个RedisTemplate组件-->
	<bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
		<property name="connectionFactory" ref="jeditConnectionFactory"/>
<!--		指定key和value的序列化策-->
		<property name="keySerializer" ref="stringReadisSerializer"/>
		<property name="valueSerializer" ref="jdkSerializationRedisSerializer"/>
		
	</bean>

<bean id="redisUtil" class="com.hfxt.controller.redis.RedisUtil">
	<property name="redisTemplate" ref="redisTemplate"/>
</bean>
<!--	通过aop实现缓存拦截器的配置-->
	<bean id="methodInterceptor" class="com.hfxt.controller.redis.MethodCacheInterceptor">
		<property name="redisUtil" ref="redisUtil"/>
		<property name="defaultCacheExpireTime" value="360000"/>
		<property name="targetNamesList">
			<list>
				<value></value>
			</list>
		</property>
		<property name="methodNamesList">
			<list>
				<value></value>
			</list>
		</property>
	</bean>
<aop:config>
<!--	定义切点-->
	<aop:pointcut id="pointcut" expression="execution(* com.hfxt.service.*.*(..)) "/>
<!--      植入拦截器设置-->
	<aop:advisor advice-ref="methodInterceptor" pointcut-ref="pointcut"/>
</aop:config>

（普通方式）

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	   xmlns:aop="http://www.springframework.org/schema/aop"
	   xmlns:p="http://www.springframework.org/schema/p"
	   xmlns:tx="http://www.springframework.org/schema/tx"
	   xmlns:context="http://www.springframework.org/schema/context"
	   xmlns:mvc="http://www.springframework.org/schema/mvc"
	   xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
                http://www.springframework.org/schema/aop 
                http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
                http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
                http://www.springframework.org/schema/context
                http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/mvc 
                http://www.springframework.org/schema/mvc/spring-mvc.xsd">

<!--Redis连接池-->
	<bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">
		<property name="maxIdle" value="${redis.maxIdle}"/>
		<property name="maxWaitMillis" value="${redis.maxWait}"/>
	</bean>
<!--	创建Redis连接工厂-->
	<bean id="jeditConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
		<property name="poolConfig" ref="poolConfig"/>
		<property name="hostName" value="${redis.host}"/>
		<property name="port" value="${redis.port}"/>
		<property name="timeout" value="${redis.timeout}"/>
	</bean>
<!--	创建一个RedisTemplate组件-->
	<bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
		<property name="connectionFactory" ref="jeditConnectionFactory"/>
	</bean>
<bean id="redisUtil" class="com.hfxt.controller.redis.RedisUtil">
	<property name="redisTemplate" ref="redisTemplate"/>
</bean>
</beans>

2.工具类
2.1redisUtil

package com.hfxt.controller.redis;

import java.io.Serializable;
import java.util.Set;
import java.util.concurrent.TimeUnit;

import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;

/**
 * Redis工具类
 */
public class RedisUtil {
    private RedisTemplate<Serializable, Object> redisTemplate;

    /**
     * 批量删除对应的value
     *
     * @param keys
     */
    public void remove(final String... keys) {
        for (String key : keys) {
            remove(key);
        }
    }

    /**
     * 批量删除key
     *
     * @param pattern
     */
    public void removePattern(final String pattern) {
        Set<Serializable> keys = redisTemplate.keys(pattern);
        if (keys.size() > 0)
            redisTemplate.delete(keys);
    }

    /**
     * 删除对应的value
     *
     * @param key
     */
    public void remove(final String key) {
        if (exists(key)) {
            redisTemplate.delete(key);
        }
    }

    /**
     * 判断缓存中是否有对应的value
     *
     * @param key
     * @return
     */
    public boolean exists(final String key) {
        return redisTemplate.hasKey(key);
    }

    /**
     * 读取缓存
     *
     * @param key
     * @return
     */
    public Object get(final String key) {
        Object result = null;
        ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
        result = operations.get(key);
        return result;
    }

    /**
     * 写入缓存
     *
     * @param key
     * @param value
     * @return
     */
    public boolean set(final String key, Object value) {
        boolean result = false;
        try {
            ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
            operations.set(key, value);
            result = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 写入缓存
     *
     * @param key
     * @param value
     * @return
     */
    public boolean set(final String key, Object value, Long expireTime) {
        boolean result = false;
        try {
            ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
            operations.set(key, value);
            redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
            result = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }

    public void setRedisTemplate(RedisTemplate<Serializable, Object> redisTemplate) {
        this.redisTemplate = redisTemplate;
    }
}

2.2MethodCacheInterceptor

package com.hfxt.controller.redis;

import java.util.List;


import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;

public class MethodCacheInterceptor implements MethodInterceptor {
    private RedisUtil redisUtil;
    private List<String> targetNamesList; // 禁用缓存的类名列表
    private List<String> methodNamesList; // 禁用缓存的方法列表
    private String defaultCacheExpireTime; // 缓存默认的过期时间

    public Object invoke(MethodInvocation invocation) throws Throwable {
        Object value = null;

        String targetName = invocation.getThis().getClass().getName();
        String methodName = invocation.getMethod().getName();
        if (!isAddCache(targetName, methodName)) {
            // 跳过缓存返回结果
            return invocation.proceed();
        }
        Object[] arguments = invocation.getArguments();
        String key = getCacheKey(targetName, methodName, arguments);
        try {
            // 判断是否有缓存
            if (redisUtil.exists(key)) {
                return redisUtil.get(key);
            }
            // 写入缓存
            value = invocation.proceed();
            if (value != null) {
                final String tkey = key;
                final Object tvalue = value;
                new Thread(new Runnable() {
                    public void run() {
                        redisUtil.set(tkey, tvalue, Long.parseLong(defaultCacheExpireTime));
                    }
                }).start();
            }
        } catch (Exception e) {
            e.printStackTrace();
            if (value == null) {
                return invocation.proceed();
            }
        }
        return value;
    }

    /**
     * 是否加入缓存
     *
     * @return
     */
    private boolean isAddCache(String targetName, String methodName) {
        boolean flag = true;
        if (targetNamesList.contains(targetName)
                || methodNamesList.contains(methodName) || targetName.contains("$$EnhancerBySpringCGLIB$$")) {
            flag = false;
        }
        return flag;
    }

    /**
     * 创建缓存key
     *
     * @param targetName
     * @param methodName
     * @param arguments
     */
    private String getCacheKey(String targetName, String methodName, Object[] arguments) {
        StringBuffer sbu = new StringBuffer();
        sbu.append(targetName).append("_").append(methodName);
        if ((arguments != null) && (arguments.length != 0)) {
            for (int i = 0; i < arguments.length; i++) {
                sbu.append("_").append(arguments[i]);
            }
        }
        return sbu.toString();
    }

    public void setRedisUtil(RedisUtil redisUtil) {
        this.redisUtil = redisUtil;
    }

    public void setTargetNamesList(List<String> targetNamesList) {
        this.targetNamesList = targetNamesList;
    }

    public void setMethodNamesList(List<String> methodNamesList) {
        this.methodNamesList = methodNamesList;
    }

    public void setDefaultCacheExpireTime(String defaultCacheExpireTime) {
        this.defaultCacheExpireTime = defaultCacheExpireTime;
    }
}

3.controller 层处理

package com.hfxt.controller;

import com.hfxt.controller.redis.RedisUtil;
import com.hfxt.entity.FilmInfo;
import org.springframework.context.annotation.Conditional;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

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

@Controller
@RequestMapping("/shop")
public class ShopController extends BaseController {
    @Resource
    protected RedisTemplate redisTemplate;
    @RequestMapping("/shop.html")
    public String shop()
    {
        Object count =redisTemplate.boundValueOps("name").get();
        System.out.println(count);
        if (count == null) {
            redisTemplate.boundValueOps("name").set("zhangsan");
        }else {
            System.out.println("从redis中获取");
            System.out.println(count);
        }
        return "shop";
    }
    @Resource
    protected RedisUtil redisUtil;
    @RequestMapping("/shop2.html")
    public String shop2()
    {
        Object count =redisUtil.get("name");
        System.out.println(count);
        if (count == null) {
           // redisTemplate.boundValueOps("name").set("zhangsan");
            redisUtil.set("name","lisi");
        }else {
            System.out.println("从redis中获取");
            System.out.println(count);
        }
        return "shop";
    }
    @RequestMapping("/shop3.html")
    public String shop3 ()
    {
        List<FilmInfo> list= (List<FilmInfo>) redisUtil.get("infolist");
        if (list == null) {
           list=filmInfoService.getFilmInfosall();
           redisUtil.set("infolist",list);
        }else {
            System.out.println("从redis中获取");
        }
        return "shop";
    }
}

3.contoller 层进行缓存

package com.hfxt.controller;

import com.hfxt.controller.redis.RedisUtil;
import com.hfxt.entity.FilmInfo;
import org.springframework.context.annotation.Conditional;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

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

@Controller
@RequestMapping("/shop")
public class ShopController extends BaseController {
    @Resource
    protected RedisTemplate redisTemplate;
    @RequestMapping("/shop.html")
    public String shop()
    {
        Object count =redisTemplate.boundValueOps("name").get();
        System.out.println(count);
        if (count == null) {
            redisTemplate.boundValueOps("name").set("zhangsan");
        }else {
            System.out.println("从redis中获取");
            System.out.println(count);
        }
        return "shop";
    }
    @Resource
    protected RedisUtil redisUtil;
    @RequestMapping("/shop2.html")
    public String shop2()
    {
        Object count =redisUtil.get("name");
        System.out.println(count);
        if (count == null) {
           // redisTemplate.boundValueOps("name").set("zhangsan");
            redisUtil.set("name","lisi");
        }else {
            System.out.println("从redis中获取");
            System.out.println(count);
        }
        return "shop";
    }
    @RequestMapping("/shop3.html")
    public String shop3 ()
    {
        List<FilmInfo> list= (List<FilmInfo>) redisUtil.get("infolist");
        if (list == null) {
           list=filmInfoService.getFilmInfosall();
           redisUtil.set("infolist",list);
        }else {
            System.out.println("从redis中获取");
        }
        return "shop";
    }
}
LJ君
关注
SSM集成Redis做缓存
xingkong_00123的博客
10-20 1661
基于 srping srping MVC Mybatis maven整合Redis做换缓存使用的
SSM整合Redis缓存Demo
12-25
SSM整合Redis缓存Demo是基于Spring、SpringMVC和MyBatis的高效开发框架，进一步结合了Redis作为缓存技术的示例项目。这个Demo适用于开发者在MyEclipse或Eclipse环境中导入并配置数据库，只要本地已安装Redis服务器，...
SSM项目-redis缓存策略和配置实现
07-06
实现redis缓存策略和Spring集成redis配置 1.1 Redis是一个key-value存储系统，支持多种存储结构，如String,Hash,list,zset等； 1.2 Redis采用内存中数据集的形式，因此读写性能优异； 1.3 Redis支持数据持久化，支持AOF和RDB两种持久化方式； 1.4 Redis类似mysql可以进行主从复制，可以实现读写分离； 1.5 Redis由于是内存中数据集存储的，故对内存的要求较高，对海量数据处理有限制； 1.6 Redis主从复制时，由于宕机或其他情况一起，导致最后部分数据可能丢失
SSM框架下的redis缓存
weixin_34292924的博客
07-19 155
基本SSM框架搭建：http://www.cnblogs.com/fuchuanzhipan1209/p/6274358.html 配置文件部分： 第一步：加入jar包 pom.xml <!-- spring-redis实现 --> <dependency> <groupId>org.springframe...
ssm框架整合redis实现缓存
10-14
此应用为我最近探索的ssm框架整合范例以及redis 整合 ssm的demo, 给大家作为参考。
ssm+redis 实现session共享
03-18
SSM是指Spring、Spring MVC和MyBatis这三大Java Web开发框架的组合，而Redis则是一种高性能的键值存储数据库，常被用于缓存和分布式数据共享。 首先，让我们深入理解一下SSM框架。Spring是一个全面的后端应用程序...
ssm开发使用redis作为缓存的使用步骤
08-26
例如，在查询数据库时，可以先从Redis缓存中获取数据，如果不存在，则从数据库中查询然后存储到Redis缓存中。这样可以减少数据库的查询次数，提高系统的响应速度。 Redis缓存的优点 使用Redis缓存有以下几个优点：...
基于SSM框架的商品实时秒杀系统的设计与实现.rar(论文设计+项目源码) 采用SSM+redis缓存+rabbitMS消息队列
03-22
2.4 redis缓存数据库 9 2.5 RabbitMQ消息队列 10 3 需求分析与设计 10 3.1 可行性分析 10 3.1.1技术可行性 10 3.1.2 经济可行性 11 3.1.3操作可行性 11 3.2 系统功能分析 11 3.3 系统功能结构图 11 3.4 系统流程图 ...
在ssm项目中使用redis缓存查询数据的方法
09-09
在SSM（Spring、SpringMVC、MyBatis）项目中使用Redis缓存查询数据，是一种常见的优化策略，旨在提高应用程序的性能和响应速度。Redis是一个高性能的键值存储系统，常被用作缓存解决方案，因为它支持多种数据结构如...
SSM整合Redis做缓存
10-20
SSM架构集成Redis做缓存,里面是一个完整的框架可以运行，sql文件在里面直接创建数据库
Java+redis缓存工具类（SSM）
04-28
直接下载可以运行 就是自己需要创建数据库 很简单 参考实体就行 里面有redis的工具类 可以进行参考
SpringBoot搭建SSM整合Redis缓存数据（菜鸟学习）
Java初级工程师
02-12 1580
菜鸟学习SpringBoot整合Redis缓存数据 前言 自学多时，写一个demo做个总结。 从建项目开始，比较简单的实现springboot+redis缓存，供初学者参考，更快的理解redis缓存。 环境 win10 Idea2018.1.2x64 jdk1.8.0_131 mysql5.7.21 Redis3.2.100 RedisDesktopManager0.8.8.384(redis桌面...
redis学习-02-ssm框架整合redis缓存
sofency'Blog
02-10 215
redis主要是用来做缓存,以此来减轻数据库访问的压力，我们在上篇博客中就已经介绍了redis的读写访问速度非常块，而且redis支持高并发的访问。而如果不做缓存的话，面对庞大用户群体的访问数据库的压力会非常大。因此出现了redis这个中间件缓存。 那么如何使用redis哪，主要有以下步骤 用户要访问数据库信息之前，首先会在redis缓存中查询，是否有所要查询的数据。 如果之前有其他的用户查...
java-ssm框架整合Redis缓存服务器-详解
weixin_44232093的博客
02-01 1059
我们目前的系统已经实现了广告后台管理和广告前台展示，但是对于首页每天有大量的人访问，对数据库造成很大的访问压力，甚至是瘫痪。那如何解决呢？我们通常的做法有两种：一种是数据缓存、一种是网页静态化 1. Redis介绍 1.1 Redis redis 是一款开源的 Key-Value 数据库，运行在内存中，由 ANSIC 编写。企业开发通常采用 Redis 来实现缓存。同类的产品还有 memcac...
SSM 如何使用 Redis 实现缓存？
最新发布
IT徐师兄
05-26 2465
本文介绍了如何使用 SSM框架和 Redis 实现数据缓存。首先介绍了 Redis 的常用数据结构，包括字符串、哈希、列表、集合和有序集合等；然后介绍了 Redis 的 Java 客户端 Jedis 的使用方法，包括连接池和连接的创建、字符串、哈希、列表、集合和有序集合等操作；最后介绍了在 SSM 中使用 Redis 实现数据缓存的方法，包括依赖的引入、Redis 连接池的配置、Redis 操作的封装和在 Service 中使用 Redis 缓存数据。
SSM中Redis添加缓存
蔡文彬的博客
04-15 482
需求是：查询文章时，先查询Redis中是否有文章，有则直接返回，没有则查询数据库，然后添加到Redis. 先启动Reids 添加Reids依赖 <!--redis--> <!-- https://mvnrepository.com/artifact/redis.clients/jedis --> <dependency> <group...
SSM整合Redis实现Mybatis二级缓存
5. 配置MyBatis：在MyBatis的配置文件中启用二级缓存，并指定使用Redis作为缓存实现。还需要创建一个自定义的Cache实现，集成RedisTemplate，处理缓存的读写操作。 6. 编写Mapper配置：在每个需要使用二级缓存的...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值