【SpringBoot1.x】SpringBoot1.x 入门

SpringBoot1.x 入门

文章源码

简介

传统的 JavaEE 开发，十分笨重且配置繁琐，开发效率很低，而且有很复杂的部署流程，对于第三方技术的集成也很困难。

Sring 全家桶时代则解决了上面的问题，而 SpringBoot 则是 JavaEE 一站式解决方案，SpringCloud 是分布式整体解决方案。

SpringBoot 可以简化 Spring 应用开发，遵循约定大于配置的原则，去繁从简。

SpringBoot 的优点：

• 快速创建独立运行的 Spring 项目以及与主流框架集成
• 使用嵌入式的 Servlet 容器，应用无需打成WAR包
• starters 自动依赖与版本控制
• 大量的自动配置，简化开发，也可修改默认值
• 无需配置 XML，无代码生成，开箱即用
• 准生产环境的运行时应用监控
• 与云计算的天然集成

微服务介绍

传统的单体应用：

• 一个单体应用把所有的功能都放在一个单一进程中
• 通过在多个服务器上复制这些单体进行扩展
• 开发、测试、部署和升级等较为繁琐

微服务应用：

• 微服务是一种架构风格
• 一个微服务架构把每个功能元素放进一个独立的服务中，可以通过 HTTP 等方式进行互通
• 通过跨服务器分发这些服务进行扩展，只在需要时才复制
• 每一个功能元素最终都是一个可独立替换和独立升级的软件单元

HelloWorld

传统方式创建

需求：浏览器发送 hello 请求，服务器接受请求并处理，响应 Hello World 字符串。

实现步骤：

• 创建一个 Maven 工程

• 引入 SpringBoot 相关依赖

      <parent>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter-parent</artifactId>
          <version>1.5.22.RELEASE</version>
          <relativePath/> <!-- lookup parent from repository -->
      </parent>
      <dependencies>
          <dependency>
              <groupId>org.springframework.boot</groupId>
              <artifactId>spring-boot-starter-web</artifactId>
          </dependency>
      </dependencies>
      
  

• 创建主程序

  package cn.parzulpan.helloworld;
  
  import org.springframework.boot.SpringApplication;
  import org.springframework.boot.autoconfigure.SpringBootApplication;
  
  /**
  * @SpringBootApplication 来标注一个主程序类，说明这是一个Spring Boot应用
  */
  
  @SpringBootApplication
  public class HelloworldApplication {
  
      public static void main(String[] args) {
          // Spring应用启动起来
          SpringApplication.run(HelloworldApplication.class, args);
      }
  
  }
  

• 编写相关的 Controller、Service

  package cn.parzulpan.helloworld.cotroller;
  
  import org.springframework.stereotype.Controller;
  import org.springframework.web.bind.annotation.RequestMapping;
  import org.springframework.web.bind.annotation.ResponseBody;
  import org.springframework.web.bind.annotation.RestController;
  
  /**
  * @Author : parzulpan
  * @Time : 2020-12
  * @Desc :
  */
  
  // 由于方法都是 Restful 风格，还可以直接用在类上
  //@ResponseBody
  //@Controller
  // RestController 更加简单
  @RestController
  public class HelloController {
  
      // ResponseBody 将这个方法返回的数据直接写给浏览器，如果是对象还可以直接转为 json 数据
  //    @ResponseBody
      @RequestMapping("/hello")
      public String hello() {
          return "hello world!";
      }
  }
  

• 运行主程序即可

• 或者以简化部署的方式运行

      <!--这个插件，可以将应用打包成一个可执行的 jar 包，然后直接使用 java -jar 的命令进行执行 -->
      <build>
          <plugins>
              <plugin>
                  <groupId>org.springframework.boot</groupId>
                  <artifactId>spring-boot-maven-plugin</artifactId>
              </plugin>
          </plugins>
      </build>
  

Spring Initializer 快速创建

