《SpringBoot实战》读书笔记

最新推荐文章于 2022-02-11 14:55:36 发布

山河已无恙

最新推荐文章于 2022-02-11 14:55:36 发布

阅读量1.1k

点赞数 2

分类专栏： # Spring Booot笔记

本文链接：https://blog.csdn.net/sanhewuyang/article/details/104494202

版权

Spring Booot笔记专栏收录该内容

12 篇文章 8 订阅

订阅专栏

生活加油,

我来不及认真地年轻，待明白过来时，只能选择认真地老去。——三毛

第一章,入门:

Spring概述,虽然Spring的组件代码是轻量级的，但它的配置却是重量级的。一开始，Spring用XML配置，而且是很多XML配置。Spring 2.5引入了基于注解的组件扫描，Spring 3.0引入了基于Java的配置，这是一种类型安全的可重构配置方式，可以代替XML:

Spring 1.x 时代,第一阶段:xml配置,
Spring 2.x时代,注解配置.
Spring 3.x时代 Java配置,

Spring框架是一个轻量级的企业级开发的一站式解决方案,即基于Spring解决Java EE开发的所有问题,Spring框架主要提供了IoC容器,AOP,数据访问,Web开发,消息测试等相关的技术的支持.

Spring使用简单的POJO来进行企业级开发,被Spring管理的对象都被称为Bean,使用Spring提供的Ioc容器来初始化对象,解决对象的依赖管理和对象的使用.

为啥要有Springboot:

Spring虽然提供了基于Java的配置,但是在使用的时候,比如springMVC中配置核心控制器(本质是一个Servlet),事务管理,已及第三方库,过滤器等,还是需要使用xml配置,这些配置开发浪费了逻辑开发时间.

项目的管理依赖问题,不同的版本对于不同库直接会造成版本冲突,版本不兼容的问题.

内嵌了tomcat服务器.

Spring框架本身有四大原则:

使用POJO
进行轻量级和最小侵入式开发.
通过依赖注入和基于接口编程实现松耦合
通过AOP和默认习惯进行声明式编程
使用Aop和模板减少模块化代码

Spring Framework已有十余年的历史了，已成为Java应用程序开发框架的事实标准。

Spring诞生时是Java企业版（Java Enterprise Edition，JEE，也称J2EE）的轻量级代替品。无需开发重量级的Enterprise JavaBean（EJB），Spring为企业级Java开发提供了一种相对简单的方法，通过依赖注入和面向切面编程，用简单的Java对象（Plain Old Java Object，POJO）实现了EJB的功能。

Spring Boot精要 :

自动配置：针对很多Spring应用程序常见的应用功能，Spring Boot能自动提供相关配置,比如DataSource的配置,。
起步依赖：告诉Spring Boot需要什么功能，引入需要的库。基于父子工程的基础,Springboot定义好了版本号. 不必担心版本依赖的问题.
命令行界面：这是Spring Boot的可选特性，借此你只需写代码就能完成完整的应用程序，无需传统项目构建。Spring Boot CLI利用了起步依赖和自动配置，CLI能检测到你使用了哪些类，它知道要向Classpath中添加哪些起步依赖才能让它运转起来。一旦那些依赖出现在Classpath中，一系列自动配置就会接踵而来，确保启用 DispatcherServlet和Spring MVC，这样控制器就能响应HTTP请求了。
Actuator：让你能够深入运行中的Spring Boot应用程序，一探究竟。

Spring Boot不是什么 :

Spring Boot可以把Web应用程序变为可自执行的JAR文件，不用部署到传统Java应用服务器里就能在命令行里运行。Spring Boot 在应用程序里嵌入了一个Servlet容器（Tomcat、Jetty或Undertow）

Spring Boot也没有实现诸如JPA或JMS（Java Message Service，Java消息服务）之类的企业级Java规范。它的确支持不少企业级Java规范，但是要在Spring里自动配置支持那些特性的Bean。例如，Spring Boot没有实现JPA，不过它自动配置了某个JPA实现（比如Hibernate）的 Bean，以此支持JPA.

安装Spring Boot CLI :

