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

Ne0inhk

— 8 min read
Redis实战之征服 Redis + Jedis + Spring （一）

接着需要快速的调研下基于Spring框架下的Redis操作。

相关链接：

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


www.zeeklog.com - Redis实战之征服 Redis + Jedis + Spring （一）

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

www.zeeklog.com - Redis实战之征服 Redis + Jedis + Spring （一）

一、简述

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

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

www.zeeklog.com - Redis实战之征服 Redis + Jedis + Spring （一）

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

二、配置

对象池配置：

Xml代码

  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>

工厂实现：

Xml代码

  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>

模板类：

Xml代码

  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？其实就这么简单。

www.zeeklog.com - Redis实战之征服 Redis + Jedis + Spring （一）

redis.properties配置如下：

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
  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吧！

www.zeeklog.com - Redis实战之征服 Redis + Jedis + Spring （一）

三、GET、SET、DEL操作

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

www.zeeklog.com - Redis实战之征服 Redis + Jedis + Spring （一）

假定做一个UserDao：

Java代码

  1. public interface UserDao {
  2. /**
  3. * @param uid
  4. * @param address
  5. */
  6. void save(User user);
  8. /**
  9. * @param uid
  10. * @return
  11. */
  12. User read(String uid);
  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对象就这么两个属性：

Java代码

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

	private static final long serialVersionUID = -1267719235225203410L;

	private String uid;

	private String address;
}

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

Java代码

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

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

www.zeeklog.com - Redis实战之征服 Redis + Jedis + Spring （一）

1.保存-SET

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

Java代码

  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源代码，对此一定熟悉。

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

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

2.获取-GET

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

Java代码

  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

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

Java代码

  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，暂时够我用了！

www.zeeklog.com - Redis实战之征服 Redis + Jedis + Spring （一）

4. TestCase

Java代码

  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;
  9. public class UserDaoTest {
  10. private ApplicationContext app;
  11. private UserDao userDao;
  13. @Before
  14. public void before() throws Exception {
  15. app = new ClassPathXmlApplicationContext("applicationContext.xml");
  16. userDao = (UserDao) app.getBean("userDao");
  17. }
  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);
  29. // ---------------Read ---------------
  30. user = userDao.read(uid);
  32. assertEquals(address1, user.getAddress());
  34. // --------------Update ------------
  35. String address2 = "北京";
  36. user.setAddress(address2);
  37. userDao.save(user);
  39. user = userDao.read(uid);
  41. assertEquals(address2, user.getAddress());
  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时，会用上。

www.zeeklog.com - Redis实战之征服 Redis + Jedis + Spring （一）

看看控制台获得了什么：

redis 127.0.0.1:6379> get user.uid.u123456
(nil)
redis 127.0.0.1:6379> get user.uid.u123456
"\xe5\x8c\x97\xe4\xba\xac"
redis 127.0.0.1:6379> get user.uid.u123456
"\xe4\xb8\x8a\xe6\xb5\xb7"
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
"\xe4\xb8\x8a\xe6\xb5\xb7"

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

相关链接：

Read more

学习Python，为什么可以轻松应对工作大小事？

学习Python，为什么可以轻松应对工作大小事？

Python，大名鼎鼎，它在工作中到底能发挥什么样的作用？在现代职场，Python如同一把瑰丽的多功能钥匙，能打开各行各业的大门。无论你是行政助手、财务分析师、电商经营者，还是数据研究员，Python都能为你的工作增色不少。那么，究竟是什么让Python如此神奇？ 行政管理，Excel搞不定？ 对于行政工作，Excel表格常常是不可或缺的工具。对于行政管理的打工人来说，他们的任务常常涉及处理大量Excel数据，比如员工名单、考勤表、报销单之类的。问题是Excel有点小顽皮，总爱搞点幺蛾子。比如说，有时候数据格式不对，有时候公式出错，有时候文件太大打不开。这时候，考虑一下Python，它可以成为你的得力工具。 为什么这么说？因为Python可以让电脑替他们处理这些麻烦事。想象一下，每天都要对付成堆的数据，一行一行地操作，那得折磨死人。可是，学了Python，不到20行的代码，电脑就能帮他们轻松搞定。 举个例子，他们想要把员工名单按照部门分组，并且统计每个部门的人数和平均年龄。用Excel的话，可能要用到很多函数和公式，还要手动筛选和排序。用Python就能实现更快的方法： im

