SpringBoot快速入门（解析+入门案例源码实现）

冷不防 2022-10-09 00:35 212阅读 0赞

### 这里写目录标题 ###

*  SpringBoot入门
 *   *  一、SpringBoot 概念
     *  二、JavaConfig 入门
     *   *  1. JavaConfig 概念
         *  2. 项目准备
     *  三、常用注解
     *  四、SpringBoot 入门案例
     *  五、SpringBoot 入门案例分析
     *   *  问题1：web打包不应该是war,为什么是jar
         *  问题2：pom.xml文件中继承的spring-boot-starter-parent有啥用
         *  问题3：pom.xml文件中导入的依赖spring-boot-starter-web又有啥用
         *  问题4：启动类App头顶上的@SpringBootApplication注解做了什么
         *  问题5：没有配置tomcat，没有设置端口服务器怎么来，又怎么启动的
         *  问题6：main方法中SpringApplication.run(..)又是什么情况
 *  总结

# SpringBoot入门 #

## 一、SpringBoot 概念 ##

SpringBoot其实不是一个新的框架，而是对Spring的补充、改善和优化。基于约定优于配置的思想，可以让开发人员不必在配置与逻辑业务之间进行思维的切换，全身心的投入到逻辑业务的代码编写中，从而大大提高了开发的效率，一定程度上缩短了项目周期。

## 二、JavaConfig 入门 ##

### 1. JavaConfig 概念 ###

java config 是指基于java配置的 spring，简单来说 javaconfig 就是使用 java 注解替换原来的 xml 配置。传统的Spring一般都是基本 xml 配置的，后来 spring3.0 新增了许多 java config 的注解，尤其是 spring boot，基本都是 java config 配置。Springboot 原理基于 javaConfig 的，学好 javaConfig 会为 springboot 打好基础。

### 2. 项目准备 ###

1.  创建 maven 项目
2.  导入依赖

<properties>
 <spring.version>5.0.8.RELEASE</spring.version>
 <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
 <maven.compiler.source>11</maven.compiler.source>
 <maven.compiler.target>11</maven.compiler.target>
 </properties>
 <dependencies>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-test</artifactId>
 <version>${spring.version}</version>
 </dependency>
 <dependency>
 <groupId>org.projectlombok</groupId>
 <artifactId>lombok</artifactId>
 <version>1.16.22</version>
 <scope>provided</scope>
 </dependency>
 <dependency>
 <groupId>junit</groupId>
 <artifactId>junit</artifactId>
 <version>4.12</version>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-context-support</artifactId>
 <version>${spring.version}</version>
 </dependency>
 </dependencies>

1.  JavaConfig 案例实现

*  定义一个名为 SomeBean 的 Bean

public class SomeBean { 
    }

*  定义一个名为 AppConfig 的配置类

@Configuration
    @ComponentScan(basePackages ="cn.wolfcode._03_scan" )  //组件扫描标签
    @Import(OtherConfig.class)
    @ImportResource("classpath:applicationContext.xml")
    @PropertySource("classpath:db.properties")
    public class AppConfig { 
        @Value("${jdbc.driverClassName}")
        private String driverClassName;
        
        @Bean(value = "sb",initMethod = "init", destroyMethod = "destroy")
        public SomeBean someBean(){ 
            return new SomeBean();
        }
    }

*  测试类：TestApp

@RunWith(SpringRunner.class)
    // 引用的是配置类而不是配置文件
    @ContextConfiguration(classes = AppConfig.class)
    public class TestApp { 
        @Autowired
        private ApplicationContext ctx;
        @Test
        public void testApp(){ 
            SomeBean someBean = ctx.getBean("someBean", SomeBean.class);
            System.out.println(someBean);
        }
    }

## 三、常用注解 ##

