SpringBoot【入门】，学过SpringBoot才能够知道Spring开发原来能够这么的简答，以前学的是个啥

SpringBoot

学习目标

掌握基于SpringBoot框架的程序开发步骤
熟练使用SpringBoot配置信息修改服务器配置
基于SpringBoot的完成SSM整合项目开发

SpringBoot简介

• SpringBoot是由Pivotal团队提供的全新框架，其设计目的是用来简化Spring应用的初始搭建以及开发过程
• 原始的SpringMVC程序过程

1. 创建一个工程并且配置他的工程依赖

<dependencies>
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.2.10.RELEASE</version>
  </dependency>
      <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>3.1.0</version>
      <scope>provided</scope>
    </dependency>
</dependencies>    

2. 编写 web3.0 的配置类
   作为 web 程序， web3.0 的配置类不能缺少，而这个配置类还是比较麻烦的，代码如下

public class ServletConfig extends AbstractAnnotationConfigDispatcherServletInitializer {
    protected Class<?>[] getRootConfigClasses() {
        return new Class[]{SpringConfig.class};
    }

    protected Class<?>[] getServletConfigClasses() {
        return new Class[]{SpringMvcConfig.class};
    }

    protected String[] getServletMappings() {
        return new String[]{"/"};
    }
}

3. 编写SpringMVCpeizhol

@Configuration
@ComponentScan({"com.itheima.controller","com.itheima.config"})
@EnableWebMvc
public class SpringMvcConfig {
}

4. 编写 Controller 类

@RestController
@RequestMapping("/books")
public class BookController {
    @Autowired
    private BookService bookService;
    @PostMapping
    public Result save(@RequestBody Book book) {
        boolean flag = bookService.save(book);
        return new Result(flag ? Code.SAVE_OK:Code.SAVE_ERR,flag);
    }
}

SpringBoot入门程序

1. 创建新模块，选择spring初始化，并配置相关模块的基本信息。

2. 选择当前模块所需要使用的技术集

然后在Web中勾选spring web选项，因为我们做的是web程序。

3. 开发控制器类

@RestController
@RequestMapping("/books")
public class BookController {
    @GetMapping("/{id}")
    public String getById(@PathVariable Integer id){
        System.out.println("id === >"+id);
        return "hello springBoot!";
    }
}

4. 运行自动生成的Application类

入门案例

• 最简单SpringBoot程序所包含的文件

  • pom.xml文件

     <parent>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter-parent</artifactId>
          <version>2.7.4</version>
          <relativePath/> <!-- lookup parent from repository -->
      </parent>
      <groupId>com.zpd</groupId>
      <artifactId>SpringBoot</artifactId>
      <version>0.0.1-SNAPSHOT</version>
          <dependencies>
          <dependency>
              <groupId>org.springframework.boot</groupId>
              <artifactId>spring-boot-starter-web</artifactId>
          </dependency>
          </dependencies>
  

  • Application类

@SpringBootApplication
public class Application {

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

• Spring与SringBoot程序对比

基于idea开发的SpringBoot程序开发的时候需要联网进行开发才可以加载到框架结构。

也可以在Spring官网上直接创建SpringBoot工程，和idea中的过程一样，在idea中创建就是利用官网中创建，所以需要联网。

SpringBoot项目快速启动

• 前后端分离合作开发

1. 对SpringBoot项目打包（执行Maven指令构建的package）

2. 执行启动指令

java -jar springBoot.jar

注意事项

jar支持命令行需要依赖maven插件支持，请确认打包时是否具有SpringBoot对应的maven插件

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

SpringBoot概述

• SpringBoot是由Pivotal团队提供的全新框架，其设计目的是用来简化Spring应用的初始搭建以及开发过程。
• Spring程序缺点
  • 配置繁琐
  • 依赖设置繁琐
• SpringBooot程序优点
  • 自动配置
  • 起步依赖（简化依赖配置)
  • 辅助功能（内置服务器，…）

起步依赖

<?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>2.5.0</version>
    </parent>
    <groupId>com.zpd</groupId>
    <artifactId>SpringBoot</artifactId>
    <version>0.0.1-SNAPSHOT</version>
   <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            //里面有有好多种依赖
        </dependency>
   </dependencies>

由<artifactId>spring-boot-starter-parent</artifactId>可以得到它继承于
  <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-dependencies</artifactId>
    <version>2.7.4</version>
  </parent>

在<artifactId>spring-boot-dependencies</artifactId>中配置了两组信息
若干个propertie信息和各种各样的依赖管理

