程序员必看内容连续集之 SpringBoot05 整合Druid&Redis

秃头没秃头

已于 2022-11-25 16:12:48 修改

阅读量1.2k

点赞数 1

文章标签： redis 数据库缓存 spring boot 性能优化

于 2022-11-08 15:46:07 首次发布

本文链接：https://blog.csdn.net/weixin_66110079/article/details/127723850

版权

一、整合Druid

二、集成redis之非注解式开发

三、集成redis之注解式开发

一、整合Druid

1、Druid简介：

Druid是阿里巴巴开源平台上一个数据库连接池实现，它结合了C3P0、DBCP、Proxool等DB池的优点，同时加入了日志监控，可以很好的监控DB池连接和SQL的执行情况，可以说是针对监控而生的DB连接池，可以说是目前最好的连接池之一。

2、Druid的优点

①结合了C3P0、DBCP、Proxool等DB池的优点；

②速度快，且稳定性好；

③可以很好的监控DB池连接和SQL的执行情况。

3、Springboot项目集成Druid

大家也可以参照这个学习网址来学习：

官方学习网址：

druid/druid-spring-boot-starter at master · alibaba/druid · GitHub

接下来我们直接在一个Springboot项目中集成Druid

第①步：导入pom依赖

添加配置，不要最新的，小编测试过SQL监控会失效，就这个版本就可以了

<dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.10</version>
        </dependency>

第②步：整合Druid的配置文件到application.yml文件

#添加druid的源
        type: com.alibaba.druid.pool.DruidDataSource
        druid:
            #2.连接池配置
            #初始化连接池的连接数量 大小，最小，最大
            initial-size: 5
            min-idle: 5
            max-active: 20
            #配置获取连接等待超时的时间
            max-wait: 60000
            #配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
            time-between-eviction-runs-millis: 60000
            # 配置一个连接在池中最小生存的时间，单位是毫秒
            min-evictable-idle-time-millis: 30000
            validation-query: SELECT 1 FROM DUAL
            test-while-idle: true
            test-on-borrow: true
            test-on-return: false
            # 是否缓存preparedStatement，也就是PSCache  官方建议MySQL下建议关闭   个人建议如果想用SQL防火墙 建议打开
            pool-prepared-statements: true
            max-pool-prepared-statement-per-connection-size: 20
            # 配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙
            filter:
                stat:
                    merge-sql: true
                    slow-sql-millis: 5000
            #3.基础监控配置
            web-stat-filter:
                enabled: true
