ssm+redis 如何更简洁的利用自定义注解+AOP实现redis缓存

最新推荐文章于 2023-09-15 16:02:16 发布
最新推荐文章于 2023-09-15 16:02:16 发布
阅读量4.3k 收藏 13
点赞数 6
分类专栏： redis 文章标签： ssm redis

基于 ssm + maven + redis 使用自定义注解 利用aop基于AspectJ方式 实现redis缓存

　　如何能更简洁的利用aop实现redis缓存，话不多说，上demo

　　需求：
　　　　数据查询时每次都需要从数据库查询数据，数据库压力很大，查询速度慢，
　　　　因此设置缓存层，查询数据时先从redis中查询，如果查询不到，则到数据库中查询
　　　　然后将数据库中查询的数据放到redis中一份，下次查询时就能直接从redis中查到，不需要查询数据库了

　　实现过程：

　　　　　　先搭建ssm的架子，引入redis，编写redis 缓存方法 RedisCache.java以及序列化用到的工具类 


　　　　　　自定义注解 getCache 目的：
　　　　　　　　　　　　被这个注解标记的方法实现aop
　　　　　　　　　　　　防止redis key重复

　　　　　编写切面
　　　　　　@Aspect

　　　　　　　　@Pointcut("@annotation(com.spring_redis.cache.GetCache)")
　　　　　　　　切入点为自定义注解 即每个被该注解标记的方法实现通知

　　　　　　　　@Around("getCache()")
　　　　　　　　利用环绕通知 
　　　　　　　　　　过程： 查询时，先查询redis 如果存在key-value，则返回不查询
　　　　　　　　　　如果不存在，则查询数据库，之后将查询到的数据存入到redis缓存中
　　　　　　　　　　redis key格式：为了防止key冲突，创建的key格式为：

　　　　　　　　　　包名.类名.方法名.参数类型.参数值"，类似 "your.package.SomeService.getById(integer).123"

目录结构:


maven依赖：

<properties>
            <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
             <!-- spring版本号 -->
            <spring.version>4.0.6.RELEASE</spring.version>
            <!-- mybatis版本号 -->
            <mybatis.version>3.2.7</mybatis.version>
        </properties>
  <dependencies>
  
          <!-- spring核心包 -->
        <!-- springframe start -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-oxm</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.springframework/spring-context-support -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
            <version>4.0.6.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <exclusions>
                <exclusion>
                    <groupId>commons-logging</groupId>
                    <artifactId>commons-logging</artifactId>
                </exclusion>
            </exclusions>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!-- springframe end -->

          <!-- aop注解  -->
          
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjrt</artifactId>
            <version>1.6.12</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.6.12</version>
        </dependency>
        <dependency>
            <groupId>cglib</groupId>
            <artifactId>cglib</artifactId>
            <version>2.2</version>
        </dependency>
          
          <!-- mysql驱动包 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.31</version>
        </dependency>
          
          <!-- dbcp2连接池 -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-dbcp2</artifactId>
            <version>2.0.1</version>
        </dependency>

        <!-- json数据 -->
        <dependency>
            <groupId>org.codehaus.jackson</groupId>
            <artifactId>jackson-mapper-asl</artifactId>
            <version>1.9.13</version>
        </dependency>

          <!-- mybatis核心包 -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>${mybatis.version}</version>
        </dependency>
        <!-- mybatis/spring包 -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>1.2.2</version>
        </dependency>
  
          <dependency>  
            <groupId>org.springframework.data</groupId>  
            <artifactId>spring-data-redis</artifactId>  
            <version>1.6.1.RELEASE</version>  
        </dependency>  
         <dependency>  
            <groupId>redis.clients</groupId>  
            <artifactId>jedis</artifactId>  
            <version>2.7.3</version>  
        </dependency> 
  
          <!-- servlet-api -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.0.1</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>jsp-api</artifactId>
            <version>2.2</version>
            <scope>provided</scope>
        </dependency>
        <!-- servlet-api end -->
  
          <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>
  </dependencies>

