Redis使用(一)

最新推荐文章于 2024-09-11 07:56:57 发布

luoyuOvO

最新推荐文章于 2024-09-11 07:56:57 发布

阅读量247

点赞数 2

分类专栏： Java

本文链接：https://blog.csdn.net/qq_21751781/article/details/84938373

版权

Java 专栏收录该内容

16 篇文章 0 订阅

订阅专栏

Redis使用

安装Redis
Redis官网下载地址：http://redis.io/download
下载相应版本的Redis，在运行中输入cmd，然后把目录指向解压的Redis目录。目前官网好像不支持Windows，github
下载地址：https://github.com/MSOpenTech/redis/releases
启动redis
打开一个 cmd 窗口使用cd命令切换目录到 C:\redis 运行 redis-server.exe redis.windows.conf ，
如果想方便的话
新建一个txt，内容为redis-server.exe redis.windows.conf，后缀名改为.bat，双击运行，出现如下界面代表安装成功
设置后台运行:进入 DOS窗口,在进入Redis的安装目录
输入：redis-server --service-install redis.windows.conf --loglevel verbose ( 安装redis服务 )
输入：redis-server --service-start ( 启动服务 )
输入：redis-server --service-stop
（停止服务）
启动指定的配置文件redis-server
–service-start redis.windows-service.conf
远程访问被拒绝：使用redis-cli -h ip -p port无法连接。查了以后发现是redis配置问题。
首先，停止redis服务。
然后，修改redis.conf文件，将其中的bind 127.0.0.1注释掉，同时将protected-mode yes改为no。
最后，重启redis。
redis简介
redis是nosql数据缓存数据库，可以减少数据库访问的压力，提高运行效率，常见使用（Session共享，token生成，分布式锁，自增id，验证码等），支持的5种数据类型有String ,set,zset,list,has.
数据的缓存有java缓存技术（oscache，ehcache），缺点：内存溢出，没有持久化，线程安全，多服务器数据不能共享等
oscache是mybatis二级缓存技术，主要针对数据库访问层，
ehcache是hibernate二级缓存技术，主要是针对jsp界面缓存技术
reids配置在redis.windows.conf文件中配置
密码：requirepass 123456
主从复制实现：在redis集群下，如果主机宕机，会重新选取主机（一主master多从slave，只有主机才可以读写，从机只能读取），当全部机器都宕机，先是使用keepalived尝试重庆主机，当尝试失败后发送警告邮件通知！从机启动自动复制主机的快照文件（实时的）
注意：使用root账号，关闭所有防火墙
配置：
slaveof ------------> slaveof 127.0.0.1 6379
masterauth ------------> masterauth 123456
哨兵配置：在sentinel.conf中（没有则创建）

#当前Sentinel服务运行的端口
port 26379
#master
#Sentinel去监视一个名为mymaster的主redis实例，这个主实例的IP地址为本机地址127.0.0.1，端口号为6379，
#而将这个主实例判断为失效至少需要2个 Sentinel进程的同意，只要同意Sentinel的数量不达标，自动failover就不会执行
sentinel monitor master 127.0.0.1 6381 1
#sentinel auth-pass master 123456
#指定了Sentinel认为Redis实例已经失效所需的毫秒数。当 实例超过该时间没有返回PING，或者直接返回错误，那么Sentinel将这个实例标记为主观下线。
#只有一个 Sentinel进程将实例标记为主观下线并不一定会引起实例的自动故障迁移：只有在足够数量的Sentinel都将一个实例标记为主观下线之后，实例才会被标记为客观下线，这时自动故障迁移才会执行
sentinel down-after-milliseconds master 30
#指定了在执行故障转移时，最多可以有多少个从Redis实例在同步新的主实例，在从Redis实例较多的情况下这个数字越小，同步的时间越长，完成故障转移所需的时间就越长
sentinel config-epoch master 12
#如果在该时间（ms）内未能完成failover操作，则认为该failover失败
sentinel leader-epoch master 13

启动哨兵 redis-server.exe sentinel.conf --sentinel

springboot整合redis
添加依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
    <version>2.1.1.RELEASE</version>
</dependency>

配置文件

spring:
redis:
  database: 0
  host: 127.0.0.1
  port: 6379
  password: 123456
  jedis:
    pool:
      max-idle: 8
      min-idle: 0
      max-active: 8
      max-wait: -1ms
  timeout: 5000ms

redis操作5种基本数据类型

在这里插入代码片

redis 保存对象
在spring boot环境下有个StringRedisTemplate对象，默认已经为我们配置好了，只需要自动注入过来就能用，但是使用它只能在Redis中存放字符串因为在StringRedisTemplate的构造器中，设置的序列化器是字符串，所以它只能存取字符串。现在，如果我们想使用RedisTemplate存取对象，那我们只需要设置相应的序列化器就行了。

保存对象要序列号

 public class User  implements Serializable

配置

@Configuration
public class RedisConfig {

    @Bean
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<Object, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        // 使用Jackson2JsonRedisSerialize 替换默认序列化
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer =
                new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(objectMapper);
        // 设置value的序列化规则和 key的序列化规则
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }
}

@Autowired
private RedisTemplate<Object, Object> redisTemplate;

public void setObject(String key, Object value) {
    if (StringUtils.isEmpty(key) || value == null) {
        return;
    }
    redisTemplate.opsForValue().set(key, value);
}

public Object getObject(String key) {
    return redisTemplate.opsForValue().get(key);
}

