Spring Boot 的常用 API 说明

Posted 2021-11-30 maigy

1、SpringApplication 类

作用：用于启动 Spring Boot 的程序，根据传入的类的声明的注解来决定不同的启动方式

示例代码：

 1 package org.ranger;
 2 import org.springframework.boot.SpringApplication;
 3 import org.springframework.boot.autoconfigure.SpringBootApplication;
 4 //使用 SpringBoot 自动配置程序 
 5 @SpringBootApplication 
 6 public class Application {
 7      public static void main(String[] args) {
 8              //执行当前类,根据@SpringBootApplication 的配置,启动 SpringBoot 程序     
 9             SpringApplication.run(Application.class, args); 
10      }
11 }

2、@EnableAutoConfiguration 注解

注解的声明：

 1 @SuppressWarnings("deprecation") 
 2 @Target(ElementType.TYPE) 
 3 @Retention(RetentionPolicy.RUNTIME) 
 4 @Documented @Inherited 
 5 @AutoConfigurationPackage @Import(EnableAutoConfigurationImportSelector.class) 
 6 public @interface EnableAutoConfiguration { 
 7     String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration"; 
 8     Class<?>[] exclude() default {};
 9     String[] excludeName() default {};
10 }

作用：启动程序时，告诉 SpringApplication 启动对象使用 SpringBoot 的默认配置

只要在 SpringBoot 项目的入口配置了 @EnableAutoConfiguration，SpringBoot 框架启动时就会自动根据你导入的 jar 包来加载 spring-boot-autoconfigure-1.5.4.RELEASE-sources.jar 中的 xxxAutoConfiguration 配置类，使用其默认配置。

属性说明：

　　exclude 属性：使用 Class 格式的方式，排除默认自动启动中不需要的配置类

       excludeName 属性：使用类的限制名的方式，排序默认自动启动中不需要的配置类

3、@SpringBootApplication 注解

注解说明：

 1 @Target(ElementType.TYPE) 
 2 @Retention(RetentionPolicy.RUNTIME) 
 3 @Documented 
 4 @Inherited 
 5 @SpringBootConfiguration 
 6 @EnableAutoConfiguration 
 7 @ComponentScan(excludeFilters = { 
 8     @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class), 
 9     @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) }) 
10 public @interface SpringBootApplication { 
11    @AliasFor(annotation = EnableAutoConfiguration.class, attribute = "exclude") 
12    Class<?>[] exclude() default {};
13    @AliasFor(annotation = EnableAutoConfiguration.class, attribute = "excludeName") 
14    String[] excludeName() default {}; 
15    @AliasFor(annotation = ComponentScan.class, attribute = "basePackages") 
16    String[] scanBasePackages() default {}; 
17    @AliasFor(annotation = ComponentScan.class, attribute = "basePackageClasses") 
18    Class<?>[] scanBasePackageClasses() default {}; 
19 }

　　根据注解的声明可以得出：@SpringBootApplication 注解也是启动 Springboot 的默认配置。只是 在@EnableAutoConfiguration 注解的基础上增加了扫描包@ComponentScan 和 设置类为配置类 @SpringBootConfiguration 注解。实现了将给类设置为配置类、扫描指定范围的类创建对象到容器里面，并且自动加载Spring Boot默认配置。

属性说明：

　　① basePackages 属性 @SpringBootApplication 默认扫描的范围是使用该注解的当前的类的包以及子包,如果要指定其他 范围的包，可以是 basePackages 指定。

　　② basePackageClasses 属性 用于精确指定哪些类需要创建对象加载到 Spring 容器里面。

　　③ exclude 属性 通过 Class 的方式排除不扫描的类，就是该类不创建对象。

　　④ excludeName 属性 通过类的全限制名的方式，排除不扫描的类,指定的类不会在容器中创建对象。

4、@AutoConfigureBefore 注解

注解说明：

　　指定在 SpringBoot 框架自动配置的配置类执行完成之前，执行指定的自定义的配置类。 如果放在 Application 入口类，表示在所有自动配置的配置类还没有可以就先加载自定义的配置 类。

　　@AutoConfigureBefore 注解属性：

