• Redis实战之征服 Redis + Jedis + Spring （一）

    相关链接：

    Redis实战

    Redis实战之Redis + Jedis

    Redis实战之征服 Redis + Jedis + Spring （一）

    Redis实战之征服 Redis + Jedis + Spring （二）

    Redis实战之征服 Redis + Jedis + Spring （三）

    前文有述，Spring提供了对于Redis的专门支持：spring-data-redis。此外，类似的还有：


    我想大部分人对spring-data-hadoop、spring-data-mongodb、spring-data-redis以及spring-data-jpa表示关注。

    一、简述

    spring把专门的数据操作独立封装在spring-data系列中，spring-data-redis自然是针对Redis的独立封装了。

    当前版本1.0.1，主要是将jedis、jredis、rjc以及srp等Redis Client进行了封装，同时支持事务。已经让我垂涎欲滴了。当然，当前版本不支持Sharding。例如，前文曾经通过Jedis通过Client配置，实现一致性哈希，达到Sharding的目的。再一点，如果你早在spring1.x写过SpringJdbc的话，现在会觉得似曾相识。

    在经过一番思想斗争后，我最终放弃了Jedis原生实现，拥抱spring-data-redis了。为什么？因为，我需要一个有事务机制的框架，一个不需要显式调用对象池操作的框架。这些spring-data-redis都解决了。至于Sharding，当前数据量要求还不大，期待Redis 3.0吧。

    二、配置

    对象池配置：

    1. <bean  
    2.         id="jedisPoolConfig"  
    3.         class="redis.clients.jedis.JedisPoolConfig"  
    4.     >  
    5.         <property  
    6.             name="maxActive"  
    7.             value="${redis.pool.maxActive}" />  
    8.         <property  
    9.             name="maxIdle"  
    10.             value="${redis.pool.maxIdle}" />  
    11.         <property  
    12.             name="maxWait"  
    13.             value="${redis.pool.maxWait}" />  
    14.         <property  
    15.             name="testOnBorrow"  
    16.             value="${redis.pool.testOnBorrow}" />  
    17.     </bean>  
    <bean
		id="jedisPoolConfig"
		class="redis.clients.jedis.JedisPoolConfig"
	>
		<property
			name="maxActive"
			value="${redis.pool.maxActive}" />
		<property
			name="maxIdle"
			value="${redis.pool.maxIdle}" />
		<property
			name="maxWait"
			value="${redis.pool.maxWait}" />
		<property
			name="testOnBorrow"
			value="${redis.pool.testOnBorrow}" />
	</bean>

    工厂实现：

    1. <bean  
    2.     id="jedisConnectionFactory"  
    3.     class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory"  
    4. >  
    5.     <property  
    6.         name="hostName"  
    7.         value="${redis.ip}" />  
    8.     <property  
    9.         name="port"  
    10.         value="${redis.port}" />  
    11.     <property  
    12.         name="poolConfig"  
    13.         ref="jedisPoolConfig" />  
    14. </bean>  
    	<bean
		id="jedisConnectionFactory"
		class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory"
	>
		<property
			name="hostName"
			value="${redis.ip}" />
		<property
			name="port"
			value="${redis.port}" />
		<property
			name="poolConfig"
			ref="jedisPoolConfig" />
	</bean>

    模板类：

    1. <bean  
    2.         class="org.springframework.data.redis.core.RedisTemplate"  
    3.         p:connection-factory-ref="jedisConnectionFactory" />  
    <bean
		class="org.springframework.data.redis.core.RedisTemplate"
		p:connection-factory-ref="jedisConnectionFactory" />

    是不是很像配置一个JdbcTemplate？其实就这么简单。

    redis.properties配置如下：

    1. #最大分配的对象数  
    2. redis.pool.maxActive=1024  
    3. #最大能够保持idel状态的对象数  
    4. redis.pool.maxIdle=200  
    5. #当池内没有返回对象时，最大等待时间  
    6. redis.pool.maxWait=1000  
    7. #当调用borrow Object方法时，是否进行有效性检查  
    8. redis.pool.testOnBorrow=true  
    9.   
    10. #IP  
    11. redis.ip=10.11.20.140  
    12. #Port  
    13. redis.port=6379  
    #最大分配的对象数
redis.pool.maxActive=1024
#最大能够保持idel状态的对象数
redis.pool.maxIdle=200
#当池内没有返回对象时，最大等待时间
redis.pool.maxWait=1000
#当调用borrow Object方法时，是否进行有效性检查
redis.pool.testOnBorrow=true

