一、SpringBoot介绍

  • 原有Spring优缺点分析
    • Spring的优点分析：
    • Spring是Java企业版（Java Enterprise Edition，JEE，也称J2EE）的轻量级代替品。无需开发重量级的Enterprise JavaBean（EJB），Spring为企业级Java开发提供了一种相对简单的方法，通过依赖注入和面向切面编程，用简单 的Java对象（Plain Old Java Object，POJO）实现了EJB的功能。
  • Spring的缺点分析
    • 虽然Spring的组件代码是轻量级的，但它的配置却是重量级的。一开始，Spring用XML配置，而且是很多XML配 置。Spring 2.5引入了基于注解的组件扫描，这消除了大量针对应用程序自身组件的显式XML配置。Spring 3.0引入 了基于Java的配置，这是一种类型安全的可重构配置方式，可以代替XML。 所有这些配置都代表了开发时的损耗。因为在思考Spring特性配置和解决业务问题之间需要进行思维切换，所以编 写配置挤占了编写应用程序逻辑的时间。和所有框架一样，Spring实用，但与此同时它要求的回报也不少。 除此之外，项目的依赖管理也是一件耗时耗力的事情。在环境搭建时，需要分析要导入哪些库的坐标，而且还需要 分析导入与之有依赖关系的其他库的坐标，一旦选错了依赖的版本，随之而来的不兼容问题就会严重阻碍项目的开发进度。
  • SpringBoot概念简介
    • Spring Boot是Spring公司的一个顶级项目，和Spring Framework是一个级别的。
    • Spring Boot实际上是利用Spring Framework 4 自动配置特性完成。编写项目时不需要编写xml文件。发展到现在，Spring Boot已经具有很很大的生态圈，各种主流技术已经都提供了Spring Boot的启动器。
  • 什么是启动器
    • Spring框架在项目中作用是Spring整合各种其他技术，让其他技术使用更加方便。Spring Boot的启动器实际上就是一个依赖。这个依赖中包含了整个这个技术的相关jar包，还包含了这个技术的自动配置，以前绝大多数XML配置都不需要配置了。当然了，启动器中自动配置无法实现所有内容的自动配置，在使用Spring Boot时还需要进行少量的配置（这个配置不是在xml中了，而是在properties或yml中即可）。如果是Spring自己封装的启动器的artifact id名字满足：spring-boot-starter-xxxx，如果是第三方公司提供的启动满足：xxxx-spring-boot-starter。以后每次使用Spring Boot整合其他技术时首先需要考虑导入启动器。

  • Spring Boot优点

    • ①　使用Spring Boot可以创建独立的Spring应用程序
    • ②　在Spring Boot中直接嵌入了Tomcat、Jetty、Undertow等Web 容器，在使用SpringBoot做Web开发时不需要部署WAR文件
    • ③　通过提供自己的启动器(Starter)依赖，简化项目构建配置
    • ④　尽量的自动配置Spring和第三方库
    • ⑤　绝对没有代码生成，也不需要XML配置文件
      1. <build>
      2. <plugins>
      3.  <!-- tomcat插件,在springboot中已经不需要了 -->
      4.  <plugin>
      5.    <groupId>org.apache.tomcat.maven</groupId>
      6.    <artifactId>tomcat7-maven-plugin</artifactId>
      7.    <version>2.2</version>
      8.    <configuration>
      9.      <port>8080</port>
      10.      <path>/ssm02</path>
      11.      <uriEncoding>UTF-8</uriEncoding>
      12.    </configuration>
      13.  </plugin>
      14.  <plugin>
      15.    <groupId>org.apache.maven.plugins</groupId>
      16.    <artifactId>maven-compiler-plugin</artifactId>
      17.    <version>3.1</version>
      18.    <configuration>
      19.      <source>1.8</source>
      20.      <target>1.8</target>
      21.      <encoding>utf-8</encoding>
      22.    </configuration>
      23.  </plugin>
      24. </plugins>
      25. </build>

  • Spring Boot版本介绍

    • SNAPSHOT：快照版，即开发版。
    • CURRENT：最新版，但是不一定是稳定版。
    • GA：General Availability，正式发布的版本。

