redis03：Java中的操作

准备工作

创建工程

创建maven父工程，例如03-sca-redis,并在此工程下创建两个子工程，一个为sca-jedis,一个为sca-tempate,例如：

添加项目依赖

sca-jedis 工程依赖

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

<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
    <scope>test</scope>
</dependency>

<dependency>
    <groupId>com.google.code.gson</groupId>
    <artifactId>gson</artifactId>
    <version>2.8.6</version>
</dependency>

准备工作
第一步:从redis.io官方下载对应版本的redis.conf文件,地址如下(假如下载不下来从code上去取或者从同学那拿):

https://redis.io/topics/config/

第二步:停止redis并删除挂载目录下(/usr/local/docker/redis01/conf)的redis.conf配置文件.
第三步:将下载的redis.conf文件拷贝到redis挂载目录(/usr/local/docker/redis01/conf)
第四步:基于vim打开redis.conf文件,然后注释 bind 127.0.0.1这一行,并修改protected-mode的值修改为no.
第五步:重启redis服务,并检查启动日志(docker logs 容器id)

快速入门实现

在Jedis工程中定义单元测试类，在类中定义单元测试方法：

基础类型操作

在项目的src/test/java目录创建单元测类

package com.jt;


import com.google.gson.Gson;
import org.junit.Test;
import redis.clients.jedis.Jedis;

import java.util.*;


public class JedosTests {
    //1.建立连接
    private Jedis jedis = new Jedis("192.168.126.129",6379);

    @Test
    public void testSetPoer01(){
        Set<String> set1;
        //增
        jedis.sadd("set1", "A","B","C","D","A","E");
        //查
        set1 = jedis.smembers("set1");
        System.out.println(set1);

        Long setcard = jedis.scard("set1");
        System.out.println(setcard);
        //改
        //删
        jedis.spop("set1");
        set1 = jedis.smembers("set1");
        System.out.println(set1);
        jedis.srem("set1", "B");
        set1 = jedis.smembers("set1");
        System.out.println(set1);
    }
    @Test
    public void testListOper(){
        List<String> list;

        //增
        jedis.lpush("lst1", "A","B","C","D","E","F");

        //查
        list =  jedis.lrange("lst1", 0, -1);
        System.out.println(list);

        //改
        /**新**/
        Long index = jedis.lpos("lst1", "A");
        jedis.lset("lst1", index, "AA");
        list =  jedis.lrange("lst1", 0, -1);
        System.out.println(list);

        //长度
        Long llen = jedis.llen("lst1");
        System.out.println(llen);
        jedis.lrem("lst1", 1, "AA");
        //删
        llen = jedis.llen("lst1");
        System.out.println(llen);
        list =  jedis.lrange("lst1", 0, -1);
        System.out.println(list);
        //阻塞方式取数据
        jedis.brpop(5,"lst1");
        jedis.brpop(5,"lst1");
        jedis.brpop(5,"lst1");
        jedis.brpop(5,"lst1");

        list =  jedis.lrange("lst1", 0, -1);
        System.out.println(list);
        jedis.brpop(5,"lst1");
        list =  jedis.lrange("lst1", 0, -1);
        System.out.println(list);
        jedis.brpop(5,"lst1");

        jedis.flushDB();
        jedis.close();
    }


    @Test
    public void testHashOper(){
        String id;
        String name;
        Jedis jedis = new Jedis("192.168.126.129",6379);
        //增
        jedis.hset("user", "id","10");
        id = jedis.hget("user", "id");
        System.out.println(id);
        jedis.hset("user", "name","jack");
        //改
        jedis.hset("user", "id","20");
        //查
        id = jedis.hget("user", "id");
        System.out.println(id);
        Map<String,String> user = jedis.hgetAll("user");
        user.get(id);
        System.out.println(user);
        //释放资源
        jedis.close();
    }

