商城05——首页轮播图显示实现&Redis环境搭建&Redis实现缓存

1. 课程计划

1、首页轮播图的展示

2、首页大广告展示流程图

3、Redis的常用命令

4、Redis的服务器搭建 (集群的搭建)

5、向业务逻辑中添加缓存

6、Jedis的使用(redis的客户端)

7、缓存同步

2. 首页轮播图展示

taotao-portal-web工程中，动态展示内容信息。

前端团队：负责JS，html等开发。

后端团队：负责后台的开发并提供数据给前端。

2.1. 功能分析

只需要动态生成一个json数据，轮播图就可以动态展示：

taotao-portal-web工程下的index.jsp中：

Json数据格式：

[
    {
        "srcB": "http://image.taotao.com/images/2015/03/03/2015030304360302109345.jpg",
        "height": 240,
        "alt": "",
        "width": 670,
        "src": "http://image.taotao.com/images/2015/03/03/2015030304360302109345.jpg",
        "widthB": 550,
        "href": "http://sale.jd.com/act/e0FMkuDhJz35CNt.html?cpdad=1DLSUE",
        "heightB": 240
}
]

分析:

　　需要 自己自定义POJO 存放数据的列表，在 portal-web 中定义。

　　由于content 服务层是公用的，可以被其他的系统（表现的系统）来调用，所以我们需要的POJO不能再service层返回，

　　所以为了通用性：我们从content 服务层中 获取 tbcontent的内容列表 即 list<TbContent>；portal-web 表现层 需要拿到tbcontent 的列表，然后进行转换成自定义的类型的数据列表即可。

从tb_content表中取数据，根据(叶子节点)内容分类id查询列表(内容列表)。List<TbContent>

内容分类id固定，需要配置在属性文件中。

图片的width、height配置在属性文件中。

Alt属性从sub_title中取。

　　alt-->sub_title

　　Src->pic

　　srcB->pic2

　　Href->url

分析:

　　URL:/index

　　参数：无。

　　返回值:首页页面 (数据是JSON 设置model中)

业务逻辑：

　　1、根据分类的id 查询内容列表(List<TbContent>)

　　 2、发布服务

　　3、表现层引入服务

　　4、调用服务，转换成自定义的数据类型(Ad1Node) 的列表

　　5、将数据列表设置到Model 中，返回给页面。

2.2 后台实现

需要创建一个pojo转换成页面需要的json数据格式。放入com.taotao.portal.pojo中。

：

/**
 * 首页大广告位轮播图数据展示POJO
 */
public class Ad1Node {
    private String srcB; //pic2
    private String height; 
    private String alt;  //subtitle中获取
    private String width;
    private String src;  //pic
    private String widthB;
    private String href; //url
    private String heightB;
    set/get。。。。。。
}

2.2.1 Dao层

　　从tb_content表中取数据，根据内容分类id查询列表。可以使用逆向工程。

2.2.2 Service层

　　　　参数：long categoryId

　　　　返回值：List<TbContent>

接口：（taotao-content-interface工程下com.taotao.content.service包下的 ContentService接口类：）

　　/**
     * 根据cid查询内容列表
     */
    public List<TbContent> getContentListByCatId(long cid);

实现类：（taotao-content-service工程下com.taotao.content.service.impl包下的 ContentServiceImpl 实现类：）

　　@Override
    public List<TbContent> getContentListByCatId(long cid) {
        TbContentExample example = new TbContentExample();
        Criteria criteria = example.createCriteria();
        criteria.andCategoryIdEqualTo(cid);
        //执行查询
        List<TbContent> list = contentMapper.selectByExample(example);
        return list;
    }

发布服务：（applicationContext-service.xml）前面已经发布过了

2.2.3 Controller层

　　在taotao-portal-web中实现，查询首页轮播图的内容

引用服务：

　　首先在taotao-protal-web项目中引入taotao-content-interface的依赖包

　　然后在taotao-protal-web项目下的 springmvc.xml 配置文件中引用dubbo服务：

