使用Java操作Redis数据库
1、 建立一个jedis的Maven项目;
2、 修改pom.xml配置文件,追加相应的开发包以及插件:
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>cn.mldn</groupId>
<artifactId>jedis</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>jar</packaging>
<name>jedis</name>
<url>http://maven.apache.org</url>
<properties>
<jedis.version>2.9.0</jedis.version>
<junit.version>4.12</junit.version>
<jdk.version>1.8</jdk.version>
<compiler.version>3.6.1</compiler.version>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<dependencies>
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>${jedis.version}</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>${junit.version}</version>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<finalName>jedisDemo</finalName>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>${compiler.version}</version>
<configuration>
<source>${jdk.version}</source>
<target>${jdk.version}</target>
<encode>${encoding.charset}</encode>
</configuration>
</plugin>
</plugins>
</build>
</project>
3、 如果要进行Redis数据库的连接,千万不要做地址的绑定处理。
package cn.mldn.jedis;
import redis.clients.jedis.Jedis;
public class ConnectRedisServer {
public static final String REDIS_HOST = "192.168.125.136" ; // 主机地址
public static final int REDIS_PORT = 6379 ; // 端口号
public static final String REDIS_AUTH = "mldnjava" ; // 认证密码
public static void main(String[] args) {
// 进行Redis的连接只需要设置主机名称和端口号即可,不需要考虑认证问题
Jedis jedis = new Jedis(REDIS_HOST,REDIS_PORT) ;
jedis.auth(REDIS_AUTH) ; // 进行REDIS访问认证
System.out.println(jedis.ping());
jedis.close();
}
}
如果此时服务器返回的内容为 PONG ,就表示连接成功。
Jedis数据操作
Jedis如果要进行数据操作实际上与Redis使的命令是相同的,也就是说整体的Jedis处理的时候所使用的方法名称就是命令名称。
1、 设置字符串数据
package cn.mldn.jedis;
import redis.clients.jedis.Jedis;
public class BaseDataDemo {
public static final String REDIS_HOST = "192.168.125.136" ; // 主机地址
public static final int REDIS_PORT = 6379 ; // 端口号
public static final String REDIS_AUTH = "mldnjava" ; // 认证密码
public static void main(String[] args) {
// 进行Redis的连接只需要设置主机名称和端口号即可,不需要考虑认证问题
Jedis jedis = new Jedis(REDIS_HOST,REDIS_PORT) ;
jedis.auth(REDIS_AUTH) ; // 进行REDIS访问认证
jedis.set("user-mldn","hello") ;
jedis.set("user-admin","happy") ;
System.out.println(jedis.get("user-admin")); // 获取数据
jedis.close();
}
}
2、 设置有效时间的数据:
package cn.mldn.jedis;
import redis.clients.jedis.Jedis;
public class BaseExpireDataDemo {
public static final String REDIS_HOST = "192.168.125.136" ; // 主机地址
public static final int REDIS_PORT = 6379 ; // 端口号
public static final String REDIS_AUTH = "mldnjava" ; // 认证密码
public static void main(String[] args) throws Exception {
// 进行Redis的连接只需要设置主机名称和端口号即可,不需要考虑认证问题
Jedis jedis = new Jedis(REDIS_HOST,REDIS_PORT) ;
jedis.auth(REDIS_AUTH) ; // 进行REDIS访问认证
jedis.setex("code-mldn",3,"7369") ; // 该数据只保留3秒,3秒内可以使用,超过无法使用
System.out.println("立即获取数据:" + jedis.get("code-mldn"));
Thread.sleep(3500);
System.out.println("3.5秒后获取数据:" + jedis.get("code-mldn"));
jedis.close();
}
}
3、 操作Hash数据:
package cn.mldn.jedis;
import redis.clients.jedis.Jedis;
public class HashDataDemo {
public static final String REDIS_HOST = "192.168.125.136" ; // 主机地址
public static final int REDIS_PORT = 6379 ; // 端口号
public static final String REDIS_AUTH = "mldnjava" ; // 认证密码
public static void main(String[] args) throws Exception {
// 进行Redis的连接只需要设置主机名称和端口号即可,不需要考虑认证问题
Jedis jedis = new Jedis(REDIS_HOST,REDIS_PORT) ;
jedis.auth(REDIS_AUTH) ; // 进行REDIS访问认证
jedis.hset("user-mldn", "name", "啊三") ;
jedis.hset("user-mldn", "age", "18") ;
System.out.println(jedis.hget("user-mldn", "name"));
System.out.println(jedis.hget("user-mldn", "age"));
jedis.close();
}
}
4、 操作List数据:
package cn.mldn.jedis;
import redis.clients.jedis.Jedis;
public class ListDataDemo {
public static final String REDIS_HOST = "192.168.125.136" ; // 主机地址
public static final int REDIS_PORT = 6379 ; // 端口号
public static final String REDIS_AUTH = "mldnjava" ; // 认证密码
public static void main(String[] args) throws Exception {
// 进行Redis的连接只需要设置主机名称和端口号即可,不需要考虑认证问题
Jedis jedis = new Jedis(REDIS_HOST,REDIS_PORT) ;
jedis.auth(REDIS_AUTH) ; // 进行REDIS访问认证
jedis.lpush("user-admin", "database","cas","openssh","codis","tidb") ;
jedis.rpush("user-admin", "hello","world") ;
System.out.println(jedis.lpop("user-admin"));
System.out.println(jedis.lpop("user-admin"));
System.out.println(jedis.lpop("user-admin"));
System.out.println(jedis.lpop("user-admin"));
System.out.println(jedis.lpop("user-admin"));
System.out.println(jedis.lpop("user-admin"));
System.out.println(jedis.lpop("user-admin"));
jedis.close();
}
}
5、 取得全部List数据:
package cn.mldn.jedis;
import java.util.List;
import redis.clients.jedis.Jedis;
public class ListDataDemo2 {
public static final String REDIS_HOST = "192.168.125.136" ; // 主机地址
public static final int REDIS_PORT = 6379 ; // 端口号
public static final String REDIS_AUTH = "mldnjava" ; // 认证密码
public static void main(String[] args) throws Exception {
// 进行Redis的连接只需要设置主机名称和端口号即可,不需要考虑认证问题
Jedis jedis = new Jedis(REDIS_HOST,REDIS_PORT) ;
jedis.auth(REDIS_AUTH) ; // 进行REDIS访问认证
jedis.lpush("user-admin", "database","cas","openssh","codis","tidb") ;
jedis.rpush("user-admin", "hello","world") ;
List<String> all = jedis.lrange("user-admin", 0, -1) ;
System.out.println(all);
jedis.close();
}
}
6、 操作Set数据:
package cn.mldn.jedis;
import java.util.Set;
import redis.clients.jedis.Jedis;
public class SetDataDemo {
public static final String REDIS_HOST = "192.168.125.136"; // 主机地址
public static final int REDIS_PORT = 6379; // 端口号
public static final String REDIS_AUTH = "mldnjava"; // 认证密码
public static void main(String[] args) throws Exception {
// 进行Redis的连接只需要设置主机名称和端口号即可,不需要考虑认证问题
Jedis jedis = new Jedis(REDIS_HOST, REDIS_PORT);
jedis.auth(REDIS_AUTH); // 进行REDIS访问认证
jedis.sadd("user-admin", "a", "b", "c", "d", "e");
jedis.sadd("user-mldn", "a", "c", "e", "x", "y", "z");
Set<String> all = jedis.sinter("user-admin","user-mldn") ;
System.out.println(all);
jedis.close();
}
}
7、 操作SortedSet集合
package cn.mldn.jedis;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import redis.clients.jedis.Jedis;
public class SortedSetDataDemo {
public static final String REDIS_HOST = "192.168.125.136"; // 主机地址
public static final int REDIS_PORT = 6379; // 端口号
public static final String REDIS_AUTH = "mldnjava"; // 认证密码
public static void main(String[] args) throws Exception {
// 进行Redis的连接只需要设置主机名称和端口号即可,不需要考虑认证问题
Jedis jedis = new Jedis(REDIS_HOST, REDIS_PORT);
jedis.auth(REDIS_AUTH); // 进行REDIS访问认证
// 定义好一个Map集合
Map<String,Double> map = new HashMap<String,Double>() ;
map.put("pid-1-1", 2.0) ;
map.put("pid-1-2", 1.0) ;
map.put("pid-2-1", 5.0) ;
jedis.zadd("user-mldn", map) ;
Set<String> zrangeByScore = jedis.zrangeByScore("user-mldn", 1.0, 5.0) ;
System.out.println(zrangeByScore);
jedis.close();
}
}
8、 取得对应的成绩数据:
package cn.mldn.jedis;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.Tuple;
public class SortedSetDataDemo2 {
public static final String REDIS_HOST = "192.168.125.136"; // 主机地址
public static final int REDIS_PORT = 6379; // 端口号
public static final String REDIS_AUTH = "mldnjava"; // 认证密码
public static void main(String[] args) throws Exception {
// 进行Redis的连接只需要设置主机名称和端口号即可,不需要考虑认证问题
Jedis jedis = new Jedis(REDIS_HOST, REDIS_PORT);
jedis.auth(REDIS_AUTH); // 进行REDIS访问认证
// 定义好一个Map集合
Map<String, Double> map = new HashMap<String, Double>();
map.put("pid-1-1", 2.0);
map.put("pid-1-2", 1.0);
map.put("pid-2-1", 5.0);
jedis.zadd("user-mldn", map);
Set<Tuple> all = jedis.zrangeByScoreWithScores("user-mldn", 1.0, 5.0);
Iterator<Tuple> iter = all.iterator();
while (iter.hasNext()) {
Tuple tuple = iter.next();
System.out.println(
"元素名称:" + tuple.getElement() + "、分数:" + tuple.getScore());
}
jedis.close();
}
}
9、 keys处理操作,使用keys可以获取全部的key的信息。
package cn.mldn.jedis;
import java.util.Set;
import redis.clients.jedis.Jedis;
public class KeysDemo {
public static final String REDIS_HOST = "192.168.125.136"; // 主机地址
public static final int REDIS_PORT = 6379; // 端口号
public static final String REDIS_AUTH = "mldnjava"; // 认证密码
public static void main(String[] args) throws Exception {
// 进行Redis的连接只需要设置主机名称和端口号即可,不需要考虑认证问题
Jedis jedis = new Jedis(REDIS_HOST, REDIS_PORT);
jedis.auth(REDIS_AUTH); // 进行REDIS访问认证
Set<String> keys = jedis.keys("user-*") ;
System.out.println(keys);
jedis.close();
}
}
Jedis连接池
如果直接使用Jedis可以直接进行数据库的操作,但是每一次的打开和关闭实在是太浪费性能了,所以为了提升操作性能,一定要使用数据库连接池的模式来进行处理,幸运的是Jedis开发包直接提供了数据库连接池的操作支持。
package cn.mldn.jedis;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
public class JedsConnectionPool {
public static final String REDIS_HOST = "192.168.125.136" ; // 主机地址
public static final int REDIS_PORT = 6379 ; // 端口号
public static final int TIMEOUT = 2000 ; // 连接超时时间
public static final String REDIS_AUTH = "mldnjava" ; // 认证密码
public static final int MAX_TOTAL = 1000 ; // 设置最大连接数
public static final int MAX_IDLE = 200 ; // 设置最小维持连接数
public static final int MAX_WAIT_MILLIS = 1000 ; // 设置最大等待时间
public static final boolean TEST_ON_BORROW = true ; // 是否进行可用测试
public static void main(String[] args) {
// 首先如果要想使用Jedis连接池,则必须有一个类可以保存所有连接池相关属性的配置项
JedisPoolConfig poolConfig = new JedisPoolConfig() ;
poolConfig.setMaxTotal(MAX_TOTAL); // 设置最大连接数
poolConfig.setMaxIdle(MAX_IDLE); // 设置空闲的连接数
poolConfig.setMaxWaitMillis(MAX_WAIT_MILLIS);// 最大等待时间
poolConfig.setTestOnBorrow(TEST_ON_BORROW); // 是否要进行连接测试,以保证返回的连接为可用连接
JedisPool pool = new JedisPool(poolConfig,REDIS_HOST,REDIS_PORT,TIMEOUT,REDIS_AUTH) ;
Jedis jedis = pool.getResource() ; // 通过连接池获取连接对象
jedis.set("mldn", "www.mldn.cn") ;
jedis.close();
pool.close(); // 关闭连接池
}
}
SpringData与Redis集成
Redis是一款优秀的缓存数据库,但是传统的Redis开发有一个缺点:无法进行对象的保存。因为对象属于二进制的操作数据(所有的对象都可以通过Serializable进行序列化处理),所以为了解决这样的难题,推出了一个重要的技术:SpringData,使用SpringData可以轻松的实现各个数据库中对象信息保存处理。
SpringData简介
Redis本身数据类型:基本数据、Hash数据,在整个的Redis里面只有这两类数据支持有普通的数据转换功能,例如:
- 基本数据:如果现在要求保存的数据是一个JSON结构,那么一定可以描述出一个完整对象信息;
- HashSet数据:Hash数据本身就可以描述出各个属性的内容。
如果要在这两种可以保存对象的处理方案里面进行选择,相信大部分人绝对会选择第一种方案,有两个原因:
- 操作比较直观;
- 只进行一次数据的保存即可。
如果真的使用基本数据类型进行对象的保存,实际上有两种方案:对象序列化(速度快)、JSON处理(速度慢)。那么现在在Spring开发框架里面就提供有这种支持,也就是说利用Spring-Data技术就可以轻松的实现转换,而SpringData的转换原则如下:
SpringData支持各种数据库的开发处理:spring-data-commons、spring-data-mongodb、spring-data-redis;
配置SpringData与Redis集成
1、 如果要想进行SpringData与Redis集成一定要在项目里面配置好所有的Spring、Redis开发包。
2、 建立一个新的Maven项目:SpringDataProject;
3、 修改pom.xml配置文件:
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>cn.mldn</groupId>
<artifactId>springdata</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>jar</packaging>
<name>springdata</name>
<url>http://maven.apache.org</url>
<properties>
<jedis.version>2.9.0</jedis.version>
<junit.version>4.12</junit.version>
<jdk.version>1.8</jdk.version>
<compiler.version>3.6.1</compiler.version>
<spring.version>4.3.8.RELEASE</spring.version>
<spring-data.version>1.8.3.RELEASE</spring-data.version>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<dependencies>
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>${jedis.version}</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>${junit.version}</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-redis</artifactId>
<version>${spring-data.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-beans</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-tx</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context-support</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aop</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aspects</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>${spring.version}</version>
</dependency>
</dependencies>
<build>
<finalName>springdatademo</finalName>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>${compiler.version}</version>
<configuration>
<source>${jdk.version}</source>
<target>${jdk.version}</target>
<encode>${encoding.charset}</encode>
</configuration>
</plugin>
</plugins>
</build>
</project>
4、 建立 src/main/profiles/dev 目录,并且在里面建立config/redis.properties配置文件:
- 将 src/main/profiles/dev 目录提升为源代码目录;
# 追加所有的哨兵的访问处理地址以及对应的端口号
redis.sentinel-1.host=192.168.125.161
redis.sentinel-2.host=192.168.125.161
redis.sentinel-3.host=192.168.125.161
redis.sentinel-1.port=26379
redis.sentinel-2.port=26380
redis.sentinel-3.port=26381
# 定义哨兵的master的名称
redis.sentinel.master.name=mymaster
# Redis的认证信息,认证信息密码
redis.password=mldnjava
# Redis连接的超时时间
redis.timeout=2000
# 设置最大的可用连接数
redis.pool.maxTotal=100
# 最小维持的可用连接数
redis.pool.maxIdle=20
# 最大等待时间
redis.pool.maxWaitMillis=2000
5、 建立src/main/resources源文件目录;
6、 建立spring配置文件:spring/spring-redis.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"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.3.xsd">
<!-- 如果要进行Redis处理用户应该不去关注具体的序列化或反序列化操作,这一切都应该交给SpringData处理 -->
<bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
<property name="connectionFactory" ref="connectionFactory"/> <!-- 定义Redis连接工厂 -->
<property name="keySerializer"> <!-- 定义序列化Key的程序处理类 -->
<bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
</property>
<property name="valueSerializer"> <!-- 处理value数据的操作 -->
<!-- 明确表示如果要进行value数据保存的时候,保存的对象一定要使用JDK提供的序列化处理类 -->
<bean class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer"/>
</property>
<property name="hashKeySerializer">
<bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
</property>
<property name="hashValueSerializer"> <!-- 处理hash数据的保存 -->
<bean class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer"/>
</property>
</bean>
<!-- 进行所有的哨兵地址的配置项 -->
<bean id="sentinelsConfiguration" class="org.springframework.data.redis.connection.RedisSentinelConfiguration">
<property name="master"><!-- 配置master的节点名称 -->
<bean class="org.springframework.data.redis.connection.RedisNode">
<!-- 通过资源文件读取出master的名称进行配置 -->
<property name="name" value="${redis.sentinel.master.name}"/>
</bean>
</property>
<!-- 配置所有哨兵的连接地址信息 -->
<property name="sentinels">
<set>
<bean class="org.springframework.data.redis.connection.RedisNode">
<constructor-arg name="host" value="${redis.sentinel-1.host}"/>
<constructor-arg name="port" value="${redis.sentinel-1.port}"/>
</bean>
<bean class="org.springframework.data.redis.connection.RedisNode">
<constructor-arg name="host" value="${redis.sentinel-2.host}"/>
<constructor-arg name="port" value="${redis.sentinel-2.port}"/>
</bean>
<bean class="org.springframework.data.redis.connection.RedisNode">
<constructor-arg name="host" value="${redis.sentinel-3.host}"/>
<constructor-arg name="port" value="${redis.sentinel-3.port}"/>
</bean>
</set>
</property>
</bean>
<!-- 首先进行Jedis连接池的相关配置 -->
<bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
<property name="maxTotal" value="${redis.pool.maxTotal}"/> <!-- 最大可用连接数 -->
<property name="maxIdle" value="${redis.pool.maxIdle}"/> <!-- 最小维持连接数 -->
<property name="maxWaitMillis" value="${redis.pool.maxWaitMillis}"/> <!-- 最大等待时间 -->
</bean>
<!-- 进行ConnectionFactory的配置 -->
<bean id="connectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
<constructor-arg name="sentinelConfig" ref="sentinelsConfiguration"/>
<property name="poolConfig" ref="jedisPoolConfig"/> <!-- 引用进行连接池的配置项 -->
<property name="password" value="${redis.password}"/> <!-- 定义的是连接密码,认证密码 -->
</bean>
</beans>
定义config/spring-common.xml配置文件:
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>cn.mldn</groupId>
<artifactId>springdata</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>jar</packaging>
<name>springdata</name>
<url>http://maven.apache.org</url>
<properties>
<jedis.version>2.9.0</jedis.version>
<junit.version>4.12</junit.version>
<jdk.version>1.8</jdk.version>
<compiler.version>3.6.1</compiler.version>
<spring.version>4.3.8.RELEASE</spring.version>
<spring-data.version>1.8.3.RELEASE</spring-data.version>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<dependencies>
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>${jedis.version}</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>${junit.version}</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-redis</artifactId>
<version>${spring-data.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-beans</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-tx</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context-support</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aop</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aspects</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>${spring.version}</version>
</dependency>
</dependencies>
<build>
<finalName>springdatademo</finalName>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>${compiler.version}</version>
<configuration>
<source>${jdk.version}</source>
<target>${jdk.version}</target>
<encode>${encoding.charset}</encode>
</configuration>
</plugin>
</plugins>
</build>
</project>
SpringData序列化与反序列化对象
本次直接使用Spring-Test进行项目测试,可以进行资源的自动注入,主要使用的就是redisTemplate资源。
1、 建立一个VO类:Member
package cn.mldn.springdata.vo;
import java.io.Serializable;
import java.util.Date;
@SuppressWarnings("serial")
public class Member implements Serializable {
private String mid ;
private String name ;
private Integer age ;
private Date birthday ;
private Double salary ;
}
2、 编写测试程序来实现SpringData数据处理:
package cn.mldn.springdata;
import java.util.Date;
import javax.annotation.Resource;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import cn.mldn.springdata.vo.Member;
@ContextConfiguration(locations = {"classpath:spring/spring-common.xml"})
@RunWith(SpringJUnit4ClassRunner.class) // 使用Junit进行测试
public class TestMember {
@Resource
private RedisTemplate<String, Object> redisTemplate; // 序列化操作模版
@Test
public void testLoad() {
Object obj = this.redisTemplate.opsForValue().get("mldn-1"); // 要进行转型处理
System.out.println(obj);
}
@Test
public void testSave() { // 数据保存处理
Member vo = new Member();
vo.setMid("mldn-java");
vo.setBirthday(new Date());
vo.setName("张三");
vo.setAge(18);
vo.setSalary(1.1);
this.redisTemplate.opsForValue().set("mldn-1", vo);
}
@Test
public void testMultiSave() throws Exception { // 数据保存处理
for (int x = 0; x < 10000; x++) {
Member vo = new Member();
vo.setMid("mldn-java");
vo.setBirthday(new Date());
vo.setName("张三");
vo.setAge(18);
vo.setSalary(1.1);
this.redisTemplate.opsForValue().set("mldn-" + x, vo);
}
}
}