2--Java中操作redis实践230409

Redis 客户端

概述

Redis 是一种C/S 架构的分布式缓存数据库，它有自带的命令行客户端，也有对应的Java或其它语言客户端，可以在这些客户端中通过一些API对redis进行读写操作。

准备工作

第一步：创建工程。

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

第二步：添加父工程依赖

修改父工程pom.xml文件，添加编译配置

<build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <source>8</source>
                    <target>8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>

Jedis的基本应用

简介

Jedis是Java中操作redis的一个客户端，类似通过jdbc访问mysql数据库。

准备工作

在redis-jedis 工程添加如下依赖

<dependencies>
 <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>
</dependencies>

Jeids基本应用实践

在Jedis工程中的src/test/java目录创建单元测类,例如:

package com.jt;

import org.junit.Test;
import redis.clients.jedis.Jedis;

import java.util.concurrent.TimeUnit;

public class JedisTests {
    /**
     * 测试是否可以连通redis。
     */
    @Test
     public void testGetConnection(){
            Jedis jedis=new Jedis("192.168.126.129",6379);
            String result = jedis.ping();
            System.out.println(result);
     }
   
    /**
     * 测试字符串操作
     */
    @Test
    public void testStringOper01(){
         //1.建立连接
         Jedis jedis=new Jedis("192.168.126.129",6379);
         //2.执行redis数据操作(增删改查)
         //2.1新增数据
         jedis.set("id", "100");
         jedis.set("name", "tony");
         //2.2修改数据
         jedis.incr("id");
         jedis.incrBy("id", 100);//201
         jedis.set("name", "Mike");//Mike
         //2.3查询数据
         String id = jedis.get("id");
         String name = jedis.get("name");
         System.out.println("id="+id+";name="+name);
         //2.4删除数据
         jedis.del("name");
         //3.释放资源
         jedis.close();
    }
    /**
     * 测试字符串操作
     */
    @Test
    public void testStringOper02(){
        //1.建立连接
        Jedis jedis=new Jedis("192.168.126.129",6379);
        //2.数据操作(将一个map对象转换为json字符串，然后写入到redis)
        //2.1构建map对象
        Map<String,String> map=new HashMap<>();
        map.put("id", "100");
        map.put("name", "Mike");
        //2.2将map转换为字符串
        Gson gson=new Gson();
        String jsonStr = gson.toJson(map);
        //2.3将字符串写入到redis
        String key= UUID.randomUUID().toString();
        jedis.set(key, jsonStr);
        //3.释放资源
        jedis.close();
    }
   /**
     * 课堂练习：
     * 基于hash类型将testStringOper02中对象写入到redis，
     * 并且尝试进行查询，修改，删除等操作。
     */
    @Test
    public void testHash01(){
        //1.建立连接
        Jedis jedis=new Jedis("192.168.126.129",6379);
        //2.执行hash数据操作
        //2.1新增数据
        String key= UUID.randomUUID().toString();
        jedis.hset(key, "id", "500");
        jedis.hset(key, "name", "Jack");
        //2.2修改数据数据
        jedis.hset(key, "name", "Jim");
        //2.3查询数据
        Map<String, String> map = jedis.hgetAll(key);
        System.out.println(map);
        //2.4删除数据
        //jedis.del(key);
        jedis.expire(key, 10);
        //3.释放资源
        jedis.close();
    }