image.png

  • Spring Boot的核心

    • 起步依赖- 起步依赖本质上是一个Maven项目对象模型（Project Object Model，POM），定义了对其他库的传递依赖，这些东西加在一起即支持某项功能。 简单的说，起步依赖就是将具备某种功能的坐标打包到一起，并提供一些默认的功能。

    • 自动配置 -Spring Boot的自动配置是一个运行时（更准确地说，是应用程序启动时）的过程，考虑了众多因素，才决定 Spring配置应该用哪个，不该用哪个。该过程是Spring自动完成的。

      二、项目搭建方式

      方式一

      新建一个maven项目，不使用其中的组件
      1、导入依赖方式1

      1. <?xml version="1.0" encoding="UTF-8"?>
      2. <project xmlns="http://maven.apache.org/POM/4.0.0"
      3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      4.     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
      5. <modelVersion>4.0.0</modelVersion>
      7. <groupId>org.example</groupId>
      8. <artifactId>springBoot_01</artifactId>
      9. <version>1.0-SNAPSHOT</version>
      11. <!--继承父项目方式-->
      12. <parent>
      13.    <groupId>org.springframework.boot</groupId>
      14.    <artifactId>spring-boot-starter-parent</artifactId>
      15.    <version>2.5.0</version>
      16. </parent>
      18. <dependencies>
      19.    <!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-web -->
      20.    <dependency>
      21.        <groupId>org.springframework.boot</groupId>
      22.        <artifactId>spring-boot-starter-web</artifactId>
      23.        <version>2.5.0</version>
      24.    </dependency>
      25. </dependencies>
      26. </project>

      依赖传递关系图
      image.png
      创建一个Controller文件 ```java package com.xiaohui.controller;

import org.springframework.stereotype.Controller; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.ResponseBody;

@Controller public class MyController { @RequestMapping(“/firstController”) @ResponseBody public String firstController(){ return “Hello springboot”; } }

  2. - 新建启动类
  3.    - Spring Boot的启动类的作用是启动Spring Boot项目，是基于Main方法来运行的。
  4.    - 注意：启动类在启动时会做注解扫描(@Controller、@Service、@Repository......)，扫描位置为同包或者子包下的注解，所以启动类的位置应放于包的根下。
  5.    - 能和service、mapper、controller目录同级，就能全部扫描进springboot中
  6. - 启动类与启动器区别：
  7.    - 启动类表示项目的启动入口
  8.    - 启动器表示jar包的坐标
  9.    - 必须在包中新建这个类，不能直接放入到java文件夹。
  10.    - 在com.msb下新建自定义名称的类(规范：XXXXApplication),可以是项目上下文路径Application
  11. ```java
  12. package com.xiaohui;
  14. import org.springframework.boot.SpringApplication;
  15. import org.springframework.boot.autoconfigure.SpringBootApplication;
  17. @SpringBootApplication
  18. public class Springboot01Application {
  19.     //定义一个主方法启动项目
  20.     public static void main(String[] args) {
  21.         SpringApplication.run(Springboot01Application.class,args);
  22.     }
  23. }

image.png

方式二

新建一个maven项目，不使用其中的组件
在公司中可能会出现必须继承某个项目，如果Spring Boot用了继承就不能继承别的项目了。所以Spring Boot还提供了依赖的方式。
pom.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0"
  3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5.     <modelVersion>4.0.0</modelVersion>
  7.     <groupId>org.example</groupId>
  8.     <artifactId>springBoot_02</artifactId>
  9.     <version>1.0-SNAPSHOT</version>
  11.     <dependencyManagement>
  12.         <dependencies>
  13.             <dependency>
  14.                 <groupId>org.springframework.boot</groupId>
  15.                 <artifactId>spring-boot-dependencies</artifactId>
  16.                 <version>2.5.0</version>
  17.                 <type>pom</type>
  18.                 <scope>import</scope>
  19.             </dependency>
  20.         </dependencies>
  21.     </dependencyManagement>
  22.     <dependencies>
  23.         <dependency>
  24.             <groupId>org.springframework.boot</groupId>
  25.             <artifactId>spring-boot-starter-web</artifactId>
  26.             <version>2.5.0</version>
  27.         </dependency>
  28.     </dependencies>
  30. </project>

方式三

使用idea自带springBoot项目初始化插件
image.png
image.png
image.png
image.png
创建后大概是这样子的
image.png
然后直接运行Springboot02Application中的主方法，就能启动服务器，结果和上述相同\

三、项目配置

1、properties配置文件

SpringBoot默认读取项目下名字为application开头的 yml yaml properties配置文件
image.png在项目下的application.properties里修改端口号和项目上下文路径
application.properties

  1. server.servlet.context-path=/springboot02
  2. server.port=8090

