四川盐亭网站制作公司

redis与ssm如何整合

这篇文章主要介绍redis与ssm如何整合，文中介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们一定要看完！

创新互联专注于企业全网营销推广、网站重做改版、高邮网站定制设计、自适应品牌网站建设、H5技术、商城开发、集团公司官网建设、外贸营销网站建设、高端网站制作、响应式网页设计等建站业务，价格优惠性价比高，为高邮等各大城市提供网站开发制作服务。

SSM+redis整合

ssm框架之前已经搭建过了，这里不再做代码复制工作。

这里主要是利用redis去做mybatis的二级缓存，mybaits映射文件中所有的select都会刷新已有缓存，如果不存在就会新建缓存，所有的insert，update操作都会更新缓存。

redis的好处也显而易见，可以使系统的数据访问性能更高。本节只是展示了整合方法和效果，后面会补齐redis集群、负载均衡和session共享的文章。

下面就开始整合工作：

redis与ssm如何整合

后台首先启动redis-server（后台启动与远程连接linux服务的方法都需要改redis.conf文件），启动命令“./src/redis-server ./redis.conf”

我这里是windows系统下开发的，推荐一个可视化工具“Redis Desktop manager”,需要远程连接linux下的redis，需要linux下开启端口对外开放（具体方法是修改/etc/sysconfig/iptables文件，增加对外端口开发命令）。

以上操作都完成后，即可远程连接成功了，如图：

redis与ssm如何整合

redis与ssm如何整合

现在还没有缓存记录，下面进入代码阶段，首先在pom.xml中增加需要的redis jar包


      redis.clients
      jedis
      2.9.0
    
    
      org.springframework.data
      spring-data-redis
      1.6.2.RELEASE
    
    
      org.mybatis
      mybatis-ehcache
      1.0.0
    
     
    
      com.alibaba
      druid
      1.0.24
    

pom.xml写好后，还需要新增两个配置文件：redis.properties

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


  
   
  
    
    
    
  
  
  
    
    
    
     
  
  
  
  
    
  

配置文件写好后，就开始java代码的编写：

JedisClusterFactory.java

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, 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 getObjectType() {
    return (this.jedisCluster != null ? this.jedisCluster.getClass() : JedisCluster.class);
  }
  public boolean isSingleton() {
    return true;
  }
  private Set parseHostAndPort() throws Exception {
    try {
      Properties prop = new Properties();
      prop.load(this.addressConfig.getInputStream());
      Set haps = new HashSet();
      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 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

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 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 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 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
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
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;
  }
}
所有东西准备齐全后还需要修改映射文件
redis与ssm如何整合
要使mybaits缓存生效，还需如上图这样开启二级缓存。配置文件还需要在web.xml中加载生效
redis与ssm如何整合
一切准备就绪后，启动服务
redis与ssm如何整合
启动成功后，点击员工表单可以触发查询所有员工的方法，第一次进行查询语句可以看到mybatis打印了查询语句，并在redis服务器中更新了一条缓存
redis与ssm如何整合
redis与ssm如何整合
我们清空控制台再次点击查询员工按钮执行查询方法，可以看到没有执行查询语句，证明第二次查询直接从缓存中取值，没有连接MySQL进行查询。
redis与ssm如何整合
以上是“redis与ssm如何整合”这篇文章的所有内容，感谢各位的阅读！希望分享的内容对大家有帮助，更多相关知识，欢迎关注创新互联行业资讯频道！
            
            
                            

                文章名称：redis与ssm如何整合                

                网页URL：http://scyanting.com/article/ijejog.html
            
        
        

            
其他资讯