ssm框架之前已经搭建过了,这里不再做代码复制工作。
这里主要是利用redis去做mybatis的二级缓存,mybaits映射文件中所有的select都会刷新已有缓存,如果不存在就会新建缓存,所有的insert,update操作都会更新缓存。
redis的好处也显而易见,可以使系统的数据访问性能更高。本节只是展示了整合方法和效果,后面会补齐redis集群、负载均衡和session共享的文章。
下面就开始整合工作:
后台首先启动redis-server(后台启动与远程连接linux服务的方法都需要改redis.conf文件),启动命令“./src/redis-server ./redis.conf”
我这里是windows系统下开发的,推荐一个可视化工具“Redis Desktop manager”,需要远程连接linux下的redis,需要linux下开启端口对外开放(具体方法是修改/etc/sysconfig/iptables文件,增加对外端口开发命令)。
以上操作都完成后,即可远程连接成功了,如图:
现在还没有缓存记录,下面进入代码阶段,首先在pom.xml中增加需要的redis jar包
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
<dependency> <groupId>redis.clients</groupId> <artifactId>jedis</artifactId> <version> 2.9 . 0 </version> </dependency> <dependency> <groupId>org.springframework.data</groupId> <artifactId>spring-data-redis</artifactId> <version> 1.6 . 2 .RELEASE</version> </dependency> <dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis-ehcache</artifactId> <version> 1.0 . 0 </version> </dependency> <!-- 添加druid连接池包 --> <dependency> <groupId>com.alibaba</groupId> <artifactId>druid</artifactId> <version> 1.0 . 24 </version> </dependency> |
pom.xml写好后,还需要新增两个配置文件:redis.properties
1
2
3
4
5
6
7
|
redis.host= 192.168 . 0.109 redis.port= 6379 redis.pass= 123456 redis.maxIdle= 200 redis.maxActive= 1024 redis.maxWait= 10000 redis.testOnBorrow= true |
其中字段也都很好理解,再加入配置文件:spring-redis.xml
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
|
<beans xmlns= "http://www.springframework.org/schema/beans" xsi:schemaLocation="http: //www.springframework.org/schema/beans http: //www.springframework.org/schema/beans/spring-beans-4.3.xsd http: //www.springframework.org/schema/util http: //www.springframework.org/schema/util/spring-util-4.3.xsd http: //www.springframework.org/schema/mvc http: //www.springframework.org/schema/mvc/spring-mvc-4.3.xsd http: //www.springframework.org/schema/aop http: //www.springframework.org/schema/aop/spring-aop-4.3.xsd http: //www.springframework.org/schema/context http: //www.springframework.org/schema/context/spring-context-4.3.xsd"> <!-- 连接池基本参数配置,类似数据库连接池 --> <context:property-placeholder location= "classpath*:redis.properties" /> <bean id= "poolConfig" class = "redis.clients.jedis.JedisPoolConfig" > <property name= "maxTotal" value= "${redis.maxActive}" /> <property name= "maxIdle" value= "${redis.maxIdle}" /> <property name= "testOnBorrow" value= "${redis.testOnBorrow}" /> </bean> <!-- 连接池配置,类似数据库连接池 --> <bean id= "jedisConnectionFactory" class = "org.springframework.data.redis.connection.jedis.JedisConnectionFactory" > <property name= "hostName" value= "${redis.host}" ></property> <property name= "port" value= "${redis.port}" ></property> <property name= "password" value= "${redis.pass}" ></property> <property name= "poolConfig" ref= "poolConfig" ></property> </bean> <!-- 调用连接池工厂配置 --> <!-- <bean id= "redisTemplate" class = " org.springframework.data.redis.core.RedisTemplate" > <property name= "jedisConnectionFactory" ref= "jedisConnectionFactory" ></property> 如果不配置Serializer,那么存储的时候智能使用String,如果用User类型存储,那么会提示错误User can't cast to String!!! <property name= "keySerializer" > <bean class = "org.springframework.data.redis.serializer.StringRedisSerializer" /> </property> <property name= "valueSerializer" > <bean class = "org.springframework.data.redis.serializer.JdkSerializationRedisSerializer" /> </property> </bean> --> <bean id= "redisCacheTransfer" class = "com.cjl.util.RedisCacheTransfer" > <property name= "jedisConnectionFactory" ref= "jedisConnectionFactory" /> </bean> </beans> |
配置文件写好后,就开始java代码的编写:
JedisClusterFactory.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
|
package com.cjl.util; 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) { throw new IllegalArgumentException( "ip 或 port 不合法" ); } String[] ipAndPort = val.split( ":" ); HostAndPort hap = new HostAndPort(ipAndPort[ 0 ], Integer.parseInt(ipAndPort[ 1 ])); haps.add(hap); } return haps; } catch (IllegalArgumentException ex) { throw ex; } catch (Exception ex) { throw new Exception( "解析 jedis 配置文件失败" , 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; } } |
RedisCache.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
|
package com.cjl.util; 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; } /** * 清空所有缓存 */ public void clear() { rwl.readLock().lock(); JedisConnection connection = null ; try { connection = jedisConnectionFactory.getConnection(); connection.flushDb(); connection.flushAll(); } catch (JedisConnectionException e) { e.printStackTrace(); } finally { if (connection != null ) { connection.close(); } rwl.readLock().unlock(); } } public String getId() { return this .id; } /** * 获取缓存总数量 */ public int getSize() { int result = 0 ; JedisConnection connection = null ; try { connection = jedisConnectionFactory.getConnection(); result = Integer.valueOf(connection.dbSize().toString()); logger.info( "添加mybaits二级缓存数量:" + 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( "添加mybaits二级缓存key=" + key + ",value=" + value); } catch (JedisConnectionException e) { e.printStackTrace(); } finally { if (connection != null ) { connection.close(); } rwl.writeLock().unlock(); } } public Object getObject(Object key) { // 先从缓存中去取数据,先加上读锁 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( "命中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) { RedisCache.jedisConnectionFactory = jedisConnectionFactory; } public ReadWriteLock getReadWriteLock() { // TODO Auto-generated method stub return rwl; } } |
RedisCacheTransfer.java
1
2
3
4
5
6
7
8
9
10
11
12
|
package com.cjl.util; 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); } } |
SerializeUtil.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
|
package com.cjl.util; import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; /** * * @author cjl * */ public class SerializeUtil { /** * 序列化 */ 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 ; } /** *反序列化 */ 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 ; } } |
所有东西准备齐全后还需要修改映射文件
要使mybaits缓存生效,还需如上图这样开启二级缓存。配置文件还需要在web.xml中加载生效
一切准备就绪后,启动服务