Spring整合redis（設置密碼）完整版

時間 2019-11-07

原文原文鏈接

博主在上個項目中使用了redis，開始使用的jedisPool鏈接池的方式進行整合，發現這樣是不安全，調研了一下，選擇了設置redis密碼從新整合，總結經驗以下：java

1）導入Spring-redis的jar具體以下：

2）配置Spring-redis.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: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 ">
    <!-- 鏈接池配置 -->
    <bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">
        <!-- 最大鏈接數 -->
        <property name="maxActive" value="30" />
        <!-- 最大空閒鏈接數 -->
        <property name="maxIdle" value="10" />
        <!-- 每次釋放鏈接的最大數目 -->
        <property name="numTestsPerEvictionRun" value="1024" />
        <!-- 釋放鏈接的掃描間隔（毫秒） -->
        <property name="timeBetweenEvictionRunsMillis" value="30000" />
        <!-- 鏈接最小空閒時間 -->
        <property name="minEvictableIdleTimeMillis" value="1800000" />
        <!-- 鏈接空閒多久後釋放, 當空閒時間>該值 且 空閒鏈接>最大空閒鏈接數 時直接釋放 -->
        <property name="softMinEvictableIdleTimeMillis" value="10000" />
        <!-- 獲取鏈接時的最大等待毫秒數,小於零:阻塞不肯定的時間,默認-1 -->
        <property name="MaxWait" value="15000" />
        <!-- 在獲取鏈接的時候檢查有效性, 默認false -->
        <property name="testOnBorrow" value="true" />
        <!-- 在空閒時檢查有效性, 默認false -->
        <property name="testWhileIdle" value="true" />
    </bean>

    <!-- redis服務器中心 -->  
   <bean id="connectionFactory"  class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory" >  
         <property name="poolConfig" ref="poolConfig" />    

<!-- 端口號-->
         <property name="port" value="6379" />  

<!-- host-->
         <property name="hostName" value="172.16.30.73" />  

<!-- redis密碼-->
         <property name="password" value="123456" />  
         <property name="usePool" value="true"></property>
         <property name="timeout" value="20000" ></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.JdkSerializationRedisSerializer" />  
         </property>  
   </bean >
 <!-- 將redisTemplate注入redisSession -->
  <bean id="redisSession" class="com.custle.webutil.RedisSession">
  		<property name="redisTemplate" ref="redisTemplate"/>
  </bean>
  
</beans>

3)配置Redis會話工具類

須要聲明一點，Static變量使用Spring注入，Static變量的set方法不能加上static修飾。web

package com.custle.webutil;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.Closeable;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;

import javax.annotation.PostConstruct;
import javax.annotation.Resource;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;

import com.custle.vo.info.UserInfoVO;

public class RedisSession {
	private static ApplicationContext context;
	private static RedisTemplate<Serializable, Object> redisTemplate;
	private static int validTime =  60*30; //單位秒 

	/*static {
		// 加載配置文件
		context = new ClassPathXmlApplicationContext("applicationContext-redis.xml");
		
		redisTemplate = (RedisTemplate<Serializable, Object>) context.getBean("redisTemplate");
	}*/
	public  RedisTemplate<Serializable, Object> getRedisTemplate() {
		return redisTemplate;
	}
       //spring設置注入redisTemplate
	public  void setRedisTemplate(RedisTemplate<Serializable, Object> redisTemplate) {
		RedisSession.redisTemplate = redisTemplate;
	}
	
	public static void setAttribute(String token, String name, Serializable value) throws UnsupportedEncodingException {
		ValueOperations<Serializable, Object> operations = redisTemplate  
                .opsForValue(); 
		Object obj = operations.get(token);
		Map<String, Serializable> session;
		if(obj == null){
			session = new HashMap<String, Serializable>();
		}else{
			session = (Map<String, Serializable>) obj;
		}
		session.put(name, value);
		operations.set(token, session);
		redisTemplate.expire(token, validTime, TimeUnit.SECONDS);
	
		//返回鏈接
	}
	
	public static Object getAttribute(String token, String name) throws UnsupportedEncodingException {
		ValueOperations<Serializable, Object> operations = redisTemplate  
                .opsForValue(); 
		Object obj = operations.get(token);
		Map<String, Serializable> session = (Map<String, Serializable>) obj;
		if (null != session) {
			//若存在，延長有效期
			redisTemplate.expire(token, validTime, TimeUnit.SECONDS);
			return session.get(name);
		}
		return null;
	}
	
	/**
	 * 一次取多個值
	 * @param token
	 * @param names
	 * @return
	 * @throws UnsupportedEncodingException
	 */
	public static Map<String,Serializable> getMap(String token) throws UnsupportedEncodingException {
		ValueOperations<Serializable, Object> operations = redisTemplate  
                .opsForValue(); 
		Object obj = operations.get(token);
		Map<String, Serializable> session = (Map<String, Serializable>) obj;
		if (null != session) {
			//若存在，延長有效期
			redisTemplate.expire(token, validTime, TimeUnit.SECONDS);
			return session;
		}
		return null;
	}
	