    /*直接存储map对象*/
    @Test
    public void testHashOper1(){
        Map<String,String > map = new HashMap<>();
        map.put("id", "10");
        map.put("name", "sayhi");
        jedis.hset("user", map);
        map.clear();
        map = jedis.hgetAll("user");
        System.out.println(map);
        jedis.flushDB();
        jedis.close();
    }


    /**
     * 将对象转换成字符串，根据字符串的类型转换成redis
     * */
    @Test
    public void testStingJsonOper(){
        Map<String,Object> map = new HashMap<>();
        map.put("id", "10");
        map.put("name", "sayhi");
        Gson gson = new Gson();
        String jsonStr = gson.toJson(map);
        jedis.set("member",jsonStr);
        String member = jedis.get("member");
        System.out.println(member);
        map = gson.fromJson(member, Map.class);
        System.out.println(map);
        System.out.println(map.get("name"));
    }



    @Test
    public void testStingOper() throws InterruptedException {
         String name;
         String id;
         String token;
        //2.存储数据
        jedis.set("id", "10");
        jedis.set("token", UUID.randomUUID().toString());
        jedis.expire("token", 2);
        //3.更新数据
        jedis.set("id", "20");
        jedis.incr("id");
        id = jedis.get("id");
        System.out.println(id);

        jedis.incrBy("id",2);
        id = jedis.get("id");
        System.out.println(id);

        jedis.decr("id");
        id = jedis.get("id");
        System.out.println(id);

        jedis.decrBy("id",2);
        id = jedis.get("id");
        System.out.println(id);
        //4.读取数据
        id = jedis.get("id");
        token = jedis.get("token");
        System.out.println(id+" "+token);

        Thread.sleep(2000);
        id = jedis.get("id");
        token = jedis.get("token");
        System.out.println(id+" "+token);
        //5.删除数据
        jedis.set("name", "sayhi");
        name = jedis.get("name");
        System.out.println(name);

        jedis.del("name");
        name = jedis.get("name");
        System.out.println(name);
        //6.清楚数据，释放资源
        jedis.flushDB();
        jedis.close();
    }

    @Test
    public void test(){

        String ping = jedis.ping();
        System.out.println(ping);//pong
    }
}

连接池JedisPool应用

我们直接基于Jedis访问redis时，每次获取连接，释放连接会带来很大的性能开销，可以借助Jedis连接池，重用创建好的连接，来提高其性能

public class JedisPoolTests {
    @Test
   public void testJedisPool(){
        //定义连接池的配置
        JedisPoolConfig config=new JedisPoolConfig();
        config.setMaxTotal(1000);//最大连接数
        config.setMaxIdle(60);//最大空闲时间(连接不用了要释放)
        //创建连接池
        JedisPool jedisPool=
        new JedisPool(config,"192.168.126.130",6379);
        //从池中获取一个连接
        Jedis resource = jedisPool.getResource();
        resource.auth("123456");
        //通过jedis连接存取数据
        resource.set("class","cgb2004");
        String clazz=resource.get("class");
        System.out.println(clazz);
        //将链接返回池中
        resource.close();
        //关闭连接池
        jedisPool.close();
    }
}

我们可以基于池对象，设计一个数据源，将来在业务中通过一个数据源对象，从池中获取连接，不用每次获取连接都要创建池对象

/**
 * 构建一个Jedis数据源，基于此数据源可以从一个Jedis池中
 * 获取连接(Jedis)，进而操作redis数据库。
 */
public class JedisDataSource {
    private static final JedisPool jedisPool;
    private static final String HOST="192.168.126.129";
    private static final int PORT=6379;
    static{
        JedisPoolConfig config=new JedisPoolConfig();
        config.setMaxTotal(16);//最大连接数，默认为8
        config.setMaxIdle(60);
        jedisPool=new JedisPool(config,HOST,PORT);
    }
    /**
     * 获取一个连接对象，后续需要jedis连接时，可以通过此方法直接从池中获取。
     * @return
     */
    public static Jedis getConnection(){
        return jedisPool.getResource();
    }

    /**
     * 提供一个外界可以获取池的方法，
     * 假如外界要关闭池，首先要获取此池对象。
     * @return
     */
    public static JedisPool getJedisPool() {
        return jedisPool;
    }
}