image.png
注意,这里的每一个. 都代表一个层级
SpringBoot常见配置
https://docs.spring.io/spring-boot/docs/current/reference/html/application-properties.html#application-properties.server
image.pngimage.png
注意,这里的每一个. 都代表一个层级 转换成yml之后,使用缩进代表层级关系

2、yml配置文件

创建一个application.yml文件
基本格式要求
①　大小写敏感
②　使用缩进代表层级关系
③　相同的部分只出现一次
④　注意空格

  1. # 基本数据类型
  2. server:
  3.   port: 8091
  4.   servlet:
  5.     context-path: springboot02
  6. # 配置对象类型数据
  7. person:
  8.   name: zhangsan
  9.   age: 25
  10.   sex: 男
  11.   #或者写成json格式
  12.   person2: {name: zhangsan,age: 20}
  13. #配置数组类型
  14. city:
  15.   - chongqing
  16.   - shanghai
  17.   - chengdu
  18.   - shenzheng
  19.   #或者
  20.   city2: [chongqing,shanghai,chengdu,shenzheng]

如果同一个目录下，有application.yml也有application.properties，默认先读取application.properties。
如果同一个配置属性，在多个配置文件都配置了，默认使用第1个读取到的，后面读取的不覆盖前面读取到的。

3、配置文件存放位置

a、当前项目根目录中

SpringBoot之基础搭建 - 图13

b、当前项目根目录下的一个/config子目录中

SpringBoot之基础搭建 - 图14

c、项目的resources即classpath根路径中（推荐）

SpringBoot之基础搭建 - 图15

d、项目的resources即classpath根路径下的/config目录中

SpringBoot之基础搭建 - 图16

配置文件存放读取优先级

a、当前项目根目录下的一个/config子目录中(最高)
config/application.properties
config/application.yml
b、当前项目根目录中(其次)
application.properties
application.yml
c、项目的resources即classpath根路径下的/config目录中(一般)
resources/config/application.properties
resources/config/application.yml
d、项目的resources即classpath根路径中(最后)
resources/application.properties
resources/application.yml

bootstrap配置文件(后期详细学习)

  • Spring Boot 中有两种上下文对象，一种是 bootstrap, 另外一种是 application(ServletContext), bootstrap 是应用程序的父上下文，也就是说 bootstrap 加载优先于 applicaton。bootstrap 主要用于从额外的资源来加载配置信息，还可以在本地外部配置文件中解密属性。这两个上下文共用一个环境，它是任何Spring应用程序的外部属性的来源。bootstrap 里面的属性会优先加载，它们默认也不能被本地相同配置覆盖。
  • bootstrap配置文件特征
    • ①boostrap 由父 ApplicationContext 加载，比 applicaton 优先加载。
    • ②boostrap 里面的属性不能被覆盖。
  • bootstrap与 application 的应用场景
    • application 配置文件主要用于 Spring Boot 项目的自动化配置。
    • bootstrap 配置文件有以下几个应用场景。
      • ①使用 SpringCloudConfig 配置中心时，这时需要在 bootstrap 配置文件中添加连接到配置中心的配置属性来加载外部配置中心的配置信息。
      • ②一些固定的不能被覆盖的属性。
      • ③一些加密/解密的场景。

        SpringBoot项目结构

        SpringBoot之基础搭建 - 图17
        1. -- 项目名
        2. |    |--src
        3. |    |    |--main
        4. |    |    |    |--java
        5. |    |    |    |    |--java代码
        6. |    |    |    |--resources
        7. |    |    |    |    |--public 公共资源。所有共享的内容。对外公开的内容。
        8. |    |    |    |    |--static静态资源。图片、js、css。不会被服务器解析。
        9. |    |    |    |    |    |--js
        10. |    |    |    |    |    |-- jquery.js 访问：http://ip:port/js/jquery.js
        11. |    |    |    |    |    |注意:该目录是SpringBoot可以直接识别的目录，会将其中的
        12. |    |    |    |    |    |静态资源编译到web项目中，并放到tomcat中使用。静态资源的
        13. |    |    |    |    |    |访问路径中无需声明static 例如:localhost:8080/a.png
        14. |    |    |    |    |--templates 
        15. |    |    |    |    |    |FreeMarker  thymeleaf 页面所在目录。
        16. |    |    |    |--webapp 只有当页面使用jsp时才有。
        17. |    |    |    |    |--WEB-INF
        设置WEB-INF
        SpringBoot之基础搭建 - 图18