Redis cache SSM Integrated Framework

Java SSM Framework Integration Framework Redis

1. Download Jedis dependent

<.!-- jedis依赖 -->
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>2.7.1</version>
</dependency>
<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-redis</artifactId>
<version>1.6.2.RELEASE</version>
</dependency>

2. Configure applicationContext.xml profile location on the front

<! - connection pool configuration parameters substantially similar database connection pool -> 
< context: Property-placeholder LOCATION = "CLASSPATH: redis.properties" />


<bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">
<property name="maxTotal" value="1024"/>
<property name="maxIdle" value="200" />
<property name="testOnBorrow" value="true"/>
</bean>

<!-- 连接池配置，类似数据库连接池 -->
<bean id="jedisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory" >
<property name="hostName" value="127.0.0.1"></property>
<property name="port" value="6379"></property>
<!-- <property name="password" value="${redis.pass}"></property> -->
<property name="poolConfig" ref="poolConfig"></property>
</bean>

<bean id="redisCacheTransfer" class="com.jdt.wetalk.redisUtils.RedisCacheTransfer">
<property name="jedisConnectionFactory" ref="jedisConnectionFactory" />
</bean>

3. Edit the file Redis.properties

host=127.0.0.1
port=6379
redis.pass=123456
maxIdle=200
maxActive=1024
redis.maxWait = 10000
testOnBorrow=true

4. Redis to write some helper classes

1）。JedisClusterFactory.java

Package Com.Jdt.Wetalk.RedisUtils;

import java.util.HashSet;
import java.util.Properties;
import java.util.Set;
import java.util.regex.Pattern;

import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
import org.springframework.beans.factory.FactoryBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.core.io.Resource;

import redis.clients.jedis.HostAndPort;
import redis.clients.jedis.JedisCluster;

public class JedisClusterFactory implements FactoryBean<JedisCluster>, InitializingBean {
private Resource addressConfig;
private String addressKeyPrefix;

private JedisCluster jedisCluster;
private Integer timeout;
private Integer maxRedirections;
private GenericObjectPoolConfig genericObjectPoolConfig;

private Pattern p = Pattern.compile("^.+[:]\\d{1,5}\\s*$");

public JedisCluster getObject() throws Exception {
return jedisCluster;
}

public Class<? extends JedisCluster> getObjectType() {
return (this.jedisCluster != null ? this.jedisCluster.getClass() : JedisCluster.class);
}

public boolean isSingleton() {
return true;
}

private Set<HostAndPort> parseHostAndPort() throws Exception {
try {
Properties prop = new Properties();
prop.load(this.addressConfig.getInputStream());

Set<HostAndPort> haps = new HashSet<HostAndPort>();
for (Object key : prop.keySet()) {

if (!((String) key).startsWith(addressKeyPrefix)) {
continue;
}

String val = (String) prop.get(key);

boolean isIpPort = p.matcher(val).matches();

IF (! isIpPort) {
 the throw  new new IllegalArgumentException ( "ip port or illegal" );
}
String[] ipAndPort = val.split(":");

HostAndPort hap = new HostAndPort(ipAndPort[0], Integer.parseInt(ipAndPort[1]));
haps.add(hap);
}

return haps;
} catch (IllegalArgumentException ex) {
throw ex;
} The catch (Exception EX) {
 the throw  new new Exception ( "parsing jedis profile fails" , EX);
}
}

public void afterPropertiesSet() throws Exception {
Set<HostAndPort> haps = this.parseHostAndPort();

jedisCluster = new JedisCluster(haps, timeout, maxRedirections, genericObjectPoolConfig);

}

public void setAddressConfig(Resource addressConfig) {
this.addressConfig = addressConfig;
}

public void setTimeout(int timeout) {
this.timeout = timeout;
}

public void setMaxRedirections(int maxRedirections) {
this.maxRedirections = maxRedirections;
}

public void setAddressKeyPrefix(String addressKeyPrefix) {
this.addressKeyPrefix = addressKeyPrefix;
}

public void setGenericObjectPoolConfig(GenericObjectPoolConfig genericObjectPoolConfig) {
this.genericObjectPoolConfig = genericObjectPoolConfig;
}

}

2）。RedisCache.java

ackage com.jdt.wetalk.redisUtils;

import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

import org.apache.ibatis.cache.Cache;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.data.redis.connection.jedis.JedisConnection;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.serializer.JdkSerializationRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializer;

import redis.clients.jedis.exceptions.JedisConnectionException;