	/**
	 * 批量存
	 * @param token
	 * @param name
	 * @param value
	 * @throws UnsupportedEncodingException
	 */
	public static void setMap(String token,HashMap<String, Serializable> map) throws UnsupportedEncodingException {
		ValueOperations<Serializable, Object> operations = redisTemplate  
                .opsForValue(); 
		Object obj = operations.get(token);
		Map<String, Serializable> session;
		if(obj == null){
			session = new HashMap<String, Serializable>();
		}else{
			session = (Map<String, Serializable>) obj;
		}
		session.putAll(map);
		operations.set(token, session);
		redisTemplate.expire(token, validTime, TimeUnit.SECONDS);
	}

	public static void logout(String token) throws UnsupportedEncodingException {
		ValueOperations<Serializable, Object> operations = redisTemplate  
                .opsForValue(); 
		// 若是存在這個key 則刪除此條數據
		if (redisTemplate.hasKey(token)) {
			redisTemplate.delete(token);
		}
	}
	

	public static void setAttribute(String token, String name, Serializable value, int timeOut) throws UnsupportedEncodingException {
		ValueOperations<Serializable, Object> operations = redisTemplate  
                .opsForValue(); 
		Object obj = operations.get(token);
		Map<String, Serializable> session;
		if(obj == null){
			session = new HashMap<String, Serializable>();
		}else{
			session = (Map<String, Serializable>) obj;
		}
		session.put(name, value);
		// 保存到redis
		operations.set(token, session);
		redisTemplate.expire(token, timeOut, TimeUnit.SECONDS);
		//redisTemplate.expire(token, validTime, TimeUnit.SECONDS);
		//返回鏈接
	}
	
	
	/**
	 * 設置普通的redis緩存(不帶session)
	 * @param key
	 * @param value
	 * @param timeOut
	 * @throws UnsupportedEncodingException
	 */
	public static void setCommonAttribute(String key, Object value, int timeOut) throws UnsupportedEncodingException {
		ValueOperations<Serializable, Object> operations = redisTemplate  
                .opsForValue(); 
		// 保存到redis
		operations.set(key, value);
		redisTemplate.expire(key, timeOut, TimeUnit.SECONDS);
		//返回鏈接
	}
	
	/**
	 * 設置存入Oject的redis緩存(不帶session)
	 * @param key
	 * @param value 
	 * @param timeOut
	 * @throws UnsupportedEncodingException
	 */
	public static void setObjectAttribute(String key, Object value, int timeOut) throws UnsupportedEncodingException {
		ValueOperations<Serializable, Object> operations = redisTemplate  
                .opsForValue(); 
		// 保存到redis
		operations.set(key, value);
		redisTemplate.expire(key, timeOut, TimeUnit.SECONDS);
		//返回鏈接
	}
	
	public static Object getObjectAttribute(String key) throws UnsupportedEncodingException {
		ValueOperations<Serializable, Object> operations = redisTemplate  
                .opsForValue(); 
		// 保存到redis
		return operations.get(key);
		//返回鏈接
	}
	
	
	public static Object getCommonAttribute(String key) throws UnsupportedEncodingException {
		ValueOperations<Serializable, Object> operations = redisTemplate  
                .opsForValue(); 
		// 保存到redis
		return operations.get(key);
		//返回鏈接
	}
	
    /** 
     * 序列化 list 集合 
     *  
     * @param list 
     * @return 
     */  
    public static byte[] serializeList(List<?> list) {  
  
        ObjectOutputStream oos = null;  
        ByteArrayOutputStream baos = null;  
        byte[] bytes = null;  
        try {  
            baos = new ByteArrayOutputStream();  
            oos = new ObjectOutputStream(baos);  
            for (Object obj : list) {  
                oos.writeObject(obj);  
            }  
            bytes = baos.toByteArray();  
        } catch (Exception e) {  
            e.printStackTrace();  
        } finally {  
            close(oos);  
            close(baos);  
        }  
        return bytes;  
    }  
  
    /** 
     * 反序列化 list 集合 
     *  
     * @param lb 
     * @return 
     */  
    public static List<?> unserializeList(byte[] bytes) {  
        if (bytes == null) {  
            return null;  
        }  
  
        List<Object> list = new ArrayList<Object>();  
        ByteArrayInputStream bais = null;  
        ObjectInputStream ois = null;  
        try {  
            // 反序列化  
            bais = new ByteArrayInputStream(bytes);  
            ois = new ObjectInputStream(bais);  
            while (bais.available() > 0) {  
                Object obj = (Object) ois.readObject();  
                if (obj == null) {  
                    break;  
                }  
                list.add(obj);  
            }  
        } catch (Exception e) {  
            e.printStackTrace();  
        } finally {  
            close(bais);  
            close(ois);  
        }  
        return list;  
    }  
  
    /** 
     * 關閉io流對象 
     *  
     * @param closeable 
     */  
    public static void close(Closeable closeable) {  
        if (closeable != null) {  
            try {  
                closeable.close();  
            } catch (Exception e) {  
                e.printStackTrace();  
            }  
        }  
    }
    
    
}