• starter

  • SpringBoot中常见名称，定义了当前项目使用的所有项目坐标，以达到减少依赖配置的目的

• parent

  • 所有SpringBoot项目要继承的项目，定义了若干个坐标版本号（依赖管理，而非依赖)，以达到减少依赖冲突的目的
  • spring-boot-starter-parent (2.5.0)与spring-boot-starter-parent (2.4.6)共计57处坐标版本不同

• 实际开发

  • 使用任意坐标时，仅书写GAV中的G和A，V由SpringBoot提供
  • 如发生坐标错误，再指定version(要小心版本冲突)

• 辅助功能

<?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>2.5.0</version>
    </parent>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            //里面有有好多种依赖
        </dependency>
   </dependencies>
</project>

SpringBoot启动方式

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

• SpringBoot在创建项目时，采用jar的打包方式

• SpringBoot的引导类是项目的入口，运行main方法就可以启动项目

• 使用maven依赖管理起来更麻烦

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
			<!--web起步依赖环境中，排除Tomcat起步依赖-->
            <exclusions>
                <exclusion>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-starter-tomcat</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <!--添加Jetty起步依赖，版本由SpringBoot的start控制-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jetty</artifactId>
        </dependency>
    </dependencies>

• Jetty比Tomcat更轻量级，可扩展性更强（相较于Tomcat)，谷歌应用引擎（GAE）已经全面切换为Jetty

基础配置

配置文件格式

• 修改服务器端口号

http://localhost:8080/books/1

改为

http://localhost/books/1

• SpringBoot提供了三种格式

  • application.properties

  server.port=80
  

  • application.yml

  server:
  	port: 81
  

  • application.yaml

  server:
  	port: 82
  

注意： SpringBoot 程序的配置文件名必须是 application ，只是后缀名不同而已。

自动提示消失的解决方案：

可以在Project Structure中的Facets中添加配置文件到Sring中，然后直接输入port就可以提示。

可以进行测试发现三个配置文件的优先级

application.properties > application.yml > application.yaml

SpringBoot核心配置文件名为application
SpringBoot内置属性过多，且所有属性集中在一起修改，在使用时，通过提示键+关键字修改属性

yaml

• YAML：（YAML Ain’t Markup Language），一种数字序列化格式
• 优点
  • 容易阅读
  • 容易与脚本语言交互
  • 以数据为核心，重数据轻格式
• YAML文件扩展名
  • **.**yml(主流)
  • **.**yaml

yaml语法格式：

• 大小写敏感

• 属性层级关系使用多行描述，每行结尾使用冒号结束

• 使用缩进表示层级关系，同层级左侧对齐，只允许使用空格（不允许使用Tab键)

• 属性值前面添加空格（属性名与属性值之间使用冒号+空格作为分隔)

• # 表示注释

• 核心规则：数据前面要加空格与冒号隔开

• 数组数据在数据书写位置的下方使用减号作为数据开始符号，每行书写一个数据减号与数据间空格分隔

enterprice:
  name: zpd
  age: 21
  tel: 180
  subject:
    - java
    - 前端
    - 云计算

yaml数据读取方式（3种）

• 使用@Value读取单个数据，属性名引用方式:${一级属性名.二级属性名…}

server:
  port: 80

lesson: SpringBoot
enterprise:
  name: zpd
  age: 21
  tel: 180
  subject:
    - java
    - 前端
    - 云计算

@RestController
@RequestMapping("/books")
public class BookController {
    @Value("${lesson}")
    private String lesson;
    @Value("${server.port}")
    private Integer port;
    @Value("${enterprise.subject[1]}")
    private String sub_01;
    @GetMapping("/{id}")
    public String getById(@PathVariable Integer id){
       System.out.println(lesson);
       System.out.println(port);
       System.out.println(sub_01);
       return "hello SpringBoot"
    }
}

• 封装全部数据到Environment对象

@RestController
@RequestMapping("/books")
public class BookController {
    @Autowired
    private Environment environment;
    @GetMapping("/{id}")
    public String getById(@PathVariable Integer id){
      System.out.println(environment.getProperty("lesson"));
      System.out.println(environment.getProperty("server.port"));
      System.out.println(environment.getProperty("enterprise.subject[1]"));
      return "hello SpringBoot"
    }
}

• 自定义对象封装指定数据

@Component
@ConfigurationProperties(prefix = "enterprise")
public class Enterprise {
    private String name;
    private Integer age;
    private String tel;
    private String[] subject;

    @Override
    public String toString() {
        return "Enterprise{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", tel='" + tel + '\'' +
                ", subject=" + Arrays.toString(subject) +
                '}';
    }

