Spring Boot 2.5.0
资料来源：https://www.bilibili.com/video/BV1Cv411p7cQ?p=2&spm_id_from=pageDriver

第一章 回顾SSM

一、SSM环境搭建

• spring
• springmvc
• mybatis
• spring springmvc mybatis 简单功能 员工添加 查询 所有

# 项目
- 需求分析 概要设计(库表设计) 详细设计(验证库表正确性) 编码(环境搭建+业务代码) 测试 部署上线

# 员工添加 查询所有功能 SSM
- 库表 库: ssm 数据库:mysql 表: id name birthday salary

# 编码 环境搭建 ssm spring springmvc 一个团队开发 无缝整合
- springmvc spring mybatis

二、引入依赖

<dependencies>
        <!--junit-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
            <scope>test</scope>
        </dependency>
        <!--spring-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>5.3.6</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>5.3.6</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>5.3.6</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.6</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
            <version>5.3.6</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.3.6</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>5.3.6</version>
        </dependency>
        <!--spring web mvc-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.3.6</version>
        </dependency>
        <!--druid-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.2.4</version>
        </dependency>
        <!--mysql-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.38</version>
        </dependency>
        <!--mybatis-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.6</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>2.0.6</version>
        </dependency>
        <!--  jackson-->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.9.3</version>
        </dependency>
        <!-- aspectj -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.5</version>
        </dependency>
        <!--aspectj-->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjrt</artifactId>
            <version>1.9.5</version>
        </dependency>
</dependencies>

三、创建spring配置

<!--开启注解扫描-->
<context:component-scan base-package="com.baizhi.service">
  <context:exclude-filter type="aspectj" expression="com.baizhi.controller..*"/>
</context:component-scan>
<!--创建DataSource-->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
  <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
  <property name="url" value="jdbc:mysql://localhost:3306/ssm?characterEncoding=UTF-8"/>
  <property name="username" value="root"/>
  <property name="password" value="root"/>
</bean>
<!--创建SQLSessionFactoryBean -->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
  <property name="dataSource" ref="dataSource"/>
  <property name="mapperLocations" value="classpath:com/baizhi/mapper/*.xml"/>
  <property name="typeAliasesPackage" value="com.baizhi.entity"/>
</bean>
<!--创建dao -->
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
  <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
  <property name="basePackage" value="com.baizhi.dao"/>
</bean>
<!--创建事务管理器-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
  <property name="dataSource" ref="dataSource"/>
</bean>
<!-- 开启注解事务生效-->
<tx:annotation-driven transaction-manager="transactionManager"/>

四、创建springmvc配置

<!--注解扫描-->
<context:component-scan base-package="com.baizhi.controller"/>
<!-- 开启注册驱动-->
<mvc:annotation-driven/>
<!-- 配置视图解析器-->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
  <property name="prefix" value="/"/>
  <property name="suffix" value=".jsp"/>
</bean>

五、配置web.xml

<!--配置工厂配置-->
<context-param>
  <param-name>contextConfigLocation</param-name>
  <param-value>classpath:spring.xml</param-value>
</context-param>
<listener>
  <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<!--配置springmvc-->
<servlet>
  <servlet-name>springmvc</servlet-name>
  <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
  <init-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:springmvc.xml</param-value>
  </init-param>
</servlet>
<servlet-mapping>
  <servlet-name>springmvc</servlet-name>
  <url-pattern>/</url-pattern>
</servlet-mapping>

六、现有SSM开发存在问题

• 大量maven冗余配置
• 每次构建项目都要书写大量相同配置极大浪费了项目开发时间
• 每次整合第三方技术都需要编写相关配置文件
• 项目测试每次都需要部署到tomcat

注意：这就是早期的SSM或者SSH开发存在问题，是不是很麻烦☹️☹️☹️

第二章 SpringBoot引言

Spring Boot是由Pivotal团队提供的全新框架，其设计目的是用来简化Spring应用的 初始搭建以及开发过程。该框架使用了特定的方式来进行配置，从而使开发人员不 再需要定义样板化的配置。通过这种方式，SpringBoot致力于在蓬勃发展的快速应 用开发领域(rapid application development)成为领导者。
SpringBoot全新框架的作用：简化spring应用初始搭建和开发过程
如何简化：开发人员使用springboot只要基于特定方式进行配置 ，简化spring使用
SpringBoot 微框架：5分钟 完成之前ssm中环境
springboot(微框架) = springmvc(控制器) + spring core(项目管理)

一、SpringBoot的优势

1. 创建完整的独立的Spring应用程序 spring springmvc 只有一个容器
2. 嵌入的Tomcat，无需部署WAR文件 springboot 内嵌tomcat 应用跑在内嵌服务器
3. 简化Maven配置，自动配置Spring Springmvc，没有XML配置 几个依赖
4. 使用springboot，spring应用再无xml

   二、SpringBoot的约定

• springboot项目中必须在src/main/resources中放入application.yml(.properties)核心配置文件 名字必须为：application
• springboot项目中必须在src/main/java中所有子包之外构建全局入口类型，xxApplication，入口类一个springboot项目只能有一个

三、环境搭建

1、环境要求

