spring ssm框架整合redis，用来存储一些常用校验数据

最新推荐文章于 2026-06-02 09:06:36 发布
原创 最新推荐文章于 2026-06-02 09:06:36 发布 · 6.2k 阅读 · 5 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
收录于
eclispe j2ee

当前文章被收录于：

eclispe j2ee
43 篇文章 0 人学习
订阅专栏 查看详情
redis

当前文章被收录于：

redis
5 篇文章 0 人学习
订阅专栏 查看详情
本文介绍如何在Spring SSM框架下整合Redis，用于存储和快速访问常用校验数据。通过配置pom.xml，spring-mybatis.xml，以及创建redis.properties文件，定义AbstractBaseRedisDao抽象类，实现RedisSaveManageService接口，并在具体实现类RedisSaveManagerServiceImpl中完成功能。最后在controller层UserRestApiController中应用这些配置和实现。

spring ssm框架前面给大家构建过，这里直接贴代码了就。
1.pom.xml配置

<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>simple</groupId>
    <artifactId>board-webapp</artifactId>
    <version>0.0.1-SNAPSHOT</version>

    <properties>
        <!-- spring版本号 -->
        <spring.version>4.0.2.RELEASE</spring.version>
        <!-- mybatis版本号 -->
        <mybatis.version>3.2.6</mybatis.version>
        <!-- log4j日志文件管理包版本 -->
        <slf4j.version>1.7.7</slf4j.version>
        <log4j.version>1.2.17</log4j.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
            <!-- 表示开发的时候引入，发布的时候不会加载此包 -->
            <scope>test</scope>
        </dependency>
        <!-- spring核心包 -->
        <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-jdbc</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</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-context-support</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>${spring.version}</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>
        <!-- 导入java ee jar 包 -->
        <dependency>
            <groupId>javax</groupId>
            <artifactId>javaee-api</artifactId>
            <version>7.0</version>
        </dependency>
        <!-- 导入Mysql数据库链接jar包 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.30</version>
        </dependency>
        <!-- 导入dbcp的jar包，用来在applicationContext.xml中配置数据库 -->
        <dependency>
            <groupId>commons-dbcp</groupId>
            <artifactId>commons-dbcp</artifactId>
            <version>1.2.2</version>
        </dependency>
        <!-- JSTL标签类 -->
        <dependency>
            <groupId>jstl</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>
        <!-- 日志文件管理包 -->
        <!-- log start -->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>${log4j.version}</version>
        </dependency>


        <!-- 格式化对象，方便输出日志 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.1.41</version>
        </dependency>


        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>${slf4j.version}</version>
        </dependency>

        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>${slf4j.version}</version>
        </dependency>
        <!-- log end -->
        <!-- 映入JSON -->
        <dependency>
            <groupId>org.codehaus.jackson</groupId>
            <artifactId>jackson-mapper-asl</artifactId>
            <version>1.9.13</version>
        </dependency>
        <!-- 上传组件包 -->
        <dependency>
            <groupId>commons-fileupload</groupId>
            <artifactId>commons-fileupload</artifactId>
            <version>1.3.1</version>
        </dependency>
        <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
            <version>2.4</version>
        </dependency>
        <dependency>
            <groupId>commons-codec</groupId>
            <artifactId>commons-codec</artifactId>
            <version>1.9</version>
        </dependency>
        <dependency>
            <groupId>org.freemarker</groupId>
            <artifactId>freemarker</artifactId>
            <version>2.3.23</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.apache.poi/poi -->
        <dependency>
            <groupId>org.apache.poi</groupId>
            <artifactId>poi</artifactId>
            <version>3.6</version>
        </dependency>
        <dependency>
            <groupId>com.itextpdf</groupId>
            <artifactId>itext-asian</artifactId>
            <version>5.1.0</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.eclipse.birt.runtime.3_7_1/com.lowagie.text -->
        <dependency>
            <groupId>org.eclipse.birt.runtime.3_7_1</groupId>
            <artifactId>com.lowagie.text</artifactId>
            <version>2.1.7</version>
        </dependency>
        <dependency>
            <groupId>com.thoughtworks.xstream</groupId>
            <artifactId>xstream</artifactId>
            <version>1.3.1</version>
        </dependency>
        <dependency>
            <groupId>com.thoughtworks.xstream</groupId>
            <artifactId>xstream</artifactId>
            <version>1.4.9</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.apache.commons/commons-lang3 -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.2</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.hibernate/hibernate-validator-legacy -->
        <!-- https://mvnrepository.com/artifact/org.hibernate/hibernate-validator -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-validator</artifactId>
            <version>5.1.1.Final</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.apache.commons/commons-collections4 -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-collections4</artifactId>
            <version>4.0</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/com.google.guava/guava -->
        <dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
            <version>17.0</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.apache.tika/tika-core -->
        <dependency>
            <groupId>org.apache.tika</groupId>
            <artifactId>tika-core</artifactId>
            <version>1.8</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.apache.ant/ant-commons-net -->
        <dependency>
            <groupId>org.apache.ant</groupId>
            <artifactId>ant-commons-net</artifactId>
            <version>1.8.3</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.kie.modules/org-apache-commons-net -->
        <dependency>
            <groupId>org.kie.modules</groupId>
            <artifactId>org-apache-commons-net</artifactId>
            <version>6.3.0.Final</version>
            <type>pom</type>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.springframework.data/spring-data-commons -->
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-commons</artifactId>
            <version>1.8.0.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.redisson</groupId>
            <artifactId>redisson</artifactId>
            <version>1.0.2</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.7.7</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-redis</artifactId>
            <version>1.0.2.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>2.1.0</version>
        </dependency>

    </dependencies>