    public Enterprise() {
    }

    public Enterprise(String name, Integer age, String tel, String[] subject) {
        this.name = name;
        this.age = age;
        this.tel = tel;
        this.subject = subject;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public String getTel() {
        return tel;
    }

    public void setTel(String tel) {
        this.tel = tel;
    }

    public String[] getSubject() {
        return subject;
    }

    public void setSubject(String[] subject) {
        this.subject = subject;
    }
}

@RestController
@RequestMapping("/books")
public class BookController {
    @Autowired
    private Enterprise enterprise;
    @GetMapping("/{id}")
    public String getById(@PathVariable Integer id){
      System.out.println(enterprise);
      System.out.println(enterprise.getAge());
      System.out.println(enterprise.getSubject()[1]);
      return "hello SpringBoot"
    }
}

自定义封装对象数据警告解决方案

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>

多环境启动

spring:
  profiles:
    active: test
---
#开发环境
spring:
  config:
    activate:
      on-profile: dev
server:
  port: 80

---
#生产环境
spring:
  profiles: pro
server:
  port: 81
---
#测试环境
spring:
  profiles: test
server:
  port: 82

prioperties文件多环境启动

• 主启动配置文件application. properties

  spring.profiles.active=pro
  //在application. properties定义用哪个开发环境

• 环境分类配置文件application==-pro==.properties

server.port=80

• 环境分类配置文件application==-dev==.properties

server.port=81

• 环境分类配置文件application==-test==.properties

server.port=82

• 带参数启动SpringBoot

java -jar SpringBoot-0.0.1-SNAPSHOT.jar --spring.profiles.active=test

java -jar SpringBoot-0.0.1-SNAPSHOT.jar --spring.profiles.active=test --server.port=88

java -jar SpringBoot-0.0.1-SNAPSHOT.jar --server.port=88

参数加载优先顺序

参看

https://docs.spring.io/spring-boot/docs/current/reference/html/spring-boot-features.html#bootfeatures-external-config

1.Default properties (specified by setting SpringApplication.setDefaultProperties).

2.@PropertySource annotations on your @Configuration classes. Please note that such property sources are not added to the Environment until the application context is being refreshed. This is too late to configure certain properties such as logging.* and spring.main.* which are read before refresh begins.

3.Config data (such as application.properties files).

4.A RandomValuePropertySource that has properties only in random.*.

5.OS environment variables.

6.Java System properties (System.getProperties()).

7.JNDI attributes from java:comp/env.

8.ServletContext init parameters.

9.ServletConfig init parameters.

10.Properties from SPRING_APPLICATION_JSON (inline JSON embedded in an environment variable or system property).

11.Command line arguments.

12.properties attribute on your tests. Available on @SpringBootTest and the test annotations for testing a particular slice of your application.

13.@TestPropertySource annotations on your tests.

14.Devtools global settings properties in the $HOME/.config/spring-boot directory when devtools is active.

Maven与SpringBoot多环境兼容问题

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-resources-plugin</artifactId>
                <version>3.2.0</version>
                <configuration>
                    <encoding>utf-8</encoding>
                    <useDefaultDelimiters>true</useDefaultDelimiters>
                </configuration>
            </plugin>
        </plugins>
    </build>
<profiles>
    <!--开发环境-->
    <profile>
        <id>dev</id>
        <properties>
            <profile.active>dev</profile.active>
        </properties>
    </profile>
    <!--生产环境-->
    <profile>
        <id>pro</id>
        <properties>
            <profile.active>pro</profile.active>
        </properties>
    </profile>
    <!--测试环境-->
    <profile>
        <id>test</id>
        <properties>
            <profile.active>test</profile.active>
        </properties>
        <activation>
            <activeByDefault>true</activeByDefault>
        </activation>
    </profile>
</profiles>

2. 在SpringBoot中引用了Maven属性

spring:
  profiles:
    active: ${profile.active}
---
server:
  port: 80
#开发环境
spring:
  profiles: dev
---
server:
  port: 81
#生产环境
spring:
  profiles: pro
---

server:
  port: 82
#测试环境
spring:
  profiles: test
---

打包的时候application.yaml中${profile.active}会被修改为pom.xml文件中<profile.active>中的值