# 1.System Requirements
        JDK1.8+
        MAVEN3.2+  
        Spring Framework 5.x+ 
# 2.ServletContainers: 
        Tomcat 9.0+
# 3.开发工具
        IDEA    2021版本

2、新建项目中引入依赖

<!--继承springboot的父项目  便于维护版本  2.3.x.RELEASE 2.4.x 数字命令-->
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.5.0</version>
</parent>
<dependencies>
    <!--引入springboot的web支持-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>

3、引入配置文件

项目中新建src/main/resources/application.yml

4、编写入口类

//在项目中如下的包结构中创建入口类 Application
/*
    com
        +| baizhi
*/
// 修饰范围: 用在类上 只能用在入口类上 只能出现一次
// 作用: 标识这个类是一个springboot入口类  启动整个springboot项目总入口
// 总结: 1、pom文件引入依赖  2、resources生成application.yml 3、创建入口类加入@SpringBootApplication注解，在main中启动应用
@SpringBootApplication
public class SpringBootDay1Application {
    public static void main(String[] args) {
        //启动springboot应用 参数1: 指定入口类的类对象 .class  参数2: main函数参数
        SpringApplication.run(SpringBootDay1Application.class,args);
    }
}

5、运行main启动项目

o.s.j.e.a.AnnotationMBeanExporter        : Registering beans for JMX exposure on startup
s.b.c.e.t.TomcatEmbeddedServletContainer : Tomcat started on port(s): 8080 (http)
com.baizhi.Application : Started Application in 2.152 seconds (JVM running for 2.611)
//说明:  出现以上日志说明启动成功

注意：到这里项目环境已经搭建成功了,看看仅仅需要5分钟😄😁😁

6、建包并创建控制器

// 在项目中创建指定的包结构
package com.baizhi.controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class HelloController {
    //测试控制器  测试地址: http://localhost:端口号/项目名/请求路径
    //注意: springboot项目默认启动没有项目名 http://localhost:8080/hello
    @RequestMapping("hello")
    public String hello(){
        System.out.println("hello springboot.....");
        return "hello springboot";
    }
}

7、访问项目

注意：springboot的项目启动默认项目名
- 访问路径: http://localhost:8080/hello/hello

8、修改内嵌服务器端口

# application.yml
server:
  port: 8989

9、修改应用名称

# application.yml
server:
  servlet:
    context-path: /springboot_day1    #修改项目名 注意：项目名必须 "/" 开头

第三章 SpringBoot的使用

一、相关注解说明

# 入口类 SpringApplication
- SpringBootApplication: 全局入口类 有且只能有一个
- mian：函数参数可以在启动时指定jvm参数覆盖默认配置
# @SpringBootApplication 注解（组合注解）等价于: 
- @SpringBootConfiguration      标识这是一个springboot的配置类，这个注解就是用来自动配置spring springmvc(初始化 servlet ..)相关环境
- @EnableAutoConfiguration         开启自动配置，自动配置核心注解，自动配置spring相关环境自动与项目中引入第三方技术自动配置其环境、
                                                          如mybatis-springboot、redis-springboot 、es-springboot 、rabbitmq第三技术 
- @ComponentScan                 组件扫描，根据注解发挥注解作用，默认扫描当前包及其子包

二、配置文件

1、配置文件的拆分

说明：在实际开发过程中生产环境和测试环境有可能是不一样的 因此将生产中的配置和测试中的配置拆分开,是非常必要的在springboot中也提供了配置文件拆分的方式. 这里以生产中项名名称不一致为例:

