spring+Redis

这里如何创建Maven项目就不说了，直接进入主题 Windwo下安装Redis。

温馨提示:官方没有Windows版的Redis,不过不用慌张。

下载地址:https://github.com/Aiaoaoao/Redis-Windows

一、Redis安装

1、将Redis-x64-3.2.100.zip解压改名为redis放入C盘下(当然这一点随心就好)

2、进入redis文件下按住Shift+右键 在此打开命令窗口

3、将Redis加入windows服务，在命令窗口输入：redis-server.exe --service-install redis.windows.conf --loglevel verbose

4、在服务中启动redis 这样redis就安装完成 这里就不设置密码了 设置密码需要改redis.windows.conf配置就好了

二、spring + Redis

 

1、在pom.xml中加入依赖

 <!--Spring-Redis-->
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>2.5.1</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-redis</artifactId>
            <version>1.7.2.RELEASE</version>
            <exclusions>
                <exclusion>
                    <groupId>org.springframework</groupId>
                    <artifactId>spring-orm</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

2、创建redis.properties配置文件

redis.host=127.0.0.1 
redis.port=6379 //端口
redis.pass=redis //redis密码
  
  
redis.maxIdle=300
redis.maxWaitMillis=1000
redis.maxTotal=10000
redis.testOnBorrow=true
redis.database=0
redis.timeout=0
redis.usePool=true
redis.enableTransactionSupport=true

3、将redis交由spring管理  创建配置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:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="
		http://www.springframework.org/schema/beans
		http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
	    ">
		<!-- redis连接池 -->
    <bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig"
          p:maxIdle="${redis.maxIdle}" p:maxTotal="${redis.maxTotal}"  p:maxWaitMillis="${redis.maxWaitMillis}" p:testOnBorrow="${redis.testOnBorrow}">
    </bean>
    
    <!-- 序列化 -->
    <bean id="jdkSerializationRedisSerializer"
          class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer"/>

    <bean id="jedisConnFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory"
          p:hostName="${redis.host}" p:port="${redis.port}" p:password="${redis.pass}" p:poolConfig-ref="poolConfig"
          p:usePool="${redis.usePool}"
          p:database="${redis.database}"
          p:timeout="${redis.timeout}"/>

    <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate"
          p:defaultSerializer-ref="jdkSerializationRedisSerializer"
          p:keySerializer-ref="jdkSerializationRedisSerializer"
          p:valueSerializer-ref="jdkSerializationRedisSerializer"
          p:connectionFactory-ref="jedisConnFactory"
          p:enableTransactionSupport="${redis.enableTransactionSupport}"
    />
    
 

</beans>

4、在spring配置中加载redis配置

   <context:property-placeholder location="classpath:redis.properties"/>
    <!-- 导入redis的配置文件 -->
    <import resource="spring-redis.xml"/>

5、启动服务一路畅通无阻 ojbk 那就说明配置成功。

三、下面是redis在spring下的一些通用接口

package com.yc.education.service;

import java.util.Date;

/**
 * redis 的操作开放接口
 * 
 * @author 
 * 
 *        
 */
public interface RedisService {
	
	/**
     * 通过key删除
     * 
     * @param keys
     */
    public abstract void del(String... keys);
    
	/**
     * 通过key删除
     * 
     * @param key
     */
    public abstract void del(String key);


    /**
     * 添加key value 
     * 
     * @param key
     * @param value
     * 
     */
    public abstract boolean set(final String key, Object value);
    
    /**
     * 添加key value 
     * 
     * @param key
     * @param value
     * 
     */
    public abstract boolean set(Object key, Object value);


    /**
     * 添加key value 并且设置存活时间
     * 
     * @param key
     * @param value
     * @param liveTime
     *            单位秒
     */
    public abstract boolean set(final String key, Object value, Long expireTime);


    /**
     * 获取redis value (String)
     * 
     * @param key
     * @return
     */
    public abstract Object get(String key);

    /**
     * 通过正则匹配keys
     * 
     * @param pattern
     * @return
     */
    public abstract void Setkeys(String pattern);

    /**
     * 检查key是否已经存在
     * 
     * @param key
     * @return
     */
    public abstract boolean exists(String key);

