redis及其集群的安装、Jedis的使用方法

最新推荐文章于 2022-05-09 15:22:42 发布

陌上花开zz

最新推荐文章于 2022-05-09 15:22:42 发布

阅读量156

点赞数

文章标签： redis Redis-cluster

本文链接：https://blog.csdn.net/weixin_43228381/article/details/101028603

版权

1 redis的介绍

为了解决高并发、高可扩展（集群）、高可用（不能宕机）、大数据存储问题而产生的数据库解决方案，就是NoSql数据库。
NoSql数据库：全称 not only sql ,非关系型数据库。可以作为关系型数据库的一个很好的补充。不能替代。
Redis是用C语言开发的一个开源的高性能键值对（key-value）数据库（nosql）。它通过提供多种键值数据类型来适应不同场景下的存储需求，目前为止Redis支持的键值数据类型有5种。如下：
字符串类型 (String)
散列类型（hash）
列表类型(List)
集合类型(set)
有序集合类型(SortedSet)
redis的功能强大，有丰富的应用场景，如下：
缓存。
分布式集群架构中的session分离。
任务队列。（秒杀、抢购、12306等等）
应用排行榜。（SortedSet）
网站访问统计。
数据过期处理。(expire)
详情可以参考官网：https://redis.io/topics/benchmarks

2 Redis的安装

安装redis需要c语言的编译环境,如果没有gcc需要在线安装。如下命令：
[root@localhost ~]# yum -y install gcc-c++
如果有GCC环境，只需输入命令：
[root@localhost ~]# gcc
出现：gcc: no input files 表示安装成功。

安装步骤：
第一步：将redis的源码包上传到linux系统。
第二步：解压缩redis的源码包。
第三步：进行编译。 cd到解压后的目录输入命令：make
第四步：进行安装。输入命令：make install PREFIX=/usr/local/redis
第五步：检查目录是否存在。
在/usr/local/redis 下有bin 说明安装成功。

3 连接Redis

3.1 redis服务端启动

前端启动:
[root@localhost bin]# ./redis-server
后台启动：
第一步：把/root/redis-3.0.0/redis.conf复制到/usr/local/redis/bin目录下
[root@localhost redis-3.0.0]# cp redis.conf /usr/local/redis/bin/
第二步：使用vim命令修改redis.conf配置文件将daemonize no修改为daemonize yes
在这里插入图片描述
第三步：输入启动命令
[root@localhost bin]# ./redis-server redis.conf
第四步：检查redis进程：
[root@localhost bin]# ps -ef|grep redis
前端启动，不能更换终端，影响下一步操作。而后台启动，只在进程中悄悄启动。
推荐使用后台启动。

3.2 客户端Redis-cli连接redis

使用Redis-cli建立连接：
[root@localhost bin]# ./redis-cli
默认连接localhost运行在6379端口的redis服务。

[root@localhost bin]# ./redis-cli -h 192.168.25.153 -p 6379
-h：连接的服务器的地址
-p：服务的端口号

–> 使用redis的桌面程序建立连接
安装：
在这里插入图片描述
退出连接：
第一种：
[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]#

3.3 关闭Redis服务

第一种：通过连接上客户端进行关闭，使用shutdown 命令。
在这里插入图片描述
第二种：使用 kill 命令。
找到对应的redis的进程id 然后使用命令：(pid为进程id)
kill -9 pid

4 Redis五种数据类型

4.1. String：key-value

redis命令不区分大小写，但是key区分的
redis中的数据都是字符串。
redis是单线程，（不适合存储比较大的数据）

使用incr 命令，如果key 不存在，会自动创建key 并自动+1.
redis中所有的数据都是字符串。

set key value 设置值
get key 获取值
incr key 加一
decr key 减一

4.2. Hash: key-field-value

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

hset  key field value
hget  key field 
hincrby key field num

4.3. List

List是有顺序可重复(数据结构中的：双链表，队列)
可作为链表，从左添加元素也可以从右添加元素。

lpush list a b c d    (从左添加元素)
rpush list 1 2 3 4    (从右边添加元素)
lrange list 0 -1 (从0 到 -1 元素查看：也就表示查看所有)
lpop list （从左边取，删除）
rpop list  (从右边取，删除)

4.4. Set

Set无顺序，不能重复

sadd set1 a b c d d (向set1中添加元素) 元素不重复
smembers set1 （查询元素）
srem set1 a （删除元素）