• 生产中项目名为：springboot
• 测试中项目名为：springboot_day1
• 端口同时为：8080 ```java

  主配置文件:

• application.yml #用来书写相同的的配置

            server:
                port: 8080 #生产和测试端口一致

生产配置文件:

• application-pord.yml #prod为配置文件简名

            server:
                context-path: /cmfz

测试配置文件:

• application-dev.yml #dev为配置文件简名

         server:
             context-path: /springboot

在主配置中指定那个环境生效配置

spring: profiles: active: dev #指定那个环境配置生效 dev为环境配置文件的简名

![image-20210609152026228.png](https://cdn.nlark.com/yuque/0/2021/png/22523384/1637762968621-0afff4a1-8d46-4406-a8b0-25efb315b787.png#clientId=u56649af6-a716-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=300&id=u619695c7&margin=%5Bobject%20Object%5D&name=image-20210609152026228.png&originHeight=300&originWidth=1432&originalType=binary&ratio=1&rotation=0&showTitle=false&size=60887&status=done&style=none&taskId=uba62437b-4d20-4bba-8f01-a06984b7900&title=&width=1432)<br />![image-20210819220928438.png](https://cdn.nlark.com/yuque/0/2021/png/22523384/1637763013018-7bfd45d4-13c9-49df-bc81-33fd5a4d038d.png#clientId=u56649af6-a716-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=581&id=uc8867610&margin=%5Bobject%20Object%5D&name=image-20210819220928438.png&originHeight=581&originWidth=1644&originalType=binary&ratio=1&rotation=0&showTitle=false&size=488104&status=done&style=none&taskId=ua1ddccc1-2d3b-4831-b8da-a20bde25816&title=&width=1644)
<a name="ciokZ"></a>
##### 2、启动指定配置文件
说明：往往在企业级开发过程中为SpringBoot应用启动时指定一个完整外部配置也是经常用到的,在SpringBoot中也提供这个方式来启动项目如<br />**# 1.创建一个完整的配置文件**<br />![image.png](https://cdn.nlark.com/yuque/0/2021/png/22523384/1637763037177-8592616c-42f1-471c-a576-42432ef2f9a5.png#clientId=u56649af6-a716-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=261&id=u6d9e5160&margin=%5Bobject%20Object%5D&name=image.png&originHeight=261&originWidth=1017&originalType=binary&ratio=1&rotation=0&showTitle=false&size=40908&status=done&style=none&taskId=ud6f85184-d816-431e-9f9d-f82302644b7&title=&width=1017)<br />**# 2.启动时指定配置文件位置**<br />![image-20210609152324204.png](https://cdn.nlark.com/yuque/0/2021/png/22523384/1637763075861-5a4c4c83-64d0-42da-b123-4e35c04a864a.png#clientId=u56649af6-a716-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=719&id=u7803a8bf&margin=%5Bobject%20Object%5D&name=image-20210609152324204.png&originHeight=719&originWidth=1804&originalType=binary&ratio=1&rotation=0&showTitle=false&size=145649&status=done&style=none&taskId=u7a417ef2-6a1e-4dda-be6d-dfc12caebfa&title=&width=1804)
<a name="dEyrg"></a>
### 三、工厂创建对象
![image-20210819225809672.png](https://cdn.nlark.com/yuque/0/2021/png/22523384/1637763099749-3a319592-0140-4fbd-876f-f753de1dc6f2.png#clientId=u56649af6-a716-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=773&id=ufa863b68&margin=%5Bobject%20Object%5D&name=image-20210819225809672.png&originHeight=773&originWidth=632&originalType=binary&ratio=1&rotation=0&showTitle=false&size=216898&status=done&style=none&taskId=u2e011662-69bf-4615-a652-fee3fa9b4c1&title=&width=632)
<a name="BCigF"></a>
#### 1、创建单个对象
    在springboot中可以管理单个对象，可以直接使用spring框架中注解形式创建。
- **@Component** 通用的对象创建注解
   - @Controller 用来创建控制器对象
   - @Service 用来创建业务层对象
   - @Repository 用来创建DAO层对象
      - 以上注解都有value属性，value属性用来指定工厂中对象名称
```java
@Service
public class DemoServiceImpl implements UserService{
  //doing....
}

2、通过工厂创建之后可以在使用处注入该对象

@Controller
@RequestMapping("hello")
public class HelloController {
    @Autowired
    private DemoService demoService;
    //doing...
}

2、创建多个对象

如何在springboot中像spring框架一样通过xml创建多个对象,在SpringBoot中也提供了相同注解如**@Configuration + @Bean**注解进行创建

• @Configuration 代表这是一个spring的配置类相当于Spring.xml配置文件
• @Bean 用来在工厂中创建这个@Bean注解标识的对象
  • 默认使用@Bean创建对象在工厂中唯一标识为方法名称
  • 修改在工厂中对象标识可以在使用@Bean(“工厂中名字”)指定一个名字

# 1.管理复杂对象的创建

@Configuration
public class Beans {
    @Bean
    public Calendar calendar(){
        return Calendar.getInstance();
    }
}

# 2.使用复杂对象

@Controller
@RequestMapping("hello")
public class HelloController {
    @Autowired
    private Calendar calendar;
    ......
}

# 注意:
1、@Configuration 用来在工厂中一次性创建多个对象
2、@Component 用来创建单个对象

四、属性注入

1、基本属性注入

# 1. @Value 属性注入 [重点]

@RestController
public class HelloController {
    //基本类型+String类型+日期类型
      @Value("${name}")
    private String name;
    @Value("${age}")
    private Integer age;
    @Value("${sex}")
    private Boolean sex;
    @Value("${price}")
    private Double price;
    @Value("${bir}")
    private Date bir;
        //注入数组
    @Value("${qqs}")
    private String[] qqs;
      //注入list
    @Value("${lists}")
    private List<String> lists;
      //注入maps
    @Value("#{${maps}}")
    private Map<String,String> maps;
}

# 2. 在配置文件中定义注入值

name: 小陈
age: 23
price: 23.23
sex: true
bir: 2012/12/12
qqs: 123,3434,3434
lists: xiaochen,xiaoming,xiaosan
maps: "{'aa':'1234','bb':'2344'}"

• 注意：这里面map集合注入比较特殊

  2、对象方式注入

  注意: 这种方式必须提供SET方法
  # 1. @ConfigurationProperties(prefix=”前缀”)

  @Component
  @ConfigurationProperties(prefix = "user")
  public class User {
    private String id;
    private String name;
    private Integer age;
    private String  bir;
    //set 方法一定要提供
  }

  # 2. 编写配置文件

  user:
  id: 24
  name: xiaohei
  age: 23
  bir: 2012/12/12

  # 3. 引入依赖构建自定义注入元数据

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

第四章 SpringBoot整合

一、JSP模板集成

在SpringBoot框架中默认模板推荐使用Thymeleaf模板，这里我们优先讲与JSP模板集成

