您的位置：首页 > 数据库 > Redis

框架 day79 涛涛商城项目-业务中添加redis缓存,jedis使用,redis集群搭建

2016-12-26 12:00 746 查看

淘淘商城第七天

讲师:入云龙

1 昨天问题解决

1.1 访问taotao-portal服务406问题

1、查看是否Jackson包是否存在。

2、如果后缀是html是不能响应json数据的。需要修改后缀名。

1.2 Httpclient Post乱码问题

2 使用redis做缓存

2.1 安装redis

n 版本说明

本教程使用redis3.0版本。3.0版本主要增加了redis集群功能。

安装的前提条件：

需要安装gcc：yum install gcc-c++

1、下载redis的源码包。

2、把源码包上传到linux服务器

3、解压源码包

tar -zxvf redis-3.0.0.tar.gz

4、Make

5、Make install

[root@bogon redis-3.0.0]# make installPREFIX=/usr/local/redis

2.2 启动redis

1、前端启动模式

/usr/local/redis/bin/redis-server

默认是前端启动模式，端口是6379

2、后端启动

1）从redis的源码目录中复制redis.conf到redis的安装目录。

2）修改配置文件

3）[root@bogonbin]# ./redis-server redis.conf

2.3 Redis常用命令

127.0.0.1:6379> set a 10

OK

127.0.0.1:6379> get a

"10"

2.4 常用数据类型

String

Hash

List

Set

SortedSet

3 Redis集群的搭建

3.1 Redis集群相关概念

3.1.1 redis-cluster架构图

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

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

Key:a
计算a的hash值，例如值为100，100这个槽在server1上，所以a应该放到server1.

Key:hello
Hash值：10032，此槽在server2上。Hell可以应该存在server2.

3.1.2 redis-cluster投票:容错

(1)领着投票过程是集群中所有master参与,如果半数以上master节点与master节点通信超过(cluster-node-timeout),认为当前master节点挂掉.

(2):什么时候整个集群不可用(cluster_state:fail)?

a:如果集群任意master挂掉,且当前master没有slave.集群进入fail状态,也可以理解成集群的slot映射[0-16383]不完成时进入fail状态.
ps :redis-3.0.0.rc1加入cluster-require-full-coverage参数,默认关闭,打开集群兼容部分失败.

b:如果集群超过半数以上master挂掉，无论是否有slave集群进入fail状态.

ps:当集群不可用时,所有对集群的操作做都不可用，收到((error) CLUSTERDOWN The cluster
is down)错误

3.2 我们的集群结构

集群中有三个节点的集群，每个节点有一主一备。需要6台虚拟机。

搭建一个伪分布式的集群，使用6个redis实例来模拟。

3.3 搭建集群需要的环境

搭建集群需要使用到官方提供的ruby脚本。

需要安装ruby的环境。

安装ruby

yum install ruby

yum install rubygems

redis集群管理工具redis-trib.rb

[root@bogon ~]# cd redis-3.0.0

[root@bogon redis-3.0.0]# cd src

[root@bogon src]# ll *.rb

-rwxrwxr-x. 1 root root 48141 Apr 1 07:01 redis-trib.rb

[root@bogon src]#

脚本需要的ruby包：
http://download.csdn.net/detail/menggucaoyuan/8487967

需要上传到linux服务。

安装ruby的包：

gem install redis-3.0.0.gem

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

Successfully installed redis-3.0.0

1 gem installed

Installing ri documentation for redis-3.0.0...

Installing RDoc documentation for redis-3.0.0...

3.4 集群的搭建

第一步：创建6个redis实例，端口号从7001~7006

第二步：修改redis的配置文件

1、修改端口号

2、打开cluster-enable前面的注释。

第三步：把创建集群的ruby脚本复制到redis-cluster目录下。

第四步：启动6个redis实例

第五步：创建集群。

./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

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

>>> Creating cluster

Connecting to node 192.168.25.153:7001: OK

Connecting to node 192.168.25.153:7002: OK

Connecting to node 192.168.25.153:7003: OK

Connecting to node 192.168.25.153:7004: OK

Connecting to node 192.168.25.153:7005: OK

Connecting to node 192.168.25.153:7006: OK

>>> Performing hash slots allocation on 6nodes...

Using 3 masters:

192.168.25.153:7001

192.168.25.153:7002

192.168.25.153:7003

Adding replica 192.168.25.153:7004 to192.168.25.153:7001

Adding replica 192.168.25.153:7005 to192.168.25.153:7002

Adding replica 192.168.25.153:7006 to192.168.25.153:7003

M: 5a8523db7e12ca600dc82901ced06741b3010076192.168.25.153:7001

  slots:0-5460 (5461 slots) master