4.5. SortedSet（zset）

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

zadd zset1 9 a 8 c 10 d 1 e （添加元素 zadd key score member ）
(ZRANGE key start stop [WITHSCORES])(查看所有元素：zrange key 0 -1 withscores)
如果要查看分数，加上withscores.

zrange zset1 0 -1 (从小到大)
zrevrange zset1 0 -1 (从大到小)
zincrby zset2 score member (对元素member 增加 score)

127.0.0.1:6379> zadd zset1 8 a 4 b 5 c 1 d
(integer) 4
127.0.0.1:6379> zrange zset1 0 -1 
1) "d"
2) "b"
3) "c"
4) "a"
127.0.0.1:6379> zadd zset1 9 a
(integer) 0
127.0.0.1:6379> zrange zset1 0 -1 
1) "d"
2) "b"
3) "c"
4) "a"
127.0.0.1:6379> zrange zset1 0 -1 withscores
1) "d"
2) "1"
3) "b"
4) "4"
5) "c"
6) "5"
7) "a"
8) "9"
127.0.0.1:6379> zrevrange zset1 0 -1
1) "a"
2) "c"
3) "b"
4) "d"
127.0.0.1:6379> zincrby zset1 1 a
"10"
127.0.0.1:6379> zrevrange zset1 0 -1 withscores
1) "a"
2) "10"
3) "c"
4) "5"
5) "b"
6) "4"
7) "d"
8) "1"

5 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集群的搭建

至少3个节点，为了集群的高可用，为每一个节点增加一个备份机。（6台服务器）。
搭建伪分布式集群方案：在一台机器里面运行6个redis实例。端口需要不同（7001-7006）

6.1 集群搭建环境

1、使用ruby脚本搭建集群。需要ruby的运行环境。
安装ruby：
yum install ruby
yum install rubygems
2、上传redis-3.0.0.gem到 linux中
3、安装ruby运行时所使用的包

[root@localhost ~]# 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...
[root@localhost ~]# 
[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

6.2 搭建步骤

需要6台redis服务器。搭建伪分布式。
需要6个redis实例。
需要运行在不同的端口7001-7006
使用之前搭建好的redis实例。

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

第一步：

创建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

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目录，修改每一个redis实例的端口分别改为7001-7006
[root@localhost bin]# vim redis.conf
在这里插入图片描述

第二步：

启动每个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

第三步：

使用ruby脚本搭建集群。
从拷贝rb文件到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

第四步:

创建关闭集群的脚本：（不是必须的）
首先使用: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

6.3 集群的使用方法

Redis-cli连接集群。

[root@localhost redis-cluster]# redis01/bin/redis-cli -p 7002 -c

-c：代表连接的是redis集群
使用命令操作redis是和单机版的一样。

7 Jedis

需要把jedis依赖的jar包添加到工程中。Maven工程中需要把jedis的坐标添加到依赖。推荐添加到服务层。
添加如下坐标到服务层中的pom.xml文件中

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

7.1 连接单机版

第一步：创建一个Jedis对象。需要指定服务端的ip及端口。
第二步：使用Jedis对象操作数据库，每个redis命令对应一个方法。
第三步：打印结果。
第四步：关闭Jedis

@Test
	public void testJedis() throws Exception {
		// 第一步：创建一个Jedis对象。需要指定服务端的ip及端口。
		Jedis jedis = new Jedis("192.168.25.153", 6379);
		// 第二步：使用Jedis对象操作数据库，每个redis命令对应一个方法。
		String result = jedis.get("hello");
		// 第三步：打印结果。
		System.out.println(result);
		// 第四步：关闭Jedis
		jedis.close();
	}

7.2 使用连接池连接单机版

第一步：创建一个JedisPool对象。需要指定服务端的ip及端口。
第二步：从JedisPool中获得Jedis对象。
第三步：使用Jedis操作redis服务器。
第四步：操作完毕后关闭jedis对象，连接池回收资源。
第五步：关闭JedisPool对象。

@Test
	public void testJedisPool() throws Exception {
		// 第一步：创建一个JedisPool对象。需要指定服务端的ip及端口。
		JedisPool jedisPool = new JedisPool("192.168.25.153", 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();
	}

7.3 连接集群版

第一步：使用JedisCluster对象。需要一个Set参数。Redis节点的列表。
第二步：直接使用JedisCluster对象操作redis。在系统中单例存在。
第三步：打印结果
第四步：系统关闭前，关闭JedisCluster对象。

@Test
	public void testJedisCluster() throws Exception {
		// 第一步：使用JedisCluster对象。需要一个Set<HostAndPort>参数。Redis节点的列表。
		Set<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 jedisCluster = new JedisCluster(nodes);
		// 第二步：直接使用JedisCluster对象操作redis。在系统中单例存在。
		jedisCluster.set("hello", "100");
		String result = jedisCluster.get("hello");
		// 第三步：打印结果
		System.out.println(result);
		// 第四步：系统关闭前，关闭JedisCluster对象。
		jedisCluster.close();
	}

8 向业务逻辑中添加缓存

因为集群是比较消耗成本的，所以在公司中，一般生产环境使用集群，开发环境使用单机版。
我们在项目整合中都需要有。
可以开发一个接口，有单机版的实现类和集群版的实现类。使用时可以面向接口开发，不影响业务逻辑，使用spring管理实现类，部署时切换实现类即可。

8.1 接口封装

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

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

8.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;
	}

}

