Redis单点登陆以及管道应用以及常用命令、cookie

最新推荐文章于 2022-10-22 21:38:49 发布

Kotak

最新推荐文章于 2022-10-22 21:38:49 发布

阅读量132

点赞数

本文链接：https://blog.csdn.net/weixin_45174508/article/details/114177732

版权

ngix反向代理两个服务器会发生一个服务器登陆了，另一个服务器没登陆的情况，因此需要保存登陆信息到redis中，登陆的用户就保存信息到redis中，
key为uuid，但是uuid是随机的，
所以需要在创建的时候保存在cookies中，
所以创建cookies的名字，值为uuid，
取的时候用cookie的名字取uuid，通过uuid取到用户信息

Maven依赖

<dependencies>
    <!--    1、 Jedis-->
    <dependency>
        <groupId>redis.clients</groupId>
        <artifactId>jedis</artifactId>
        <version>2.9.0</version>
    </dependency>
    <!--    2、 Junit测试-->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>
    <!--    3、 Lombok-->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.16.20</version>
    </dependency>
    <!-- 导入fastJSON -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.47</version>
</dependency>
</dependencies>

Utils包

public class RedisUtils {

    private static JedisPoolConfig config=new JedisPoolConfig();
    static {
        //最大空闲
        config.setMaxIdle(20);
        //最小空闲
        config.setMinIdle(10);
        //最大数量
        config.setMaxTotal(20);
        //最大等待时间
        config.setMaxWaitMillis(3000);
    }

    public static Jedis  getJedis(){

        return new Jedis("10.36.144.44",6379);

    }

    /**
     * jedis通用设置方法
     * @param key
     * @param value
     */
    public static String set(String key,String value){
        Jedis jedis = getJedis();
        String result = jedis.set(key, value);
        close(jedis);
        return result;
    }

    /**
     * jedis通用获取
     */
    public static String get(String key){
        Jedis jedis = getJedis();

        String result = jedis.get(key);
        close(jedis);
        return result;
    }



    /**
     * jedis 序列化设置方法
     * @param
     */
    public static String set(String key,Object value){
        Jedis jedis=getJedis();
        //将对象序列化
        String jsonString = JSON.toJSONString(value);
        String result = jedis.set(key, jsonString);
        close(jedis);
        return result;
    }


    /**
     * jedis序列化get方法
     * @param
     */
    public static <T> T get(String key,Class<T> clazz){

        Jedis jedis = getJedis();
        String result = jedis.get(key);
        //得到的结果反序列化
        T t = JSON.parseObject(result, clazz);
        close(jedis);
        return t;

    }

    public static void  close(Jedis jedis){

        jedis.close();

    }



}

Controller

@RestController
@RequestMapping("/user")
public class AController {

    @RequestMapping("/login")
    public String login(String name, String password, HttpServletResponse response){
        System.out.println(name);
        if (name.equals("admin")&&password.equals("admin")){
//            session.setAttribute("user","user");
            //uuid保存在cookies中 设置路径为全局有效
            UUID uuid = UUID.randomUUID();
            Cookie cookie=new Cookie("islogin",uuid.toString() );
            cookie.setPath("/");
            //保存cookies在本地
            response.addCookie(cookie);
            //保存在redis中 key为uuid
            RedisUtils.set(uuid.toString(),"zs");

            return "ok";
        }

        return "no ok";
    }

    @RequestMapping("/check")
    //@CookieValue("islogin") String uuid 注解得到cookie中名字为islogin的值
    public String check(@CookieValue("islogin") String uuid){

//        String user = (String) session.getAttribute("user");
        //redis中取到uuid的值，uuid的作用防止名称重复
        String result = RedisUtils.get(uuid);

        if (StringUtils.hasLength(result)){
            return "is login";
        }
        return "no login";
    }



}

mvc配置

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:aop="http://www.springframework.org/schema/aop" xmlns:mvc="http://www.springframework.org/schema/mvc"
       xmlns:task="http://www.springframework.org/schema/task"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       https://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/tx
       https://www.springframework.org/schema/tx/spring-tx.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task.xsd">
    <context:component-scan base-package="controller"></context:component-scan>
    <!--静态资源过滤-->
    <!--<mvc:default-servlet-handler/>-->

</beans>

web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">
    <servlet>
        <servlet-name>mvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <!--读取配置文件-->
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath*:mvc.xml</param-value>
        </init-param>
    </servlet>
    <servlet-mapping>
        <servlet-name>mvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

管道传输

@Test
    public void t6(){

        /**
         * 使用pipeline管道去暂时保存要操作的事情
         * 一次性提交到redis去操作 减少大量时间
         */

        Jedis jedis = RedisUtils.getJedis();
        jedis.set("age2","0");
        Pipeline pipelined = jedis.pipelined();
        long start = System.currentTimeMillis();
        for (int i=0;i<10000;i++){
            //jedis.incr("age"); 用了4683毫秒
            pipelined.incr("age2");

        }
        //pipelined.syncAndReturnAll() 用了63毫秒
        pipelined.syncAndReturnAll();
        System.out.println(System.currentTimeMillis()-start);
    }


}

string

#1.  添加值
set key value

#2. 取值
get key

#3. 批量操作
mset key value [key value...]
mget key [key...]

#4. 自增命令（自增1）
incr key 

#5. 自减命令（自减1）
decr key

#6. 自增或自减指定数量
incrby key increment
decrby key increment