这里只给出redis 的相关配置

　　　　在applicationContext-dao.xml　里添加

<?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:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:util="http://www.springframework.org/schema/util"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context-3.2.xsd
    http://www.springframework.org/schema/tx
    http://www.springframework.org/schema/tx/spring-tx-3.2.xsd
    http://www.springframework.org/schema/aop
    http://www.springframework.org/schema/aop/spring-aop-3.2.xsd
    http://www.springframework.org/schema/util 
    http://www.springframework.org/schema/util/spring-util-3.2.xsd">
        
        
        <!-- 加载db.properties文件中的内容，db.properties文件中key命名要有一定的特殊规则 -->
        <context:property-placeholder location="classpath:properties/db.properties" />
        
        
        
        <!-- 配置数据源 ，dbcp -->
        
        <bean id="dataSource" class="org.apache.commons.dbcp2.BasicDataSource">
        <property name="driverClassName" value="${jdbc.driver}" />
        <property name="url" value="${jdbc.url}" />
        <property name="username" value="${jdbc.username}" />
        <property name="password" value="${jdbc.password}" />
        </bean>


        <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean"
        p:dataSource-ref="dataSource" p:configLocation="classpath:mybatis/sqlMapConfig.xml"
        ></bean>
              <!-- Redis和缓存配置开始 -->  
            <!-- jedis 配置 -->  
            <bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig" >  
                  <property name="maxIdle" value="100" />  
                  <property name="maxWaitMillis" value="1000" />  
                  <property name="testOnBorrow" value="true" />  
            </bean >  
            
            <!-- redis连接池 -->
                <bean id="jedisPool" class="redis.clients.jedis.JedisPool" destroy-method="close">
                    <constructor-arg name="poolConfig" ref="poolConfig"/>
                    <constructor-arg name="host" value="127.0.0.1"/>
                    <constructor-arg name="port" value="6379"/>
                </bean>

              <!-- redis服务器中心 -->  
            <bean id="connectionFactory"  class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory" >  
                  <property name="poolConfig" ref="poolConfig" />  
                  <property name="port" value="6379" />  
                  <property name="hostName" value="127.0.0.1" />  
                  <!-- <property name="password" value="${redis.password}" /> --> 
                  <property name="timeout" value="10000" ></property>  
            </bean >  
            <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate" >  
                  <property name="connectionFactory" ref="connectionFactory" />  
                  <property name="keySerializer" >  
                      <bean class="org.springframework.data.redis.serializer.StringRedisSerializer" />  
                  </property>  
                  <property name="valueSerializer" >  
                      <bean class="org.springframework.data.redis.serializer.StringRedisSerializer" />  
                  </property>  
            </bean > 
            
            
            
            
            
            <!-- cache配置 -->  
            <bean id="putCache" class="com.spring_redis.cache.PutCacheAOP" >  
                  <property name="redisTemplate" ref="redisTemplate" />
            </bean>  
            
            <!-- cache配置 -->  
             <bean id="getCache" class="com.spring_redis.cache.GetCacheAOP" >  
                   <property name="redisTemplate" ref="redisTemplate" />
             </bean>  
             
             <!-- Redis和缓存配置结束 -->
            
            <!-- mapper扫描器 -->
            <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
                <!-- 扫描包路径，如果需要扫描多个包，中间使用半角逗号隔开 -->
                <property name="basePackage" value="com.spring_redis.mapper"></property>
                <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
            </bean>
            
            <bean id="roomservice" class="com.spring_redis.service.impl.RoomServiceImpl" >  
                   
             </bean>  
            
</beans>

