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 }
原文地址：https://www.cnblogs.com/maigy/p/10859480.html