引入jsp的集成jar包

<!--c标签库-->
<dependency>
    <groupId>jstl</groupId>
    <artifactId>jstl</artifactId>
    <version>1.2</version>
</dependency>
<!--让内嵌tomcat具有解析jsp功能-->
<dependency>
    <groupId>org.apache.tomcat.embed</groupId>
    <artifactId>tomcat-embed-jasper</artifactId>
</dependency>

引入jsp运行插件

<build>
    <finalName>springboot_day1</finalName>
    <!--引入springboot插件 可以正确打包  显示jsp-->
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

配置视图解析器

#在配置文件中引入视图解析器
spring:
  mvc:
    view:
      prefix: /     # /代表访问项目中webapp中页面
      suffix: .jsp

第一种方式使用插件启动访问JSP页面

第二种方式使用idea中指定工作目录启动 访问JSP

启动项目测试

http://localhost:8989/index.jsp

修改jsp无须重启应用

server:
  servlet:
    jsp:
      init-parameters:
        development: true

二、整合Mybatis框架

1、引入依赖

<dependency>
  <groupId>com.alibaba</groupId>
  <artifactId>druid</artifactId>
  <version>1.2.4</version>
</dependency>
<dependency>
  <groupId>mysql</groupId>
  <artifactId>mysql-connector-java</artifactId>
  <version>5.1.38</version>
</dependency>
<!--整合mybatis-->
<dependency>
  <groupId>org.mybatis.spring.boot</groupId>
  <artifactId>mybatis-spring-boot-starter</artifactId>
  <version>2.1.4</version>
</dependency>
<!--
  说明:由于springboot整合mybatis版本中默认依赖mybatis 
  因此不需要额外引入mybati版本,否则会出现冲突`-->

2、配置数据源

spring:
  mvc:
    view:
      prefix: /
      suffix: .jsp
  datasource:
    type: org.apache.commons.dbcp.BasicDataSource   #指定连接池类型
    driver-class-name: com.mysql.jdbc.Driver        #指定驱动   mysql5.x版本驱动
    #driver-class-name: com.mysql.cj.jdbc.Driver    #指定驱动   mysql8.x版本驱动
    url: jdbc:mysql://localhost:3306/ssm?characterEncoding=UTF-8           #指定url
    username: root                                    #指定用户名
    password: root                                     #指定密码

3、加入mybatis配置

#配置文件中加入如下配置:
mybatis:
  # 指定mapper配置文件位置
  mapper-locations: classpath:com/baizhi/mapper/*.xml  
   # 指定实体类的包名  默认别名 : 类名  类名首字母小写
  type-aliases-package: com.baizhi.entity

//入口类中加入如下配置:
@SpringBootApplication
@MapperScan("com.baizhi.dao")   //修饰范围: 用在类上，作用：用来扫描dao接口所在包，同时将所有dao接口在工厂中创建对象
                                //@Mapper注解: 修饰范围: 只能放在Dao接口上  作用：用来在工厂中创建单个dao对象
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class,args);
    }
}

4、建表

CREATE TABLE `t_clazz` (
  `id` varchar(40) NOT NULL,
  `name` varchar(80) DEFAULT NULL,
  `no` varchar(90) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

5、开发实体类

public class Clazz {
    private String id;
    private String name;
    private String no;
    //get set 方法省略....
}

6、开发DAO接口以及Mapper

public interface ClazzDAO {
    List<Clazz> findAll();
}

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.baizhi.dao.ClazzDAO">
    <select id="findAll" resultType="Clazz">
        select * from t_clazz 
    </select>
</mapper>

7、开发Service以及实现

//接口
public interface ClazzService {
    List<Clazz> findAll();
}
//实现
@Service
@Transactional
public class ClazzServiceImpl implements  ClazzService {
    @Autowired
    private ClazzDAO clazzDAO;
    @Transactional(propagation = Propagation.SUPPORTS)
    @Override
    public List<Clazz> findAll() {
        return clazzDAO.findAll();
    }
}

8、开发Controller

@RestController
public class ClazzController {
    @Autowired
    private ClazzService clazzService;
    //查询所有
    @RequestMapping("findAll")
    public List<Clazz> findAll(){
        return clazzService.findAll();
    }   
}

9、启动项目访问测试

http://localhost:8989/项目名/findAll

三、本地测试

往往在开发过程中业务代码课程非常复杂频繁启动服务器测试，非常麻烦！这个时候使用本地测试就是一个很好的解决方案，springboot也提供了本地测试解决方案!

1、引入测试依赖

<!--spring-boot-stater-test   junit 单元  -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <!--只能在测试时可用，test为包名-->
    <scope>test</scope>
</dependency>

2、编写测试类

• @SpringBootTest

  • 修饰范围：用在类上

  • 作用：用来启动本地Spring环境

    @SpringBootTest
    public class TestEmpService {
    @Autowired
    private EmpService empService;
    @Test
    public void test(){
       empService.findAll().forEach(emp-> System.out.println(emp));
    }
    }

    四、热部署工具

    为了进一步提高开发效率，springboot为我们提供了全局项目热部署，日后在开发过程中修改了部分代码以及相关配置文件后，不需要每次重启使修改生效，在项目中开启了springboot全局热部署之后只需要在修改之后等待几秒即可使修改生效。

    1、项目中引入依赖

    ```java

