Java的redis一般用来做什么 java中的redis操作

转载

mob64ca140ac564 2024-06-25 17:22:50

文章标签 Java的redis一般用来做什么 java redis jedis 秒杀队列 文章分类 Java 后端开发

文章目录

准备工作

创建工程
添加项目依赖

Jedis的应用

简介
准备工作
快速入门实现

基础类型操作
连接池JedisPool应用

RedisTemplate应用

简介
准备工作
快速入门实现

StringRedisTemplate 应用
RedisTemplate 应用
定制RedisTemplate对象

项目工程实践

单点登陆

业务描述
关键代码实现

投票系统

业务描述
关键代码实现

秒杀队列

业务描述
关键代码实现

分布式id

业务描述
关键代码实现

购物车简易实现

业务描述
关键代码实现

总结（Summary）

准备工作

创建工程

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

Java的redis一般用来做什么 java中的redis操作_redis

添加项目依赖

jt-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>

添加jt-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>

Jedis的应用

简介

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

准备工作

在java中远程连接redis，需要将redis.conf配置文件中的bind 127.0.0.1元素注释掉,并且将其保护模式(protected-mode)设置为no(redis3.0之后默认开启了这个策略) ,当修改了配置以后,一定要记得重启redis,然后再进行访问。

快速入门实现

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

基础类型操作

package com.jt;
import org.junit.Test;
import redis.clients.jedis.Jedis;
import java.util.concurrent.TimeUnit;
public class JedisTests {
    //字符串类型练习
    @Test
    public void testStringOper() throws InterruptedException {
        //建立链接(与redis建立链接)
        Jedis jedis=new Jedis("192.168.126.130",6379);
        jedis.auth("123456");//假如设置了密码,需要密码认证
        String result=jedis.ping();
        System.out.println(result);
        //存储数据(key/value)
        jedis.set("count","1");
        jedis.set("id","10001");
        jedis.set("content","aaaaaaaadfas");
        //更新数据
        jedis.expire("id",1);//设置key的有效时长
        jedis.incr("count");//对key的值进行自增操作
        //获取数据
        String count = jedis.get("count");
        //TimeUnit是Java中枚举类型,SECONDS为枚举类型的实例,sleep底层会调用Thread.sleep()方法
        //TimeUnit.SECONDS.sleep(1);//休眠一秒
        Thread.sleep(1000);
        String id=jedis.get("id");
        Long num=jedis.strlen("content");
        System.out.println("cart.count="+count);
        System.out.println("id="+id);
        System.out.println("num="+num);
        //释放资源
        jedis.close();
    }
//json数据练习
@Test
 public void testJsonOper(){
     //构建对象
      Map<String,Object> map=new HashMap<>();
      map.put("id",100);
      map.put("title","spring 认证");
      map.put("content","very good");
     //将对象转换为json格式字符串
      Gson gson=new Gson();
      String jsonStr=gson.toJson(map);
      //将json字符串写入到redis
      Jedis jedis=new Jedis("192.168.126.128",6379);
      jedis.set("user",jsonStr);
      //读取redis中数据
      jsonStr=jedis.get("user");
      System.out.println(jsonStr);
      Map<String,Object> obj=gson.fromJson(jsonStr,Map.class);
      System.out.println(obj);
      jedis.close();
 }
//hash类型练习
@Test
 public void testHashOper01(){
   //1.建立连接
   Jedis jedis=new Jedis("192.168.126.128",6379);
   //2.存储一篇博客信息
   jedis.hset("article","id","1");
   jedis.hset("article","title","mybatis");
   jedis.hset("article","content","framework");
   //3.获取博客内容并输出
   String id=jedis.hget("article","id");
   String title=jedis.hget("article","title");
   String content= jedis.hget("article","content");
   System.out.println(id+"/"+title+"/"+content);
   //4.释放资源
   jedis.close();
 }
//hash类型练习（直接存储map对象）
@Test
public void testHashOper02(){
    //1.建立连接
    Jedis jedis=new Jedis("192.168.126.128",6379);
    //2.存储一篇博客信息
    Map<String,String> map=new HashMap<>();
    map.put("x","100");
    map.put("y","200");
    jedis.hset("point",map);
    //3.获取博客内容并输出
    map=jedis.hgetAll("point");
    System.out.println(map);
    //4.释放资源
    jedis.close();
}
//list类型练习:实现一个秒杀队列
@Test
public void testListOper01(){
  //1.连接redis
    Jedis jedis=new Jedis("192.168.126.128",6379);
  //2.向队列存数据
    jedis.rpush("list1","A","B","C");
  //3.按先进先出的顺序从队列取数据
    Long n=jedis.llen("list1");//获取队列长度
    List<String> list=jedis.lpop("list1",n.intValue());
    System.out.println(list);
  //4.释放资源
    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();
    }
}