   /**
     * 测试:redis中list结构的应用
     * 基于FIFO(First In First Out)算法,借助redis实现一个队列
     */
    @Test
    public void testListOper01(){
        //1.建立连接
        Jedis jedis=new Jedis("192.168.126.130",6379);
        //2.存储数据
        jedis.lpush("lst1","A","B","C","C");
        //3.更新数据
        Long pos=jedis.lpos("lst1","A");//获取A元素的位置
        jedis.lset("lst1",pos,"D");//将A元素位置的内容修改为D
        //4.获取数据
        int len=jedis.llen("lst1").intValue();//获取lst1列表中元素个数
        List<String> rpop = jedis.rpop("lst1",len);//获取lst1列表中所有元素
        System.out.println(rpop);
        //5.释放资源
        jedis.close();
    }



//list类型练习：实现一个阻塞式队列

@Test
public void testListOper02(){
    //1.连接redis
    Jedis jedis=new Jedis("192.168.126.128",6379);
    //2.向队列存数据
    //jedis.lpush("list1","A","B","C");
    //3.按先进先出的顺序从队列取数据
    List<String> list= jedis.brpop(40,"list1");
    System.out.println(list);
    jedis.brpop(40,"list1");
    jedis.brpop(40,"list1");
    jedis.brpop(40,"list1");
    //4.释放资源
    jedis.close();
}
//set类型练习
@Test
public void testSetOper01() {
    //1.连接redis
    Jedis jedis = new Jedis("192.168.126.128", 6379);
    //2.朋友圈点赞
    jedis.sadd("count", "1", "1", "2");
    //3.取出点赞数
    Set<String> set = jedis.smembers("count");
    System.out.println(set);
    //4.释放资源
    jedis.close();
}
}

连接池JedisPool连接池应用

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

package com.jt;

import org.junit.Test;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;


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();
    }
}

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

package com.jt.redis;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

public class JedisDataSource {

    private static final String IP="192.168.126.128";
    private static final int PORT=6379;//redis.conf 默认端口
    /**
     * volatile 关键通常用于修饰属性:
     * 1)保证线程其可见性(一个线程改了,其它CPU线程立刻可见)
     * 2)禁止指令重排序 
     * 3)不能保证其原子性(不保证线程安全)
     */
    private static volatile JedisPool jedisPool;
    //方案1:饿汉式池对象的创建
    /*static{
        JedisPoolConfig config=new JedisPoolConfig();
        config.setMaxTotal(16);
        config.setMaxIdle(8);
        jedisPool=new JedisPool(config,IP,PORT);
    }
    public static Jedis getConnection(){
        return jedisPool.getResource();
    }*/
    //方案2:懒汉式池对象的创建
    public static Jedis getConnection(){
        if(jedisPool==null) {
            synchronized (JedisDataSource.class) {
                if (jedisPool == null) {
                    JedisPoolConfig config = new JedisPoolConfig();
                    config.setMaxTotal(16);
                    config.setMaxIdle(8);
                    jedisPool = new JedisPool(config, IP, PORT);
                    //创建对象分析
                    //1.开辟内存空间
                    //2.执行属性的默认初始化
                    //3.执行构造方法
                    //4.将创建的对象的内存地址赋值给jedisPool变量
                    //假如使用了volatile修饰jedisPool变量,可以保证如上几个步骤是顺序执行的
                }
            }
        }
        return jedisPool.getResource();
    }
    public static void close(){
        jedisPool.close();
    }
}

RedisTemplate基本应用

简介

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

准备工作

第一步：添加在redis-template工程添加依赖

<dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>2.3.2.RELEASE</version>
                <scope>import</scope>
                <type>pom</type>
            </dependency>
        </dependencies>
    </dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

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

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

第三步：创建工程启动类，例如：

package com.jt;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

RedisTemplate对象应用实践

RedisTemplate是一个专门用于实现对远端redis数据进行操作的对象，默认会采用JDK序列化方式存取数据，应用案例如下：

package com.jt.redis;
@SpringBootTest
public class RedisTemplateTests {
    /**
     * 此对象为操作redis的一个模板对象,基于此对象进行数据存储时，
     * 数据会进行序列化，序列化方式默认为JDK自带的序列化机制。
     */
    @Autowired
    private RedisTemplate redisTemplate;
    
    /**测试是否能够连通redis*/
    @Test
    void testGetConnection(){
        RedisConnection connection =
            redisTemplate.getConnectionFactory()
                         .getConnection();
        String result = connection.ping();
        System.out.println(result);
    }