<table> 
 <thead> 
 <tr> 
 <th align="left">注解</th> 
 <th align="left">作用</th> 
 <th align="left">对比</th> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <td align="left">@Configuration</td> 
 <td align="left">Spring 配置注解； 作用：贴有这个注解的类为配置类；</td> 
 <td align="left">等价于： applicationContext.xml</td> 
 </tr> 
 <tr> 
 <td align="left">@Bean</td> 
 <td align="left">Spring 的 bean 实例标签； 作用： 【1】贴有该注解的方法表示该方法为实例方法； 【2】该方法返回的对象会嫁给 Spring 容器管理； 属性： 【1】bean标签中name属性等价于@Bean注解中name/value属性； 【2】bean标签中id属性等价于实例方法的方法名； 【3】bean标签中init-method属性等价于@Bean注解中initMethod属性； 【4】bean标签中destroy-method属性等价于@Bean注解中destroyMethod属性； 【5】bean标签中scope属性等价于实例方法中的@Scope注解；</td> 
 <td align="left">等价于： </td> 
 </tr> 
 <tr> 
 <td align="left">@ComponentScan</td> 
 <td align="left">Spring 组件扫描注解； 作用： 扫描指定包路径下（包括子包）所有贴有版型标签（@Controller、@Service、@Repository、@Component、@）的类，创建对象并交给容器管理； 默认情况： 如果不指定包路径，会扫描当前类所在包及其子包；</td> 
 <td align="left">等价于： &lt;context:component-scan base-package=“扫描包路径”/&gt;</td> 
 </tr> 
 <tr> 
 <td align="left">@Import</td> 
 <td align="left">配置类导入注解； 作用：贴在配置类上，用于配置类与配置类间的导入；</td> 
 <td align="left">等价于： </td> 
 </tr> 
 <tr> 
 <td align="left">@ImportResource</td> 
 <td align="left">配置文件导入注解； 作用：贴在配置类上，用于配置类与配置文件间的导入；</td> 
 <td align="left">等价于： </td> 
 </tr> 
 <tr> 
 <td align="left">@PropertySource</td> 
 <td align="left">资源配置文件加载注解; 作用：贴在配置类上，用于将properties类型文件加载到spring容器中；</td> 
 <td align="left">等价于： &lt;context:property-placeholder location=“classpath:xxx.perperties”/&gt;</td> 
 </tr> 
 <tr> 
 <td align="left">@Value</td> 
 <td align="left">资源文件取值注解; 作用：从properties配置中获取配置的数据，使用SpEL表达式</td> 
 <td align="left">等价于： </td> 
 </tr> 
 <tr> 
 <td align="left">@SpringBootApplication</td> 
 <td align="left">@SpringBootApplication注解等同于3大注解功能的集成； @ComponentScan: 开启组件扫描； @SpringBootConfiguration: 作用等同于@Configuration注解,也是用于标记配置类； @EnableAutoConfiguration: 开启了Spring Boot中最重要的特性—自动配置，自动配置可以根据你引入的依赖自动生成Bean等。告诉SpringBoot基于所添加的依赖，去“猜测”你想要如何配置Spring。比如我们引入了spring-boot-starter-web，而这个启动器中帮我们添加了tomcat、SpringMVC的依赖，此时自动配置就知道你是要开发一个web应用，所以就帮你完成了web及SpringMVC的默认配置了！我们使用SpringBoot构建一个项目，只需要引入所需框架的依赖，配置就可以交给SpringBoot处理了；</td> 
 <td align="left"></td> 
 </tr> 
 <tr> 
 <td align="left">@MapperScan</td> 
 <td align="left">mybatis 接口扫描注解：@MapperScan(basePackages = “com.yy.springboot.mapper”) 作用： 【1】mybatis 中 mapper 接口扫描器，指定参数为：mapper 接口所在路径； 【2】功能：将包中路径下所有接口动态代理，创建 mapper 接口实现类交给 spring 容器管理；</td> 
 <td align="left"></td> 
 </tr> 
 <tr> 
 <td align="left">@ConfigurationProperties</td> 
 <td align="left">资源文件批量取值注解; @ConfigurationProperties(prefix=“name”) 其中 name 对应配置文件中相应的前缀值 作用： 【1】作用在方法上：@Configuration注解的配置类中通过@Bean注解在某个方法上将方法返回的对象定义为一个Bean，并使用配置文件中对应前缀后面属性的值为该Bean的属性进行初始化。 【2】作用在类上：和 @component 一起使用，当Bean被实例化时，@ConfigurationProperties会将对应前缀的后面的属性与Bean对象的属性匹配。符合条件则进行赋值。</td> 
 <td align="left"></td> 
 </tr> 
 </tbody> 
</table>

## 四、SpringBoot 入门案例 ##

1.  创建一个普通的 maven 项目
2.  在pom.xml文件设置项目打包方式

1.  在pom.xml文件导入springboot父项目

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

1.  在pom.xml文件导入web项目依赖

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

1.  编写普通Controller类

@Controller
    public class HelloController { 
        @RequestMapping("/hello")    
        @ResponseBody   
        public Object hello(){ 
                return "hello, springboot~";
        }
    }

