B2Ctt商城07 redis

1.1  安装redis

n  版本说明

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

安装的前提条件：

需要安装gcc：yuminstall gcc-c++

 

1、下载redis的源码包。

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

 进入sftp后 可以直接拖拽文件上传

 * 在SecureCRT中采用SSH方式登录linux后，在标签页上面点击右键：连接SFTP标签页 

3、解压源码包

tar -zxvf redis-3.0.0.tar.gz

4、Make

5、先创建文件夹

 make install PREFIX=/usr/local/redis

1.1  启动redis

1、前端启动模式

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

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

2、后端启动

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

    cp redis.conf /usr/local/redis

2）修改配置文件

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

redis启动带上配置文件

（生产上 redis 是不让远程访问的 因为不安全）

1.1  Redis常用命令

进入redis ./redis-cli

127.0.0.1:6379> set a 10

OK

127.0.0.1:6379> get a

"10"

2  Redis集群的搭建

2.1  Redis集群相关概念

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

2.1.1   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)错误

2.2 我们的集群结构

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

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

2.3  搭建集群需要的环境

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

需要安装ruby的环境。

 

安装ruby

yum install ruby

yum install rubygems

 

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

[root@bogon ~]#  

[root@bogon redis-3.0.0]# cd src

[root@bogon src]# ll *.rb

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

[root@bogon src]#

 

脚本需要的ruby包：
redis-3.0.0.gem

需要上传到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 forredis-3.0.0...

Installing RDoc documentation forredis-3.0.0...

2.4  集群的搭建

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

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

1、修改端口号

创建集群：

./redis-trib.rb create --replicas 1192.168.25.153:7001 192.168.25.153:7002 192.168.25.153:7003 192.168.25.153:7004192.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

连接

创建主副节点，分配卡槽

>>> Performing hash slotsallocation on 6 nodes...

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

3.1  测试集群

[root@bogon redis-cluster]#redis01/redis-cli -h 192.168.25.153 -p 7002-c

-h -p  指定ip 和端口 -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> 

关闭redis

redis01/redis-cli -p 7001 shutdown

启动redis集群 创建一个命令 ，redis01是同一级目录

chmod +x shutdown.sh 赋权

ps aux|grep redis 查看redis运行情况

redis 图形化客户端

1.1.1   Jedis客户端

1.1.1.1        单机版

引入jar包

<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
</dependency>

@Test
	public void testJedisSingle(){
		// 创建Jedis客户端
		Jedis jedis = new Jedis("192.168.238.129",6379);
		jedis.set("k1", "v1");
		String value = jedis.get("k1");
		System.out.println(value);
		// 关闭jedis
		jedis.close();
	}
	
	// 测试jedis连接池
	@Test
	public void testJedisPool(){
		// 创建连接池
		JedisPool pool = new JedisPool("192.168.238.129",6379);
		// 获取资源 得到jedis
		Jedis jedis = pool.getResource();
		String value = jedis.get("k1");
		System.out.println(value);
		// 关闭jedis
		jedis.close();
		pool.close();
	}

注意：从池里取出对象一定要关闭，否则取多了池就会爆炸

/**
	 * 测试集群版
	 */
	@Test
	public void testJedisCluster(){
		HashSet<HostAndPort> nodes = new HashSet<>();
		nodes.add(new HostAndPort("192.168.238.129", 7001));
		nodes.add(new HostAndPort("192.168.238.129", 7002));
		nodes.add(new HostAndPort("192.168.238.129", 7003));
		nodes.add(new HostAndPort("192.168.238.129", 7004));
		nodes.add(new HostAndPort("192.168.238.129", 7005));
		nodes.add(new HostAndPort("192.168.238.129", 7006));
		
		JedisCluster cluster = new JedisCluster(nodes);
		cluster.set("key1", "111");
		System.out.println(cluster.get("key1"));
		cluster.close();
	}

cluster自带连接池

连接redis集群中的某一个主机

redis01/redis-cli -p 7001 -c

1   业务逻辑中添加缓存

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

1.1  jedis整合spring

1.1.1   单机版整合

配置

<!-- redis客户端  单机版-->
	<bean id="redisClient" class="redis.clients.jedis.JedisPool">
		<!-- class 就是JedisPool类的全限定名  -->
		<!-- constructor-arg 是构造方法参数 -->
		<constructor-arg name="host" value="192.168.238.129"></constructor-arg>
		<constructor-arg name="port" value="6379"></constructor-arg>
	</bean>	
	
	<!-- redis客户端 集群版-->
	<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.238.129"></constructor-arg>
					<constructor-arg name="port" value="7001"></constructor-arg>
				</bean>
				<bean class="redis.clients.jedis.HostAndPort">
					<constructor-arg name="host" value="192.168.238.129"></constructor-arg>
					<constructor-arg name="port" value="7002"></constructor-arg>
				</bean>
				<bean class="redis.clients.jedis.HostAndPort">
					<constructor-arg name="host" value="192.168.238.129"></constructor-arg>
					<constructor-arg name="port" value="7003"></constructor-arg>
				</bean>
			</set>
		</constructor-arg>
	</bean>

JedisCluster cluster = new JedisCluster(nodes);  配置cluster 构造方法是一个set<HostAndPort>
所以<set>  在配置多个节点
HashSet<HostAndPort> nodes = new HashSet<>();
new HostAndPort("192.168.238.129", 7001)







测试spring 注入jedis

	@Test
	public void testJedisClusterForSpring(){
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext
				("classpath:spring/applicationContext-*.xml");
		JedisCluster cluster = (JedisCluster) applicationContext.getBean("redisClient");
		cluster.set("key1", "111");
		System.out.println(cluster.get("key1"));
		cluster.close();
	}

