ssm + redis

最新推荐文章于 2022-08-19 09:40:42 发布
最新推荐文章于 2022-08-19 09:40:42 发布
阅读量361 收藏 4
点赞数 1
分类专栏： redis SSM java基础 JSP java基础，eclipse 数据库 文章标签： redis spring java maven ssm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/JuinH/article/details/78441000
版权

个人经验，需要的话可以一看

windows 64位redis下载地址

点击打开链接


首先：安装redis服务器，分别运行redis-server.exe，redis-cli.exe，并在redis-cli.exe中设置密码（如下图）



接下来进入项目，注解都在项目中，可以自己看

  

首先我们要新建一个缓存类RedeisCache

import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
import org.apache.ibatis.cache.Cache;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 
 * @描述: 使用第三方内存数据库Redis作为二级缓存
 * @版权: Copyright (c) 2017
 * @作者: juin
 * @版本: 1.0 
 * @创建日期: 2017年10月30日 
 * @创建时间: 下午8:02:57
 */
public class RedisCache implements Cache
{
	private static Logger logger = LoggerFactory.getLogger(RedisCache.class); 

    /** The ReadWriteLock. */ 

    private final ReadWriteLock readWriteLock = new ReentrantReadWriteLock();

     

    private String id;

     

    public RedisCache(final String id) {  

        if (id == null) {

            throw new IllegalArgumentException("Cache instances require an ID");

        }

        logger.debug(">>>>>>>>>>>>>>>>>>>>>>>>MybatisRedisCache:id="+id);

        this.id = id;

    }  

     

    public String getId() {

        return this.id;

    }

 

    public void putObject(Object key, Object value) {

        logger.debug(">>>>>>>>>>>>>>>>>>>>>>>>putObject:"+key+"="+value);

        RedisUtil.getJedis().set(SerializeUtil.serialize(key.toString()), SerializeUtil.serialize(value));

    }

 

    public Object getObject(Object key) {

        Object value = SerializeUtil.unserialize(RedisUtil.getJedis().get(SerializeUtil.serialize(key.toString())));

        logger.debug(">>>>>>>>>>>>>>>>>>>>>>>>getObject:"+key+"="+value);

        return value;

    }

 

    public Object removeObject(Object key) {

        return RedisUtil.getJedis().expire(SerializeUtil.serialize(key.toString()),0);

    }

 

    public void clear() {

        RedisUtil.getJedis().flushDB();

    }

 

    public int getSize() {

        return Integer.valueOf(RedisUtil.getJedis().dbSize().toString());

    }

 

    public ReadWriteLock getReadWriteLock() {

        return readWriteLock;

    }
     

}


然后需要一个工具类

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

public final class RedisUtil {

	// Redis服务器IP
	 private static String ADDR = "127.0.0.1";
	// 测试服务器
	//private static String ADDR = "192.168.12.134";
	// Redis的端口号
	private static int PORT = 6379;

	// 访问密码
	private static String AUTH = "123456";

    
    //访问密码
    
    //可用连接实例的最大数目，默认值为8；
    //如果赋值为-1，则表示不限制；如果pool已经分配了maxActive个jedis实例，则此时pool的状态为exhausted(耗尽)。
    private static int MAX_ACTIVE = 1024;
    
    //控制一个pool最多有多少个状态为idle(空闲的)的jedis实例，默认值也是8。
    private static int MAX_IDLE = 200;
    
    //等待可用连接的最大时间，单位毫秒，默认值为-1，表示永不超时。如果超过等待时间，则直接抛出JedisConnectionException；
    private static int MAX_WAIT = 10000;
    
    private static int TIMEOUT = 10000;
    
    //在borrow一个jedis实例时，是否提前进行validate操作；如果为true，则得到的jedis实例均是可用的；
    private static boolean TEST_ON_BORROW = true;
    
    private static JedisPool jedisPool = null;
    