　springmvc.xml 

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:mvc="http://www.springframework.org/schema/mvc"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans-3.2.xsd 
        http://www.springframework.org/schema/mvc 
        http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd 
        http://www.springframework.org/schema/context 
        http://www.springframework.org/schema/context/spring-context-3.2.xsd 
        http://www.springframework.org/schema/aop 
        http://www.springframework.org/schema/aop/spring-aop-3.2.xsd 
        http://www.springframework.org/schema/tx
        http://www.springframework.org/schema/tx/spring-tx-3.2.xsd ">

    <aop:aspectj-autoproxy proxy-target-class="true"/>

    <!-- 可以扫描controller、service、... 这里让扫描controller，指定controller的包 com.ssm.controlle -->
    <context:component-scan base-package="com.spring_redis">
    </context:component-scan>
    <!-- 使用 mvc:annotation-driven代替上边注解映射器和注解适配器配置 mvc:annotation-driven默认加载很多的参数绑定方法 -->
    <mvc:annotation-driven />
    <!-- 视图解析器 解析jsp解析，默认使用jstl标签，classpath下的得有jstl的包 -->
    <bean
        class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!-- 配置jsp路径的前缀 <property name="prefix" value="/jsp/"/> -->
        <!-- 配置jsp路径的后缀 -->
        <property name="suffix" value=".jsp" />
    </bean>

    
</beans>

 <aop:aspectj-autoproxy proxy-target-class="true"/>  开启注解这个一定要写到springmvc.xml里，否则注解会不起作用

 

　　那重点开始了

　　创建自定义注解

/** 
 * 自定义注解,对于查询使用缓存的方法加入该注解 
 * @author Chenth 
 */  
@Retention(RetentionPolicy.RUNTIME)  
@Target({ElementType.METHOD})  
public @interface GetCache {  
    String name() default "";  
    String value() default "";  
}

被这个自定义注解所标记的方法将实现下面的切面

 

　　配置切面


package com.spring_redis.cache;

import java.io.Serializable;
import java.lang.reflect.Method;


import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;

import com.spring_redis.util.RedisCache;

@Component
@Aspect
public class GetCacheAOP  {  
      
    @Autowired
    private RedisTemplate<Serializable, Object> redisTemplate;
    
    private RedisCache redisCache = new RedisCache();
  
      
    @Pointcut("@annotation(com.spring_redis.cache.GetCache)")  
    public void getCache(){
        System.out.println("我是一个切入点");  
    }  
    
    /** 
     * 在所有标注@getCache的地方切入 
     * @param joinPoint 
     */
    @Around("getCache()")
    public Object beforeExec(ProceedingJoinPoint joinPoint){  
        
        
        //前置：到redis中查询缓存
        System.out.println("调用从redis中查询的方法...");
        
        //redis中key格式：    id
        String redisKey = getCacheKey(joinPoint);
        
        //获取从redis中查询到的对象
        Object objectFromRedis = redisCache.getDataFromRedis(redisKey);
        
        //如果查询到了
        if(null != objectFromRedis){
            System.out.println("从redis中查询到了数据...不需要查询数据库");
            return objectFromRedis;
        }
        
        System.out.println("没有从redis中查到数据...");
        
        //没有查到，那么查询数据库
        Object object = null;
        try {
            object = joinPoint.proceed();
        } catch (Throwable e) {
            
            e.printStackTrace();
        }
        
        System.out.println("从数据库中查询的数据...");
        
        //后置：将数据库中查询的数据放到redis中
        System.out.println("调用把数据库查询的数据存储到redis中的方法...");
        
        redisCache.setDataToRedis(redisKey, object);
        System.out.println("redis中的数据..."+object.toString());
        //将查询到的数据返回
        return object;
    }
    
    /**
     * 根据类名、方法名和参数值获取唯一的缓存键
     * @return 格式为 "包名.类名.方法名.参数类型.参数值"，类似 "your.package.SomeService.getById(int).123"
     */
   
    @SuppressWarnings("unused")
    private String getCacheKey(ProceedingJoinPoint joinPoint) {
    
    
        MethodSignature ms=(MethodSignature) joinPoint.getSignature();  
        Method method=ms.getMethod();  
        String ActionName = method.getAnnotation(GetCache.class).name();  
        String fieldList = method.getAnnotation(GetCache.class).value();  
        //System.out.println("签名是"+ms.toString());
        for (String field:fieldList.split(","))   
             ActionName +="."+field;
    
        //先获取目标方法参数
        String id = null;
        Object[] args = joinPoint.getArgs();
        if (args != null && args.length > 0) {
            id = String.valueOf(args[0]);
        }
        
        ActionName += "="+id;
        String redisKey = ms+"."+ActionName;
        return redisKey;
    }
    
    
    public void setRedisTemplate(  
            RedisTemplate<Serializable, Object> redisTemplate) {  
        this.redisTemplate = redisTemplate;  
    }
}