使用Spring Initializr初始化 Spring Boot项目 :Spring Initializr从本质上来说就是一个Web应用程序，它能为你生成Spring Boot项目结构。虽然不能生成应用程序代码，但它能为你提供一个基本的项目结构，以及一个用于构建代码的 Maven或Gradle构建说明文件。你只需要写应用程序的代码就好了.

第二章,开发一个SpringBoot应用

目录结构:

启动引导HrosApplication在Spring Boot应用程序里有两个作用：配置和启动引导(启动类)。

package com.liruilong.hros;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.amqp.core.Queue;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;

@SpringBootApplication//开启组件扫描和自动配置
@MapperScan(basePackages ="com.liruilong.hros.mapper" )

public class HrosApplication {

    public static void main(String[] args) {
        // 负责启动引导应用程序
        SpringApplication.run(HrosApplication.class, args);
    }
}

@SpringBootApplication将三个有用的注解组合在了一起。

Spring的@Configuration：标明该类使用Spring基于Java的配置。
Spring的@ComponentScan：启用组件扫描，这样你写的Web控制器类和其他组件才能被自动发现并注册为Spring应用程序上下文里的Bean。
Spring Boot的@EnableAutoConfiguration：这个不起眼的小注解也可以称为 @Abracadabra，就是这一行配置开启了Spring Boot自动配置

使用起步依赖

指定基于功能的依赖

Spring Boot通过提供众多起步依赖降低项目依赖的复杂度。起步依赖本质上是一个Maven项目对象模型（Project Object Model，POM），定义了对其他库的传递依赖，这些东西加在一起即支持某项功能。很多起步依赖的命名都暗示了它们提供的某种或某类功能。

覆盖起步依赖引入的传递依赖

比如你在使用Springboot中Web起步依赖,他会传递依赖Jackson JSON库,但是你做的是一个前后端不分离的项目,可能不用JSON,把他排除掉,可以为项目瘦身.

在maven里使用:可以用<exclusions>元素来排除传递依赖。<dependency>增加了<exclusions>元素去除Jackson：

<dependency>  
 <groupId>org.springframework.boot</groupId> 
  <artifactId>spring-boot-starter-web</artifactId> 
      <exclusions> 
       <exclusion>
       <groupId>com.fasterxml.jackson.core</groupId>
      </exclusion>
     </exclusions>
</dependency>

可以显示选择合适的版本

<dependency>
   <groupId>com.fasterxml.jackson.core</groupId>
   <artifactId>jackson-databind</artifactId>
   <version>2.4.3</version>
</dependency>

使用自动配置 :

专注于应用程序功能 :

我们构建一个简单的应用之后,，有个名为spring-boot-autoconfigure的JAR文件，其中包含了很多配置类。每个配置类都在应用程序的Classpath里，都有机会为应用程序的配置添砖加瓦

利用了Spring的条件化配置，这是Spring 4.0引入的新特性。条件化配置允许配置存在于应用程序中，但在满足某些特定条件之前都忽略这个配置。在Spring里可以很方便地编写你自己的条件，你所要做的就是实现Condition接口，覆盖它的matches()方法。举例来说，下面这个简单的条件类只有在Classpath里存在JdbcTemplate时才会生效

package readinglist; 
import org.springframework.context.annotation.Condition; 
import org.springframework.context.annotation.ConditionContext; 
import org.springframework.core.type.AnnotatedTypeMetadata; 
 
public class JdbcTemplateCondition implements Condition {  
 @Override   
public boolean matches(ConditionContext context,AnnotatedTypeMetadata metadata)
 {  
     try {    
       context.getClassLoader().loadClass( "org.springframework.jdbc.core.JdbcTemplate");
       return true;
    } catch (Exception e) {
       return false;
     }
   } 
} 
//当你用Java来声明Bean的时候，可以使用这个自定义条件类： 
@Conditional(JdbcTemplateCondition.class) public MyService myService() {     ... }

只有当JdbcTemplateCondition类的条件成立时才会创建MyService这个 Bean。也就是说MyService Bean创建的条件是Classpath里有JdbcTemplate.