RedisTemplate应用

简介

RedisTemplate为SpringBoot工程中操作redis数据库的一个Java对象，此对象封装了对redis的一些基本操作。

准备工作

第一步：创建工程配置文件application.yml,其内容如下：

spring:
  redis:
    host: 192.168.64.129  #写自己的ip
    port: 6379

第二步：创建工程启动类

@SpringBootApplication
public class RedisApplication {
    public static void main(String[] args) {
        SpringApplication.run(RedisApplication.class,args);
    }
}

快速入门实现

StringRedisTemplate 应用

StringRedisTemplate 是一个专门用于操作redis字符串类型数据的一个对象

@SpringBootTest
public class StringRedisTemplateTests {
    /**
     * 此对象为操作redis的一个客户端对象,这个对象
     * 对key/value采用了字符串的序列化(StringRedisSerializer)
     * 方式进行,redis数据的读写操作.
     */
    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    @Test
    void testHashOper01(){
       //1.获取hash操作的对象
        HashOperations<String, Object, Object> vo =stringRedisTemplate.opsForHash();
       //2.读写redis数据
       //2.1存储一个对象
       vo.put("user", "id", "100");
       vo.put("user", "username", "tony");
       vo.put("user", "status", "1");
       //2.2获取一个对象
       //2.2.1获取对象某个属性值
       Object status =vo.get("user","status");
       System.out.println(status);
        //2.2.2获取对象某个key对应的所有值
       List<Object> user = vo.values("user");
       System.out.println(user);
    }
    @Test
    void testStringOper02() throws JsonProcessingException {
        //1.获取字符串操作对象(ValueOperations)
        ValueOperations<String, String> vo =
                stringRedisTemplate.opsForValue();
        //2.读写redis中的数据
        Map<String,String> map=new HashMap<>();
        map.put("id","100");
        map.put("title","StringRedisTemplate");
        //将map对象转换为json字符串写到redis数据库
        String jsonStr=//jackson (spring-boot-starter-web依赖中自带)
        new ObjectMapper().writeValueAsString(map);
        vo.set("blog", jsonStr);
        jsonStr=vo.get("blog");
        System.out.println(jsonStr);
        //将json字符串转换为map对象
        map=
        new ObjectMapper().readValue(jsonStr, Map.class);
        System.out.println(map);
    }
    @Test
    void testStringOper01(){
        //1.获取字符串操作对象(ValueOperations)
        ValueOperations<String, String> vo =
                stringRedisTemplate.opsForValue();
        //2.读写redis中的数据
        vo.set("x", "100");
        vo.increment("x");
        vo.set("y", "200", 1, TimeUnit.SECONDS);
        String x = vo.get("x");
        String y = vo.get("y");
        System.out.println("x="+x+",y="+y);
    }
    @Test
    void testGetConnection(){
        RedisConnection connection =
                stringRedisTemplate.getConnectionFactory()
                        .getConnection();
        String ping = connection.ping();
        System.out.println(ping);
    }
}

RedisTemplate 应用

RedisTemplate是一个专门用于实现对远端redis中复杂数据的操作的对应

@SpringBootTest
public class RedisTemplateTests {
    //这个对象在springboot工程的RedisAutoConfiguration类中已经做了配置
    //此对象在基于redis存取数据时默认采用的JDK的序列化方式
    @Autowired
    private RedisTemplate redisTemplate;

    /**
     * 测试字符串数据的存取
     */
    @Test
    void testStringOper01(){
        //自己指定key/value序列化方式
        //redisTemplate.setKeySerializer(new StringRedisSerializer());
        //redisTemplate.setValueSerializer(new StringRedisSerializer());
        ValueOperations vo = redisTemplate.opsForValue();
        //key和value默认会采用JDK的序列化方式进行存储
        vo.set("token", UUID.randomUUID().toString());
        Object token = vo.get("token");
        System.out.println(token);
    }