    @Test
    void testStringOper01(){
       //1.获取字符串操作对象(ValueOperations)
        ValueOperations vo = redisTemplate.opsForValue();
        //2.操作redis数据
        vo.set("x", 100);
        Object x = vo.get("x");
        System.out.println(x);
        //vo.increment("x");//不可以
        Long y = vo.increment("y");
        y=vo.increment("y");
        //Object y = vo.get("y");//不可以
        System.out.println(y);
        //存储key/value，设置key的有效期
        vo.set("z", "100", Duration.ofSeconds(10));
    }
    
    @Test
    void testStringOper02(){
        //1.获取字符串操作对象(ValueOperations)
        ValueOperations vo = redisTemplate.opsForValue();
        //2.按默认序列化方式存储数据
        String token= UUID.randomUUID().toString();
        vo.set(token,"admin");
        //3.指定序列方式进行数据存储
        redisTemplate.setKeySerializer(RedisSerializer.string());
        redisTemplate.setValueSerializer(RedisSerializer.string());
        vo.set(token,"Mike");
        //4.更新数据(假如有对应的key则直接进行覆盖)
        vo.set(token, "Jack");
        Object value = vo.get(token);
        System.out.println(value);
        //5.删除数据(存数据时给定有效期-生产环境必须设置)
        vo.set("permissions", "sys:res:update",Duration.ofSeconds(5));
    }
    
    @Test
    void testHashOper01(){
        //1.获取Hash操作对象(ValueOperations)
        HashOperations ho = redisTemplate.opsForHash();
        //2.以hash类型存储数据
        ho.put("blog","id",100);
        ho.put("blog", "title", "redis....");
        //3.获取数据
        Object id = ho.get("blog", "id");
        Object title = ho.get("blog", "title");
        System.out.println("id="+id+";title="+title);
        Map blog = ho.entries("blog");//取key对应的所有值。
        System.out.println(blog);
    }
  
   /**
     * 设计一个Blog类，然后通过redisTemplate将此类的对象写入到redis数据库
     * 两种方案：
     * 1)方案1：基于ValueOperations对象实现数据存取
     * 2)方案2：基于HashOperations对象实现数据存储
     */
    @Test
    void testHashOper02() throws JsonProcessingException {
        //1.获取数据操作对象(ValueOperations,HashOperations)
        ValueOperations vo = redisTemplate.opsForValue();
        HashOperations ho = redisTemplate.opsForHash();
        //2.基于ValueOperations存取Blog对象
        Blog blog=new Blog();
        blog.setId(100L);
        blog.setTitle("redis ...");
        vo.set("blog-jack", blog);//序列化
        Object o = vo.get("blog-jack");//反序列化
        System.out.println(o);
        //3.基于HashOperations存取Blog对象
        ObjectMapper objectMapper=new ObjectMapper();//jackson
        String jsonStr=objectMapper.writeValueAsString(blog);
        Map map = objectMapper.readValue(jsonStr, Map.class);
        ho.putAll("blog-mike", map);
        ho.put("blog-mike","id","200");
        map=ho.entries("blog-mike");
        System.out.println(map);
    }

    @Test
    void testListOper(){
      //向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);
    }

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

   @Test
    void testFlushdb(){
        redisTemplate.execute(new RedisCallback() {
            @Override
            public Object doInRedis(RedisConnection redisConnection) throws DataAccessException {
               //redisConnection.flushDb();
                redisConnection.flushAll();
                return "flush ok";
            }
        });
    }
     @Test
    void testGetConnection(){
        RedisConnection connection =
                stringRedisTemplate.getConnectionFactory()
                        .getConnection();
        String ping = connection.ping();
        System.out.println(ping);
    }
}

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

package com.jt.redis.pojo;

import java.io.Serializable;

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()");
    }
    public Blog(Integer id,String title){
        this.id=id;
        this.title=title;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }
    @Override
    public String toString() {
        return "Blog{" +
                "id=" + id +
                ", title='" + title + '\'' +
                '}';
    }
}

