非关系数据库redis

概念：redis是一款高性能的NOSQL系列的非关系型数据库

命令操作：

        1.redis的数据结构：

                redis存储的是：key,value格式的数据，其中key都是字符串，value有5种不同的数据结构

                        value的数据结构：

                                1、字符串类型：string

                                2、哈希类型：hash:map格式

                                3、列表格式：list:linkeslist格式，支持重复元素

                               4、集合类型：set:不允许重复元素

                               5、有序集合类型：sortedset：不允许重复元素，且元素排序

        2、字符串类型：string

                1、存储：set key value

                2、获取：get key

                3、删除：del key

        3、哈希类型：hash

                1.存储：hset key field value

                        例如：hset 1 username shangsan

                                    hset 1 password 1234

                2、获取：hgetall key：获取key所有的field和value

                        例如：hgetall 1

                                        1) "username"
                                        2) "shangsan"
                                        3) "password"
                                        4) "1234"

                        hget key field：获取指定的field对应的值

                                例如：hget 1 username

                                        "shangsan"

                3、删除：hdel key field [field ...]

                                例如：hdel 1 username

        4、列表类型：list：可以添加一个元素到列表的头部（左边）或尾部（右边）

                1、添加：rpush key value [value ...]：将元素加入列表右边

                                lpush key value [value ...]：将元素加入列表左表

                                例如：rpush age 1 2 3

                                           rpush age "12"

                                        1) "12"
                                        2) "1"
                                        3) "2"
                                        4) "3"

                2、获取：lrange key start stop：范围获取

                                lrange age 0 -1：获取此列表所有值

                3、删除：lpop key：从列表最左边移除一个元素，并将元素返回

                                rpop key：从列表最右边一处一个元素，并将元素返回

        5、集合类型：set：不允许重复元素

                1、存储：sadd key member [member ...]

                2、获取：smembers key：获取set集合中所有元素

                3、删除：srem name member [member ...]：通过特指删除set集合中的某个元素

        6、有序集合类型：sortedset：不允许重复元素，且元素有顺序

                1、存储：zadd key score member [score member ...]：根据score排序，score是数字。

                2、获取：zrange key start stop

                3、删除：zrem key member [member ...]

        7、通用命令：

                1、keys *：查询所有的键

                2、type key：获取键对应的value的类型

                3、del key：删除指定的key value

持久化

        1、redis是一个内存数据库，当redis服务器重启，获取电脑重启，数据会丢失，我们可以将redis内存中的数据持久化保存到硬盘的文件中。

        2.redis持久化机制：

                1、RDB：默认方式，不需要进行配置，默认就使用这种机制（容易丢失一些数据）

                        在一定的时间间隔中，检测key的变化情况，然后持久化数据

                        1、编辑redis.windows.conf文件

                                #   after 900 sec (15 min) if at least 1 key changed

                                #   after 300 sec (5 min) if at least 10 keys changed

                                #   after 60 sec if at least 10000 keys changed

                                save 900 1

                                save 300 10

                                save 60 10000

                        2、重新启动redis服务器，并指定配置文件名称：使用cmd进入redis目录，输入redis-server.exe redis.windows.conf。

                                D:\app\Redis-x64-5.0.14.1>redis-server.exe redis.windows.conf

                2、AOF：日志记录的方式，可以记录每一条命令的操作。可以每一次命令操作后持久化数据（对性能影响较严重）

                        编辑redis.windows.conf文件。

                                appendonly yes：开启aof，默认是no.

                                # appendfsync always：每一次操作都进行持久化

                                appendfsync everysec：每个一秒进行一次持久化

                                # appendfsync no：不进行持久化

Jedis:通过Java来操作redis数据库的工具

1、导入jar包

        maven依赖：

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

2、操作各种resis中的数据结构

public class JedisTest {
    static Jedis jedis;
    static{
        jedis=new Jedis("localhost",6379);
    }
//String
@Test
    public void test1(){
        jedis.setex("username",20,"liweier");
        jedis.set("username","liweier");
        System.out.println(jedis.get("username"));
        jedis.del("username");
        jedis.close();
    }
//    hash
    @Test
    public void test2(){
        jedis.hset("company", "beijing", "12");
        System.out.println(jedis.hget("company", "beijing"));
        Map<String, String> company = jedis.hgetAll("company");
        for (String s:company.keySet())
            System.out.println(s+":"+company.get(s));
        jedis.close();
    }
//    list
    @Test
    public void test3(){
        jedis.lpush("place1", "beijing","shanghai","chongqin");
        List<String> company = jedis.lrange("place1", 0, -1);
        System.out.println(company);
        System.out.println(jedis.rpop("place1"));
        System.out.println(jedis.lrange("place1", 0, -1));
        jedis.del("place1");
        jedis.close();
    }
//    set
    @Test
    public void test4(){
        jedis.sadd("place1","beijing","shanghai","chongqin");
        Set<String> place1 = jedis.smembers("place1");
        System.out.println(place1);
        jedis.srem("place1","shanghai");
        System.out.println(jedis.smembers("place1"));
        jedis.del("place1");
        jedis.close();
    }
//    sotedset
    @Test
    public void test5(){
        Map<String,Double> map=new HashMap<>();
        map.put("beijing", 3.0);
        map.put("shanghai", 1.0);
        map.put("chongqin", 4.0);
        for(String s:map.keySet())
            System.out.println(s + " " + map.get(s));
        jedis.zadd("place1",map);
        Set<String> place1 = jedis.zrange("place1", 0, -1);
        System.out.println(place1);
        jedis.zrem("place1","shanghai");
        System.out.println(jedis.zrange("place1", 0, -1));
        jedis.del("place1");
        jedis.close();
    }
}

3、Jedis数据库连接池

jedis.properties

#Reids地址
host=127.0.0.1
#Reids服务器端口
port=6379

#连接池最大连接数
maxTotal=200
#最大空闲连接数
maxIdle=200
#最小空闲连接数
minIdle=10
#当连接池连接用尽后，调用者的最大等待时间（单位：ms）。如果超过此时间将接到异常。设为-1表示无限制。
maxWaitMillis=1000
#在向连接池借用连接是否先做连接有效验证（ping），无效连接会被移除，高并发下建议关闭，因为验证会额外消耗时间
testOnBorrow=true
#向连接池归还连接时是否做连接有效验证，无效连接会被移除
testOnReturn=true
#空闲连接的检测周期（单位为毫秒）。-1表示不检测
timeBetweenEvictionRunsMillis=30000
#连接池中连接的最小空闲时间（单位为毫秒），达到此值后空闲资源将被移除。
minEvictableIdleTimeMillis=180000
#做空闲资源检测时，每次检测资源的个数。-1就是对所有连接做空闲监测
numTestsPerEvictionRun=-1

​​​​​​​数据库连接池工具类：

public class JedisUtil {
    private static JedisPool jedisPool;
    static{
        try {
            Properties properties=new Properties();
            InputStream resourceStream = JedisUtil.class.getClassLoader().getResourceAsStream("jedis.properties");
            properties.load(resourceStream);
            GenericObjectPoolConfig config=new GenericObjectPoolConfig();
            config.setMaxTotal(Integer.parseInt(properties.getProperty("maxTotal")));
            config.setMinIdle(Integer.parseInt(properties.getProperty("minIdle")));
            jedisPool=new JedisPool(config, properties.getProperty("host"), Integer.parseInt(properties.getProperty("port")));

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public static Jedis getResource(){
        return jedisPool.getResource();
    }
}