springboot整合其他项目

最新推荐文章于 2023-07-15 20:00:03 发布

小刘学编程.

最新推荐文章于 2023-07-15 20:00:03 发布

阅读量761

点赞数

本文链接：https://blog.csdn.net/weixin_64313980/article/details/127981234

版权

一，集成Druid

学习地址：

主要讲监控

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

1.1 增加pom依赖

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

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

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

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

一，集成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());
    }

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

此次使用的test是设置的60秒的缓存时间

再使用默认的缓存时间600秒，修改方法

ClazzBiz

启动项目查看单个的方法，查看缓存

ttl为600秒

小刘学编程.

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
springboot整合其他项目

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

扫一扫