    @Test
    void testSetData(){
        SetOperations setOperations=redisTemplate.opsForSet();
        setOperations.add("setKey1", "A","B","C","C");
        Object members=setOperations.members("setKey1");
        System.out.println("setKeys="+members);
        //........
    }

    @Test
    void testListData(){
      //向list集合放数据
        ListOperations listOperations = redisTemplate.opsForList();
        listOperations.leftPush("lstKey1", "100"); //lpush
        listOperations.leftPushAll("lstKey1", "200","300");
        listOperations.leftPush("lstKey1", "100", "105");
        listOperations.rightPush("lstKey1", "700");
        Object value= listOperations.range("lstKey1", 0, -1);
        System.out.println(value);
      //从list集合取数据
        Object v1=listOperations.leftPop("lstKey1");//lpop
        System.out.println("left.pop.0="+v1);
        value= listOperations.range("lstKey1", 0, -1);
        System.out.println(value);
    }

    /**通过此方法操作redis中的hash数据*/
    @Test
    void testHashData(){
        HashOperations hashOperations = redisTemplate.opsForHash();//hash
        Map<String,String> blog=new HashMap<>();
        blog.put("id", "1");
        blog.put("title", "hello redis");
        hashOperations.putAll("blog", blog);
        hashOperations.put("blog", "content", "redis is very good");
        Object hv=hashOperations.get("blog","id");
        System.out.println(hv);
        Object entries=hashOperations.entries("blog");
        System.out.println("entries="+entries);
    }

   @Test
    void testFlushdb(){
        redisTemplate.execute(new RedisCallback() {
            @Override
            public Object doInRedis(RedisConnection redisConnection) throws DataAccessException {
               //redisConnection.flushDb();
                redisConnection.flushAll();
                return "flush ok";
            }
        });
    }

}

定制RedisTemplate对象(拓展)

对于系统默认的RedisTemplate默认采用的是JDK的序列化机制，假如我们不希望实用JDK的序列化，可以采用的定制RedisTemplate，并采用自己指定的的序列化方式

@Configuration
public class RedisConfig {
    @Bean
    public RedisTemplate<Object,Object> redisTemplate(RedisConnectionFactory redisConnectionFactory){
        //1.构建RedisTemplate对象
        RedisTemplate<Object,Object> redisTemplate=new RedisTemplate<>();
        //2.设置连接工厂
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        //3.定义序列化方式(在这里选择jackson)
        Jackson2JsonRedisSerializer redisSerializer= new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper objectMapper=new ObjectMapper();
        //设置要序列化的域(属性)
        //any表示任意级别访问修饰符修饰的属性 private,public,protected
        objectMapper.setVisibility(PropertyAccessor.ALL,JsonAutoDetect.Visibility.ANY);
        //启动输入域检查(类不能是final修饰的)
        objectMapper.activateDefaultTyping(objectMapper.getPolymorphicTypeValidator(),
                ObjectMapper.DefaultTyping.NON_FINAL,
                JsonTypeInfo.As.PROPERTY);
        redisSerializer.setObjectMapper(objectMapper);
        //4.设置RedisTemplate的序列化
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(redisSerializer);
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashValueSerializer(redisSerializer);
        //spring规范中假如修改bean对象的默认特性,建议调用一下afterPropertiesSet()
        redisTemplate.afterPropertiesSet();
       return redisTemplate;
    }
}

创建Blog对象,然后基于RedisTemplate进行序列化实践,Blog代码如下

@Data
public class Blog implements Serializable {//{"id":10,"title":"redis"}
    private static final long serialVersionUID = -6721670401642138021L;
    private Integer id;
    private String title;
    public Blog(){
        System.out.println("Blog()");
    }

}

在RedisTemplateTests类中添加如下单元测试方法,进行测试

@Test
void testJsonOper() throws JsonProcessingException {
    ValueOperations valueOperations = redisTemplate.opsForValue();
    Blog blog=new Blog(10,"study redis");
    valueOperations.set("blog",blog);//序列化
    blog=(Blog)valueOperations.get("blog");//反序列化
    System.out.println("blog="+blog);
}

