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

Posted 2021-06-29 Yan Yang

这里写目录标题

• 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>

3. 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();
    }
}

<bean name="someBean" class="..." ></bean>

• 测试类：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);
    }
}

三、常用注解

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

四、SpringBoot 入门案例

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

<packaging>jar</packaging>

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

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

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

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

5. 编写普通Controller类

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

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

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

7. 浏览器访问测试： 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项目依赖的工具集(启动器)

常用的启动器(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注解的类称之为启动类，建议放置在根包下。

2. @SpringBootConfiguration

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

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

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

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

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

3. @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文件进行修改

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

SpringApplication.run(…)的作用

• 启动SpringBoot应用

• 加载自定义的配置类,完成自动配置功能

• 把当前项目部署到嵌入的Tomcat服务器

• 启动Tomcat服务器跑项目

总结

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