1.  编写启动类，启动springboot项目

@SpringBootApplication
    public class App { 
        public static void main(String[] args) { 
                SpringApplication.run(App.class, args);
        }
    }

1.  浏览器访问测试： http://localhost:8080/hello

## 五、SpringBoot 入门案例分析 ##

### 问题1：web打包不应该是war,为什么是jar ###

springboot默认的打包方式就是jar，传统的外接tomcat或插件式tomcat与web项目是相互独立，相互对接时必须满足一定规则，war包结构项目就是规则约定之一。而springboot项目采用的是内嵌式(简单理解为编码方式)tomcat，项目与tomcat融为一体，部署，启动，运行一体化，就没有各种条条框框的约束了。

### 问题2：pom.xml文件中继承的spring-boot-starter-parent有啥用 ###

spring-boot-starter-parent其实是SpringBoot提供了工具工程，工程收集了市面上常用各种第三方jar依赖，并对这些jar依赖进行了版本管理。当我们的项目继承这个项目工程，就自动成为springboot项目，并无偿继承了这些第三方jar依赖。后续项目中需要某个第三方依赖，只需要引入依赖坐标即可， 不需要关系依赖版本。比如：

<dependency>
 <groupId>org.projectlombok</groupId>
 <artifactId>lombok</artifactId>
 </dependency>

一个拓展：

继承是 Maven 中很强大的一种功能，继承可以使得子POM可以获得 parent 中的部分配置(groupId,version,dependencies,build,dependencyManagement等)，可以对子pom进行统一的配置和依赖管理。

*  parent项目中的dependencyManagement里的声明的依赖 , 只具有声明的作用，并不实现引入，因此子项目需要显式的声明需要用的依赖。如果不在子项目中声明依赖，是不会从父项目中继承下来的；只有在子项目中写了该依赖项，可以不指定具体版本，会从父项目中继承该项，并且version和scope都读取自父pom;另外如果子项目中指定了版本号，那么会使用子项目中指定的jar版本
 *  parent项目中的dependencies里声明的依赖会被所有的子项目继承

### 问题3：pom.xml文件中导入的依赖spring-boot-starter-web又有啥用 ###

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

问题2中说了，springboot收集了很多常用的第三方jar依赖，为了进一步提高用户体验感，springboot根据jar依赖特点，对这些依赖进一步分类，整合，再封装，形成一个新的依赖工具集， 每个工具集都解决特定领域的依赖问题。springboot将这些依赖工具称为：启动器（组件），命名规则： spring-boot-starter-xxx。 如果是非springboot定制的启动器， 一般命名规则：xxx-spring-boot-starter

入门案例中导入的spring-boot-starter-web 就是用于解决web项目依赖的工具集(启动器)

![在这里插入图片描述][20210622163636698.png]

常用的启动器(starter)还有很多：

> spring-boot-starter: 核心启动器 , 提供了自动配置,日志和YAML配置支持
> 
> spring-boot-starter-aop: 支持使用 `Spring AOP` 和 `AspectJ` 进行切面编程。
> 
> spring-boot-starter-freemarker: 支持使用 `FreeMarker` 视图构建Web 应用
> 
> spring-boot-starter-test: 支持使用 `JUnit`， 测试 `Spring Boot` 应用
> 
> spring-boot-starter-web: 支持使用 `Spring MVC` 构建 Web 应用，包括 `RESTful` 应用，使用 `Tomcat` 作为默认的嵌入式容器。
> 
> spring-boot-starter-actuator: 支持使用 Spring Boot Actuator 提供生产级别的应用程序监控和管理功能。
> 
> spring-boot-starter-logging: 提供了对日志的支持 , 默认使用Logback

### 问题4：启动类App头顶上的@SpringBootApplication注解做了什么 ###

要回答这个问题， 就必须讲清楚springboot的自动配置原理(也称自动装配)，【**面试必考，必须会**】

springboot的精髓就在这个注解里。

@SpringBootApplicationpublic class App { 
        public static void main(String[] args) { 
                SpringApplication.run(App.class, args);
        }
    }

先回顾一下以前使用springmv搭建web项目时， 我们是怎么做的

1.  导入web， spring， springmvc依赖
2.  在web.xml文件配置前端控制器：DispatcherServlet
3.  编写controller类
4.  配置controller扫描包路径
5.  部署到tomcat并启动