DataSourceAutoConfiguration中的配置:

@Configuration
 @ConditionalOnClass({ DataSource.class, EmbeddedDatabaseType.class }) 
@EnableConfigurationProperties(DataSourceProperties.class)
 @Import({ Registrar.class, DataSourcePoolMetadataProvidersConfiguration.class }) 
public class DataSourceAutoConfiguration { 
 
... 
 
}

DataSourceAutoConfiguration上添加了@ConditionalOnClass注解，要求Classpath里必须要有DataSource和 EmbeddedDatabaseType。如果它们不存在，条件就不成立，DataSourceAutoConfiguration 提供的配置都会被忽略掉。 DataSourceAutoConfiguration里嵌入了一个JdbcTemplateConfiguration类，自动配置了一个JdbcTemplate Bean：

@Configuration 
@Conditional(DataSourceAutoConfiguration.DataSourceAvailableCondition.class) 
protected static class JdbcTemplateConfiguration { 
 
  @Autowired(required = false)
   private DataSource dataSource; 
 
  @Bean
   @ConditionalOnMissingBean(JdbcOperations.class)
   public JdbcTemplate jdbcTemplate() {     return new JdbcTemplate(this.dataSource);   } 
 
... 
 
}

这个方法上还加了@ConditionalOnMissingBean注解，因此只有在不存在JdbcOperations（即JdbcTemplate实现的接口）类型的Bean时，才会创建JdbcTemplate Bean。

自动配置,配置决策:

因为Classpath里有Spring MVC（归功于Web 起步依赖），所以会配置Spring的 DispatcherServlet并启用Spring MVC。
因为这是一个Spring MVC Web应用程序，所以会注册一个资源处理器，把相对于Classpath 根目录的/static目录里的静态内容提供出来。（这个资源处理器还能处理/public、/resources 和/META-INF/resources的静态内容。）
因为Classpath里有Tomcat（通过Web起步依赖传递引用），所以会启动一个嵌入式的Tomcat 容器，监听8080端口
.........

第三章,自定义配置

覆盖Spring Boot自动配置 :

应用程序添加Spring Security:

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

创建自定义的安全配置

在Spring Security的场景下，这意味着写一个扩展了WebSecurityConfigurerAdapter的配置类,重写该类的configure,和方法.

package com.liruilong.hros.config;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.liruilong.hros.filter.VerifyCodeFilter;
import com.liruilong.hros.model.Hr;
import com.liruilong.hros.model.RespBean;
import com.liruilong.hros.service.HrService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.authentication.*;
import org.springframework.security.config.annotation.ObjectPostProcessor;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.builders.WebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.web.AuthenticationEntryPoint;
import org.springframework.security.web.access.intercept.FilterSecurityInterceptor;
import org.springframework.security.web.authentication.AuthenticationSuccessHandler;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
import org.springframework.security.web.authentication.logout.LogoutSuccessHandler;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;

/**
 * @Description :
 * @Author: Liruilong
 * @Date: 2019/12/18 19:11
 */

