• springboot整合其它项目

    目录

    一、集成Druid

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

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

    一、集成Druid

    学习地址：

    https://github.com/alibaba/druid/tree/master/druid-spring-boot-starter

    添加配置，不要最新的，进过测试SQL监控失效

    pom依赖：(注意别放错了哦)

     
                com.alibaba
                druid-spring-boot-starter
                1.1.10
     

    添加Druid配置到yml文件：

    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
    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

    用户名和密码对应如下： 

     

     

    当运行了http://localhost:8080/spboot04/clz/list 时，下面URL监控就会显示：

     （SQL监控也能看到）

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

    pom.xml：

    

    org.springframework.boot
    spring-boot-starter-data-redis

     yml配置：

    1. mybatis:
    2.     mapper-locations: classpath:mappers/*xml
    3.     type-aliases-package: com.ycx.spboot04.model
    4. server:
    5.     port: 8080
    6.     servlet:
    7.         context-path: /spboot04
    8. spring:
    9.     application:
    10.         name: spboot04
    11.     datasource:
    12.         driver-class-name: com.mysql.jdbc.Driver
    13.         name: defaultDataSource
    14.         password: 1234
    15.         url: jdbc:mysql://localhost:3306/yjy?useUnicode=true&characterEncoding=UTF-8
    16.         username: root
    17.         type: com.alibaba.druid.pool.DruidDataSource
    18.         druid:
    19.             #2.连接池配置
    20.             #初始化连接池的连接数量 大小，最小，最大
    21.             initial-size: 5
    22.             min-idle: 5
    23.             max-active: 20
    24.             #配置获取连接等待超时的时间
    25.             max-wait: 60000
    26.             #配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
    27.             time-between-eviction-runs-millis: 60000
    28.             # 配置一个连接在池中最小生存的时间，单位是毫秒
    29.             min-evictable-idle-time-millis: 30000
    30.             validation-query: SELECT 1 FROM DUAL
    31.             test-while-idle: true
    32.             test-on-borrow: true
    33.             test-on-return: false
    34.             # 是否缓存preparedStatement，也就是PSCache  官方建议MySQL下建议关闭   个人建议如果想用SQL防火墙 建议打开
    35.             pool-prepared-statements: true
    36.             max-pool-prepared-statement-per-connection-size: 20
    37.             # 配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙
    38.             filter:
    39.                 stat:
    40.                     merge-sql: true
    41.                     slow-sql-millis: 5000
    42.             #3.基础监控配置
    43.             web-stat-filter:
    44.                 enabled: true
    45.                 url-pattern: /*
    46.                 #设置不统计哪些URL
    47.                 exclusions: "*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*"
    48.                 session-stat-enable: true
    49.                 session-stat-max-count: 100
    50.             stat-view-servlet:
    51.                 enabled: true
    52.                 url-pattern: /druid/*
    53.                 reset-enable: true
    54.                 #设置监控页面的登录名和密码
    55.                 login-username: admin
    56.                 login-password: admin
    57.                 allow: 127.0.0.1
    58.                 #deny: 192.168.1.100
    59.     freemarker:
    60.         cache: false
    61.         charset: utf-8
    62.         expose-request-attributes: true
    63.         expose-session-attributes: true
    64.         suffix: .ftl
    65.         template-loader-path: classpath:/templates/
    66. #    resources:
    67. #        static-locations: classpath:/static/# 应用服务 WEB 访问端口
    68.     mvc:
    69.         static-path-pattern: /static/**
    70.     redis:
    71.         host:192.168.122.128
    72.     password: 
    73.         port: 6379
    74.         database: 0
    75.     pagehelper:
    76.         reasonable: true
    77.         supportMethodsArguments: true
    78.         page-size-zero: true
    79.         helper-dialect: mysql
    80. #logging:
    81. #    level:
    82. #        com.ycx.spboot04:debug

    RedisConfig ：

    1. package com.ycx.spboot04.config;
    2.  
    3. import org.springframework.context.annotation.Bean;
    4. import org.springframework.context.annotation.Configuration;
    5. import org.springframework.data.redis.connection.RedisConnectionFactory;
    6. import org.springframework.data.redis.core.RedisTemplate;
    7. import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
    8. import org.springframework.data.redis.serializer.StringRedisSerializer;
    9.  
    10. /**
    11.  * @author 杨总
    12.  * @create 2022-11-02 22:03
    13.  *
    14.  * @Configuration:凡是被@Configuration注解所标记，就代表当前这个类为配置类
    15.  * 而配置类等价于ssm阶段中spring-*.xml这一类的配置文件
    16.  *
    17.  * spring-*.xml
    18.  * 
    19.  * 将redistemplate进行配置,然后交给spring进行管理
    20.  */
    21. @Configuration
    22. public class RedisConfig {
    23.  
    24.     @Bean
    25.     public RedisTemplate<String,Object> getRedisTemplate(RedisConnectionFactory connectionFactory){
    26.         RedisTemplate<String,Object> redisTemplate=new RedisTemplate<>();
    27.  
    28. //        配置序列化器
    29.         //针对于key
    30.         redisTemplate.setKeySerializer(new StringRedisSerializer());
    31.         redisTemplate.setHashKeySerializer(new StringRedisSerializer());
    32.  
    33.         //针对于value
    34.         redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
    35.         redisTemplate.setHashKeySerializer(new GenericJackson2JsonRedisSerializer());
    36. //        redisTemplate.afterPropertiesSet();//根据不同的redis版本
    37.  
    38.         //  connectionFactory是包含了redis的连接信息
    39.         redisTemplate.setConnectionFactory(connectionFactory);
    40.         return redisTemplate;
    41.  
    42.     }
    43.  
    44. }

     ClazzBizImpl ：

    1. package com.ycx.spboot04.biz.impl;
    2.  
    3. import com.ycx.spboot04.biz.ClazzBiz;
    4. import com.ycx.spboot04.mapper.ClazzMapper;
    5. import com.ycx.spboot04.model.Clazz;
    6. import com.ycx.spboot04.util.PageBean;
    7. import org.springframework.beans.factory.annotation.Autowired;
    8. import org.springframework.data.redis.core.RedisTemplate;
    9. import org.springframework.stereotype.Service;
    10.  
    11. import java.util.List;
    12. import java.util.Map;
    13.  
    14.  
    15. @Service
    16. public class ClazzBizImpl implements ClazzBiz {
    17.     @Autowired
    18.     private ClazzMapper clazzMapper;
    19.     @Autowired
    20.     private RedisTemplate<String,Object> redisTemplate;
    21.     @Override
    22.     public int deleteByPrimaryKey(Integer cid) {
    23.         System.out.println("不做任何操作...");
    24.         return clazzMapper.deleteByPrimaryKey(cid);
    25. //        return 0;
    26.     }
    27.  
    28.     @Override
    29.     public int insert(Clazz record) {
    30.         return clazzMapper.insert(record);
    31.     }
    32.  
    33.     @Override
    34.     public int insertSelective(Clazz record) {
    35.         return clazzMapper.insertSelective(record);
    36.     }
    37.  
    38.     @Override
    39.     public Clazz selectByPrimaryKey(Integer cid) {
    40.         return clazzMapper.selectByPrimaryKey(cid);
    41.     }
    42.  
    43.     @Override
    44.     public int updateByPrimaryKeySelective(Clazz record) {
    45.         return clazzMapper.updateByPrimaryKeySelective(record);
    46.     }
    47.  
    48.     @Override
    49.     public int updateByPrimaryKey(Clazz record) {
    50.         return clazzMapper.updateByPrimaryKey(record);
    51.     }
    52.  
    53.     @Override
    54.     public List<Clazz> listPager(Clazz clazz, PageBean pageBean) {
    55.         List<Clazz> clazzes = clazzMapper.listPager(clazz);
    56.         //       将班级信息缓存到redis中
    57.         redisTemplate.opsForValue().set("clz_infos",clazzes);
    58.         return clazzes;
    59.     }
    60.  
    61.     @Override
    62.     public List<Map> listMapPager(Clazz clazz, PageBean pageBean) {
    63.         if(true)
    64.             throw new RuntimeException("查询班级信息异常，异常存在于ClazzBizImpl.list。。。。");
    65.         return clazzMapper.listMapPager(clazz);
    66.     }
    67. }

     

     测试，记得打开虚拟机，再打开redis查看：

     

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

    注解式缓存

    RedisConfig ：

    1. package com.ycx.spboot04.config;
    2.  
    3. import org.springframework.context.annotation.Bean;
    4. import org.springframework.context.annotation.Configuration;
    5. import org.springframework.data.redis.cache.RedisCacheConfiguration;
    6. import org.springframework.data.redis.cache.RedisCacheManager;
    7. import org.springframework.data.redis.connection.RedisConnectionFactory;
    8. import org.springframework.data.redis.core.RedisTemplate;
    9. import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
    10. import org.springframework.data.redis.serializer.RedisSerializationContext;
    11. import org.springframework.data.redis.serializer.StringRedisSerializer;
    12.  
    13. import java.time.Duration;
    14. import java.util.HashMap;
    15. import java.util.HashSet;
    16. import java.util.Map;
    17. import java.util.Set;
    18.  
    19. /**
    20.  * @author 杨总
    21.  * @create 2022-11-02 22:03
    22.  *
    23.  * @Configuration:凡是被@Configuration注解所标记，就代表当前这个类为配置类
    24.  * 而配置类等价于ssm阶段中spring-*.xml这一类的配置文件
    25.  *
    26.  * spring-*.xml
    27.  * 
    28.  * 将redistemplate进行配置,然后交给spring进行管理
    29.  */
    30. @Configuration
    31. public class RedisConfig {
    32.     private final int defaultExpireTime = 600;
    33.  
    34.     private final int userCacheExpireTime = 60;
    35.  
    36.     private final String userCacheName = "test";
    37.     @Bean
    38.     public RedisTemplate<String,Object> getRedisTemplate(RedisConnectionFactory connectionFactory){
    39.         RedisTemplate<String,Object> redisTemplate=new RedisTemplate<>();
    40.  
    41. //        配置序列化器
    42.         //针对于key
    43.         redisTemplate.setKeySerializer(new StringRedisSerializer());
    44.         redisTemplate.setHashKeySerializer(new StringRedisSerializer());
    45.  
    46.         //针对于value
    47.         redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
    48.         redisTemplate.setHashKeySerializer(new GenericJackson2JsonRedisSerializer());
    49. //        redisTemplate.afterPropertiesSet();//根据不同的redis版本
    50.  
    51.         //  connectionFactory是包含了redis的连接信息
    52.         redisTemplate.setConnectionFactory(connectionFactory);
    53.         return redisTemplate;
    54.  
    55.     }
    56.     @Bean
    57.     public RedisCacheManager redis(RedisConnectionFactory connectionFactory){
    58.         RedisCacheConfiguration defaultCacheConfig = RedisCacheConfiguration.defaultCacheConfig();
    59.         // 设置缓存管理器管理的缓存的默认过期时间
    60.         defaultCacheConfig = defaultCacheConfig.entryTtl(Duration.ofSeconds(defaultExpireTime))
    61.                 // 设置 key为string序列化
    62.                 .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()))
    63.                 // 设置value为json序列化
    64.                 .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer()))
    65.                 // 不缓存空值
    66.                 .disableCachingNullValues();
    67.  
    68.         Set<String> cacheNames = new HashSet<>();
    69.         cacheNames.add(userCacheName);
    70.  
    71.         // 对每个缓存空间应用不同的配置
    72.         Map<String, RedisCacheConfiguration> configMap = new HashMap<>();
    73.         configMap.put(userCacheName, defaultCacheConfig.entryTtl(Duration.ofSeconds(userCacheExpireTime)));
    74.  
    75.         RedisCacheManager cacheManager = RedisCacheManager.builder(connectionFactory)
    76.                 .cacheDefaults(defaultCacheConfig)
    77.                 .initialCacheNames(cacheNames)
    78.                 .withInitialCacheConfigurations(configMap)
    79.                 .build();
    80.  
    81.         return cacheManager;
    82.     }
    83. }

    测试注解式开发，修改代码如下

    ClazzBiz.java：

    1. package com.ycx.spboot04.biz;
    2.  
    3. import com.ycx.spboot04.model.Clazz;
    4. import com.ycx.spboot04.util.PageBean;
    5. import org.springframework.cache.annotation.CacheEvict;
    6. import org.springframework.cache.annotation.CachePut;
    7. import org.springframework.cache.annotation.Cacheable;
    8.  
    9. import java.util.List;
    10. import java.util.Map;
    11.  
    12. public interface ClazzBiz {
    13. //    @CacheEvict(value = "xx",key = "'cid:'+#cid",allEntries = true)
    14.     int deleteByPrimaryKey(Integer cid);
    15.  
    16.     int insert(Clazz record);
    17.  
    18.     int insertSelective(Clazz record);
    19.  
    20.  
    21. //    @Cacheable(value = "test") ttl时间未60s
    22.     @Cacheable(value = "clz",key="'cid:'+#cid")
    23.     Clazz selectByPrimaryKey(Integer cid);
    24.  
    25.     int updateByPrimaryKeySelective(Clazz record);
    26.  
    27.     int updateByPrimaryKey(Clazz record);
    28.  
    29.     List<Clazz> listPager(Clazz clazz, PageBean pageBean);
    30.     List<Map> listMapPager(Clazz clazz, PageBean pageBean);
    31. }

    ​​​​​​​

     

     今日知识到此结束，再见！

  • 相关阅读:
    智能座舱架构与芯片- (13) 软件篇 下
    android13 RK356X 预装第三方apk失败
    多通道振弦数据记录仪应用桥梁安全监测的解决方案
    java-net-php-python-Java奖助学金评审管理系统计算机毕业设计程序
    Jetson-XAVIAR NX 上编译tensorflow-lite
    logback-spring.xml 中根据不同的业务表示，分类打印到不同的文件夹、时区动态设置
    Cent OS 使用ip addr or nmcli 分配临时IP地址
    如何用WinRAR给压缩包设置和取消密码
    MFC 定时器使用
    太空射击第10课： Score （繪畫和文字）
  • 原文地址：https://blog.csdn.net/weixin_65808248/article/details/127650068