Spring Boot整合 NoSQL 数据库 Redis

Posted 2023-03-29 百思不得小赵

📢 专栏推荐：Spring Boot整合第三方组件
📖系列文章：【快速上手】使用SpringBoot 2.X + Mybatis-Plus 轻松实现CRUD（持续更新。。。）
🌲专栏简介：
在日常实际的开发中，我们会使用企业级快速构建项目框架Spring Boot整和 各个组件进行开发，本专栏将总结使用Spring Boot与常用第三方组件进行整合的详细步骤，欢迎大佬们交流学习。👏👏👏

文章目录

• 一、环境准备
• 二、构建Spring Boot项目
• 三、引入Redis依赖
• 四、Reds相关配置
• 五、添加Redis配置类
• 六、测试一下

在日常的开发中，除了使用Spring Boot这个企业级快速构建项目的框架之外，随着业务数据量的大幅度增加，对元数据库造成的压力成倍剧增。在此背景下，Redis这个NoSQL数据库已然整个项目架构中的不可或缺的一部分，懂得如何Spring Boot整合 Redis，是当今开发人员必备的一项技能，接下来对整合步骤进行详细说明。

一、环境准备

在开始开发之前，我们需要准备一些环境配置:

• jdk 1.8 或其他更高版本
• 开发工具 IDEA
• 管理依赖 Maven
• Redis环境，推荐linux系统中搭建redis环境

二、构建Spring Boot项目

打开idea -> file -> Nwe -> Project ,如图，勾选填写相关的配置信息：

勾选一些初始化的依赖配置：

Spring Boot项目初始化完成。

三、引入Redis依赖

构建完成Spring Boot项目工程之后，需要在pom.xml文件中引入redis相关依赖

<!-- redis -->
<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

<!-- spring2.X集成redis所需common-pool2-->
<dependency>
	<groupId>org.apache.commons</groupId>
	<artifactId>commons-pool2</artifactId>
	<version>2.6.0</version>
</dependency>

四、Reds相关配置

将redis相关的依赖引入到项目中之后，需要对redis进行一些配置，在application.properties配置redis:

# Redis服务器地址
spring.redis.host=自己搭建的redis服务器的 IP
# Redis服务器连接端口
spring.redis.port=6379
# Redis数据库索引（默认为0）
spring.redis.database= 0
# 连接超时时间（毫秒）
spring.redis.timeout=1800000
# 连接池最大连接数（使用负值表示没有限制）
spring.redis.lettuce.pool.max-active=20
# 最大阻塞等待时间(负数表示没限制)
spring.redis.lettuce.pool.max-wait=-1
# 连接池中的最大空闲连接
spring.redis.lettuce.pool.max-idle=5
# 连接池中的最小空闲连接
spring.redis.lettuce.pool.min-idle=0

五、添加Redis配置类

对Redis相关配置完成后，添加Redis配置类，（拿来即用）：

package com.zhao.demo.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
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.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import java.time.Duration;

/**
 * @author xiaoZhao
 * @date 2022/9/6
 * @describe
 */
@EnableCaching
@Configuration
public class RedisConfig extends CachingConfigurerSupport 

    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) 
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        RedisSerializer<String> redisSerializer = new StringRedisSerializer();
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        template.setConnectionFactory(factory);
        //key序列化方式
        template.setKeySerializer(redisSerializer);
        //value序列化
        template.setValueSerializer(jackson2JsonRedisSerializer);
        //value hashmap序列化
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        return template;
    

    @Bean
    public CacheManager cacheManager(RedisConnectionFactory factory) 
        RedisSerializer<String> redisSerializer = new StringRedisSerializer();
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        //解决查询缓存转换异常的问题
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        // 配置序列化（解决乱码的问题）,过期时间600秒
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(Duration.ofSeconds(600))
                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(redisSerializer))
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(jackson2JsonRedisSerializer))
                .disableCachingNullValues();
        RedisCacheManager cacheManager = RedisCacheManager.builder(factory)
                .cacheDefaults(config)
                .build();
        return cacheManager;
    

六、测试一下

将所有的环境依赖和配置搭建完成之后，进行测试一把。

① 首先，确保安装Redis的服务器已经启动Redis服务

② 编写controller类，前提需要引入Spring Boot Web 的依赖：

package com.zhao.demo.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author xiaoZhao
 * @date 2022/9/6
 * @describe
 */
@RestController
@RequestMapping("/redistest")
public class RedisTestController 

    @Autowired
    private RedisTemplate redisTemplate;

    @GetMapping
    public String testRedis()
        // 设置值到reids
        redisTemplate.opsForValue().set("name","jack");
        // 从redis中获取值
        String name = (String)redisTemplate.opsForValue().get("name");
        return name;
    

