精华内容
下载资源
问答
  • redis在java项目中的使用
    千次阅读
    2021-10-29 09:51:49

    前言:我们经常根据条件查询数据,如果每查询一次数据都经过数据库,随着数据量增多,对数据库性能都有一定的消耗,效率也会大大降低,这时,我们就可以用Redis,可以把经常查询的数据第一次存到Redis中,再此查询时直接通过Redis查询,不走数据库,这样大大提高了数据查询效率而且也降低了对数据库的压力。

    一、我的Redis环境:docker,首先docker安装并启动Redis。(windows更简单可百度)

    1,提前下载安装Redis到docker容器中

    (docker search redis  命令来查看可用版本 docker pull redis:latest 下载最新Redis版本  已下载安装可忽略) 

     2,启动Redis

    $ docker run -itd --name redis-test -p 6379:6379 redis

    3,通过 docker ps 命令查看容器的运行信息:

     二,配置Redis连接(yml文件中输入spring.redis.host)

     三、敲代码

    1.引入RedisTemplate

    @Autowired
    private RedisTemplate redisTemplate;

     2、接口添加Redis缓存

    /**
    	 * 根据ID查询实体
    	 * @param id
    	 * @return
    	 */
    	public Article findById(String id) {
    		//先从缓存中查询当前对象
    		Article article =(Article)redisTemplate.opsForValue().get("article_"+id);
    		//如果没有获取到
    		if (article==null)
    		{
    			//从数据库查询
    			article=articleDao.findById(id).get();
    			//存入缓存中   10,TimeUnit.SECONDS  表示十秒过期清理缓存
    			redisTemplate.opsForValue().set("article_"+id,article,10,TimeUnit.SECONDS);
    		}
    
    		return article;
    	}
    /**
    	 * 修改
    	 * @param article
    	 */
    	public void update(Article article) {
    		redisTemplate.delete("article_"+article.getId());
    		articleDao.save(article);
    	}
    
    	/**
    	 * 删除
    	 * @param id
    	 */
    	public void deleteById(String id) {
    		redisTemplate.delete("article_"+id);
    		articleDao.deleteById(id);
    	}

    四,跑项目验证

    1、run项目

     2、查询已存在的数据

    日志显示第一次查询缓存中没有该数据,直接走数据库并且将该数据存到Redis中

     先清空控制台第二次查询该数据

     发现没有日志,没走数据库,说明通过Redis查询该数据。

    更多相关内容
  • redisjava项目应用.zip

    2020-06-30 16:40:59
    java项目中redis的应用,写的一个小例子,可以参考借鉴.
  • Redis在项目中使用场景;这是java面试中非常经典的面试题
  • 在Java项目中配置Redis

    千次阅读 2022-04-27 09:00:59
    Redis官网( https://redis.io/docs/clients/#java )所推荐的Java客户端有: Redisson Jedis lettuce 等等。本文将介绍 Jedis 和 lettuce 。 Jedis 方法1:手工配置 即手工搜索并下载所需的jar包,可以到以下网站...

    环境:

    • 操作系统: Ubuntu 20.04
    • Redis:6.2.6
    • 开发工具:IntelliJ IDEA 2022.1 (Community Edition)

    Redis官网( https://redis.io/docs/clients/#java )所推荐的Java客户端有:

    • Redisson
    • Jedis
    • lettuce

    等等。本文将介绍 Jedislettuce

    Jedis

    方法1:手工配置

    即手工搜索并下载所需的jar包,可以到以下网站搜索:

    搜索 jedis ,下载 jedis-4.2.2.jar 文件。

    新建项目 test0427_1

    在这里插入图片描述
    在项目下创建 lib 目录,把 jedis-4.2.2.jar 复制到这里。

    ➜  test0427_1 mkdir lib
    ➜  test0427_1 cp ~/Downloads/jedis-4.2.2.jar lib/
    ➜  test0427_1 
    

    File -> Project Structure... -> Modules -> Dependencies ,点击 + 图标,选择 JARs or Directories... ,然后选择 jedis-4.2.2.jar 文件:

    在这里插入图片描述
    创建 Test0427.java 文件如下:

    package pkg1;
    
    import redis.clients.jedis.Jedis;
    import redis.clients.jedis.JedisPool;
    
    public class Test0427 {
        public static void main(String[] args) {
            JedisPool pool = new JedisPool("localhost", 6379);
    
            try (Jedis jedis = pool.getResource()) {
                jedis.set("mykey1", "500");
            }
        }
    }
    

    运行程序,报错如下:

    /home/ding/IdeaProjects/test0427_1/src/pkg1/Test0427.java:8:26
    java: cannot access org.apache.commons.pool2.impl.GenericObjectPoolConfig
      class file for org.apache.commons.pool2.impl.GenericObjectPoolConfig not found
    

    http://www.bjpowernode.com/tutorial_redis/342.html 可知,还需要下载 commons-pool2

    搜索 commons-pool2 ,并下载 commons-pool2-2.11.1.jar 文件,按前面的方法将其添加到项目里。

    运行程序,报错如下:

    Exception in thread "main" java.lang.NoClassDefFoundError: org/slf4j/LoggerFactory
    	at redis.clients.jedis.JedisPool.<clinit>(JedisPool.java:19)
    	at pkg1.Test0427.main(Test0427.java:8)
    Caused by: java.lang.ClassNotFoundException: org.slf4j.LoggerFactory
    	at java.base/jdk.internal.loader.BuiltinClassLoader.loadClass(BuiltinClassLoader.java:641)
    	at java.base/jdk.internal.loader.ClassLoaders$AppClassLoader.loadClass(ClassLoaders.java:188)
    	at java.base/java.lang.ClassLoader.loadClass(ClassLoader.java:520)
    	... 2 more
    

    继续搜索 slf4j.api ,下载 slf4j-api-2.0.0-alpha7.jar 文件,按前面的方法将其添加到项目里。

    运行程序,报错如下:

    SLF4J: No SLF4J providers were found.
    SLF4J: Defaulting to no-operation (NOP) logger implementation
    SLF4J: See http://www.slf4j.org/codes.html#noProviders for further details.
    Exception in thread "main" java.lang.NoClassDefFoundError: com/google/gson/Gson
    	at redis.clients.jedis.CommandObjects.<clinit>(CommandObjects.java:3655)
    	at redis.clients.jedis.Jedis.<init>(Jedis.java:39)
    	at redis.clients.jedis.JedisFactory.makeObject(JedisFactory.java:181)
    	at org.apache.commons.pool2.impl.GenericObjectPool.create(GenericObjectPool.java:571)
    	at org.apache.commons.pool2.impl.GenericObjectPool.borrowObject(GenericObjectPool.java:298)
    	at org.apache.commons.pool2.impl.GenericObjectPool.borrowObject(GenericObjectPool.java:223)
    	at redis.clients.jedis.util.Pool.getResource(Pool.java:34)
    	at redis.clients.jedis.JedisPool.getResource(JedisPool.java:364)
    	at pkg1.Test0427.main(Test0427.java:10)
    Caused by: java.lang.ClassNotFoundException: com.google.gson.Gson
    	at java.base/jdk.internal.loader.BuiltinClassLoader.loadClass(BuiltinClassLoader.java:641)
    	at java.base/jdk.internal.loader.ClassLoaders$AppClassLoader.loadClass(ClassLoaders.java:188)
    	at java.base/java.lang.ClassLoader.loadClass(ClassLoader.java:520)
    	... 9 more
    

    SLF4J 的错误其实并不影响运行,真正影响运行的是 gson 的错误。继续搜索gson ,下载 gson-2.9.0.jar 文件,按前面的方法将其添加到项目里。

    运行程序,报错如下:

    SLF4J: No SLF4J providers were found.
    SLF4J: Defaulting to no-operation (NOP) logger implementation
    SLF4J: See http://www.slf4j.org/codes.html#noProviders for further details.
    

    不过也成功了。

    如果想移除错误,继续搜索slf4j.simpl ,下载 slf4j-simple-2.0.0-alpha7.jar 文件,按前面的方法将其添加到项目里。

    运行程序,这回终于没有任何错误了。

    最终所使用的的jar包如下:

    在这里插入图片描述

    方法2:Maven配置

    手工配置Jedis实在太麻烦,所以显而易见的解决方案是使用Maven来管理依赖。

    新建Maven项目test0427_2
    在这里插入图片描述
    打开 pom.xml 文件,添加如下内容:

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

    注:需要加到 <dependencies> 里面,如果没有就手工创建一下。

    同样,创建 Test0427.java 文件如下:

    package pkg1;
    
    import redis.clients.jedis.Jedis;
    import redis.clients.jedis.JedisPool;
    
    public class Test0427 {
        public static void main(String[] args) {
            JedisPool pool = new JedisPool("localhost", 6379);
    
            try (Jedis jedis = pool.getResource()) {
                jedis.set("mykey1", "500");
            }
        }
    }
    

    运行程序,报错如下:

    SLF4J: Failed to load class "org.slf4j.impl.StaticLoggerBinder".
    SLF4J: Defaulting to no-operation (NOP) logger implementation
    SLF4J: See http://www.slf4j.org/codes.html#StaticLoggerBinder for further details.
    

    不过也成功了。

    这个错误跟方法1缺少 slf4j-simple-2.0.0-alpha7.jar 文件的错误完全一样。

    查看 External Libraries ,可见除了 slf4j-simple-2.0.0-alpha7.jar 以外,已经包含了方法1所添加的那些jar包。
    在这里插入图片描述

    如果想移除错误,在 pom.xml 中添加以下依赖:

            <dependency>
                <groupId>org.slf4j</groupId>
                <artifactId>slf4j-simple</artifactId>
                <version>1.7.32</version>
            </dependency>
    

    注:版本是 1.7.32 ,因为 slf4j-api 的版本是 1.7.32 。如果换成别的版本(比如 2.0.0-alpha7 ),貌似不行,仍然报错。

    查看 External Libraries ,如下:

    在这里插入图片描述

    方法3:SpringBoot

    参见下面Lettuce部分的SpringBoot配置。Spring Data Redis默认使用的是Lettuce。

    Lettuce

    方法1:手工配置

    即手工搜索并下载所需的jar包。可从(https://github.com/lettuce-io/lettuce-core/releases)下载。我看到的最新版本是6.1.8,但是该版本只提供源码下载,需要自己做build,于是我下载了6.1.7的包 lettuce-core-6.1.7.RELEASE-bin.tar.gz

    解压后得到 lettuce-core-6.1.7.RELEASE.jar 以及其它一些jar包。

    新建项目 test0429_1

    在这里插入图片描述
    在项目下创建 lib 目录,把 lettuce-core-6.1.7.RELEASE.jar 以及其它所有的jar包都复制到这里。

    File -> Project Structure... -> Modules -> Dependencies ,点击 + 图标,选择 JARs or Directories... ,然后选择 lib 目录下所有的文件:

    在这里插入图片描述
    最终所使用的jar包如下:

    在这里插入图片描述
    创建 Test0429.java 文件如下:

    package pkg1;
    
    import io.lettuce.core.RedisClient;
    import io.lettuce.core.RedisURI;
    import io.lettuce.core.api.StatefulRedisConnection;
    import io.lettuce.core.api.sync.RedisCommands;
    
    import java.time.Duration;
    import java.time.temporal.ChronoUnit;
    
    public class Test0429 {
        public static void main(String[] args) {
            RedisURI redisUri = RedisURI.builder()
                    .withHost("localhost")
                    .withDatabase(0)
                    .withPort(6379)
                    .withTimeout(Duration.of(10, ChronoUnit.SECONDS))
                    .build();
    
            RedisClient redisClient = RedisClient.create(redisUri);
    
            StatefulRedisConnection<String, String> conn = redisClient.connect();
    
            RedisCommands<String, String> command = conn.sync();
    
            command.set("mykey1", "500");
    
            conn.close();
    
            redisClient.shutdown();
        }
    }
    

    运行程序,OK,测试成功!

    方法2:Maven配置

    新建Maven项目test0429_2

    在这里插入图片描述
    打开 pom.xml 文件,添加如下内容:

    <dependency>
        <groupId>io.lettuce</groupId>
        <artifactId>lettuce-core</artifactId>
        <version>6.1.8.RELEASE</version>
    </dependency>
    

    注:需要加到 <dependencies> 里面,如果没有就手工创建一下。

    同样,创建 Test0429.java 文件如下:

    package pkg1;
    
    import io.lettuce.core.RedisClient;
    import io.lettuce.core.RedisURI;
    import io.lettuce.core.api.StatefulRedisConnection;
    import io.lettuce.core.api.sync.RedisCommands;
    
    import java.time.Duration;
    import java.time.temporal.ChronoUnit;
    
    public class Test0429 {
        public static void main(String[] args) {
            RedisURI redisUri = RedisURI.builder()
                    .withHost("localhost")
                    .withDatabase(0)
                    .withPort(6379)
                    .withTimeout(Duration.of(10, ChronoUnit.SECONDS))
                    .build();
    
            RedisClient redisClient = RedisClient.create(redisUri);
    
            StatefulRedisConnection<String, String> conn = redisClient.connect();
    
            RedisCommands<String, String> command = conn.sync();
    
            command.set("mykey1", "500");
    
            conn.close();
    
            redisClient.shutdown();
        }
    }
    

    运行程序,OK,测试成功!

    查看 External Libraries ,如下:

    在这里插入图片描述

    注:如果要使用连接池,则需要 commons-pool2 。在 pom.xml 文件中添加如下依赖:

            <dependency>
                <groupId>org.apache.commons</groupId>
                <artifactId>commons-pool2</artifactId>
                <version>2.11.1</version>
            </dependency>
    

    方法3:SpringBoot

    打开 https://start.spring.io/ ,搜索 redis ,添加依赖 Spring Data Redis (Access+Driver) ,如下图所示:

    在这里插入图片描述
    创建项目 test0429_3 ,下载 test0429_3.zip 文件,解压生成项目,并打开。

    打开 pom.xml 文件,可见相关的依赖为:

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

    打开 application.properties 文件,添加Redis的配置信息:

    spring.redis.host=localhost
    spring.redis.port=6379
    

    本例只配置了 hostport ,若有其它信息,也可在此配置。

    打开 Test04293ApplicationTests.java 文件,添加依赖注入的 StringRedisTemplate ,然后添加一个自定义Test,最终代码如下:

    package com.example.test0429_3;
    
    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.core.StringRedisTemplate;
    
    @SpringBootTest
    class Test04293ApplicationTests {
    
    	@Autowired
    	StringRedisTemplate redisTemplate;
    
    	@Test
    	void contextLoads() {
    	}
    
    	@Test
    	void myTest() {
    		redisTemplate.opsForValue().set("mykey1", "500");
    	}
    }
    
    

    运行 myTest ,OK,测试成功!

    注:这里使用的是 StringRedisTemplate 而不是 RedisTemplate 。如果是后者,运行也OK,但是从 redis-cli 命令行检查,key和value都是一些奇怪的编码,这是因为 RedisTemplate 默认采用的是JDK的序列化策略。

    最终项目结构如下:

    在这里插入图片描述

    参考

    展开全文
  • springboot 实战项目中如何集成 Redis ,并且封装了超详细易用的 Redis 操作工具类。
  • Redis在Java中操作Redis

    千次阅读 2022-04-07 16:21:28
    一、通过Jedis 操作Redis ...注意 : 如果连接不上,可能是redis配置文件的问题,需要到redis主机上的redis.conf进行如下修改 : ① 把bind=127.0.0.1注释掉。 ② 将protected-mode设置为no。 ...

    一、通过Jedis 操作Redis

    1. 引入Jedis 依赖 : 在这里插入图片描述
    2. 创建Jedis 连接 → 操作Redis → 关闭Jedis 连接
      在这里插入图片描述
      注意 : 如果连接不上,可能是redis配置文件的问题,需要到redis主机上的redis.conf中进行如下修改 :
      ① 把bind=127.0.0.1注释掉。在这里插入图片描述
      ② 将protected-mode设置为no。在这里插入图片描述
      通常不这样直接使用Jedis,而是通过Jedis连接池来创建Jedis : 创建连接池类 → 通过连接池类创建Jedis
      连接池类 :
      在这里插入图片描述
      获取Jedis : 在这里插入图片描述
      获取到Jedis之后的使用就没什么特别的了。

    二、通过SpringDataRedis 操作Redis
    SpringDataRedis 是Spring Boot 集成的Redis服务,使用步骤 : 引入Redis 和common-pool 依赖 → 在application.properties中配置Redis 相关信息 → 获取RedisTemplate 对象,并通过RedisTemplate 对象操作Redis 数据库。
    ① 引入Redis 和common-pool 依赖 :
    在这里插入图片描述
    ② 在application.properties中配置Redis 相关信息 :
    在这里插入图片描述
    注意 : SpringDataRedis 默认使用 lettuce 而不是Jedis。
    ③ 获取RedisTemplate 对象,并通过RedisTemplate 对象操作Redis 数据库 :
    在这里插入图片描述
    SpringDataRedis存在的问题 :
    Redis会自动对接收到的数据进行序列化,因此当写入Redis 时,实际存在Redis 数据库中的内容跟我们写入的不一样 :
    在这里插入图片描述
    参考资料 : https://www.bilibili.com/video/BV1cr4y1671t?p=22
    解决方法 : 自定义RedisTemplate 的序列化方式 :
    序列化方案一 :
    在这里插入图片描述
    在这里插入图片描述
    这种方案的优点 : 能自动进行序列化和反序列化,也就是当我们存入一个对象时,会自动帮我们序列化成JSON 数据存入Redis;同样的,当从Redis 去除对应的JSON数据时,也会自动反序列化成对象。
    缺点 : 存入Redis 时需要多保存属性 (用于保存JSON数据与对象的映射),带来额外开销。

    方案二 :
    在这里插入图片描述
    优点 : 不增加额外开销。
    缺点 : 需要手动序列化和反序列化。

    ----- end ------

    展开全文
  • Redis有五种基础数据结构,分别为: 1、string(字符串) 2、list(列表) 3、hash(字典) 4、set(集合) 5、zset(有序集合) 数据结构有八种分类,分别为: 1、数组 2、栈 3、队列 4、链表 5、树 6、散列表 7、堆 8、图 ...

    由于在博主的博客专栏《杂货铺实战》中的杂货铺项目中用到了Redis,那么本篇博文就针对Redis的五种数据结构以及如何在JAVA中封装使用做一个简单的介绍。

    数据结构

    Redis有五种基础数据结构,分别为:
    1、string(字符串)
    2、list(列表)
    3、hash(字典)
    4、set(集合)
    5、zset(有序集合)

    接下来我们就来具体看看每种数据结构的简介和常用指令,以及在JAVA中如何封装使用吧!

    string字符串

    string字符串简介

    字符串的结构使用非常的广泛,常见的用途就是缓存用户信息。比如说博主的《杂货铺实战专栏》中的杂货铺项目,邮箱验证时生成的邮箱验证码等等。

    我们将要存储的对象信息使用JSON序列化成字符串,然后将序列化后的字符串使用Redis进行缓存。在取存储信息的时候进行一次反序列化操作就可以了。

    Redis的字符串与Java的字符串有所不同的就是,Java中的String是final类型的字符串,而Redis的字符串是动态字符串,是可以修改的字符串,内部实现结构类似于Java的ArrayList,采用预分配冗余空间来减少内存的频繁分配。

    既Redis会分配比实际字符串大的capacity(空间),扩容的时候就扩容加倍现有的空间。但是字符串的最大长度为512MB。

    一些普通的操作比如set、get、exists、del如下:

    Redis基本操作
    当然也可以通过mset、mget批量读写:
    批量写入Redis

    我们都知道,有些数据我们是不会让它长久存储在缓存里的,所以要设置对应的过期时间,可以通过expire、setex来设置,并且可以通过sexnx来判断key值是否存在不存在就创建:
    麻烦过期时间设置

    单句过期时间设置
    当我们的value是一个整数的时候,还可以通过incr、decr、incrby、decrby进行增减操作,需要注意的是它的返回是介于signed long的最大值以及最小值之间的,一旦超出这个范围,就会报错:

    Redis自增自减

    string字符串在Java中的封装

    (注:以下只列举string类型的工具类的完整写法,其他数据结构只列举部分写法)

    在pom.xml引入依赖:

            <!-- redis依赖包 -->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-data-redis</artifactId>
            </dependency>
    

    你可以在yml文件中配置,或者在properties文件中配置,挑选一个你认为看着舒服的配置上就好:

    # yml文件配置
    spring:
      redis:
        host: 127.0.0.1
        port: 6379
        password:
        jedis:
          pool:
            #连接池最大连接数(使用负值表示没有限制)
            max-active: 20
            #连接池最大阻塞等待时间(使用负值表示没有限制)
            max-wait: -1
            #连接池中的最大空闲连接
            max-idle: 20
            #连接池中的最小空闲连接
            min-idle: 2
        #连接超时时间(毫秒)
        timeout: 5000
    
    # properties文件配置
    #Redis服务器地址
    spring.redis.host=127.0.0.1
    #Redis服务器连接端口
    spring.redis.port=6379
    #Redis数据库索引(默认为0)
    spring.redis.database=0
    #连接池最大连接数(使用负值表示没有限制)
    spring.redis.jedis.pool.max-active=50
    #连接池最大阻塞等待时间(使用负值表示没有限制)
    spring.redis.jedis.pool.max-wait=3000
    #连接池中的最大空闲连接
    spring.redis.jedis.pool.max-idle=20
    #连接池中的最小空闲连接
    spring.redis.jedis.pool.min-idle=2
    #连接超时时间(毫秒)
    spring.redis.timeout=5000
    

    然后编写Redis的工具类:

    package com.gantiexia.redis;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.stereotype.Component;
    
    import java.util.concurrent.TimeUnit;
    
    /**
     * @author GanTieXia
     * @date 2021/11/21 18:07
     */
    
    @Component
    public class RedisUtils {
    
        /** 引入对应的依赖后注入即可*/
        @Autowired
        private RedisTemplate<String, String> redisTemplate;
    
        /**
         * 读取缓存
         *
         * @param key
         * @return
         */
        public String get(final String key) {
            return redisTemplate.opsForValue().get(key);
        }
    
        /**
         * 写入缓存
         */
        public boolean set(final String key, String value) {
            boolean result = false;
            try {
                redisTemplate.opsForValue().set(key, value);
                result = true;
            } catch (Exception e) {
                e.printStackTrace();
            }
            return result;
        }
    
        /**
         * 带失效时间key
         *
         * @param key
         * @param value
         * @param timeOut
         * @param timeUnit
         * @return
         */
        public boolean setKeyTimeOut(final String key,String value,long timeOut,TimeUnit timeUnit){
            boolean result = false;
            try {
                redisTemplate.opsForValue().set(key, value, timeOut, timeUnit);
                result = true;
            } catch (Exception e) {
                e.printStackTrace();
            }
            return result;
        }
    
        /**
         * 更新缓存
         */
        public boolean getAndSet(final String key, String value) {
            boolean result = false;
            try {
                redisTemplate.opsForValue().getAndSet(key, value);
                result = true;
            } catch (Exception e) {
                e.printStackTrace();
            }
            return result;
        }
    
        /**
         * 删除缓存
         */
        public boolean delete(final String key) {
            boolean result = false;
            try {
                redisTemplate.delete(key);
                result = true;
            } catch (Exception e) {
                e.printStackTrace();
            }
            return result;
        }
    }
    
    

    list列表

    list列表简介

    Redis的列表相当于Java语言中的LinkedList,但是它是链表,而不是数组。那么这就意味着它的插入和删除非常快,而索引定位却是比较慢的。

    列表中的每个元素是使用双向指针连接起来的,支持向前遍历和向后遍历。当列表弹出最后一个元素时,该数据结构自动删除,内存被回收。

    Redis的列表结构可以用来做异步队列使用。我们把需要延后处理的任务结构序列化成字符串,存入Redis列表,再启用另一个线程从列表中取得数据进行处理。

    队列

    众所周知,队列是先进先出的数据结构,可用于我们常听到的消息队列,可确保元素的访问顺序性。

    redis队列

    栈是一种先进后出的数据结果,跟我们常用的撤回是一个道理。

    redis栈
    还可以通过lindex查找对应位置上的元素,lrange 0 -1(-1代表最后一个元素,-2代表倒数第二个元素)获取所有的元素,ltrim可以保留某个区间的元素,砍掉其他位置的元素。但是这些操作的时间复杂度为O(n),所以一般都不推荐使用

    Redis的列表查找

    list列表在Java中的封装

    (完整代码参考上文string的封装)

    // 根据你的需要传入相应的参数
    // set方法的主要语句
    redisTemplate.opsForList(). ;  // .后面的方法根据你的应用场景写入
    

    list主要语句

    hash(字典)

    hash字典简介

    Redis的字典相当于JAVA语言里的HashMap,它是一个无需字典,内部存储了很多键值对。

    而针对HashMap的概念模型,在博主的JAVA进阶篇——HashMap底层实现解析(一)一文中讲解得很清晰了。

    不同的是,Redis的字典的值只能是字符串,并且他们的rehash也是不一样的。Java的HashMap在字典很大的时候,rehash是非常耗时的操作,得一次性全部rehash。而redis为了延续高性能,不产生堵塞,采用了渐进式的rehash策略。

    渐进式rehash策略就是会在rehash的同时,保留新旧两个hash结构,查询时会同时查询两个hash结构,然后通过后续的定时任务以及hash操作指令中,将旧的hash结构转移到新的hash结构中,在最后一个hash元素搬移之后,旧hash结构删除,内存被回收。

    hash的好处在哪呢,举个例子,当我们存储用户信息的时候,string是将整条信息直接序列化后存储,取出来以后还需要反序列化再获取我们想要的信息。使用hash则可以对用户结构中的每一个单一字段进行存储,比如我们要获取用户名的之后,就不用拿到一整条用户信息了,这样就可以节省网络流量。

    但美中不足的是,hash结构的存储消耗要高于单个字符串。

    接下来我们来看看操作:

    Redis字典

    hash字典在Java中的封装

    (完整代码参考上文string的封装)

    // 根据你的需要传入相应的参数
    // set方法的主要语句
    redisTemplate.opsForHash(). ;  // .后面的方法根据你的应用场景写入
    

    Hash主要语句

    set(集合)

    set集合简介

    Redis的集合相当于Java中的HashSet,内部的键值是无序的、唯一的,也就是在Java中我们所常用的使用Set去重。

    Redis的集合内部相当于一个特殊的字典,字典中每一个key的键值value都是NULL,同其他数据结构一样,最后一个元素被移除时,数据结构删除,内存被回收。

    接下来我们来看看操作指令:

    Redis集合

    set集合在Java中的封装

    (完整代码参考上文string的封装)

    // 根据你的需要传入相应的参数
    // set方法的主要语句
    redisTemplate.opsForSet(). ;  //.后面的方法根据你的应用场景写入
    

    redis中set

    zset(有序列表)

    zset有序列表

    zset也是一个set,它保证了内部value的唯一性,并且给每一个value赋予一个score,代表value的排序权重。

    zset可以用来干什么呢?比如粉丝列表,打开粉丝列表,value存储用户信息,score存储关注时间,粉丝列表就可以以关注时间排序展示…等等这里就不做过多的阐述了。

    下面我们来看看操作:
    Redis有序序列表操作1
    Redis有序列表操作2

    zset有序列表在Java中的封装

    (完整代码参考上文string的封装)

    // 根据你的需要传入相应的参数
    // set方法的主要语句
    redisTemplate.opsForZSet(). ;  // .后面的方法根据你的应用场景写入
    

    Redis中zset

    展开全文
  • Redis在java项目中的缓存应用

    千次阅读 2019-05-21 22:06:14
    当前大数据时代,信息量、数据量日益膨胀;一些存储系统的数据库也不断优化,去适应这个大数据的需求;当我们的客户端某个系统发送请求频繁读取大量数据的时候,单单是:客户端–&amp;amp;amp;amp;amp;amp;amp...
  • redis缓存在项目中使用

    千次阅读 2021-02-27 16:37:09
    关于redis为什么能作为缓存这个问题我们就不说了,直接来说一下redis缓存到底如何在项目中使用吧:1.redis缓存如何项目中配置?1.1redis缓存单机版和集群版配置?(redis的客户端jedis常用)xmlns:context=...
  • 使用Java操作Redis

    千次阅读 多人点赞 2022-02-13 11:13:18
    讲解使用Java连接远程Redis的两种方式,包括对基本操作的讲解,对redis更深一步。
  • redis-java项目配置手册

    2018-01-29 09:06:06
    有关于项目中怎样maven中配置redis,以及项目配置文件中对redis进行相关配置。
  • Redis在javaWeb项目中的应用

    千次阅读 2019-04-10 10:03:54
    2,javaweb工程引入依赖,jedis是操作redis的客户端 <dependency> <groupId>redis.clients</groupId> <artifactId>jedis</artifactId> <version&...
  • Redis在Java项目中的依赖

    千次阅读 2018-10-16 17:59:30
    compile group: 'org.springframework.boot', name: 'spring-boot-starter-data-redis', version: '2.0.4.RELEASE' compile group: 'redis.clients', name: 'jedis', version: '2.9.0' 可能会漏了后者。 ...
  • Java项目配置redis

    千次阅读 2021-02-12 11:38:52
    成功配置redis之后,便来学习使用redis。首先了解下redis的数据类型。Redis的数据类型Redis支持五种数据类型:string(字符串),hash(哈希),list(列表),set(集合)及zset(sorted set:有序集合)。Stringstring是...
  • 启动时,现将自己电脑内的Redis运行起来。里面有测试类,可选择性进行测试不同数据类型的读写方式。
  • Java调用Redis的一些简单Demo,可Eclipse上运行,相关入门介绍:https://www.w3cschool.cn/redis/redis-install.html
  • 主要介绍了Java简单实现session保存到redis的方法,结合实例形式分析了Java将session存入redis缓存服务器的相关设置、实现技巧与操作注意事项,需要的朋友可以参考下
  • 如何在Java中使用Redis

    千次阅读 2020-04-22 13:55:55
    最近做的项目是后台方面,涉及到Swagger、Springboot、Shiro…此篇用于初步梳理一下redis在java下的使用方法,主要简单记录两种...1.普通项目中,可以写一个TestRedis的java类,使用jedis 二、Springboot+Redis ...
  • Redis在项目中的应用

    千次阅读 2022-03-14 12:02:50
    redis的应用
  • Redis Java实例

    2022-04-07 15:27:38
    Redis Java String(字符串) 实例 //连接Redis 服务 Jedis jedis = new Jedis("116.63.178.139"); System.out.println("连接成功"); //设置 redis 字符串数据 jedis.set("runoobkey", "www.runoob.com"); // 获取...
  • redis在java项目中使用

    千次阅读 2017-08-16 22:49:49
    在上一篇文章中已经讲了redis的spring配置,这篇将会描述redis在java项目中使用redis存储形式都是key-value(键值对),按照存储的内容分为两种,一种是存简单数据,即数字,字符串等,可以用string-value的...
  • 本教程将演示如何 Eclipse 中使用 Maven 将 Redis 连接到 Java,并使用适用于 Java 的 Jedis 客户端库。Redis 是一种开源数据存储,用作缓存和数据库,具有内置复制功能,支持位图、索引、列表、集合、排序集合和...
  • 或者运行时指定--server.port=xxx,启动脚本start添加参数 下载源码 git clone xxx 根据服务器类型运行start脚本 ./start Maven打包编译 mvn clean package 当项目完成 后续会考虑docker方式部署
  • Java项目中使用Redis缓存案例

    千次阅读 2018-05-24 15:29:53
    我们将经常访问到的数据放在缓存,降低数据库I/O,同时因为缓存的数据的高速查询,加快整个系统的响应速度,也一定程度上提高并发量。 2.查询耗时的数据。如果有一些数据查询十分耗时,那么每次请求这些数据时,...
  • 项目显示了如何使用使用使用者组来发布和使用消息。 这是使用单个使用者的第一个基本示例。 建立 > cd redis-streams-101-java > mvn clean verify 跑 运行生产者 > cd redis-streams-101-java > mvn exec:java -...
  • 本文主要简单的使用Java代码进行redis缓存,即查询的时候先service层从redis缓存中获取数据。如果大家对ssm项目中使用redis缓存查询数据的相关知识感兴趣的朋友跟随脚本之家小编一起看看吧
  • 本篇文章主要介绍了Java自定义注解实现Redis自动缓存的方法,具有一定的参考价值,感兴趣的小伙伴们可以参考一下。
  • javaredis项目

    2020-12-26 19:43:50
    javaredis项目
  • Java使用Redis详解

    2020-12-07 16:06:49
    在项目的classpath包含该驱动包 连接redis服务: import redis.clients.jedis.Jedis; public class RedisJava { public static void main(String[] args){ //连接本地的redis Jedis jedis = new Jedis(...
  • springboot整合redis在项目中使用

    千次阅读 2020-07-05 18:12:22
    目录一、下载安装并启动redis二、springboot项目整合redis1、pom.xml引入redis依赖2、application.properties加入配置3、新建`RedisCache.java`4、新建工具类`ApplicationContextUtils.java`5、实体类实现`...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 186,663
精华内容 74,665
关键字:

redis在java项目中的使用