Redis与Spring整合

来源：互联网发布：杠杆交易知乎编辑：程序博客网时间：2024/05/21 00:55

spring与redis整合

1、jar包

<groupId>org.springframework.data</groupId>

<artifactId>spring-data-redis</artifactId>

<version>1.6.2.RELEASE</version>

</dependency>

<groupId>redis.clients</groupId>

<artifactId>jedis</artifactId>

</dependency>

2、redis.properties

#redis.properties

#2017/04/15

redis.host=192.168.255.133

redis.port=6379

redis.pass=123456

redis.maxIdle=300

redis.maxActive.value=600

redis.maxWait=1000

redis.testOnBorrow=true

3、spring-redis.xml

<?xml version="1.0"encoding="UTF-8"?>

<beansxmlns="http://www.springframework.org/schema/beans"

xmlns:xsi=http://www.w3.org/2001/XMLSchema-instancexmlns: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/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd

http://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context.xsd">

<propertyname="maxTotal" value="${redis.maxActive.value}" />

<propertyname="maxWaitMillis" value="${redis.maxWait}" />

<propertyname="testOnBorrow" value="${redis.testOnBorrow}" />

</bean>

<bean id="connectionsFactory"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"/>

<propertyname="connectionFactory" ref="connectionsFactory" />

<propertyname="keySerializer">

<beanclass="org.springframework.data.redis.serializer.StringRedisSerializer"/>

</property>

<propertyname="valueSerializer">

<bean

class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer"/>

</property>

</bean>

</beans>

4、applicationContent.xml

<importresource="spring-redis.xml"/>

5、AbstractBaseRedisService抽象类

importjavax.annotation.Resource;

importorg.springframework.data.redis.core.RedisTemplate;

importorg.springframework.data.redis.serializer.RedisSerializer;

publicabstractclassAbstractBaseRedisService<K,V>{

@Resource(name="redisTemplate")

protectedRedisTemplate<K, V>redisTemplate;

/**

* 设置redisTemplate

* @paramredisTemplate the redisTemplate to set

publicvoidsetRedisTemplate(RedisTemplate<K, V>redisTemplate) {

this.redisTemplate =redisTemplate;

}

/**

* 获取RedisSerializer

* ------------------------------

protectedRedisSerializer<String> getRedisSerializer() {

returnredisTemplate.getStringSerializer();

}

6、接口以及实现类

importjava.util.List;

importcom.workorder.entity.Person;

publicinterfacePersonService {

/**

* 新增

* ------------------------------

* @param Person

* @return

booleanadd(PersonPerson);

/**

* 批量新增使用pipeline方式

* ------------------------------

* @param list

* @return

booleanadd(List<Person> list);

/**

* 删除

* ------------------------------

* @param key

void delete(Stringkey);

/**

* 删除多个

* ------------------------------

* @param keys

void delete(List<String>keys);

/**

* 修改

* ------------------------------

* @param Person

* @return

booleanupdate(Person Person);

/**

* 通过key获取

* ------------------------------

* @param keyId

* @return

Person get(String keyId);

}

importjava.util.ArrayList;

importjava.util.List;

importorg.springframework.dao.DataAccessException;

importorg.springframework.data.redis.connection.RedisConnection;

importorg.springframework.data.redis.core.RedisCallback;

importorg.springframework.data.redis.serializer.RedisSerializer;

importorg.springframework.stereotype.Service;

importorg.springframework.util.Assert;

importcom.workorder.entity.Person;

importcom.workorder.service.PersonService;

@Service

publicclass PersonServiceImplextends AbstractBaseRedisService<String,Person>implements PersonService {

@Override

publicbooleanadd( final Personperson) {

booleanresult =redisTemplate.execute(newRedisCallback<Boolean>() {

public Boolean doInRedis(RedisConnectionconnection)

throwsDataAccessException {

RedisSerializer<String> serializer =getRedisSerializer();

byte[]key =serializer.serialize(person.getId());

byte[]name = serializer.serialize(person.getName());

returnconnection.setNX(key,name);

}

});

returnresult;

}

@Override

publicboolean add(finalList<Person>list) {

Assert.notEmpty(list);

booleanresult =redisTemplate.execute(newRedisCallback<Boolean>() {

public Boolean doInRedis(RedisConnectionconnection)

throwsDataAccessException {

RedisSerializer<String> serializer =getRedisSerializer();

for (Personperson : list) {

byte[]key =serializer.serialize(person.getId());

byte[]name = serializer.serialize(person.getName());

connection.setNX(key,name);

}

returntrue;

}

}, false,true);

returnresult;

}

@Override

publicvoiddelete(Stringkey) {

List<String> list = newArrayList<String>();

list.add(key);

delete(list);

}

@Override

publicvoiddelete(List<String>keys) {

redisTemplate.delete(keys);

}

@Override

publicboolean update(final Person person) {

String key =person.getId();

if (get(key) ==null) {

thrownewNullPointerException("数据行不存在, key =" + key);

}

booleanresult =redisTemplate.execute(newRedisCallback<Boolean>() {

public Boolean doInRedis(RedisConnectionconnection)

throwsDataAccessException {

RedisSerializer<String> serializer =getRedisSerializer();

byte[]key =serializer.serialize(person.getId());

byte[]name = serializer.serialize(person.getName());

connection.set(key,name);

returntrue;

}

});

returnresult;

}

@Override

public Person get(final StringkeyId) {

Person result =redisTemplate.execute(newRedisCallback<Person>() {

public PersondoInRedis(RedisConnectionconnection)

throwsDataAccessException {

RedisSerializer<String> serializer =getRedisSerializer();

byte[]key = serializer.serialize(keyId);

byte[]value = connection.get(key);

if (value ==null) {

returnnull;

}

String name = serializer.deserialize(value);

returnnew Person(keyId,name, null);

}

});

returnresult;

}

0 0