③ 启动Spring Boot工程，在浏览器上向接口发送请求：

项目启动成功，向/redistest接口发送请求

请求发送成功，获取到数据，测试成功，至此Spring Boot整合 Redis所有步骤已经完成，

spring-boot数据访问

一、简介

使用springboot可以与jdbc、mybatis、spring data等结合进行数据访问

对于数据访问层，无论是SQL好NoSQL，springBoot默认采用整合Spring Data的方式进行统一处理，添加大量自动配置，屏蔽了很多设置。

各种xxxTemplate,xxxRepository来简化我们对数据访问层的操作。对我们来说只需要进行简单的设置即可。

二、整合JDBC

1)、添加依赖

<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>${mysql-version}</version>
            <scope>runtime</scope>
        </dependency>

2）、在application.yml中配置数据源

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/test?serverTimezone=UTC
    driver-class-name: com.mysql.cj.jdbc.Driver
    username: root
    password: 123456

3）、测试效果

用下面代码测试

    @Autowired
    DataSource dataSource;
    @Test
    void contextLoads() throws SQLException {
        System.out.println(dataSource.getClass());
        Connection connection = dataSource.getConnection();
        System.out.println(connection);
        connection.close();
    }

结果如下，使用的是默认的内置数据源，hikari

class com.zaxxer.hikari.HikariDataSource

HikariProxyConnection@108209958 wrapping com.mysql.cj.jdbc.ConnectionImpl@474821de

数据源相关配置都在DataSourceProperties中。

4）、自动配置原理

org.springframework.boot.autoconfigure.jdbc

1. DataSourceConfiguration，根据配置来创建数据源，默认是hikari连接池，并且可以使用spring.datasource.type来选择数据源。