@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Autowired
    HrService hrService;
    @Autowired
    CustomFilterInvocationSecurityMetadataSource customFilterInvocationSecurityMetadataSource;
    @Autowired
    CustomUrlDecisionManager customUrlDecisionManager;
     @Autowired
    VerifyCodeFilter verifyCodeFilter ;
    @Autowired
    MyAuthenticationFailureHandler myAuthenticationFailureHandler;

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.addFilterBefore(verifyCodeFilter, UsernamePasswordAuthenticationFilter.class)
                .authorizeRequests()
                //.anyRequest().authenticated()
                //所有请求的都会经过这进行鉴权处理。返回当前请求需要的角色。
                .withObjectPostProcessor(new ObjectPostProcessor<FilterSecurityInterceptor>() {
                    @Override
                    public <O extends FilterSecurityInterceptor> O postProcess(O object) {
                        object.setSecurityMetadataSource(customFilterInvocationSecurityMetadataSource);
                        object.setAccessDecisionManager(customUrlDecisionManager);
                        return object;
                    }
                })
                .and().formLogin().usernameParameter("username").passwordParameter("password")
                //设置登录请求的url路径
                .loginProcessingUrl("/doLogin")
                /*需要身份验证时，将浏览器重定向到/ login
                我们负责在请求/ login时呈现登录页面
                当身份验证尝试失败时，将浏览器重定向到/ login？error（因为我们没有另外指定）
                当请求/ login？error时，我们负责呈现失败页面
                成功注销后，将浏览器重定向到/ login？logout（因为我们没有另外指定）
                我们负责在请求/ login？logout时呈现注销确认页面*/
                .loginPage("/login")
                //登录成功回调
                .successHandler(new AuthenticationSuccessHandler() {
                    @Override
                    public void onAuthenticationSuccess(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Authentication authentication) throws IOException, ServletException {
                        httpServletResponse.setContentType("application/json;charset=utf-8");
                        PrintWriter out = httpServletResponse.getWriter();
                        Hr hr = (Hr) authentication.getPrincipal();
                        //密码不回传
                        hr.setPassword(null);
                        RespBean ok = RespBean.ok("登录成功！", hr);
                        //将hr转化为Sting
                        String s = new ObjectMapper().writeValueAsString(ok);
                        out.write(s);
                        out.flush();
                        out.close();
                    }
                })
                //登失败回调
                .failureHandler(myAuthenticationFailureHandler)
                //相关的接口直接返回
                .permitAll().and().logout()
                //注销登录
                .logoutSuccessHandler(new LogoutSuccessHandler() {
                    @Override
                    public void onLogoutSuccess(HttpServletRequest httpServletRequest,
                                                HttpServletResponse httpServletResponse,
                                                Authentication authentication) throws IOException, ServletException {
                        httpServletResponse.setContentType("application/json;charset=utf-8");
                        PrintWriter out = httpServletResponse.getWriter();
                        out.write(new ObjectMapper().writeValueAsString(RespBean.ok("注销成功!")));
                        out.flush();
                        out.close();
                    }
                })
                .permitAll().and().csrf().disable().exceptionHandling()
                //没有认证时，在这里处理结果，不要重定向
                .authenticationEntryPoint(
                        //myAuthenticationEntryPoint;
                        new AuthenticationEntryPoint() {
                    @Override
                    public void commence(HttpServletRequest req, HttpServletResponse resp, AuthenticationException authException) throws IOException, ServletException {
                        resp.setContentType("application/json;charset=utf-8");
                        resp.setStatus(401);
                        PrintWriter out = resp.getWriter();
                        RespBean respBean = RespBean.error("访问失败!");
                        if (authException instanceof InsufficientAuthenticationException) {
                            respBean.setMsg("请求失败，请联系管理员!");
                        }
                        out.write(new ObjectMapper().writeValueAsString(respBean));
                        out.flush();
                        out.close();
                    }
                });
    }
    @Bean
    PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.userDetailsService(hrService);
    }
    /**
     * @Author Liruilong
     * @Description  放行的请求路径
     * @Date 19:25 2020/2/7
     * @Param [web]
     * @return void
     **/
    @Override
    public void configure(WebSecurity web) throws Exception {
        web.ignoring().antMatchers("/auth/code","/login","/css/**","/js/**", "/index.html", "/img/**", "/fonts/**","/favicon.ico");
    }
}

覆盖Spring Boot的自动配置，你所要做的仅仅是编写一个显式的配置。 Spring Boot会发现你的配置，随后降低自动配置的优先级，以你的配置为准。

在SecurityConfig里，第一个configure()方法指明， “/”（ReadingListController 的方法映射到了该路径）的请求只有经过身份认证且拥有READER角色的用户才能访问。其他的所有请求路径向所有用户开放了访问权限。

第二个 configure()方法设置了一个自定义的UserDetailsService，这个服务可以是任意实现了 UserDetailsService的类，用于查找指定用户名的用户。

用户需要实现了UserDetails接口以及其中的方法，这样Reader就能代表 Spring Security里的用户了。getAuthorities()方法被覆盖过了，始终会为用户授予READER 权限。isAccountNonExpired()、 isAccountNonLocked()、isCredentialsNonExpired() 和isEnabled()方法都返回true，这样读者账户就不会过期，不会被锁定，也不会被撤销。

