windows简易版本 Redis 使用 demo样例（ssm框架下）

前些天发现了一个巨牛的人工智能学习网站，通俗易懂，风趣幽默，忍不住分享一下给大家。点击跳转到教程。

 1. 在网上下载 windows 版本 的Redis  。下载了直接解压出来 ：

 

 

2. 双击 redis-server.exe 启动服务（如下图），使用中就一直不要关闭这个窗口。（也可cdm命令中设置电脑开机自启动，就不用每次手动开启这个窗口）

 

 

3.   redis 配置：（任由你配置在哪个properties文件中，比如是A.properties文件）

我是配置在dbconfig.properties文件中的。

说明：

redis.host    --------  IP地址 , 如果是本机就127.0.0.1 。   如果是公司服务器就配置服务器IP。

redis.port     --------  jedis 端口号，默认为 6379。

其余都使用默认配置，不用更改。

 

#redis
redis.host=127.0.0.1 
redis.port=6379

redis.maxTotal=300
redis.maxIdle=10
redis.numTestsPerEvictionRun=1024
redis.timeBetweenEvictionRunsMillis=30000
redis.minEvictableIdleTimeMillis=1800000
redis.softMinEvictableIdleTimeMillis=10000
redis.maxWaitMillis=1500
redis.testOnBorrow=true
redis.testWhileIdle=true
redis.blockWhenExhausted=false

 

 

 

 

 

4.  spring配置文件中的配置：（任由你放在spring的哪个配置文件中，比如是B.xml 文件。但一定要在B.xml 中引入A.properties ）

 

	<!-- 引入配置文件：dbconfig.properties -->
	<context:property-placeholder location="classpath:dbconfig.properties" />
	
	<!-- jedis连接池配置 -->
	<bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
		<!-- 最大连接数 -->
		<property name="maxTotal" value="${redis.maxTotal}" />
		<!-- 最大空闲连接数 -->
		<property name="maxIdle" value="${redis.maxIdle}" />
		<!-- 每次释放连接的最大数目 -->
		<property name="numTestsPerEvictionRun" value="${redis.numTestsPerEvictionRun}" />
		<!-- 释放连接的扫描间隔（毫秒） -->
		<property name="timeBetweenEvictionRunsMillis" value="${redis.timeBetweenEvictionRunsMillis}" />
		<!-- 连接最小空闲时间 -->
		<property name="minEvictableIdleTimeMillis" value="${redis.minEvictableIdleTimeMillis}" />
		<!-- 连接空闲多久后释放, 当空闲时间>该值 且 空闲连接>最大空闲连接数 时直接释放 -->
		<property name="softMinEvictableIdleTimeMillis" value="${redis.softMinEvictableIdleTimeMillis}" />
		<!-- 获取连接时的最大等待毫秒数,小于零:阻塞不确定的时间,默认-1 -->
		<property name="maxWaitMillis" value="${redis.maxWaitMillis}" />
		<!-- 在获取连接的时候检查有效性, 默认false -->
		<property name="testOnBorrow" value="${redis.testOnBorrow}" />
		<!-- 在空闲时检查有效性, 默认false -->
		<property name="testWhileIdle" value="${redis.testWhileIdle}" />
		<!-- 连接耗尽时是否阻塞, false报异常,ture阻塞直到超时, 默认true -->
		<property name="blockWhenExhausted" value="${redis.blockWhenExhausted}" />
	</bean>
	
	<!-- jedis客户端单机版 -->
	<bean id="redisClient" class="redis.clients.jedis.JedisPool">
		<constructor-arg name="host" value="${redis.host}"></constructor-arg>
		<constructor-arg name="port" value="${redis.port}"></constructor-arg>
		<constructor-arg name="poolConfig" ref="jedisPoolConfig"></constructor-arg>
	</bean>
	<!-- 引用工程中自己书写的redis常用接口实现类 -->
	<bean id="_jedisClient" class="com.redis.impl.JedisClientSingle"/>