在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);
}

StringRedisTemplate 对象应用实践

StringRedisTemplate 是一个特殊的RedisTemplate对象，默认基于字符串序列化方式存取数据，其应用方式如下：

package com.jt.redis;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.ValueOperations;

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

@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);
    }
   
}

基于业务定制RedisTemplate对象(拓展)

我们知道系统中的RedisTemplate默认采用的是JDK的序列化机制，假如我们不希望使用默认的JDK方式序列化，可以对RedisTemplate对象进行定制，指定自己的序列化方式，例如：

package com.jt;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.annotation.JsonTypeInfo;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializer;

import java.net.UnknownHostException;

@Configuration
public class RedisConfig {//RedisAutoConfiguration
    //自定义json序列化
    public RedisSerializer jsonSerializer(){
        //1.定义Redis序列化,反序列化规范对象(此对象底层通过ObjectMapper完成对象序列化和反序列化)
        Jackson2JsonRedisSerializer serializer=
                new Jackson2JsonRedisSerializer(Object.class);
        //2.创建ObjectMapper(有jackson api库提供)对象,基于此对象进行序列化和反序列化
        //2.1创建ObjectMapper对象
        ObjectMapper objectMapper=new ObjectMapper();
        //2.2设置按哪些方法规则进行序列化
        objectMapper.setVisibility(PropertyAccessor.GETTER,//get方法
                 JsonAutoDetect.Visibility.ANY);//Any 表示任意方法访问修饰符
        //对象属性值为null时,不进行序列化存储
        objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
        //2.2激活序列化类型存储,对象序列化时还会将对象的类型存储到redis数据库
        //假如没有这个配置,redis存储数据时不存储类型,反序列化时会默认将其数据存储到map
        objectMapper.activateDefaultTyping(
                objectMapper.getPolymorphicTypeValidator(),//多态校验分析
                ObjectMapper.DefaultTyping.NON_FINAL,//激活序列化类型存储,类不能使用final修饰
                JsonTypeInfo.As.PROPERTY);//PROPERTY 表示类型会以json对象属性形式存储
        serializer.setObjectMapper(objectMapper);
        return serializer;
    }
    //高级定制
    @Bean
    public RedisTemplate<Object, Object> redisTemplate(
            RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
        RedisTemplate<Object, Object> template = new RedisTemplate();
        template.setConnectionFactory(redisConnectionFactory);
        //设置key的序列化方式
        template.setKeySerializer(RedisSerializer.string());
        template.setHashKeySerializer(RedisSerializer.string());
        //设置值的序列化方式
        template.setValueSerializer(jsonSerializer());
        template.setHashValueSerializer(jsonSerializer());
        //更新一下RedisTemplate对象的默认配置
        template.afterPropertiesSet();
        return template;
    }

    //简单定制
//    @Bean
//    public RedisTemplate<Object, Object> redisTemplate(
//            RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
//        RedisTemplate<Object, Object> template = new RedisTemplate();
//        template.setConnectionFactory(redisConnectionFactory);
//        //设置key的序列化方式
//        template.setKeySerializer(RedisSerializer.string());
//        template.setHashKeySerializer(RedisSerializer.string());
//        //设置值的序列化方式
//        template.setValueSerializer(RedisSerializer.json());
//        template.setHashValueSerializer(RedisSerializer.json());
//        return template;
//    }
}

基于Redis的项目业务分析及实践

分布式id

业务描述

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

关键代码实现

package com.jt.demos;

import redis.clients.jedis.Jedis;

/**
 * 需求:生成一个分布递增的id
 * 多张表基于这个方法中生成的id作为主键id值(分布式环境不会采用数据库
 * 表中自带的自增策略-auto_increment)
 */