RedisTemplate应用

简介

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

准备工作

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

spring:
  redis:
    host: 192.168.64.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);
    }
}

快速入门实现

StringRedisTemplate 应用

StringRedisTemplate 是一个专门用于操作redis字符串类型数据的一个对象，其应用方式如下：

package com.jt.redis;
@SpringBootTest
public class StringRedisTemplateTests {
    /**此对象为spring提供的一个用于操作redis数据库中的字符串的一个对象*/
  @Autowired
  private StringRedisTemplate stringRedisTemplate;
  @Test
  void testConnection(){
        RedisConnection connection =
                stringRedisTemplate.getConnectionFactory()
                        .getConnection();
        String ping = connection.ping();
        System.out.println(ping);
    }
  @Test
  void testRedisStringOper()throws Exception{
    //获取用于操作字符串的值对象
   ValueOperations<String, String> valueOperations
            = stringRedisTemplate.opsForValue();
   //向redis中存储数据
   valueOperations.set("ip", "192.168.174.130");
   valueOperations.set("state","1",1, TimeUnit.SECONDS);
   valueOperations.decrement("state");
   // Thread.sleep(2000);
   //从redis中取数据
   String ip=valueOperations.get("ip");
   System.out.println("ip="+ip);
   String state=valueOperations.get("state");
   System.out.println("state="+state);
  }

}

RedisTemplate 应用

RedisTemplate是一个专门用于实现对远端redis中复杂数据的操作的对象，应用案例如下：