从上面步骤上看，刚刚入门案例不需要我们去做的有几步？

1.  不需要配置前端控制器
2.  不需要配置包扫描路径
3.  不需要部署tomcat这步

**@SpringBootApplication注解** 帮我们做了这些操作。

**@SpringBootApplication源码解析**

点击进入，查看源码：

@Target(ElementType.TYPE)
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @Inherited
    @SpringBootConfiguration
    @EnableAutoConfiguration
    @ComponentScan(excludeFilters = 
                   {  
                     @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
    				 @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) 
                   }
                  )
    public @interface SpringBootApplication { 
        ......
    }

注解上面又有一堆注解，核心的有3个：

*  **@SpringBootConfiguration**
 *  **@EnableAutoConfiguration**
 *  **@ComponentScan**

**注意**：注解头顶又贴有注解(非元注解)，表示当前注解为复合注解，当前注解也拥有所贴注解功能。

1.  **@ComponentScan**

功能：spring组件扫描注解，扫描所贴的类所在包及其子包所有贴有版型注解的类，并创建对象交给spring容器管理。

**注意**： **一般贴有@SpringBootApplication注解的类称之为启动类，建议放置在根包下。**

1.  **@SpringBootConfiguration**

@Target(ElementType.TYPE)
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @Configuration
    public @interface SpringBootConfiguration { 
        ....
    }

该注解头顶贴了`@Configuration`注解， 贴有`@Configuration`类为配置类

@SpringBootApplication   头顶贴有  @SpringBootConfiguration  
    @SpringBootConfiguration 头顶贴有  @Configuration

根据上面注解关系推导下：**贴有@SpringBootApplication注解的类就是一个项目配置类**。

**注意**：**一般springboot项目只有唯一一个启动类，启动类都是配置类。**

1.  **@EnableAutoConfiguration**

`@EnableAutoConfiguration`的作用，告诉SpringBoot基于你所添加的依赖，去“猜测”你想要如何配置Spring。比如当我们引入了`spring-boot-starter-web`这个启动器，spring会解析这个启动器，推测当前项目为web项目，根据启动器默认配置要求自动配置web及SpringMVC相关对象创建与管理。比如：前端控制的创建，比如前端控制的路径映射等。

SpringBoot对自带启动器与第三方启动器进行了大量的默认配置，这些配置是否生效，是否加载到spring容器中使用，取决于我们项目是否引入了对启动器依赖，如果有那么默认配置就会生效。

**注意**：**不管是spring定制的启动器，还是第三方定制的启动器，都需要编写META-INF/spring.factories，里面指定启动器的自动配置类**

**EnableAutoConfiguration 通过选择器导入一堆 SpringBoot 事先准备好的配置类（此时配置为全限定类类名），然后根据导入依赖决定激活符合条件的配置类，创建对象，并交给 Spring 容器管理。**

**总结**:

@SpringBootApplication注解内部是3大注解功能的集成

*  **@ComponentScan**: 开启组件扫描
 *  **@SpringBootConfiguration**: 作用等同于@Configuration注解,也是用于标记配置类
 *  **@EnableAutoConfiguration**: 内部导入AutoConfigurationImportSelector,该类中有个getCandidateConfigurations方法, 读取jar包中META-INF/spring.factories文件中配置类, , 再根据条件进行加载和配置, 比如: AOP / PropertyPlaceholder / FreeMarker / HttpMessageConverter / Jackson / DataSource / DataSourceTransactionManager / DispatcherServlet / WebMvc 等等

### 问题5：没有配置tomcat，没有设置端口服务器怎么来，又怎么启动的 ###

springboot使用嵌入式tomcat，编程实现，默认端口是8080，后续可以通过application.properties文件进行修改  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p6dmFy_size_16_color_FFFFFF_t_70]

### 问题6：main方法中SpringApplication.run(…)又是什么情况 ###

SpringApplication.run(…)的作用

*  启动SpringBoot应用
 *  加载自定义的配置类,完成自动配置功能
 *  把当前项目部署到嵌入的Tomcat服务器
 *  启动Tomcat服务器跑项目

# 总结 #

以上就是 SpringBoot 入门的介绍了，代码仅供参考，欢迎讨论交流。

[20210622163636698.png]: /images/20221005/6778a09b5dce4c7882e6b4faa96e1e54.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p6dmFy_size_16_color_FFFFFF_t_70]: /images/20221005/b38cbb392ee74263b182c530deb0811f.png