项目工程实践

分布式id

业务描述

在分布式系统中，数据量将越来越大时，就需要对数据进行分表操作,但是,分表后，每个表中的数据都会按自己的节奏进行自增，很有可能出现ID冲突。这时就需要一个单独的机制来负责生成唯一ID，生成出来的ID也可以叫做 分布式ID，这里我们借助redis实现一个简易的分布式id进行实现,当然还有一些第三方的系统,可以帮你生成这样的id,可以自己进行拓展学习.

/**
 * 需求:生成一个分布递增的id
 * 多张表基于这个方法中生成的id作为主键id值(分布式环境不会采用数据库
 * 表中自带的自增策略-auto_increment)
 */
public class IdGeneratorDemo01 {
    public static Long getId(){
          Jedis jedis=new Jedis("192.168.126.130",6379);
          jedis.auth("123456");
          Long id = jedis.incr("id");
          jedis.close();
          return id;
    }
    public static void main(String[] args) {
         for(int i=0;i<10;i++) {
              new Thread(){
                  @Override
                  public void run() {
                      String tName=Thread.currentThread().getName();
                      System.out.println(tName+"->"+
                              IdGeneratorDemo01.getId());
                  }
              }.start();
          }

    }
}

单点登陆

业务描述

在分布式系统中,通过会有多个服务,我们登录了一个服务以后,再访问其它服务时,不想再登录,就需要有一套单独的认证系统,我们通常会称之为单点登录系统,在这套系统中提供一个认证服务器,服务完成用户身份认证,在一些中小型分布式系统中中,我们通常会借助redis存储用户的认证信息

package com.jt.demos;

import redis.clients.jedis.Jedis;

import java.util.UUID;

/**
 * 单点登录应用实践
 */
public class SSODemo01 {
    static String token;
    //模仿访问服务端的资源
    static void doGetResource(){
        //1.检查token是否存在,(token是存储在客户端-Cookie,localStorage)
        if(token==null){
            System.out.println("please login");
            return;
        }
        //2.检查token是否已经失效
        Jedis jedis=new Jedis("192.168.126.130",6379);
        String user = jedis.get(token);
        jedis.close();
        if(user==null){
            System.out.println("login timeout or token invalid");
            return;
        }
        //3.返回你要访问的资源
        System.out.println("return user resource");
    }
    static void doLogin(String username,String password){
        if("jack".equals(username)&&"123456".equals(password)){
            System.out.println("login ok");
            String token= UUID.randomUUID().toString();
            Jedis jedis=new Jedis("192.168.126.130",6379);
            jedis.set(token,username);//存储用户信息
            jedis.expire(token,1);
            jedis.close();
            //将token存储到客户端
            SSODemo01.token=token;
            return;
        }
        System.out.println("username or password error");
    }
    public static void main(String[] args) throws InterruptedException {//这里的main方法代表客户端
        //1.访问资源
        doGetResource();
        //2.执行登录操作
        doLogin("jack","123456");
        //3.再次访问资源
        Thread.sleep(1000);
        doGetResource();
    }
}

 

秒杀队列

业务描述

在设计一个秒杀或抢购系统时,为了提高系统的响应速度,通常会将用户的秒杀或抢购请求先存储到一个redis队列,这里我们就基于redis实现一个先进先出队列

 关键代码实现

package com.jt.demos;

import redis.clients.jedis.Jedis;

//秒杀队列演示
//描述逻辑中会将商品抢购信息先写到redis(以队列形式进行存储),
//因为写redis内存数据库要比写你的mysql数据库快很多倍
//算法:先进先出(FIFO)-体现公平性
public class SecondKillDemo01 {

    //商品抢购首先是入队
    static void enque(String msg){//入队
         Jedis jedis=new Jedis("192.168.126.130",6379);
         jedis.auth("123456");//没有认证不需要写这个语句
         jedis.lpush("queue",msg);
         jedis.close();
    }