#IP
redis.ip=10.11.20.140
#Port
redis.port=6379

    当前只能用一个节点，期待Redis 3.0，Sharding吧！

    三、GET、SET、DEL操作

    Redis初来乍练，目前也就是用Memcached多些，只会这些基本的操作，在这里献丑了！

    假定做一个UserDao：

    1. public interface UserDao {  
    2.     /** 
    3.      * @param uid 
    4.      * @param address 
    5.      */  
    6.     void save(User user);  
    7.   
    8.     /** 
    9.      * @param uid 
    10.      * @return 
    11.      */  
    12.     User read(String uid);  
    13.   
    14.     /** 
    15.      * @param uid 
    16.      */  
    17.     void delete(String uid);  
    18. }  
    public interface UserDao {
	/**
	 * @param uid
	 * @param address
	 */
	void save(User user);

	/**
	 * @param uid
	 * @return
	 */
	User read(String uid);

	/**
	 * @param uid
	 */
	void delete(String uid);
}

    User对象就这么两个属性：

    1. public class User implements Serializable {  
    2.   
    3.     private static final long serialVersionUID = -1267719235225203410L;  
    4.   
    5.     private String uid;  
    6.   
    7.     private String address;  
    8. }  
    public class User implements Serializable {

	private static final long serialVersionUID = -1267719235225203410L;

	private String uid;

	private String address;
}

    实现这三个方法需要得到RedisTemplate的支持：

    1. @Autowired  
    2. private RedisTemplate<Serializable, Serializable> redisTemplate;  
    	@Autowired
	private RedisTemplate<Serializable, Serializable> redisTemplate;

     为什么用序列化泛型？我存的数据都是可序列化的内容。还有更多为什么？其实我也解答不了很多，边练边学，我弄通了一定告诉你！

    1.保存-SET

    做一个保存造作，使用Redis的SET命令：

    1. @Override  
    2. public void save(final User user) {  
    3.     redisTemplate.execute(new RedisCallback<Object>() {  
    4.         @Override  
    5.         public Object doInRedis(RedisConnection connection)  
    6.                 throws DataAccessException {  
    7.             connection.set(  
    8.                     redisTemplate.getStringSerializer().serialize(  
    9.                             "user.uid." + user.getUid()),  
    10.                     redisTemplate.getStringSerializer().serialize(  
    11.                             user.getAddress()));  
    12.             return null;  
    13.         }  
    14.     });  
    15. }  
    	@Override
	public void save(final User user) {
		redisTemplate.execute(new RedisCallback<Object>() {
			@Override
			public Object doInRedis(RedisConnection connection)
					throws DataAccessException {
				connection.set(
						redisTemplate.getStringSerializer().serialize(
								"user.uid." + user.getUid()),
						redisTemplate.getStringSerializer().serialize(
								user.getAddress()));
				return null;
			}
		});
	}

     这里是通过模板类，实现方法回调。在spring框架下，可以方便的控制事务，如果你研究过spring的dao源代码，对此一定熟悉。

    1. 传入参数，需要final标识，禁止方法内修改。
    2. 调用RedisConnection的set方法实现Redis的SET命令。
    3. 不管是Key，还是Value都需要进行Serialize。
    4. 序列化操作，最好使用RedisTemplate提供的Serializer来完成。

    这跟当年的SpringJdbcTemplate有那么一拼！

    2.获取-GET

    想要将对象从Redis中取出来，就麻烦一些，需要序列化key，最好判断下这个key是否存在，避免无用功。如果键值存在，需要对数据反序列化。

    1. @Override  
    2. public User read(final String uid) {  
    3.     return redisTemplate.execute(new RedisCallback<User>() {  
    4.         @Override  
    5.         public User doInRedis(RedisConnection connection)  
    6.                 throws DataAccessException {  
    7.             byte[] key = redisTemplate.getStringSerializer().serialize(  
    8.                     "user.uid." + uid);  
    9.             if (connection.exists(key)) {  
    10.                 byte[] value = connection.get(key);  
    11.                 String address = redisTemplate.getStringSerializer()  
    12.                         .deserialize(value);  
    13.                 User user = new User();  
    14.                 user.setAddress(address);  
    15.                 user.setUid(uid);  
    16.                 return user;  
    17.             }  
    18.             return null;  
    19.         }  
    20.     });  
    21. }  
    	@Override
	public User read(final String uid) {
		return redisTemplate.execute(new RedisCallback<User>() {
			@Override
			public User doInRedis(RedisConnection connection)
					throws DataAccessException {
				byte[] key = redisTemplate.getStringSerializer().serialize(
						"user.uid." + uid);
				if (connection.exists(key)) {
					byte[] value = connection.get(key);
					String address = redisTemplate.getStringSerializer()
							.deserialize(value);
					User user = new User();
					user.setAddress(address);
					user.setUid(uid);
					return user;
				}
				return null;
			}
		});
	}

     当年写SpringJdbc的时候，就是这样一个字段一个字段拼装的，甭提多累人。好吧，用Spring-Data-Redis，又让我回归了！

    1. 记得使用泛型，如RedisCallback<User>()
    2. 使用同一的序列化/反序列化Serializer
    3. 建议使用connection.exists(key)判别键值是否存在，避免无用功

    3.删除-DEL

    删除，就简单点，不过也需要这样折腾一会：

    1. @Override  
    2. public void delete(final String uid) {  
    3.     redisTemplate.execute(new RedisCallback<Object>() {  
    4.         public Object doInRedis(RedisConnection connection) {  
    5.             connection.del(redisTemplate.getStringSerializer().serialize(  
    6.                     "user.uid." + uid));  
    7.             return null;  
    8.         }  
    9.     });  
    10. }  
    	@Override
	public void delete(final String uid) {
		redisTemplate.execute(new RedisCallback<Object>() {
			public Object doInRedis(RedisConnection connection) {
				connection.del(redisTemplate.getStringSerializer().serialize(
						"user.uid." + uid));
				return null;
			}
		});
	}

    做个TestCase，暂时够我用了！

    4. TestCase

    1. import static org.junit.Assert.*;  
    2. import org.junit.Before;  
    3. import org.junit.Test;  
    4. import org.springframework.context.ApplicationContext;  
    5. import org.springframework.context.support.ClassPathXmlApplicationContext;  
    6. import org.zlex.redis.dao.UserDao;  
    7. import org.zlex.redis.domain.User;  
    8.   
    9. public class UserDaoTest {  
    10.     private ApplicationContext app;  
    11.     private UserDao userDao;  
    12.   
    13.     @Before  
    14.     public void before() throws Exception {  
    15.         app = new ClassPathXmlApplicationContext("applicationContext.xml");  
    16.         userDao = (UserDao) app.getBean("userDao");  
    17.     }  
    18.   
    19.     @Test  
    20.     public void crud() {  
    21.         // -------------- Create ---------------  
    22.         String uid = "u123456";  
    23.         String address1 = "上海";  
    24.         User user = new User();  
    25.         user.setAddress(address1);  
    26.         user.setUid(uid);  
    27.         userDao.save(user);  
    28.   
    29.         // ---------------Read ---------------  
    30.         user = userDao.read(uid);  
    31.   
    32.         assertEquals(address1, user.getAddress());  
    33.   
    34.         // --------------Update ------------  
    35.         String address2 = "北京";  
    36.         user.setAddress(address2);  
    37.         userDao.save(user);  
    38.   
    39.         user = userDao.read(uid);  
    40.   
    41.         assertEquals(address2, user.getAddress());  
    42.   
    43.         // --------------Delete ------------  
    44.         userDao.delete(uid);  
    45.         user = userDao.read(uid);  
    46.         assertNull(user);  
    47.     }  
    48. }  
    import static org.junit.Assert.*;