</project>

redis 配置我是配置在spring-mybatis.xml中的
2.spring-mybatis.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:mvc="http://www.springframework.org/schema/mvc"
    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.1.xsd  
                        http://www.springframework.org/schema/context  
                        http://www.springframework.org/schema/context/spring-context-3.1.xsd  
                        http://www.springframework.org/schema/mvc  
                        http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd
                        http://www.springframework.org/schema/tx 
                        http://www.springframework.org/schema/tx/spring-tx-3.0.xsd">
    <!-- 自动扫描 -->
    <context:component-scan base-package="com.baobaotao" />

    <context:property-placeholder location="classpath:redis.properties" ignore-unresolvable="true"/>  
     <bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">  
        <property name="maxIdle" value="${redis.maxIdle}" />  
        <property name="maxActive" value="${redis.maxActive}" />  
        <property name="maxWait" value="${redis.maxWait}" />  
        <property name="testOnBorrow" value="${redis.testOnBorrow}" />  
    </bean>  

    <bean id="connectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory"  
        p:host-name="${redis.host}" p:port="${redis.port}"  p:pool-config-ref="poolConfig"/>  

    <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">  
        <property name="connectionFactory"   ref="connectionFactory" />  
    </bean>         

    <!-- 引入配置文件 -->
    <bean id="propertyConfigurer"
        class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="location" value="classpath:jdbc.properties" />
        <property name="ignoreUnresolvablePlaceholders" value="true" /> 
    </bean>

    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
        destroy-method="close">
        <property name="driverClassName" value="${jdbc.driverClassName}" />
        <property name="url" value="${jdbc.url}" />
        <property name="username" value="${jdbc.username}" />
        <property name="password" value="${jdbc.password}" />
    </bean>

    <!-- spring和MyBatis完美整合，不需要mybatis的配置映射文件 -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource" />
        <!-- 自动扫描mapping.xml文件 -->
        <property name="mapperLocations" value="classpath:com/baobaotao/mapping/*.xml"></property>
    </bean>

    <!-- DAO接口所在包名，Spring会自动查找其下的类 -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.baobaotao.repository" />
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"></property>
    </bean>

    <!-- (事务管理)transaction manager, use JtaTransactionManager for global tx -->
    <bean id="transactionManager"
        class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource" />
    </bean>
    <tx:annotation-driven  proxy-target-class="true" />