<!-- 引入配置文件：dbconfig.properties -->
	<context:property-placeholder location="classpath:dbconfig.properties" />
	
	<!-- jedis连接池配置 -->
	<bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
		<!-- 最大连接数 -->
		<property name="maxTotal" value="${redis.maxTotal}" />
		<!-- 最大空闲连接数 -->
		<property name="maxIdle" value="${redis.maxIdle}" />
		<!-- 每次释放连接的最大数目 -->
		<property name="numTestsPerEvictionRun" value="${redis.numTestsPerEvictionRun}" />
		<!-- 释放连接的扫描间隔（毫秒） -->
		<property name="timeBetweenEvictionRunsMillis" value="${redis.timeBetweenEvictionRunsMillis}" />
		<!-- 连接最小空闲时间 -->
		<property name="minEvictableIdleTimeMillis" value="${redis.minEvictableIdleTimeMillis}" />
		<!-- 连接空闲多久后释放, 当空闲时间>该值 且 空闲连接>最大空闲连接数 时直接释放 -->
		<property name="softMinEvictableIdleTimeMillis" value="${redis.softMinEvictableIdleTimeMillis}" />
		<!-- 获取连接时的最大等待毫秒数,小于零:阻塞不确定的时间,默认-1 -->
		<property name="maxWaitMillis" value="${redis.maxWaitMillis}" />
		<!-- 在获取连接的时候检查有效性, 默认false -->
		<property name="testOnBorrow" value="${redis.testOnBorrow}" />
		<!-- 在空闲时检查有效性, 默认false -->
		<property name="testWhileIdle" value="${redis.testWhileIdle}" />
		<!-- 连接耗尽时是否阻塞, false报异常,ture阻塞直到超时, 默认true -->
		<property name="blockWhenExhausted" value="${redis.blockWhenExhausted}" />
	</bean>
	
	<!-- jedis客户端单机版 -->
	<bean id="redisClient" class="redis.clients.jedis.JedisPool">
		<constructor-arg name="host" value="${redis.host}"></constructor-arg>
		<constructor-arg name="port" value="${redis.port}"></constructor-arg>
		<constructor-arg name="poolConfig" ref="jedisPoolConfig"></constructor-arg>
	</bean>
	<!-- 引用工程中自己书写的redis常用接口实现类 -->
	<bean id="_jedisClient" class="com.redis.impl.JedisClientSingle"/>

 

 

 

 

5.   maven  依赖：

 

		<!-- redis -->
		<dependency>
			<groupId>redis.clients</groupId>
			<artifactId>jedis</artifactId>
			<version>2.7.2</version>
		</dependency><!-- redis -->
		<dependency>
			<groupId>redis.clients</groupId>
			<artifactId>jedis</artifactId>
			<version>2.7.2</version>
		</dependency>

 

 

 

 

 

 

6.  书写的redis常用接口及其实现类：（这个主要看你需要哪些，不用的可以不定义）

 

接口：

 

package com.redis;

/**
 * redis java api 常用接口
 * @author JiangYu
 */
public interface JedisClient {
	
	/**
	 * 获取string缓存值
	 * @param key
	 * @return
	 */
	String get(String key);
	
	/**
	 * 设置string缓存值
	 * @param key
	 * @param value
	 * @param second
	 * @return
	 */
	String set(String key, String value);
	
	/**
	 * 设置string缓存值带失效时间
	 * @param key
	 * @param value
	 * @param second
	 * @return
	 */
	String set(String key, String value, int second);
	
	/**
	 * 获取hash缓存值
	 * @param hkey
	 * @param key
	 * @return
	 */
	String hget(String hkey, String key);
	
	/**
	 * 设置hash缓存值
	 * @param hkey
	 * @param key
	 * @param value
	 * @return
	 */
	long hset(String hkey, String key, String value);
	
	/**
	 * 递增缓存值
	 * @param key
	 * @return
	 */
	long incr(String key);
	
	/**
	 * 设置缓存值有效时间
	 * @param key
	 * @param second
	 * @return
	 */
	long expire(String key, int second);
	
	/**
	 * 获取缓存值失效时间
	 * @param key
	 * @return
	 */
	long ttl(String key);
	
	/**
	 * 删除string缓存值
	 * @param key
	 * @return
	 */
	long del(String key);
	
	/**
	 * 批量删除以string为前缀的key 
	 * @param key
	 * @return
	 */
	void batchDel(String key);
	
	/**
	 * 删除hash缓存值
	 * @param hkey
	 * @param key
	 * @return
	 */
	long hdel(String hkey, String key);
	
	/**
	 * 判断key是否存在
	 * @param key
	 * @return
	 */
	boolean exists(String key);
	