By Ne0inhk
Python 中的真与假

Python 中的真与假

在 Python 这门编程语言中，真值与假值的概念起着至关重要的作用，它们决定了Python如何判断一个表达式是真还是假，这在涉及变量条件的情况下尤为重要。在本文中，我们将深入探讨Python如何进行真值和假值的评估，以及如何在编程过程中充分利用这一特性。 在Python中，存在一系列特定的值被认定为假，这意味着它们在布尔表达式中被视为假。这些伪造的值包括但不限于以下几种情况： * None * 空字符串 (‘’) * 空列表 ([]) * 空元组 (()) * 空集合 ({}) * 空范围 (range(0)) * 数值计算结果为零的数字 为了更好地理解真值和假值在Python中的运作方式，让我们看看一些示例情况。 a = None if a: print(a) 在这个示例中，由于 aisNone 被视为假值，因此不会输出任何内容。 a = '' if a: print(a) 同样地，由于变量 a 存储了一个空字符串，它也被视为假值，因此不会触发任何内容的输出。 a = [] if

By Ne0inhk
一次python服务的性能优化经历

一次python服务的性能优化经历

问题背景： 在我们的业务中，有一些推荐的场景会需要走到集团研究院的算法推荐服务，对一些用户进行个性化的课件推荐或者作者推荐，这个业务场景已经很久了，但是一直有一个很难解决的问题困扰着我们，就是我们调用研究院的接口经常性的出现偶发性的接口超时，频率还比较高。 初步排查过程： 一开始以为是研究院的推荐服务有性能问题，因为不了解推荐服务的实现逻辑，觉得算法推荐要基于大量的数据进行计算再生成结果，会不会是推荐服务里面超时了，但是和研究院的同事沟通后，他们的服务整体上的耗时有1秒的，但是一整天只有197个，完全对不上。 最后找运维确定了下整个网络链路，如下，感谢公司运维大佬的指点和分析。 因为业务侧的服务都在公有云上，然后算法侧基于软硬件成本等原因，整体的服务都在内网的服务器上，中间通过公有网络访问，中间也没有拉专线，所以整体的网络耗时非常的不稳定，另外由于公有云现在都在杭州，内网的服务都在广州，因为跨地域的问题，本身的网络耗时也是会有一定的影响。 初步解决方案： 因此和运维大佬讨论后有两种解决方案： 1. 公有云和私有云之间拉一条专线，解决网络不稳定的问题 2. 推荐服

By Ne0inhk
超详细！教你如何使用Python连接MySQL数据库

超详细！教你如何使用Python连接MySQL数据库

数据库编程是在应用程序中与数据库交互和管理数据的关键部分。MySQL是一种流行的关系型数据库管理系统（RDBMS），在Python中进行MySQL数据库编程相对容易。 本文介绍如何使用Python进行MySQL数据库编程，包括连接数据库、执行SQL查询、插入、更新和删除数据等操作。 目录 1. 安装MySQL驱动 2. 连接MySQL数据库 3. 创建数据库 4. 创建数据表 5. 插入数据 6. 查询数据 7. 更新数据 8. 删除数据 9. 执行事务 10. 关闭数据库连接 11. 示例：一个完整的MySQL数据库编程示例 12. 安全性注意事项 13. 总结 1. 安装MySQL驱动 在开始之前，需要安装Python的MySQL数据库驱动程序。最常用的驱动程序之一是mysql-connector-python 使用pip进行安装： pip install mysql-connector-python 2. 连接MySQL数据库 在进行任何数据库操作之前，首先需要建立与MySQL数据库的连接。

By Ne0inhk