		<properties>
            <profile.active>test</profile.active>
        </properties>
        <activation>
            <activeByDefault>true</activeByDefault>
        </activation>

Maven指令执行完毕后，生成了对应的包，其中类参与编译，但是配置文件并没有编译，而是复制到包中

如果出现了打包后${profile.active}中的占位符没有被解析，说明pom中的少了解析文件的插件。

解决思路：对于源码中非java类的操作要求加载Maven对应的属性，解析${}占位符

4. 对资源文件开启默认对占位符的解析

        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-resources-plugin</artifactId>
                <version>3.2.0</version>
                <configuration>
                    <encoding>utf-8</encoding>
                    <useDefaultDelimiters>true</useDefaultDelimiters>
                </configuration>
            </plugin>

配置文件分类

• SpringBoot中4级配置文件
  • 1级： file : config/ application.yml【最高】
  • 2级: file : application.yml
  • 3级: classpath: config/ application.yml
  • 4级: classpath: application.yml【最低】
• 作用：
  • 1级与2级留做系统打包后设置通用属性
  • 3级与4级用于系统开发阶段设置通用属性

整合Junit

• Spring整合Junit

@RunWith(SpringJUnit4ClassRunner.class)//设置运行器
@ContextConfiguration(classes = SpringConfig.class)//加载环境
public class UserServiceTest {
//注入测试对象
@Autowired
private BookService bookService;
//测试功能
@Test
public void testSave(){
bookService.save();
	}
}

• SpringBoot整合Junit

@SpringBootTest
class SpringBootJunitApplicationTests {
    @Autowired
    private BookService bookService;
    @Test
    public void save() {
       bookService.save();
    }
}

知识点@SpringleBootTest

名称	@SpringleBootTest
类型	测试类注解
位置	测试类定义上方
作用	设置Junit加载的SpringBoot启动类
相关属性	classes：设置SpringBoot启动类

如果测试类在SpringBoot启动类的包或子包中，可以省略启动类的设置，也就是省略classes的设定

SpringBoot整合Mybatis

• SpringBoot整合Mybatis（复习）

  • SpringConfig

* 导入JdbcConfig

• 导入MybatisConfig

• JDBCConfig

  • 定义数据源（加载properties配置项：driver，url，username，password）

• MybatisConfig

  • 定义SqlSessionFactoryBean

* 定义映射配置

1. 创建新的模块，选择Spring初始化，并配置模块的基本信息

2. 选择当前模块需要用到的技术集（MyBatis，MySQL）

3. 设置数据源参数

spring:
  datasource:
#数据源对象
    driver-class-name: com.mysql.cj.jdbc.Driver
#数据源参数
    url: jdbc:mysql://localhost:3306/ssm_db
    username: root
    password: root
    type: com.alibaba.druid.pool.DruidDataSource

SpringBoot版本低于2.4.3(不含)，Mysql驱动版本大于8.0时，需要在url连接串中配置时区

jdbc:mysql://localhost:3306/ssm_db?serverTimezone=UTC

或在MySQL数据库端配置时区解决此问题

4. 定义数据层接口与映射配置

@Mapper
public interface BookDao {
    @Select("select * from tbl_book where id=#{id}")
    public Book getById(Integer id);
}

5. 测试类自动注入dao接口，测试功能

@SpringBootTest
class SpringBootMybatisApplicationTests {
    @Autowired
    private BookDao bookDao;
    @Test
    void contextLoads() {
        Book book = bookDao.getById(1);
        System.out.println(book);
    }
}

基于SpringBoot的SSM的整合案例

1. pom.xml

配置起步依赖，必要的坐标资源（druid）

2. application.yml

设置数据源，端口等

3. 配置类

全部删除

4. dao

设置@Mapper

5. 测试类

6. 页面

放置在resours目录下的ststic目录中

`

SpringBoot版本低于2.4.3(不含)，Mysql驱动版本大于8.0时，需要在url连接串中配置时区

jdbc:mysql://localhost:3306/ssm_db?serverTimezone=UTC

或在MySQL数据库端配置时区解决此问题

4. 定义数据层接口与映射配置

@Mapper
public interface BookDao {
    @Select("select * from tbl_book where id=#{id}")
    public Book getById(Integer id);
}

5. 测试类自动注入dao接口，测试功能

@SpringBootTest
class SpringBootMybatisApplicationTests {
    @Autowired
    private BookDao bookDao;
    @Test
    void contextLoads() {
        Book book = bookDao.getById(1);
        System.out.println(book);
    }
}

基于SpringBoot的SSM的整合案例

1. pom.xml

配置起步依赖，必要的坐标资源（druid）

2. application.yml

设置数据源，端口等

3. 配置类

全部删除

4. dao

设置@Mapper

5. 测试类

6. 页面

放置在resours目录下的ststic目录中