WEB项目系统添加redis缓存逻辑和功能


阅读数: 次   

概述

由于我们项目的首页是最频繁访问的，每次请求都调用mysql查询浪费性能和效率，我们可以用redis做缓存工具，这样将数据加载到内存中，提高了性能和效率。同时，为了实现系统高可用，redis需要做主备，使用redis做分片集群，搭建redis集群。最后我们还需要向业务逻辑中添加缓存并让缓存同步。

一、Redis

1.redis介绍及安装

Windows安装

直接下载redis的win包，解压后可直接打开

image-20200526194859946

Linux安装

redis介绍及redis在Linux上的安装参照上一篇博客《Redis在Linux上的安装和集群搭建(CentOS为例)》

2.redis持久化

Redis的高性能是由千其将所有数据都存储在了内存中， 为了使Redis在重启之后仍能保证数据不丢失， 需要将数据从内存中同步到硬盘中， 这一过程就是待久化。

Redis支待两种方式的待久化， 种是RDB方式， 种是AOF方式。 可以单独使用其中 种或将二者结合使用。

1、 RDB持久化（默认支持， 无需配置）

该机制是指在指定的时间间隔内将内存中的数据集快照写入磁盘。

2、 AOF待久化

该机制将以日志的形式记录服务器所处理的每一个写操作， 在Redis服务器启动之初会读取该文件来重新构建数据库， 以保证启动后数据库中的数据是完整的。

3、 无待久化

我们可以通过配置的方式禁用Redis服务器的待久化功能， 这样我们就可以将Redis视为一个功能加强版的memcached了。

4、 redis可以同时使用RDB和AOF

3.redis集群

3.1redis-cluster架构图

img

架构细节:

(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 会根据节点数量大致均等的将哈希槽映射到不同的节点

3.2redis-cluster投票:容错

img

(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状态.

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

3.3redis集群的搭建

参照上一篇博客《Redis在Linux上的安装和集群搭建(CentOS为例)》，这里做了详细操作介绍。

4.redis客户端

4.1Redis-cli

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

4.2图形化界面客户端

RedisDesktopManager

image-20200526195942215

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

4.3Jedis客户端

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

img

img

4.3.1单机版

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
public class JedisTest {

	@Test
	public void testJedisSingle() {
		//创建一个jedis的对象。
		Jedis jedis = new Jedis("192.168.10.130", 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.10.130", 6379);
		//从连接池中获得Jedis对象
		Jedis jedis = pool.getResource();
		String string = jedis.get("key1");
		System.out.println(string);
		//关闭jedis对象
		jedis.close();
		pool.close();
	}
}

4.3.2集群版

需要事先打开7001~7006端口，或者直接关闭防火墙sevice iptables stop

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
//集群版
@Test
public void testJedisCluster() {
    HashSet<HostAndPort> nodes = new HashSet<>();
    nodes.add(new HostAndPort("192.168.10.130", 7001));
    nodes.add(new HostAndPort("192.168.10.130", 7002));
    nodes.add(new HostAndPort("192.168.10.130", 7003));
    nodes.add(new HostAndPort("192.168.10.130", 7004));
    nodes.add(new HostAndPort("192.168.10.130", 7005));
    nodes.add(new HostAndPort("192.168.10.130", 7006));
    JedisCluster cluster = new JedisCluster(nodes);

    cluster.set("a", "1000");
    System.out.println(cluster.get("a"));
    cluster.close();
}

5.keys的通用操作

  • keys pattern:获取所有与pattern匹配的key,返回所有与该key匹配的keys。＊表示任意 一多个字符，？表示任意一个字符
  • del keyl key2…：删除指定的key
  • exists key:判断该key是否存在，1代表存在，0代表不存在
  • rename key newkey:为当前的key重命名
  • expire key :设置过期时间，单位：秒
  • ttl key:获取该key所剩的超时时间，如果没有设置超时，返回-1。如果返回－2表示超时不存在
  • type key: 获取指定key 的类型。该命令将以字符串的格式返回。 list set hash和zset,如果key不存在返回 none。

二、系统添加缓存逻辑

添加缓存逻辑的原则：缓存逻辑不能影响正常的业务逻辑执行。

1.添加缓存后系统架构

img

2.jedis整合spring

2.1单机版整合

配置：

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
<!-- 连接池配置 -->
<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" />
    <!-- 获取连接时的最大等待毫秒数,小于零:阻塞不确定的时间,默认-1 -->
    <property name="maxWaitMillis" value="1500" />
    <!-- 在获取连接的时候检查有效性, 默认false -->
    <property name="testOnBorrow" value="true" />
    <!-- 在空闲时检查有效性, 默认false -->
    <property name="testWhileIdle" value="true" />
    <!-- 连接耗尽时是否阻塞, false报异常,ture阻塞直到超时, 默认true -->
    <property name="blockWhenExhausted" value="false" />
</bean>	
<!-- jedis客户端单机版 -->
<bean id="redisClient" class="redis.clients.jedis.JedisPool">
    <constructor-arg name="host" value="192.168.10.130"></constructor-arg>
    <constructor-arg name="port" value="6379"></constructor-arg>
    <constructor-arg name="poolConfig" ref="jedisPoolConfig"></constructor-arg>
</bean> 
<bean id="jedisClientSingle" class="com.taotao.rest.dao.impl.JedisClientSingle"></bean>

测试：

1
2
3
4
5
6
7
8
9
10
11
//单机版测试
@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();
}

2.2集群版整合

配置:

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
<!-- 集群版整合 -->
<bean id="redisClient" class="redis.clients.jedis.JedisCluster">
    <constructor-arg name="nodes">
        <set>
            <bean class="redis.clients.jedis.HostAndPort">
                <constructor-arg name="host" value="192.168.10.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.10.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.10.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.10.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.10.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.10.130"></constructor-arg>
                <constructor-arg name="port" value="7006"></constructor-arg>
            </bean>
        </set>
    </constructor-arg>
    <constructor-arg name="poolConfig" ref="jedisPoolConfig"></constructor-arg>
</bean> 
<bean id="jedisClientCluster" class="com.taotao.rest.dao.impl.JedisClientCluster"></bean>

测试：

1
2
3
4
5
6
7
8
//集群版测试
@Test
public void testSpringJedisCluster() {
    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:spring/applicationContext-*.xml");
    JedisCluster cluster = (JedisCluster) applicationContext.getBean("redisClient");
    System.out.println(cluster.get("a"));
    cluster.close();
}

3.添加jedis dao

使用一个接口定义操作的方法，这样无论是单机版还是集群版都用的同一个接口，只需要在配置文件改即可修改调用单机还是集群。

3.1接口

1
2
3
4
5
6
7
8
9
10
11
public interface JedisClient {
	String get(String key);
	String set(String key,String value);
	String hget(String hkey,String key);
	long hset(String hkey,String key,String value);
	long incr(String key);
	long expire(String key,int second);//设置缓存时间
	long ttl(String key);//查看剩余缓存时间，-1代表永久，-2代表已过期
	long del(String key);
	long hdel(String hkey,String key);
}

3.2单机版

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
/**
 * 单机版
 * 每一次使用完都要关闭jedis让他返回连接池以便下次调用
 * @author JY
 *
 */
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;
	}

}