　　<!-- 引用dubbo服务 -->
    <dubbo:application name="taotao-portal-web" />
    <dubbo:registry protocol="zookeeper" address="192.168.25.129:2181" />
    <dubbo:reference interface="com.taotao.content.service.ContentService" id="contentService" timeout="300000" />

Controller：

　　在首页展示之前，对数据进行处理，然后展示首页，需要在PageController中实现。以大广告位为例子。

　　：

@Controller
public class PageController {

    //注入服务
    @Autowired
    private ContentService contentService;
    
    @Value("${AD1_CATEGORY_ID}")
    private Long categoryId;
    
    @Value("${AD1_HEIGHT_B}")
    private String AD1_HEIGHT_B;
    @Value("${AD1_HEIGHT}")
    private String AD1_HEIGHT;
    @Value("${AD1_WIDTH}")
    private String AD1_WIDTH;
    @Value("${AD1_WIDTH_B}")
    private String AD1_WIDTH_B;

    /**
     * 展示首页
     * @return
     */
    @RequestMapping("/index")
    public String showIndex(Model model){
        //根据内容分类的id查询内容列表
        List<TbContent> contentList = contentService.getContentListByCatId(categoryId);
        //转成自定义的pojo：Ad1Node
        List<Ad1Node> nodes = new ArrayList<Ad1Node>();
        for(TbContent content : contentList){
            Ad1Node node = new Ad1Node();
            node.setAlt(content.getSubTitle());
            node.setHeight(AD1_HEIGHT);
            node.setHeightB(AD1_HEIGHT_B);
            node.setHref(content.getUrl());
            node.setSrc(content.getPic());
            node.setSrcB(content.getPic2());
            node.setWidth(AD1_WIDTH);
            node.setWidthB(AD1_WIDTH_B);
            
            nodes.add(node);
        }
        //传递数据给jsp
        model.addAttribute("ad1", JsonUtils.objectToJson(nodes));
        
        return "index"; //响应jsp
    }
}

属性文件所在位置：

在taotao-portal-web中的springmvc.xml中还需要配置：

<!-- 加载属性文件 -->
<context:property-placeholder location="classpath:resource/*.properties" />

注意在index.jsp页面修改接收数据为“ad1”：

测试效果：

3. 首页大广告的展示流程

　　首页是系统的门户，也就是系统的入口。所以首页的访问量是这个系统最大的。如果每次展示首页都从数据库中查询首页的内容信息，那么势必会对数据库造成很大的压力，所以需要使用缓存来减轻数据库压力。

　　实现缓存的工具有很多，现在比较流行的是redis。

　　首页大广告展示流程：

　　　　展示流程：先从缓存取，如果不存在，从数据库取出来，写入缓存，再返回页面；如果存在key ,直接从缓存中取出来，展示到页面。

　　　　同步缓存：当事务提交（更新，删除，插入）后，需要同步缓存，直接根据Key 删除redis的key(清空缓存) ，再展示时由上边的流程展示。

4. redis的介绍

4.1. 什么是NoSql

为了解决高并发、高可扩展（集群）、高可用（不能宕机）、大数据存储问题而产生的数据库解决方案，就是NoSql数据库。

NoSql ：全称 not only sql ,非关系型数据库。可以作为关系型数据库的一个很好的补充，不能替代关系型数据库。

4.2. NoSql数据库分类

键值(Key-Value)存储数据库

　　相关产品： Tokyo Cabinet/Tyrant、Redis、Voldemort、Berkeley DB。

　　典型应用：内容缓存，主要用于处理大量数据的高访问负载。

　　数据模型：一系列键值对

　　优势：快速查询

　　劣势：存储的数据缺少结构化

列存储数据库

　　相关产品：Cassandra, HBase, Riak

　　典型应用：分布式的文件系统

　　数据模型：以列簇式存储，将同一列数据存在一起

　　优势：查找速度快，可扩展性强，更容易进行分布式扩展

　　劣势：功能相对局限

文档型数据库

　　相关产品：CouchDB、MongoDB

　　典型应用：Web应用（与Key-Value类似，Value是结构化的）

　　数据模型：一系列键值对

　　优势：数据结构要求不严格

　　劣势：查询性能不高，而且缺乏统一的查询语法

