使用图形化界面和Jedis操作redis

图形化界面

图形界面的客户端Redis Desktop Manager，可以看到每个redis里边存了多少key

jedis的使用

在content-service的pom中添加对jedis的依赖

建一个测试类cn.e3mall.jedis.JedisTest

public class JedisTest {

    /**
     * 连接单机版
     * @throws Exception
     */
    @Test
    public void testJedis() throws Exception{
        //创建一个链接Jedis对象，参数：host,port
        Jedis jedis=new Jedis("192.168.25.130",6379);
        //直接使用jedis操作redis，所有jedis的命令都对应一个方法
        jedis.set("test123","my first jedis test");
        String string=jedis.get("test123");
        System.out.println(string);
        //关闭连接
        jedis.close();

    }


    /**
     * 连接单机版，用连接池
     * @throws Exception
     */
    @Test
    public void testJedisPool() throws Exception{
        //创建一个连接池对象，两个参数host,port
        JedisPool jedisPool=new JedisPool("192.168.25.130",6379);
        //从连接池获得一个连接，就是一个jedis对象
        Jedis jedis=jedisPool.getResource();
        //使用jedis操作redis
        String string=jedis.get("test123");
        System.out.println(string);
        //关闭连接，每次使用完后关闭连接。连接池回收资源
        jedis.close();
        //关闭连接池
        jedisPool.close();
    }


    /**
     * 操作redis集群
     * @throws Exception
     */
    @Test
    public void testJedisCluster()throws Exception{
        //创建一个JedisCluster对象。他自带连接池。有一个参数nodes是一个set类型。set中包含若干个HostAndPort对象
        Set<HostAndPort> nodes=new HashSet<>();
        nodes.add(new HostAndPort("192.168.25.130",7001));
        nodes.add(new HostAndPort("192.168.25.130",7002));
        nodes.add(new HostAndPort("192.168.25.130",7003));
        nodes.add(new HostAndPort("192.168.25.130",7004));
        nodes.add(new HostAndPort("192.168.25.130",7005));
        nodes.add(new HostAndPort("192.168.25.130",7006));

        JedisCluster jedisCluster=new JedisCluster(nodes);
        //直接使用jedisCluster对象操作jedis
        jedisCluster.set("test","123");
        String string=jedisCluster.get("test");
        System.out.println(string);
        //关闭JedisCluster对象
        jedisCluster.close();
    }

}

现在有单机版和集群版，那我们平时开发的时候用单机版还是集群版呢，平时开发的时候用单机版就可以了，没必要弄六七台服务器就为连个redis，等上线的时候再用集群版。

但发现操作集群版和单机版用的代码不一样啊，到时候切换的时候会很麻烦。

怎么才能不改代码呢？

面向接口编程

之前写dao层的时候为啥要先写一个接口再写实现类呢，就是为了以后如果要改实现类的话直接切换过去就行了。
现在定义一个接口，我们用的时候用这个接口，到时候具体用哪个实现类在spring的配置文件中配置一下就行了。以后切换单机和集群的收代码就不用动了，修改配置文件就可以了。

接口JedisClient

public interface JedisClient {

    String set(String key, String value);
    String get(String key);
    Boolean exists(String key);
    Long expire(String key, int seconds);
    Long ttl(String key);
    Long incr(String key);
    Long hset(String key, String field, String value);
    String hget(String key, String field);
    Long hdel(String key, String... field);
}

单机版工具类,JedisClientPool

public class JedisClientPool implements JedisClient {

    private JedisPool jedisPool;

    public void setJedisPool(JedisPool jedisPool) {
        this.jedisPool = jedisPool;
    }

    @Override
    public String set(String key, String value) {
        Jedis jedis = jedisPool.getResource();
        String result = jedis.set(key, value);
        jedis.close();
        return result;
    }

    @Override
    public String get(String key) {
        Jedis jedis = jedisPool.getResource();
        String result = jedis.get(key);
        jedis.close();
        return result;
    }

    @Override
    public Boolean exists(String key) {
        Jedis jedis = jedisPool.getResource();
        Boolean result = jedis.exists(key);
        jedis.close();
        return result;
    }