测试代码

@RequestMapping("/redis")
public User redis() {
    User user = new User()
            .setName("zy")
            .setPassword("123")
            .setId(1L);
    redisUtil.setObject("user", user);
    return (User) redisUtil.getObject("user");
}

下面是完整的工具类（有的不全）


import org.apache.commons.lang.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

@Component
public class RedisUtil {

    @Autowired
    private StringRedisTemplate stringRedisTemplate;
    @Autowired
    private RedisTemplate<Object, Object> redisTemplate;

    public void setObject(String key, Object value) {
        if (StringUtils.isEmpty(key) || value == null) {
            return;
        }
        redisTemplate.opsForValue().set(key, value);
    }

    public Object getObject(String key) {
        return redisTemplate.opsForValue().get(key);
    }

    public void setZSet(String key, Map<String, Double> value) {
        if (StringUtils.isEmpty(key) || value == null) {
            return;
        }
        HashMap<String, Double> mapvalue = (HashMap) value;
        for (String hashkey : mapvalue.keySet()) {
            stringRedisTemplate.opsForZSet().add(key, hashkey, mapvalue.get(hashkey));
        }
    }

    public void setMap(String key, Map<String, String> value) {
        if (StringUtils.isEmpty(key) || value == null) {
            return;
        }
        HashMap<String, String> mapvalue = (HashMap) value;
        for (String hashkey : mapvalue.keySet()) {
            stringRedisTemplate.opsForHash().put(key, hashkey, mapvalue.get(hashkey));
        }
    }

    public void setList(String key, List<String> value, Boolean sethead) {
        if (StringUtils.isEmpty(key) || value == null) {
            return;
        }
        List<String> listValue = (List<String>) value;
        if (sethead) {
            for (String string : listValue) {
                stringRedisTemplate.opsForList().leftPush(key, string);
            }
        } else {
            for (String string : listValue) {
                stringRedisTemplate.opsForList().rightPush(key, string);
            }
        }
    }

    public void setSet(String key, Set<String> value) {
        if (StringUtils.isEmpty(key) || value == null) {
            return;
        }
        Set<String> setvalue = (Set<String>) value;
        for (String set : setvalue) {
            stringRedisTemplate.opsForSet().add(key, set);
        }
    }

    public void setString(String key, String value) {
        setString(key, value, null);
    }

    public void setString(String key, String value, Long time) {
        if (StringUtils.isEmpty(key) || value == null) {
            return;
        }
        String stringValue = (String) value;
        if (time == null) {
            stringRedisTemplate.opsForValue().set(key, stringValue);
        } else {
            stringRedisTemplate.opsForValue().set(key, stringValue, time, TimeUnit.SECONDS);
        }
    }

    //根据key获取list集合
    public List<String> getList(String key) {
        return stringRedisTemplate.opsForList().range(key, 0, getListSize(key));
    }

    //根据key查找list中元素，并且删除
    //count位置value值，值相等才能删除
    public void getListRemove(String key, Long count, String value) {
        stringRedisTemplate.opsForList().remove(key, count, value);
    }

    //根据key在list元素中index更改value
    public void getListAdd(String key, Long index, String value) {
        stringRedisTemplate.opsForList().set(key, index, value);
    }

    //获取list大小
    public Long getListSize(String key) {
        return stringRedisTemplate.opsForList().size(key);
    }

    //根据key获取字符串
    public String getString(String key) {
        return stringRedisTemplate.opsForValue().get(key);
    }

    //根据key获取过期时间
    public Long getExpire(String key) {
        return stringRedisTemplate.getExpire(key);
    }

    //根据key获取过期时间并换算成指定单位
    public Long getSECONDS(String key) {
        return stringRedisTemplate.getExpire(key, TimeUnit.SECONDS);
    }

    //根据key删除缓存
    public void deletekey(String key) {
        stringRedisTemplate.delete(key);
    }

    //检查key是否存在，返回boolean值
    public boolean getkey(String key) {
        return stringRedisTemplate.hasKey(key);
    }

    //设置过期时间
    public void setexpire(String key, Long time) {
        stringRedisTemplate.expire(key, time, TimeUnit.SECONDS);
    }

    //根据key查看集合中是否存在指定数据
    public boolean getSetExist(String key, String value) {
        return stringRedisTemplate.opsForSet().isMember(key, value);
    }

    //根据key获取set集合
    public Set<String> getSet(String key) {
        return stringRedisTemplate.opsForSet().members(key);
    }


}

java的reids使用，不使用任何框架

package gwgis;

import java.util.List;
import java.util.Map;

import redis.clients.jedis.Jedis;

public class RedisUtil {

	private static RedisUtil redisUtil = new RedisUtil();
	private Jedis jedis = new Jedis("127.0.0.1");

	private RedisUtil() {
		jedis.auth("123456");
		System.out.println("连接成功");
	}

	public static  RedisUtil intance() {
		return redisUtil;
	}

	public static void main(String[] args) {
		redisUtil.intance().getMap("TD");
	}

	public void setMap(String key, Map<String, String> map) {
		jedis.hmset(key, map);
	}

	public void getMap(String map) {
		Map<String, String> hgetAll = jedis.hgetAll(map);
		System.out.println(hgetAll.toString());

	}

	public void getMapOne(String map, String key) {
		List<String> mget = jedis.hmget(map, key);
		for (String value : mget) {
			System.out.println(value);
		}
	}

	public void close() {
		jedis.close();
	}
}