2.在springboot项目中新建config(配置)包
    @Configuration  //修饰范围: 只能用在类上 作用: 代表这是一个spring的配置类   spring.xml<br />        @Aspect //修饰范围: 只能用在类上   作用：代表这个类是一个切面类             <aop:config><br />        MyAspectConfig(自定义切面类)      配置类{
        //@Before: 代表这个方法是一个前置附加操作<br />            //@After : 代表这个方法是一个后置附加操作<br />                注意: 使用@Before 和 @After注解声明方法上加入一个参数 定义一个参数 JointPoint 连接点<br />            //@Around: 代表这个方法是一个环绕附加操作<br />                value属性: 用来书写切入点表达式<br />                注意: 使用@Around注解 在方法定义时声明一个参数: ProceedingJoinPoint 处理过程中连接点
        @Before("execution(* com.baizhi.service.*.*(..))")<br />            public void before(){<br />                sout("===========")<br />            }<br />        }

2、引入依赖

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

3、相关注解

# 切面注解
- @Aspect 用来类上,代表这个类是一个切面
- @Before 用在方法上代表这个方法是一个前置通知方法 
- @After 用在方法上代表这个方法是一个后置通知方法 
- @Around 用在方法上代表这个方法是一个环绕的方法

4、前置切面

@Aspect            //代表这个类是一个切面配置类
@Configuration    //代表当前这个类是一个spring的配置类
public class MyAspect {
    //@Before：代表这是一个核心业务逻辑执行之前附加操作   value：用来书写切入点表达式，配置附加操作在哪里生效
    @Before("execution(* com.baizhi.service.*.*(..))")  
    public void before(JoinPoint joinPoint){   //JointPoint：连接点
        System.out.println("前置通知");
        joinPoint.getTarget();               //获取目标对象
        joinPoint.getSignature().getName();  //获取目标对象的方法
        joinPoint.getSignature();            //获取方法签名
        joinPoint.getArgs();                 //获取方法参数
    }
}

5、后置切面

@Aspect
@Configuration
public class MyAspect {
    @After("execution(* com.baizhi.service.*.*(..))")
    public void before(JoinPoint joinPoint){
        System.out.println("后置通知");
        joinPoint.getTarget();        //目标对象
        joinPoint.getSignature();    //方法签名
        joinPoint.getArgs();        //方法参数
    }
}

注意：前置通知和后置通知都没有返回值,方法参数都为joinpoint

6、环绕切面

@Aspect
@Configuration
public class MyAspect {
    @Around("execution(* com.baizhi.service.*.*(..))")
    //返回值作用: 用来将业务方法返回结果返回给调用者
    public Object before(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {   //ProceedingJoinPoint 处理过程中连接点
        System.out.println("进入环绕通知");
        proceedingJoinPoint.getTarget();                    //目标对象
        proceedingJoinPoint.getSignature();                 //方法签名
        proceedingJoinPoint.getArgs();                      //方法参数
        Object proceed = proceedingJoinPoint.proceed();     //放行执行目标方法，如果不放行，就只会执行前置、后置通知，不会执行目标方法
        System.out.println("目标方法执行之后回到环绕通知");
        return proceed;                                    //返回目标方法返回值
    }
}

注意：环绕通知存在返回值，参数为ProceedingJoinPoint，如果执行放行，不会执行目标方法，一旦放行必须将目标方法的返回值返回,否则调用者无法接受返回数据

7、切入点表达式

//切入点表达式:
1.execution：方法级别切入点表达式 save update 运行效率越低
2.within：类级别切入点表达式: 控制越粗 运行效率
3.基于注解的切入点表达式：@annotation(com.baizhi.annotations.xxx)
@Around("execution(* com.baizhi.service.*.*(..))")
//@Around("within(com.baizhi.service.*)")
//@Around("@annotation(com.baizhi.annotations.MyAdvice)")     //扫描有MyAdvice注解的类，切入
public Object around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
    System.out.println("==========进入环绕的前置操作===========");
    System.out.println("当前执行类: "+proceedingJoinPoint.getTarget());
    System.out.println("方法名: "+proceedingJoinPoint.getSignature().getName());
    //放行目标方法执行
    Object proceed = proceedingJoinPoint.proceed();//继续处理  业务逻辑方法执行
    System.out.println("==========进入环绕的后置操作===========");
    return proceed;
}

//创建注解，指定运行时生效
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface MyAdvice {
}
@Service
public class UserServiceImpl  implements UserService{
    @Override
    @MyAdvice //指定注解
    public String find(String name) {
        System.out.println("处理find核心业务逻辑,调用DAO~~");
        return name;
    }
}

七、文件上传下载

1、文件上传

用户访问当前系统，将自己本地计算机中文件通过浏览器上传到当前系统所在的服务器过程中称之为文件的上传
文件上传：用户将自己计算机中文件上传到项目所在服务器过程、文件服务器、OSS 称之为文件上传

2、准备上传页面

<form action="${pageContext.request.contextPath}/file/upload" method="post" enctype="multipart/form-data">
        <input type="file" name="file">
        <input type="submit" value="上传">