    @Override
    public Long expire(String key, int seconds) {
        Jedis jedis = jedisPool.getResource();
        Long result = jedis.expire(key, seconds);
        jedis.close();
        return result;
    }

    @Override
    public Long ttl(String key) {
        Jedis jedis = jedisPool.getResource();
        Long result = jedis.ttl(key);
        jedis.close();
        return result;
    }

    @Override
    public Long incr(String key) {
        Jedis jedis = jedisPool.getResource();
        Long result = jedis.incr(key);
        jedis.close();
        return result;
    }

    @Override
    public Long hset(String key, String field, String value) {
        Jedis jedis = jedisPool.getResource();
        Long result = jedis.hset(key, field, value);
        jedis.close();
        return result;
    }

    @Override
    public String hget(String key, String field) {
        Jedis jedis = jedisPool.getResource();
        String result = jedis.hget(key, field);
        jedis.close();
        return result;
    }

    @Override
    public Long hdel(String key, String... field) {
        Jedis jedis = jedisPool.getResource();
        Long result = jedis.hdel(key, field);
        jedis.close();
        return result;
    }

}

集群版工具类

public class JedisClientCluster implements JedisClient {


    private JedisCluster jedisCluster;

    public void setJedisCluster(JedisCluster jedisCluster) {
        this.jedisCluster = jedisCluster;
    }

    @Override
    public String set(String key, String value) {
        return jedisCluster.set(key, value);
    }

    @Override
    public String get(String key) {
        return jedisCluster.get(key);
    }

    @Override
    public Boolean exists(String key) {
        return jedisCluster.exists(key);
    }

    @Override
    public Long expire(String key, int seconds) {
        return jedisCluster.expire(key, seconds);
    }

    @Override
    public Long ttl(String key) {
        return jedisCluster.ttl(key);
    }

    @Override
    public Long incr(String key) {
        return jedisCluster.incr(key);
    }

    @Override
    public Long hset(String key, String field, String value) {
        return jedisCluster.hset(key, field, value);
    }

    @Override
    public String hget(String key, String field) {
        return jedisCluster.hget(key, field);
    }

    @Override
    public Long hdel(String key, String... field) {
        return jedisCluster.hdel(key, field);
    }

}

把这三个类添加到common的cn.e3mall.common.jedis包中

然后把content的pom文件中对jedis的依赖剪切到common的pom中

再在content的cn.e3mall.jedis中建立一个测试类JedisClientTest

public class JedisClientTest {

    @Test
    public void testJedisClient()throws Exception{
        //初始化spring容器
        ApplicationContext applicationContext=new ClassPathXmlApplicationContext("classpath:spring/applicationContext-redis.xml");
        //从容器中获得JedisClient对象
        JedisClient jedisClient=applicationContext.getBean(JedisClient.class);
        jedisClient.set("mytest","jedisClient");
        String string=jedisClient.get("mytest");
        System.out.println(string);
    }
}