#7. 设置值的同时，指定生存时间（每次向Redis中添加数据时，尽量都设置上生存时间）
setex key second value

#8. 设置值，如果当前key不存在的话（如果这个key存在，什么事都不做，如果这个key不存在，和set命令一样）
setnx key value

#9. 在key对应的value后，追加内容
append key value

#10. 查看value字符串的长度
strlen key

list

#1. 存储数据（从左侧插入数据，从右侧插入数据）
lpush key value [value ...]
rpush key value [value ...]

#2. 存储数据（如果key不存在，什么事都不做，如果key存在，但是不是list结构，什么都不做）
lpushx key value 先插入的数据在底下
rpushx key value 后插入的数据在底下

#3. 修改数据（在存储数据时，指定好你的索引位置,覆盖之前索引位置的数据，index超出整个列表的长度，也会失败）
lset key index value

#4. 弹栈方式获取数据（左侧弹出数据，从右侧弹出数据）
lpop key 后进先出，顶部出
rpop key 先进先出，底部出

#5. 获取指定索引范围的数据（start从0开始，stop输入-1，代表最后一个，-2代表倒数第二个）
lrange key start stop

#6. 获取指定索引位置的数据
lindex key index

#7. 获取整个列表的长度
llen key

#8. 删除列表中的数据（他是删除当前列表中的count个value值(重复数据)，count > 0从左侧向右侧删除，count < 0从右侧向左侧删除，count == 0删除列表中全部的value）
lrem key count value

#9. 保留列表中的数据（保留你指定索引范围内的数据，超过整个索引范围被移除掉）
ltrim key start stop

#10. 将一个列表中最后的一个数据，插入到另外一个列表的头部位置
rpoplpush list1 list2

hash

#1. 存储数据
hset key field value

#2. 获取数据
hget key field

#3. 批量操作
hmset key field value [field value ...]
hmget key field [field ...]

#4. 自增（指定自增的值）
hincrby key field increment

#5. 设置值（如果key-field不存在，那么就正常添加，如果存在，什么事都不做）
hsetnx key field value

#6. 检查field是否存在
hexists key field 

#7. 删除key对应的field，可以删除多个
hdel key field [field ...]

#8. 获取当前hash结构中的全部field和value
hgetall key

#9. 获取当前hash结构中的全部field
hkeys key

#10. 获取当前hash结构中的全部value
hvals key

#11. 获取当前hash结构中field的数量
hlen key

set


#1. 存储数据
sadd key member [member ...]

#2. 获取数据（获取全部数据）
smembers key

#3. 随机获取一个数据（获取的同时，移除数据，count默认为1，代表弹出数据的数量）
spop key [count]

#4. 交集（取多个set集合交集）
sinter set1 set2 ...

#5. 并集（获取全部集合中的数据）
sunion set1 set2 ...

#6. 差集（获取多个集合中不一样的数据）
sdiff set1 set2 ...

#7. 删除数据
srem key member [member ...]

#8. 查看当前的set集合中是否包含这个值
sismember key member

zset

#1. 添加数据(score必须是数值。member不允许重复的。)
zadd key score member [score member ...]

#2. 修改member的分数（如果member是存在于key中的，正常增加分数，如果memeber不存在，这个命令就相当于zadd）
zincrby key increment member

#3. 查看指定的member的分数
zscore key member

#4. 获取zset中数据的数量
zcard key

#5. 根据score的范围查询member数量
zcount key min max

#6. 删除zset中的成员
zrem key member [member...]

#7. 根据分数从小到大排序，获取指定范围内的数据（withscores如果添加这个参数，那么会返回member对应的分数）
zrange key start stop [withscores]

#8. 根据分数从大到小排序，获取指定范围内的数据（withscores如果添加这个参数，那么会返回member对应的分数）
zrevrange key start stop [withscores]

#9. 根据分数的返回去获取member(withscores代表同时返回score，添加limit，就和MySQL中一样，如果不希望等于min或者max的值被查询出来可以采用 ‘(分数’ 相当于 < 但是不等于的方式，最大值和最小值使用+inf和-inf来标识)
zrangebyscore key min max [withscores] [limit offset count]

#10. 根据分数的返回去获取member(withscores代表同时返回score，添加limit，就和MySQL中一样)
zrangebyscore key max min [withscores] [limit offset count]

key

#1. 查看Redis中的全部的key（pattern：* ，xxx*，*xxx）
keys pattern

#2. 查看某一个key是否存在（1 - key存在，0 - key不存在）
exists key

#3. 删除key
del key [key ...]

#4. 设置key的生存时间，单位为秒，单位为毫秒,设置还能活多久
expire key second
pexpire key milliseconds

#5. 设置key的生存时间，单位为秒，单位为毫秒,设置能活到什么时间点
expireat key timestamp
pexpireat key milliseconds

#6. 查看key的剩余生存时间,单位为秒，单位为毫秒（-2 - 当前key不存在，-1 - 当前key没有设置生存时间，具体剩余的生存时间）
ttl key
pttl key

#7. 移除key的生存时间（1 - 移除成功，0 - key不存在生存时间，key不存在）
persist key

#8. 选择操作的库
select 0~15

#9. 移动key到另外一个库中
move key db

db

#1. 清空当前所在的数据库
flushdb

#2. 清空全部数据库
flushall

#3. 查看当前数据库中有多少个key
dbsize

#4. 查看最后一次操作的时间
lastsave

#5. 实时监控Redis服务接收到的命令
monitor

Kotak

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