M: bf6f0929044db485dea9b565bb51e0c917d20a53192.168.25.153:7002

  slots:5461-10922 (5462 slots) master

M: c5e334dc4a53f655cb98fa3c3bdef8a808a693ca192.168.25.153:7003

  slots:10923-16383 (5461 slots) master

S: 2a61b87b49e5b1c84092918fa2467dd70fec115f192.168.25.153:7004

   replicates5a8523db7e12ca600dc82901ced06741b3010076

S: 14848b8c813766387cfd77229bd2d1ffd6ac8d65192.168.25.153:7005

   replicatesbf6f0929044db485dea9b565bb51e0c917d20a53

S: 3192cbe437fe67bbde9062f59d5a77dabcd0d632 192.168.25.153:7006

   replicatesc5e334dc4a53f655cb98fa3c3bdef8a808a693ca

Can I set the above configuration? (type 'yes' toaccept): yes

>>> Nodes configuration updated

>>> Assign a different config epoch toeach node

>>> Sending CLUSTER MEET messages to jointhe cluster

Waiting for the cluster to join.....

>>> Performing Cluster Check (using node192.168.25.153:7001)

M: 5a8523db7e12ca600dc82901ced06741b3010076192.168.25.153:7001

  slots:0-5460 (5461 slots) master

M: bf6f0929044db485dea9b565bb51e0c917d20a53192.168.25.153:7002

  slots:5461-10922 (5462 slots) master

M: c5e334dc4a53f655cb98fa3c3bdef8a808a693ca192.168.25.153:7003

  slots:10923-16383 (5461 slots) master

M: 2a61b87b49e5b1c84092918fa2467dd70fec115f192.168.25.153:7004

   slots: (0slots) master

   replicates5a8523db7e12ca600dc82901ced06741b3010076

M: 14848b8c813766387cfd77229bd2d1ffd6ac8d65192.168.25.153:7005

   slots: (0slots) master

   replicatesbf6f0929044db485dea9b565bb51e0c917d20a53

M: 3192cbe437fe67bbde9062f59d5a77dabcd0d632192.168.25.153:7006

   slots: (0slots) master

   replicatesc5e334dc4a53f655cb98fa3c3bdef8a808a693ca

[OK] All nodes agree about slots configuration.

>>> Check for open slots...

>>> Check slots coverage...

[OK] All 16384 slots covered.

[root@bogon redis-cluster]#

3.5 测试集群

说明：

./redis-cli -c -h 192.168.101.3-p 7001
，其中-c表示以集群方式连接redis，-h指定ip地址，-p指定端口号

cluster nodes 查询集群结点信息

cluster info 查询集群状态信息

[root@bogon redis-cluster]# redis01/redis-cli -h192.168.25.153 -p 7002
-c

[root@bogon redis-cluster]# redis01/redis-cli -h192.168.25.153 -p 7002

192.168.25.153:7002> set a 100

(error)MOVED 15495 192.168.25.153:7003

192.168.25.153:7002>

[root@bogon redis-cluster]# redis01/redis-cli -h192.168.25.153 -p 7002 -c

192.168.25.153:7002> set a 100

-> Redirected to slot [15495] located at192.168.25.153:7003

OK

192.168.25.153:7003>

注意：

如果执行时报如下错误：

[ERR]Node XXXXXX is not empty. Either the node already knows other nodes (check withCLUSTER NODES) or contains some key in database 0

解决方法是删除生成的配置文件nodes.conf，如果不行则说明现在创建的结点包括了旧集群的结点信息，需要删除redis的持久化文件后再重启redis，比如：appendonly.aof、dump.rdb

3.6 添加主节点

集群创建成功后可以向集群中添加节点，下面是添加一个master主节点

添加7007结点，参考集群结点规划章节添加一个“7007”目录作为新节点。

执行下边命令：

./redis-trib.rb add-node 192.168.101.3:7007 192.168.101.3:7001

查看集群结点发现7007已添加到集群中：

3.6.1 hash槽重新分配

添加完主节点需要对主节点进行hash槽分配这样该主节才可以存储数据。

redis集群有16384个槽，集群中的每个结点分配自已槽，通过查看集群结点可以看到槽占用情况。

给刚添加的7007结点分配槽：

第一步：连接上集群

./redis-trib.rb reshard 192.168.101.3:7001（连接集群中任意一个可用结点都行）

第二步：输入要分配的槽数量

输入 500表示要分配500个槽

第三步：输入接收槽的结点id

这里准备给7007分配槽，通过cluster nodes查看7007结点id为15b809eadae88955e36bcdbb8144f61bbbaf38fb

输入：15b809eadae88955e36bcdbb8144f61bbbaf38fb

第四步：输入源结点id

这里输入all