图形(Graph)数据库

　　相关数据库：Neo4J、InfoGrid、Infinite Graph

　　典型应用：社交网络

　　数据模型：图结构

　　优势：利用图结构相关算法。

　　劣势：需要对整个图做计算才能得出结果，不容易做分布式的集群方案。

4.3. 什么是redis

Redis是用C语言开发的一个开源的高性能键值对（key-value）数据库（nosql），应用在缓存。它通过提供多种键值数据类型来适应不同场景下的存储需求。

　　目前为止Redis支持的键值数据类型有5种。如下：

　　　　字符串类型 (String)

　　　　散列类型（hash）

　　　　列表类型(List)

　　　　集合类型(set)

　　　　有序集合类型(SortedSet)

1.4. redis的应用场景

缓存（最重要的应用场景）
分布式集群架构中的session分离
任务队列（秒杀、抢购、12306等等）
应用排行榜（SortedSet）
网站访问统计
数据过期处理 (expire)

redis官网：https://redis.io/topics/benchmarks

5. Redis的安装

5.1 Redis的安装

安装redis需要c语言的编译环境,如果没有gcc需要在线安装。

安装步骤：

　　第1步：将redis的源码包上传到linux系统。

　　　　　　Alt+p打开sftp窗口：输入put "F:/java/ziyuan/redis-3.0.0.tar.gz"

　　第2步：解压：tar -zxvf redis-3.0.0.tar.gz

　　第3步：进行编译。 cd到解压后的目录输入命令：make

　　第4步：进行安装。输入命令：make install PREFIX=/usr/local/redis （注意PREFIX 必须是大写的。）

　　第5步：检查目录是否存在。

　　　　　　在/usr/local/redis 下有bin 说明安装成功。

5.2. 连接redis

5.2.1.redis服务端启动

前端启动 [root@localhost bin]# ./redis-server

　　 Ctrl+c退出编辑

　　一般不使用前端启动，而使用后端启动。

后台启动：

　　第1步：把/root/redis-3.0.0/redis.conf复制到/usr/local/redis/bin目录下

[root@localhost redis-3.0.0]# cp redis.conf /usr/local/redis/bin/

　　第2步：使用vim命令修改redis.conf配置文件，开始编辑文本，vim redis.conf后点击 i 键进入编辑（此时在窗体最底下会出现— —insert），将daemonize no修改为daemonize yes 。

　　　　　　输入完成后按ESC键退出，然后保存编辑的文件并退出。命令： :wq

　　第3步：输入启动命令

[root@localhost bin]# ./redis-server redis.conf

　　第4步：检查redis进程：

[root@localhost bin]# ps -ef|grep redis

前端启动，不能更换终端，影响下一步操作。而后台启动，只在进程中悄悄启动。推荐使用后台启动。

5.2.2.客户端Redis-cli连接redis

使用Redis-cli建立连接： [root@localhost bin]# ./redis-cli

　　　　默认连接localhost运行在6379端口的redis服务。

　　　　[root@localhost bin]# ./redis-cli -h 192.168.25.131 -p 6379 （完整的连接服务端的命令，-h：连接的服务器的地址，-p：服务的端口号）

使用redis的桌面程序redis-desktop-manager建立连接

　　　　redis-desktop-manager安装及使用参照https://www.jianshu.com/p/6895384d2b9e

退出连接：

　　　　第一种：

　　　　　　 [root@localhost bin]# ./redis-cli

　　　　127.0.0.1:6379> quit

　　第二种：

　　　　 [root@localhost bin]# ./redis-cli

　　　　127.0.0.1:6379> exit

　　第三种：CTR+C

　　　　　　[root@localhost bin]#

5.2.3. 关闭Redis服务

　　第一种：通过连接上客户端进行关闭，使用shutdown 命令。

　　　　　　或者：cd 到redis的bin 目录再执行以下：[root@localhost bin]# ./redis-cli shutdown　

　　第二种：使用 kill 命令。

　　　　　　找到对应的redis的进程id 然后使用命令：(pid为进程id) kill -9 pid

5.3. Redis五种数据类型