在其spring目录下建立一个配置文件applicationContent-reids.xml，用哪个实现类就把哪个的注释解开，代码不用变。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns="http://www.springframework.org/schema/beans"

       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.2.xsd">

    <!--连接jedis单机版-->
    <!--<bean id="jedisClientPool" class="cn.e3mall.common.jedis.JedisClientPool">-->
        <!--<property name="jedisPool" ref="jedisPool"/>-->
    <!--</bean>-->

    <!--<bean id="jedisPool" class="redis.clients.jedis.JedisPool">-->
        <!--<constructor-arg name="host" value="192.168.25.130"/>-->
        <!--<constructor-arg name="port" value="6379"/>-->
    <!--</bean>-->

    <!--连接redis集群-->
    <bean id="jedisClientCluster" class="cn.e3mall.common.jedis.JedisClientCluster">
        <property name="jedisCluster" ref="jedisCluster"/>
    </bean>

    <bean id="jedisCluster" class="redis.clients.jedis.JedisCluster">
        <constructor-arg name="nodes">
            <set>
                <bean class="redis.clients.jedis.HostAndPort">
                    <constructor-arg name="host" value="192.168.25.130"></constructor-arg>
                    <constructor-arg name="port" value="7001"></constructor-arg>
                </bean>
                <bean class="redis.clients.jedis.HostAndPort">
                    <constructor-arg name="host" value="192.168.25.130"></constructor-arg>
                    <constructor-arg name="port" value="7002"></constructor-arg>
                </bean>
                <bean class="redis.clients.jedis.HostAndPort">
                    <constructor-arg name="host" value="192.168.25.130"></constructor-arg>
                    <constructor-arg name="port" value="7003"></constructor-arg>
                </bean>
                <bean class="redis.clients.jedis.HostAndPort">
                    <constructor-arg name="host" value="192.168.25.130"></constructor-arg>
                    <constructor-arg name="port" value="7004"></constructor-arg>
                </bean>
                <bean class="redis.clients.jedis.HostAndPort">
                    <constructor-arg name="host" value="192.168.25.130"></constructor-arg>
                    <constructor-arg name="port" value="7005"></constructor-arg>
                </bean>
                <bean class="redis.clients.jedis.HostAndPort">
                    <constructor-arg name="host" value="192.168.25.130"></constructor-arg>
                    <constructor-arg name="port" value="7006"></constructor-arg>
                </bean>
            </set>
        </constructor-arg>
    </bean>

</beans>

在项目中加缓存

推荐加在服务层，因为以后只要调用了这个服务就有缓存。

修改content-service的contentServiceImpl.java中的getContentListByCid方法

@Autowired
private JedisClient jedisClient;

@Value("${CONTENT_LIST}")
private String CONTENT_LIST;

 @Override
    public List<TbContent> getContentListByCid(long cid) {
        /*
        查询缓存和添加结果到缓存出错了都不应该报错，应该try-catch
        因为不用缓存也可以正常使用。出错之后不应该影响正常的逻辑。但应该打印一下日志
         */
        //查询缓存
        try {
            //如果缓存中有直接响应结果
            String json=jedisClient.hget(CONTENT_LIST,cid+"");
            if(StringUtil.isNotEmpty(json)){
                List<TbContent> list=JsonUtils.jsonToList(json,TbContent.class);
                return list;
            }

        }catch (Exception e){
            e.printStackTrace();
        }
        //如果没有查询数据库
        TbContentExample example=new TbContentExample();
        TbContentExample.Criteria criteria=example.createCriteria();
        criteria.andCategoryIdEqualTo(cid);
        List<TbContent> tbContents = contentMapper.selectByExampleWithBLOBs(example);
        //把结果添加到缓存
        /*
            我会将一堆东西都存入redis中。我应该分一下类。
            用哈希，大key为CONTENT_LIST，field为cid，value为List<TbContent>
            这里把CONTENT_LIST存到了配置文件中resource.properties，然后我要加载这个配置文件，但
            <context:property-placeholder location="classpath:conf/*.properties" />，这个只能写一个，
            于是就改成了*.properties
         */
        try {
            jedisClient.hset(CONTENT_LIST,cid+"", JsonUtils.objectToJson(tbContents));

        }catch (Exception e){
            e.printStackTrace();
        }

        return tbContents;
    }

添加一个conf/resource.properties

#内容列表在redis中缓存的key
CONTENT_LIST=CONTENT_LIST

修改applicationContent-dao.xml

<!-- 加载配置文件 -->
    <context:property-placeholder location="classpath:conf/*.properties" />

缓存同步

问题，比如我更改了 数据库，但是缓存中没改，下次查还是从缓存中查，那查出来的结果还是以前的。

解决方案：每次更改了数据库后都把相应的缓存中的东西删除。这样缓存中没有了，下次查的时候就会去数据库中查了，然后再添加新的缓存数据。

更改content-service中ContentServiceImpl.java中的addContent方法

@Override
    public TaotaoResult addContent(TbContent content) {
        //将内容插入到内容表
        content.setCreated(new Date());
        content.setUpdated(new Date());
        //插入到数据库
        contentMapper.insert(content);
        //缓存同步，删除缓存中对应的数据
        jedisClient.hdel(CONTENT_LIST,content.getCategoryId().toString());
        return TaotaoResult.ok();
    }