SpringBoot之Redis整合——搭配mysql

最新推荐文章于 2024-05-07 00:18:11 发布
最新推荐文章于 2024-05-07 00:18:11 发布
阅读量1.3k 收藏 16
点赞数 3
分类专栏： springboot 文章标签： redis mysql spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42137703/article/details/108367838
版权

SpringBoot之Redis整合——搭配mysql

 

 

第一次学习整合Redis知识，很多地方学艺不精，如有不足之处还需指点！

直接开干

 

步骤

1.工程目录结构

创建工程的步骤我就不操作了，比较简单

目录结构如下：

 

2.pom.xml依赖

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--redis驱动-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <!--spring2.0集成redis所需common-pool2-->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>
        <!--jdbc驱动-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <!--mybatis驱动-->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.1.3</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <!--        导入阿里的数据库连接池技术-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.17</version>
        </dependency>

 3.创建数据库account表

CREATE TABLE `account` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(20) DEFAULT NULL,
  `money` double DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

4.application.yml配置

spring:
  # 数据库配置----------------
  datasource:
    username: root
    password: 
    url: jdbc:mysql://localhost:3306/ssm?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8
    driver-class-name: com.mysql.cj.jdbc.Driver
    type: com.alibaba.druid.pool.DruidDataSource
  # Redis配置----------------
  redis:
    # redis数据库索引
    database: 0
    # 要连接的主机ip
    host: 
    #连接密码
    password: 
    # port连接的端口
    port: 6379
    #连接池
    jedis:
      pool:
        max-active: 5 #最大连接数（负数表示没有限制）
        min-idle: 0   #最小空闲连接
        max-idle: 5   #最大空闲连接
        max-wait: -1  #最大阻塞等待时间（负数表示没有限制）
    timeout: 6000     #连接超时时间（毫秒）

5.entity包下创建与account表对应的类

public class Account implements Serializable {
    private Integer id;
    private String name;
    private Double money;

    //getter setter toString...
}

6.在mapper包下创建AccoumtMapper接口，用来操作数据表用的

@Mapper
@Repository
public interface AccountMapper {

    /**
     * 查询指定id的用户信息
     * @param id
     * @return
     */
    @Select("select * from account where id = #{id}")
    public Account queryAccountById(@Param("id") Integer id);
}

7.在server包下创建接口和对应的Impl实例对象

AccountService

public interface AccountService {
    public Account queryAccountById(Integer id);
    //.....
}

AccountServiceImpl

@Service
public class AccountServiceImpl implements AccountService {

    @Autowired
    private AccountMapper accountMapper;

    @Override
    public Account queryAccountById(Integer id) {
        return accountMapper.queryAccountById(id);
    }
}

8.测试数据库是否能够访问成功

从图中可以看出，是可以访问数据库且可以对数据表进行操作的

9.在config包下编写RedisConfig配置类

@Configuration  //这是一个配置类
@EnableCaching  //开启缓存机制
public class RedisConfig extends CachingConfigurerSupport {
    @Bean
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<Object, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        // 使用Jackson2JsonRedisSerialize 替换默认的jdkSerializeable序列化
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(objectMapper);
        // 设置value的序列化规则和 key的序列化规则
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }
}

10.编写RedisUtils工具类，用来操作Redis数据库使用的，该工具类是直接从网上随便摘取的，如有冒犯到的还请见谅

@Service
public class RedisUtils {
    @Autowired
    private RedisTemplate redisTemplate;

    private static double size = Math.pow(2, 32);