public class IdGeneratorDemo01 {
    public static Long getId(){
          Jedis jedis=new Jedis("192.168.126.130",6379);
          //jedis.auth("123456");//假如redis设置了密码,连接redis时需要指定密码
          Long id = jedis.incr("id");
          jedis.close();
          return id;
    }
    //自己创建线程执行任务
    static void execute01(){
         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();
          }
    }
     //基于线程池执行任务  
     static void execute02(){
      //构建一个最多只有3个线程的线程池
        ExecutorService es=
        Executors.newFixedThreadPool(3);
        for(int i=1;i<=10;i++){
            //从池中取线程执行任务
            es.execute(new Runnable() {//这个任务会存储到阻塞式任务队列中
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName()
                            +"->"+getId());
                }
            });
        }
    }
    public static void main(String[] args) {
        //execute01();
          execute02();
    }
}

单点登陆(SSO)

业务描述

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

关键代码实现

package com.jt.redis;

import redis.clients.jedis.Jedis;

import java.util.UUID;

/**
 * 基于redis的单点登录设计及实现
 * 1)用户登录成功以后将登录状态等信息存储到redis
 * 2)用户携带token去访问资源,资源服务器要基于token从redis查询用户信息
 */
public class SSODemo01 {
    /**
     * 执行登录认证,将来这样的业务要写到认证服务器
     * @param username
     * @param password
     */
    static String doLogin(String username,String password){
       //1.检验数据的合法性(判定用户名,密码是否为空,密码的长度,是否有数字字母特殊符号构成)
       if(username==null||"".equals(username))
           throw new IllegalArgumentException("用户不能为空");
       //2.基于用户名查询用户信息,并判定密码是否正确
       if(!"jack".equals(username))
           throw new RuntimeException("此用户不存在");
       if(!"123456".equals(password))
           throw new RuntimeException("密码不正确");
       //3.用户存在且密码正确,将用户信息写入到redis
        Jedis jedis=new Jedis("192.168.126.128", 6379);
        String token= UUID.randomUUID().toString();
        jedis.hset(token, "username", username);
        jedis.hset(token, "permission", "sys:resource:create");
        jedis.expire(token, 10);//设置key的有效时间
        jedis.close();
       //4.将token返回给客户端(将来使用response对象响应到客户端).
        return token;
    }
    static String token;

    /**
     * 演示资源访问过程
     * 1)允许匿名访问(无需登录)
     * 2)登录后访问(认证通过了)
     * 3)登录后必须有权限才可以访问
     */
    static Object doGetResource(String token){
        //1.校验token是否为空
        if(token==null)
            throw new IllegalArgumentException("请先登录");
        //2.基于token查询redis数据,假如有对应数据说明用户登录了
        Jedis jedis=new Jedis("192.168.126.128", 6379);
        String username=jedis.hget(token, "username");
        if(username==null)
            throw new RuntimeException("登录超时,请重新登录");
        String permission=jedis.hget(token, "permission");
        jedis.close();
        //3.检查用户是否有访问资源的权限,假如有则允许访问
        if(!"sys:resource:create".equals(permission))
            throw new RuntimeException("你没有权限访问这个资源");
        //4.返回要访问的资源.
        return "your resource";
    }
    public static void main(String[] args) {
        //1.登录操作(用户身份认证)
        token=doLogin("jack", "123456");
        System.out.println(token);
        //2.携带token访问资源服务器
        Object result=doGetResource(token);
        System.out.println(result);
    }
}

简易秒杀队列

业务描述

在设计一个秒杀或抢购系统时,为了提高系统的响应速度,通常会将用户的秒杀或抢购请求先存储到一个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();

    }
}

简易投票系统

业务描述

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

关键代码实现

package com.jt.redis;

import redis.clients.jedis.Jedis;

import java.util.Set;

/**
 * 基于某个活动的简易投票系统设计
 * 1)投票数据存储到redis (key为活动id,多个用户id的集合)
 * 2)同一个用户不能执行多次投票
 * 3)具体业务操作(投票,获取总票数,获取哪些人参与了投票)
 */
public class VoteDemo01 {