8.1.3 applicationContext-redis.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p"
	xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans4.2.xsd
	http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context4.2.xsd
	http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop4.2.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx4.2.xsd
	http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util4.2.xsd">

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

8.1.4 集群版实现类

package com.taotao.jedis;

import org.springframework.beans.factory.annotation.Autowired;

import redis.clients.jedis.JedisCluster;

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

}

8.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.153"></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.153"></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.153"></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.153"></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.153"></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.153"></constructor-arg>
					<constructor-arg name="port" value="7006"></constructor-arg>
				</bean>
			</set>
		</constructor-arg>
	</bean>
	<bean id="jedisClientCluster" class="com.taotao.jedis.JedisClientCluster"/>

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

8.2 封装代码测试

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

8.3 添加缓存

查询内容列表时添加缓存。
1、查询数据库之前先查询缓存。
2、查询到结果，直接响应结果。
3、查询不到，缓存中没有需要查询数据库。
4、把查询结果添加到缓存中。
5、返回结果。

向redis中添加缓存，使用hash对key进行归类。：
Key：categoryId
field:cid
Value：内容列表。需要把java对象转换成json。
注意：添加缓存不能影响正常业务逻辑。

8.3.2 代码实现

在ContentServiceImpl实现类中添加缓存，
部分代码如下：

@Autowired
	private JedisClient jedisClient;	
	@Value("${CONTENT_KEY}")
	private String CONTENT_KEY;
@Override
	public List<TbContent> getContentList(long cid) {
		//查询缓存
		try {
			String json = jedisClient.hget(CONTENT_KEY, cid + "");
			//判断json是否为空
			if (StringUtils.isNotBlank(json)) {
				//把json转换成list
				List<TbContent> list = JsonUtils.jsonToList(json, TbContent.class);
				return list;
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		//根据cid查询内容列表
		TbContentExample example = new TbContentExample();
		//设置查询条件
		Criteria criteria = example.createCriteria();
		criteria.andCategoryIdEqualTo(cid);
		//执行查询
		List<TbContent> list = contentMapper.selectByExample(example);
		//向缓存中添加数据
		try {
			jedisClient.hset(CONTENT_KEY, cid + "", JsonUtils.objectToJson(list));
		} catch (Exception e) {
			e.printStackTrace();
		}
		return list;
	}

属性文件所在的位置：

8.4 缓存同步

对内容信息做增删改操作后只需要把对应缓存key删除即可。
以添加内容为例，可以根据categoryId删除。

@Override
	public TaotaoResult addContent(TbContent content) {
		//补全属性
		content.setCreated(new Date());
		content.setUpdated(new Date());
		//插入数据
		contentMapper.insert(content);
		//缓存同步
		jedisClient.hdel(CONTENT_KEY, content.getCategoryId().toString());
		
		return TaotaoResult.ok();
	}

陌上花开zz

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
redis及其集群的安装、Jedis的使用方法

1 redis的介绍为了解决高并发、高可扩展（集群）、高可用（不能宕机）、大数据存储问题而产生的数据库解决方案，就是NoSql数据库。NoSql数据库：全称 not only sql ,非关系型数据库。可以作为关系型数据库的一个很好的补充。不能替代。Redis是用C语言开发的一个开源的高性能键值对（key-value）数据库（nosql），应用在缓存。它通过提供多种键值数据类型来适应不同场景...
复制链接

扫一扫