Redis简介

简介

Redis (Remote Dictionary Server) ：是一个开源的内存数据结构存储系统，也被称为键值值存储数据库。它支持多种数据结构，包括字符串（Strings）、哈希（Hashes）、列表（Lists）、集合（Sets）和有序集合（Sorted Sets）等。

特点：

1. 内存存储：Redis 将数据存储在内存中，因此具有非常高的读写性能。它通过将数据保持在内存中，提供了快速的数据访问速度。此外，Redis 还提供了持久化选项，可以将数据定期写入磁盘，以防止数据丢失。
2. 数据结构多样性：Redis 支持多种数据结构，包括字符串、哈希、列表、集合和有序集合等。这使得 Redis 在不同的应用场景中具有灵活性，可以存储和处理各种类型的数据。
3. 高级功能：Redis 提供了许多高级功能，如发布/订阅（Pub/Sub）、事务（Transactions）、Lua 脚本执行等。这些功能使得 Redis 可以应对更复杂的应用需求，并提供更丰富的功能和灵活性。
4. 分布式支持：Redis 提供了集群模式，可以将数据分布在多个节点上，以实现数据的高可用性和横向扩展。Redis 集群通过分片和复制来实现数据的分布和冗余，以提供更高的性能和可靠性。
5. 多语言支持：Redis 支持多种编程语言的客户端库，如 Python、Java、C#、Node.js 等。这使得开发人员可以使用自己熟悉的编程语言与 Redis 进行交互，并方便地集成 Redis 到他们的应用程序中。

注意：
Redis 在许多应用场景中被广泛使用，包括缓存、会话存储、排行榜、实时分析、消息队列等。它的高性能、灵活性和丰富的功能使得 Redis 成为一个受欢迎的数据存储解决方案。

1.关系型数据库和非关系型数据库区别

1. 关系型数据库

常见的关系型数据库：Sql Server，My Sql，Oracle。
特点：数据和数据之间，表和字段之间，表和表之间是存在关系的。
例如：部门表中的员工ID，与员工表的员工ID。
用户表中的用户名、密码字段。
商品分类表和商品表，就是一对多的关系。
特点：
1、数据之间有关系，在进行对数据的增删改查的时候就非常方便。
如查部门下的所有员工信息时，只要写一条SQL语句，就能搞定。
2、关系型数据库是有事务操作，能够保证数据的一致性、完整性。

缺点：
1、因为数据与数据之间是有关系，这种关系不是空穴来风，它是由底层大量算法来保证的。如select * from product;语句,其实会进行底层大量算法的运算。虽然查询出来你所想要的数据，但是大量算法会拉低系统运行速度、消耗系统性能。
2、关系型数据库在面对海量数据的增删改查时会显示得无能为力。很有可能会宕机(未响应、卡住了)。
3、海量数据环境下对数据表进行维护/扩展，也会变得无能无力。
如：update product set cname = ‘手机数码’;
//如果数据量在几百万以上会直接卡到
如：要将商品表的cname字段，由varchar(64)修改为char(100) 由于数据量大，每一条语句都要去运行关系算法，这样直接会卡死。
特点：关系型数据库适合处理一般量级数据，但是安全。

2. 非关系型数据库

为了处理海量数据，需要将关系型数据库的关系去掉。
非关系型数据库设计之初是为了替代关系型数据库。
常用的非关系型数据库：Redis。
优点：
1、海量数据的增删改查，非常轻松应对。因为数据与数据之间是没有关系的，所以就不存在大量算法。
2、海量数据的维护也是非常轻松，如在海量数据中扩充一个字段(非关系数据库不用去运行关系算法)。

1. 缺点：
1、数据和数据之间没有有关系，所以不能一目了然。如在关系型数据库中存储一个部门表，一看就能 知道部门表里有哪些数据(部门名、部门下的员工)。非关系型数据库数据与数据之间是没有关系的，它们之 间是单独存在的。把数据查询出来时，就好比一盘散沙一样，然后自己再将它们整理成为一个有关系的表。
2、非关系型数据库数据与数据之间是没有关系了，也没有强大的事务保证数据的完整性与安全性。

特点：适合处理海量数据，效率高。但是不一定安全。
如：查询奥运健儿奖牌总数。 这些数据一般都是在官网上进行展示，它的查询是极为频繁的，可能 几秒钟就会有上万次查询，像这种几秒钟查询上万次查询，如果交给关系型数据库，它不一定能扛得住。 而非关系型数据库会非常轻松应对。

结论：将来看开发都是关系型数据库+非关系型数据库一起共同带起一个项目。在这个 项目中， 重要 的数据保存到关系型数据库中，而海量且不重要的数据就保存到非关系型数 据库中。

2.Redis充当的角色

充当关系型数据库的缓存而存在，缓解关系型数据库的查询压力(也叫缓存数据库)。

细节：