    /**
     * 获取哪些人执行了这个活动的投票
     * @param activityId
     * @return
     */
    static  Set<String> doGetMembers(String activityId){
        //1.建立连接
        Jedis jedis=new Jedis("192.168.126.128", 6379);
        //2.获取当前活动的总票数
        Set<String> smembers = jedis.smembers(activityId);
        //3.释放资源
        jedis.close();
        return smembers;
    }
    /**
     * 获取指定活动的投票总数
     * @param activityId
     * @return
     */
    static Long doCount(String activityId){
       //1.建立连接
       Jedis jedis=new Jedis("192.168.126.128", 6379);
       //2.获取当前活动的总票数
       Long count=jedis.scard(activityId);
       //3.释放资源
       jedis.close();
       return count;
    }
    /**
     * 执行投票操作
     * @param activityId
     * @param userId
     */
    static void doVote(String activityId,String userId){
       //1.建立连接
        Jedis jedis=new Jedis("192.168.126.128", 6379);
       //2.执行投票
        //2.1检查是否投过票
        Boolean flag = jedis.sismember(activityId, userId);
        //2.2执行投票或取消投票
        if(flag){
            //假如已经投过票,再投票就取消投票
            jedis.srem(activityId, userId);
        }else{
            //没有投过票则执行投票
            jedis.sadd(activityId, userId);
        }
       //3.释放资源
        jedis.close();
    }
    public static void main(String[] args) {
        String activityId="101";
        String userId1="1";
        String userId2="2";
        String userId3="3";
        //执行投票动作
        doVote(activityId, userId1);
        doVote(activityId, userId2);
        doVote(activityId, userId3);
        //获取投票的总票数
        Long aLong = doCount(activityId);
        System.out.println(aLong);
        //获取参与投票的成员
        Set<String> members= doGetMembers(activityId);
        System.out.println(members);
    }

}

简易购物车系统

业务描述

简易购物车业务设计如图所示:

基础指令操作,例如:

1)向购物车添加商品
hset  cart:101  2001  1
hset  cart:101  2002  1
hset  cart:101  2003  2
2)查看购物车商品
hgetall cart:101
3)删除购物车商品
hdel cart:101 2003
4)改变购物车某个商品的购买数量
hincrby cart:101 2002 2

关键代码实现

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);
    }

}

SpringBoot工程中Redis与Aop技术的整合

业务描述

基于AOP与Redis技术实现mysql,redis数据库中数据操作.

项目准备工作

第一步:打开redis-template工程,添加访问MySql数据库的依赖(两个)

<!--mysql依赖-->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
    </dependency>
    <!--mybatis plus (简化mybatis操作)-->
    <dependency>
        <groupId>com.baomidou</groupId>
        <artifactId>mybatis-plus-boot-starter</artifactId>
        <version>3.4.2</version>
    </dependency>

第二步:修改sca-template工程的配置文件,添加连接mysql数据库的配置

spring:
  datasource:
    url: jdbc:mysql:///jt-sso?serverTimezone=Asia/Shanghai&characterEncoding=utf8
    username: root
    password: root

Pojo逻辑对象定义

定义一个Menu对象,用户封装tb_menus表中的数据,例如:

package com.jt.pojo;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import org.springframework.data.annotation.Id;

import java.io.Serializable;

@TableName(value = "tb_menus")
public class Menu implements Serializable {
    private static final long serialVersionUID = -577747732166248365L;
    @TableId(type = IdType.AUTO)
    private Long id;
    private String name;
    private String permission;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPermission() {
        return permission;
    }

    public void setPermission(String permission) {
        this.permission = permission;
    }

    @Override
    public String toString() {
        return "Menu{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", permission='" + permission + '\'' +
                '}';
    }
}

Dao逻辑对象设计及实现

创建用于操作数据库中tb_menus表中数据的Mapper对象,例如:

package com.jt.dao;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.jt.pojo.Menu;
import org.apache.ibatis.annotations.Mapper;