import org.junit.Before;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.zlex.redis.dao.UserDao;
import org.zlex.redis.domain.User;

public class UserDaoTest {
	private ApplicationContext app;
	private UserDao userDao;

	@Before
	public void before() throws Exception {
		app = new ClassPathXmlApplicationContext("applicationContext.xml");
		userDao = (UserDao) app.getBean("userDao");
	}

	@Test
	public void crud() {
		// -------------- Create ---------------
		String uid = "u123456";
		String address1 = "上海";
		User user = new User();
		user.setAddress(address1);
		user.setUid(uid);
		userDao.save(user);

		// ---------------Read ---------------
		user = userDao.read(uid);

		assertEquals(address1, user.getAddress());

		// --------------Update ------------
		String address2 = "北京";
		user.setAddress(address2);
		userDao.save(user);

		user = userDao.read(uid);

		assertEquals(address2, user.getAddress());

		// --------------Delete ------------
		userDao.delete(uid);
		user = userDao.read(uid);
		assertNull(user);
	}
}

     貌似少了update，也许以后操作Hash时，会用上。

    看看控制台获得了什么： 

    redis 127.0.0.1:6379> get user.uid.u123456
    (nil)
    redis 127.0.0.1:6379> get user.uid.u123456
    "xe5x8cx97xe4xbaxac"
    redis 127.0.0.1:6379> get user.uid.u123456
    "xe4xb8x8axe6xb5xb7"
    redis 127.0.0.1:6379> del user.uid.u123456
    (integer) 1
    redis 127.0.0.1:6379> get user.uid.u123456
    (nil)
    redis 127.0.0.1:6379> get user.uid.u123456
    "xe4xb8x8axe6xb5xb7"

     好吧，可以开始用它来存点什么了！

    相关链接：

    Redis实战

    Redis实战之Redis + Jedis

    Redis实战之征服 Redis + Jedis + Spring （一）

    Redis实战之征服 Redis + Jedis + Spring （二）

    Redis实战之征服 Redis + Jedis + Spring （三）
  • 相关阅读:
    创建桌面快捷方式
    令牌桶在数据通信QoS流量监管中的应用
    cocos2d-x 实现clash of clans多点聚焦缩放场景
    NotePad++ 快捷键中文说明
    2017第24周日
    《自信力~成为更好的自己》晨读笔记
    不知道如何决定的时候就快速决定
    《意外之外》晨读笔记
    《从“为什么”开始》听书笔记
    解决电脑上网问题记录
  • 原文地址：https://www.cnblogs.com/sand-tiny/p/3894913.html
Copyright © 2020-2023  润新知