Redis 简介：
Redis 是一个开源（BSD许可）的，key-value存储的.内存中的数据结构存储系统，它可以用作数据库、缓存和消息中间件。 它支持多种类型的数据结构，如 字符串（strings）， 散列（hashes）， 列表（lists）， 集合（sets）， 有序集合（sorted sets） 与范围查询， bitmaps， hyperloglogs 和 地理空间（geospatial） 索引半径查询。 Redis 内置了 复制（replication），LUA脚本（Lua scripting）， LRU驱动事件（LRU eviction），事务（transactions） 和不同级别的 磁盘持久化（persistence）， 并通过 Redis哨兵（Sentinel）和自动 分区（Cluster）提供高可用性（high availability）。
结果:读的速度是110000次/s,写的速度是81000次/s
将redis.tar 放在linux系统里面解压：
tar -zxvf redis-3.2.8.tar.gz
编译/和安装redis
在redis的根目录下执行make/make install
[root@iZwz9c6jlipu33po7lw2kgZ redis-3.2.8]# make
[root@iZwz9c6jlipu33po7lw2kgZ redis-3.2.8]# make install
Redis 启动：
1.redis-server
2.redis-server &
3.redis-server redis.conf
4.redis-cli -p 6379 shutdown
redis-cli shutdown
kill -9 8386
5.redis-cli -p 6379 进入控制台
修改Redis配置文件：
[root@iZwz9c6jlipu33po7lw2kgZ redis-3.2.8]# vim redis.conf
-
**关闭IP绑定 **61行
-
关闭保护模式
-
开启后台启动
-
修改PID位置
-
修改持久化文件路径
-
修改内存策略
##通过配置文件的方式 启动redis
[root@iZwz9c6jlipu33po7lw2kgZ redis-3.2.8]# redis-server redis.conf
Redis中持久化策略说明
因为redis中保存的数据都在内存中,当断电/宕机.缓存中的数据都会被清空.如果redis中没有配置持久化策略,安全性不够完善.
策略说明:
1.RDB方式
该方式是redis默认选择的持久化策略
特点:持久化的效率更高,定期持久化可能会丢失数据
2.AOF方式
该方式需要通过配置文件手动开启
特点:持久化效率低,每秒持久化/每次操作持久化,保证数据尽可能不丢失
持久化步骤:
1.当用户set操作时,redis中的数据会新增/更新
2.这时根据用户选择的持久化的策略.自动的进行数据持久化操作.以下以RDB模式为例.
3.定期会将redis中全部的数据通过xxx.RDB文件的方式保存.
4.如果redis服务器宕机重启时,首先会加载持久化文件xxx.RDB.恢复内存中的数据.
5.当用户使用redis时,这时redis内存中已经恢复了数据,为用户继续提供服务.
RDB模式：
1.RDB持久化策略
save 900 1
save 300 10
save 60 10000
1.在15分钟内,如果用户执行了一次set操作则持久化一次
2.在5分钟内,如果用户执行了10次set操作则持久化一次
3.在5分钟内,如果用户执行了10000set操作则持久化一次
持久化文件名称配置
在237行可以修改持久化文件的名称
修改持久化文件的位置
总结：
如果使用redis服务时,如果允许丢失小部分数据,则使用RDB模式,因为它的效率是最高的。
AOF模式：
1.开启AOF模式
说明:如果在配置文件中开启AOF模式,则redis中的RDB模式将不生效.
2.持久化文件名称
持久化策略：
说明:
AOF模式是记录用户的执行的过程.将用户的全部的操作步骤,以文件的形式进行记录.当redis服务器重新启动时,会根据AOF文件中的步骤,重新执行一次.最终实现数据的恢复.
appendfsync always
appendfsync everysec
appendfsync no
always:用户每次操作都是追加到aof文件中
everysec:每秒记录用户的操作步骤
no:不记录
持久化文件位置
总结：
AOF模式相当于记录了用户的执行过程.从而实现了数据的持久化.默认的条件下AOF模式采用每秒备份.保证数据的有效性.但是效率低于RDB.
AOF文件较大,需要的执行时间较长.
Redis中内存策略说明
1.定义redis中最大内存
LRU算法：
内存管理的一种页面置换算法，对于在内存中但又不用的数据块（内存块）叫做LRU，操作系统会根据哪些数据属于LRU而将其移出内存而腾出空间来加载另外的数据。
内存优化手段
volatile-lru -> 将设定超时时间的数据并且其中使用较少的数据进行删除
allkeys-lru -> 将redis中全部key进行LRU筛选,之后进行删除
volatile-random -> 设定了超时间的数据,随机删除
allkeys-random -> 全部的key随机删除
volatile-ttl -> 将已经设定了超时时间的数据,按照存活时间排序,将马上要过期的数据进行删除.
noeviction -> 不做任何操作,将报错信息返回给用户.
.修改优化策略
Redis常用命令：
String类型
## Hash类型：
List类型：
说明:Redis中的List集合是双端循环列表,分别可以从左右两个方向插入数据.
List集合可以当做队列使用,也可以当做栈使用
队列:存入数据的方向和获取数据的方向相反
栈:存入数据的方向和获取数据的方向相同
Redis事务命令：
说明:redis中操作可以添加事务的支持.一项任务可以由多个redis命令完成,如果有一个命令失败导致入库失败时.需要实现事务回滚.
操作简单实例：
导入依赖包:
<!-- https://mvnrepository.com/artifact/redis.clients/jedis -->
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>2.9.0</version>
</dependency>
<!--添加spring-datajar包 -->
<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-redis</artifactId>
<version>1.4.1.RELEASE</version>
</dependency>
<dependency><!-- fastJson json转换工具 -->
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.8.5</version>
</dependency>
操作redis数据库
public class TestRedisString {
/**
* 步骤:
* 1.连接Redis IP:端口
*/
@Test
public void test01(){
Jedis jedis = new Jedis("192.168.126.169", 6379);
jedis.set("1ii", "好好学习,OJBK");
System.out.println(jedis.get("1ii"));
}
//操作Hash
@Test
public void test02(){
Jedis jedis = new Jedis("192.168.126.169", 6379);
jedis.hset("user", "id", "100");
jedis.hset("user", "name", "9班");
Map<String,String> userMap = jedis.hgetAll("user");
System.out.println(userMap);
}
@Test
public void testList(){
Jedis jedis = new Jedis("192.168.126.169", 6379);
jedis.lpush("List1", "1,2,2,2,2,2","2","3");
System.out.println(jedis.rpop("List1"));
System.out.println(jedis.rpop("List1"));
}
}
对象转换为String
ObjectMapper objectMapper = new ObjectMapper();
String userJSON =
objectMapper.writeValueAsString(user);
System.out.println(userJSON);
//将json串转化为java对象
User user1 = objectMapper.readValue(userJSON, User.class);
System.out.println(user1.toString());
String listJSON =
objectMapper.writeValueAsString(strList);
System.out.println(listJSON);
//将JSON转化为List集合
List<String> jsonList =
objectMapper.readValue(listJSON, List.class);
实例2：
public class App
{
public static void main( String[] args )
{
System.out.println( "Hello World!" );
}
@Test
public void testReadRedis() throws Exception{
ObjectMapper objectMapper= new ObjectMapper();
//取值对象
Jedis jedis= new Jedis("119.23.224.88", 6379);
//lpop 取值
String s1 = jedis.lpop("s2");
Student student1 = objectMapper.readValue(s1, Student.class);
System.out.println(student1.toString());
String s2=jedis.lpop("s1");
Student student2 = objectMapper.readValue(s2, Student.class);
System.out.println(student2.toString());
//hset 取值
String hs1 = jedis.hget("h1", "s1");
String hs2 = jedis.hget("h1", "s2");
Student student3 = objectMapper.readValue(hs1, Student.class);
Student student4 = objectMapper.readValue(hs2, Student.class);
hs1=jedis.hget("h2", "s1");
hs2=jedis.hget("h2", "s2");
Student student5 = objectMapper.readValue(hs1, Student.class);
Student student6 = objectMapper.readValue(hs2, Student.class);
System.out.println(student3);
System.out.println(student4);
System.out.println(student5);
System.out.println(student6);
}
@Test
public void testRedis(){
Student s1= new Student();
s1.setAddress("湖南省牛逼市虎头山");
s1.setAge(26);
s1.setBrithday(new Date());
s1.setFristName("王");
s1.setLastName("飞起");
s1.setGender("男");
Student s2= new Student();
s2.setAddress("湖南省牛逼市虎头山");
s2.setAge(29);
s2.setBrithday(new Date());
s2.setFristName("王");
s2.setLastName("白起");
s2.setGender("女");
ObjectMapper objectMapper= new ObjectMapper();
Jedis jedis= new Jedis("119.23.224.88", 6379);
try {
String s1JSON= objectMapper.writeValueAsString(s1);
String s2JSON= objectMapper.writeValueAsString(s2);
//有序对列存值
jedis.lpush("s1", s1JSON );
jedis.lpush("s2", s2JSON);
//hset 存值 key值为 hashmap的名字 field 参数 为hashmap的key 值 value 为value
jedis.hset("h1", "s1", s1JSON);
jedis.hset("h1", "s2", s2JSON);
jedis.hset("h2", "s1", s1JSON);
jedis.hset("h2", "s2", s2JSON);
} catch (JsonProcessingException e) {
e.printStackTrace();
}
}
@Test
public void testRedisArays(){
Jedis jedis=new Jedis("119.23.224.88", 6379);
jedis.set("9797", "丢你老母");
String value=jedis.get("9797");
System.out.println(value);
}
}
class Student{
private String fristName;
private String lastName;
private Integer age;
private Date brithday;
private String address;
private String gender;
@Override
public String toString() {
return "Student{" +
"fristName='" + fristName + '\'' +
", lastName='" + lastName + '\'' +
", age=" + age +
", brithday=" + brithday +
", address='" + address + '\'' +
", gender='" + gender + '\'' +
'}';
}
public String getFristName() {
return fristName;
}
public void setFristName(String fristName) {
this.fristName = fristName;
}
public String getLastName() {
return lastName;
}
public void setLastName(String lastName) {
this.lastName = lastName;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public Date getBrithday() {
return brithday;
}
public void setBrithday(Date brithday) {
this.brithday = brithday;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
}
Redis集群实现:
集群特点：
说明:redis集群实质上将redis分片和redis哨兵的机制进行整合.redis集群中每个节点多可以与其他节点进行通讯.同时集群内部有心跳检测.如果节点发生宕机的现象.由所在集群的全部服务器负责推选.保证服务的正常运行.如果全部的从节点宕机,并且这时主节点宕机那么整个集群才会奔溃.
集群规模定义：
原则:一般集群中的主节点的数量一定是奇数个.目的防止出现平票现象（脑裂）
-
创建文件夹
在redis 跟目录下创建cluster文件夹后新增7000-7008文化夹
-
导入配置文件：
将redis.conf文件分别导入7000-7008文件夹中 -
修改redis.conf配置文件
1.关闭ip绑定
2.关闭保护模式
3.修改端口号
4.开启后台启动
5.修改PID位置
6.修改持久化文件路径
7.修改内存策略
8.开启集群
9.开启集群的日志文件
10.设定推选时间
分别修改配置文件：
编辑redis启动脚本文件：
启动Redis
sh start.sh
实现集群搭建：
使用ruby工具管理redis集群.
参考Ruby安装教程：
./redis-trib.rb create --replicas 2 176.53.5.94:7000 176.53.5.94:7001 176.53.5.94:7002 176.53.5.94:7003 176.53.5.94:7004 176.53.5.94:7005 176.53.5.94:7006 176.53.5.94:7007 176.53.5.94:7008
replicas 2:代表一个主节点有2台从机
自己购买的服务器再搭建完集群后需要：
服务器搭建集群需把Redis的监听窗口也打开；一般为10000+端口号
集群的部分代码实现：
redis.properties 配置文件
#最小空闲数
redis.minIdle=100
#最大空闲数
redis.maxIdle=300
#最大连接数
redis.maxTotal=1000
#客户端超时时间单位是毫秒
redis.timeout=5000
#最大建立连接等待时间
redis.maxWait=1000
#是否在从池中取出连接前进行检验,如果检验失败,则从池中去除连接并尝试取出另一个
redis.testOnBorrow=true
#redis cluster
redis.cluster0=119.23.224.88:7000
redis.cluster1=119.23.224.88:7001
redis.cluster2=119.23.224.88:7002
redis.cluster3=119.23.224.88:7003
redis.cluster4=119.23.224.88:7004
redis.cluster5=119.23.224.88:7005
redis.cluster6=119.23.224.88:7006
redis.cluster7=119.23.224.88:7007
redis.cluster8=119.23.224.88:7008
Redis配置类：
@Configuration
@PropertySource("classpath:property/redis.properties") // 读取redisCluter配置文件
public class AppRedisConfig {
/**
* redis连接池
* @param maxIdle 最大空闲数 int 毫秒
* @param maxWait 最大建立连接等待时间 int 毫秒
* @param testOnBorrow 是否取出前在连接池中校验 boolean
* @param maxTotal 最大连接数 int 毫秒
* @param minIdle 最小空闲数 int 毫秒
* @return
*/
@Bean("jedisPoolConfig")
public JedisPoolConfig newJedisPoolConfig(@Value("${redis.maxIdle}") int maxIdle,
@Value("${redis.maxWait}") long maxWait
,@Value("${redis.testOnBorrow}") boolean testOnBorrow
,@Value("${redis.maxTotal}") int maxTotal
,@Value("${redis.minIdle}") int minIdle){
JedisPoolConfig jedisPoolConfig=new JedisPoolConfig();
jedisPoolConfig.setMaxIdle(maxIdle);
jedisPoolConfig.setMaxTotal(maxTotal);
jedisPoolConfig.setMaxWaitMillis(maxWait);
jedisPoolConfig.setMinIdle(minIdle);
jedisPoolConfig.setTestOnBorrow(testOnBorrow);
return jedisPoolConfig;
}
/**
* redis 集群工厂
* @param jedisPoolConfig
* @return
*/
@Bean
public JedisClusterFactory newJedisClusterFactory( @Autowired JedisPoolConfig jedisPoolConfig){
JedisClusterFactory jedisClusterFactory=new JedisClusterFactory();
jedisClusterFactory.setPoolConfig(jedisPoolConfig);
jedisClusterFactory.setRedisNodePrefix("redis.cluster");
jedisClusterFactory.setPropertySource(new ClassPathResource("property/redis.properties"));//路径
return jedisClusterFactory;
}
}
RedisFactory工场类实现：
//通过工厂模式创建JedisCluster对象
public class JedisClusterFactory implements FactoryBean<JedisCluster>{
private Resource propertySource; //表示注入properties文件
private JedisPoolConfig poolConfig; //注入池对象
private String redisNodePrefix; //定义redis节点的前缀
@Override
public JedisCluster getObject() throws Exception {
Set<HostAndPort> nodes = getNodes(); //获取节点信息
JedisCluster jedisCluster =
new JedisCluster(nodes, poolConfig);
return jedisCluster;
}
//获取redis节点Set集合
public Set<HostAndPort> getNodes(){
//1.准备Set集合
Set<HostAndPort> nodes = new HashSet<HostAndPort>();
//2.创建property对象
Properties properties = new Properties();
try {
properties.load(propertySource.getInputStream());
//2.从配置文件中遍历redis节点数据
for (Object key : properties.keySet()) {
String keyStr = (String) key;
//获取redis节点数据
if(keyStr.startsWith(redisNodePrefix)){
//IP:端口
String value = properties.getProperty(keyStr);
String[] args = value.split(":");
System.out.println(args);
HostAndPort hostAndPort =
new HostAndPort(args[0],Integer.parseInt(args[1]));
nodes.add(hostAndPort);
}
}
} catch (Exception e) {
e.printStackTrace();
}
return nodes;
}
@Override
public Class<?> getObjectType() {
return JedisCluster.class;
}
@Override
public boolean isSingleton() {
return false;
}
public Resource getPropertySource() {
return propertySource;
}
public void setPropertySource(Resource propertySource) {
this.propertySource = propertySource;
}
public JedisPoolConfig getPoolConfig() {
return poolConfig;
}
public void setPoolConfig(JedisPoolConfig poolConfig) {
this.poolConfig = poolConfig;
}
public String getRedisNodePrefix() {
return redisNodePrefix;
}
public void setRedisNodePrefix(String redisNodePrefix) {
this.redisNodePrefix = redisNodePrefix;
}
}
部分测试代码：
@RequestMapping("redis/{nana}")
@ResponseBody
public String test(@PathVariable("nana") String name
,HttpServletRequest request
,HttpServletResponse response){
//1.获取浏览器的cookies
Cookie[] cookies = request.getCookies();
String token=null;//存储在redis集群的token
//2.遍历cookies集合,获取用户的token
if(cookies!=null){
for (Cookie cookie : cookies) {
if("XIAMI_LOGIN".equals(cookie.getName())){
token=cookie.getValue();
break;
}
}
}
if(token!=null){//缓存区存在数据
return jedisCluster.get(token);
}else{
Md5Hash md5Hash=new Md5Hash(name+""+System.currentTimeMillis());
token=md5Hash.toString();
Cookie cookie=new Cookie("XIAMI_LOGIN", token);
cookie.setMaxAge(10*60);//单位秒
cookie.setPath("/");//设置cookie存储路径
response.addCookie(cookie);
jedisCluster.set(token, name);
jedisCluster.expire(token, 10*60);//设置键值的存活时间
return "查无此数据";
}
}