@Mapper
public interface MenuMapper extends BaseMapper<Menu> {
}

Service逻辑对象设计及实现

第一步:定义用于处理菜单业务的业务接口,例如:

package com.jt.service;
import com.jt.pojo.Menu;
import java.io.Serializable;
public interface MenuService {
    /**
     * 基于id查找菜单对象,先查redis,redis没有再查数据库
     * @param id
     * @return
     */
    Menu selectById(Long id);
    /**
     * 向表中写入一条菜单信息,与此同时也要向redis写入一样的数据
     * @param menu
     * @return
     */
    Menu insertMenu(Menu menu);
    /**
     * 更新表中数据,与此同时也要更新redis中的数据
     * @param menu
     * @return
     */
    Menu updateMenu(Menu menu);
    //.....
}

第二步:定义用于处理菜单业务的业务接口实现类,
在这个实现类中自己基于RedisTemplate对象操作Redis缓存,例如:

package com.jt.service;
import com.jt.dao.MenuMapper;
import com.jt.pojo.Menu;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.time.Duration;

@Service
public class MenuServiceImpl implements MenuService{
    //注入方案1
    //@Autowired
    //private RedisTemplate redisTemplate;
    //@Autowired
    //private MenuMapper menuMapper;
    private static final Logger log=
            LoggerFactory.getLogger(MenuServiceImpl.class);
    //注入方案2
    private MenuMapper menuMapper;
    private ValueOperations valueOperations;

    public MenuServiceImpl(MenuMapper menuMapper,
                            RedisTemplate redisTemplate) {
        this.menuMapper = menuMapper;
        this.valueOperations = redisTemplate.opsForValue();
    }

    private static final String KEY_PREFIX="menu:";
    @Override
    public Menu selectById(Long id) {
        //1.从redis获取菜单信息,有则直接返回
        //ValueOperations valueOperations = redisTemplate.opsForValue();
        Object obj = valueOperations.get(KEY_PREFIX + id);
        if(obj!=null){
            log.info("Data from Redis Cache");
            return (Menu)obj;
        }
        log.info("Data from MySQL");
        //2.从mysql数据库中查询菜单信息
        Menu menu=menuMapper.selectById(id);
        //3.将数据中查询到的菜单信息存储到redis
        valueOperations.set(KEY_PREFIX+id,
                menu,
                Duration.ofSeconds(60*60));
        //4.返回菜单对象
        return menu;
    }

    @Override
    public Menu insertMenu(Menu menu) {
        //1.保存到关系数据
        log.info("insert.before.menu={}",menu);
        menuMapper.insert(menu);
        log.info("insert.after.menu={}",menu);
        //2.将数据保存到缓存
        //ValueOperations valueOperations = redisTemplate.opsForValue();
        valueOperations.set(KEY_PREFIX+menu.getId(),
                menu, Duration.ofSeconds(60*60));
        return menu;
    }

    @Override
    public Menu updateMenu(Menu menu) {
        //1.更新mysql数据
        menuMapper.updateById(menu);
        //2.更新缓存数据
        //ValueOperations valueOperations = redisTemplate.opsForValue();
        valueOperations.set(KEY_PREFIX+menu.getId(),
                menu, Duration.ofSeconds(60*60));
        return menu;
    }
}

第三步:定义用于处理菜单业务的业务接口实现类,基于AOP方式操作redis缓存,比较
与第二步写的Redis操作方式的不同,例如:

package com.jt.service;

import com.jt.dao.MenuMapper;
import com.jt.pojo.Menu;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CachePut;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

@Service
public class DefaultMenuService implements MenuService{
    @Autowired
    private MenuMapper menuMapper;

    /**
     * 由此注解描述的方法为切入点方法,此方法执行时,底层会通过AOP机制
     * 先从缓存取数据,缓存有则直接返回,缓存没有则查数据,最后将查询的数据
     * 还会向redis存储一份
     * @param id
     * @return
     */
    @Cacheable(value = "menuCache",key="#id")
    @Override
    public Menu selectById(Long id) {
        return menuMapper.selectById(id);
    }