5.3.1.String：key-value

　　redis命令不区分大小写，但key是区分大小的。

　　redis中的数据都是字符串。

　　redis是单线程，（不适合存储比较大的数据）

　　redis中所有的数据都是字符串。

　　set key value 设置值

　　get key 获取值

　　 incr key 加一（使用incr 命令，如果key 不存在，会自动创建key 并自动+1）

　　decr key 减一

5.3.2. Hash: key-field-value

相当于一个key 对应一个map (map中又是key- value)，应用于归类。

hset key field value 设置值

　　hget key field 获取值

hincrby key field num 设置增数量

5.3.3. List

List是有顺序可重复(数据结构中的：双链表，队列)

可作为链表，从左添加元素也可以从右添加元素。

　 lpush list a b c d (从list左边添加元素)

　　 rpush list 1 2 3 4 (从list右边添加元素)

　　lrange list 0 -1 (从0 到 -1 元素查看：也就表示查看所有)

　　lpop list （从list左边取，删除）

　　 rpop list (从list右边取，删除)

5.3.4. Set

　　Set无顺序，不能重复

　　sadd set1 a b c d d (向set1中添加元素) 元素不重复

　　smembers set1 （查询元素）

　　srem set1 a （删除元素）

5.3.5. SortedSet（zset）

有顺序，不能重复。 适合做排行榜排序需要一个分数属性

　　zadd zset1 1 a 2 b 3 c （添加元素 zadd key score member，这里添加元素a:1分、元素b:2分、元素c:3分）

　　zrange zset1 0 -1 (查看zset1的所有元素，默认从小到大)

　　zrange zset1 0 -1 withscores (查看zset1的所有元素,包括分数score)

　　zrevrange zset1 0 -1 (查看zset1的所有元素，从大到小)

　　zincrby zset1 5 a (对zset1的a元素增加5分)

5.4. key 命令

　　expire key second (设置key的过期时间，单位：秒)

　　ttl key (查看剩余时间)（-2 表示不存在，-1 表示已被持久化，正数表示剩余的时间）

　　persist key (清除过期时间，也即是持久化持久化成功体提示 1 不成功0)。

　　del key （删除key ）

　　EXISTS key （若key存在，返回1，否则返回0。）

　　select 0 表示：选择0号数据库。默认是0号数据库

6. Redis持久化方案

Redis 数据都放在内存中。如果机器挂掉，内存的数据就不存在。

需要做持久化，将内存中的数据保存在磁盘，下一次启动的时候就可以恢复数据到内存中。

2种持久化方案：

1、RDB 快照形式（定期将当前时刻的数据保存磁盘中）会产生一个dump.rdb文件

特点：会存在数据丢失，性能较好，数据备份。

2、AOF append only file (所有对redis的操作命令记录在aof文件中)，恢复数据，重新执行一遍即可。

特点：每秒保存，数据比较完整，耗费性能。

redis 默认开启RDB。

如下图：redis.conf中默认设置了保存规则及时间间隔

AOF开启设置：

修改 redis.conf 文件如下图：

将appendonly 设置为yes

同时开启两个持久化方案，则按照 AOF的持久化放案恢复数据。

默认是按照rdb的方式恢复数据，如果开启了AOF，就是用AOF恢复数据，数据是存在于/usr/local/redis/bin/appendonly.aof文件中

7. Redis集群的搭建

7.1. redis-cluster架构图

架构细节:

（1）所有的redis节点彼此互联(PING-PONG机制)，内部使用二进制协议优化传输速度和带宽。

（2）节点的fail是通过集群中超过半数的节点检测失效时才生效。通过投票机制。

（3）客户端与redis节点直连，不需要中间proxy层。客户端不需要连接集群所有节点,连接集群中任何一个可用节点即可。

（4）redis-cluster把所有的物理节点映射到[0-16383]slot上，cluster 负责维护node<->slot<->value。

　　Redis 集群中内置了 16384 个哈希槽，当需要在 Redis 集群中放置一个 key-value 时，redis 先对 key 使用 crc16 算法算出一个结果，然后把结果对 16384 求余数，这样每个 key 都会对应一个编号在 0-16383 之间的哈希槽，redis 会根据节点数量大致均等的将哈希槽映射到不同的节点。

