精华内容
下载资源
问答
  • springboot整合redis实例
    2020-09-22 09:49:21

    1. 引入关于spring-data-jpa的依赖

    <properties>
            <java.version>1.8</java.version>
        </properties>
    
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-data-redis</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-devtools</artifactId>
                <scope>runtime</scope>
                <optional>true</optional>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-configuration-processor</artifactId>
                <optional>true</optional>
            </dependency>
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <optional>true</optional>
            </dependency>
    
    
            <dependency>
    
                <groupId>mysql</groupId>
    
                <artifactId>mysql-connector-java</artifactId>
    
                <version>5.1.25</version>
    
            </dependency>
    
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
                <scope>test</scope>
                <exclusions>
                    <exclusion>
                        <groupId>org.junit.vintage</groupId>
                        <artifactId>junit-vintage-engine</artifactId>
                    </exclusion>
                </exclusions>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-data-jpa</artifactId>
                <version>RELEASE</version>
                <scope>compile</scope>
            </dependency>
        </dependencies>
    

    2. 编写配置文件

    spring:
      datasource:
        username: root
        password: 123456
        driver-class-name: com.mysql.jdbc.Driver
        url: jdbc:mysql://127.0.0.1:3306/tensquare_user?useUnicode=true&characterEncoding=utf8&autoReconnect=true&rewriteBatchedStatements=TRUE
      redis:
        host:  192.168.43.151
    

    3. 编写实体类

    这里使用的spring-data-jpa整合数据库,follow表是复合主键,需先创建UserProjectMultiKeysClass类

    @AllArgsConstructor
    @Data
    @NoArgsConstructor
    public class UserProjectMultiKeysClass implements Serializable {
    
        private  String userid;
    
        private  String targetuser;
    // 一定要重写equals 和hashcode方法
        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            UserProjectMultiKeysClass that = (UserProjectMultiKeysClass) o;
            return Objects.equals(userid, that.userid) &&
                    Objects.equals(targetuser, that.targetuser);
        }
    
        @Override
        public int hashCode() {
            return Objects.hash(userid, targetuser);
        }
    }
    
    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    @Entity
    @Table(name="tb_follow")
    @IdClass(UserProjectMultiKeysClass.class)
    public class Fllow implements Serializable {
        @Id
        private  String userid;
        @Id
        private  String targetuser;
    }
    

    4. 开发dao和controller

    @Repository
    public interface FllowDao extends JpaRepository<Fllow,String>, JpaSpecificationExecutor<Fllow> {
    }
    
    
    @RestController
    @RequestMapping("fllow")
    public class FllowController {
        @Autowired
        FllowService fllowService;
    
        @RequestMapping(value = "/getAll",method = RequestMethod.GET)
        public List<Fllow> findAll(){
            return  fllowService.findAll();
        }
    }
    
    

    5. 编写service

    @Service
    public class FllowService {
        @Autowired
        FllowDao fllowDao;
    
        @Autowired
        RedisTemplate redisTemplate;
    
        public List<Fllow> findAll(){
            List<Fllow> list;
            list =  redisTemplate.opsForList().range("follow", 0, -1);
            if(list.isEmpty()){
                list =  fllowDao.findAll();
                redisTemplate.opsForList().leftPushAll("follow", list);
            }
            return  list;
        }
    }
    
    更多相关内容
  • SpringBoot整合Redis实例

    热门讨论 2018-02-24 15:58:20
    SpringBoot整合Redis,包括整合单机版Redis、redis-cluster集群、redis哨兵模式
  • springboot整合redis实例

    2021-03-06 13:04:38
    springboot整合redis实例
  • springboot整合redis的完整例子,里面封装了redis五种数据类型的工具类
  • springbootredis结合的实战、实例项目,有助于帮助你了解springboot中怎么使用redis
  • 主要为大家详细介绍了springboot集成redis实现简单秒杀系统,文中示例代码介绍的非常详细,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 主要介绍了SpringBoot2整合Redis多数据源步骤详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • --springboot整合redis--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> <version>2.2.2.RE

    1.Maven依赖

    我这里整合引入的相关jar包

    <!--springboot整合redis-->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-data-redis</artifactId>
                <version>2.2.2.RELEASE</version>
            </dependency>
    
            <!-- 用来转换数据 -->
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>fastjson</artifactId>
                <version>1.2.62</version>
            </dependency>
    

    2.配置文件

    只贴出redis相关的,注意是在spring的下一级的
    在这里插入图片描述

    配置文件

    redis:
        host: 192.168.0.103
        port: 6379
        jedis:
          pool:
            max-active: 8
            max-wait: -1
            max-idle: 500
            min-idle: 0
          lettuce:
            shutdown-timeout: 0
    

    3.更改默认的redisTemplate

    因为SpringBoot整合Redis的时候会自动帮我们生成一个RedisTemplate和一个StringRedisTemplate。但因为这个RedisTemplate的泛型是<Object,Object>,对我们很多操作都不太方便,所以一般自己定义一个

    RedisConfig

    package com.jbit.springboot.springbootredis.conf;
    
    
    import com.fasterxml.jackson.annotation.JsonAutoDetect;
    import com.fasterxml.jackson.annotation.PropertyAccessor;
    import com.fasterxml.jackson.databind.ObjectMapper;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.cache.annotation.CachingConfigurerSupport;
    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.Jackson2JsonRedisSerializer;
    import org.springframework.data.redis.serializer.StringRedisSerializer;
    
    @Configuration
    public class RedisConfig extends CachingConfigurerSupport {
    
        @Autowired
        private RedisConnectionFactory redisConnectionFactory;
    
    
        @Bean("redisTemplate")
        public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
            Jackson2JsonRedisSerializer<Object> serializer = new Jackson2JsonRedisSerializer<Object>(Object.class);
            ObjectMapper objectMapper = new ObjectMapper();
            objectMapper.setVisibility(PropertyAccessor.ALL,JsonAutoDetect.Visibility.ANY);
            objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
            serializer.setObjectMapper(objectMapper);
    
            RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
            redisTemplate.setConnectionFactory(redisConnectionFactory);
            redisTemplate.setKeySerializer(new StringRedisSerializer());
            redisTemplate.setValueSerializer(serializer);
            redisTemplate.setHashKeySerializer(new StringRedisSerializer());
            redisTemplate.setHashValueSerializer(serializer);
            redisTemplate.afterPropertiesSet();
            return redisTemplate;
        }
    }
    

    4.使用

    就是在需要使用到的地址声明对象(我这里在ServiceImpl中使用的)

    	@Autowired
        private RedisTemplate<String,String> redisTemplate;
    

    相关的方法中使用(我这里实现的是一个查询所有商品信息的功能)

    @Override
        public List<Goods> selectAll() {
            //判断reids中是否存在(键为商品的Id,这里根据自己的需求设置合适的键就行)
            List<Goods> goods = goodsDao.selectAll();
    
            //声明一个集合存放redis中转化成对象后的数据
            List<Goods> redisList=new ArrayList<>();
    
            for(Goods good:goods){
                String s = redisTemplate.opsForValue().get(String.valueOf(good.getId()));
    
                //我这里存储到redis中的情况是
                //如果redis中有值就代表数据库的全部数据都在里面
                if(s!=null && !s.equals("")){
                    System.out.println("redis中有值");
                    //如果有值则依次取出来
                    Goods g=JSON.parseObject(s,Goods.class);
                    redisList.add(g);
                }else{
                    //如果没有则去数据库中查询
                    System.out.println("redis中无值");
                    List<Goods> goods1 = goodsDao.selectAll();
                    //查询出来后放到redis中
                    for(Goods good2:goods1){
                        redisTemplate.opsForValue().set(String.valueOf(good2.getId()),JSON.toJSONString(good));
                    }
                    //因为数据库中都查出来了,所以直接返回数据库中的
                    return goods1;
                }
            }
    
            //没有返回数据库的则返回redis中的
            return redisList;
        }
    

    5.测试

    1.第一次进来,redis中无值
    在这里插入图片描述
    可以看到后台正常返回,且redis数据库中生成了我们规定的键对值

    2.第二次进来
    在这里插入图片描述
    因为我的打印语句是放在取redis的时候有值的循环中的,所以redis中有多少数据就会打印多少次(从redis中取出数据并转换成相应的对象放到集合中返回成功了)

    SpringBoot整合redis的步骤大概就是这个样子了~

    展开全文
  • springboot整合redis系列集合 1.springboot整合redis序列化(3步搞定)- 本文 2.springboot整合redis发布订阅(4步搞定) 3.springboot整合redis数据结构对应使用场景讲解 4.springboot整合redis分布式锁 springboot...

    springboot整合redis系列集合



    项目结构图

    在这里插入图片描述

    1、pom文件添加依赖

    1.依赖版本springboot会自动匹配,所以不用关注
    2.fastjson依赖方便我们管理json格式数据

    <dependency>
    	<groupId>org.springframework.boot</groupId>
    	<artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
    <dependency>
       <groupId>com.alibaba</groupId>
        <artifactId>fastjson</artifactId>
        <version>1.2.72</version>
    </dependency>
    

    2、yml文件配置连接

    redis安装教程请移步查看: docker快速安装redis(两步轻松搞定)

    port:端口号
    host:ip地址
    password:密码

    spring:
      redis:
        port: 6379
        host: 127.0.0.1
        password: 123456
    

    3、添加序列化配置类

    package com.phy.demo.config;
    
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
    import org.springframework.data.redis.serializer.StringRedisSerializer;
    
    /**
     * redis 序列化配置
     * @author phy
     */
    @Configuration
    public class RedisConfig {
        /**
         * redis序列化配置
         * @param connectionFactory 连接工厂
         * @return
         */
        @Bean
        public RedisTemplate redisTemplate(LettuceConnectionFactory connectionFactory) {
            RedisTemplate redisTemplate = new RedisTemplate();
            redisTemplate.setConnectionFactory(connectionFactory);
            // 替换默认序列化
            GenericJackson2JsonRedisSerializer jackson2JsonRedisSerializer = new GenericJackson2JsonRedisSerializer();
            redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
            redisTemplate.setKeySerializer(new StringRedisSerializer());
            redisTemplate.setHashKeySerializer(new StringRedisSerializer());
            redisTemplate.afterPropertiesSet();
            return redisTemplate;
        }
    }
    

    至此,springboot整合redis并设置序列化就已完成,下面我们测试一下


    测试

    添加一个DemoController

    package com.phy.demo.controller;
    
    import com.alibaba.fastjson.JSONObject;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.web.bind.annotation.*;
    
    /**
     * demo redis 前端控制器
     * @author phy
     * @since 2021-09-29
     */
    @RestController
    @RequestMapping("/demo")
    public class DemoController {
        @Autowired
        private RedisTemplate redisTemplate;
    
        @PostMapping("set")
        public void set(@RequestBody JSONObject data) {
            redisTemplate.opsForValue().set(data.get("key"),data.get("value"));
        }
    
        @GetMapping("get")
        public String get(String key) {
            return (String)redisTemplate.opsForValue().get(key);
        }
    }
    

    运行项目,Postman调用测试

    添加redis键

    在这里插入图片描述

    通过键获取值

    在这里插入图片描述

    展开全文
  • Spring boot+redis+rabbitMq实例整合的简单例子,可用来参考学习
  • SpringBoot整合Redis

    2022-04-11 13:54:10
    1. 导入Redis相关依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> 导入了相关的...

    1. 导入Redis相关依赖

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

    导入了相关的依赖后会有自动配置类,找到自动配置类RedisAutoConfiguration。该自动配置类有两个方法,如下。

    @Configuration(proxyBeanMethods = false)
    @ConditionalOnClass(RedisOperations.class)
    @EnableConfigurationProperties(RedisProperties.class)
    @Import({ LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class })
    public class RedisAutoConfiguration {
    
    	@Bean
    	@ConditionalOnMissingBean(name = "redisTemplate")
    	@ConditionalOnSingleCandidate(RedisConnectionFactory.class)
    	public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
    		RedisTemplate<Object, Object> template = new RedisTemplate<>();
    		template.setConnectionFactory(redisConnectionFactory);
    		return template;
    	}
    
    	@Bean
    	@ConditionalOnMissingBean
    	@ConditionalOnSingleCandidate(RedisConnectionFactory.class)
    	public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
    		return new StringRedisTemplate(redisConnectionFactory);
    	}
    
    }
    

    RedisTemplateStringRedisTemplate的区别。

    RedisTemplate键值对可以是Object类型,但是StringRedisTemplate,的键只能是String类型,值可以是Object类型。

    2. 配置Redis

    application.yml中配置redis

    spring:
        redis:
            host: 127.0.0.1
    

    Redis底层默认是使用Lettuce作为客户端的,如需要使用jedis作为客户端管理工具,需要在pom.xml中引入jedis的依赖。

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

    application.yml配置则如下。

    spring:
        redis:
            host: 127.0.0.1
            client-type: jedis
            jedis:
              pool:
                max-active: 10
                min-idle: 5
    

    如果你的redis配置了连接密码,可以用下面的方式进行配置。

    spring:
        redis:
            host: 127.0.0.1
            password: 123456
    

    编写技术器

    首先我们需要写一个拦截器的组件,然后将组件注册进来。

    编写redis拦截组件。

    @Component
    public class RedisUrlCountInterceptor implements HandlerInterceptor {
    
        @Autowired
        StringRedisTemplate redisTemplate;
    
        @Override
        public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
    
            String uri = request.getRequestURI();
    
            // 默认每次访问当前 uri 就会计数+1
            redisTemplate.opsForValue().increment(uri);
    
            return true;
        }
    }
    

    把该组件注册到拦截器中。

    @Configuration
    public class InterceptorConfig implements WebMvcConfigurer {
    
        @Autowired
        RedisUrlCountInterceptor redisUrlCountInterceptor;
    
        @Override
        public void addInterceptors(InterceptorRegistry registry) {
                registry.addInterceptor(redisUrlCountInterceptor)
                    .addPathPatterns("/**")
                    .excludePathPatterns("/", "/login", "/css/**", "/fonts/**", "/images/**", "/js/**");
        }
    }
    

    分析Redis自动装配原理

    找到RedisAutoConfiguration类,可以看到该类有连个方法,RedisTemplate<Object, Object>StringRedisTemplate,这两者的区别上面已经介绍了,这里就不再叙述。

    该类的注解如下图所示。

    • 其中@Configuration(proxyBeanMethods = false)表示lite模式。lite模式中,每次都会创建新的bean实例。不用到容器中检查是否存在该bean实例,能够加快SpringBoot的启动速度。
    • @ConditionalOnClass(RedisOperations.class)表示某个RedisOperations位于类路径上,才会实例化一个Bean
    • @EnableConfigurationProperties(RedisProperties.class)表示使使用了@ConfigurationProperties的类生效,即我们配置的properties文件可以生效,可以从properties配置文件中读取数据,当然也可以是yml文件。这里表示绑定了RedisProperties类中的属性,我们可以在application.yml中配置redis的属性值。
    • @Import({ LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class })的作用是导入这两种连接的配置类。

    image-20220410190427791

    下面这个是RedisProperties类,首先是使用@ConfigurationProperties注解进行配置文件的绑定,这里绑定了前缀spring.redis所以我们可以直接在配置文件application.yml中配置redis。并且在该类中有很多默认的配置,比如端口号默认是6379,连接的主机默认是本地等等。redis一共有16个数据库,从源码可以看到,默认使用第一个数据库,也就是databases = 0。客户端类型有两种,可以选择LETTUCE,这是默认的,还有一个是JEDIS。这里需要注意,如果使用JEDIS作为客户端连接工具,则需要在pom.xml中引入jedis的依赖。

    image-20220411133020702

    image-20220411133843049

    RedisTemplate对象通过调用setConnectionFactory方法,产生redis连接工厂,这样就可以连接到redis了。

    image-20220410190314865

    StringRedisTemplate是使用了构造方法来产生一个redis连接工厂。

    etConnectionFactory方法,产生redis连接工厂,这样就可以连接到redis`了。

    StringRedisTemplate是使用了构造方法来产生一个redis连接工厂。

    image-20220410190338945

    更多内容欢迎关注我

    展开全文
  • springboot整合Redis

    千次阅读 2022-02-11 17:38:36
    springboot整合Redis
  • springBoot 整合redis

    2018-04-24 11:03:22
    版权声明:本文为博主原创文章,未经博主允许不得转载...)[+]前言在本篇文章中将SpringBoot整合Redis,使用的是RedisTemplate,分别实现了SpringBoot与redis的单机版、集群版、哨兵模式的整合。Maven依赖&lt;!--...
  • SpringBoot 整合redis缓存

    千次阅读 2021-12-24 17:19:44
    1.导入springboot redis依赖 <!--redis--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </...
  • springboot整合redis

    千次阅读 2021-01-04 12:23:25
    工欲善其事必先利其器,学习整合之前我们肯定得先学习一下redis的相关使用方法,才能对两者做整合操作!学习这个整合后,你必须掌握下面几点: 1.Redis介绍 Redis技术栈目前广泛使用于开发领域,掌握Redis技术栈...
  • 如何用SpringBoot整合Redis(详细讲解~)

    千次阅读 多人点赞 2022-07-09 13:54:15
    springboot在现在的版本中操作Redis数据库用到了lettuce,而不是Jedis,如何使用springboot这个技术框架来整合redis呢?
  • springboot 整合 redis

    千次阅读 2021-06-25 00:57:09
    java 操作 jedis ,jedis 是 redis 官方推荐的 java 连接开发工具!使用 Java 操作 redis 中间件 导入依赖 新建 maven 项目,导入 jedis 依赖 <dependencies> <dependency> <groupId>redis....
  • Redis 的安装与使用;SpringBoot 整合 Redis 代码示例
  • jedis是Redis推荐的Java连接Redis客户端,但是实际上springboot2推荐的是连接Redis客户端是lettuce (实际上对应比较流行的客户端还有一个redisson),主要是jedis好久不更新对新的功能支持没有另外的好(本身...
  • Springboot整合redis与缓存

    千次阅读 2021-12-05 19:48:09
    文章目录Springboot整合源码分析整合测试自定义序列化Redis.conf讲解单位包含网络配置通用GENERAL快照SECURITY安全限制CLIENTSAPPEND ONLY 模式Redis持久化RDB触发机制如何恢复rdb文件优点:缺点:AOF(Append Only ...
  • Jedis是Redis官方推荐的连接开发工具,使用java操作Redis中间件,如果要使用java操作redis,那么一定要对redis十分的熟悉 使用Jedis 1.在pom.xml中导入对应的依赖 <!-- jedis依赖 --> <dependency> <...
  • springboot_redis

    2017-04-03 10:55:38
    spring boot 集成redis,demo 对应博客地址:http://blog.csdn.net/woniu211111/article/details/54564308
  • SpringBoot 整合Redis

    2021-05-24 21:35:22
    -- 引入Redis依赖 --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> <!-- ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 9,530
精华内容 3,812
关键字:

springboot整合redis实例

spring 订阅