</form>
<!--
    1. 表单提交方式必须是post
    2. 表单的enctype属性必须为multipart/form-data
    3. 后台接受变量名字要与文件选择name属性一致
-->

3、编写控制器

方式一：不推荐

@Controller
@RequestMapping("file")
public class FileController {
    private static final Logger log = LoggerFactory.getLogger(FileController.class);
    /**
     * 用来测试文件上传 - 这种方式：不能用于jar包部署，不能获取到上传文件的路径，jar包没法访问，war包会解压后再访问
     * 注意:这种方式存在局限性,不推荐在使用这种方式进行文件上传了
     * @return
     */
    @RequestMapping("upload")
    public String upload(MultipartFile file, HttpServletRequest request) throws IOException {
        //定义:接收文件对象 multipartFile file变量名要与form中input type="file"标签name属性名一致
        //文件名
        String originalFilename = file.getOriginalFilename();
        log.debug("文件名: {}", originalFilename);
        log.debug("文件大小: {}", file.getSize());
        log.debug("文件类型: {}", file.getContentType());
        //1.根据相对 上传 "upload" 获取绝对路径(真实路径) /users/桌面....   服务器: /home/springboot_day4..
        String realPath = request.getSession().getServletContext().getRealPath("/upload");
        log.debug("获取绝对路径: {}", realPath);
        //2.上传文件  参数1: 将文件写入到那个目录 aa.txt  .md xxx.xxx.xxx.md
        //修改文件名
        String ext = originalFilename.substring(originalFilename.lastIndexOf("."));
        String newFileName = new SimpleDateFormat("yyyyMMddHHmmssSSS").format(new Date()) + ext;
        file.transferTo(new File(realPath, newFileName));
        return "redirect:/upload.jsp";
    }
}

方式二：推荐

# 配置文件指定文件上传位置
file:
  upload:
    dir: /Users/chenyn/imgs # 指定本地测试上传目录
@Controller
@RequestMapping("file")
public class FileController {
    private static final Logger log = LoggerFactory.getLogger(FileController.class);
    @Value("${file.upload.dir}")
    private String realPath;    //另外指定服务器上的文件存放位置，不需要读取jar/war包路径
    /**
     * 第二种文件上传
     * 注意: 这种方式适用于任何一种部署方式 推荐使用这种方式
     * @param file
     * @return
     * @throws IOException
     */
    @RequestMapping("uploadByJarDeploy")
    public String uploadByJarDeploy(MultipartFile file) throws IOException {
        //文件名
        String originalFilename = file.getOriginalFilename();
        log.debug("文件名: {}", originalFilename);
        log.debug("文件大小: {}", file.getSize());
        log.debug("文件类型: {}", file.getContentType());
        //改名
        String ext = originalFilename.substring(originalFilename.lastIndexOf("."));
        String newFileName = new SimpleDateFormat("yyyyMMddHHmmssSSS").format(new Date()) + ext;
        //上传文件到哪
        file.transferTo(new File(realPath,newFileName));
        return  "redirect:/upload.jsp";
    }
}

4、修改文件上传大小

#上传时出现如下异常:  上传文件的大小超出默认配置      默认10M
nested exception is java.lang.IllegalStateException: org.apache.tomcat.util.http.fileupload.FileUploadBase$SizeLimitExceededException: the request was rejected because its size (38443713) exceeds the configured maximum (10485760)
#修改配置文件上传文件大小:
spring:
  http:
    multipart:
       max-request-size: 209715200                  #用来控制文件上传大小的限制
       max-file-size: 209715200                     #用来指定服务端最大文件大小   
spring.servlet.multipart.max-file-size=500MB        #运行请求传递文件大小默认为10M
spring.servlet.multipart.max-request-size=500MB     #运行服务器可以处理的最大文件大小默认为10M

5、文件下载

