`
huangyongxing310
  • 浏览: 490425 次
  • 性别: Icon_minigender_1
  • 来自: 广州
文章分类
社区版块
存档分类
最新评论

spring-data-redis实例应用

spring-data-redis实例应用 
阅读更多
spring-data-redis实例应用

1.对Redis的Key-Value数据存储操作提供了更高层次的抽象，类似于Spring Framework对JDBC支持一样。
2.如果不用这个你就要自己进行redis连接的连接与关闭操作，这个要小心的进行关闭，因为不关闭连接
就会太多，甚至用完(连接池方式)不能连接
3.RedisTemplate是线程安全的(spring-data-redis的操作接口)
4.ObjectMapper是线程安全的(外部序列化用到的)



spring-data-redis Operations
spring-data-redis针对jedis提供了如下功能：
1. 连接池自动管理，提供了一个高度封装的“RedisTemplate”类
2. 针对jedis客户端中大量api进行了归类封装,将同一类型操作封装为operation接口
ValueOperations：简单K-V操作
SetOperations：set类型数据操作
ZSetOperations：zset类型数据操作
HashOperations：针对map类型的数据操作
ListOperations：针对list类型的数据操作
3. 提供了对key的“bound”(绑定)便捷化操作API，可以通过bound封装指定的key，然后进行一系列的操作而无须“显式”的再次指定Key.
BoundValueOperations
BoundSetOperations
BoundListOperations
BoundSetOperations
BoundHashOperations

两者区别是一个进行set时要写key值（里面可以进行多个key的操作），一个不用（里面只可以进行一个key的操作） 

ValueOperations<String, User> valueOper = redisTemplate.opsForValue(); //取得一个新的ValueOperations




Spring-data-redis: serializer（序列化方式）
设置序列化方式（可以用内置的,也可以用别的）

spring-data-redis提供了多种serializer策略，这对使用jedis的开发者而言，实在是非常便捷。sdr提供了4种内置的serializer：
1.JdkSerializationRedisSerializer：使用JDK的序列化手段(serializable接口，ObjectInputStrean，ObjectOutputStream)，数据以字节流存储
2.StringRedisSerializer：字符串编码，数据以string存储
3.JacksonJsonRedisSerializer：json格式存储
4.OxmSerializer：xml格式存储

注意：
1.其中JdkSerializationRedisSerializer和StringRedisSerializer是最基础的序列化策略。
2.其中“JacksonJsonRedisSerializer”与“OxmSerializer”都是基于stirng存储，因此它们是较为“高级”的序列化(最终还是使用string解析以及构建java对象)。


RedisTemplate中需要声明4种serializer，默认为“JdkSerializationRedisSerializer”：
1) keySerializer ：对于普通K-V操作时，key采取的序列化策略
2) valueSerializer：value采取的序列化策略
3) hashKeySerializer： 在hash数据结构中，hash-key的序列化策略
4) hashValueSerializer：hash-value的序列化策略

注意：无论如何，建议key/hashKey采用StringRedisSerializer。


例子：
redis.properties 
# Redis settings
redis.host=127.0.0.1
redis.port=6379
redis.pass=

redis.maxIdle=300
redis.maxTotal=600
redis.maxWaitMillis=1000
redis.testOnBorrow=true



applicationContext.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"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:jee="http://www.springframework.org/schema/jee" xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xsi:schemaLocation="
            http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">


	<context:annotation-config />
	<!-- <task:annotation-driven /> -->
	<context:component-scan base-package="com.*" />

	<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"
		p:host-name="${redis.host}" p:port="${redis.port}" p:password="${redis.pass}"
		p:pool-config-ref="poolConfig" />

	<bean id="redisTemplate" class="org.springframework.data.redis.core.StringRedisTemplate">
		<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>
		<!-- <property name="enableTransactionSupport" value="true" /> -->

	</bean>
</beans>



User.java 
package com.redis;
import java.io.Serializable;

public class User implements Serializable{
	private static final long serialVersionUID = 1L;
	private long id;
	private String name;

	public long getId() {
		return id;
	}

	public void setId(long id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	@Override
	public String toString() {
		return "User [id=" + id + ", name=" + name + "]";
	}

	public User(long id, String name) {
		super();
		this.id = id;
		this.name = name;
	}

	public User() {
		super();
		// TODO Auto-generated constructor stub
	}
}



使用内部JdkSerializationRedisSerializer工具进行序列化
main 
package com.redis;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;

public class SpringDataRedisTest {
	public static void main(String[] args) throws InterruptedException {
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:/applicationContext.xml");

		RedisTemplate redisTemplate = (RedisTemplate) applicationContext.getBean("redisTemplate");
		System.out.println("redisTemplate == " + redisTemplate);

		ValueOperations<String, User> valueOper = redisTemplate.opsForValue();
		User u1 = new User(10, "zhangsan");
		User u2 = new User(11, "lisi");
		valueOper.set("u:u1", u1);
		valueOper.set("u:u2", u2);

		User User = valueOper.get("u:u1");
		System.out.println("User == " + User.toString());
		User User2 = valueOper.get("u:u2");
		System.out.println("User2 == " + User2.toString());
	}
}



使用外部jackson工具进行序列化
1.因为使用内部的序列化工具创建ValueOperations时要指定对象的ClassType,用外部序列化工具可以全部基于String(接口统一),如 
ValueOperations<String, User> valueOper = redisTemplate.opsForValue(); //取得一个新的ValueOperations,要指定User


main 
package com.redis;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringDataRedisOtherJsonTest {
	public static void main(String[] args) throws InterruptedException {
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:/applicationContext.xml");

		RedisClientTest redisClientTest = (RedisClientTest) applicationContext.getBean("redisClientTest");
		System.out.println("redisClientTest == " + redisClientTest);

		User user1 = new User();
		user1.setId(21);
		user1.setName("obama21");
		redisClientTest.insertUser(user1);
		System.out.println("insertUser");

		User user2 = redisClientTest.getUser(21);
		System.out.println("user2 == " + user2.toString());

	}
}


JsonRedisSeriaziler.java 
package com.redis;
import java.io.IOException;
import org.codehaus.jackson.JsonGenerationException;
import org.codehaus.jackson.JsonParseException;
import org.codehaus.jackson.map.JsonMappingException;
import org.codehaus.jackson.map.ObjectMapper;
import org.springframework.stereotype.Service;

@Service("jsonRedisSeriaziler")
public class JsonRedisSeriaziler {
	private ObjectMapper objectMapper = new ObjectMapper();

	/**
	 * java-object as json-string
	 *
	 * @param object
	 * @return
	 */
	public String seriazileAsString(Object object) {
		if (object == null) {
			return null;
		}

		try {
			return this.objectMapper.writeValueAsString(object);
		} catch (JsonGenerationException e) {
			e.printStackTrace();
		} catch (JsonMappingException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
		return null;
	}

	/**
	 * json-string to java-object
	 *
	 * @param str
	 * @return
	 */
	public <T> T deserializeAsObject(String str, Class<T> clazz) {
		if (str == null || clazz == null) {
			return null;
		}
		try {
			return this.objectMapper.readValue(str, clazz);
		} catch (JsonParseException e) {
			e.printStackTrace();
		} catch (JsonMappingException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}

		return null;
	}
}


RedisClientTest.java 
package com.redis;
import javax.annotation.Resource;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Service;

@Service("redisClientTest")
public class RedisClientTest {

	@Resource(name = "jsonRedisSeriaziler")
	private JsonRedisSeriaziler seriaziler;

	@Resource(name = "redisTemplate")
	private RedisTemplate redisTemplate;

	public void insertUser(User user) {
		ValueOperations<String, String> operations = redisTemplate.opsForValue();
		operations.set("user:" + user.getId(), seriaziler.seriazileAsString(user));
	}

	public User getUser(long id) {
		ValueOperations<String, String> operations = redisTemplate.opsForValue();
		String json = operations.get("user:" + id);
		System.out.println("json ==" + json);
		return seriaziler.deserializeAsObject(json, User.class);
	}
}


参考原文：http://shift-alt-ctrl.iteye.com/blog/1886831



Spring-data-redis事务
1.enableTransactionSupport：是否启用事务支持。要在XML文件中进行配置(StringRedisTemplate的属性)
2.enableTransactionSupport为true时，系统自动帮我们拿到了事务中绑定的连接。可以在一个方法的多次对Redis增删该查中，始终使用同一个连接。
但是，即使使用了同样的连接，没有进行connection.multi()和connection.exec()，依然是无法启用事务的。
3.sdr提供SessionCallback接口用于同线程的多操作执行。（同一个连接）

非连接池环境下，事务操作；对于sdr而言，每次操作(例如，get，set)都有会从pool中获取connection；
因此在连接池环境下，使用事务需要注意。 
public void saveNoPoolUser(final User user) {
	redisTemplate.watch("user:" + user.getId());
	redisTemplate.multi();
	ValueOperations<String, String> tvo = redisTemplate.opsForValue();
	tvo.set("user:" + user.getId(), seriaziler.seriazileAsString(user));
	redisTemplate.exec();
}


在连接池环境中，需要借助sessionCallback来绑定connection 
public void savePoolUser(final User user) {
	SessionCallback<User> sessionCallback = new SessionCallback<User>() {
    @Override
    public User execute(RedisOperations operations) throws DataAccessException {
        operations.multi();
        String key = "user:" + user.getId();
        ValueOperations<String, String> oper = operations.opsForValue();
        oper.set(key,seriaziler.seriazileAsString(user));
        operations.exec();
        return user;
    }
};
redisTemplate.execute(sessionCallback);
}


SpringDataRedisTransactional.java 
package com.redis;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringDataRedisTransactional {
	public static void main(String[] args) throws InterruptedException {
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:/applicationContext.xml");

		RedisClientTest redisClientTest = (RedisClientTest) applicationContext.getBean("redisClientTest");
		System.out.println("redisClientTest == " + redisClientTest);

		User user1 = new User();
		user1.setId(33);
		user1.setName("obama31 55");
		redisClientTest.savePoolUser(user1);
		System.out.println("insertUser");

		User user2 = redisClientTest.getUser(33);
		System.out.println("user2 == " + user2.toString());

	}
}


RedisClientTest.java 
package com.redis;
import javax.annotation.Resource;
import org.springframework.dao.DataAccessException;
import org.springframework.data.redis.core.RedisOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.SessionCallback;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service("redisClientTest")
public class RedisClientTest {

	@Resource(name = "jsonRedisSeriaziler")
	private JsonRedisSeriaziler seriaziler;

	@Resource(name = "redisTemplate")
	private RedisTemplate redisTemplate;

	public void insertUser(User user) {
		ValueOperations<String, String> operations = redisTemplate.opsForValue();
		operations.set("user:" + user.getId(), seriaziler.seriazileAsString(user));
	}

	public User getUser(long id) {
		ValueOperations<String, String> operations = redisTemplate.opsForValue();
		String json = operations.get("user:" + id);
		System.out.println("json ==" + json);
		return seriaziler.deserializeAsObject(json, User.class);
	}

	public void savePoolUser(final User user) {
		SessionCallback<User> sessionCallback = new SessionCallback<User>() {
			@Override
			public User execute(RedisOperations operations) throws DataAccessException {
				operations.multi();
				String key = "user:" + user.getId();
				ValueOperations<String, String> oper = operations.opsForValue();
				oper.set(key, seriaziler.seriazileAsString(user));
				operations.exec();
				return user;
			}
		};
		redisTemplate.execute(sessionCallback);
	}

	public void saveNoPoolUser(final User user) {
		redisTemplate.watch("user:" + user.getId());
		redisTemplate.multi();
		ValueOperations<String, String> tvo = redisTemplate.opsForValue();
		tvo.set("user:" + user.getId(), seriaziler.seriazileAsString(user));
		redisTemplate.exec();
	}
}




Pipeline
1.就是先将命令缓存起来，到时一次打包发送到redis服务器进行处理
2.通过pipeline方式当有大批量的操作时候，我们可以节省很多原来浪费在网络延迟的时间，需要注意到是用pipeline方式打包命令发送，
redis必须在处理完所有命令前先缓存起所有命令的处理结果。打包的命令越多，缓存消耗内存也越多。所以并不是打包的命令越多越好。


如果存储的是数字（当然值的序列化方式要先用StringRedisSerializer否则不能用increment） 
package com.redis;

import java.io.Serializable;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;

public class SpringDataRedisTestLong {
	public static void main(String[] args) throws InterruptedException {
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:/applicationContext.xml");

		RedisTemplate redisTemplate = (RedisTemplate) applicationContext.getBean("redisTemplate");
		System.out.println("redisTemplate == " + redisTemplate);

		ValueOperations<String, Serializable> valueOper = redisTemplate.opsForValue();
		long i = 10245;
		valueOper.set("u:u53", String.valueOf(i));
		
		System.out.println("redisTemplate == 100");
		valueOper.increment("u:u53", 3L);//负数实现减操作
		System.out.println("redisTemplate == 100");
		
		String User = (String) valueOper.get("u:u53");
		System.out.println("User == " + User);
		
		long j =Long.parseLong(User);
		System.out.println("j == " + j);
	}
}


参考原文：http://www.cnblogs.com/luochengqiuse/p/4640932.html[/b]
参考原文：http://shift-alt-ctrl.iteye.com/blog/1887370
参考原文：http://shift-alt-ctrl.iteye.com/blog/1886831
参考原文（性能对比）：http://blog.csdn.net/u010739551/article/details/48165063

所用到的jar包如下：

分享到：
| Spring注解之@autowired和@resource的区别
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    spring-data-redis 1.7.6

    Spring-data-redis是Spring框架下针对Redis数据库的扩展，它提供了一种在Java应用中方便、高效地使用Redis的方法。版本1.7.6是该库的一个稳定版本，包含了一系列的功能改进和优化。本文将详细探讨Spring-data-redis ...

    spring-data-redis实例

    本文将深入探讨Spring Data Redis的使用方法，并通过实例项目“hotel-redis-app”来具体展示其在实际开发中的应用。 一、Spring Data Redis简介 Spring Data Redis是Spring项目下的一个模块，它提供了一套完整的...

    redis集群以及Spring-data-redis操作集群

    Spring-data-redis同样提供了一种方便的方式来管理单个Redis实例，主要使用`JedisConnectionFactory`和`RedisTemplate`。 1. **配置单例Redis**：配置文件中设置Redis服务器的IP、端口、密码等信息，创建`...

    SpringData与Redis集成

    SpringData与Redis集成是现代Java应用中常见的数据存储和缓存解决方案。SpringData是一个强大的框架，它简化了数据库访问，并提供了对多种数据存储技术的统一API。而Redis是一款开源、高性能的键值对数据存储系统，...

    spring-data-redis-1.6.0.RELEASE.jar + jedis-2.7.2.jar包

    Spring Data Redis使得在应用程序中集成Redis变得简单，提供了丰富的API和抽象层，让开发者能够利用Redis的高速缓存、持久化和分布式特性。这个“spring-data-redis-1.6.0.RELEASE.jar”是该库的特定版本，1.6.0....

    spring-boot2集成redis

    Spring Boot 2 提供了对 Redis 的便捷集成，使得开发者能够快速地在 Spring 应用中利用 Redis 的高性能存储特性。以下将详细介绍如何在 Spring Boot 2 项目中集成 Redis，并通过实际操作步骤解析整个过程。 1. **...

    spring-data-redis英文版

    Spring Data Redis通过上述核心组件和服务，为开发者提供了一套完整的工具集，使得基于Spring的应用程序可以更加便捷地使用Redis，无论是单实例还是集群模式。此外，文档还介绍了支持社区和专业支持的方式，以及如何...

    Redis 集成Spring的示例代码（spring-data-redis）

    spring-data-redis 是 Spring大家族的一部分，提供了在 Spring 应用中通过简单的配置访问 Redis 服务，对 Redis 底层开发包（Jedis, JRedis, and RJC）进行了高度封装。RedisTemplate 提供了 Redis 各种操作、异常...

    spring-redis-maven整合带安装包

    Spring Redis 是一个集成Redis数据库与Spring框架的模块，它提供了对Redis数据存储的全面支持，使得在Java应用中使用Redis变得更加便捷。这个"Maven整合工程"意味着该项目使用Maven作为构建工具，通过管理依赖关系来...

    spring-boot-redis.zip

    Redis拾遗部分博客相关的实例代码，包括其中的抢红包案例，相关SQL也一并附上，导入之后，修改Redis的配置文件之后，可以直接运行，但是如果想要配置集群，也只需要修改连接配置即可

    Spring-data-redis操作redis cluster的示例代码

    本文将深入探讨如何使用Spring-data-redis来操作Redis Cluster，以及在实际应用中需要注意的要点。 首先，我们来看直接使用Jedis操作Redis Cluster的方法。Jedis是Redis官方推荐的Java客户端，它支持集群模式。要...

    SpringBoot使用注解实现 Redis 数据库的切换.zip

    SpringBoot提供了对Redis的自动配置支持，只需要在项目中引入`spring-boot-starter-data-redis`依赖，它会自动配置`RedisConnectionFactory`和`RedisTemplate`等核心组件。在`pom.xml`文件中添加以下依赖： ```xml ...

    sharded-spring-data-redis:增强 Spring Data Redis 以支持实例分片和弹性连接

    Spring Data Redis中的弹性连接可能包括动态增加或减少连接池大小、自动重连故障的Redis实例等功能。这有助于提升系统的可用性和韧性，尤其是在分布式环境中，当某个Redis实例出现问题时，应用能够快速适应并恢复...

    maven-spring-redis

    在IT行业中，Spring框架与Redis的整合是常见的数据存储与缓存解决方案，尤其适用于高并发、数据读写频繁的应用场景。"maven-spring-redis"这个项目显然旨在展示如何在Java环境中，利用Maven构建工具，将Spring框架与...

    spring-boot很多实例

    'springboot-mybatis-redis','springboot-mybatis-redis-annotation','springboot-properties','springboot-restful','springboot-validation-over-json','springboot-webflux','spring-data-elasticsearch-crud','...

    Spring mvc整合redis实例(redis连接池)

    在Maven项目中，可以在pom.xml文件中添加`spring-data-redis`和`jedis`库，这两个库分别提供了Spring对Redis的支持和Jedis，一个Java客户端连接Redis。 ```xml &lt;groupId&gt;org.springframework.data &lt;artifactId&gt;...

    springboot整合redis集群零配置

    在Spring Boot中，我们可以通过引入`spring-boot-starter-data-redis`依赖来启用Redis支持。但是，要配置Redis集群，通常需要设置多个节点地址、密码、端口等信息。在Spring Boot 2.1及以上版本中，我们可以利用`...

    使用spring-session加redis来实现session共享.zip

    1. **添加依赖**：在`pom.xml`中，你需要引入Spring Session和Redis的相关依赖，如`spring-boot-starter-data-redis`和`spring-session-data-redis`。 2. **配置Redis**：在Spring Boot的配置文件`application....

    redis-6.2.12可执行安装包

    1. 安装多个Redis实例，每个实例运行在不同的端口上。 2. 使用`redis-trib.rb`工具配置集群，指定每个节点的角色和连接信息。 3. 启动集群，监控节点状态，确保所有节点都能正常通信。 4. 配置客户端连接集群，使用`...

    springboot_redis

    标题 "springboot_redis" 涉及的是Spring Boot与Redis集成的应用。Spring Boot是Spring框架的一个简化版，它旨在简化创建独立的、生产级别的基于Spring的应用程序。而Redis是一款高性能的键值对数据库，常被用作缓存...

Magicbox
Global site tag (gtag.js) - Google Analytics