//每个数据源上都有此注解，根据配置中的spring.datasource.type来配置数据源
@ConditionalOnProperty(name = "spring.datasource.type", havingValue = "com.zaxxer.hikari.HikariDataSource",
            matchIfMissing = true)
    static class Hikari {

1. 默认支持的数据源

//tomcat
org.springframework.boot.autoconfigure.jdbc.DataSourceConfiguration.Tomcat
//hikari
org.springframework.boot.autoconfigure.jdbc.DataSourceConfiguration.Hikari
//Dbcp2
org.springframework.boot.autoconfigure.jdbc.DataSourceConfiguration.Dbcp2

1. 自定义数据源

//自定义数据源，但制定的类型不为上面三种时，便通过此来创建自定义数据源
@Configuration(proxyBeanMethods = false)
    @ConditionalOnMissingBean(DataSource.class)
    @ConditionalOnProperty(name = "spring.datasource.type")
    static class Generic {
        @Bean
        DataSource dataSource(DataSourceProperties properties) {
            //使用反射创建响应数据的数据源，并且绑定相关属性
            return properties.initializeDataSourceBuilder().build();
        }
    }

1. DataSourceInitializerInvoker:实现了ApplicationListener

   ? 作用：创建数据源时可以执行自动执行sql

   ? 1）、afterPropertiesSet。用来执行建表语句

   ? 2）、onApplicationEvent。用来执行插入数据的语句

   /**
    * Bean to handle {@link DataSource} initialization by running {@literal schema-*.sql} on
    * {@link InitializingBean#afterPropertiesSet()} and {@literal data-*.sql} SQL scripts on
    * a {@link DataSourceSchemaCreatedEvent}.
    */
   由官方注释可知，通过afterPropertiesSet方法，可以执行格式为schema-*.sql的语句进行建表操作，通过onApplicationEvent方法可以执行格式为data-*sql的插入操作
   可以使用：
       schema:
        - classpath:xxx.sql
       指定位置

   对于spring-boot2.x，如果使用不使用内置的数据源，要想自动执行sql脚本，必须要加上initialization-mode: always

   //建表时是否执行DML和DDL脚本
   public enum DataSourceInitializationMode {
   
    /**
     * Always initialize the datasource.总是会执行
     */
    ALWAYS,
   
    /**
     * Only initialize an embedded datasource.嵌入式会执行
     */
    EMBEDDED,
   
    /**
     * Do not initialize the datasource.不会执行
     */
    NEVER
   
   }

   1. 操作数据库：自动配置了JdbcTemplateConfiguration和NamedParameterJdbcTemplateConfiguration来操作数据库

5）、整合Druid

1.创建Druid数据源并为属性赋值

在application中配置Druid的基本属性。使用spring.datasource.type指定数据源为druid

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/test?serverTimezone=UTC
    driver-class-name: com.mysql.cj.jdbc.Driver
    username: root
    password: 123456
    type: com.alibaba.druid.pool.DruidDataSource
    
    #   数据源其他配置
    initialSize: 5
    minIdle: 5
    maxActive: 20
    maxWait: 60000
    timeBetweenEvictionRunsMillis: 60000
    minEvictableIdleTimeMillis: 300000
    validationQuery: SELECT 1 FROM DUAL
    testWhileIdle: true
    testOnBorrow: false
    testOnReturn: false
    poolPreparedStatements: true
    #   配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙
    filters: stat,wall,log4j
    maxPoolPreparedStatementPerConnectionSize: 20
    useGlobalDataSourceStat: true
    connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=500

不过这里会存在一个问题，那就是DataSource是通过DataSourceProperties来赋值的。然而DataSourceProperties类中并不存在数据源的其他配置属性。因此我们所希望的其他配置在创建的数据源中并不会存在。

@ConfigurationProperties(prefix = "spring.datasource")
public class DataSourceProperties implements BeanClassLoaderAware, InitializingBean {

要解决这个问题也很简单，就是自己为数据源赋值，将其他配置的值直接赋值给DruidDataSource

@Configuration
public class DruidConfig {

    @ConfigurationProperties(prefix = "spring.datasource")
    @Bean
    public DataSource druidDataSource(){
        return new DruidDataSource();
    }
}

完成后运行时可能会报错，这时需要我们添加log4j的依赖。便能顺利执行了

<dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>

2. 配置数据源监控

1. 配置一个管理后台的Servlet

嵌入式servlet容器创建servlet是通过ServletRegistrationBean来创建的

/**
     * 配置一个Web监控的servlet
     * @return
     */
    @Bean
    public ServletRegistrationBean<StatViewServlet> statViewServlet(){
        ServletRegistrationBean<StatViewServlet> bean = new ServletRegistrationBean<>(new StatViewServlet(),"/druid/*");
        Map<String,String> initParameters = new HashMap<>(10);
        initParameters.put("loginUsername","root");
        initParameters.put("loginPassword","123456");
        //默认允许所有访问
        initParameters.put("allow","");

        bean.setInitParameters(initParameters);
        return bean;
    }

    /**
     * 配置一个Web监控的Filter
     * @return
     */
    @Bean
    public FilterRegistrationBean<WebStatFilter> webStatFilter(){
        FilterRegistrationBean<WebStatFilter> bean = new FilterRegistrationBean<>();
        Map<String,String> initParameters = new HashMap<>(10);
        initParameters.put("exclusions","*.js,*css,/druid/*");
        bean.setUrlPatterns(Collections.singletonList("/*"));
        bean.setInitParameters(initParameters);
        return bean;
    }

三、整合mybatis

加入依赖

<dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.1.2</version>
</dependency>

注解版mybatis

只需要在接口上加入@Mapper注解，在方法上使用对应的注解即可。若要批量加上@Mapper注解，可在主程序上使用@MapperScan(value="mapper包名")来将包下的所有mapper都扫描到容器中。

@Mapper
public interface DepartmentMappper {
    @Select("select * from department where id=#{id} ")
    Department getDeptById(Integer id);

    @Delete("delete from department where id=#{id}")
    int deleteById(Integer id);

    @Update("update department set departmentName=#{departmentName} where id=#{id} ")
    int update(Department department);
    @Options(useGeneratedKeys = true,keyProperty = "id")//自增主键
    @Insert("insert into department(departmentName) values(#{departmentName} )")
    int insert(Department department);
}

但可能会有这样的疑问，我们原本在配置文件中的设置该怎样设置？比如开启二级缓存，使用驼峰命名法等

在mybatis的自动配置类MyBatisAutoConfiguration中，在创建SqlSessionFactory时，会获取到配置类，并且将configurationCustomizers类中的customize方法执行.

private void applyConfiguration(SqlSessionFactoryBean factory) {
        org.apache.ibatis.session.Configuration configuration = this.properties.getConfiguration();
        if (configuration == null && !StringUtils.hasText(this.properties.getConfigLocation())) {
            configuration = new org.apache.ibatis.session.Configuration();
        }

        if (configuration != null && !CollectionUtils.isEmpty(this.configurationCustomizers)) {
            Iterator var3 = this.configurationCustomizers.iterator();

            while(var3.hasNext()) {
                ConfigurationCustomizer customizer = (ConfigurationCustomizer)var3.next();
                customizer.customize(configuration);
            }
        }

因此我们可以通过在容器中添加configurationCustomizers组件，重写其内部的customize方法，以实现像配置文件一样的配置。例如：开启驼峰命名法

@Configuration
public class MyBatisConfig {
    @Bean
    public ConfigurationCustomizer configurationCustomizer(){
        return new ConfigurationCustomizer(){

            @Override
            public void customize(org.apache.ibatis.session.Configuration configuration) {
                configuration.setMapUnderscoreToCamelCase(true);
            }
        };
    }
}