// 测试jedis连接池
	@Test
	public void testJedisPoolForSpring(){
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext
				("classpath:spring/applicationContext-*.xml");
		JedisPool jedisPool = (JedisPool) applicationContext.getBean("redisClient");
		Jedis jedis = jedisPool.getResource();
		System.out.println(jedis.get("k1"));
		jedisPool.close();
	}



1.2 添加jedis dao

 
 

  
  定义一个接口，有两个实现类，分别为redis池 以及集群方式
 
 

 
 

  
  


 
 

 
 

  
  public interface RedisClientMapper {
  
  


  
  


  
  


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


  
  
  
  

}
  
  


 
 

 
 

  
  


 
 

 
 

  
  实现类
 
 

 
 

  
  public class JedisClientSingle implements RedisClientMapper {
  
  


  
  


  
  


  
  @Autowired
  
  


  
  private JedisPool JedisPool;
  
  


  
  
  
  


  
  @Override
  
  


  
  public String get(String key) {
  
  


  
  Jedis jedis = JedisPool.getResource();
  
  


  
  String result = jedis.get(key);
  
  


  
  jedis.close();
  
  


  
  return result;
  
  


  
  }
  
  


 
 

 
 

  
  }
 
 

 
 

  
  


 
 

 
 


  
  
1.3  把缓存添加到业务逻辑

  
  

@Override
  
  


  
  public List<TbContent> getContentList(long categoryId) {
  
  


  
  // 从缓存里面取
  
  


  
  try {
  
  


  
  String result = redisClientMapper.hget(INDEX_CONTENT_REDIS_KEY, categoryId + "");
  
  


  
  // 如果取到直接返回
  
  


  
  if ( !StringUtils.isBlank(result) ) {
  
  


  
  System.out.println("读取缓存 " + result);
  
  


  
  return JsonUtils.jsonToList(result, TbContent.class);
  
  


  
  }
  
  


  
  } catch (Exception e) { 
  
  


  
  e.printStackTrace();
  
  


  
  }
  
  


  
  TbContentExample example = new TbContentExample();
  
  


  
  Criteria criteria = example.createCriteria();
  
  


  
  criteria.andCategoryIdEqualTo(categoryId);
  
  


  
  List<TbContent> list = contentMapper.selectByExample(example);
  
  


  
  
  
  


  
  // 放入缓存当中
  
  


  
  try {
  
  


  
  // 将list转换成字符串
  
  


  
  String cacheString = JsonUtils.objectToJson(list);
  
  


  
  redisClientMapper.hset(INDEX_CONTENT_REDIS_KEY, categoryId + "", cacheString);
  
  


  
  System.out.println("存入缓存" + cacheString);
  
  


  
  } catch (Exception e) {
  
  


  
  e.printStackTrace();
  
  


  
  }
  
  


  
  return list;
  
  


  
  }
 
 

 
 

  
  


 
 

 
 

  
  使用hset 是因为缓存的内容可能会有很多，便于区别。使用hset hashset 速度差不多。
 
 

 
 

  
  


 
 

 
 


  
  
2   缓存同步

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

  
  
2.1  添加缓存后的系统架构

  
  

   
   
   
   


  
  

  
  

   
   


  
  

  
  


   
   
2.2  解决方案

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

   
   
 

   
   
2.3 Dao层

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

   
   
@Override

public long hdet(String hkey, String key) {

Jedis jedis = JedisPool.getResource();

long result = jedis.hdel(hkey, key);

jedis.close();

return result;

}



   
   


  
  

  
  


   
   
2.4  Service层

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

   
   
 

   
   
参数：内容分类id

   
   
返回值：TaotaoResult

  
  

  
  


  
  


   
   
@Override

   
   
      public TaotaoResultsyncContent(longcontentCid) {

   
   
            try {

   
   
                  jedisClient.hdel(INDEX_CONTENT_REDIS_KEY,contentCid +
"");

   
   
            } catch (Exceptione) {

   
   
                  e.printStackTrace();

   
   
                  return TaotaoResult.build(500, ExceptionUtil.getStackTrace(e));

   
   
            }

   
   
            return TaotaoResult.ok();

   
   
      }

   
   


  
  

  
  
2.5  Controller层

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

  
  
@Controller

  
  
@RequestMapping("/cache/sync")

  
  
public 
class RedisController {

  
  
 

  
  
      @Autowired

  
  
      private RedisServiceredisService;

  
  
      

  
  
      @RequestMapping("/content/{contentCid}")

  
  
      public 
TaotaoResultcontentCacheSync(@PathVariable LongcontentCid) {

  
  
            TaotaoResult result =redisService.syncContent(contentCid);

  
  
            returnresult;

  
  
      }
}
  
  


 
 

 
 

  
  


 
 

 
 

  
  
  
  


 
 

 
 

  
  
  
  


 
 

 
 

  
  


 
 

 
 

  
  在添加内容 和 修改内容的地方 调用服务
 
 

 
 


  
  
@Override

  
  
   public TaotaoResultaddContent(TbContentcontent) {

  
  
      content.setCreated(new Date());

  
  
      content.setUpdated(new Date());

  
  
      contentMapper.insert(content);

  
  
      

  
  
      // 添加同步缓存逻辑

  
  
      HttpClientUtil.doGet(REST_BASE_URL +REST_CONTENT_SYNC_URL+
content.getCategoryId());

  
  
      return TaotaoResult.ok();

  
  
   }