    /**
     * CachePut注解的意思是更新缓存
     * @param menu
     * @return
     */
    @CachePut(value = "menuCache",key="#menu.id")
    @Override
    public Menu insertMenu(Menu menu) {
         menuMapper.insert(menu);
         return menu;
    }

    @CachePut(value = "menuCache",key="#menu.id")
    @Override
    public Menu updateMenu(Menu menu) {
        menuMapper.updateById(menu);
        return menu;
    }
}

说明,启动AOP方式的缓存应用,需要在启动类上添加@EnableCaching注解:

第四步:定义单元测试类,基于单元测试类测试缓存应用.例如:

package com.jt;

import com.jt.pojo.Menu;
import com.jt.service.MenuService;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.test.context.SpringBootTest;

import javax.annotation.Resource;

@SpringBootTest
public class MenuServiceTests {
    @Autowired
    @Qualifier("defaultMenuService")
    //@Resource(name="defaultMenuService")
    private MenuService menuService;
    @Test
    void testSelectById(){
        Menu menu = menuService.selectById(1L);
        System.out.println(menu);
    }
    @Test
    void testUpdateMenu(){
        Menu menu = menuService.selectById(1L);
        menu.setName("select res");
        menuService.updateMenu(menu);
    }
    @Test
    void testInertMenu(){
        Menu menu = new Menu();
        menu.setName("insert res");
        menu.setPermission("sys:res:insert");
        menuService.insertMenu(menu);
    }
}

第五步:改变AOP方式中redis数据存储时的序列化方式(假如业务上需要).其实现上要借助
CacheManager对象,例如:

package com.jt;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.RedisSerializer;

/**
 * 重构CacheManager对象,其目的是改变AOP方式应用redis的序列化和反序列化的方式.
 */
@Configuration
public class CacheManagerConfig {
    /**
     * 重构CacheManager对象
     * @return
     */
    @Bean
    public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
        //定义RedisCache配置
        RedisCacheConfiguration cacheConfig=
                RedisCacheConfiguration.defaultCacheConfig()
        //定义key的序列化方式
        .serializeKeysWith(
                RedisSerializationContext.
                   SerializationPair.fromSerializer(RedisSerializer.string()))
        //定义value的序列化方式
        .serializeValuesWith(
                RedisSerializationContext.SerializationPair
                .fromSerializer(RedisSerializer.json()));

        return  RedisCacheManager.builder(redisConnectionFactory)
               .cacheDefaults(cacheConfig)
               .build();//建造者模式(复杂对象的创建,建议使用这种方式,封装了对象的创建细节)
    }
}

写好这个对象后,可以再次基于MenuService中的方法进行单元测试,检测redis数据的存储.

Controller逻辑对象设计及实现

第一步:定义Controller处理,处理客户端对菜单数据的请求操作,例如:

package com.jt.controller;
import com.jt.pojo.Menu;
import com.jt.service.MenuService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.web.bind.annotation.*;
@RestController
@RequestMapping("/menu")
public class MenuController{
    @Autowired
    @Qualifier("defaultMenuService")
    private MenuService menuService;

    @GetMapping("/{id}")
    public Menu doSelectById(@PathVariable("id") Long id){
        return menuService.selectById(id);
    }
    @PutMapping
    public String doUpdate(@RequestBody Menu menu){
         menuService.updateMenu(menu);
         return "update ok";
    }
    @PostMapping
    public String doInsert(@RequestBody Menu menu){
        menuService.insertMenu(menu);
        return "insert ok";
    }
}

第二步:打开postman或基于idea中的http client工具进行访问测试.检测redis数据存储与更新

总结（Summary）

本章节主要对Java中操作redis数据库的方式及API应用进行了分析和实践，具体方法的理解可以在实践中基于结果进行分析，逐步进行强化记忆。

原文链接

链接: link