7.2. Redis集群的搭建

　　至少3个节点，为了集群的高可用，为每一个节点增加一个备份机。（6台服务器）。

　　搭建伪分布式集群方案：在一台机器里面运行6个redis实例。端口需要不同（7001-7006）

7.2.1.集群搭建环境

1、使用ruby脚本搭建集群。需要ruby的运行环境。

2、上传redis-3.0.0.gem到 linux中

　　Alt+p打开sftp窗口：输入put "F:/java/ziyuan/redis-3.0.0.gem"

3、安装ruby运行时所使用的包

　　[root@localhost ~]# gem install redis-3.0.0.gem

　　查看redis-trib.rb 脚本所在的目录：

　　　　[root@localhost ~]# cd redis-3.0.0/src

　　　　[root@localhost src]# ll *.rb

　　　　-rwxrwxr-x. 1 root root 48141 Apr 1 2015 redis-trib.rb

7.2.2. 搭建步骤

　　需要6台redis服务器。搭建伪分布式。

　　需要6个redis实例。

　　需要运行在不同的端口7001-7006

　　使用之前搭建好的redis实例。

　　注意：搭建前如果节点里有数据，需要删除（rdb文件，aof文件）。

第1步：创建6个redis实例，每个实例运行在不同的端口。需要修改redis.conf配置文件。配置文件中还需要把cluster-enabled yes前的注释去掉。

创建目录：[root@localhost local]# mkdir redis-cluster

copy 之前搭建好的redis 并改名为redis01 ：[root@localhost local]# cp redis/ redis-cluster/redis01 -r

进入redis-cluster目录中cd到redis01的bin目录，删除数据文件。

　　[root@localhost local]# cd redis-cluster/redis01/bin

　　[root@localhost bin]# rm -rf *.rdb *.aof

修改redis.conf,取消注释,如图

　　[root@localhost bin]# vim redis.conf

　　更改端口号为7001：

　　按ESC :wq 保存退出。

cd到redis-cluster目录
copy六份并分别命名为redis02,redis03,redis04,redis05,redis06

　　[root@localhost redis-cluster]# cp redis01 redis02 -r

　　[root@localhost redis-cluster]# cp redis01 redis03 -r

　　[root@localhost redis-cluster]# cp redis01 redis04 -r

　　[root@localhost redis-cluster]# cp redis01 redis05 -r

　　[root@localhost redis-cluster]# cp redis01 redis06 -r

cd到每一个实例的bin目录，修改redis02到redis06的端口分别改为7002-7006

　　[root@localhost redis-cluster]# vim redis02/bin/redis.conf

第2步：启动每个redis实例。

　　vim redis-cluster-start-all.sh

　　添加如下文字到文件中：

　　　　cd /usr/local/redis-cluster/redis01/bin

　　　　./redis-server redis.conf

　　　　cd /usr/local/redis-cluster/redis02/bin

　　　　./redis-server redis.conf

　　　　cd /usr/local/redis-cluster/redis03/bin

　　　　./redis-server redis.conf

　　　　cd /usr/local/redis-cluster/redis04/bin

　　　　./redis-server redis.conf

　　　　cd /usr/local/redis-cluster/redis05/bin

　　　　./redis-server redis.conf

　　　　cd /usr/local/redis-cluster/redis06/bin

　　　　./redis-server redis.conf

修改文件：redis-cluster-start-all.sh 的权限，让其可执行。

　　　　chmod u+x redis-cluster-start-all.sh

执行启动：[root@localhost redis-cluster]# ./redis-cluster-start-all.sh

第3步：使用ruby脚本搭建集群。

从解压目录下的src下的拷贝redis-trib.rb文件到redis-cluster目录中

　　[root@localhost src]# cp redis-trib.rb /usr/local/redis-cluster/

执行创建：

　　[root@localhost redis-cluster]# ./redis-trib.rb create --replicas 1 192.168.25.153:7001 192.168.25.153:7002 192.168.25.153:7003 192.168.25.153:7004 192.168.25.153:7005 192.168.25.153:7006