#                配置访问路径 /* 代表所有路径
                url-pattern: /*
                #设置不统计哪些URL
                exclusions: "*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*"
                session-stat-enable: true
                session-stat-max-count: 100
#            druid的访问路径
            stat-view-servlet:
                enabled: true
                url-pattern: /druid/*
                reset-enable: true
                #设置监控页面的登录名和密码
                login-username: admin
                login-password: admin
#               druid配置服务器（本地或者云服务器等）
                allow: 127.0.0.1
                #deny: 192.168.1.100

第③步：启动访问Druid的登录界面并输入账号密码（配置文件中已配置）

二、集成redis之非注解式开发

Springboot项目集成redis

如果重新创建项目，在选择组件时，在非关系数据库是可以看见Redis的组件的，在这博主就不重新创建项目了，而是通过手动引入组件的方法

第①步：导入pom依赖

<!--添加Redis相关依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

第②步：整合Redis的配置文件到application.yml文件

redis:
        #配置主机（这里小编放的是本机的redis）
        host: localhost
        #端口
        port: 6379
        #选择数据库
        database: 0
        #密码
        password: 123456

第③步：增加一个redis的配置类

package com.zq.springboot04.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

@Configuration
public class RedisConfig {
 
    @Bean
    public RedisTemplate<String,Object> getRedisTemplate(RedisConnectionFactory connectionFactory){
        RedisTemplate<String,Object> redisTemplate=new RedisTemplate<>();
 
//        配置序列化器
        //针对于key
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
 
        //针对于value
        redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        redisTemplate.setHashKeySerializer(new GenericJackson2JsonRedisSerializer());
//        redisTemplate.afterPropertiesSet();//根据不同的redis版本
 
        //  connectionFactory是包含了redis的连接信息
        redisTemplate.setConnectionFactory(connectionFactory);
        return redisTemplate;
 
    }
 
}

第④步：测试，将查询数据加入缓存：

package com.zq.springboot04.biz.impl;

import com.zq.springboot04.biz.ClazzBiz;
import com.zq.springboot04.mapper.ClazzMapper;
import com.zq.springboot04.model.Clazz;
import com.zq.springboot04.util.PageBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.Map;
@Service
public class ClazzBizImpl implements ClazzBiz {
    @Autowired
    private ClazzMapper clazzMapper;
    @Autowired
    private RedisTemplate<String,Object> redisTemplate;

    @Override
    public int deleteByPrimaryKey(Integer cid) {
        return clazzMapper.deleteByPrimaryKey(cid);
    }

    @Override
    public int insert(Clazz record) {
        return clazzMapper.insert(record);
    }

    @Override
    public int insertSelective(Clazz record) {
        return clazzMapper.insertSelective(record);
    }

    @Override
    public Clazz selectByPrimaryKey(Integer cid) {
        return clazzMapper.selectByPrimaryKey(cid);
    }

    @Override
    public int updateByPrimaryKeySelective(Clazz record) {
        return clazzMapper.updateByPrimaryKeySelective(record);
    }

    @Override
    public int updateByPrimaryKey(Clazz record) {
        return clazzMapper.updateByPrimaryKey(record);
    }

    @Override
    public List<Clazz> listPager(Clazz clazz, PageBean pageBean) {
        List<Clazz> clazzes = clazzMapper.listPager(clazz);
        //       将班级信息缓存到redis中
        redisTemplate.opsForValue().set("clz_infos",clazzes);
        return clazzes;
    }

    @Override
    public List<Map> listMapPager(Clazz clazz, PageBean pageBean) {
        if(true)
            throw new RuntimeException("查询班级信息异常，异常存在于ClazzBizImpl.list。。。。");
        return clazzMapper.listMapPager(clazz);
    }
}

我们发现redis中已经有了我们的缓存那么就说明我们整合不用注解版的redis版本成功了

三、集成redis之注解式开发

集成注解式也是大同小异的，我们一样需要一下步骤：

第①步：导入pom依赖

<!--添加Redis相关依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

第②步：整合Redis的配置文件到application.yml文件

redis:
        #配置主机（这里小编放的是本机的redis）
        host: localhost
        #端口
        port: 6379
        #选择数据库
        database: 0
        #密码
        password: 123456

第③步：增加一个redis的配置类（这里就和非注解式不一样了）

package com.zq.springboot04.config;

import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import java.time.Duration;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

/**
 * @author 张强
 *
 * @Configuration:凡是被@Configuration注解所标记，就代表当前这个类为配置类
 * 而配置类等价于ssm阶段中spring-*.xml这一类的配置文件
 *
 * spring-*.xml
 * <bean id="" class=""></bean>
 * 将redistemplate进行配置,然后交给spring进行管理
 */
@Configuration
//开启缓存
@EnableCaching
public class RedisConfig {
    private final int defaultExpireTime = 600;

    private final int userCacheExpireTime = 60;

    private final String userCacheName = "test";
    @Bean
    public RedisTemplate<String,Object> getRedisTemplate(RedisConnectionFactory connectionFactory){
        RedisTemplate<String,Object> redisTemplate=new RedisTemplate<>();

//        配置序列化器
        //针对于key
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());

        //针对于value
        redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        redisTemplate.setHashKeySerializer(new GenericJackson2JsonRedisSerializer());
//        redisTemplate.afterPropertiesSet();//根据不同的redis版本

        //  connectionFactory是包含了redis的连接信息
        redisTemplate.setConnectionFactory(connectionFactory);
        return redisTemplate;

    }
    @Bean
    public RedisCacheManager redis(RedisConnectionFactory connectionFactory){
        RedisCacheConfiguration defaultCacheConfig = RedisCacheConfiguration.defaultCacheConfig();
        // 设置缓存管理器管理的缓存的默认过期时间
        defaultCacheConfig = defaultCacheConfig.entryTtl(Duration.ofSeconds(defaultExpireTime))
                // 设置 key为string序列化
                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()))
                // 设置value为json序列化
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer()))
                // 不缓存空值
                .disableCachingNullValues();

        Set<String> cacheNames = new HashSet<>();
        cacheNames.add(userCacheName);

        // 对每个缓存空间应用不同的配置
        Map<String, RedisCacheConfiguration> configMap = new HashMap<>();
        configMap.put(userCacheName, defaultCacheConfig.entryTtl(Duration.ofSeconds(userCacheExpireTime)));

        RedisCacheManager cacheManager = RedisCacheManager.builder(connectionFactory)
                .cacheDefaults(defaultCacheConfig)
                .initialCacheNames(cacheNames)
                .withInitialCacheConfigurations(configMap)
                .build();

        return cacheManager;
    }
}