第五步：输入yes开始移动槽到目标结点id

3.7 添加从节点

集群创建成功后可以向集群中添加节点，下面是添加一个slave从节点。

添加7008从结点，将7008作为7007的从结点。

./redis-trib.rbadd-node --slave --master-id 主节点id
添加节点的ip和端口
集群中已存在节点ip和端口

执行如下命令：

./redis-trib.rb add-node --slave --master-idcad9f7413ec6842c971dbcc2c48b4ca959eb5db4 192.168.101.3:7008 192.168.101.3:7001

cad9f7413ec6842c971dbcc2c48b4ca959eb5db4 是7007结点的id，可通过cluster nodes查看。

注意：如果原来该结点在集群中的配置信息已经生成cluster-config-file指定的配置文件中（如果cluster-config-file没有指定则默认为nodes.conf），这时可能会报错：

[ERR]Node XXXXXX is not empty. Either the node already knows other nodes (check withCLUSTER NODES) or contains some key in database 0

解决方法是删除生成的配置文件nodes.conf，删除后再执行./redis-trib.rb add-node指令

查看集群中的结点，刚添加的7008为7007的从节点：

3.8 删除结点：

./redis-trib.rb del-node 127.0.0.1:70054b45eb75c8b428fbd77ab979b85080146a9bc017

删除已经占有hash槽的结点会失败，报错如下：

[ERR] Node 127.0.0.1:7005 is not empty! Resharddata away and try again.

需要将该结点占用的hash槽分配出去（参考hash槽重新分配章节）。

3.9 关闭redis

redis01/redis-cli -p 7001 shutdown

3.10 Redis客户端

3.10.1 Redis-cli

自带客户端。使用最多的。

3.10.2 图形化界面客户端

只支持单机版，不支持集群。

3.10.3 Jedis客户端

3.10.3.1 单机版

需要把jedis的jar包添加到工程中，如果是maven需要添加jar包的坐标。

public
class JedisTest {

     @Test
     public
void testJedisSingle() {
          //创建一个jedis的对象。
          Jedis jedis =
new Jedis("192.168.25.153", 6379);
          //调用jedis对象的方法，方法名称和redis的命令一致。
          jedis.set("key1",
"jedis test");
          String string =
jedis.get("key1");
          System.out.println(string);
          //关闭jedis。
          jedis.close();
     }

     /**
     * 使用连接池
     */
     @Test
     public
void testJedisPool() {
          //创建jedis连接池
          JedisPool pool =
new JedisPool("192.168.25.153", 6379);
          //从连接池中获得Jedis对象
          Jedis jedis =
pool.getResource();
          String string =
jedis.get("key1");
          System.out.println(string);
          //关闭jedis对象
          jedis.close();
          pool.close();
     }
}

3.10.3.2 集群版

@Test
     public
void testJedisCluster() {
          HashSet<HostAndPort> nodes =
new HashSet<>();
          nodes.add(new HostAndPort("192.168.25.153", 7001));
          nodes.add(new HostAndPort("192.168.25.153", 7002));
          nodes.add(new HostAndPort("192.168.25.153", 7003));
          nodes.add(new HostAndPort("192.168.25.153", 7004));
          nodes.add(new HostAndPort("192.168.25.153", 7005));
          nodes.add(new HostAndPort("192.168.25.153", 7006));

          JedisCluster
cluster = new
JedisCluster(nodes);

          cluster.set("key1",
"1000");
          String string =
cluster.get("key1");
          System.out.println(string);

          cluster.close();
     }

4 业务逻辑中添加缓存

需要在taotao-rest工程中添加缓存。

4.1 jedis整合spring

4.1.1 单机版整合

4.1.1.1 配置

<bean
id="jedisPoolConfig"
class="redis.clients.jedis.JedisPoolConfig">
          
          <property
name="maxTotal"
value="30"
/>
          
          <property
name="maxIdle"
value="10"
/>
          
          <property
name="numTestsPerEvictionRun"
value="1024"
/>
          
          <property
name="timeBetweenEvictionRunsMillis"
value="30000"
/>
          
          <property
name="minEvictableIdleTimeMillis"
value="1800000"
/>
          
          <property
name="softMinEvictableIdleTimeMillis"
value="10000"
/>
          
          <property
name="maxWaitMillis"
value="1500"
/>
          
          <property
name="testOnBorrow"
value="true"
/>
          
          <property
name="testWhileIdle"
value="true"
/>
          
          <property
name="blockWhenExhausted"
value="false"
/>
     </bean>

     
     <bean
id="redisClient"
class="redis.clients.jedis.JedisPool">
          <constructor-arg
name="host"
value="192.168.25.153"></constructor-arg>
          <constructor-arg
