Spring Boot 核心

素颜马尾好姑娘i 2022-05-16 07:17 242阅读 0赞

# [Spring Boot的基本配置][Spring Boot]： #

## 一. 配置不继承SpringBoot父依赖项目 ##

在真实的企业级项目中，一个大的项目会由多个子模块组成，每个模块是一个小的项目，那么每个模块都有自己的父项目，这个时候就不能再依赖`spring`提供的父项目了，这时候怎么办呢?`spring` `boot`已经考虑到了这种可能性，下面就来看看怎么解决的。  
单一模块的时候，我们会看到我们的`Spring` `Boot`项目有个`parent`依赖，如下所示：

<parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>1.4.5.RELEASE</version>
            <relativePath />
        </parent>

在真实的企业级项目中，这部分内容被我们自己的父模块占用了，比如变成了如下：

<parent>
            <groupId>org.light4j</groupId>
            <artifactId>springBoot-basic</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </parent>

这个时候，只需要加如下依赖即可解决原来依赖`Spring` `Boot`的`parent`的问题：

<dependencyManagement>
            <dependencies>
                <dependency>
                    
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-dependencies</artifactId>
                    <version>1.4.5.RELEASE</version>
                    <type>pom</type>
                    <scope>import</scope>
                </dependency>
            </dependencies>
        </dependencyManagement>

别的部分不需要变动，**后面的内容都按照这种方式来进行。**

## 二. 入口类和@SpringBootApplication ##

`Spring Boot`通常有一个名为`*Application`的入口类，入口类里面有一个`main`方法，这个`main`方法其实就是一个标准的`Java`应用的入口。在`main`方法中使用`SpringApplication.run(HelloApplication.class, args)`，启动`Spring Boot`应用项目。

`@SpringBootApplication`是`Spring Boot`的核心注解，它是一个组合注解,对组合注解不了解的朋友可以看前面的文章[Spring4.x高级话题(五):组合注解与元注解][Spring4.x]，`SpringBootApplication`源码如下：