关于Spring Security，自动配置会考虑几个配置类。在这里讨论每个配置类的细节是不切实际的，但覆盖Spring Boot自动配置的安全配置时，重要的一个类是SpringBootWebSecurity- Configuration。以下是其中的一个代码片段：

@Configuration
 @EnableConfigurationProperties
 @ConditionalOnClass({ EnableWebSecurity.class }) 
@ConditionalOnMissingBean(WebSecurityConfiguration.class)
@ConditionalOnWebApplication
 public class SpringBootWebSecurityConfiguration { 
 
... 
 
}

SpringBootWebSecurityConfiguration上加了好几个注解。

@Condi- tionalOnClass注解后，你就应该知道Classpath里必须要有@EnableWebSecurity注解。
@ConditionalOnWebApplication 说明这必须是个Web 应用程序。
@ConditionalOn- MissingBean注解才是我们的安全配置类代替SpringBootWebSecurityConfiguration的关键所在。
@ConditionalOnMissingBean注解要求当下没有WebSecurityConfiguration类型的 Bean。虽然表面上我们并没有这么一个Bean，但通过在SecurityConfig上添加@EnableWeb- Security注解，我们实际上间接创建了一个WebSecurityConfiguration Bean。所以在自动配置时，这个Bean就已经存在了，@ConditionalOnMissingBean条件不成立，SpringBoot- WebSecurityConfiguration提供的配置就被跳过了。

通过属性文件外置配置

Spring Boot自动配置的Bean提供了300多个用于微调的属性。当你调整设置时，只要在环境变量、Java系统属性、JNDI（Java Naming and Directory Interface）、命令行参数或者属性文件里进行指定就好了

比如你想禁用Banner有以下方法:

命令行方式:$ java -jar readinglist-0.0.1-SNAPSHOT.jar --spring.main.show-banner=false
application.properties的文件:spring.main.show-banner=false
为application.yml的YAML文件:spring: main: show-banner: false
将属性设置为环境变量:$ export spring_main_show_banner=false

Spring Boot应用程序有多种设置途径。Spring Boot能从多种属性源获得属性，

(1) 命令行参数
(2) java:comp/env里的JNDI属性
(3) JVM系统属性
(4) 操作系统环境变量
(5) 随机生成的带random.*前缀的属性（在设置其他属性时，可以引用它们，比如${random. long}）
(6) 应用程序以外的application.properties或者appliaction.yml文件
(7) 打包在应用程序内的application.properties或者appliaction.yml文件
(8) 通过@PropertySource标注的属性源
(9) 默认属性这个列表按照优先级排序，也就是说，任何在高优先级属性源里设置的属性都会覆盖低优先级的相同属性。例如，命令行参数会覆盖其他属性源里的属性。
application.properties和application.yml文件能放在以下四个位置。
- (1) 外置，在相对于应用程序运行目录的/config子目录里。
- (2) 外置，在应用程序运行的目录里。
- (3) 内置，在config包内。
- (4) 内置，在Classpath根目录

自动配置微调 :

配置嵌入式服务器 ;

第一步就是用JDK的 keytool工具来创建一个密钥存储（keystore）

$ keytool -keystore mykeys.jks -genkey -alias tomcat -keyalg RSA 
server.port=8443
server.ssl.key-password=liruilong
server.ssl.key-store-password=liruilong
server.ssl.key-store=file:///hros/mykeys.jks

禁用模板缓存 :

Thymeleaf模板的变更是不会生效的。这是因为Thymeleaf模板默认缓存。这有助于改善应用程序的性能，因为模板只需编译一次，但在开发过程中就不能实时看到变更的效果了

spring.thymeleaf.cache=false

其他模板:

 spring.freemarker.cache（Freemarker）  spring.groovy.template.cache（Groovy模板）  spring.velocity.cache（Velocity）

配置日志 :