**文件下载：将服务器某个资源文件下载到用户本地计算机过程称之为文件下载**<br />![image.png](https://cdn.nlark.com/yuque/0/2021/png/22523384/1637763354503-771b5f05-2ed5-4428-8b7d-3381342476df.png#clientId=u56649af6-a716-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=228&id=u83af60c4&margin=%5Bobject%20Object%5D&name=image.png&originHeight=228&originWidth=796&originalType=binary&ratio=1&rotation=0&showTitle=false&size=71348&status=done&style=none&taskId=u028ac68c-c5e5-41cf-8fa1-f255c385bb1&title=&width=796)

6、提供下载文件链接

<a href="${pageContext.request.contextPath}/file/download?fileName=HELP.md">HELP.md</a>
<a href="${pageContext.request.contextPath}/file/download?fileName=readme.txt">readme.txt</a>
<a href="${pageContext.request.contextPath}/file/download?fileName=项目介绍.md">项目介绍.md</a>

7、开发控制器

# 配置文件
server:
  port: 8989  
  servlet:
    context-path: /day6  
    jsp:
      init-parameters:
        development: true
spring:
  mvc:
    view:
      prefix: /
      suffix: .jsp
file:
  download:
    dir: E:/Java/百知教育/springboot-2021-版本资料/codes/springboot_day6/download  # 指定下载目录测试环境
    #dir: /home/download  生产环境

@Controller
@RequestMapping("file")
public class FileController {
    private static final Logger log = LoggerFactory.getLogger(FileController.class);
    @Value("${file.download.dir}")   //读取配置文件
    private String realPath;
    /**
     * 文件下载
     * @param fileName
     */
    @RequestMapping("download")
    public void download(String fileName, HttpServletResponse response) throws IOException {
        log.debug("当前下载文件名为: {}",fileName);
        log.debug("当前下载文件目录: {}",realPath);
        //1.去指定目录中读取文件
        File file = new File(realPath, fileName);
        //2.将文件读取为文件输入流
        FileInputStream is = new FileInputStream(file);
        //2.5 获取响应流之前 一定要设置以附件形式下载 attachment:附件，否则会再浏览器直接打开文件，而不是下载文件
        response.setHeader("content-disposition","attachment;filename="+ URLEncoder.encode(fileName,"UTF-8"));
        //3.获取响应输出流
        ServletOutputStream os = response.getOutputStream();
        //4.输入流复制给输出流
        /*int len=0;
        byte[] b = new byte[1024];
        while(true){
            len = is.read(b);
            if(len==-1)break;
            os.write(b,0,len);
        }*/
        //5.释放资源
        //is.close();
        FileCopyUtils.copy(is,os);  //会自动释放资源
    }
}

8、下载注意点

# 1、必须注入依赖，否则访问download.jsp，页面会弹窗下载框，下载该jsp文件

<!--tomcat解析jsp-->
<dependency>
    <groupId>org.apache.tomcat.embed</groupId>
    <artifactId>tomcat-embed-jasper</artifactId>
</dependency>

# 2、手动新增的webapp包，包上没有小蓝点，需要按以下方式设置，否则访问download.jsp，报404
https://blog.csdn.net/qq_43080036/article/details/87273538

# 3、启动之前需要设置$MODULE_DIR$，否则访问download.jsp，报404

八、拦截器

1、开发拦截器

/**
 * 自定义拦截器器1
 */
public class MyInterceptor1 implements HandlerInterceptor {
    private static final Logger log = LoggerFactory.getLogger(MyInterceptor1.class);
    //pre handler 最先执行
    //参数3: handler 当前请求请求的控制器方法对象  比如DemoController的demo方法
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        log.debug("handler: {} ", handler);
        log.debug("===========1=========");
        //response.sendRedirect(request.getContextPath()+"/403.jsp");
        return true;//true代表放行，false代表中断
    }
    //参数3: handler 当前请求请求的控制器方法对象  DemoController#demo
    //参数4: modelAndView 模型和视图  当前请求访问方法的modelandview对象
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        log.debug("===========2=========");
        log.debug("view: {}",modelAndView.getViewName());
    }
    //参数3: handler 当前请求请求的控制器方法对象  DemoController#demo
    //参数4: exception 如果控制器出现异常时异常对象
    //这个方法: finally{}代码块  总是执行  无论请求正确,出现异常
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        log.debug("===========3=========");
    }
}
/**
 * 自定义拦截器2
 */
public class MyInterceptor2  implements HandlerInterceptor {
    private static final Logger log = LoggerFactory.getLogger(MyInterceptor2.class);
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        log.debug("===========4=========");
        return true;
    }
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        log.debug("===========5=========");
    }
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        log.debug("===========6=========");
    }
}

2、配置拦截器

@Configuration
public class MvcConfig implements WebMvcConfigurer {
    /**
     * 配置拦截器相关方法
     * @param registry
     */
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new MyInterceptor1())     //指定拦截器1
                .addPathPatterns("/**")                     //拦截所有
                .excludePathPatterns("/file/**")         //排除哪些路径
                .order(1);                                 //指定拦截器执行顺序。int 类型数字: 默认按照自然排序执行，数字相同时,按照配置顺序执行
        registry.addInterceptor(new MyInterceptor2())    //指定拦截器2
                .addPathPatterns("/login","/user")       //拦截指定
                .excludePathPatterns("/file/**")
                .order(2);
        //1 4 5 2 6 3
    }
}

注意：order用来执行多个拦截器的执行顺序，order书写是自然数，按照自然数顺序执行

九、war包部署

1、设置打包方式为war

执行项目打包的方式为 “war” 默认创建springboot项目打包都是jar
修改项目pom.xml:
war

2、在插件中指定入口类

<build>
    <plugins>
      <plugin>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
        <!--使用热部署出现中文乱码解决方案-->
        <configuration>
          <fork>true</fork>
          <!--增加jvm参数-->
          <jvmArguments>-Dfile.encoding=UTF-8</jvmArguments>
          <!--指定入口类-->
          <mainClass>com.baizhi.Application</mainClass>
        </configuration>
      </plugin>
    </plugins>
</build>

3、排除内嵌的tomcat

<!--tomcat解析jsp-->
<dependency>
    <groupId>org.apache.tomcat.embed</groupId>
    <artifactId>tomcat-embed-jasper</artifactId>
    <!--provided当前idea环境可用,打包不参与打包-->
    <scope>provided</scope>
</dependency>
<!--去掉内嵌的tomcat依赖-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-tomcat</artifactId>
    <scope>provided</scope>