@Target({java.lang.annotation.ElementType.TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @Inherited
    @Configuration
    @EnableAutoConfiguration
    @ComponentScan
    public @interface SpringBootApplication
    {
      public abstract Class<?>[] exclude();
    
      public abstract String[] excludeName();
    }

`@SpringBootApplication`注解主要组合了`@Configuration`，`@EnableAutoConfiguration`，`@ComponentScan`；若不使用`@SpringBootApplication`注解，则可以在入口类上直接使用`@Configuration`，`@EnableAutoConfiguration`，`@ComponentScan`三个注解的效果是一样的。  
其中`@EnableAutoConfiguration`让`Spring` `Boot`根据类路径中的`jar`包依赖为当前项目进行自动配置。

例如，添加了`spring-boot-starter-web`依赖，会自动添加`Tomcat`和`Spring MVC`的依赖，那么`Spring` `Boot`会对`Tomcat`和`Spring MVC`进行自动配置。

又如，添加了`spring-boot-starter-jpa`依赖,`Spring` `Boot`会自动进行`JPA`相关的配置。

`Spring Boot`会自动扫描`@SpringBootApplication`所在类的同级包(如`org.light4j.springboot.config`)以及下级包里面的`Bean`(若为`JPA`项目还可以扫描标注`@Entity`的实体类)。建议入口类放置在`groupId+arctifactID`组合的包名下。

## 三. 关闭特定的自动配置 ##

通过上面的`@SpringBootApplication`的源码可以看出，关闭特定的自动配置应该使用`@SpringBootApplication`注解的`exclude`参数，比如要关闭`Spring` `Boot`对数据源的自动配置，则可以这样使用，例如：

@SpringBootApplication(exclude={DataSourceAutoConfiguration.class})

## 四. 定制Banner ##

## 1. 修改Banner ##

在`Spring Boot`启动的时候会有一个默认启动方案，如下图所示：  
![11-5.png][]

如果想把这个图案修改成自己的，**步骤如下所示：**

> (1). 在`src/main/resources`下新建一个`banner.txt`。  
> (2). 通过[http://patorjk.com/software/taag][http_patorjk.com_software_taag]网站生成字符，如敲入的为`"fffff"`,将网站生成的字符复制到`banner.txt`中。  
> (3). 这时再启动程序，图案将变为如下图所示：

## 五. 关闭banner ##

## 1. 入口类`main`方法里的内容修改为： ##

SpringApplication application = new SpringApplication(HelloApplication.class);
    application.setBannerMode(Banner.Mode.OFF);
    application.run(args);

## 2. 或者使用`fluent API`修改为： ##

new SpringApplicationBuilder(HelloApplication.class).bannerMode(Banner.Mode.OFF).run(args);

# [Spring Boot的配置文件][Spring Boot 1] #

`Spring` `Boot`的全局配置文件的作用是对一些默认配置的配置值进行修改。`Spring Boot`使用一个全局的配置文件`application.properties`或`application.yml`进行全局配置，放置在`src/main/resources`目录或者类路径的`/config`下。

`Spring Boot`不仅支持常规的`properties`配置文件，还支持`yaml`语言的配置文件。`yaml`是以数据为中心的语言，在配置数据的时候具有面向对象的特征。

## 二. 简单示例 ##

将`Tomcat`的默认端口号修改为`9090`，并将默认的访问路径”/”修改为”`/springboot_configFile`“，可以在`application.properties`中添加：

server.port=9090
    server.context-path=/springboot_configFile

或者在`application.yml`中添加：

server:
      port:9090
      contextPath:/springboot_configFile

从上面的配置可以看出，在`Spring Boot`中，`context-path`,`contextPath`或者`CONTEXT_PATH`形式其实是相通的。并且，`yaml`的配置更简洁清晰，更多`Spring` `Boot`常用配置请参考[官网文档][Link 1]。

# [Spring Boot的starter pom][Spring Boot_starter pom] #

`Spring Boot`通过使用`starter` `pom`使得我们不需要关注各种依赖库的处理，不需要具体的配置信息，由`Spring``Boot`自动通过`classpath`路径下的类发现需要的`Bean`，并织入`bean`。

`Spring Boot`为我们提供了简化企业级开发绝大多数场景的`starter pom`，只要使用了应用场景所需要的`starter pom`，相关的技术配置将会消除，就可以得到`Spring Boot`为我们提供的自动配置的`Bean`。

官方提供的`starter pom`特别多，详细可参考[官网文档][Link 2]。下面列出部分供参考：

<table> 
 <thead> 
  <tr> 
   <th>名称</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>spring-boot-starter</td> 
   <td>Spring Boot核心的starter，包含自动配置，日志，yaml配置文件等的支持</td> 
  </tr> 
  <tr> 
   <td>spring-boot-starter-actuator</td> 
   <td>准生产应用，用来监控和管理应用</td> 
  </tr> 
  <tr> 
   <td>spring-boot-starter-remote-shell</td> 
   <td>提供基于ssh协议的监控和管理</td> 
  </tr> 
  <tr> 
   <td>spring-boot-starter-amqp</td> 
   <td>使用spring-rabbit来支持AMQP</td> 
  </tr> 
  <tr> 
   <td>spring-boot-starter-aop</td> 
   <td>使用spring-aop和AspectJ支持面向切面编程</td> 
  </tr> 
  <tr> 
   <td>spring-boot-starter-batch</td> 
   <td>提供对Spring Batch的支持</td> 
  </tr> 
  <tr> 
   <td>spring-boot-starter-cache</td> 
   <td>提供对Spring Cache的支持</td> 
  </tr> 
  <tr> 
   <td>spring-boot-starter-cloud-connectors</td> 
   <td>对云平台(Cloud Foundry，Heroku)提供的服务提供简化的连接方式</td> 
  </tr> 
  <tr> 
   <td>spring-boot-starter-data-elasticsearch</td> 
   <td>通过spring-data-elasticsearch对Elasticsearcht提供支持</td> 
  </tr> 
  <tr> 
   <td>spring-boot-starter-data-gemfire</td> 
   <td>通过spring-data-gemfire对GemFire提供支持</td> 
  </tr> 
  <tr> 
   <td>spring-boot-starter-data-jpa</td> 
   <td>对JPA的支持，包含spring-data-jpa，spring-orm和Hibernate</td> 
  </tr> 
  <tr> 
   <td>spring-boot-starter-data-mongodb</td> 
   <td>通过spring-data-mongodb对MongoDB提供支持</td> 
  </tr> 
  <tr> 
   <td>spring-boot-starter-data-rest</td> 
   <td>通过spring-data-rest-webmvc将Spring Data respository暴露为Rest的服务</td> 
  </tr> 
  <tr> 
   <td>spring-boot-starter-data-solr</td> 
   <td>通过spring-data-rest-solr对Apache Solr数据检索平台的支持。</td> 
  </tr> 
  <tr> 
   <td>spring-boot-starter-freemarker</td> 
   <td>对FreeMarker模板引擎提供支持</td> 
  </tr> 
  <tr> 
   <td>spring-boot-starter-groovy-templates</td> 
   <td>对Groovy模板引擎提供支持</td> 
  </tr> 
  <tr> 
   <td>spring-boot-starter-hateoas</td> 
   <td>通过spring-hateoas对基于HATEOAS的REST形式的网络服务的支持</td> 
  </tr> 
  <tr> 
   <td>spring-boot-starter-hornetq</td> 
   <td>通过Hornetq对JMS的支持</td> 
  </tr> 
  <tr> 
   <td>spring-boot-starter-integration</td> 
   <td>对系统集成框架spring-integration的支持</td> 
  </tr> 
  <tr> 
   <td>spring-boot-starter-jdbc</td> 
   <td>对JDBC数据库的支持</td> 
  </tr> 
  <tr> 
   <td>spring-boot-starter-jersey</td> 
   <td>对Jersery REST形式的网络服务的支持</td> 
  </tr> 
  <tr> 
   <td>spring-boot-starter-jta-atomikos</td> 
   <td>通过Atomikos对分布式事务的支持</td> 
  </tr> 
  <tr> 
   <td>spring-boot-starter-jta-bitronix</td> 
   <td>通过Bitronix对分布式事务的支持</td> 
  </tr> 
  <tr> 
   <td>spring-boot-starter-mail</td> 
   <td>对javax.mail的支持</td> 
  </tr> 
  <tr> 
   <td>spring-boot-starter-mobile</td> 
   <td>对spring-mobile的支持</td> 
  </tr> 
  <tr> 
   <td>spring-boot-starter-mustache</td> 
   <td>对Mustache模板引擎的支持</td> 
  </tr> 
  <tr> 
   <td>spring-boot-starter-redis</td> 
   <td>对键值对内存数据库Redis的支持，包含spring-redis</td> 
  </tr> 
  <tr> 
   <td>spring-boot-starter-security</td> 
   <td>对spring-security的支持</td> 
  </tr> 
  <tr> 
   <td>spring-boot-starter-social-facebook</td> 
   <td>通过spring-social-facebook对FaceBook的支持</td> 
  </tr> 
  <tr> 
   <td>spring-boot-starter-social-linkedin</td> 
   <td>通过spring-social-linkedin对LinkedIn的支持</td> 
  </tr> 
  <tr> 
   <td>spring-boot-starter-social-twitter</td> 
   <td>通过spring-social-twitter对Twitter的支持</td> 
  </tr> 
  <tr> 
   <td>spring-boot-starter-test</td> 
   <td>对常用的测试框架Junit，Hamcrest和Mockito的支持，包含spring-test模块</td> 
  </tr> 
  <tr> 
   <td>spring-boot-starter-thymeleaf</td> 
   <td>对Thymeleaf模板引擎的支持，包含于Spring整合的配置</td> 
  </tr> 
  <tr> 
   <td>spring-boot-starter-velocity</td> 
   <td>对Velocity模板引擎的支持</td> 
  </tr> 
  <tr> 
   <td>spring-boot-starter-web</td> 
   <td>对Web项目开发的支持，包含Tomcat和spring-webmvc</td> 
  </tr> 
  <tr> 
   <td>spring-boot-starter-Tomcat</td> 
   <td>Spring Boot默认的Servlet容器Tomcat</td> 
  </tr> 
  <tr> 
   <td>spring-boot-starter-Jetty</td> 
   <td>使用Jetty作为Servlet容器替换Tomcat</td> 
  </tr> 
  <tr> 
   <td>spring-boot-starter-undertow</td> 
   <td>使用Undertow作为Servlet容器替换Tomcat</td> 
  </tr> 
  <tr> 
   <td>spring-boot-starter-logging</td> 
   <td>Spring Boot默认的日志框架Logback</td> 
  </tr> 
  <tr> 
   <td>spring-boot-starter-log4j</td> 
   <td>支持使用log4J日志框架</td> 
  </tr> 
  <tr> 
   <td>spring-boot-starter-websocket</td> 
   <td>对WebSocket开发的支持</td> 
  </tr> 
  <tr> 
   <td>spring-boot-starter-ws</td> 
   <td>对Spring Web Services的支持</td> 
  </tr> 
 </tbody> 
</table>

## 二. 第三方starter pom ##

除了官方`starter pom`外，还有第三方为`Spring` `Boot`所写的`starter pom`，如下图所示：

<table> 
 <thead> 
  <tr> 
   <th>名称</th> 
   <th>地址</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Handlebars</td> 
   <td>https://github.com/allegro/handlebars-spring-boot-starter</td> 
  </tr> 
  <tr> 
   <td>Vaadin</td> 
   <td>https://github.com/vaadin/spring/tree/master/vaadin-spring-boot-starter</td> 
  </tr> 
  <tr> 
   <td>Apache Camel</td> 
   <td>https://github.com/apache/camel/tree/master/components/camel-spring-boot</td> 
  </tr> 
  <tr> 
   <td>WRO4J</td> 
   <td>https://github.com/sbuettner/spring-boot-autoconfigure-wro4j</td> 
  </tr> 
  <tr> 
   <td>Spring Batch(高级用法)</td> 
   <td>https://github.com/codecentric/spring-boot-starter-batch-web</td> 
  </tr> 
  <tr> 
   <td>HDIV</td> 
   <td>https://github.com/hdiv/spring-boot-starter-hdiv</td> 
  </tr> 
  <tr> 
   <td>Jade Templates (Jadw4j)</td> 
   <td>https://github.com/domix/spring-boot-starter-jade4j</td> 
  </tr> 
  <tr> 
   <td>Activiti</td> 
   <td>https://github.com/Activiti/Activiti/tree/master/modules/activiti-spring-boot/spring-boot-starte</td> 
  </tr> 
 </tbody> 
</table>

如果有需要我们也可以编写自己的`starter` `pom`。

# [Spring Boot的xml配置][Spring Boot_xml] #

`Spring Boot`提倡零配置，即无`xml`配置，但是在实际项目中，可能有一些特殊要求你必须使用`xml`配置，这时候可以通过在配置类上面使用`Spring`提供的`@ImportResource`来在加载`xml`配置，例如：

@ImportResource(value = { "classpath:some-context.xml","classpath:another-context.xml" })

## 二. 示例 ##

## 1. 新建包 ##

新建两个包:`org.light4j.springboot.xml.scan`和`org.light4j.springboot.xml.noScan`

## 2. 新建启动类 ##

新建`Application.java`启动类，放到包`org.light4j.springboot.xml.scan`下，根据`Spring` `Boot`的扫描原则（扫描从根包到子包的原则），能够扫描到`org.light4j.springboot.xml.scan`以及它的子包，`org.light4j.springboot.xml.noScan`包以及子包则不能被扫描到，代码如下：

package org.light4j.springboot.xml.scan;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.context.annotation.ImportResource;
    
    @SpringBootApplication
    public class Application {
        public static void main(String[] args) {
            SpringApplication.run(Application.class, args);
        }
    }

## 3. 新建Service类 ##

新建`ScanService`和`NoScanService`两个`Service`类，根据`Spring ``Boot`的扫描原则，我们把`ScanService`写在`Spring ``Boot`可以扫描的位置,也即放到包`org.light4j.springboot.xml.scan`下，`NoScanService`写在`Spring``Boot`无法扫描到的位置,也即放到包`org.light4j.springboot.xml.noScan`下。  
**`ScanService.java`代码如下所示：**

package org.light4j.springboot.xml.scan;
    
    import org.springframework.stereotype.Service;
    
    @Service
    public class ScanService {
        public ScanService() {
            System.out.println("I am ScanService,i can be scan");
        }
    }

**`NoScanService.java`代码如下所示：**

package org.light4j.springboot.xml.noScan;
    
    import org.springframework.stereotype.Service;
    
    @Service
    public class NoScanService {
        public NoScanService() {
            System.out.println("I am NoScanService,i can not be scan");
        }
    }

## 4. 运行程序 ##

运行`Application.java`，看到控制台打印日志如下图所示：  
![11-8.png][]  
从上面可以看到，在程序启动的时候，执行了`ScanService`类的构造函数，而`NoScanService`没有执行，这是因为`NoScanService`所在的包没有被扫描到，所以没有进行初始化。 那么下面我们使用`xml`配置文件的方式进行引入。

## 5. 编写application-bean.xml ##

在`src/main/resouces`目录下编写配置文件`application-bean.xml`文件，内容如下所示：

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    
        
        <bean id="noScanService" class="org.light4j.springboot.xml.noScan.NoScanService"></bean>
    
    </beans>

## 6. 导入配置文件 ##

在启动类`Application`上使用注解`@ImportResource(value = { "classpath:application-bean.xml" })`导入`bean`的配置文件，修改后的`Application`启动类如下图所示：

package org.light4j.springboot.xml.scan;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.context.annotation.ImportResource;
    
    @SpringBootApplication
    @ImportResource(value = { "classpath:application-bean.xml" })
    public class Application {
        public static void main(String[] args) {
            SpringApplication.run(Application.class, args);
        }
    }

## 7.运行程序测试 ##

运行`Application.java`，现在看到控制台打印日志如下图所示：  
![11-9.png][]  
从上面可以看到，在程序启动的时候，`ScanService`和`NoScanService`的构造函数都被执行了，二者构造函数里的代码都在控制台打印。

# [命令行参数配置][Link 3] #

`Spring` `Boot`可以允许使用`properties`文件，`yaml`文件或者命令行参数作为外部配置。使用`properties`文件，`yaml`文件进行配置的例子在之前文章[Spring Boot核心(二):Spring Boot的配置文件][Spring Boot 1]中已经有过演示，下面专门说命令行参数配置。

`Spring` `Boot`可以是基于`jar`包运行的，使用如下命令打包：

mvn package

打成`jar`包的程序可以直接通过下面的命令运行：

java -jar xxx.jar

可以通过以下命令修改`Tomcat`端口号：

java -jar xxx.jar --server.port=9090

修改之后`Tomcat`将在`9090`端口启动服务。

# [常规属性配置][Link 4] #

在之前的文章[Spring4.x常用配置(二):Spring EL和资源调用][Spring4.x_Spring EL]中讲述了在常规`Spring`环境下，注入`properties`文件里面的值的方式，通过`@PropertySource`指明`properties`文件的位置，然后通过`@Value`注入值。在`Spring` `Boot`里，我们只需在`application.properties`定义属性，直接使用`@Value`注入值即可。

## 二. 示例 ##

## 1. application.properties增加属性： ##

article.author=feeerss
    article.name=spring boot

## 2. 修改控制器类 ##

控制器类如下所示：

package org.light4j.springboot.properties.controller;
    
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    @RestController
    public class HelloController {
        @Value("${article.author}")
        private String articleAuthor;
        @Value("${article.name}")
        private String articleName;
    
        @RequestMapping("/")
        public String hello() {
            return "article name is:" + articleName + " and article author is:" + articleName;
        }
    }

## 3. 运行 ##

启动入口类`Application`，访问[http://localhost:8080/][http_localhost_8080]，**效果如下图所示：**  
![11-1.png][]

# [类型安全的属性配置][Link 5] #

[常规属性配置][Link 4]文章中使用`@Value`注入每个配置在实际项目中会显得格外麻烦，因为我们的配置通常会是许多个，若使用上篇文章的方式则要使用`@Value`注入很多次。

`Spring` `Boot`还提供了基于类型安全的属性配置方式，通过`@ConfigurationProperties`将`properties`属性和一个`Bean`及其属性关联，从而实现类型安全的配置。

## 二. 示例 ##

**1. 新建Spring Boot项目**

**2.添加配置**

在`application.properties`上添加：

article.author=xxxxxxx
    article.name=spring boot

当然，我们也可以新建一个`properties`文件，这就需要我们在`@ConfigurationProperties`的属性`locations`里指定`properties`的位置，且需要在入口类上配置。

**3. 创建类型安全的`Bean`**，代码如下所示：

package org.light4j.springboot.save.properties.config;
    
    import org.springframework.boot.context.properties.ConfigurationProperties;
    import org.springframework.stereotype.Component;
    
    @Component
    @ConfigurationProperties(prefix = "article") // ①
    public class ArticleSettings {
        private String author;
        private String name;
        public String getAuthor() {
            return author;
        }
        public void setAuthor(String author) {
            this.author = author;
        }
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
    }

## 代码解释： ##

> ① 通过`ConfigurationProperties`加载`properties`文件内的配置，通过`prefix`属性指定`properties`的配置的前缀，通过`locations`指定`properties`文件的位置，例如：

@ConfigurationProperties(prefix = "article",locations={"classpath:config/article.properties"})

本例中，由于直接配置在`application.properties`文件里面，所以不需要配置`locations`属性。

**4. 校验代码**，修改`HelloController`的代码如下所示：

package org.light4j.springboot.save.properties.controller;
    
    import org.light4j.springboot.save.properties.config.ArticleSettings;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    @RestController
    public class HelloController {
    
        @Autowired
        private ArticleSettings articleSettings; //①
    
        @RequestMapping("/")
        public String hello() {
            return "article name is "+ articleSettings.getName()+" and article author is "+articleSettings.getAuthor();
        }
    }

## 代码解释： ##

> ① 可以用`@Autowired`直接注入该配置

# [日志配置][Link 6] #

`Spring` `Boot`支持`Java Util Logging`，`Log4J`,`Log4J2`和`Logback`作为日志框架，无论使用哪种日志框架，`Spring``Boot`已经为当前使用的日志框架在控制台的输出以及在文件的输出做好了配置，可以对比前面文章[SpringMvc4.x基础(一):Spring MVC项目快速搭建][SpringMvc4.x_Spring MVC]中没有使用`Spring` `Boot`时候的日志配置的方式。

默认情况下，`Spring` `Boot`使用`Logback`作为日志框架。

## 二. 示例 ##

**1. 配置日志文件，格式为`logging.file=文件路径`：**

logging.file=F:/mylog/log.log

**2. 配置日志级别，格式为`logging.level.包名=级别`，如下所示：**

logging.level.org.springframework.web = DEBUG

## 三. 测试 ##

运行程序，可以看到控制台输出`DBUG`日志如下：  
![11-4.png][]  
在文件路径下生成了日志文件,并且里面也保存了日志内容，如下图所示：  
![11-5.png 1][]

# [Profile配置][Profile] #

`Profile`是`Spring`用来针对不同的环境对不同的配置提供支持的，全局`Profile`配置使用`application-{profile}.properties`(如`application-prod.properties`)。

通过在`application.properties`中设置`spring.profiles.active`的值来指定活动的`Profile`配置。

## 二. 示例 ##

下面将进行一个最简单的演示，例如我们分别为生产(`prod`)和开发(`dev`)环境，生产环境下端口号为`80`，开发环境下端口号为`8888`

**1. 新建配置文件**  
在`src/main/resources`下新建三个配置文件代表普通配置文件，开发环境配置文件，生产环境配置环境，文件名分别是`application.properties`，`application-dev.properties`，`application-prod.properties`。

`application-prod.properties`文件的内容如下所示：

server.port=80

`application-dev.properties`文件的内容如下所示：

server.port=8888

此时`src/main/resources`的目录结构如下所示：  
![11-3.png][]

## 2. 运行 ##

`application.properties`增加内容：`spring.profiles.active=dev`，**启动程序结果为：**  
![xxx][]  
将文件`application.properties`的内容`spring.profiles.active=dev`修改为：`spring.profiles.active=prod`，**启动程序结果为：**  
![xxx][xxx 1]

# 关闭特定的自动配置： #

如：@SpringBootApplication(exclude = \{ DataSourceAutoConfiguration.class \})

# 启动查看自动配置报告 #

在application.properties 增加debug=true

# [Spring Boot的AOP配置][Spring Boot_AOP] #

`AOP`是`Spring`框架中的一个重要内容，在`Spring` `boot`里配置`aop`非常简单，`Spring` `Boot`对`AOP`的默认配置属性是开启的，也就是说`spring.aop.auto`属性的值默认是`true`，我们只要引入了`AOP`依赖后，默认就已经增加了`@EnableAspectJAutoProxy`功能，不需要我们在程序启动类上面加入注解`@EnableAspectJAutoProxy`。

下面将使用`Spring` `Boot`通过模拟记录操作日志来演示基于注解拦截的`AOP`实现方式。

## 二. 示例 ##

## 1. 添加依赖 ##

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

## 2. 编写拦截规则的注解 ##

package org.light4j.springboot.aop.annotation;
    
    import java.lang.annotation.Documented;
    import java.lang.annotation.ElementType;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.annotation.Target;
    
    @Target({ ElementType.PARAMETER, ElementType.METHOD })
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    public @interface Action {
    
        String value() default "";
    }

## (3). 在控制器的方法上使用注解@Action ##

package org.light4j.springboot.aop.controller;
    
    import org.light4j.springboot.aop.annotation.Action;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    @RestController
    public class HelloController {
    
        @RequestMapping("/")
        @Action("hello")
        public String hello() {
            return "Hello Spring Boot";
        }
    }

## 代码解释 ##

> `@Action`注解加在方法`hello()`上面。

## (5). 编写切面 ##

package org.light4j.springboot.aop.aspect;
    
    import java.lang.reflect.Method;
    
    import org.aspectj.lang.JoinPoint;
    import org.aspectj.lang.annotation.AfterReturning;
    import org.aspectj.lang.annotation.Aspect;
    import org.aspectj.lang.annotation.Before;
    import org.aspectj.lang.annotation.Pointcut;
    import org.aspectj.lang.reflect.MethodSignature;
    import org.light4j.springboot.aop.annotation.Action;
    import org.springframework.stereotype.Component;
    
    @Aspect
    @Component
    public class LogAspect {
    
        // pointCut
        @Pointcut("@annotation(org.light4j.springboot.aop.annotation.Action)")
        public void log() {
    
        }
    
        /**
         * 前置通知
         */
        @Before("log()")
        public void doBeforeController(JoinPoint joinPoint) {
            MethodSignature signature = (MethodSignature) joinPoint.getSignature();
            Method method = signature.getMethod();
            Action action = method.getAnnotation(Action.class);
            System.out.println("action名称 " + action.value()); // ⑤
        }
    
        /**
         * 后置通知
         */
        @AfterReturning(pointcut = "log()", returning = "retValue")
        public void doAfterController(JoinPoint joinPoint, Object retValue) {
            System.out.println("retValue is:" + retValue);
        }
    }

## 代码解释 ##

> ①通过`@Aspect`注解声明该类是一个切面。  
> ②通过`@Component`让此切面成为`Spring`容器管理的`Bean`。  
> ③通过`@Pointcut`注解声明切面。  
> ④通过`@After`注解声明一个建言，并使用`@Pointcut`定义的切点。  
> ⑤通过反射可以获得注解上面的属性，然后做日志记录相关的操作，下面的相同。  
> ⑥通过`@Before`注解声明一个建言，此建言直接使用拦截规则作为参数。

[Spring Boot]: http://blog.longjiazuo.com/archives/1546
[Spring4.x]: http://blog.longjiazuo.com/archives/1361
[11-5.png]: /images/20220516/d590181b23934369b09e652292ee90d2.png
[http_patorjk.com_software_taag]: http://patorjk.com/software/taag
[Spring Boot 1]: http://blog.longjiazuo.com/archives/1558
[Link 1]: https://docs.spring.io/spring-boot/docs/current-SNAPSHOT/reference/htmlsingle/#appendix
[Spring Boot_starter pom]: http://blog.longjiazuo.com/archives/1563
[Link 2]: http://docs.spring.io/spring-boot/docs/current-SNAPSHOT/reference/htmlsingle/#using-boot-starter
[Spring Boot_xml]: http://blog.longjiazuo.com/archives/1565
[11-8.png]: /images/20220516/f30fd154526a4283ae75eb36d967c792.png
[11-9.png]: /images/20220516/b228d1b24e4341c4b09ba50904018a83.png
[Link 3]: http://blog.longjiazuo.com/archives/1569
[Link 4]: http://blog.longjiazuo.com/archives/1572
[Spring4.x_Spring EL]: http://blog.longjiazuo.com/archives/1294
[http_localhost_8080]: http://localhost:8080/
[11-1.png]: /images/20220516/f14fcbe7533d40e38ccb0cce734e2de8.png
[Link 5]: http://blog.longjiazuo.com/archives/1582
[Link 6]: http://blog.longjiazuo.com/archives/1592
[SpringMvc4.x_Spring MVC]: http://blog.longjiazuo.com/archives/1389
[11-4.png]: /images/20220516/3a105db4c5af4da89857ddc691ea70fb.png
[11-5.png 1]: /images/20220516/73eb38664074419ba174e953a38a28f0.png
[Profile]: http://blog.longjiazuo.com/archives/1596
[11-3.png]: /images/20220516/233c2efaf45043cb8ac69423167e340a.png
[xxx]: /images/20220516/90d060e9fbdc48298e741138ec011416.png
[xxx 1]: /images/20220516/e7b235ec255e4f8a8f129cdd10b9b31e.png
[Spring Boot_AOP]: http://blog.longjiazuo.com/archives/1606