@Pointcut("@annotation(com.spring_redis.cache.GetCache)") 这个切入点的作用是
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　在所有标注@getCache的地方切入 
 @Around("getCache()")这里用的是后置通知，即查询之前先查询redis，如果有数据就返回数据，没有就穿透的数据库查询数据，之后再缓存到redis中

 

　　这里并没有太多的讲解配置ssm框架，可能后续会写关于spring+springmvc+mybatis的框架整合

　　编写mapper层,service层,controller层

　　mapper

/**
 * 
 * @author     cmy
 * @date     2016-10-22
 * @description 持久化
 */

public interface RoomMapper {

    @Insert("insert into room(roomName,address) values(#{roomName},#{addRess})")
    int insert(Room room);

    @Select("select * from room where id=#{id}")
    public Room selectByPrimaryKey(@Param("id")Integer id);

}
service 
/**
 * 
 * @author     cmy
 * @date     2016-10-22
 * @description test
 */
public interface RoomService {
    
    
    int insert(Room room)throws Exception;
    
    
    Room selectByPrimaryKey(Integer id)throws Exception;
    
}

// 实现
/**
 * @author         cmy
 * @date         2016-10-22
 * @description  test 实现
 */
public class RoomServiceImpl implements RoomService{

    @Autowired
    private RoomMapper mapper;
    
    @Override
    public int insert(Room room) throws Exception {
        
        return mapper.insert(room);
    }

    @Override
    public Room selectByPrimaryKey(Integer id) throws Exception {
        
        return mapper.selectByPrimaryKey(id);
    }

    
}

controller 

/**
 * 
 * @author     cmy
 * @date     2016-10-22
 * @description test controller
 */

@Controller
@RequestMapping("room")
public class RoomController {

    @Autowired
    private RoomService  roomService;
    
    @GetCache(name="room",value="id")
    @RequestMapping("selectByPrimaryKey")
    public @ResponseBody Object roomList(Integer id) throws Exception{  
        System.out.println("已查询到数据，准备缓存到redis...  "+roomService.selectByPrimaryKey(id).getRoomName());
        return roomService.selectByPrimaryKey(id);
    }
    

}

缓存要用到的工具类  RedisCache: 

public class RedisCache {
    
    @Autowired
    private JedisPool jedisPool = new JedisPool();
    

    //从redis缓存中查询，反序列化
    public Object getDataFromRedis(String redisKey){
        //查询
        Jedis jedis = jedisPool.getResource();
        byte[] result = jedis.get(redisKey.getBytes());
        
        //如果查询没有为空
        if(null == result){
            return null;
        }
        
        //查询到了，反序列化
        return SerializeUtil.unSerialize(result);
    }
    
    //将数据库中查询到的数据放入redis
    public void setDataToRedis(String redisKey, Object obj){
        
        //序列化
        byte[] bytes = SerializeUtil.serialize(obj);
        
        //存入redis
        Jedis jedis = jedisPool.getResource();
        String success = jedis.set(redisKey.getBytes(), bytes);
        
        if("OK".equals(success)){
            System.out.println("数据成功保存到redis...");
        }
    }
}

缓存要用到的序列化和反序列化工具 

/**
 * 
 * @Description: 序列化反序列化工具
 */
public class SerializeUtil {
    /**
     * 
     * 序列化
     */
    public static byte[] serialize(Object obj){
        
        ObjectOutputStream oos = null;
        ByteArrayOutputStream baos = null;
        
        try {
            //序列化
            baos = new ByteArrayOutputStream();
            oos = new ObjectOutputStream(baos);
            
            oos.writeObject(obj);
            byte[] byteArray = baos.toByteArray();
            return byteArray;
            
        } catch (IOException e) {
            e.printStackTrace();
        }    
        return null;
    }
    