要设置日志级别，你可以创建以logging.level开头的属性，后面是要日志名称。如果根日志级别要设置为WARN，但Spring Security的日志要用DEBUG级别，

logging.level.com.liruilong.hros.mapper=debug
logging.level.root=WARN
logging.level.org.springframework.security=DEBUG

可以把日志写到指定的文件夹:logging. path和loggin.file属性.

logging.config属性指定自定义的名字

logging.config.classpath=logging-config.xml

配置数据源

spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
spring.datasource.username=root
spring.datasource.password=mysql
spring.datasource.url=jdbc:mysql://39.97.241.18:3306/vhr?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai


server.port=8443
server.ssl.key-password=liruilong
server.ssl.key-store-password=liruilong
server.ssl.key-store=file:///hros/mykeys.jks
 #数据源配置
#MySQL配置
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
spring.datasource.username=root
spring.datasource.password=mysql
spring.datasource.url=jdbc:mysql://39.97.241.18:3306/vhr?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai


spring.security.user.name=user1
spring.security.user.password=password1


#日志处理
# 打印sql语句
logging.level.com.liruilong.hros.mapper=debug
logging.level.root=WARN
logging.level.org.springframework.security=DEBUG



# 指定映射文件的位置
mybatis.mapper-locations=classpath:com/liruilong/hros/mapper/*Mapper.xml

spring.servlet.multipart.max-file-size=64000MB
spring.servlet.multipart.max-request-size=-1

Redis
Redisspring.redis.host=localhost
spring,redis.database  = 0
spring.redis.port=6379
spring.redis.password=liruilong

spring.mail.host=smtp.qq.com
spring.mail.protocol=smtp
spring.mail.default-encoding=UTF-8
spring.mail.password=dfssxgsqfiilcbef
spring.mail.username=1654687517@qq.com
spring.mail.port=465
spring.mail.properties.mail.stmp.socketFactory.class=javax.net.ssl.SSLSocketFactory
spring.mail.properties.mail.smtp.socketFactory.port=465
spring.mail.properties.mail.smtp.socketFactory.fallback=false

spring.mail.properties.mail.debug=true

spring.rabbitmq.username=guest
spring.rabbitmq.password=guest
spring.rabbitmq.host=39.97.241.18
spring.rabbitmq.port=5672

应用程序 Bean的配置外置

amazon.associateId=habuma-20

在一个类里收集属性

package readinglist;  
 
import org.springframework.boot.context.properties.                               ConfigurationProperties;
 import org.springframework.stereotype.Component; 
 
@Component
//注入带amazon 前缀的属性 
 @ConfigurationProperties("amazon")
  public class AmazonProperties { 
 
  private String associateId; 
 
  public void setAssociateId(String associateId) {      this.associateId = associateId;   } 
 
  public String getAssociateId() {     return associateId;   } 
 
}

使用Profile进行配置

为不同的部署环境配置不同的属性

Spring Framework从 Spring 3.1开始支持基于Profile的配置。Profile是一种条件化配置，基于运行时激活的Profile，会使用或者忽略不同的Bean或配置类

安全配置是针对生产环境的，而自动配置的安全配置用在开发环境刚刚好,所以我们需要在开发环境下,屏蔽SecurityConfig

@Profile("production")
 @Configuration
 @EnableWebSecurity
 public class SecurityConfig extends WebSecurityConfigurerAdapter { 
 
... 
 
}

spring.profiles.active=production

使用特定于Profile的属性文件

如果你正在使用application.properties，可以创建额外的属性文件，遵循application-{profile}. properties这种命名格式，这样就能提供特定于Profile的属性了

开发环境的配置可以放在名为application-development.properties的文件
对于生产环境，application-production.properties会将日志级别设置为WARN或更高级别

使用多Profile YAML文件进行配置

logging:
   level:
     root: INFO 
 
--- 
 
spring:
   profiles: development 
 
logging:
   level:
     root: DEBUG 
 
--- 
 
spring:
   profiles: production 
 
logging:
   path: /tmp/
   file: BookWorm.log
   level:
     root: WARN

application.yml文件分为三个部分，使用一组三个连字符（---）作为分隔符。