1. 数据存储：Redis 是一个键值存储数据库，它将数据存储在内存中。作为一个键值存储系统，Redis 提供了丰富的数据结构，包括字符串（Strings）、哈希（Hashes）、列表（Lists）、集合（Sets）、有序集合（Sorted Sets）等。这使得 Redis 能够存储和处理各种类型的数据。
2. 缓存：Redis 常用于作为缓存层，将常用的数据存储在内存中，以提高数据访问速度。通过将热点数据存储在 Redis 中，应用程序可以从快速的内存访问中获益，减少对后端存储系统（如数据库）的访问压力。
3. 分布式锁：Redis 提供了分布式锁的功能，用于在分布式系统中实现资源的互斥访问。通过 Redis 的原子性操作和锁机制，可以确保在分布式环境中对共享资源的安全访问。
4. 发布/订阅：Redis 支持发布/订阅模式，允许应用程序通过订阅感兴趣的频道来接收消息，并通过发布消息到指定频道来通知其他订阅者。这使得 Redis 成为一个简单而强大的消息队列系统，可用于实现实时通知、事件驱动等场景。
5. 排行榜：Redis 的有序集合（Sorted Sets）数据结构提供了对数据进行排序和排名的功能。这使得 Redis 可以用于实现排行榜功能，如用户积分排名、热门文章排行等。
6. 地理空间索引：Redis 通过提供地理空间索引功能，使得应用程序可以存储和查询基于地理位置的数据。这使得 Redis 在位置服务、附近的人功能等应用中具有优势。
7. 分布式缓存：Redis 支持集群模式，可以将数据分布在多个节点上，以实现数据的高可用性和横向扩展。通过分片和复制机制，Redis 集群提供了数据的分布和冗余，以提供更高的性能和可靠性。
   除了上述角色和功能外，Redis 还提供了事务（Transactions）、Lua 脚本执行、持久化选项等高级功能，使得它在各种应用场景中都能发挥重要作用。需要根据具体的应用需求来选择和配置 Redis，以充分利用其功能和优势。

3.Docker部署Redis

使用docker在Linux系统部署Redis

# 拉取Redis
docker pull Redis   --拉取最新redis版本
 
# --name:名称 -p:端口 ‐v:目录映射关系 
 docker run ‐di ‐‐name=redis‐p 6379:6379 redis 

客户端测试 在你的本地电脑命令提示符下，用window版本redis测试 
redis‐cli ‐h 192.168.247.135

4.Redis数据结构介绍

1.redis是使用键值对去保存数据的，类似于java中的map集合。(redis中是没有表概念)
2.这个map集合是有key和value，key全部都是字符串，value有五种数据类型。

5.使用redisTemplate进行各类型的CURD操作

package spring_data_redis_test;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import java.util.List;
import java.util.Set;

/**
 * Redis Test CURD
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:spring/applicationContext_redis.xml")
public class AllTest {
    //注入template对象
    @Autowired
    private RedisTemplate redisTemplate;
	//----------------------Hash类型的操作:经常用---------------------------------
	
	//（1）存入值
	@Test
	public void  boundHashOpsSet(){
	    redisTemplate.boundHashOps("namehash").put("country1","中国");
	    redisTemplate.boundHashOps("namehash").put("country2","日本");
	    redisTemplate.boundHashOps("namehash").put("country3","韩国");
	}
	
	//（2）提取所有的KEY
	@Test
	public void  boundHashOpsKeys(){
	    Set keys = redisTemplate.boundHashOps("namehash").keys();
	    System.out.println(keys);
	}
	
	//（3）提取所有的值
	@Test
	public void boundHashOpsValues(){
	    List values = redisTemplate.boundHashOps("namehash").values();
	    System.out.println(values);
	}
	
	//(4) 根据KEY提取值
	@Test
	public void boundHashOpsByKey(){
	    Object name = redisTemplate.boundHashOps("namehash").get("country1");
	    System.out.println(name);
	}
	
	//根据KEY移除值
	@Test
	public void boundHashOpsDelByKey(){
	    redisTemplate.boundHashOps("namehash").delete("country2");
	}
	
//----------------------------值类型的操作:因为操作数量少,所以不长用-----------------------------
    @Test
    public void setValue(){
        redisTemplate.boundValueOps("name").set("王五");
    }
    @Test
    public void getValue(){
        Object name = redisTemplate.boundValueOps("name").get();
        System.out.println(name);
    }
    @Test
    public void deleteValue(){
        redisTemplate.delete("name");
    }

//----------------------set类型的操作:因为操作数量少,所以不长用---------------------------------
    /**
     * 存入值
     */
    @Test
    public void boundSetOpsAdd(){
    redisTemplate.boundSetOps("nameset").add("曹操"); //放入值
    redisTemplate.boundSetOps("nameset").add("刘备");
    redisTemplate.boundSetOps("nameset").add("孙权");
    }
    
    /**
     * 提取值
     */
    @Test
    public void boundSetOpsGet(){
        Set names= redisTemplate.boundSetOps("nameset").members();//取出值
        System.out.println(names);
    }
    
    /**
     * 删除集合中的某一个值
     */
    @Test
     public void boundSetOpsDelete(){
         redisTemplate.boundSetOps("nameset").remove("曹操");
     }

    /**
     * 删除整个集合
     */
    @Test
    public void boundSetOpsDeleteAll(){
        redisTemplate.delete("nameset");
    }

    //----------------------list类型的操作:因为操作数量少,所以不长用-----------------------------
    
    /**
     * 右压栈：后添加的对象排在后边
     * 右压栈用的多,因为快,原理是
     */
    @Test
    public void boundListrightPush(){
        redisTemplate.boundListOps("namelist").rightPush("赵子龙");
        redisTemplate.boundListOps("namelist").rightPush("张飞");
        redisTemplate.boundListOps("namelist").rightPush("关羽");
    }
    
    /**
     * 显示右压栈集合
     */
    @Test
    public void boundListRange(){
        List namelist = redisTemplate.boundListOps("namelist").range(0, 10);
        System.out.println(namelist);
    }
    

    /**
     * 查询:根据索引查询集合某个元素
     */
    @Test
    public void boundListIndex(){
        Object name = redisTemplate.boundListOps("namelist").index(1);
        System.out.println(name);
    }

    /**
     * 删除: 根据值移除集合某个元素
     */
    @Test
    public void  bondListRemove(){
        redisTemplate.boundListOps("namelist").remove(1,"关羽");
    }
    
    /**
     * 删除: 删除全部
     */
    @Test
    public void  bondListDelete(){
        redisTemplate.delete("namelist");
    }
}