第4步：创建关闭集群的脚本：（不是必须的）

　　首先使用:vim 命令创建一个文件 redis-cluster-stop-all.sh

　　编辑文件，添加如下：

　　　　cd /usr/local/redis-cluster/redis01/bin

　　　　./redis-cli -p 7001 shutdown

　　　　cd /usr/local/redis-cluster/redis02/bin

　　　　./redis-cli -p 7002 shutdown

　　　　cd /usr/local/redis-cluster/redis03/bin

　　　　./redis-cli -p 7003 shutdown

　　　　cd /usr/local/redis-cluster/redis04/bin

　　　　./redis-cli -p 7004 shutdown

　　　　cd /usr/local/redis-cluster/redis05/bin

　　　　./redis-cli -p 7005 shutdown

　　　　cd /usr/local/redis-cluster/redis06/bin

　　　　./redis-cli -p 7006 shutdown

　　修改文件：redis-cluster-stop-all.sh 的权限，让其可执行：chmod u+x redis-cluster-stop-all.sh

7.3. 集群的使用方法

　　Redis-cli连接集群：[root@localhost redis-cluster]# redis01/bin/redis-cli -p 7002 -c

　　（-c：代表连接的是redis集群）

　　使用命令操作redis是和单机版的一样。

8. Jedis

　　Jedis是Redis官方推出的一款面向Java的客户端，提供了很多接口供Java语言调用。可以在Redis官网下载，当然还有一些开源爱好者提供的客户端，如Jredis、SRP等等，推荐使用Jedis。

　　需要把jedis依赖的jar包添加到工程中。Maven工程中需要把jedis的坐标添加到依赖。

　　添加缓存（添加图片首页的轮播图，轮播图属于内容content）

　　推荐添加到服务层。Taotao-content-Service工程中。

　　添加如下坐标到taotao-content-service中的pom.xml文件中：

　　　　　　　<!-- Redis客户端 -->
            <dependency>
                <groupId>redis.clients</groupId>
                <artifactId>jedis</artifactId>
                <version>${jedis.version}</version>
            </dependency>

8.1. 连接单机版

第一步：创建一个Jedis对象。需要指定服务端的ip及端口。

第二步：使用Jedis对象操作数据库，每个redis命令对应一个方法。

第三步：打印结果。

第四步：关闭Jedis

　　/**
     * 测试单机版
     */
    @Test
    public void testJedis(){
        //1.创建Jedis对象 需要指定连接的地址和端口
        Jedis jedis = new Jedis("192.168.25.131",6379);
        //2.直接操作Jedis set
        jedis.set("key123", "value123");
        System.out.println(jedis.get("key123"));
        //3.关闭Jedis
        jedis.close();
    }
输出：value123

8.2. 使用连接池连接单机版

第一步：创建一个JedisPool对象。需要指定服务端的ip及端口。

第二步：从JedisPool中获得Jedis对象。

第三步：使用Jedis操作redis服务器。

第四步：操作完毕后关闭jedis对象，连接池回收资源。

第五步：关闭JedisPool对象。

　　/**
     * 使用连接池连接单机版
     */
    @Test
    public void testJedisPool(){
        // 第一步：创建一个JedisPool对象。需要指定服务端的ip及端口。
        JedisPool jedisPool = new JedisPool("192.168.25.131", 6379);
        // 第二步：从JedisPool中获得Jedis对象。
        Jedis jedis = jedisPool.getResource();
        // 第三步：使用Jedis操作redis服务器。
        jedis.set("jedis", "test");
        String result = jedis.get("jedis");
        System.out.println(result);
        // 第四步：操作完毕后关闭jedis对象，连接池回收资源。
        jedis.close();
        // 第五步：关闭JedisPool对象。
        jedisPool.close();
    }
输出：test

8.3. 连接集群版

第一步：使用JedisCluster对象。需要一个Set<HostAndPort>参数。Redis节点的列表。

第二步：直接使用JedisCluster对象操作redis。在系统中单例存在。

第三步：打印结果

第四步：系统关闭前，关闭JedisCluster对象。