</beans>

3.redis.properties文件

#the redis key rang
redis.key.prefix=500

redis.host=localhost
redis.port=6379
redis.maxIdle=300
redis.maxActive=600 
redis.maxWait=1000
redis.testOnBorrow=true

4.抽象类 AbstractBaseRedisDao

package com.baobaotao.utils;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.RedisSerializer;

public abstract class AbstractBaseRedisDao<K,V> {

    @Autowired
    protected RedisTemplate<K, V> redisTemplate; 

    /** 
     * 设置redisTemplate 
     * @param redisTemplate the redisTemplate to set 
     */  
    public void setRedisTemplate(RedisTemplate<K, V> redisTemplate){
        this.redisTemplate=redisTemplate;
    }


    /** 
     * 获取 RedisSerializer 
     * <br>------------------------------<br> 
     */  
    protected RedisSerializer<String> getRedisSerializer() {  
        return redisTemplate.getStringSerializer();  
    }  

}

5.RedisSaveManageService

package com.baobaotao.service;

import java.util.List;

public interface RedisSaveManageService {

     /** 
     * 新增 
     * <br>------------------------------<br> 
     * @param user 
     * @return 
     */  
     boolean add(String key ,String value);  

    /** 
     * 批量新增 使用pipeline方式 
     * <br>------------------------------<br> 
     * @param list 
     * @return 
     */  
     boolean add(List<String> key,List<String> values);  

    /** 
     * 删除 
     * <br>------------------------------<br> 
     * @param key 
     */  
     void delete(String key);  

    /** 
     * 删除多个 
     * <br>------------------------------<br> 
     * @param keys 
     */  
     void delete(List<String> keys);  

    /** 
     * 修改 
     * <br>------------------------------<br> 
     * @param user 
     * @return  
     */  
     boolean update(String key,String value);  

    /** 
     * 通过key获取 
     * <br>------------------------------<br> 
     * @param keyId 
     * @return  
     */  
     String get(String key);

}

6.实现类 RedisSaveManagerServiceImpl

package com.baobaotao.service.impl;

import java.util.ArrayList;
import java.util.List;

import org.springframework.dao.DataAccessException;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.stereotype.Service;

import com.baobaotao.service.RedisSaveManageService;
@Service
public class RedisSaveManagerServiceImpl extends com.baobaotao.utils.AbstractBaseRedisDao<String, String> implements RedisSaveManageService {
     /**  
     * 新增 
     *<br>------------------------------<br> 
     * @param user 
     * @return 
     */  
    @Override
    public  boolean add( final String key,final String value) {
        // TODO Auto-generated method stub
        boolean result=redisTemplate.execute(new RedisCallback<Boolean>() {

            @Override
            public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
                // TODO Auto-generated method stub
                RedisSerializer<String> serializer=getRedisSerializer();
                //序列化
                byte[] key2=serializer.serialize(key);
                byte[] value2=serializer.serialize(value);
                return connection.setNX(key2, value2);
            }
        });
        return result;
    }
    /** 
     * 批量新增 使用pipeline方式   
     *<br>------------------------------<br> 
     *@param list 
     *@return 
     */  
    @Override
    public  boolean add(final List<String> key, final List<String> values) {
        boolean result=redisTemplate.execute(new RedisCallback<Boolean>() {

            @Override
            public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
                RedisSerializer<String> serializer=getRedisSerializer();
                for (int i = 0; i < values.size(); i++) {
                    byte[] key2=serializer.serialize(key.get(i));
                    byte[] value2=serializer.serialize(values.get(i));
                    connection.setNX(key2, value2);
                }
                return true;
            }
        },false,true);
        return result;
    }

    @Override
    public  void delete(String key) {
         List<String> list = new ArrayList<>();  
            list.add(key);  
            delete(list);  
    }

    @Override
    public  void delete(final List<String> keys) {
        redisTemplate.execute(new RedisCallback<Boolean>() {

            @Override
            public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
                // TODO Auto-generated method stub
                RedisSerializer<String> serializer=getRedisSerializer();
                //序列化
                for(String k:keys){
                    byte[] key = serializer.serialize(k); 
                    connection.del(key);
                }
                return true;
            }
        });


    }

    @Override
    public  boolean update(final String key,final String value) {
        // TODO Auto-generated method stub
        if (get(key) == null) {  
            throw new NullPointerException("数据行不存在, key = " + key);  
        }  
        boolean result = redisTemplate.execute(new RedisCallback<Boolean>() {  
            public Boolean doInRedis(RedisConnection connection)  
                    throws DataAccessException {  
                RedisSerializer<String> serializer = getRedisSerializer();  
                byte[] key2  = serializer.serialize(key);  
                byte[] value2 = serializer.serialize(value);  
                connection.set(key2, value2);  
                return true;  
            }  
        });  
        return result;  
    }

    @Override
    public String get(final String key) {
        String result = redisTemplate.execute(new RedisCallback<String>() {  
            public String doInRedis(RedisConnection connection)  
                    throws DataAccessException {  
                RedisSerializer<String> serializer = getRedisSerializer();  
                byte[] key2 = serializer.serialize(key);  
                byte[] value = connection.get(key2);  
                if (value == null) {  
                    return null;  
                }  
                String value2 = serializer.deserialize(value);  
                return value2;  
            }  
        });  
        return result;  
    }

}