　　　　value:使用类的方式指定自动配置类

　　　　name：使用类的全限制名（字符串）类指定配置类

示例代码：

　　① 创建一个普通的类，没有任何注解

 1 package cn.mgy.utils;
 2 /** 
 3    * 创建一个没有扫描注入容器注解的类
 4    * @author ranger
 5 * */ 
 6 public class TestUtils { 
 7     /** 
 8       * 返回测试信息 
 9       * @return 
10       */ 
11       public String test(){ 
12           return "-测试注入对象成功-"; 
13       }
14 }

　　② 创建一个自定义配置类，注入普通的类的Spring容器

 1 package cn.mgy.config;
 2 
 3 import org.springframework.context.annotation.Bean;
 4 import org.springframework.context.annotation.Configuration;
 5 
 6 package cn.mgy.config;
 7 
 8 import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
 9 import org.springframework.context.annotation.Bean;
10 import org.springframework.context.annotation.Configuration;
11 
12 import cn.mgy.utils.TestUtils;
13 
14 /**
15  * 创建一个自定义的配置类
16  * @author ranger
17  *
18  */
19 @Configuration
20 public class MyConfiguration {
21     /**
22      * 返回一个对象到容器
23      * @return
24      */
25     @Bean(name="testUtils")
26     //表示如果Spring容器有TestUtils的对象就不执行这个方法在创建一次了。
27     @ConditionalOnMissingBean(TestUtils.class)
28     public TestUtils getTestUtils(){
29         TestUtils testUtils=new TestUtils();
30         return testUtils;
31     }
32 
33 }

　　③ 在入口类配置加入自定义配置类

package cn.mgy;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.AutoConfigureBefore;
import org.springframework.boot.autoconfigure.SpringBootApplication;

import cn.mgy.config.MyConfiguration;

//使用SpringBoot自动配置程序
@SpringBootApplication
//在自动配置的配置类之前启动自定义的配置类
@AutoConfigureBefore(value=MyConfiguration.class)
public class Application {
    
    public static void main(String[] args) {
        //执行当前类,根据@SpringBootApplication的配置,启动SpringBoot程序
        SpringApplication.run(Application.class, args);
        
    }

}

　　④ 在 Controller 里面使用这个注入的对象

 1 package cn.mgy.controller;
 2 
 3 import org.springframework.beans.factory.annotation.Autowired;
 4 import org.springframework.stereotype.Controller;
 5 import org.springframework.web.bind.annotation.RequestMapping;
 6 import org.springframework.web.bind.annotation.ResponseBody;
 7 
 8 import cn.mgy.utils.TestUtils;
 9 
10 @Controller
11 public class HelloController {
12     
13     @Autowired
14     private TestUtils testUtils;
15     
16     @RequestMapping(value="/")
17     @ResponseBody
18     public String say(){
19         System.out.println(testUtils.test());
20         return testUtils.test();
21     }
22 
23 }

　　⑤ 测试，成功

 

5、@AutoConfigureAfter注解

　　作用：指定在SpringBoot框架自动配置的配置类执行完成之后，然后执行指定的自定义的配置类。

6、@SpringBootTest注解

注解说明：用于使用JUnit测试SpringBoot程序，启动SpringBoot框架。测试SpringBoot一定要加上。

示例代码：

 1 package cn.mgy.test;
 2 
 3 import java.sql.SQLException;
 4 
 5 import javax.sql.DataSource;
 6 
 7 import org.junit.Test;
 8 import org.junit.runner.RunWith;
 9 import org.springframework.beans.factory.annotation.Autowired;
10 import org.springframework.boot.test.context.SpringBootTest;
11 import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
12 
13 @RunWith(SpringJUnit4ClassRunner.class)
14 //如果不加该注解，无法启动SpringBoot
15 @SpringBootTest
16 public class DataSourceTest {
17     
18     @Autowired
19     private DataSource dataSource;
20 
21     @Test
22     public void dataSource() {
23         try {
24             System.out.println(dataSource.getConnection());
25         } catch (SQLException e) {
26             // TODO Auto-generated catch block
27             e.printStackTrace();
28         }
29     }
30 
31 }