Spring+redis整合

一、引入依赖jar包

	<!--Redis start -->
		<dependency>
			<groupId>org.springframework.data</groupId>
			<artifactId>spring-data-redis</artifactId>
			<version>1.6.1.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>redis.clients</groupId>
			<artifactId>jedis</artifactId>
			<version>2.7.3</version>
		</dependency>
   <!--Redis end -->

二、编写redis.properties

#redis中心
redis.host=192.168.207.131
redis.port=6379
redis.pass=123456
redis.maxIdle=100
redis.maxTotal=300
redis.maxWaitMillis=1000
redis.testOnBorrow=true
redis.timeout=100000

三、配置applicationContext-redis.xml

<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-4.3.xsd 
		http://www.springframework.org/schema/mvc 
		http://www.springframework.org/schema/mvc/spring-mvc-4.3.xsd 
		http://www.springframework.org/schema/context 
		http://www.springframework.org/schema/context/spring-context-4.3.xsd 
		http://www.springframework.org/schema/aop 
		http://www.springframework.org/schema/aop/spring-aop-4.3.xsd 
		http://www.springframework.org/schema/tx 
		http://www.springframework.org/schema/tx/spring-tx-4.3.xsd ">
		
	<!-- 加载properties文件 -->
	<context:property-placeholder location="classpath:redis.properties"/>
	<bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">
	    <property name="maxIdle" value="${redis.maxIdle}" />  
        <property name="maxTotal" value="${redis.maxTotal}" />  
        <property name="maxWaitMillis" value="${redis.maxWaitMillis}" />  
        <property name="testOnBorrow" value="${redis.testOnBorrow}" />  
	</bean>
	
	<bean id="connectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
        <property name="hostName" value="${redis.host}"/>
        <property name="port" value="${redis.port}"/>
        <property name="password" value="${redis.pass}"/>
        <property name="poolConfig" ref="poolConfig"/>
    </bean>  
      
<!--     <bean id="redisTemplate" class="org.springframework.data.redis.core.StringRedisTemplate">   -->
<!--         <property name="connectionFactory"   ref="connectionFactory" />   -->
<!--     </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 >         
      
    <bean id="userDao" class="com.my.ssm.dao.impl.UserDaoImpl">
    	<property name="redisTemplate" ref="redisTemplate" /> 
    </bean>   
	
</beans>

四、User类、UserDao、UserDaoImpl

public interface UserDao {

	boolean add(User user);
	
	boolean add(List<User> list);
	
	void delete(String key);
	
	void delete(List<String> keys);
	
	boolean update(User user);
	
	User get(String keyid);
	
}

package com.my.ssm.dao.impl;

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.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.data.redis.serializer.RedisSerializer;

import com.my.ssm.dao.UserDao;
import com.my.ssm.po.User;

public class UserDaoImpl implements UserDao {

	private RedisTemplate<String, User> redisTemplate;
	
	public void setRedisTemplate(RedisTemplate<String, User> redisTemplate) {
		this.redisTemplate = redisTemplate;
	}

	@Override
	public boolean add(final User user) {
		boolean result = redisTemplate.execute(new RedisCallback<Boolean>() {
			@Override
			public Boolean doInRedis(RedisConnection connection)
					throws DataAccessException {
				RedisSerializer<String> redisSerializer = redisTemplate.getStringSerializer();
				byte[] key = redisSerializer.serialize(user.getId().toString());
				byte[] name = redisSerializer.serialize(user.getUsername());
				return connection.setNX(key, name);
			}
		});
		return result;
	}

	@Override
	public boolean add(final List<User> list) {
		boolean result = redisTemplate.execute(new RedisCallback<Boolean>() {

			@Override
			public Boolean doInRedis(RedisConnection connection)
					throws DataAccessException {
				RedisSerializer<String> redisSerializer = redisTemplate.getStringSerializer();
				for(User user : list){
					byte[] key = redisSerializer.serialize(user.getId().toString());
					byte[] name = redisSerializer.serialize(user.getUsername());
					connection.set(key, name);
				}
				return true;
			}
		},false, true);
		return result;
	}

	@Override
	public void delete(String key) {
		redisTemplate.delete(key);
	}

	@Override
	public void delete(List<String> keys) {
		redisTemplate.delete(keys);

	}

	@Override
	public boolean update(final User user) {
		String userId = user.getId().toString();
		if(get(userId) == null){
			throw new NullPointerException("数据不存在"+userId);
		}
		boolean reuslt = redisTemplate.execute(new RedisCallback<Boolean>() {

			@Override
			public Boolean doInRedis(RedisConnection connection)
					throws DataAccessException {
				RedisSerializer<String> serializer = redisTemplate.getStringSerializer();
				byte[] key = serializer.serialize(user.getId().toString());
				byte[] name = serializer.serialize(user.getUsername());
				connection.set(key, name);
				return true;
			}
		});
		
		return reuslt;
	}

	@Override
	public User get(final String keyid) {
		User result = redisTemplate.execute(new RedisCallback<User>() {

			@Override
			public User doInRedis(RedisConnection connection)
					throws DataAccessException {
				RedisSerializer<String> serializer = redisTemplate.getStringSerializer();
				byte[] key = serializer.serialize(keyid);
				byte[] value = connection.get(key);
				if(value == null){
					return null;
				}
				String name = serializer.deserialize(key);
				User user = new User();
				user.setId(Integer.parseInt(keyid));
				user.setUsername(name);
				return user;
			}
		});
		return result;
	}

	
	public void addUser(User user){
		
		ValueOperations<String, User> opsForValue = redisTemplate.opsForValue();
		opsForValue.set(user.getId().toString(), user);
		
	}
}

也可通过一下方法实现

这些方法获取到个接口， 可以直接用命名模式操作redis服务器

	public void addUser(User user){
		
		ValueOperations<String, User> opsForValue = redisTemplate.opsForValue();
		opsForValue.set(user.getId().toString(), user);
		
	}

测试

package com.my.ssm.dao.impl;


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

import org.junit.Before;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.my.ssm.dao.UserDao;
import com.my.ssm.po.User;

public class UserDaoImplTest {

	ApplicationContext applicationContext = null;
	UserDao userDao = null;
	@Before
	public void setUp() throws Exception {
		applicationContext = new ClassPathXmlApplicationContext("spring/applicationContext-redis.xml");
		userDao = (UserDao) applicationContext.getBean("userDao");
	}

	@Test
	public void testAddUser() {
		User user = new User();
		user.setId(1);
		user.setUsername("张三");
		userDao.add(user);
	}

	@Test
	public void testAddListOfUser() {
		List<User> users = new ArrayList<User>();
		User u1 = new User();
		u1.setId(2);
		u1.setUsername("zhangsan");
		User u2 = new User();
		u2.setId(3);
		u2.setUsername("lisi");
		User u3 = new User();
		u3.setId(4);
		u3.setUsername("wangwu");
		users.add(u1);
		users.add(u2);
		users.add(u3);
		userDao.add(users);
	}

	@Test
	public void testDeleteString() {
		userDao.delete("1");
	}

	@Test
	public void testDeleteListOfString() {
		List<String> keys = new ArrayList<String>();
		userDao.delete(keys);
	}

	@Test
	public void testUpdate() {
		User user = new User();
		user.setId(1);
		user.setUsername("aaaa");
		userDao.update(user);
	}

	@Test
	public void testGet() {
		User user = userDao.get("1");
		System.out.println(user);
	}
	
	@Test
	public void testAddUser1() {
		User user = new User();
		user.setId(22);
		user.setUsername("222");
		userDao.add(user);
	}

}