    /**
     * 初始化Redis连接池
     */
    static {
        try {
            JedisPoolConfig config = new JedisPoolConfig();
        //    config.setMaxActive(MAX_ACTIVE);
            config.setMaxTotal(MAX_ACTIVE);
            config.setMaxIdle(MAX_IDLE);
            config.setMaxWaitMillis(MAX_WAIT);
          //  config.setMaxWait(MAX_WAIT);
            config.setTestOnBorrow(TEST_ON_BORROW);
            jedisPool = new JedisPool(config, ADDR, PORT, 100000, AUTH);
            System.out.println("redis密码");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    /**
     * 获取Jedis实例
     * @return
     */
    public synchronized static Jedis getJedis() {
        try {
            if (jedisPool != null) {
                Jedis resource = jedisPool.getResource();
                return resource;
            } else {
                return null;
            }
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
    
    /**
     * 释放jedis资源
     * @param jedis
     */
	public static void returnResource(final Jedis jedis) {
        if (jedis != null) {
            jedisPool.returnResource(jedis);
        }
    }

	/**
	 * 
	 * 判断用户是否过期
	 * 
	 * @param jedis
	 */

	public static boolean VerifyUser(String id) {

		String key = RedisUtil.getJedis().get(id);
		if (key == null) {
			return false;
		}
		return true;
	}
}


最后是一个关于序列化的类

import java.io.ByteArrayInputStream;  
import java.io.ByteArrayOutputStream;  
import java.io.ObjectInputStream;  
import java.io.ObjectOutputStream;  
  
public class SerializeUtil {  
    /** 
     * 序列化 
     *  
     * @param object 
     * @return 
     */  
    public static byte[] serialize(Object object) {  
        ObjectOutputStream oos = null;  
        ByteArrayOutputStream baos = null;  
        try {  
            // 序列化  
            baos = new ByteArrayOutputStream();  
            oos = new ObjectOutputStream(baos);  
            oos.writeObject(object);  
            byte[] bytes = baos.toByteArray();  
            return bytes;  
        } catch (Exception e) {  
  
        }  
        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) {  
  
        }  
        return null;  
    }  
    
    
}


配置文件自然也是少不了的

首先是spring-redis配置文件


spring-redis：

<?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:tx="http://www.springframework.org/schema/tx"
          xmlns:context="http://www.springframework.org/schema/context"
          xsi:schemaLocation="
      http://www.springframework.org/schema/beans
      http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
      http://www.springframework.org/schema/tx
      http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
      http://www.springframework.org/schema/context
      http://www.springframework.org/schema/context/spring-context-3.0.xsd">

    <context:property-placeholder location="classpath:*.properties"/>
    <!--设置数据池-->
    <bean id="poolConfig"  class="redis.clients.jedis.JedisPoolConfig">
        <property name="maxIdle" value="${redis.maxIdle}"></property>
        <property name="minIdle" value="${redis.minIdle}"></property>
        <property name="maxTotal" value="${redis.maxTotal}"></property>
        <property name="maxWaitMillis" value="${redis.maxWaitMillis}"></property>
        <property name="testOnBorrow" value="${redis.testOnBorrow}"></property>
    </bean>
    <!--链接redis-->
    <bean id="connectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
        <property name="hostName" value="${redis.host}"></property>
        <property name="port" value="${redis.port}"></property>
        <property name="password" value="${redis.password}"></property>
        <property name="poolConfig" ref="poolConfig"></property>
    </bean>

    <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate" p:connection-factory-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>
        <property name="hashKeySerializer">
            <bean class="org.springframework.data.redis.serializer.StringRedisSerializer" />
        </property>
        <!--<property name="hashValueSerializer">
            <bean class="org.springframework.data.redis.serializer.StringRedisSerializer" />
        </property>-->
    </bean>
</beans>

propertis: 

redis.maxIdle=300
redis.minIdle=100
redis.maxWaitMillis=3000
redis.testOnBorrow=true
redis.maxTotal=500
redis.host=127.0.0.1
redis.port=6379
redis.password=123456


务必要在web.xml里面声明位置

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns="http://java.sun.com/xml/ns/javaee"
	xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
         http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
	id="WebApp_ID" version="3.0">
	<context-param>
		<param-name>contextConfigLocation</param-name>
		<param-value>classpath:spring-mybatis.xml,classpath:spring-redis.xml</param-value>
	</context-param>

	<listener>
		<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
	</listener>
	<!--spring配置文件路径 -->
	<servlet>
		<servlet-name>dispatcherServlet</servlet-name>
		<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
		<init-param>
			<param-name>contextConfigLocation</param-name>
			<param-value>classpath:spring-mvc.xml</param-value>
		</init-param>
		<load-on-startup>1</load-on-startup>
	</servlet>
	<servlet-mapping>
		<servlet-name>dispatcherServlet</servlet-name>
		<url-pattern>*.do</url-pattern>
	</servlet-mapping>
	<filter>
		<filter-name>encodingFilter</filter-name>
		<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
		<init-param>
			<param-name>encoding</param-name>
			<param-value>UTF-8</param-value>
		</init-param>
		<init-param>
			<param-name>forceEncoding</param-name>
			<param-value>true</param-value>
		</init-param>
	</filter>
	<filter-mapping>
		<filter-name>encodingFilter</filter-name>
		<url-pattern>/*</url-pattern>
	</filter-mapping>
	<session-config>
		<session-timeout>30</session-timeout>
	</session-config>
	<welcome-file-list>
		<welcome-file>index.jsp</welcome-file>
	</welcome-file-list>

</web-app>


另外也是要在spring-mybatis文件里面开启一下缓存

<?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:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:context="http://www.springframework.org/schema/context"

	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
       http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd
       http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
       http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd">


	<context:component-scan base-package="com.qdu"/> 
	<tx:annotation-driven transaction-manager="txManager" />
	<bean id="dataSource"
		class="org.springframework.jdbc.datasource.DriverManagerDataSource">
		<property name="driverClassName" value="com.mysql.jdbc.Driver" />
		<property name="url" value="jdbc:mysql://localhost:3306/classmanagesys" />
		<property name="username" value="root" />
		<property name="password" value="118554" />
		<!-- 19951211 -->
		<!-- 118554 -->
	</bean>
	<!-- 开启事务及redis缓存 -->
	<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
		<property name="dataSource" ref="dataSource" />
		<property name="mapperLocations" value="classpath:com/qdu/mapping/*.xml" />
		<property name="configurationProperties">
			<props>
				<prop key="cacheEnabled">true</prop> 
				<prop key="lazyLoadingEnabled">false</prop> 
				<prop key="aggressiveLazyLoading">true</prop>
			</props>
		</property>
	</bean>
	

	<bean id="txManager"
		class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource" ref="dataSource" />
	</bean>

	<tx:annotation-driven transaction-manager="txManager" />


</beans>


最后一步，在映射文件下面加上一句话


<?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.qdu.mapping.TestMapping">
	<cache type="com.qdu.cache.RedisCache"/>
	<resultMap type="com.qdu.pojo.Test" id="TestResult">
		<id property="studentId" column="StudentId" />
		<result property="studentPassword" column="StudentPassword" />
		<result property="studentName" column="StudentName" />
	</resultMap>

	<select id="selectFromTestById" resultMap="TestResult"
		parameterType="int">
		select * from Test where StudentId = #{studentId}
	</select>
</mapper>



别忘了改一下配置

打开redis.windows.conf,找到 #requirepass foobared ，去掉 # ，改为requirepass 123456



测试，成功

import org.junit.Before;
import org.junit.Test;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

public class RedisTest {

    JedisPool pool;
    Jedis jedis;

    @Before
    public void start() {

        // 初始化Redis连接池
        pool = new JedisPool(new JedisPoolConfig(), "127.0.0.1");
        // 从Redis连接池中获取一个连接
        jedis = pool.getResource();
        // Redis的密码，对应redis.windows.conf中的masterauth
        jedis.auth("123456");

    }

    /**
     * 添加测试
     */
    @Test
    public void putTest() {

        jedis.set("user", "adwina");
        System.out.println(jedis.get("user"));


    }

    /**
     * 覆盖测试
     */
    @Test
    public void overWriteTest() {

        jedis.set("user", "Juin");
        System.out.println(jedis.get("user"));


    }

    /**
     * 追加测试
     */
    @Test
    public void appendTest() {

        jedis.append("user", "侯亚军");
        System.out.println(jedis.get("user"));


    }

    /**
     * 删除测试
     */
    @Test
    public void deleteTest() {

        jedis.del("user");
        System.out.println(jedis.get("user"));

        // 输出结果：null

    }

}


JuinH
关注
专栏目录
快速搭建SSM+redis
隔壁的博客
12-19 1954
快速搭建SSM+redis Maven项目
ssm+redis 实现session共享
03-18
SSM+Redis 实现Session共享是现代Web应用中常见的技术组合，主要目的是在分布式系统中保持用户Session的一致性。SSM是指Spring、Spring MVC和MyBatis这三大Java Web开发框架的组合，而Redis则是一种高性能的键值存储...
SSM配置redis
PzzZ的博客
11-13 5782
redis配置：
ssm+redis部署
ysfengshu的博客
08-19 363
redis部署
SSM+Redis
ZhangYing_Jie的博客
03-09 100
1.打开服务 2.导入Jar包 <dependency> <groupId>redis.clients</groupId> <artifactId>jedis</artifactId> <version>2.9.0</version> </dependency> 3.在spring进行配置 <!--配置Redis连接池--> &l.
IDEA SSM+Redis框架搭建
yizhinvlimeng的博客
12-21 184
IDEA中SSM+Redis框架搭建
ssm+redis(使用RedisTemplate)
weixin_43832604的博客
03-29 1632
集合之前的ssm 引包 <!--redis相关--> <dependency> <groupId>org.springframework.data</groupId> <artifactId>spring-data-redis</artifactId> <version&gt...
SSM框架整合（SSM+redis）
SGLP521的博客
11-24 504
SSM框架整合（SSM+redis）
ssm+redis
qq_40180411的博客
01-03 135
https://blog.csdn.net/aqsunkai/article/details/51758900
SSM+redis配置实现简单的查询(可以复制直接使用，但需要手动修改一些文件路径)需要自行配置外部Tomcat
Lyh_ok的博客
12-16 422
跟着一步步来，可以直接复制使用哦改一些文件路径即可
SSM+Redis整合
lady132的博客
05-09 1398
记着:Spring与Redis整合其实是缓存的整合，不在spring部分，而在mybatis部分！！！ 在网上找了很多博客，最后找到这篇博文才算整合完成：https://blog.csdn.net/zhanglf02/article/details/74999231#commentBox 十分感谢博主！ 项目结构: 1、添加pom依赖 <project xmlns="http://mave...
maven+ssm+redis增删改查小demo
05-16
**SSM + Redis 增删改查小Demo详解** 在现代Java Web开发中，SSM（Spring、Spring MVC、MyBatis）框架组合与Redis缓存系统的集成应用非常广泛。本项目“maven+ssm+redis增删改查小demo”提供了一个基本的示例，展示...
ssm+redis+nginx实现session共享和负载均衡
03-18
SSM（Spring、Spring MVC、MyBatis）是Java后端开发的常用框架组合，而Redis是一个高性能的键值数据库，常用于缓存和session存储。Nginx则是一款强大的反向代理服务器，能够实现负载均衡。接下来我们将深入探讨如何...
SSM+redis的一个小demo
01-03
最近公司用到redis，网上的资料各种不全，找了很久，这个用redis和Mysql来做的，spring配的jedis连接池，供初学者学习吧，因为所有对象都可以转化为json字符串，所有图方便，全部存的字符串，至于其他数据类型自己...
maven+ssm+redis
09-21
在IT行业中，构建高效、可扩展的Web应用是至关重要的，而"Maven+SSM+Redis"的组合正是实现这一目标的有效方式。这个标题和描述所提及的知识点涵盖了Java开发中的多个关键组件，包括项目构建工具Maven，以及Spring、...
SSM+redis+mysql框架实现的一个简单博客
03-31
SSM+redis+mysql框架实现的一个简单博客，SSM+redis+mysql框架实现的一个简单博客SSM+redis+mysql框架实现的一个简单博客SSM+redis+mysql框架实现的一个简单博客SSM+redis+mysql框架实现的一个简单博客SSM+redis+...
ssm+redis和ssm+redis+shiro源码
03-14
在SSM+Redis+Shiro的架构中，Shiro可以与Redis结合，将用户的登录信息和权限信息存储在Redis中，实现跨服务器的会话共享，提高系统的可扩展性和安全性。 "redisdemo"可能是一个包含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框架由Spring、Spring MVC和MyBatis三个组件组成，而Redis则是一个高性能的键值存储系统，常用于缓存和数据持久化。在...
java ee互联网轻量级框架整合开发:ssm+redis+spring微服务pdf
最新发布
06-06
其中SSM框架是最先被广泛应用的一种框架，它是由Spring、SpringMVC和MyBatis三个框架整合而成。此外，Spring框架也是Java EE开发中非常重要的一部分，它主要提供了全部企业级应用的核心技术和API，包括依赖注入、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值