/**
     * 连接集群版
     */
    @Test
    public void testJedisCluster() throws Exception {
        //1.创建JedisCluster对象
        //需要一个Set<HostAndPort>参数。Redis节点的列表。
        Set<HostAndPort> nodes = new HashSet<>();
        nodes.add(new HostAndPort("192.168.25.131", 7001));
        nodes.add(new HostAndPort("192.168.25.131", 7002));
        nodes.add(new HostAndPort("192.168.25.131", 7003));
        nodes.add(new HostAndPort("192.168.25.131", 7004));
        nodes.add(new HostAndPort("192.168.25.131", 7005));
        nodes.add(new HostAndPort("192.168.25.131", 7006));
        JedisCluster jedisCluster = new JedisCluster(nodes);
        //2.直接根据JedisCluster对象操作redis集群
        jedisCluster.set("hello", "100");
        //3.打印结果
        System.out.println(jedisCluster.get("hello"));
        //4.系统关闭前，关闭JedisCluster对象
        jedisCluster.close();
    }
输出：100

9. 向业务逻辑中添加缓存

因为集群是比较消耗成本的，所以在公司中，一般生产环境使用集群，开发环境使用单机版。

我们在项目整合中都需要有。

可以开发一个接口，有单机版的实现类和集群版的实现类。使用时可以面向接口开发，不影响业务逻辑，使用spring管理实现类，部署时切换实现类即可。

9.1. 接口封装

常用的操作redis的方法抽取出一个接口，分别对应单机版和集群版创建两个实现类。

9.1.1.接口定义

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);
}

9.1.2.单机版实现类

public class JedisClientPool implements JedisClient {
    
    @Autowired
    private 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;
    }

}

9.1.3.applicationContext-redis.xml

<!-- 配置单机版的连接 -->
    <bean id="jedisPool" class="redis.clients.jedis.JedisPool">
        <constructor-arg name="host" value="192.168.25.131"></constructor-arg>
        <constructor-arg name="port" value="6379"></constructor-arg>
    </bean>
    <bean id="jedisClientPool" class="com.taotao.jedis.JedisClientPool"/>    
</beans>

9.1.4.集群版实现类

public class JedisClientCluster implements JedisClient {
    
    @Autowired
    private 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);
    }

}

9.1.5.Spring的配置：

添加此配置到applicationContext-redis.xml中：

　　<!-- 集群版的配置 -->
    <bean id="jedisCluster" class="redis.clients.jedis.JedisCluster">
        <constructor-arg>
            <set>
                <bean class="redis.clients.jedis.HostAndPort">
                    <constructor-arg name="host" value="192.168.25.131"></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.131"></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.131"></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.131"></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.131"></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.131"></constructor-arg>
                    <constructor-arg name="port" value="7006"></constructor-arg>
                </bean>
            </set>
        </constructor-arg>
    </bean>
    <bean id="jedisClientCluster" class="com.taotao.jedis.JedisClientCluster"/>

注意：单机版和集群版不能共存，使用单机版时注释集群版的配置。使用集群版，把单机版注释。

9.2. 封装代码测试

　　@Test
    public void testdanji(){
        //1.初始化spring容器
        ApplicationContext context = new ClassPathXmlApplicationContext("classpath:spring/applicationContext-redis.xml");
        //2.获取实现类实例
        JedisClient bean = context.getBean(JedisClient.class);
        //3.调用方法操作
        bean.set("jedisclientkey11", "jedisclientkey");
        System.out.println(bean.get("jedisclientkey11"));
    }

9.3. 添加缓存

9.3.1.功能分析

查询内容列表时添加缓存。

　　1、查询数据库之前先查询缓存。

　　2、查询到结果，直接响应结果。

　　3、查询不到，缓存中没有需要查询数据库。

　　4、把查询结果添加到缓存中。

　　5、返回结果。

向redis中添加缓存：

　　Key：categoryId field

　　Value：内容列表。需要把java对象转换成json。

　　使用hash对key进行归类。

　　HASH_KEY:HASH

　　 |--KEY:VALUE

注意：添加缓存不能影响正常业务逻辑。