</dependency>

4、配置入口类

//1.继承SpringBootServletInitializer: 不在使用内嵌容器启动,使用外部tomcat容器启动
//2.覆盖configure方法
@SpringBootApplication
public class SpringbootDay6Application extends SpringBootServletInitializer {
    public static void main(String[] args) {
        SpringApplication.run(SpringbootDay6Application.class, args);
    }
    //配置入口类是谁
    @Override
    protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
        return builder.sources(SpringbootDay6Application.class);
    }
}

5、打包测试

# 一旦使用war包部署注意:
- 1. application.yml 中配置port、context-path均失效
- 2. 访问时使用打成war包的名字和外部tomcat端口号进行访问项目

十、Jar包部署（推荐）

1、设置打包方式为jar

**<packaging>jar</packaging>**<br />**注意：默认方式也是jar**

2、执行打包

3、测试访问

• 注意：springboot部署jsp时，插件版本必须指定为1.4.2版本，并进行jsp打包配置才可以，其他版本均不支持!!!

  4、修改插件版本

  在项目的pom.xml配置文件中build标签中修改

  <plugins>
  <plugin>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-maven-plugin</artifactId>
    <!--打包jsp模板时，必须使用1.4.2插件-->
    <version>1.4.2.RELEASE</version>
  </plugin>
  </plugins>

  5、指定jsp打包配置

  在项目的pom.xml配置文件中build标签中加入配置

  <build>
    <!--执行jsp文件打包位置-->
    <resources>
        <!-- 打包时将jsp文件拷贝到META-INF目录下-->
        <resource>
            <!-- 指定resources插件处理哪个目录下的资源文件 -->
            <directory>src/main/webapp</directory>
            <!--指定必须要放在此目录下才能被访问到-->
            <targetPath>META-INF/resources</targetPath>
            <includes>
                <include>**/**</include>
            </includes>
        </resource>
        <resource>
            <directory>src/main/resources</directory>
            <includes>
                <include>**/**</include>
            </includes>
            <filtering>false</filtering>
        </resource>
    </resources>
  </build>

  6、启动jar包

  java -jar 对应jar文件名字 nohup &

第五章 Thymeleaf

Thymeleaf是一个用于web和独立环境的现代服务器端Java模板引擎。
—摘自官网https://www.thymeleaf.org/
Thymeleaf是跟Velocity、FreeMarker类似的模板引擎，它可以完全替代JSP，相较与其他的模板引擎相比, Thymeleaf在有网络和无网络的环境下皆可运行，即它可以让美工在浏览器查看页面的静态效果，也可以让程序员在服务器查看带数据的动态页面效果。

集成Thymeleaf模板

引入依赖

org.springframework.boot spring-boot-starter-thymeleaf

编写配置

spring: thymeleaf: cache: false # 关闭缓存 prefix: classpath:/templates/ #指定模板位置 suffix: .html #指定后缀

编写控制器测试

@Controller //一定要是@Controller 不能再使用@RestController注解 @RequestMapping(“hello”) public class HelloController { @GetMapping(“hello”) public String hello(){ System.out.println(“测试与 thymeleaf 的集成”); return “index”; } }

在templates目录中定义模板

测试访问

http://localhost:8989/springboot_day3/hello/hello

查看结果

模板基本语法

使用时必须在页面中加入thymeleaf如下命名空间:

展示单个数据

设置数据

model.addAttribute(“name”,”张三”); 或 request.setAttribute(“name”,”小黑”);

获取数据

—->获取数据

解析含有html标签数据

model.addAttribute(“name”,”张三“); model.addAttribute(“username”,”小陈”);

• 直接获取原样输出

• 获取并解析

• 将数据赋值给表单元素

总结 - 1.使用 th:text=”${属性名}” 获取对应数据,获取数据时会将对应标签中数据清空,因此最好是空标签 - 2.使用 th:utext=”${属性名}” 获取对应的数据,可以将数据中html先解析在渲染到页面 - 3.使用 th:value=”${属性名}” 获取数据直接作为表单元素value属性

展示对象数据

model.addAttribute(“user”,new User(“21”,”xiaochen”,23,new Date())); id: name: age: bir: ==== 日期格式化

条件展示数据

model.addAttribute(“user”,new User(“21”,”xiaochen”,23,new Date()));

青年


青年

# 运算符
gt：great than（大于）>
ge：great equal（大于等于）>=
eq：equal（等于）==
lt：less than（小于）<
le：less equal（小于等于）<=
ne：not equal（不等于）!=

展示多条数据

• 直接遍历集合

• 遍历时获取遍历状态

  
  
  • -
  获取遍历次数 count 从1开始 index 从0开始
  
  • -
  获取当前遍历是否是奇数行
  
  • -
  获取当前遍历是否是偶数行
  
  • -
  获取当前集合的总条数
  

  引入静态资源

  # 使用thymeleaf模板项目中静态资源默认放在resources路径小static目录中

• 项目中放入对应静态资源

• 页面中引入 注意: @{/}代表通过thymeleaf语法动态获取应用名

  在js代码中获取项目名

  
  注意:[[书写thymeleaf语法]],这里[[]]是thymeleaf内嵌表达式