package com.jt.redis;
@SpringBootTest
public class RedisTemplateTests {
    /**
     * 通过此对象操作redis中复杂数据类型的数据，例如hash结构
     */
    @Autowired
    private RedisTemplate redisTemplate;
  @Test
    void testConnection(){
        String result=
        redisTemplate.getConnectionFactory().getConnection().ping();
        System.out.println(result);
    }
    @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，并采用自己指定的的序列化方式，例如：

package com.jt.redis.config;
@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代码如下

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

项目工程实践

单点登陆

业务描述

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

Java的redis一般用来做什么 java中的redis操作_jedis_02

关键代码实现

package com.jt.demos;
public class SSODemo01 {
    //校验session的有效性
    public static boolean isValidSession(String token){
        if(token==null||"".equals(token)){
            return false;
        }
        //1.建立连接
        Jedis jedis=new Jedis("192.168.126.130",6379);
        jedis.auth("123456");
        //2.从redis获取会话信息
        //2.1用户token对应的用户信息,将来可以是一个json格式的字符串
        String user=jedis.hget("session",token);//session这里表示会话对象
        System.out.println("user="+user);
        if(user==null||"".equals(user)){
            System.out.println("还没有登录");
            jedis.close();
            return false;
        }
        //3.判定是否登录超时
        String dateStr=jedis.hget("session",token+":expired");
        Date expired=new Date(Long.valueOf(dateStr));
        if(dateStr==null||"".equals(dateStr)||expired.before(new Date())) {
            System.out.println("登录超时");
            jedis.close();
            return false;
        }
        return true;
    };
    //执行登录操作
    public static String login(String username,String password){
        System.out.println("基于"+username+"/"+password+"进行登录");
        //1.创建token(一般可以用一个随机的字符串)
       String token= UUID.randomUUID().toString()
               .replace("-","");
       System.out.println(token);
       //2.创建有效登录时长
        Calendar calendar=Calendar.getInstance();
        calendar.add(Calendar.MINUTE,30);
       //3.存储会话信息
        Map<String,String> map=new HashMap<>();
        map.put(token,username);//username这里可以是包含更多用户信息的json字符串
        map.put(token+":expired",String.valueOf(calendar.getTimeInMillis()));
        Jedis jedis=new Jedis("192.168.126.130",6379);
        jedis.auth("123456");
        jedis.hset("session",map);
        jedis.close();
        return token;
    }
    public static void main(String[] args) {
        System.out.println("===访问系统资源===");
        //第一访问:访问redis,检查是否有有效的会话信息
        String token=null;
        boolean flag=isValidSession(token);
        System.out.println(flag?"第一次:已登录":"第一次:未登录");
        //执行登录
        if(!flag){
            System.out.print("执行登录:");
            token=login("jack","123456");
            //登录成功的这个token将来响应到客户端
        }
       //第二次访问:
        flag=isValidSession(token);
        System.out.println(flag?"第二次:已登录":"第二次:未登录");
        //第三次访问:
        flag=isValidSession(token);
        System.out.println(flag?"第三次:已登录":"第三次:未登录");
    }
}

投票系统

业务描述

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

Java的redis一般用来做什么 java中的redis操作_redis_03

关键代码实现

package com.jt.demos;
import redis.clients.jedis.Jedis;
import java.util.Set;
/**
 * 投票系统演示:模拟基于某个活动的投票程序
 * 业务说明:一个用户只能投票一次(不允许重复)
 * 数据结构设计:基于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?"已投过票":"还没投票"));
    }
}

秒杀队列

业务描述

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

Java的redis一般用来做什么 java中的redis操作_jedis_04

关键代码实现

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

分布式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");
          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();
          }
    }
}

购物车简易实现

业务描述

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

Java的redis一般用来做什么 java中的redis操作_redis_05

基础指令操作,例如:

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.向购物车添加商品
        String product = jedis.hget("cart:" + userId, String.valueOf(productId));
        //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);
    }

}

总结（Summary）

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

文章目录

准备工作

创建工程
添加项目依赖

Jedis的应用

简介
准备工作
快速入门实现

基础类型操作
连接池JedisPool应用

RedisTemplate应用

简介
准备工作
快速入门实现

StringRedisTemplate 应用
RedisTemplate 应用
定制RedisTemplate对象

项目工程实践

单点登陆

业务描述
关键代码实现

投票系统

业务描述
关键代码实现

秒杀队列

业务描述
关键代码实现

分布式id

业务描述
关键代码实现

购物车简易实现

业务描述
关键代码实现

总结（Summary）

准备工作

创建工程

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

Java的redis一般用来做什么 java中的redis操作_redis

添加项目依赖

jt-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>

添加jt-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>

Jedis的应用

简介

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

准备工作

快速入门实现

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

基础类型操作

package com.jt;
import org.junit.Test;
import redis.clients.jedis.Jedis;
import java.util.concurrent.TimeUnit;
public class JedisTests {
    //字符串类型练习
    @Test
    public void testStringOper() throws InterruptedException {
        //建立链接(与redis建立链接)
        Jedis jedis=new Jedis("192.168.126.130",6379);
        jedis.auth("123456");//假如设置了密码,需要密码认证
        String result=jedis.ping();
        System.out.println(result);
        //存储数据(key/value)
        jedis.set("count","1");
        jedis.set("id","10001");
        jedis.set("content","aaaaaaaadfas");
        //更新数据
        jedis.expire("id",1);//设置key的有效时长
        jedis.incr("count");//对key的值进行自增操作
        //获取数据
        String count = jedis.get("count");
        //TimeUnit是Java中枚举类型,SECONDS为枚举类型的实例,sleep底层会调用Thread.sleep()方法
        //TimeUnit.SECONDS.sleep(1);//休眠一秒
        Thread.sleep(1000);
        String id=jedis.get("id");
        Long num=jedis.strlen("content");
        System.out.println("cart.count="+count);
        System.out.println("id="+id);
        System.out.println("num="+num);
        //释放资源
        jedis.close();
    }
//json数据练习
@Test
 public void testJsonOper(){
     //构建对象
      Map<String,Object> map=new HashMap<>();
      map.put("id",100);
      map.put("title","spring 认证");
      map.put("content","very good");
     //将对象转换为json格式字符串
      Gson gson=new Gson();
      String jsonStr=gson.toJson(map);
      //将json字符串写入到redis
      Jedis jedis=new Jedis("192.168.126.128",6379);
      jedis.set("user",jsonStr);
      //读取redis中数据
      jsonStr=jedis.get("user");
      System.out.println(jsonStr);
      Map<String,Object> obj=gson.fromJson(jsonStr,Map.class);
      System.out.println(obj);
      jedis.close();
 }
//hash类型练习
@Test
 public void testHashOper01(){
   //1.建立连接
   Jedis jedis=new Jedis("192.168.126.128",6379);
   //2.存储一篇博客信息
   jedis.hset("article","id","1");
   jedis.hset("article","title","mybatis");
   jedis.hset("article","content","framework");
   //3.获取博客内容并输出
   String id=jedis.hget("article","id");
   String title=jedis.hget("article","title");
   String content= jedis.hget("article","content");
   System.out.println(id+"/"+title+"/"+content);
   //4.释放资源
   jedis.close();
 }
//hash类型练习（直接存储map对象）
@Test
public void testHashOper02(){
    //1.建立连接
    Jedis jedis=new Jedis("192.168.126.128",6379);
    //2.存储一篇博客信息
    Map<String,String> map=new HashMap<>();
    map.put("x","100");
    map.put("y","200");
    jedis.hset("point",map);
    //3.获取博客内容并输出
    map=jedis.hgetAll("point");
    System.out.println(map);
    //4.释放资源
    jedis.close();
}
//list类型练习:实现一个秒杀队列
@Test
public void testListOper01(){
  //1.连接redis
    Jedis jedis=new Jedis("192.168.126.128",6379);
  //2.向队列存数据
    jedis.rpush("list1","A","B","C");
  //3.按先进先出的顺序从队列取数据
    Long n=jedis.llen("list1");//获取队列长度
    List<String> list=jedis.lpop("list1",n.intValue());
    System.out.println(list);
  //4.释放资源
    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应用

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

RedisTemplate应用

简介

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

准备工作

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

spring:
  redis:
    host: 192.168.64.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);
    }
}

快速入门实现

StringRedisTemplate 应用

StringRedisTemplate 是一个专门用于操作redis字符串类型数据的一个对象，其应用方式如下：

package com.jt.redis;
@SpringBootTest
public class StringRedisTemplateTests {
    /**此对象为spring提供的一个用于操作redis数据库中的字符串的一个对象*/
  @Autowired
  private StringRedisTemplate stringRedisTemplate;
  @Test
  void testConnection(){
        RedisConnection connection =
                stringRedisTemplate.getConnectionFactory()
                        .getConnection();
        String ping = connection.ping();
        System.out.println(ping);
    }
  @Test
  void testRedisStringOper()throws Exception{
    //获取用于操作字符串的值对象
   ValueOperations<String, String> valueOperations
            = stringRedisTemplate.opsForValue();
   //向redis中存储数据
   valueOperations.set("ip", "192.168.174.130");
   valueOperations.set("state","1",1, TimeUnit.SECONDS);
   valueOperations.decrement("state");
   // Thread.sleep(2000);
   //从redis中取数据
   String ip=valueOperations.get("ip");
   System.out.println("ip="+ip);
   String state=valueOperations.get("state");
   System.out.println("state="+state);
  }

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。

上一篇：android 保活常驻通知栏 android service 保活

下一篇：如何查看mysql 某个表某个字段的变更记录 mysql查看某个表的操作日志

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