name="port"
value="6379"></constructor-arg>
          <constructor-arg
name="poolConfig"
ref="jedisPoolConfig"></constructor-arg>
     </bean>

4.1.1.2 测试

/**
     * 单机版测试
     * <p>Title: testSpringJedisSingle</p>
     * <p>Description:
</p>
     */
     @Test
     public
void testSpringJedisSingle() {
          ApplicationContext applicationContext =
new ClassPathXmlApplicationContext("classpath:spring/applicationContext-*.xml");
          JedisPool pool = (JedisPool)
applicationContext.getBean("redisClient");
          Jedis jedis =
pool.getResource();
          String string =
jedis.get("key1");
          System.out.println(string);
          jedis.close();
          pool.close();
     }

4.1.2 集群版整合

4.1.2.1 配置

4.1.2.2 测试

@Test
     public
void testSpringJedisCluster() {
          ApplicationContext applicationContext =
new ClassPathXmlApplicationContext("classpath:spring/applicationContext-*.xml");
          JedisCluster jedisCluster = (JedisCluster)
applicationContext.getBean("redisClient");
          String string =
jedisCluster.get("key1");
          System.out.println(string);
          jedisCluster.close();
     }

4.2 添加jedis dao

4.2.1 单机版

public
class JedisClientSingle implements JedisClient{

     @Autowired
     private JedisPool
jedisPool;

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

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

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

     @Override
     public
long hset(String hkey, String
key, String value) {
          Jedis jedis =
jedisPool.getResource();
          Long result =
jedis.hset(hkey,
key, value);
          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 expire(String key,
int second) {
          Jedis jedis =
jedisPool.getResource();
          Long result =
jedis.expire(key,
second);
          jedis.close();
          return
result;
     }

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

}

Spring配置文件

4.2.2 集群版

public
class JedisClientCluster implements JedisClient {

     @Autowired
     private JedisCluster
jedisCluster;

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

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

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

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

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

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

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

}

4.3 把缓存添加到业务逻辑

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

@Override
     public List<TbContent> getContentList(long
contentCid) {

//从缓存中取内容
          try {
               String
result = jedisClient.hget(INDEX_CONTENT_REDIS_KEY,
contentCid + "");
               if (!StringUtils.isBlank(result)) {

//把字符串转换成list
                    List<TbContent>
resultList = JsonUtils.jsonToList(result, TbContent.class);
                    return
resultList;
               }
          } catch (Exception
e) {

e.printStackTrace();
          }

          //根据内容分类id查询内容列表
          TbContentExample example =
new TbContentExample();
          Criteria criteria =
example.createCriteria();
          criteria.andCategoryIdEqualTo(contentCid);
          //执行查询
          List<TbContent> list =
contentMapper.selectByExample(example);


//向缓存中添加内容
          try {

//把list转换成字符串
               String
cacheString = JsonUtils.objectToJson(list);

jedisClient.hset(INDEX_CONTENT_REDIS_KEY,
contentCid + "",
cacheString);
          } catch (Exception
e) {

e.printStackTrace();
          }

          return
list;
     }

5 缓存同步

当后台管理系统，修改内容之后需要通知redis把修改的内容对应的分类id的key删除。

5.1 添加缓存后的系统架构

5.2 解决方案

在taotao-rest工程中发布一个服务。当后台管理系统修改内容后，调用此服务，同步缓存。

5.3 Dao层

使用JedisClient接口对应的实现类。

5.4 Service层

接收内容分类id，调用dao删除redis中对应的hash中key为分类id的项。

参数：内容分类id

返回值：TaotaoResult

@Service
public
class RedisServiceImpl implements RedisService {

     @Autowired
     private JedisClient
jedisClient;

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

     @Override
     public TaotaoResult syncContent(long
contentCid) {
          try {
               jedisClient.hdel(INDEX_CONTENT_REDIS_KEY,
contentCid + "");
          } catch (Exception
e) {
               e.printStackTrace();
               return TaotaoResult.build(500, ExceptionUtil.getStackTrace(e));
          }
          return TaotaoResult.ok();
     }

}

5.5 Controller层

接收内容分类id，调用Service返回taotaoResult。

@Controller
@RequestMapping("/cache/sync")
public
class RedisController {

     @Autowired
     private RedisService
redisService;

     @RequestMapping("/content/{contentCid}")
     public
TaotaoResult contentCacheSync(@PathVariable Long
contentCid) {
          TaotaoResult result =
redisService.syncContent(contentCid);
          returnresult;
     }
}

5.6 同步缓存服务的调用

需要在后台管理系统中添加一个服务调用的逻辑。当修改内容信息后，需要调用此服务同步缓存。

内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理

标签：

相关文章推荐

新的分享

章节导航