public class RedisCache implements Cache {
private static final Logger logger = LoggerFactory.getLogger(RedisCache.class);

private static JedisConnectionFactory jedisConnectionFactory;

private final String id;

private final ReadWriteLock rwl = new ReentrantReadWriteLock();


public RedisCache(final String id) {
if (id == null) {
throw new IllegalArgumentException("Cache instances require an ID");
}
logger.debug("MybatisRedisCache:id=" + id);
this.id = id;
}

/**
* Clear all cache
*/
public void clear() {
rwl.readLock().lock();
JedisConnection connection = null;
try {
connection = jedisConnectionFactory.getConnection();
connection.flushDb();
connection.flushAll();
logger.debug ( "Clear cache ......." );
} catch (JedisConnectionException e) {
e.printStackTrace ();
} finally {
if (connection != null) {
connection.close();
}
rwl.readLock().unlock();
}
}

public String getId() {
return this.id;
}

/**
* Get the total number of cache
*/
public int getSize() {
int result = 0;
JedisConnection connection = null;
try {
connection = jedisConnectionFactory.getConnection();
result = Integer.valueOf(connection.dbSize().toString());
logger.info ( "Add Number mybaits secondary cache:" + Result);
} catch (JedisConnectionException e) {
e.printStackTrace ();
} finally {
if (connection != null) {
connection.close();
}
}
return result;
}

public void putObject(Object key, Object value) {
rwl.writeLock().lock();

JedisConnection connection = null;
try {
connection = jedisConnectionFactory.getConnection();
RedisSerializer<Object> serializer = new JdkSerializationRedisSerializer();
connection.set(SerializeUtil.serialize(key), SerializeUtil.serialize(value));
logger.info ( "secondary cache Add mybaits = Key" + Key + ", value =" + value);
} catch (JedisConnectionException e) {
e.printStackTrace ();
} finally {
if (connection != null) {
connection.close();
}
rwl.writeLock().unlock();
}
}

public Object the getObject (Object Key) {
 // existing cache data fetch, together with the first read lock 
rwl.readLock () lock ().;
Object result = null;
JedisConnection connection = null;
try {
connection = jedisConnectionFactory.getConnection();
RedisSerializer<Object> serializer = new JdkSerializationRedisSerializer();
result = serializer.deserialize(connection.get(serializer.serialize(key)));
logger.info ( "secondary cache hit mybaits, value =" + Result);

} catch (JedisConnectionException e) {
e.printStackTrace ();
} finally {
if (connection != null) {
connection.close();
}
rwl.readLock().unlock();
}
return result;
}

public Object removeObject(Object key) {
rwl.writeLock().lock();

JedisConnection connection = null;
Object result = null;
try {
connection = jedisConnectionFactory.getConnection();
RedisSerializer<Object> serializer = new JdkSerializationRedisSerializer();
result = connection.expire(serializer.serialize(key), 0);
} catch (JedisConnectionException e) {
e.printStackTrace ();
} finally {
if (connection != null) {
connection.close();
}
rwl.writeLock().unlock();
}
return result;
}

public static void setJedisConnectionFactory(JedisConnectionFactory jedisConnectionFactory) {
System.out.println ( "Get into Redis ========" );
RedisCache.jedisConnectionFactory = jedisConnectionFactory;
}

public ReadWriteLock getReadWriteLock() {
// TODO Auto-generated method stub
return rwl;
}

}

3)RedisCacheTransfer.java

Package Com.Jdt.Wetalk.RedisUtils;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;

public class RedisCacheTransfer {
@Autowired
public void setJedisConnectionFactory(JedisConnectionFactory jedisConnectionFactory) {
RedisCache.setJedisConnectionFactory(jedisConnectionFactory);
}
}

4)SerializeUtil.java

4 ) SerializeUtil.Java
 Package Com.Jdt.Wetalk.RedisUtils;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class SerializeUtil {
/**
* Serialization
*/
public static byte[] serialize(Object object) {
ObjectOutputStream oos = null ;
ByteArrayOutputStream baos = null;
try {
// 序列化
baos = new ByteArrayOutputStream();
oos = new ObjectOutputStream (baos);
oos.writeObject(object);
byte[] bytes = baos.toByteArray();
return bytes;
} catch (Exception e) {
e.printStackTrace ();
}
return null;
}

/**
* Deserialized
*/
public static Object unserialize(byte[] bytes) {
if (bytes != null) {
ByteArrayInputStream bais = null;
try {
// 反序列化
bais = new ByteArrayInputStream(bytes);
ObjectInputStream ois = new ObjectInputStream(bais);
return ois.readObject();
} catch (Exception e) {

}
}
return null;
}
}

ApplicationContext.xml above that failure to load Redis.properties defined directly in the applicationContext.xml

Redis cache SSM Integrated Framework

Guess you like