	/**
	 * 清空缓存数据
	 * @return
	 */
	boolean clear();
}

 

 

实现类：

 

package com.redis.impl;

import java.util.Iterator;
import java.util.Set;

import org.springframework.beans.factory.annotation.Autowired;

import com.redis.JedisClient;

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

/**
 * redis 常用接口实现
 * @author JiangYu
 *
 */
public class JedisClientSingle implements JedisClient {

	@Autowired
	private JedisPool jedisPool;

	/**
	 * 获取string缓存值
	 * @param key
	 * @return
	 */
	@Override
	public String get(String key) {
		Jedis jedis = jedisPool.getResource();
		String string = jedis.get(key);
		jedis.close();
		return string;
	}
	
	/**
	 * 设置string缓存值
	 * @param key
	 * @param value
	 * @param second
	 * @return
	 */
	@Override
	public String set(String key, String value) {
		Jedis jedis = jedisPool.getResource();
		String string = jedis.set(key, value);
		jedis.close();
		return string;
	}

	/**
	 * 设置string缓存值带失效时间
	 * @param key
	 * @param value
	 * @param second
	 * @return
	 */
	@Override
	public String set(String key, String value, int seconds) {
		Jedis jedis = jedisPool.getResource();
		String string = jedis.set(key, value);
		jedis.expire(key, seconds);
		jedis.close();
		return string;
	}

	/**
	 * 获取hash缓存值
	 * @param hkey
	 * @param key
	 * @return
	 */
	@Override
	public String hget(String hkey, String key) {
		Jedis jedis = jedisPool.getResource();
		String string = jedis.hget(hkey, key);
		jedis.close();
		return string;
	}

	/**
	 * 设置hash缓存值
	 * @param hkey
	 * @param key
	 * @param value
	 * @return
	 */
	@Override
	public long hset(String hkey, String key, String value) {
		Jedis jedis = jedisPool.getResource();
		Long result = jedis.hset(hkey, key, value);
		jedis.close();
		return result;
	}

	/**
	 * 递增缓存值
	 * @param key
	 * @return
	 */
	@Override
	public long incr(String key) {
		Jedis jedis = jedisPool.getResource();
		Long result = jedis.incr(key);
		jedis.close();
		return result;
	}

	/**
	 * 设置缓存值有效时间
	 * @param key
	 * @param second
	 * @return
	 */
	@Override
	public long expire(String key, int second) {
		Jedis jedis = jedisPool.getResource();
		Long result = jedis.expire(key, second);
		jedis.close();
		return result;
	}

	/**
	 * 获取缓存值失效时间
	 * @param key
	 * @return
	 */
	@Override
	public long ttl(String key) {
		Jedis jedis = jedisPool.getResource();
		Long result = jedis.ttl(key);
		jedis.close();
		return result;
	}

	/**
	 * 删除string缓存值
	 * @param key
	 * @return
	 */
	@Override
	public long del(String key) {
		Jedis jedis = jedisPool.getResource();
		Long result = jedis.del(key);
		jedis.close();
		return result;
	}
	
	/**
	 * 批量删除以string为前缀的key 
	 * @param key
	 * @return
	 */
	@Override
	public void batchDel(String key) {
		Jedis jedis = jedisPool.getResource();
		Set<String> set = jedis.keys(key+"*");  
        Iterator<String> it = set.iterator();  
        while(it.hasNext()){  
            String keyStr = it.next();  
            jedis.del(keyStr);
        }
        jedis.close();
	}

	/**
	 * 删除hash缓存值
	 * @param hkey
	 * @param key
	 * @return
	 */
	@Override
	public long hdel(String hkey, String key) {
		Jedis jedis = jedisPool.getResource();
		Long result = jedis.hdel(hkey, key);
		jedis.close();
		return result;
	}

	/**
	 * 判断key是否存在
	 * @param key
	 * @return
	 */
	@Override
	public boolean exists(String key) {
		Jedis jedis = jedisPool.getResource();
		boolean exists = jedis.exists(key);
		jedis.close();
		return exists;
	}

	/**
	 * 清空缓存数据
	 * @return
	 */
	@Override
	public boolean clear() {
		Jedis jedis = jedisPool.getResource();
		jedis.flushAll();
		jedis.close();
		return true;
	}

}

 

 

 

 

 

 

 

7.  测试通过，可以使用了：