9.3.2.代码实现

在 ContentServiceImpl 实现类中的 getContentListByCatId方法（查询内容列表）添加缓存：

//注入jedisClient
    @Autowired
    private JedisClient jedisClient;
    
    @Value("${CONTENT_KEY}")
    private String CONTENT_KEY;
    //////////根据cid查询内容列表
    @Override
    public List<TbContent> getContentListByCatId(long cid) {
        
        //查询缓存。判断是否redis中有数据，如果有，直接从redis中获取数据返回
        try{
            String jsonstr = jedisClient.hget(CONTENT_KEY, cid+"");//从redis数据库中获取内容分类下的所有内容
            if(StringUtils.isNoneBlank(jsonstr)){//不为空
                //System.out.println("这里有缓存了！！！");
                return JsonUtils.jsonToList(jsonstr, TbContent.class);
            }
        }catch(Exception e){
            e.printStackTrace();
        }
//创建example
        TbContentExample example = new TbContentExample();
        //设置查询条件
        Criteria criteria = example.createCriteria();
        criteria.andCategoryIdEqualTo(cid);
        //执行查询
        List<TbContent> list = contentMapper.selectByExample(example);
        
        //将数据写入到redis数据库:
        try{
            //System.out.println("没有缓存！");
            jedisClient.hset(CONTENT_KEY, cid+"", JsonUtils.objectToJson(list));
        }catch(Exception e){
            e.printStackTrace();
        }

//返回
        return list;
    }

属性文件所在的位置：

要想能加载还需要在applicationContext-dao.xml中配置：

<context:property-placeholder location="classpath:properties/*.properties" />

9.4. 缓存同步

对内容信息做增删改操作后只需要把对应缓存key删除即可。

以添加内容为例，可以根据categoryId删除。

    ///////////添加内容
    @Override
    public TaotaoResult addContent(TbContent content) {
        //补全属性
        content.setCreated(new Date());
        content.setUpdated(new Date());
        //插入数据
        contentMapper.insert(content);
        
        //当添加内容的时候，需要清空此内容所属的分类下的所有的缓存
        try{
            jedisClient.hdel(CONTENT_KEY, content.getCategoryId()+"");
            System.out.println("当插入时清空缓存！");
        }catch(Exception e){
            e.printStackTrace();
        }
        
        //返回结果
        return TaotaoResult.ok();
    }

posted on 2019-06-18 16:11 Toria 阅读(1160) 评论(0) 编辑收藏举报

刷新页面返回顶部

Toria

商城05——首页轮播图显示实现&Redis环境搭建&Redis实现缓存

1. 课程计划

2. 首页轮播图展示

2.1. 功能分析

2.2 后台实现

2.2.1 Dao层

2.2.2 Service层

2.2.3 Controller层

3. 首页大广告的展示流程

4. redis的介绍

4.1. 什么是NoSql

4.2. NoSql数据库分类

4.3. 什么是redis

1.4. redis的应用场景

5. Redis的安装

5.1 Redis的安装

5.2. 连接redis

5.2.1.redis服务端启动

5.2.2.客户端Redis-cli连接redis

5.2.3. 关闭Redis服务

5.3. Redis五种数据类型

5.3.1.String：key-value

5.3.2. Hash: key-field-value

5.3.3. List

5.3.4. Set

5.3.5. SortedSet（zset）

5.4. key 命令

6. Redis持久化方案

7. Redis集群的搭建

7.1. redis-cluster架构图

7.2. Redis集群的搭建

7.2.1.集群搭建环境

7.2.2. 搭建步骤

7.3. 集群的使用方法

8. Jedis

8.1. 连接单机版

8.2. 使用连接池连接单机版

8.3. 连接集群版

9. 向业务逻辑中添加缓存

9.1. 接口封装

9.1.1.接口定义

9.1.2.单机版实现类

9.1.3.applicationContext-redis.xml

9.1.4.集群版实现类

9.1.5.Spring的配置：

9.2. 封装代码测试

9.3. 添加缓存

9.3.1.功能分析

9.3.2.代码实现

9.4. 缓存同步

导航

公告