7.使用的controller层UserRestApiController

package com.baobaotao.controller;

@Controller
@RequestMapping("/baobaotao/user/")
public class UserRestApiController extends BaseController{

    private final Logger logger = LoggerFactory.getLogger(UserRestApiController.class);

    @Autowired
    private UserService userService;
    @Autowired
    private UserBizService userBizService;
    @Autowired
    private RedisSaveManagerServiceImpl redisCacheManageService;
    @Value("${redis.key.prefix}")
    private String redisPrefixKey;

    // userAccount Redis key
    public String getRedisKeyAccountName(String accountName) {
        return redisPrefixKey + "_board_" + accountName;
    }

    /**
     * 登录
     * @param user
     * @param request
     * @return
     */
    @RequestMapping(value = "login")
    @ResponseBody
    public String login(User user, HttpServletRequest request) {
        Result<String> result = new Result<String>(false);
        String password="";
        User mm=new User();
        String cacheKey = getRedisKeyAccountName(user.getUserName());
        try {
            password = redisCacheManageService.get(cacheKey);
        } catch (Exception e) {
            logger.info(MessageFormat.format("获取缓存失败", cacheKey), e);
        }
        if (StringUtils.isBlank(password)) {
            mm = userBizService.findByUserName(user.getUserName());
            if (mm == null || !mm.getPassword().equals(user.getPassword())) {
                logger.error("用户名或密码不正确");
                result.setMessage("用户名或密码不存在");
                return result.toJsonResult();
            }else{
                redisCacheManageService.add(cacheKey, user.getPassword());
            }
        }else{
            mm.setUserName(user.getUserName());
            mm.setPassword(password);
        }
        mm.setLastIp(request.getRemoteAddr());
        mm.setLastVisit(new Date());
        result = userBizService.userLogin(mm);
        return result.toJsonResult();
    }

8打断点调试的时候
这里写图片描述

标签
#spring #redis
SSM+Redis项目整合
07-24
1.注意修改db.properties中的数据库配置信息,保持和自己的一致 2.建表语句在com.briup.sql包里面 3.运行项目之前,要先开启Redis服务器 4.register.jsp页面中可以测试ssm整体的框架搭建以及事务是否可以回滚 5.success.jsp页面中可以测试Redis是否配置成功,多次点击按钮查询观察select的执行情况 6.压缩包里有三个demo1,分别是mybatis二级缓存版、spring4.0版、spring3.0版。
Redis专场：如何利用Redisson分布式化传统Web项目
10-31
2017杭州云栖大会 Redis专场：如何利用Redisson分布式化传统Web项目
SSM框架整合Redis及简单使用
L_Shaker的博客
07-16 3770
SSM框架整合Redis及简单使用1.导入jar包2.增加Redis的配置文件3.创建用于操作redis的接口4.启动redis5.测试操作redis 工具：Eclipse 环境：JDK8 Tomcat8.5 Redis版本：3.0.504 操作方式：采用redisTemplate操作redis 1.导入jar包 除了SSM相关jar包外，还要导入redis的相关jar包(这里我用的是：spring-data-redis-1.8.4.RELEASE.jar、jedis-2.9.0.jar），项目jar所以j
ssh,ssm整合redis存储验证码
尽力漂亮的博客
11-30 3333
ssh整合redis存储验证码 测试redis redis存储验证码
LTspice新手避坑指南：用运放搭比较器，为啥仿真结果和理论差这么多？
最新发布
weixin_33736048的博客
06-02 762
本文深入解析LTspice中运放比较器仿真异常的原因及解决方案，帮助新手避免常见误区。从理想模型与实际模型的差异入手，详细分析输出波形毛刺、翻转点偏移等问题的成因，并提供滞回比较器设计、动态迟滞技术等实用技巧，助力电子爱好者提升仿真精度与电路设计能力。
【Redis】掌握篇--Redis与SSM进行整合
m0_74315688的博客
11-06 1992
Redis和SSM双剑合璧！！！
【Maven+SSM】超详细Spring+SpringMVC+Redis集成
haibo_bear的博客
02-27 2205
前言：        文章背景，最近项目中做了一个上传图片的功能，由于是流式上传，所以网关层没有对用户权限做过滤。需要自己手动做用户权限校验。但是，如果每次上传图片都进行数据库查询会造成数据库压力大。因此，看前人代码中，用到了redis缓存读取。学习记录之。        在项目中学习编程就是这样，当用到哪不会没见过的时候再学，就会觉得这个东西很有用，而且以后也能在这样的场景运用起来。正文：   ...
最强分布式锁工具：Redisson
方志朋的博客
08-14 168
欢迎关注方志朋的博客，回复”666“获面试宝典一、Redisson概述什么是Redisson？Redisson是一个在Redis的基础上实现的Java驻内存数据网格（In-Memory Data Grid）。它不仅提供了一系列的分布式的Java常用对象，还提供了许多分布式服务。其中包括(BitSet, Set, Multimap, SortedSet, Map, List...
SSM框架整合Redis数据库
m0_70405779的博客
04-14 2454
创建spring-redis.xml文件，这个配置文件通常包含了与Redis数据库集成所需的各种设置，例如JedisPoolConfig、JedisConnectionFactory以及Spring RedisTemplate的配置。由于后续测试中存入redis中的数据是User对象，所有在使用前需要先让User实现序列化接口，就是在User中implements Serializable。让程序运行完，再次访问路径，这次程序停在上一断点处，表示从redis中取数据。虽然这里看起来像乱码，但是不影响。
SSM框架整合Redis实现Session共享源码解析与实战
weixin_42588555的博客
10-29 1013
当需要存储复杂对象时，推荐使用Jackson2JsonRedisSerializer替代默认序列化器：@Bean注意：启用可保留类型信息，便于反序列化时还原具体子类，但也带来一定安全风险（反序列化攻击），生产环境应谨慎启用。配合命名空间声明即可自动装配或（取决于classpath中的依赖）。为了实现对Session创建与销毁事件的精准捕获，必须注册一个实现了接口的监听器类。
SSM整合redis及redis的注解式开发和解决Redis缓存问题
ChatYU的博客
11-07 1187
简化代码：注解式开发可以显著减少与Redis相关的样板代码。通过使用注解，你可以在方法上直接标记缓存操作，而不必在每个方法中手动编写缓存逻辑。提高开发效率：通过使用注解，开发者可以更容易地实现缓存功能，减少了手动处理缓存的复杂性。这使得开发者可以专注于业务逻辑的实现，而不必花费过多时间在缓存的管理和维护上。降低错误风险：手动管理缓存可能会导致错误，例如忘记在适当的时机清除缓存，或者在更新数据时没有及时更新缓存。使用注解可以减少这些潜在的错误，提高了代码的可靠性。提升性能。
SSM整合redis
热门推荐
木与石
08-13 3万+
一、关于SSM整合Redis需要知道的一些小知识在学习Redis的时候，大家应该知道，JAVA操作redis通常使用的是Jedis，通过java代码来操作redis的数据存储读取等操作，用过的人应该知道，Jedis客户端已经足够简单和轻量级了，但是呢，在此同时，Spring也为Redis提供了支持，就是在Spring-data模块中的Spring-Data-Redis（SDR），它一部分是基于Jed
SSM+Redis整合开发
知行流浪
03-30 5739
mybatis整合Redis        Redis是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。        不使用分布式缓存，缓存数据在各自的服务器中存储，不方便系统开发，所以要使用分布式缓存对缓存数据进行集中式管理。        mybatis本身无法实现分布式缓存，需要和其他的分布式缓存进行整合。整合方...
ssm demo（通过redis解决session共享的问题）
11-16
基于SpringMVC ＋Spring + Mybaties框架的maven项目，tomcat+nginx+redis实现均衡负载、session共享
SSM+Redis+rabbitMQ框架
10-09
resources下有mysql的xk.sql文件（资料中没有redis和rabbit的安装文件） redis和数据库已经挂钩了， 项目运行后访问http://localhost:8080/webproject/send1.do?msg=111111或者http://localhost:8080/webproject/send2.do?msg=22222可以发布消息 由于是自学，参考了好多大神的资料，感谢。希望大神不要说我侵权。 下载的码农们，望轻喷
Java EE 互联网轻量级框架整合开发：Spring MVC+Spring+MyBatis 和 Redis 实现（干货）
kxkxyzyz的博客
02-13 2087
前言 随着移动互联网的兴起，以 Java 技术为后台的互联网技术占据了市场的主导地位，而在 Java 互联网后台开发中，SSM 框架（Spring+Spring MVC+MyBatis）成为了主要架构，本书以此为焦点从入门到实际工作要求讲述了 SSM 框架的技术应用；与此同时，为了提高系统性能，NoSQL（尤其是 Redis）在互联网系统中已经广泛使用，为了适应这个变化，本书通过 Spring ...
Spring框架学习第一节：认识SSM框架和Redis
paynmind的博客
06-08 1665
此博客用于个人学习，来源于ssm框架的书籍，对知识点进行一个整理。
《Java EE互联网轻量级框架整合开发— —SSM框架（Spring MVC+Spring+MyBatis）和Redis实现》笔记
philsonzhao的博客
01-23 1792
几个常识性错误 SSH框架 其实很多初学者混淆了一个概念，SSH实际上指的是Struts 1.x + Spring + Hibernate，这个概念已经有十几年历史了。在Struts 1.x的时代，Struts 1.x是当之无愧的MVC框架的霸主，但是在新的MVC框架涌现的时代，形势已经完全不是这样了，Struts 2.x借助了 Struts 1.x 的好名声，让国内开发者认为Struts 2.x...
关于SSM整合Spring-data-Redis踩的一些坑
Linn的博客
06-25 915
一、关于SSM整合Redis需要知道的一些小知识 在学习Redis的时候，大家应该知道，JAVA操作redis通常使用的是Jedis，通过java代码来操作redis的数据存储读取等操作，用过的人应该知道，Jedis客户端已经足够简单和轻量级了，但是呢，在此同时，Spring也为Redis提供了支持，就是在Spring-data模块中的Spring-Data-Redis（SDR），它一部分是基...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值