    //底层异步出队(基于这个消息,生成订单,扣减库存,...)
    static String deque(){//出队
        Jedis jedis=new Jedis("192.168.126.130",6379);
        jedis.auth("123456");//没有认证不需要写这个语句
        String result=jedis.rpop("queue");
        jedis.close();
        return result;
    }
    public static void main(String[] args){
        //1.多次抢购(模拟在界面上多次点击操作)
        new Thread(){
            @Override
            public void run() {
                for(int i=1;i<=10;i++){//模拟页面上按钮点击
                    enque(String.valueOf(i));
                    try{Thread.sleep(100);}catch(Exception e){}
                }
            }
        }.start();

        //2.从队列取内容(模拟后台从队列取数据)
        new Thread(){
            @Override
            public void run() {
                for(;;){
                    String msg=deque();
                    if(msg==null)continue;
                    System.out.print(msg);
                }
            }
        }.start();

    }
}

投票系统

业务描述

在很多系统中设计中,都会有一个活动设计,开启一个活动之前,可以对这个活动的支持力度先进行一个调查,例如基于这个活动设计一个投票系统

 

/**
 * 投票系统演示:模拟基于某个活动的投票程序
 * 业务说明:一个用户只能投票一次(不允许重复)
 * 数据结构设计:基于redis的set类型进行数据存储
 */
public class VoteDemo01 {
    private static Jedis jedis=
            new Jedis("192.168.126.130",6379);
    static{
        jedis.auth("123456");
    }
    //进行投票(key为活动id,value为userId)
    static void vote(String activityId,String userId){
         jedis.sadd(activityId,userId);
    }
    //查看投票次数
    static Long getVoteCount(String activityId){
        Long count = jedis.scard(activityId);
        return count;
    }
    //查看这个活动被哪写用户投过票
    static Set<String> getVoteUsers(String activityId){
        Set<String> smembers = jedis.smembers(activityId);
        return smembers;
    }
    //检查这个用户是否已对这个活动投过票
    static Boolean checkVote(String activityId,String userId){
        Boolean flag = jedis.sismember(activityId, userId);
        return flag;
    }

    public static void main(String[] args) {
        //0.初始化
        String activityId="10001";
        String user1="201";
        String user2="202";
        String user3="203";
        //1.投票
        vote(activityId,user1);
        vote(activityId,user2);
        vote(activityId,user3);
        //2.获取投票次数
        Long voteCount = getVoteCount(activityId);
        System.out.println("投票次数:"+voteCount);
        //3.输出哪些人投过票
        Set<String> users=getVoteUsers(activityId);
        System.out.println(users);
        //4.检查用户是否投过票
        boolean flag=checkVote(activityId,user1);
        System.out.println(user1+":"+(flag?"已投过票":"还没投票"));
    }
}

购物车简易实现

业务描述

 

package com.jt.demos;

import redis.clients.jedis.Jedis;

import java.util.Map;

/**
 * 作业:基于redis存储商品购物车信息
 */
public class CartDemo01 {

    public static void addCart(Long userId,Long productId,int num){
        //1.建立redis链接
        Jedis jedis=new Jedis("192.168.126.130",6379);
        jedis.auth("123456");
        //2.向购物车添加商品
        //hincrBy这个函数在key不存在时会自动创建key
        jedis.hincrBy("cart:" + userId, String.valueOf(productId),num);
        //3.释放redis链接
        jedis.close();
    }
    //查看我的购物车
    public static Map<String, String> listCart(Long userId){
        //1.建立redis链接
        Jedis jedis=new Jedis("192.168.126.130",6379);
        jedis.auth("123456");
        //2.查看购物车商品
        Map<String, String> map = jedis.hgetAll("cart:" + userId);
        //3.释放redis链接
        jedis.close();
        return map;
    }
    public static void main(String[] args) {
        //1.向购物车添加商品
        addCart(101L,201L,1);
        addCart(101L,202L,1);
        addCart(101L,203L,2);
        //2.查看购物车商品
        Map<String, String> map = listCart(101L);
        System.out.println(map);
    }
}