    /** 
     * 指定缓存的失效时间 
     *  
     * 
     * @date 2016年8月14日 
     * @param key 缓存KEY 
     * @param time 失效时间(秒) 
     */  
    public abstract void expireAt(String key, Date time);
    
    
    /** 
     * 指定缓存的失效时间 
     *  
     * 
     * @date 2016年8月14日 
     * @param key 缓存KEY 
     * @param time 失效时间(秒) 
     */  
    public abstract void expireAt(Object key, Date time);
    
    
    
    /** 
     * 指定缓存的失效时间 
     *  
     * 
     * @date 2016年8月14日 
     * @param key 缓存KEY 
     * @param time 失效时间(秒) 
     */  
    public abstract void expire(String key, long lon);
    
    /**
     * 清空redis 所有数据
     * 
     * @return
     */
    public abstract String flushDB();

    /**
     * 查看redis里有多少数据
     */
    public abstract long dbSize();

    /**
     * 检查是否连接成功
     * 
     * @return
     */
    public abstract String ping();
    
    
    /**
     * 发送消息
     */
    
    public abstract void sendMassages(String obj);


    /**
     * 关闭数据库连接
     */
    public abstract  void  close();

    public void closeConnet();

    public int getConnetSize();

}

实现接口:

package com.yc.education.service.impl;

import com.yc.education.service.RedisService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.core.RedisConnectionUtils;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Service;

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

@Service()
public class RedisServiceImpl implements RedisService {

	@Autowired
	private  RedisTemplate redisTemplate;

	@Override
	public void closeConnet(){

		redisTemplate.discard();
	}

	@Override
	public int getConnetSize(){
		return redisTemplate.getClientList().size();
	}
	
	@Override
	public void del(String key) {

		 if (exists(key)) {  
	            redisTemplate.delete(key); 
	        }  
	}

	
	@Override
	public void del(String... keys) {
		 for (String key : keys) {  
			 del(key);  
	        }  
	}

	@Override
	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;  
	}
	
	@Override
	public boolean set(Object key, Object value) {
		 boolean result = false;  
	        try {  
	            ValueOperations<Object, Object> operations = redisTemplate  
	                    .opsForValue();  
	            operations.set(key, value);
	            result = true;  
	        } catch (Exception e) {  
	            e.printStackTrace();  
	              
	        }  
	        return result;  
	}

	@Override
	public boolean set(final String key, Object value, Long expireTime) {
		// TODO Auto-generated method stub
		 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;    
	}


	@Override
	public Object get(final String key) {
		Object result = null;  
        ValueOperations<Serializable, Object> operations = redisTemplate  
                .opsForValue();
        result = operations.get(key);
        return result;
	}

	@Override
	public void Setkeys(final String pattern){
		 Set<Serializable> keys = redisTemplate.keys(pattern);  
	        if (keys.size() > 0)  
	            redisTemplate.delete(keys);  
	}

	@Override
	public boolean exists(final String key) {
		 return redisTemplate.hasKey(key);  
	}
	
	
	@Override
    public  void expireAt(String key, Date time) {
        if(time.getTime() > 0){  
        	redisTemplate.expireAt(key, time);
        }
    }  
	
	@Override
    public  void expireAt(Object key, Date time) {
        if(time.getTime() > 0){  
        	redisTemplate.expireAt(key, time);
        }  
    }  
	
	@Override
    public  void expire(String key, long lon) {  
    }

	@Override
	public String flushDB() {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public long dbSize() {
		// TODO Auto-generated method stub
		return 0;
	}

	@Override
	public String ping() {
		// TODO Auto-generated method stub
		return "";
	}

	/*/**
     * 发送消息
     */
	@Override
	public void sendMassages(String obj) {
		redisTemplate.convertAndSend("__key*__:expired",obj);
	}

	@Override
	public void close() {

		redisTemplate.exec();
		// 获取当前线程绑定的连接
		RedisConnection conn = RedisConnectionUtils.bindConnection(redisTemplate.getConnectionFactory(), true);
		//返还给连接池
		conn.close();

	}


}

这样spring中使用redis就搭建完成了。妈妈再也不用担心我的技术。希望对你们有帮助。