    /**
     * 
     * 反序列化
     * @param bytes
     * @return
     */
    public static Object unSerialize(byte[] bytes){
        
        ByteArrayInputStream bais = null;
        
        try {
            //反序列化为对象
            bais = new ByteArrayInputStream(bytes);
            ObjectInputStream ois = new ObjectInputStream(bais);
            return ois.readObject();
            
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
}


以上就是利用aop+自定义注解实现 redis缓存的过程了

　　　　　　有不对之处，还望指出　欢迎留言

有参考到的文章：http://www.cnblogs.com/mrlinfeng/p/5857775.html

　　　　　　　　http://blog.csdn.net/chentian610/article/details/51012789



Alannew
关注
  • 6
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
[SSM] 元注解和自定义注解
浅夜
10-23 206
下面这些都是目前的项目中用到的注解，都属于较为常用的注解，后期有另外的我再补充 spring中的注解 @controller 用于标记在一个类上，使用它标记的类就是一个SpringMVC Controller 对象。声明为控制器，可返回jsp、html页面的名称并跳转到相应页面 备注：springMVC中，控制器就是一个其方法中添加了@RequestMapping来处理请求的类 @Autowired与@Resource 相同点： @Resource的作用相当于@Autowired，均可标注在字段或属性的
【SSM】基于AOP自定义注解的操作日志
最新发布
ZD_QS的博客
11-15 71
【SSM】基于AOP自定义注解的操作日志
java ssm api接口_Java | ssm中通过自定义注解实现RESTful风格接口版本管理
weixin_39620001的博客
02-28 181
什么是RESTful?为什么要用RESTful？为了使接口使用起来更方便、实现时代码更简洁之前做java web接触的form表单提交方式通常只有两种get & postRESTful就是根据提交方式去进行操作以前的请求路径https://localhost:8080/springdemo/getUserhttps://localhost:8080/springdemo/deleteUse...
ssm+redis 实现session共享
03-18
SSM+Redis 实现Session共享是现代Web应用中常见的技术组合，主要目的是在分布式系统中保持用户Session的一致性。SSM是指Spring、Spring MVC和MyBatis这三大Java Web开发框架的组合，而Redis则是一种高性能的键值存储...
ssm+mysql+Redis实现简易的高并发模拟
06-26
在本项目中，"ssm+mysql+Redis实现简易的高并发模拟" 是一个典型的Web应用架构，用于处理大量并发请求。SSM是Spring、Spring MVC和MyBatis的缩写，这是一种流行的Java Web开发框架组合，而MySQL是常用的开源关系型...
ssm+redis学生管理的实现
03-08
这个"ssm+redis学生管理的实现"项目，涵盖了从后端架构设计到数据库操作，再到缓存策略的多个层面，对于学习和掌握Java Web开发以及提高系统性能有很好的实践意义。通过对源代码的学习和分析，开发者可以深入了解SSM...
maven+ssm+redis增删改查小demo
05-16
本项目“maven+ssm+redis增删改查小demo”提供了一个基本的示例，展示了如何在SSM基础上利用Redis进行数据的高效存储和检索。 **1. Spring框架** Spring作为Java企业级应用的核心框架，提供了依赖注入(DI)和面向切...
SSM+shiro+redis
09-11
SSM+Shiro+Redis是一个常见的企业级Java Web开发架构，结合了Spring、SpringMVC、Mybatis、Apache Shiro和Redis五种技术，用于构建高效、安全且可扩展的Web应用。下面将详细介绍这些技术及其集成应用。 **Spring** ...
redis集成spring实现aop
02-03
下载分设置的比较高，不过绝对的值得哈！ 关于代码的一些说明可以看个人博客：www.mesoftware.cn 背景： 最近比较忙，也有些日子没有写博客了。加上自己文笔也不行，哈哈。今天就给分享下最近做的一个东西吧。 membercache已经有基于spring的aop包，并且这个包是谷歌提供的开源代码，里面代码我看了写的很不错的哈。 最近项目中需要用的redis，记得之前操作redis 的代码和自己订单业务混合在一起。维护是个问题，阅读也不利于。 还有严重的问题，有时候不想使用缓存服务了，还得每个方法里面判断下。为了在接下来的项目中能够方便的控制和使用 redis，所以也粗略的模仿了下membercache的aop代码，写了一份spring-redis-aop。当然方法有很多种，也许你有更好的 使用方法当然更好哈。
学会SpringMVC之自定义注解各种场景应用，提高开发效率及代码质量
SAME_LOVE的博客
09-15 504
在Spring MVC中，自定义注解是一种用于标记和定义特定功能的注解。通过自定义注解，可以在控制器方法、参数、类等地方添加注解，从而实现特定的功能或行为。Java注解是附加在代码中的一些元信息，用于一些工具在编译、运行时进行解析和使用，起到说明、配置的功能。通过自定义注解，可以提高代码的可读性和可维护性，同时也可以减少重复的代码编写。在Spring MVC中，自定义注解可以应用于控制器方法的映射、参数校验、数据绑定、AOP切面等方面，从而实现特定的功能。
SpringBoot SSM使用aop+自定义注解实现权限管理
rw4ta的博客
02-27 456
创建数据库 准备一个SpringBoot项目! 添加依赖 <!-- aop 依赖 --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-aop</artifactId> &lt...
SSM笔记（4）——自定义注解与AOP切面
oDoJi的博客
04-24 1373
目标 使用自定义注解标记controller，前端传参调用该controller时，使用切面捕获方法，对传递来的参数添加createTime和createPerson（person从Session中获取），免去在每一个服务类中都要set这两个值 自定义注解 1. 注解基础 1.1 注解的形式 public @interface Insert{} 1.2 元注解 可以给注解添加的...
SpringAop应用二之Aop实现Redis缓存(自定义注解实现切入)
海角12138的博客
08-13 548
一.首先实现自定义注解@AutowireRedis，实现该注解的方法会自动实现切面 package com.haijiao12138.demo.spring.util; import java.lang.annotation.*; /** * @author haijiao12138 * @date 2021/8/12 20:57 * @description */ @Documented @Retention(RetentionPolicy.RUNTIME) @Target(Element
Redis：利用AOP实现Redis缓存
qq_43148324的博客
03-17 771
AOP缓存的实现 自定义注解 import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; @Retention(RetentionPolicy.RUNTIME) //什么时期有效 此处为运行期有效 @Target(ElementType.ME
Reids与ssm整合使用注解
sJzao的博客
03-01 478
从jedisConnectionFactory获取Jedis实例报错 代码 // redisTemplate配置 @Bean(name="redisTemplate") public RedisTemplate initRedisTemplate() { JedisPoolConfig poolConfig = new JedisPoolConfig(); ...
AOP加自定义注解实现redis注解缓存
zhengholien的java净土
01-24 3709
很早之前学习了redis，在这次毕业设计中使用redis对热点数据进行缓存，其中使用spring-data-redis还有@Cacheable、@CachePut和@CacheEvict这3个注解。注解的方式避免了在业务方法中参杂太多非业务的逻辑代码，比如日志和事务，都会用AOP配合注解把共用部分抽离出来，同时业务方法也更纯粹简洁。在使用时发现，spring-data-redis虽是强大，但是许多
aop切面和redis实现自定义缓存注解
zhangxiaomin1992的专栏
10-20 2773
自定义缓存注解
JSP音乐网站设计与实现：SSM+MySQL源码解析
9. **缓存机制**：为了提高性能，可能引入缓存技术（如Spring Cache或Redis），缓存热门音乐列表、用户信息等，减少数据库访问压力。 10. **安全性考虑**：网站需要考虑数据安全，如防止SQL注入、XSS攻击，以及保护...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值