一，集成Druid

学习地址：

主要讲监控

基于springboot视图渲染技术上增加代码

1.1 增加pom依赖

1.2 先在application.yml中添加Druid的数据源

1.3 其次在全局配置文件application.yml中添加所需的配置

配置截图：

配置解析

1.4 启动项目查看监控

项目截图

监控截图

查看监控的请求

URL监控

SQL监控

数据源监控

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

2.1 添加pom依赖

2.2 添加配置文件

以上就是集成redis的配置

将redistemplate进行配置，然后交给spring进行管理

创建一个配置类

使用查询功能

查看redis缓存

三，集成redis之注解缓存开发

3.1 添加配置方法

在类上面添加一个开启缓存的注解 @EnableCaching

利用单个查询的方法来实现缓存

Clazz

ClazzController

启动项目，执行查询单个的方法

一，集成Druid

学习地址：

druid/druid-spring-boot-starter at master · alibaba/druid · GitHub阿里云计算平台DataWorks(https://help.aliyun.com/document_detail/137663.html) 团队出品，为监控而生的数据库连接池 - druid/druid-spring-boot-starter at master · alibaba/druidhttps://github.com/alibaba/druid/tree/master/druid-spring-boot-starter

主要讲监控

基于springboot视图渲染技术上增加代码

博客地址：(22条消息) springboot视图渲染技术（超详细）_小刘学编程.的博客-CSDN博客https://blog.csdn.net/weixin_64313980/article/details/127720237

1.1 增加pom依赖

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

1.2 先在application.yml中添加Druid的数据源

type: com.alibaba.druid.pool.DruidDataSource

1.3 其次在全局配置文件application.yml中添加所需的配置

        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
            stat-view-servlet:
                enabled: true
                url-pattern: /druid/*
                reset-enable: true
                #设置监控页面的登录名和密码
                login-username: admin
                login-password: admin
                allow: 127.0.0.1
                #deny: 192.168.1.100

配置截图：

配置解析

最后的allow是允许本地访问，否则后期操作是登录不了的

1.4 启动项目查看监控

项目截图

监控截图

访问路径，由配置文件中配置的访问路径而定，输入localhost：8080/sprboot04/druid即可

登录成功

查看监控的请求

URL监控

目前只有查询数据的请求

当我们点击增加时发送一条请求再次监控

查看监控情况新增的请求被监控此后增删改查的请求都会被监控到

SQL监控

请求执行的sql语句

数据源监控

以及 sql防火墙 web应用 session监控 spring监控 json api

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

如果是新建了项目的话在创建的时候勾选此组件即可整合reids成功，而本期我们选择新增pom

依赖来整合Redis

2.1 添加pom依赖

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

2.2 添加配置文件

redis:
    host: 192.168.100.132 (访问ip地址)
    prot: 6379 (redis端口号)
    database: 0（选择0号数据库）
    password: 123456(密码)

这里小刘是先打开了虚拟机启动了redis服务

以上就是集成redis的配置

redisTemplate 默认SpringBoot是没有设置管理redistemplate

接下来要做的：

将redistemplate进行配置，然后交给spring进行管理

创建一个配置类

RedisConfig

package com.ljj.spboot04.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;

/**
 * @author ljj
 * @site www.xiaomage.com
 * @company
 * @create  2022-11-24 15:11
 *
 * @Configuration：凡是被@Configuration注解所标记 被代表当前这个类为配置类
 * 而配置类等价于ssm中spring-*.xml这一类的配置文件
 * <p>
 * spring-*.xml
 * <bean id="" class=""></bean>
 * <p>
 *     将redistemplate进行配置，然后交给spring进行管理
 * */
@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.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());
//        redisTemplate.afterPropertiesSet(); //根据不同的版本决定 可写可不写
        
//        connectionFactory是包含了redis的连接信息
        redisTemplate.setConnectionFactory(connectionFactory);
        return redisTemplate;
    }
}

修改impl层中的查询学生的方法，将查询到的班级缓存到redist中

记得将实体类进行实例化

public class Clazz implements Serializable {

package com.ljj.spboot04.biz.impl;

import com.ljj.spboot04.biz.ClazzBiz;
import com.ljj.spboot04.mapper.ClazzMapper;
import com.ljj.spboot04.model.Clazz;
import com.ljj.spboot04.util.PageBean;
import jdk.nashorn.internal.ir.ReturnNode;
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 redisTemplate;

    @Override
    public int deleteByPrimaryKey(Integer cid) {
//        System.out.println("不做任何操作...");
        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之注解缓存开发

3.1 添加配置方法

在类上面添加一个开启缓存的注解 @EnableCaching

以及添加设置缓存的方法

package com.ljj.spboot04.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;
/*
凡是被@Configuration注解所标记，就代表当前类为配置类 而配置类等价于ssm阶段spring-*.xml这一类的配置文件
 我们要做的：将redistemplate进行配置，然后交给spring进行管理

 @EnableCaching 替代了下面的配置
 */
@EnableCaching
@Configuration
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;
    }

}

利用单个查询的方法来实现缓存

，不使用之前的查询全部的方法来缓存，将它注掉

在单个查询的方法上做修改

Clazz

ClazzController

    @ResponseBody
    @RequestMapping("/load")
    public Clazz load(Clazz clazz, HttpServletRequest request) {
        return clazzBiz.selectByPrimaryKey(clazz.getCid());
    }