3.3集群版

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

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

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

}

4.把缓存添加到业务逻辑

4.1配置文件

1
2
3
4
#首页内容信息在redis中保存的key
INDEX_CONTENT_REDIS_KEY=INDEX_CONTENT_REDIS_KEY
#商品类目信息在redis中保存的key
INDEX_CAT_REDIS_KEY=INDEX_CAT_REDIS_KEY

4.2大广告添加缓存

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
@Service
public class ContentServiceImpl implements ContentService {

	@Autowired
	private TbContentMapper contentMapper;
	@Autowired
	private JedisClientSingle jedisClientSingle;
	@Value("${INDEX_CONTENT_REDIS_KEY}")
	private String INDEX_CONTENT_REDIS_KEY;
	
	@Override
	public List<TbContent> getContentList(long contentCid) {
		//从缓存中取内容
		try {
			String result = jedisClientSingle.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);
			jedisClientSingle.hset(INDEX_CONTENT_REDIS_KEY, contentCid+"", cacheString);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return list;
	}

}

4.3商品类目展示添加缓存

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
//查询分类列表
private List<?> getCatList(long parentId){
    //从缓存中取内容
    try {
        String result = jedisClientSingle.hget(INDEX_CAT_REDIS_KEY, parentId+"");
        if(!StringUtils.isBlank(result)) {
            List resultList = JsonUtils.jsonToList(result, null);
            return resultList;
        }
    } catch (Exception e) {
        e.printStackTrace();
    }

    TbItemCatExample example = new TbItemCatExample();
    Criteria criteria = example.createCriteria();
    criteria.andParentIdEqualTo(parentId);
    List<TbItemCat> list = itemCatMapper.selectByExample(example);
    List resultList = new ArrayList<>();
    int count=0;
    for (TbItemCat tbItemCat : list) {
        //判断是否为父节点
        if(tbItemCat.getIsParent()) {
            CatNode node = new CatNode();
            if(parentId==0) {
                node.setName("<a href='/products/"+tbItemCat.getId()+".html'>"+tbItemCat.getName()+"</a>");
                count++;
                if(count>=14)break;
            }else {
                node.setName(tbItemCat.getName());
            }
            node.setUrl("/products/"+tbItemCat.getId()+".html");
            node.setItem(getCatList(tbItemCat.getId()));
            resultList.add(node);
        }else {
            //				是叶子节点
            resultList.add("/products/"+tbItemCat.getId()+".html|" + tbItemCat.getName());
        }
    }

    //向缓存中添加内容
    try {
        String cacheString = JsonUtils.objectToJson(resultList);
        jedisClientSingle.hset(INDEX_CAT_REDIS_KEY, parentId+"", cacheString);
    } catch (Exception e) {
        e.printStackTrace();
    }

    return resultList;
}

三、缓存同步

1.需求分析

我们再来回顾一下首页流程

img

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

可以在taotao-rest工程中发布一个服务，就是专门同步数据用的，其实只需要把缓存中的数据清空即可。当管理后台更新了内容信息后，需要调用此服务。

2.Dao层

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

在配置文件添加如下内容

1
2
3
#服务层基础url
REST_BASE_URL=http://localhost:8081/rest
REST_CONTENT_SYNC_URL=/cache/sync/content/

3.Service层

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
@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();
	}

}

4.Controller层

1
2
3
4
5
6
7
8
9
10
11
12
13
@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);
		return result;
	}
}

5.同步缓存服务的调用

在后台系统service层添加缓存同步逻辑

image-20200526202758566

结语

吾日三省吾身：
你在 赣神魔
你往 哪里跑
你是 神魔恋

index

看大司马斗地主真想把他眼镜干碎

赏

谢谢你请我吃糖果

支付宝
微信

扫一扫，分享到微信

微信分享二维码

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

很惭愧<br><br>只做了一点微小的工作<br>谢谢大家