    /**
     * 写入缓存
     *
     * @param key
     * @param offset   位 8Bit=1Byte
     * @return
     */
    public boolean setBit(String key, long offset, boolean isShow) {
        boolean result = false;
        try {
            ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
            operations.setBit(key, offset, isShow);
            result = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 写入缓存
     *
     * @param key
     * @param offset
     * @return
     */
    public boolean getBit(String key, long offset) {
        boolean result = false;
        try {
            ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
            result = operations.getBit(key, offset);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }


    /**
     * 写入缓存
     *
     * @param key
     * @param value
     * @return
     */
    public boolean set(final String key, Object value) {
        boolean result = false;
        try {
            ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
            operations.set(key, value);
            result = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 写入缓存设置时效时间
     *
     * @param key
     * @param value
     * @return
     */
    public boolean set(final String key, Object value, Long expireTime) {
        boolean result = false;
        try {
            ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
            operations.set(key, value);
            redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
            result = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 批量删除对应的value
     *
     * @param keys
     */
    public void remove(final String... keys) {
        for (String key : keys) {
            remove(key);
        }
    }


    /**
     * 删除对应的value
     *
     * @param key
     */
    public void remove(final String key) {
        if (exists(key)) {
            redisTemplate.delete(key);
        }
    }

    /**
     * 判断缓存中是否有对应的value
     *
     * @param key
     * @return
     */
    public boolean exists(final String key) {
        return redisTemplate.hasKey(key);
    }

    /**
     * 读取缓存
     *
     * @param key
     * @return
     */
    public Object get(final String key) {
        Object result = null;
        ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
        result = operations.get(key);
        return result;
    }

    /**
     * 哈希 添加
     *
     * @param key
     * @param hashKey
     * @param value
     */
    public void hmSet(String key, Object hashKey, Object value) {
        HashOperations<String, Object, Object> hash = redisTemplate.opsForHash();
        hash.put(key, hashKey, value);
    }

    /**
     * 哈希获取数据
     *
     * @param key
     * @param hashKey
     * @return
     */
    public Object hmGet(String key, Object hashKey) {
        HashOperations<String, Object, Object> hash = redisTemplate.opsForHash();
        return hash.get(key, hashKey);
    }

    /**
     * 列表添加
     *
     * @param k
     * @param v
     */
    public void lPush(String k, Object v) {
        ListOperations<String, Object> list = redisTemplate.opsForList();
        list.rightPush(k, v);
    }

    /**
     * 列表获取
     *
     * @param k
     * @param l
     * @param l1
     * @return
     */
    public List<Object> lRange(String k, long l, long l1) {
        ListOperations<String, Object> list = redisTemplate.opsForList();
        return list.range(k, l, l1);
    }

    /**
     * 集合添加
     *
     * @param key
     * @param value
     */
    public void add(String key, Object value) {
        SetOperations<String, Object> set = redisTemplate.opsForSet();
        set.add(key, value);
    }

    /**
     * 集合获取
     *
     * @param key
     * @return
     */
    public Set<Object> setMembers(String key) {
        SetOperations<String, Object> set = redisTemplate.opsForSet();
        return set.members(key);
    }

    /**
     * 有序集合添加
     *
     * @param key
     * @param value
     * @param scoure
     */
    public void zAdd(String key, Object value, double scoure) {
        ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
        zset.add(key, value, scoure);
    }

    /**
     * 有序集合获取
     *
     * @param key
     * @param scoure
     * @param scoure1
     * @return
     */
    public Set<Object> rangeByScore(String key, double scoure, double scoure1) {
        ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
        redisTemplate.opsForValue();
        return zset.rangeByScore(key, scoure, scoure1);
    }


    //第一次加载的时候将数据加载到redis中
    public void saveDataToRedis(String name) {
        double index = Math.abs(name.hashCode() % size);
        long indexLong = new Double(index).longValue();
        boolean availableUsers = setBit("availableUsers", indexLong, true);
    }

    //第一次加载的时候将数据加载到redis中
    public boolean getDataToRedis(String name) {

        double index = Math.abs(name.hashCode() % size);
        long indexLong = new Double(index).longValue();
        return getBit("availableUsers", indexLong);
    }

    /**
     * 有序集合获取排名
     *
     * @param key 集合名称
     * @param value 值
     */
    public Long zRank(String key, Object value) {
        ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
        return zset.rank(key,value);
    }


    /**
     * 有序集合获取排名
     *
     * @param key
     */
    public Set<ZSetOperations.TypedTuple<Object>> zRankWithScore(String key, long start,long end) {
        ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
        Set<ZSetOperations.TypedTuple<Object>> ret = zset.rangeWithScores(key,start,end);
        return ret;
    }

    /**
     * 有序集合添加
     *
     * @param key
     * @param value
     */
    public Double zSetScore(String key, Object value) {
        ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
        return zset.score(key,value);
    }


    /**
     * 有序集合添加分数
     *
     * @param key
     * @param value
     * @param scoure
     */
    public void incrementScore(String key, Object value, double scoure) {
        ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
        zset.incrementScore(key, value, scoure);
    }


    /**
     * 有序集合获取排名
     *
     * @param key
     */
    public Set<ZSetOperations.TypedTuple<Object>> reverseZRankWithScore(String key, long start, long end) {
        ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
        Set<ZSetOperations.TypedTuple<Object>> ret = zset.reverseRangeByScoreWithScores(key,start,end);
        return ret;
    }

    /**
     * 有序集合获取排名
     *
     * @param key
     */
    public Set<ZSetOperations.TypedTuple<Object>> reverseZRankWithRank(String key, long start, long end) {
        ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
        Set<ZSetOperations.TypedTuple<Object>> ret = zset.reverseRangeWithScores(key, start, end);
        return ret;
    }
}

11. 测试连接Redis，获取数据

在Redis创建一个键值数据

我这里通过Java代码直接去获取的话会报错

这里可能是序列化的原因，但我这个小菜鸟不知道怎么去改（求解）

然后查了资料：

helloworld的数据结构为不String,应该用’“helloworld”'或者"/“helloworld/”"

然后我就去redis上改了数据格式，就能成功的获取数据了。

12.编写AccountController

       先从Redis缓存中获取数据，如果没有，就到数据库中获取数据，再将数据写入缓存，这样下次再获取相同的id时，可直接从缓存获取，无需从查找数据库，减少数据库的开销。

@Controller
public class AccountController {
    @Autowired
    private RedisUtils redisUtils;

    @Autowired
    private AccountService service;

    @ResponseBody
    @GetMapping("/byId/{id}")
    public Account queryAccountById(@PathVariable Integer id){
        System.out.println(id);
        Account val = (Account)redisUtils.get(id.toString());
        if(val != null){
            return val;
        }else{
            Account account = service.queryAccountById(id);
            if(account == null){
                return null;
            }
            redisUtils.set(account.getId().toString(),account);
            return account;
        }
    }
}

再进行最后的测试

首先Redis只有 welcome这一个key

运行SpringBootApplication入口程序

使用浏览器来查询id为3的用户

再查看是否Redis数据库，发现数据是写成功的

再查询一个数据，没问题

查id为666的没有

总结

        关于这次学习Redis整合还有很多地方不清除，改进的地方也还有许多，比如上面提到的get数据的错误问题，以及解决如何存储中文显示问题。但学习之路很漫长，一步一步走，脚踏实地，默默的成长。也祝在编程路上的伙伴们，能够坚持，加油！

小白集团
关注
  • 3
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
redis整合mysql_SpringBoot整合redis和Mysql(测试)
weixin_28887297的博客
01-18 189
刚接触springboot，初次整合，简单的数据连接，分享一下自己的配置。1.目录结构：2.参数配置application.yml#jsp文件路径，默认路径：src/main/webapp,spring:#redis配置redis:host: localhostport:6379password:123456# 连接超时时间 单位 ms(毫秒)timeout:3000max-idle: 200ma...
SpringBoot+mysql+Redis 整合
u012299679的博客
04-07 868
本文通过记录SpringBoot+springMVC+redis+mysql来实现web项目中增删改查的具体操作。|______Webdemo1Application（springboot启动类）2.3创建RedisConfig模板类。2.3创建RedisConfig模板类。2.2创建User类与UserDao。2.2创建User类与UserDao。2.5创建Controller类。2.5创建Controller类。2.7 配置文件pom.xml。2.4创建service类。2.4创建service类。
springboot+Mybatis+Redis项目搭建（非常适合新上手springboot或不经常用java写后端的朋友）
qq_74177889的博客
05-07 884
Data/*** 操作成功*//*** 对象创建成功*//*** 请求已经被接受*//*** 操作已经执行成功，但是没有返回数据*//*** 资源已被移除*//*** 重定向*//*** 资源没有被修改*//*** 参数列表错误（缺少，格式不匹配）*//*** 未授权*//*** 访问受限，授权过期*//*** 资源，服务未找到*//*** 不允许的http方法*//*** 资源冲突，或者资源被锁*/
springboot+mysql+redis集成Demo
11-15
资源内容请参考https://blog.csdn.net/qq_40448026/article/details/84110947
Redis和MySQL的结合方案
weixin_30823001的博客
03-31 1737
转载：http://m.blog.csdn.net/article/details?id=50586990 方案一： 程序同时写Redis和MySQL 读Redis 方案二： 程序写MySQL， 使用Gearman调用MySQL的UDF，完成对Redis的写 读Redis 方案三： 程序写MySQL， 解析binlog，数据放入队列写Redis 读...
SpringBoot 整合Redis 数据库
xiangzhihong8的专栏
03-27 5382
Redis简介 Redis（官网：https://redis.io）是一个基于内存的日志型可持久化的缓存数据库，保存形式为key-value格式，Redis完全免费开源，它使用ANSI C语言编写。与其他的key - value缓存产品一样，Redis具有以下三个特点。 • Redis支持数据的持久化，可以将内存中的数据保存在磁盘中，重启的时候可以再次加载进行使用； • Redis不...
Redis SpringBoot 配置 整合
07-02 109
1.首先导入使用Maven导入jar包 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> <dependency> <groupId>com.alibaba&lt.
SpringBoot整合redis（超简单配置）
学海无涯~
07-01 5628
看了网上很多springboot整合redis的文章，大多数都是自己写一个javaConfig配置文件，然后注入工厂、模版、连接池。完全没有发挥springboot的优势：约定大于配置 1&gt; 添加依赖： &lt;dependency&gt; &lt;groupId&gt;org.springframework.data&lt;/group...
基于springboot下对mysql，mongodb，redis支持ipv6的改造（csdn）————程序.pdf
12-05
基于springboot下对mysql，mongodb，redis支持ipv6的改造（csdn）————程序
SpringBoot实战系列——数据访问=(Mybatis+Redis)
uuqaz的博客
04-08 1706
前言 在开发中我们通常会对数据库的数据进行操作，SpringBoot对关系性和非关系型数据库的访问操作都提供了非常好的整合支持。SpringData是spring提供的一个用于简化数据库访问、支持云服务的开源框架。它是一个伞状项目，包含大量关系型和非关系型数据库数据访问解决方案，让我们快速简单的使用各种数据访问技术，springboot默认采用整合springdata方式统一的访问层，通过添加大量的自动配置，引入各种数据访问模板Trmplate以及统一的Repository接口，从而达到简化数据访问操..
SpringBoot整合MyBatis和Redis
weixin_47541976的博客
09-07 660
SpringBoot整合Mybatis和Redis
SpringCloud+MyBatis+Redis整合—— 超详细实例（一）
山鹰的专栏
01-11 1521
SpringCloud+MyBatis+Redis整合—— 超详细实例（一） 1、SpringCloud+MyBatis 　　MyBatis 是一款优秀的轻量级半自动持久层框架，与之相对应的还有hibernate框架。①  　  话不多说，接下来搭建SpringCloud+MyBatis环境： 第一步，在SpringCloud环境中的pom.xml中加入： 1 &lt;!-- 引用...
SpringBoot基本操作（四）——SpringBoot使用RedisTemplate整合Redis（有demo）
热门推荐
zhulier1124的博客
08-28 5万+
SpringBoot2.0笔记 （一）SpringBoot基本操作——环境搭建及项目创建（有demo） （二）SpringBoot基本操作——使用IDEA打war包发布及测试 （三）SpringBoot基本操作——SpringBoot整合SpringDataJpa（有demo） （四）SpringBoot基本操作——SpringBoot使用RedisTemplate整合Redis（有dem...
Redis和MySQL的结合方式
喝醉酒的小白
04-06 448
方式一 方式二 利用Gearman进行Mysql到Redis的复制 方式三 利用Canal完成Mysql数据同步Redis 方式四
redis配合mysql
weixin_44783160的博客
11-01 893
################redis配合mysql###################re# 数据访问流程：client -> app -> redis -> mysql -> redis -> client 客户端用app访问，先在redis里读数据，因为快，redis没有才去mysql读，读完保存在redis里，然后返回客户端，下次再读就快 【1】:【se...
SpringBoot整合Mysql、Redis
Jiangtagong的博客
02-16 3991
SpringBoot整合Mysql、Redis
redis+mysql组合
qq_36959774的博客
03-14 1944
1、原理？ 一般都是用redis作缓存，只用来读数据（将数据库中的数据读出来放到redis，下一次读取时取redis中的数据），而mysql则用来做数据的持久话； 执行过程：当需要查询数据时，先在redis缓存中找对应的键值对，若不存在，则执行对应的sql，然后再把查询的sql结果放到redis的缓存中； 2、redis的作用？ redis可以做缓存，也...
redis+mysql
LinuxOs of Internet
03-11 345
一.Redis 作 mysql 的缓存服务器 客户端通过访问apache服务，首次获取从mysql数据库中，之后就从redis中获取 php 的 redis 扩展提取码:1ykg server1 1. 安装 lnmp 环境之web服务器，mysql拓展 yum install httpd php php-mysql.x86_64 -y 2. 安装 php 的 redis 扩展 yum install php-fpm-5.4.16-46.el7.x86_64.rpm php-pecl-igbinary-1.
Redis和MySQL如何合作
m0_57236802的博客
09-23 1560
Redis 和 MySQL 是两种不同类型的数据库，但它们可以很好地配合使用，以提供更高效、更快速的数据存储和检索。
springboot和redis消息队列插入mysql
最新发布
07-10
Spring Boot 和 Redis 搭配 MySQL 使用的消息队列方案通常涉及到以下几个步骤： 1. **Spring Boot 配置**：首先，在 Spring Boot 项目中添加对 Redis 和 MySQL 的依赖，例如使用 Spring Data JPA 对于数据库操作，`spring-boot-starter-data-jpa`，以及 Spring Cloud Starter Actuator 或 Spring Cloud Stream 对于微服务集成。 2. **Redis设置**：配置 Redis 集群作为消息队列的存储，Spring Boot 提供了 Spring Data Redis 或者 RedisTemplate 来连接和管理 Redis。 3. **消息生产者**：使用 Spring Cloud Stream 或 RabbitMQ 发送者组件创建一个消费者，它将数据发送到 Redis 队列，如 RolloverQueue 或 List 实现。 4. **消费监听**：通过 RedisTemplate 或 JedisPoolConnectionFactory 创建消费者监听 Redis 队列，当有新的消息到达时，从 Redis 中取出并处理。 5. **MySQL持久化**：消费过程中的数据需要存储到 MySQL 中，可以设置一个数据库操作的 Service，接收从 Redis 取出的消息，并通过 JPA 进行 CRUD 操作。 6. **事务管理**：如果 Redis 和 MySQL 数据一致性很重要，可以考虑使用 Spring Transaction 管理跨库操作，保证数据的一致性。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值