IDE 都支持使用 Spring 的项目创建向导快速创建一个 SpringBoot 项目。可以根据自己的需求选择不同组件，比如这里选择 Web 组件。

默认生成的 SpringBoot 项目，包括：

• 主程序已经生成好了，我们只需要我们自己的逻辑
• resources 文件夹中目录结构
  • static 保存所有的静态资源
  • templates 保存所有的模板页面，SpringBoot 默认 jar 包使用嵌入式的 Tomcat，默认不支持 JSP 页面，可以使用模板引擎（freemarker、thymeleaf）
  • application.properties SpringBoot 应用的配置文件，可以修改一些默认设置

HelloWorld 探究

为什么这样简单的步骤和主程序就能运行起来了呢？

为什么能代替 Spring 那么复杂的开发？

POM 文件

完整的 pom.xml 为：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.22.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>cn.parzulpan</groupId>
    <artifactId>helloworld</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>helloworld</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

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

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>

    <!--这个插件，可以将应用打包成一个可执行的 jar 包，然后直接使用 java -jar 的命令进行执行 -->
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

---

注意到有一个 parent 标签：

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.22.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <!-- 这个 parent 标签 点进去能得到 -->
    <!-- spring-boot-starter-parent-1.5.22.RELEASE.pom -->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-dependencies</artifactId>
        <version>1.5.22.RELEASE</version>
        <relativePath>../../spring-boot-dependencies</relativePath>
    </parent>

它来真正管理 SpringBoot 应用里面的所有依赖版本（<artifactId>spring-boot-dependencies</artifactId> 定义了 jar 包的版本），所以以后我们导入依赖默认是不需要写版本的。

---

然后还注意到了这样的一个依赖：

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

它是 SpringBoot 的场景启动器，帮助我们导入了 web 模块正常运行所需要依赖的组件。

SpringBoot 将所有的功能场景都抽取出来，做成一个个的 starters（启动器），只需要在项目里面引入这些 starter，相关场景的所有依赖都会导入进来。要用什么功能就导入什么场景的启动器。

主程序

它也是主入口类，也是主配置类

@SpringBootApplication
public class HelloworldApplication {

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

@SpringBootApplication Spring Boot应用标注在某个类上说明这个类是 SpringBoot 的主配置类，SpringBoot 就应该运行这个类的 main 方法来启动 SpringBoot 应用。

---

深入查看 @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 {}

@SpringBootConfiguration 标注在某个类上，表示这是一个Spring Boot的配置类。它的源码如下，所以配置类也是容器中的一个组件。

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

---

@EnableAutoConfiguration 开启自动配置功能，以前需要配置的东西，SpringBoot 会帮我们自动配置。它的源码如下：

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import(EnableAutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {}

---

@AutoConfigurationPackage 自动配置包。它的源码如下：

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@Import(AutoConfigurationPackages.Registrar.class)
public @interface AutoConfigurationPackage {}

@Import(AutoConfigurationPackages.Registrar.class) 这是 Sping 的底层注解，表示给容器导入一个组件。这里可以看到，导入的组件为 AutoConfigurationPackages.Registrar.class，它可以将主配置类（@SpringBootApplication 标注的类）的所在包以及所有自曝理由的所有组件都扫描 Spring 容器中。

---

@Import(EnableAutoConfigurationImportSelector.class) 表示导入哪些组件的选择器，将所有需要导入的组件以全类名的方式返回，这些组件就会被添加到容器中。

---

通过上面的分析，这些注解会给给容器中导入非常多的自动配置类（xxxAutoConfiguration），有了这些自动配置类，就免去了我们手动编写配置注入功能组件等的工作。

SpringBoot 在启动的时候从类路径下的 spring-boot-autoconfigure-1.5.22.RELEASE.jar!/META-INF/spring.factories 中获取 EnableAutoConfiguration 指定的值，将
这些值作为自动配置类导入到容器中，自动配置类就生效，帮我们进行自动配置工作。以前我们需要自己配置的东西，现在自动配置类都会帮我们自动配置。

练习和总结