day01【后台】环境搭建

柔情只为你懂 2022-12-08 14:14 193阅读 0赞

# day01【后台】环境搭建 #

## 1、项目架构 ##

众筹网整体架构如下：主要分为前台会员系统和后台管理员系统。前台会员系统采用 `SpringCloud` 分布式架构搭建，后台管理员系统采用 `SSM` 框架搭建

![image-20200919160437834][]

## 2、搭建工程环境 ##

### 2.1、 安装STS ###

1.  下载地址：https://spring.io/tools，我靠，官网速度也太慢了吧！我在网上博客上找了个版本，将就着用了~
2.  Getting Started：https://spring.io/guides/gs/sts/
3.  虽然是个`jar`包，但不要怕，因为`jar`包本来就是一种压缩包
    
    ![image-20200607204655076][]
4.  解压即可用
    
    ![image-20200607220019708][]

### 2.2、配置工程环境 ###

#### 2.2.1、快捷键配置 ####

1.  将【`Maven Project`】和【`Maven Module`】添加到：**右键–>New**菜单栏中
    
    ![image-20200607220401668][]

#### 2.2.2、编码配置 ####

*  使用`UTF-8`编码
    
    ![image-20200609104132104][]

#### 2.2.3、Maven配置 ####

1.  使用我们电脑上安装的Maven，不使用Eclipse默认内置的Maven
    
    ![image-20200607232031825][]
2.  指定Maven配置文件所在的位置
    
    ![image-20200607231950264][]

### 2.3、工程架构 ###

> **工程框架**

![image-20200710105612136][]

> **工程聚合关系**

![image-20200919160800350][]

### 2.4、 创建Maven父工程 ###

1.  创建【**Maven Project**】
    
    ![image-20200607220526350][]
2.  勾选如下选项
    
    ![image-20200607221128679][]
3.  父工程名称为`atcrowdfunding01-admin-parent`，用于统一管理各个 Maven Module 中依赖的版本
    
     *  填写【Group Id】
     *  填写【Artifact Id】
     *  一定注意：父工程打包方式为`pom`
        
        ![image-20200607221343991][]

### 2.5、 创建子工程（Maven Module） ###

#### 2.5.1、创建webui工程（Maven Module） ####

1.  在父工程下创建**Maven Module**
    
    ![image-20200607221537186][]
2.  注意，web工程打包方式一定要选择为**war**
    
    1.  对应 SSM 应用来说，没有内置的 Tomcat 服务器，打包方式选择为 war
    2.  对应 SpringBoot 应用来说，有内置的 Tomcat 服务器，打包方式选择为 war 或 jar
    3.  webui 工程对应于 UI 层，主要存放页面，配置文件等
    
    ![image-20200607222006050][]
    
    ![image-20200607221755244][]
3.  由于Maven工程默认不带`web.xml`，所以我们需要手动生成
    
    ![image-20200607232931453][]
    
    ![image-20200607233055287][]

#### 2.5.2、创建其他子工程（Maven Module） ####

1.  其他两个子工程的名称分别为：
    
     *  atcrowdfunding03-admin-component ：存放 Handler 、Service 、 Mapper 、 Config 等等
     *  atcrowdfunding04-admin-entity ：存放实体类
2.  这两个工程打包方式均为**jar**
    
    ![image-20200607222150149][]
    
    ![image-20200607232705107][]

### 2.6、建立util和reverse独立工程（Maven Project） ###

1.  新建`Maven Project`，这两个独立工程的名称分别为：
    
     *  `atcrowdfunding05-common-util` ：存放工具类
     *  `atcrowdfunding06-common-reverse` ：Mybatis 逆向工程
2.  这两个工程打包方式均为`jar`包
    
    ![image-20200607233307224][]
    
    ![image-20200607233339963][]

### 2.7、 工程之间的引用关系 ###

1.  Maven父子工程关系如图所示
    
    1.  父工程统一管理如下工程的依赖版本：webui 、component 、entity
    2.  util 和 reverse 单独管理自己的依赖
    
    ![image-20200607233653366][]
2.  父工程`pom`文件
    
        <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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
          <modelVersion>4.0.0</modelVersion>
          <groupId>com.atguigu.crowd</groupId>
          <artifactId>atcrowdfunding01-admin-parent</artifactId>
          <version>0.0.1-SNAPSHOT</version>
          <packaging>pom</packaging>
          <modules>
          	<module>atcrowdfunding02-admin-webui</module>
          	<module>atcrowdfunding03-admin-component</module>
          	<module>atcrowdfunding04-admin-entity</module>
          </modules>
        </project>

![image-20200607233918333][]

### 2.8、 建立工程之间的依赖（dependency）关系 ###

#### 2.8.1、依赖关系 ####

*  `webui` 依赖 `component`
 *  `component` 依赖 `entity`
 *  `component` 依赖 `util`

![image-20200710105632155][]

#### 2.8.2、采用图形化界面添加依赖 ####

1.  以`webui`添加`component`的依赖为例：打开 webui 工程的 pom 文件，手动添加依赖
    
    ![image-20200608001106648][]
2.  搜索`component`，在 webui 工程中添加 component 工程的依赖
    
    ![image-20200608001156258][]
3.  添加完成
    
    ![image-20200608001356426][]
4.  添加完依赖之后，`webui`工程`pom`文件的变化
    
        <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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
          <modelVersion>4.0.0</modelVersion>
          <parent>
            <groupId>com.atguigu.crowd</groupId>
            <artifactId>atcrowdfunding01-admin-parent</artifactId>
            <version>0.0.1-SNAPSHOT</version>
          </parent>
          <artifactId>atcrowdfunding02-admin-webui</artifactId>
          <packaging>war</packaging>
          <dependencies>
          	<dependency>
          		<groupId>com.atguigu.crowd</groupId>
          		<artifactId>atcrowdfunding03-admin-component</artifactId>
          		<version>0.0.1-SNAPSHOT</version>
          	</dependency>
          </dependencies>
        </project>
    
    ![image-20200608001529146][]
5.  参照上面的步骤，添加如下依赖
    
     *  `component` 依赖 `entity`
     *  `component` 依赖 `util`
6.  添加完成
    
    ![image-20200608001750586][]

## 3、 物理建模 ##

1.  创建`project_crowd`数据库：众筹项目专属数据库
    
    ![image-20200608113904389][]
2.  建立**后台管理员表**：`t_admin`，创建表的`sql`语句如下
    
        use project_crowd;
        drop table if exists t_admin;
        create table t_admin
        (
          id int not null auto_increment, 		# 主键
          login_acct varchar(255) not null, 	# 登录账号
          user_pswd char(32) not null, 			# 登录密码
          user_name varchar(255) not null, 		# 昵称
          email varchar(255) not null, 			# 邮件地址
          create_time char(19), 				# 创建时间
          primary key (id)						# 主键
        );
3.  表结构
    
    ![image-20200608114004572][]

## 4、基于 Maven 的 MyBatis 逆向工程 ##

### 4.1、 reverse逆向工程的配置 ###

1.  `pom` 配置，其主要作用就是：使用`maven`构建（`build`）工程时，插件会连接数据库，并根据数据库中指定的表生成`java`实体类和`Mapper`映射文件
    
        <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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        	<modelVersion>4.0.0</modelVersion>
        	<groupId>com.atguigu.crowd</groupId>
        	<artifactId>atcrowdfunding06-common-reverse</artifactId>
        	<version>0.0.1-SNAPSHOT</version>
        	
        	<dependencies>
        		<dependency>
        			<groupId>org.mybatis</groupId>
        			<artifactId>mybatis</artifactId>
        			<version>3.2.8</version>
        		</dependency>
        	</dependencies>
        	
        	<build>
        		
        		<plugins>
        			
        			<plugin>
        				<groupId>org.mybatis.generator</groupId>
        				<artifactId>mybatis-generator-maven-plugin</artifactId>
        				<version>1.3.0</version>
        				
        				<dependencies>
        					
        					<dependency>
        						<groupId>org.mybatis.generator</groupId>
        						<artifactId>mybatis-generator-core</artifactId>
        						<version>1.3.2</version>
        					</dependency>
        					
        					<dependency>
        						<groupId>com.mchange</groupId>
        						<artifactId>c3p0</artifactId>
        						<version>0.9.2</version>
        					</dependency>
        					
        					<dependency>
        						<groupId>mysql</groupId>
        						<artifactId>mysql-connector-java</artifactId>
        						<version>5.1.8</version>
        					</dependency>
        				</dependencies>
        			</plugin>
        		</plugins>
        	</build>
        </project>
2.  `generatorConfig.xml`配置文件：在`resources`文件夹下创建`generatorConfig.xml`配置文件，并添加如下内容
    
     *  配置数据库**驱动类、 连接地址、 用户名、 密码**
    
        
        <jdbcConnection driverClass="com.mysql.jdbc.Driver"
        	connectionURL="jdbc:mysql://localhost:3306/project_crowd"
        	userId="root" password="root">
        </jdbcConnection>
    
     *  配置**实体类存放路径**：
        
         *  工程路径下： **.\\src\\main\\java**
         *  所属包名：**com.atguigu.crowd.entity**
    
        
        <javaModelGenerator targetProject=".\src\main\java"
        	targetPackage="com.atguigu.crowd.entity">
            
            <property name="enableSubPackages" value="false" />
            
            <property name="trimStrings" value="true" />
        </javaModelGenerator>
    
     *  配置 **Mapper 映射文件**存放路径： **.\\src\\main\\java**，由于 Mybatis 需要使用反射创建 Mapper 接口的实例，所以在 Mapper.xml 映射文件中，还需指出当前 Mapper 映射文件所属包名，也即 Mapper 接口所属包名：**com.atguigu.crowd.mapper**

<sqlMapGenerator targetProject=".\src\main\java"
                        targetPackage="com.atguigu.crowd.mapper">
           
           <property name="enableSubPackages" value="false" />
       </sqlMapGenerator>

*  配置 **Mapper 接口**存放路径
    
     *  工程路径下： **.\\src\\main\\java**
     *  所属包名：**com.atguigu.crowd.mapper**

<javaClientGenerator type="XMLMAPPER"
       			targetProject=".\src\main\java"
       			targetPackage="com.atguigu.crowd.mapper">
       			
       			<property name="enableSubPackages" value="false" />
       		</javaClientGenerator>

*  `generatorConfig.xml`配置文件内容

<?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE generatorConfiguration
    PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
    "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">
    <generatorConfiguration>
    	
    	<context id="atguiguTables" targetRuntime="MyBatis3">
    		<commentGenerator>
    			
    			<property name="suppressAllComments" value="true" />
    		</commentGenerator>
    		
    		<jdbcConnection driverClass="com.mysql.jdbc.Driver"
    			connectionURL="jdbc:mysql://localhost:3306/project_crowd"
    			userId="root" password="root">
    		</jdbcConnection>
    		
    		<javaTypeResolver>
    			<property name="forceBigDecimals" value="false" />
    		</javaTypeResolver>
    		
    		<javaModelGenerator targetProject=".\src\main\java"
    			targetPackage="com.atguigu.crowd.entity">
    			
    			<property name="enableSubPackages" value="false" />
    			
    			<property name="trimStrings" value="true" />
    		</javaModelGenerator>
    		
    		<sqlMapGenerator targetProject=".\src\main\java"
    			targetPackage="com.atguigu.crowd.mapper">
    			
    			<property name="enableSubPackages" value="false" />
    		</sqlMapGenerator>
    		
    		<javaClientGenerator type="XMLMAPPER"
    			targetProject=".\src\main\java"
    			targetPackage="com.atguigu.crowd.mapper">
    			
    			<property name="enableSubPackages" value="false" />
    		</javaClientGenerator>
    		
    		<table tableName="t_admin" domainObjectName="Admin" />
    	</context>
    </generatorConfiguration>

### 4.2、执行逆向生成操作的 Maven 命令 ###

1.  右击逆向工程的 pom 文件，运行`Maven`命令
    
    ![image-20200608154038372][]
2.  运行如下命令
    
        mybatis-generator:generate
    
    ![image-20200608154131087][]
3.  成功
    
    ![image-20200608154355333][]

### 4.3、逆向工程生成的资源各归各位 ###

1.  如下代码的存放位置
    
     *  `entity`包放到`entity`工程下（根据实际需要，可在相应的实体类中添加对应的有参、无参构造器和`toString()`方法等等）
     *  `Mapper.java`文件放到`component`工程下
     *  `Mapper.xml`文件放到`webui`工程下的`mybatis-->resources-->mapper`文件夹下
        
        ![image-20200608154703064][]
2.  项目结构如下，在`component`工程中引入`mybatis`依赖，否则工程会报错
    
    ![image-20200608155442788][]

## 5、父工程依赖管理 ##

### 5.1、版本声明 ###

*  `parent`工程`pom`文件中对依赖版本进行统一的管理
    
     *  Spring 版本：4.3.20.RELEASE
     *  SpringBoot 版本：4.2.10.RELEASE

### 5.2、依赖管理 ###

*  `parent`工程`pom`文件中添加如下依赖，在父工程中声明了依赖的版本（GAV 中的 V），在子工程中就不需要声明依赖的版本了，只需要声明 GA

<properties>
    	
    	<atguigu.spring.version>4.3.20.RELEASE</atguigu.spring.version>
    	
    	<atguigu.spring.security.version>4.2.10.RELEASE</atguigu.spring.security.version>
    </properties>
    <dependencyManagement>
    	<dependencies>
    		
    		
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-orm</artifactId>
    			<version>${atguigu.spring.version}</version>
    		</dependency>
    		
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-webmvc</artifactId>
    			<version>${atguigu.spring.version}</version>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-test</artifactId>
    			<version>${atguigu.spring.version}</version>
    		</dependency>
    		
    		<dependency>
    			<groupId>org.aspectj</groupId>
    			<artifactId>aspectjweaver</artifactId>
    			<version>1.9.2</version>
    		</dependency>
    		
    		<dependency>
    			<groupId>cglib</groupId>
    			<artifactId>cglib</artifactId>
    			<version>2.2</version>
    		</dependency>
    		
    		
    		<dependency>
    			<groupId>mysql</groupId>
    			<artifactId>mysql-connector-java</artifactId>
    			<version>5.1.3</version>
    		</dependency>
    		
    		<dependency>
    			<groupId>com.alibaba</groupId>
    			<artifactId>druid</artifactId>
    			<version>1.0.31</version>
    		</dependency>
    		
    		<dependency>
    			<groupId>org.mybatis</groupId>
    			<artifactId>mybatis</artifactId>
    			<version>3.2.8</version>
    		</dependency>
    		
    		<dependency>
    			<groupId>org.mybatis</groupId>
    			<artifactId>mybatis-spring</artifactId>
    			<version>1.2.2</version>
    		</dependency>
    		
    		<dependency>
    			<groupId>com.github.pagehelper</groupId>
    			<artifactId>pagehelper</artifactId>
    			<version>4.0.0</version>
    		</dependency>
    		
    		<dependency>
    			<groupId>org.slf4j</groupId>
    			<artifactId>slf4j-api</artifactId>
    			<version>1.7.7</version>
    		</dependency>
    		<dependency>
    			<groupId>ch.qos.logback</groupId>
    			<artifactId>logback-classic</artifactId>
    			<version>1.2.3</version>
    		</dependency>
    		
    		<dependency>
    			<groupId>org.slf4j</groupId>
    			<artifactId>jcl-over-slf4j</artifactId>
    			<version>1.7.25</version>
    		</dependency>
    		<dependency>
    			<groupId>org.slf4j</groupId>
    			<artifactId>jul-to-slf4j</artifactId>
    			<version>1.7.25</version>
    		</dependency>
    		
    		<dependency>
    			<groupId>com.fasterxml.jackson.core</groupId>
    			<artifactId>jackson-core</artifactId>
    			<version>2.9.8</version>
    		</dependency>
    		<dependency>
    			<groupId>com.fasterxml.jackson.core</groupId>
    			<artifactId>jackson-databind</artifactId>
    			<version>2.9.8</version>
    		</dependency>
    		
    		<dependency>
    			<groupId>jstl</groupId>
    			<artifactId>jstl</artifactId>
    			<version>1.2</version>
    		</dependency>
    		
    		<dependency>
    			<groupId>junit</groupId>
    			<artifactId>junit</artifactId>
    			<version>4.12</version>
    			<scope>test</scope>
    		</dependency>
    		
    		<dependency>
    			<groupId>javax.servlet</groupId>
    			<artifactId>servlet-api</artifactId>
    			<version>2.5</version>
    			<scope>provided</scope>
    		</dependency>
    		
    		<dependency>
    			<groupId>javax.servlet.jsp</groupId>
    			<artifactId>jsp-api</artifactId>
    			<version>2.1.3-b06</version>
    			<scope>provided</scope>
    		</dependency>
    		
    		<dependency>
    			<groupId>com.google.code.gson</groupId>
    			<artifactId>gson</artifactId>
    			<version>2.8.5</version>
    		</dependency>
    		
    		<dependency>
    			<groupId>org.springframework.security</groupId>
    			<artifactId>spring-security-web</artifactId>
    			<version>${atguigu.spring.security.version}</version>
    		</dependency>
    		
    		<dependency>
    			<groupId>org.springframework.security</groupId>
    			<artifactId>spring-security-config</artifactId>
    			<version>${atguigu.spring.security.version}</version>
    		</dependency>
    		
    		<dependency>
    			<groupId>org.springframework.security</groupId>
    			<artifactId>spring-security-taglibs</artifactId>
    			<version>${atguigu.spring.security.version}</version>
    		</dependency>
    	</dependencies>
    </dependencyManagement>

## 6、 Spring 整合 MyBatis ##

### 6.1、整合 Mybatis 的思路 ###

1.  准备 `jdbc.properties`：存放数据库连接信息
2.  创建 `Spring` 配置文件(`spring-persist-mybatis.xml`)，专门配置 `Spring` 和 `MyBatis` 整合相关
3.  在 `Spring` 的配置文件中加载 `jdbc.properties` 属性文件
4.  使用 `${}` 表达式取出 `jdbc.properties` 中的配置信息，用于配置数据源
5.  测试从数据源中获取数据库连接，测试载当前的配置文件下，数据库是否能正常连接
6.  配置 `SqlSessionFactoryBean`：`SqlSessionFactoryBean` 用于创建 `SqlSession`，对应于数据库的一条连接
    
    1.  装配数据源
    2.  指定 `XxxMapper.xml` 配置文件的位置
    3.  指定 `MyBatis` 全局配置文件的位置（可选）
7.  配置 `MapperScannerConfigurer`，用于将 `Mapper` 接口的代理对象扫描到 `IOC` 容器中
8.  测试是否可以装配 `XxxMapper` 接口并通过这个接口操作数据库

![image-20200919163202427][]

### 6.2、在子工程中加入搭建环境所需的具体依赖 ###

*  子工程： 选择 `component` 工程， 原因是具体依赖和 `component` 工程相关
 *  在父工程中找到相应的依赖`GA`坐标，不需要`V`坐标，依赖的版本由父工程统一管理
 *  在`component` 工程的`pom`的文件中添加如下内容
    
    ![image-20200608171939836][]

<dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-orm</artifactId>
    </dependency>
    
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
    </dependency>
    
    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjweaver</artifactId>
    </dependency>
    
    <dependency>
      <groupId>cglib</groupId>
      <artifactId>cglib</artifactId>
    </dependency>
    
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
    </dependency>
    
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>druid</artifactId>
    </dependency>
    
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
    </dependency>
    
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis-spring</artifactId>
    </dependency>
    
    <dependency>
      <groupId>com.github.pagehelper</groupId>
      <artifactId>pagehelper</artifactId>
    </dependency>
    
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-core</artifactId>
    </dependency>
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-databind</artifactId>
    </dependency>
    
    <dependency>
      <groupId>jstl</groupId>
      <artifactId>jstl</artifactId>
    </dependency>
    
    <dependency>
      <groupId>com.google.code.gson</groupId>
      <artifactId>gson</artifactId>
    </dependency>

### 6.3、数据库连接信息 ###

*  在`webui`工程的`resources`文件夹下新建`jdbc.properties`配置文件，并添加如下内容

![image-20200710112024033][]

jdbc.user=root
    jdbc.password=root
    jdbc.url=jdbc:mysql://localhost:3306/project_crowd?useUnicode=true&characterEncoding=UTF-8
    jdbc.driver=com.mysql.jdbc.Driver

### 6.4、名存实亡的mybatis-config.xml ###

*  在`webui`工程的`resources`文件夹中添加`mybatis-config.xml` 配置文件
 *  `mybatis-config.xml`主要用于配置`mybatis`，但由于很多配置都在`Spring`配置文件中，所以该配置文件其实名存实亡

<?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
    "http://mybatis.org/dtd/mybatis-3-config.dtd">
    <configuration>
    
    </configuration>

### 6.5、spring-persist-mybatis.xml ###

#### 6.5.1、创建配置文件 ####

*  首先在`webui`工程的`resources`文件夹下添加`spring-persist-mybatis.xml` 配置文件
    
    ![image-20200608173158602][]
 *  导入`Context`名称空间
    
    ![image-20200608173318315][]

#### 6.5.2、配置数据库连接 ####

*  `location="classpath:jdbc.properties"` ：配置数据库连接属性，**类路径下**的 `jdbc.properties` 文件
 *  `class="com.alibaba.druid.pool.DruidDataSource"` ：德鲁伊数据库连接池
 *  `${jdbc.user}` 的形式取出 `properties` 配置文件中的值

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
    	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    	xmlns:context="http://www.springframework.org/schema/context"
    	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
    		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd">
    	
    	<context:property-placeholder
    		location="classpath:jdbc.properties" />
    	
    	<bean id="dataSource"
    		class="com.alibaba.druid.pool.DruidDataSource">
    		
    		<property name="username" value="${jdbc.user}" />
    		
    		<property name="password" value="${jdbc.password}" />
    		
    		<property name="url" value="${jdbc.url}" />
    		
    		<property name="driverClassName" value="${jdbc.driver}" />
    	</bean>
    </beans>

![image-20200608173530150][]

#### 6.5.3、测试数据库连接 ####

*  添加测试依赖：由于单元测试的范围为 `scope` ，无法从父工程中传递至子工程，所以我们需要在`webui`工程中添加单元测试相关依赖

<dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-test</artifactId>
      <scope>test</scope>
    </dependency>

*  新建测试类

![image-20200608175225956][]

*  测试代码
    
     *  `@RunWith(SpringJUnit4ClassRunner.class)` ：启动测试类时，加载 `SpringJUnit4ClassRunner`
     *  `locations = { "classpath:spring-persist-mybatis.xml" }` ：指定 `Spring` 配置文件的位置

package com.atguigu.crowd.test;
    
    import java.sql.Connection;
    import java.sql.SQLException;
    import javax.sql.DataSource;
    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.test.context.ContextConfiguration;
    import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
    
    //指定 Spring 给 Junit 提供的运行器类
    @RunWith(SpringJUnit4ClassRunner.class)
    //加载 Spring 配置文件的注解
    @ContextConfiguration(locations = {
         "classpath:spring-persist-mybatis.xml" })
    public class CrowdTest {
        
    	@Autowired
    	private DataSource dataSource;
    
    	@Test
    	public void testDataSource() throws SQLException {
        
    		// 1.通过数据源对象获取数据源连接
    		Connection connection = dataSource.getConnection();
    		// 2.打印数据库连接
    		System.out.println(connection);
    	}
    }

*  成功~

![image-20200608181339215][]

*  遇到的问题：解决 `Eclipse` 里 `Maven` 工程报 `An error occurred while filtering resources` 错误
 *  参考资料：https://www.cnblogs.com/hafiz/p/5366865.html
 *  解决办法：`Update Maven` 工程即可

![image-20200608182548409][]

#### 6.5.4、配置 SqlSessionFactoryBean ####

*  在`spring-persist-mybatis.xml`配置文件中配置 `Mybatis` 所需的 `SqlSessionFactoryBean`
    
     *  `SqlSessionFactoryBean`用于获取`SqlSessionFactory`，而`SqlSessionFactory`用于获取\`\`SqlSession`，对于`SqlSession`可以这么理解，一个`SqlSession\`就对应着一个数据库连接
     *  `value="classpath:mybatis-config.xml"` ：指定 `mybatis` 配置文件的位置
     *  `value="classpath:mybatis/mapper/*Mapper.xml"` ：指定 `Mapper` 映射文件的位置，`.*Mapper.xml` 表示匹配所有以 `Mapper.xml` 结尾的文件

<bean id="sqlSessionFactoryBean"
          class="org.mybatis.spring.SqlSessionFactoryBean">
      
      <property name="dataSource" ref="dataSource" />
      
      <property name="configLocation"
                value="classpath:mybatis-config.xml" />
      
      <property name="mapperLocations"
                value="classpath:mybatis/mapper/*Mapper.xml" />
    </bean>

#### 6.5.5、配置 MapperScannerConfigurer ####

*  在`spring-persist-mybatis.xml`配置文件中配置包扫描：扫描 `Mapper` 接口
 *  `value="com.atguigu.crowd.mapper"` ：`Mapper`接口所在包为 `com.atguigu.crowd.mapper`

<bean id="mapperScannerConfigurer"
          class="org.mybatis.spring.mapper.MapperScannerConfigurer">
      
      <property name="basePackage" value="com.atguigu.crowd.mapper" />
    </bean>

#### 6.5.6、测试Mapper功能 ####

*  测试代码：由于配置了包扫描，可直接使用 `@Autowired` 注入 `Mapper`

package com.atguigu.crowd.test;
    
    import java.sql.Connection;
    import java.sql.SQLException;
    import javax.sql.DataSource;
    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.test.context.ContextConfiguration;
    import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
    
    import com.atguigu.crowd.entity.Admin;
    import com.atguigu.crowd.mapper.AdminMapper;
    
    //指定 Spring 给 Junit 提供的运行器类
    @RunWith(SpringJUnit4ClassRunner.class)
    //加载 Spring 配置文件的注解
    @ContextConfiguration(locations = {
         "classpath:spring-persist-mybatis.xml" })
    public class CrowdTest {
        
    	@Autowired
    	private DataSource dataSource;
    
    	@Autowired
    	private AdminMapper adminMapper;
    
    	@Test
    	public void testAdminMapperAutowired() {
        
    		Admin admin = adminMapper.selectByPrimaryKey(1);
    		System.out.println(admin);
    	}
    
    	@Test
    	public void testDataSource() throws SQLException {
        
    		// 1.通过数据源对象获取数据源连接
    		Connection connection = dataSource.getConnection();
    		// 2.打印数据库连接
    		System.out.println(connection);
    	}
    }

![image-20200710113622172][]

## 7、日志系统 ##

### 7.1、日志系统结构 ###

系统在运行过程中出了问题就需要通过日志来进行排查， 所以我们在上手任何新技术的时候， 都要习惯性的关注一下它是如何打印日志的。

![image-20200919164331004][]

### 7.2、日志技术选型 ###

#### 7.2.1、总体介绍 ####

**日志门面(接口)**

<table> 
 <thead> 
  <tr> 
   <th>门面：</th> 
   <th></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>名称</td> 
   <td>说明</td> 
  </tr> 
  <tr> 
   <td>JCL（Jakarta Commons Logging）</td> 
   <td>陈旧</td> 
  </tr> 
  <tr> 
   <td>SLF4J（Simple Logging Facade for Java）</td> 
   <td>适合（同一作者）</td> 
  </tr> 
  <tr> 
   <td>jboss-logging</td> 
   <td>特殊专业领域使用</td> 
  </tr> 
 </tbody> 
</table>

**日志实现(接口的具体实现)**

<table> 
 <thead> 
  <tr> 
   <th>实现：</th> 
   <th></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>名称</td> 
   <td>说明</td> 
  </tr> 
  <tr> 
   <td>log4j</td> 
   <td>最初版（同一作者）</td> 
  </tr> 
  <tr> 
   <td>JUL（java.util.logging）</td> 
   <td>JDK 自带</td> 
  </tr> 
  <tr> 
   <td>log4j2</td> 
   <td>Apache 收购 log4j 后全面重构， 内部实现和 log4j 完全不同</td> 
  </tr> 
  <tr> 
   <td>logback</td> 
   <td>优雅、 强大（同一作者）</td> 
  </tr> 
 </tbody> 
</table>

#### 7.2.2、不同的日志整合 ####

与应用程序打交道的永远是日志门面，在日志门面之下还有一层适配层，用于适配不同的日志实现包

![image-20200919164519971][]

![image-20200919164523345][]

### 7.3、排除 commons-logging ###

*  我们不想使用 `commons-logging` 日志系统，但是 `Spring` 默认使用 `commons-logging` 组我诶日志系统，所以我们需要在工程中先排除此依赖，由于依赖具有传递性，我们先排除`component`工程中的`commons-logging`依赖

![image-20200608230402474][]

![image-20200608230555172][]

*  在`component`工程的`pom`文件中，已经排除掉了`commons-logging`的依赖

<dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-orm</artifactId>
      <exclusions>
        <exclusion>
          <groupId>commons-logging</groupId>
          <artifactId>commons-logging</artifactId>
        </exclusion>
      </exclusions>
    </dependency>

*  这还不够，由于`webui`工程中使用了`spring-test`，我们也要将其中`commons-logging`的依赖排除掉

![image-20200608230755031][]

*  这个时候如果运行程序会抛异常， 因为我们把 `Spring` 依赖的 `commons-logging` 排除了，而这个依赖是必须有的， 不是可选的

![image-20200608230941739][]

### 7.4、加入转换包 ###

*  在`component`工程的`pom`文件中添加 **slf4j** 的**日志门面**和**日志包**

<dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-api</artifactId>
    </dependency>
    
    <dependency>
      <groupId>ch.qos.logback</groupId>
      <artifactId>logback-classic</artifactId>
    </dependency>

*  在`component`工程的`pom`文件中添加如下**日志转换包**

<dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>jcl-over-slf4j</artifactId>
    </dependency>

### 7.5、日志测试 ###

*  日志结果如下

![image-20200608231849493][]

### 7.6、logback配置文件 ###

*  在`webui`工程的`resources`文件夹下，新建`logback.xml` 配置文件，配置日志相关信息
    
     *  `<root level="DEBUG">` ：指定 `root` 日志级别，任何部分的日志都按照该级别打印
     *  `<logger name="com.atguigu.crowd.mapper" level="DEBUG" />` ：指定局部日志级别，排除掉 root 的日志级别，特立独行

![image-20200609093507726][]

<?xml version="1.0" encoding="UTF-8"?>
    <configuration debug="true">
    	
    	<appender name="STDOUT"
    		class="ch.qos.logback.core.ConsoleAppender">
    		<encoder>
    			
    			
    			<pattern>[%d{HH:mm:ss.SSS}] [%-5level] [%thread] [%logger]
    				[%msg]%n</pattern>
    		</encoder>
    	</appender>
    	
    	
    	<root level="DEBUG">
    		
    		<appender-ref ref="STDOUT" />
    	</root>
    	
    	<logger name="com.atguigu.crowd.mapper" level="DEBUG" />
    </configuration>

*  日志输出格式如下

![image-20200710114328152][]

### 7.7、日志的使用 ###

*  使用方法如下

@Test
    public void testLog() {
        	
      // 1.获取Logger对象，这里传入的Class对象就是当前打印日志的类
      Logger logger = LoggerFactory.getLogger(CrowdTest.class);
    
      // 2.根据不同日志级别打印日志
      logger.debug("Hello I am Debug level!!!");
      logger.debug("Hello I am Debug level!!!");
      logger.debug("Hello I am Debug level!!!");
    
      logger.info("Info level!!!");
      logger.info("Info level!!!");
      logger.info("Info level!!!");
    
      logger.warn("Warn level!!!");
      logger.warn("Warn level!!!");
      logger.warn("Warn level!!!");
    
      logger.error("Error level!!!");
      logger.error("Error level!!!");
      logger.error("Error level!!!");
    }

## 8、声明式事务 ##

### 8.1、声明式事务的目的 ###

从事务角度：一个事务方法中包含的多个数据库操作， 要么一起提交、 要么一起回滚。 也就是说事务方法中的多个数据库操作， 有任何一个失败， 整个事务全部回滚。

从声明式角度： 由 Spring 来全面接管数据库事务。 用声明式代替编程式。

### 8.2、声明式事务的原理 ###

伪代码

try {
        
        // 核心操作前： 开启事务（关闭自动提交）
        // 对应 AOP 的前置通知
        connection.setAutoCommit(false);
        // 核心操作
        adminService.updateXxx(xxx, xxx);
        // 核心操作成功： 提交事务
        // 对应 AOP 的返回通知
        connection.commit();
    }catch(Exception e){
        
        // 核心操作失败： 回滚事务
        // 对应 AOP 的异常通知
        connection.rollBack();
    }finally{
        
        // 不论成功还是失败， 核心操作终归是结束了
        // 核心操作不管是怎么结束的， 都需要释放数据库连接
        // 对应 AOP 的后置通知
        if(connection != null){
        
        	connection.close();
        }
    }

### 8.3、声明式事务的实现思路 ###

![image-20200919165128794][]

### 8.4、创建 Spring 配置文件 ###

*  在`webui`工程下创建`spring-persist-tx.xml`配置文件，用于配置声明式事务，并添加`aop`、`context`、`tx`名称空间

![image-20200609100637560][]

### 8.5、配置包扫描 ###

*  扫描`service`包：将 Service 层的组件扫描到 IOC 容器中（Service 层控制事务）

<context:component-scan
    	base-package="com.atguigu.crowd.service" />

### 8.6、配置事务管理器 ###

*  事务管理器需要控住数据库连接池，这个 dataSource 就是之前我们配置的德鲁伊数据库连接池

<bean id="txManager"
          class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
      
      <property name="dataSource" ref="dataSource" />
    </bean>

### 8.7、配置事务切面 ###

*  事务切面：
    
     *  `expression="execution(* *..*ServiceImpl.*(..))" id="txPointcut"` ：切 `*ServiceImpl` 下的所有方法
     *  具体切哪些方法，由`txAdvice`中的`<tx:method>`标签配置

<aop:config>
      
      <aop:pointcut
    	expression="execution(* *..*ServiceImpl.*(..))" id="txPointcut" />
      
      <aop:advisor advice-ref="txAdvice"
    	pointcut-ref="txPointcut" />
    </aop:config>

### 8.8、配置事务通知 ###

*  对只读方法标记`read-only="true"`，可提升性能
 *  对更新方法标记`propagation="REQUIRES_NEW"`，表明我不和你坐同一条船

<tx:advice id="txAdvice" transaction-manager="txManager">
      
      <tx:attributes>
        
        <tx:method name="get*" read-only="true" />
        <tx:method name="find*" read-only="true" />
        <tx:method name="query*" read-only="true" />
        <tx:method name="count*" read-only="true" />
    
        
        
        
        <tx:method name="save*" propagation="REQUIRES_NEW"
                   rollback-for="java.lang.Exception" />
        <tx:method name="update*" propagation="REQUIRES_NEW"
                   rollback-for="java.lang.Exception" />
        <tx:method name="remove*" propagation="REQUIRES_NEW"
                   rollback-for="java.lang.Exception" />
        <tx:method name="batch*" propagation="REQUIRES_NEW"
                   rollback-for="java.lang.Exception" />
      </tx:attributes>
    </tx:advice>

### 8.9、声明式事务的测试 ###

> **创建service相关的组件**

*  在`component`工程中添加如下组件
    
     *  `com.atguigu.crowd.service.api：AdminService.java`
     *  `com.atguigu.crowd.service.impl：AdminServiceImpl.java`

![image-20200609102303268][]

*  `AdminService.java`代码

import java.util.List;
    import com.atguigu.crowd.entity.Admin;
    
    public interface AdminService {
        
    	void saveAdmin(Admin admin);
    
    	List<Admin> getAll();
    }

*  `AdminServiceImpl.java`代码

import java.util.List;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    import com.atguigu.crowd.entity.Admin;
    import com.atguigu.crowd.entity.AdminExample;
    import com.atguigu.crowd.mapper.AdminMapper;
    import com.atguigu.crowd.service.api.AdminService;
    
    @Service
    public class AdminServiceImpl implements AdminService {
        
    	@Autowired
    	private AdminMapper adminMapper;
    
    	@Override
    	public void saveAdmin(Admin admin) {
        
    		adminMapper.insert(admin);
    
    		// throw new RuntimeException();
    	}
    
    	@Override
    	public List<Admin> getAll() {
        
    		return adminMapper.selectByExample(new AdminExample());
    	}
    
    }

> **编写测试代码**

*  代码：注意，一定要将新增的`spring-persist-tx.xml`配置文件添加至扫描路径中

![image-20200609103032271][]

import java.sql.Connection;
    import java.sql.SQLException;
    import javax.sql.DataSource;
    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.test.context.ContextConfiguration;
    import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
    
    import com.atguigu.crowd.entity.Admin;
    import com.atguigu.crowd.mapper.AdminMapper;
    import com.atguigu.crowd.service.api.AdminService;
    
    //指定 Spring 给 Junit 提供的运行器类
    @RunWith(SpringJUnit4ClassRunner.class)
    //加载 Spring 配置文件的注解
    @ContextConfiguration(locations = {
         "classpath:spring-persist-mybatis.xml", "classpath:spring-persist-tx.xml" })
    public class CrowdTest {
        
    	@Autowired
    	private DataSource dataSource;
    
    	@Autowired
    	private AdminMapper adminMapper;
    
    	@Autowired
    	private AdminService adminService;
    
    	@Test
    	public void testTx() {
        
    		Admin admin = new Admin(null, "jerry", "123456", "杰瑞", "jerry@qq.com", null);
    		adminService.saveAdmin(admin);
    	}
    
    	@Test
    	public void testAdminMapperAutowired() {
        
    		Admin admin = adminMapper.selectByPrimaryKey(1);
    		System.out.println(admin);
    	}
    
    	@Test
    	public void testDataSource() throws SQLException {
        
    		// 1.通过数据源对象获取数据源连接
    		Connection connection = dataSource.getConnection();
    		// 2.打印数据库连接
    		System.out.println(connection);
    	}
    }

## 9、SpringMVC的整合与配置 ##

### 9.1、表述层工作原理 ###

#### 9.1.1、启动过程 ####

![image-20200919165356741][]

#### 9.1.2、访问过程 ####

![image-20200919165435229][]

### 9.2、配置ContextLoaderListener ###

*  在`web.xml`中添加如下内容，不必手敲，根据智能提示来即可
    
     *  `ContextLoaderListener` 的作用： 加载 Spring 的配置文件， 根据 Spring 的配置文件初始化 IOC 容器
     *  `<param-value>classpath:spring-persist-*.xml</param-value>` ：去找类路径下的 `spring-persist-*.xml` 配置文件，加载 IOC 容器

![image-20200609105258060][]

<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    	xmlns="http://java.sun.com/xml/ns/javaee"
    	xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
    	version="2.5">
    
    	
    	<context-param>
    		<param-name>contextConfigLocation</param-name>
    		<param-value>classpath:spring-persist-*.xml</param-value>
    	</context-param>
    
    	
    	<listener>
    		<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    	</listener>
    
    </web-app>

*  配置 `ContextLoaderListener` 加载 `Spring` 配置文件

![image-20200609105453869][]

### 9.3、配置CharacterEncodingFilter ###

*  在`web.xml`中添加如下内容，主要是配置请求和响应的字符集编码，都设置`UTF-8`
    
     *  `<param-name>encoding</param-name>` ：设定字符集为 UTF-8
     *  `<param-name>forceRequestEncoding</param-name>` ：强制请求字符集为 UTF-8
     *  `<param-name>forceResponseEncoding</param-name>` ：强制响应字符集为 UTF-8
     *  `<filter-name>CharacterEncodingFilter</filter-name>` ：这个 Filter 一定要在其他 Filter 之前执行，不然配置的字符集编码就都失效了

<filter>
      <filter-name>CharacterEncodingFilter</filter-name>
      <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
      
      <init-param>
        <param-name>encoding</param-name>
        <param-value>UTF-8</param-value>
      </init-param>
      
      <init-param>
        <param-name>forceRequestEncoding</param-name>
        <param-value>true</param-value>
      </init-param>
      
      <init-param>
        <param-name>forceResponseEncoding</param-name>
        <param-value>true</param-value>
      </init-param>
    </filter>
    
    
    
    
    
    <filter-mapping>
      <filter-name>CharacterEncodingFilter</filter-name>
      <url-pattern>/*</url-pattern>
    </filter-mapping>

### 9.4、配置DispatcherServlet ###

*  如何创建`SpringMVC`配置文件：先创建`Spring`配置文件，再添加`context`和`mvc`名称空间

![image-20200609111020486][]

![image-20200609112822092][]

*  配置前端控制器：
    
     *  `<param-value>classpath:spring-web-mvc.xml</param-value>` ：指定`SpringMVC`配置文件所在的位置
     *  因为前端控制器需要初始化`SpringMVC IOC`容器中的`Beans`

![image-20200609111504467][]

<servlet>
      <servlet-name>springDispatcherServlet</servlet-name>
      <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
      <init-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:spring-web-mvc.xml</param-value>
      </init-param>
      
      
      
      <load-on-startup>1</load-on-startup>
    </servlet>
    
    
    <servlet-mapping>
      <servlet-name>springDispatcherServlet</servlet-name>
      
      
    
      
      
      
      
      
      
      <url-pattern>*.html</url-pattern>
    
      
      
      
      <url-pattern>*.json</url-pattern>
    </servlet-mapping>

*  在哪儿看默认支持的扩展名？

![image-20200609112618199][]

### 9.5、配置HiddenHttpMethodFilter ###

*  `HiddenHttpMethodFilter` 用于支持 REST 风格，暂时省略不配

### 9.6、SpringMVC的配置文件 ###

#### 9.6.1、添加mvc所需的包 ####

*  在`component`工程下添加如下包，用于存放`SpringMVC`所需要的组件

![image-20200609113651132][]

#### 9.6.2、SpringMVC具体配置 ####

*  在`spring-web-mvc.xml`中添加如下代码：
    
     *  `base-package="com.atguigu.crowd.mvc"` ：扫描`com.atguigu.crowd.mvc`包下的组件作为`SpringMVC IOC`容器中的`Beans`
     *  `<mvc:annotation-driven />` ：开启注解驱动的开发模式
     *  我们将`jsp`页面放在`WEB-INF`目录下，起保护作用，别人直接访问的话就访问不到

<context:component-scan
    	base-package="com.atguigu.crowd.mvc" />
    
    
    <mvc:annotation-driven />
    
    
    <bean id="viewResolver"
          class="org.springframework.web.servlet.view.InternalResourceViewResolver">
      <property name="prefix" value="/WEB-INF/" />
      <property name="suffix" value=".jsp" />
    </bean>

*  遇到的问题：https://www.cnblogs.com/mYunYu/p/9048473.html

### 9.7、测试页面的访问 ###

#### 9.7.1、添加相关的依赖 ####

*  在`component`工程添加对`servlet-api`的依赖，由于项目启动后，会部署在 Tomcat 上，而 Tomcat 中已经有 servlet 相关的 jar 包，所以 servlet 依赖的范围必须为 provided

<dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>servlet-api</artifactId>
      <scope>provided</scope>
    </dependency>

*  在`webui`工程下添加对`servlet-api`和`jsp-api`的依赖

<dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>servlet-api</artifactId>
      <scope>provided</scope>
    </dependency>
    
    <dependency>
      <groupId>javax.servlet.jsp</groupId>
      <artifactId>jsp-api</artifactId>
      <scope>provided</scope>
    </dependency>

*  如果不添加上述依赖，则创建`jsp`页面时将出现如下错误

![image-20200609180753696][]

*  注意：如上依赖的范围为`provided`，因为`tomcat`有这些`jar`包，部署的时候无需放在工程目录之中

#### 9.7.2、创建index.jsp ####

*  修改`jsp`页面默认的编码格式为 UTF-8

![image-20200609180618821][]

*  在`webapp`下创建`index.jsp`页面，用于发送 HTTP 请求，添加如下代码

*  在`WEB-INF`下创建`target.jsp`页面，用于请求成功后的跳转，添加如下代码

*  文件位置如下

![image-20200609181840684][]

#### 9.7.3、添加控制器 ####

*  在`component`工程下添加如下`TestHandler`，用于测试

![image-20200609182115665][]

*  添加如下代码

@Controller
    public class TestHandler {
        
    	@Autowired
    	private AdminService adminService;
    
    	@RequestMapping("/test/ssm.html")
    	public String testSsm(ModelMap modelMap) {
        
    		List<Admin> adminList = adminService.getAll();
    		modelMap.addAttribute("adminList", adminList);
    		return "target";
    	}
    }

#### 9.7.4、代码测试 ####

*  将`webui`工程在`tomcat`中启动

![image-20200609182320143][]

*  成功~

![image-20200919181539018][]

### 9.8、base标签 ###

*  `base`标签用于定位将页面上路径中的`${pageContext.request.contextPath}`部分提取到页面开头，去除冗余代码

![image-20200609184347443][]

## 10、SpringMVC与Ajax ##

### 10.1、Ajax 请求流程 ###

前端发送过来， 后端要处理的请求有两种：

1.  普通请求： 后端处理完成后返回页面， 浏览器使用使用页面替换整个窗口中的内容
2.  Ajax 请求： 后端处理完成后通常返回 JSON 数据， jQuery 代码使用 JSON 数据对页面局部更新

![image-20200919170939478][]

### 10.2、引入依赖 ###

*  `jackson`相关依赖：
    
     *  `@RequestBody` 作用：将请求参数（ json 字符串）注入到实体类中
     *  `ResponseBody` 作用：将对象转为 json 字符串，返回给调用者
     *  综上，需要引入`jackson`相关依赖

<dependency>
    	<groupId>com.fasterxml.jackson.core</groupId>
    	<artifactId>jackson-core</artifactId>
    </dependency>
    <dependency>
    	<groupId>com.fasterxml.jackson.core</groupId>
    	<artifactId>jackson-databind</artifactId>
    </dependency>

*  `SpringmVC`配置中启用注解驱动

<mvc:annotation-driven/>

### 10.3、引入jQuery ###

*  将`jQuery`文件添加至`webapp`目录下

![image-20200609221458560][]

*  在页面中使用 script 标签引入`jQuery`即可

![image-20200609221626770][]

### 10.4、方案一 ###

*  页面代码：主要关注`btn1`相关代码（直接发送 `"array" : [ 5, 8, 12 ]` 数组对象）

<%@ page language="java" contentType="text/html; charset=UTF-8"
    	pageEncoding="UTF-8"%>
    <!DOCTYPE html>
    <html>
    <head>
    <meta charset="UTF-8">
    <title>Insert title here</title>
    
    <base
    	href="http://${pageContext.request.serverName }:${pageContext.request.serverPort }${pageContext.request.contextPath }/" />
    <script type="text/javascript" src="jquery/jquery-2.1.1.min.js"></script>
    <script type="text/javascript">
    	$(function() {
          // 页面加载完成
    		$("#btn1").click(function() {
         
    			$.ajax({
         
    				"url" : "send/array/one.html", // 请求目标资源的地址
    				"type" : "post", // 请求方式
    				"data" : {
          // 要发送的请求参数
    					"array" : [ 5, 8, 12 ]
    				},
    				"dataType" : "text", // 如何对待服务器端返回的数据
    				"success" : function(response) {
          // 服务器端成功处理请求后调用的回调函数，response是响应体数据
    					alert(response);
    				},
    				"error" : function(response) {
          // 服务器端处理请求失败后调用的回调函数，response是响应体数据
    					alert(response);
    				}
    			});
    		});
    	});}
    </script>
    </head>
    <body>
    	<a href="test/ssm.html">测试SSM整合环境</a>
    	<br />
    	<br />
    	<button id="btn1">Send [5,8,12] One</button>
    </body>
    </html>

*  `Handler`代码中：参数名必须为`array[]`

@ResponseBody
    @RequestMapping("/send/array/one.html")
    public String testReceiveArrayOne(@RequestParam("array[]") List<Integer> array) {
        
      for (Integer number : array) {
        
        System.out.println("number=" + number);
      }
      return "success";
    }

*  缺点：这`jQuery`偏偏就要在`array`后面加一个`[]`，变成`array[]`

![image-20200609222642552][]

### 10.5、方案二 ###

*  创建实体类：在`entity`工程下创建实体类，用于接收`ajax`传入的参数

![image-20200609225433627][]

public class ParamData {
        
    	private List<Integer> array;

*  页面代码：添加`btn2`，并为其添加单击事件，单击 btn2 ，将 array 数组拆分为 3 个整数，并以表单方式方式提交，在后端可采用 `List<Integer>` 类型的字段来接收

$("#btn2").click(function() {
        
    	$.ajax({
        
    		"url" : "send/array/two.html", // 请求目标资源的地址
    		"type" : "post", // 请求方式
    		"data" : {
         // 要发送的请求参数
    			"array[0]" : 5,
    			"array[1]" : 8,
    			"array[2]" : 12
    		},
    		"dataType" : "text", // 如何对待服务器端返回的数据
    		"success" : function(response) {
         // 服务器端成功处理请求后调用的回调函数，response是响应体数据
    			alert(response);
    		},
    		"error" : function(response) {
         // 服务器端处理请求失败后调用的回调函数，response是响应体数据
    			alert(response);
    		}
    	});
    });

*  `Handler`代码：参数将被注入到实体的`array`属性中

@ResponseBody
    @RequestMapping("/send/array/two.html")
    public String testReceiveArrayTwo(ParamData paramData) {
        
      List<Integer> array = paramData.getArray();
      for (Integer number : array) {
        
        System.out.println("number=" + number);
      }
      return "success";
    }

*  浏览器发送的数据格式为`Form Data`，这就是为什么可以将参数注入到实体类的属性中去的原因

![image-20200609231310652][]

*  缺点：为了传个参数，我还要特地建个实体类？

### 10.6、方案三 ###

*  页面代码：添加`btn3`，并为其添加单击事件，将数组对象转为 json 字符串，发送至后端 Handler 方法

<button id="btn3">Send [5,8,12] Three</button>

$("#btn3").click(function() {
        
    	// 准备好要发送到服务器端的数组
    	var array = [ 5, 8, 12 ];
    	console.log(array.length);
    
    	// 将JSON数组转换为JSON字符串
    	var requestBody = JSON.stringify(array);
    	// "['5','8','12']"
    	console.log(requestBody.length);
    
    	$.ajax({
        
    		"url" : "send/array/three.html", // 请求目标资源的地址
    		"type" : "post", // 请求方式
    		"data" : requestBody, // 请求体
    		"contentType" : "application/json;charset=UTF-8", // 设置请求体的内容类型，告诉服务器端本次请求的请求体是JSON数据
    		"dataType" : "text", // 如何对待服务器端返回的数据
    		"success" : function(response) {
         // 服务器端成功处理请求后调用的回调函数，response是响应体数据
    			alert(response);
    		},
    		"error" : function(response) {
         // 服务器端处理请求失败后调用的回调函数，response是响应体数据
    			alert(response);
    		}
    	});
    });

*  `Handler`代码：使用`RequestBody`接受请求体参数，将 `json` 字符串序列化为实体类对象

//使用Logger输出日志
    private Logger logger = LoggerFactory.getLogger(TestHandler.class);
    
    @ResponseBody
    @RequestMapping("/send/array/three.html")
    public String testReceiveArrayThree(@RequestBody List<Integer> array) {
        
      for (Integer number : array) {
        
        logger.info("number=" + number);
      }
      return "success";
    }

*  浏览器中发送的请求体为`Request Payload`形式

![image-20200609231121639][]

### 10.7、发送复杂对象 ###

*  准备实体类：在`entity`工程下添加如下实体类

public class Student {
        	
    	private Integer stuId;
    	private String stuName;
    	private Address address;
    	private List<Subject> subjectList;
    	private Map<String, String> map;

public class Address {
        
    	private String province;
    	private String city;
    	private String street;

public class Subject {
        	
    	private String subjectName;
    	private Integer subjectScore;

*  页面代码：添加`btn4`，并为其添加单击事件，将 student 对象转为 json 字符串发送给后端 Handler 方法

<button id="btn4">Send Compose Object</button>

$("#btn4").click(function() {
        
    	// 准备要发送的数据
    	var student = {
        
    		"stuId" : 5,
    		"stuName" : "tom",
    		"address" : {
        
    			"province" : "广东",
    			"city" : "深圳",
    			"street" : "后瑞"
    		},
    		"subjectList" : [ {
        
    			"subjectName" : "JavaSE",
    			"subjectScore" : 100
    		}, {
        
    			"subjectName" : "SSM",
    			"subjectScore" : 99
    		} ],
    		"map" : {
        
    			"k1" : "v1",
    			"k2" : "v2"
    		}
    	};
    
    	// 将JSON对象转换为JSON字符串
    	var requestBody = JSON.stringify(student);
    
    	// 发送Ajax请求
    	$.ajax({
        
    		"url" : "send/compose/object.html",
    		"type" : "post",
    		"data" : requestBody,
    		"contentType" : "application/json;charset=UTF-8",
    		"dataType" : "text",
    		"success" : function(response) {
        
    			console.log(response);
    		},
    		"error" : function(response) {
        
    			console.log(response);
    		}
    	});
    });

*  `Handler`代码：使用`RequestBody`接受请求体参数，将 `json` 字符串序列化为实体类对象

@ResponseBody
    @RequestMapping("/send/compose/object.html")
    public String testReceiveComposeObject(@RequestBody Student student) {
        
      logger.info(student.toString());
      return "success";
    }

*  浏览器中发送的请求体为`Request Payload`形式

![image-20200609232521255][]

### 10.8、统一Ajax格式 ###

*  在`util`工程下创建发`ResultEntity.java`工具了，用于统一整个项目中`Ajax`请求返回的结果（未来也可以用于分布式架构各个模块间调用时返回统一类型），ResultEntity 类中个字段含义如下：
    
     *  result ：用于判断请求是否成功
        
         *  “SUCCESS” ：请求成功
         *  “FAILED”：请求失败
     *  message ：仅在请求失败时使用，用于返回请求失败的错误消息
     *  data ：Ajax 请求返回的数据

![image-20200610112230801][]

/**
     * 统一整个项目中Ajax请求返回的结果（未来也可以用于分布式架构各个模块间调用时返回统一类型）
     * @author Lenovo
     *
     * @param <T>
     */
    public class ResultEntity<T> {
        
    	
    	public static final String SUCCESS = "SUCCESS";
    	public static final String FAILED = "FAILED";
    	
    	// 用来封装当前请求处理的结果是成功还是失败
    	private String result;
    	
    	// 请求处理失败时返回的错误消息
    	private String message;
    	
    	// 要返回的数据
    	private T data;
    	
    	/**
    	 * 请求处理成功且不需要返回数据时使用的工具方法
    	 * @return
    	 */
    	public static <Type> ResultEntity<Type> successWithoutData() {
        
    		return new ResultEntity<Type>(SUCCESS, null, null);
    	}
    	
    	/**
    	 * 请求处理成功且需要返回数据时使用的工具方法
    	 * @param data 要返回的数据
    	 * @return
    	 */
    	public static <Type> ResultEntity<Type> successWithData(Type data) {
        
    		return new ResultEntity<Type>(SUCCESS, null, data);
    	}
    	
    	/**
    	 * 请求处理失败后使用的工具方法
    	 * @param message 失败的错误消息
    	 * @return
    	 */
    	public static <Type> ResultEntity<Type> failed(String message) {
        
    		return new ResultEntity<Type>(FAILED, message, null);
    	}
    	
    	public ResultEntity() {
        
    		
    	}
    
    	public ResultEntity(String result, String message, T data) {
        
    		super();
    		this.result = result;
    		this.message = message;
    		this.data = data;
    	}
    
    	@Override
    	public String toString() {
        
    		return "ResultEntity [result=" + result + ", message=" + message + ", data=" + data + "]";
    	}
    
    	public String getResult() {
        
    		return result;
    	}
    
    	public void setResult(String result) {
        
    		this.result = result;
    	}
    
    	public String getMessage() {
        
    		return message;
    	}
    
    	public void setMessage(String message) {
        
    		this.message = message;
    	}
    
    	public T getData() {
        
    		return data;
    	}
    
    	public void setData(T data) {
        
    		this.data = data;
    	}
    
    }

*  `"url" : "send/compose/object.json"`：因为我们在 `SpringMVC` 配置文件中配置过，拦截除了 `.html` 和 `.json` 之外的所有请求，我们需要将`Ajax`请求地址的扩展名改为`.json`
 *  `"dataType" : "json"` ：告诉 `Ajax` ，将接收到的 `json` 字符串转为`json`对象，这样`ajax`就能帮我们将`json`字符串转换为`json`对象，我们直接使用 `json` 对象即可

![image-20200610113418571][]

$("#btn4").click(function() {
        
    	// 准备要发送的数据
    	var student = {
        
    		"stuId" : 5,
    		"stuName" : "tom",
    		"address" : {
        
    			"province" : "广东",
    			"city" : "深圳",
    			"street" : "后瑞"
    		},
    		"subjectList" : [ {
        
    			"subjectName" : "JavaSE",
    			"subjectScore" : 100
    		}, {
        
    			"subjectName" : "SSM",
    			"subjectScore" : 99
    		} ],
    		"map" : {
        
    			"k1" : "v1",
    			"k2" : "v2"
    		}
    	};
    
    	// 将JSON对象转换为JSON字符串
    	var requestBody = JSON.stringify(student);
    
    	// 发送Ajax请求
    	$.ajax({
        
    		"url" : "send/compose/object.json",
    		"type" : "post",
    		"data" : requestBody,
    		"contentType" : "application/json;charset=UTF-8",
    		"dataType" : "json",
    		"success" : function(response) {
        
    			console.log(response);
    		},
    		"error" : function(response) {
        
    			console.log(response);
    		}
    	});
    });

*  修改`Handler`中请求的代码，请求映射地址扩展名为`json`

![image-20200610113306416][]

@ResponseBody
    @RequestMapping("/send/compose/object.json")
    public ResultEntity<Student> testReceiveComposeObject(@RequestBody Student student) {
        
      // 将“查询”到的Student对象封装到ResultEntity中返回
      ResultEntity<Student> resultEntity = ResultEntity.successWithData(student);
      return resultEntity;
    }

*  浏览器控制台输出如下

![image-20200610113015511][]

## 11、异常处理 ##

### 11.1、异常处理映射机制 ###

1.  对于 Ajax 请求，发生异常需要返回异常信息对应的 json 字符串
2.  对于普通请求，发生异常需要对应的异常页面，并在异常界面中显示异常信息

![image-20200919172116511][]

### 11.2、判断 Ajax 请求的依据 ###

![image-20200919181054979][]

### 11.3、基于XML配置的异常处理 ###

*  在`WEB-INF`下创建`system-error.jsp`，从 request 域中取出错误信息，在页面上显示

![image-20200610121801939][]

<%@ page language="java" contentType="text/html; charset=UTF-8"
    	pageEncoding="UTF-8"%>
    <!DOCTYPE html>
    <html>
    <head>
    <meta charset="UTF-8">
    <title>Insert title here</title>
    </head>
    <body>
    	<h1>出错了！</h1>
    
    	
    	${requestScope.exception.message }
    </body>
    </html>

*  在`SpringMVC`配置文件`spring-web-mvc.xml`中添加如下映射关系
 *  `<prop key="java.lang.Exception">system-error</prop>`：发生 `java.lang.Exception` 类型的异常，映射至 `system-error` 页面，经视图解析器渲染之后，将定位置 `/WEB-INF/system-error.jsp` 页面

<bean id="simpleMappingExceptionResolver" class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">
      
      <property name="exceptionMappings">
        <props>
          
          
          <prop key="java.lang.Exception">system-error</prop>
        </props>
      </property>
    </bean>

*  制造异常

@RequestMapping("/test/ssm.html")
    public String testSsm(ModelMap modelMap) {
        
      List<Admin> adminList = adminService.getAll();
      modelMap.addAttribute("adminList", adminList);
      int i = 10 / 0;
      return "target";
    }

*  测试：成功捕获到异常信息

![image-20200610122006003][]

### 11.4、判断请求类型的工具方法 ###

*  添加依赖：由于需要用到`Servlet`相关类，所以需要在`util`工程中添加对`Servlet`的依赖，依赖范围为 `provided`

<dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>servlet-api</artifactId>
      <version>2.5</version>
      <scope>provided</scope>
    </dependency>

*  在`util`工程下创建`CrowdUtil`工具类，用于判断请求类型
    
     *  `acceptHeader.contains("application/json")` ：请求头中包含 application/json ，则说明是 Ajax 请求
     *  `xRequestHeader.equals("XMLHttpRequest")` ：请求头中包含 XMLHttpRequest ，也是 Ajax 请求

![image-20200610134859465][]

public class CrowdUtil {
        
    
    	/**
    	 * 判断当前请求是否为Ajax请求
    	 * 
    	 * @param request 请求对象
    	 * @return true：当前请求是Ajax请求 false：当前请求不是Ajax请求
    	 */
    	public static boolean judgeRequestType(HttpServletRequest request) {
        
    
    		// 1.获取请求消息头
    		String acceptHeader = request.getHeader("Accept");
    		String xRequestHeader = request.getHeader("X-Requested-With");
    
    		// 2.判断
    		return (acceptHeader != null && acceptHeader.contains("application/json"))
    				||
    				(xRequestHeader != null && xRequestHeader.equals("XMLHttpRequest"));
    	}
    
    }

### 11.5、基于注解配置的异常处理 ###

*  添加异常处理配置类：在`component`工程下添加`CrowdExceptionResolver`类，该类是一个基于注解的异常处理器类

![image-20200610181314875][]

*  `commonResolve()` 方法调用 `CrowdUtil.judgeRequestType()` 方法判断当前请求是否为 `Ajax` 请求
    
     *  如果是 `Ajax` 请求：通过响应流写回错误消息（不提供异常映射页面）
     *  如果是普通请求：指定异常映射页面，并返回 `modelAndView` 对象

// @ControllerAdvice表示当前类是一个基于注解的异常处理器类
    @ControllerAdvice
    public class CrowdExceptionResolver {
        
    
    	@ExceptionHandler(value = ArithmeticException.class)
    	public ModelAndView resolveMathException(
    			ArithmeticException exception, 
    			HttpServletRequest request,
    			HttpServletResponse response
    		) throws IOException {
        
    		String viewName = "system-error";
    		return commonResolve(viewName, exception, request, response);
    	}
    
    	@ExceptionHandler(value = NullPointerException.class)
    	public ModelAndView resolveNullPointerException(
    			NullPointerException exception, 
    			HttpServletRequest request,
    			HttpServletResponse response
    		) throws IOException {
        
    		String viewName = "system-error";
    		return commonResolve(viewName, exception, request, response);
    	}
    
    	// @ExceptionHandler将一个具体的异常类型和一个方法关联起来
    	private ModelAndView commonResolve(
    			// 异常处理完成后要去的页面
    			String viewName,
    			// 实际捕获到的异常类型
    			Exception exception,
    			// 当前请求对象
    			HttpServletRequest request,
    			// 当前响应对象
    			HttpServletResponse response
    		) throws IOException {
        
    		// 1.判断当前请求类型
    		boolean judgeResult = CrowdUtil.judgeRequestType(request);
    		// 2.如果是Ajax请求
    		if (judgeResult) {
        
    			// 3.创建ResultEntity对象
    			ResultEntity<Object> resultEntity = ResultEntity.failed(exception.getMessage());
    			// 4.创建Gson对象
    			Gson gson = new Gson();
    			// 5.将ResultEntity对象转换为JSON字符串
    			String json = gson.toJson(resultEntity);
    			// 6.将JSON字符串作为响应体返回给浏览器
    			response.getWriter().write(json);
    			// 7.由于上面已经通过原生的response对象返回了响应，所以不提供ModelAndView对象
    			return null;
    		}
    		// 8.如果不是Ajax请求则创建ModelAndView对象
    		ModelAndView modelAndView = new ModelAndView();
    		// 9.将Exception对象存入模型
    		modelAndView.addObject("exception", exception);
    		// 10.设置对应的视图名称
    		modelAndView.setViewName(viewName);
    		// 11.返回modelAndView对象
    		return modelAndView;
    	}
    
    }

*  制造`.html`请求的异常

![image-20200610181747470][]

![image-20200610181902876][]

*  制造`.json`请求的异常

![image-20200610182009159][]

![image-20200610182256614][]

[image-20200919160437834]: /images/20221123/c8f02c64dc7a48ed97846c0c0da67ed6.png
[image-20200607204655076]: /images/20221123/259a2874b342475494b997be49358bcd.png
[image-20200607220019708]: /images/20221123/1920aced2e75411da1e81af93cd47161.png
[image-20200607220401668]: /images/20221123/118bcbe764c1482281b000b5ac5d2289.png
[image-20200609104132104]: /images/20221123/c4dd00c993be4ded8b20e2a68de4ab7e.png
[image-20200607232031825]: /images/20221123/072583824e4546a8956e73ff01c73d09.png
[image-20200607231950264]: /images/20221123/70edf3373eb44a9db37c3f964fa5d2fd.png
[image-20200710105612136]: /images/20221123/89fb7f8d1e054665bf90fec966651c1e.png
[image-20200919160800350]: /images/20221123/9553fbf38ec249bdb8ea1128ba1aecff.png
[image-20200607220526350]: /images/20221123/95e6be16149644c68ec0fdfa893a6ec5.png
[image-20200607221128679]: /images/20221123/742ff592b9614dd690354ea3ef7e5a02.png
[image-20200607221343991]: /images/20221123/f9ad7f25733d45e2be198e56c3bb5fc3.png
[image-20200607221537186]: /images/20221123/05cae59f5822445e813b0c0cecd1583c.png
[image-20200607222006050]: /images/20221123/7cd3840d8dc44ca1a2e9ece388ef9796.png
[image-20200607221755244]: /images/20221123/186d8731d93b48feb3b79e60c928207a.png
[image-20200607232931453]: /images/20221123/8a7b4440502e423cafc641832f0128c4.png
[image-20200607233055287]: /images/20221123/39f098b0bc97466ea6dee96170632f36.png
[image-20200607222150149]: /images/20221123/18eadfb240414bddab1d313c997672b1.png
[image-20200607232705107]: /images/20221123/7d087d4c07f34d2980b7cc433d982e26.png
[image-20200607233307224]: /images/20221123/45a6b9861dd84ccdbf2c8d00102ce74e.png
[image-20200607233339963]: /images/20221123/092ba31f4fef403db967962dd74811b3.png
[image-20200607233653366]: /images/20221123/11f10a06dd944fc98922013213098f20.png
[image-20200607233918333]: /images/20221123/e7556d9981654ee08ea896bb3f50c721.png
[image-20200710105632155]: /images/20221123/8853c026d748499a9d0a9c659bec0e31.png
[image-20200608001106648]: /images/20221123/48b1269ccbc149188e2eee5f545f8f9a.png
[image-20200608001156258]: /images/20221123/795757023ee94b0da0df9105aa1733fa.png
[image-20200608001356426]: /images/20221123/b2589ce79f594190bbf868d40b374b0e.png
[image-20200608001529146]: /images/20221123/a95a3614af4d41a5b77e9c118fbe512a.png
[image-20200608001750586]: /images/20221123/349e9a7a89ed43ad8d1bc9a43d9c465f.png
[image-20200608113904389]: /images/20221123/3d0e711ba4d54aedbbc5959542084c02.png
[image-20200608114004572]: /images/20221123/7c04fe5a53b7435a831a8f4761b43cc3.png
[image-20200608154038372]: /images/20221123/8f4b5756eff640e69963927612763b08.png
[image-20200608154131087]: /images/20221123/6067886f630544919ed3c042766da3ca.png
[image-20200608154355333]: /images/20221123/7e39f944f3bb4b398d4037e184d4d061.png
[image-20200608154703064]: /images/20221123/065979b277354806903a552f7076e84f.png
[image-20200608155442788]: /images/20221123/d37ec2ce26f94cc4bdf5d24939308a4c.png
[image-20200919163202427]: /images/20221123/eb5c44dca9184468bec6eb509af31f63.png
[image-20200608171939836]: /images/20221123/9a4dbec57d0e4350bd07ee0abd5fdf6f.png
[image-20200710112024033]: /images/20221123/d169d046777e47dba3b89d6530aee141.png
[image-20200608173158602]: /images/20221123/8db5348091164872be752df10564239e.png
[image-20200608173318315]: /images/20221123/f73e1878639c40c396928ed2991878fd.png
[image-20200608173530150]: /images/20221123/f5dcd25ea1d348cb861875439ecc3559.png
[image-20200608175225956]: /images/20221123/1ed75859a8fc4d3588fd8b1efaec6e30.png
[image-20200608181339215]: /images/20221123/ac30053f838e4467aa3f1a8f3288784b.png
[image-20200608182548409]: /images/20221123/54b633bf1b5a4415b286faa583b4dc2b.png
[image-20200710113622172]: /images/20221123/b45733d7b3974536b7286f72332444a9.png
[image-20200919164331004]: /images/20221123/9af8d2be95b54fc99c0ec506ff350cb8.png
[image-20200919164519971]: /images/20221123/dc65952b64d841e3b37ee854dd910f83.png
[image-20200919164523345]: /images/20221123/eecebc60f8c640909c884dd4ae6c9594.png
[image-20200608230402474]: /images/20221123/03a6bb993137444db23d3ea9dc79cc4c.png
[image-20200608230555172]: /images/20221123/24fed5c718b34ef090e909a745692a39.png
[image-20200608230755031]: /images/20221123/a0a31b2834374277aeaf7e11f427cc05.png
[image-20200608230941739]: /images/20221123/8bd21f33ed8f42a4a9f7c5206e19d92e.png
[image-20200608231849493]: /images/20221123/73d081357f154fe58fc73148e71fe85e.png
[image-20200609093507726]: /images/20221123/440f0323479540d79ee61a1c2a2b95d9.png
[image-20200710114328152]: /images/20221123/23d57c6cc8c24b2586857a933d3c852b.png
[image-20200919165128794]: /images/20221123/7596d953f5234b38896c1fde26874d36.png
[image-20200609100637560]: /images/20221123/16d5a4f987454f1289404ed34fcaac6c.png
[image-20200609102303268]: /images/20221123/f70cba35265443bc94b0216d49119ff6.png
[image-20200609103032271]: /images/20221123/1a7634afdfd4428a8491af05468ef5ee.png
[image-20200919165356741]: /images/20221123/bfe586a55cc1413886eb1f03d69f63a8.png
[image-20200919165435229]: /images/20221123/3f18822f50ca4e52af363cbe1dc006bb.png
[image-20200609105258060]: /images/20221123/97d77017619b4e418f7a9c2d22f87985.png
[image-20200609105453869]: /images/20221123/c2e30434d9514689994008380dd852a4.png
[image-20200609111020486]: /images/20221123/26e50743dc834ea198df4b3cf99ff729.png
[image-20200609112822092]: /images/20221123/f48c5024c2f54303b3046f6a61b9f6c0.png
[image-20200609111504467]: /images/20221123/ef736bcee91c4716a02ff495637febaa.png
[image-20200609112618199]: /images/20221123/2c7c4732161741688d2cfa381a74c1a9.png
[image-20200609113651132]: /images/20221123/7ef8bc652a15497bbd6a6be691691da5.png
[image-20200609180753696]: /images/20221123/e35316e6fdfe4c9c99ca068a2fbdbd18.png
[image-20200609180618821]: /images/20221123/3f1074e6d1474ea5a33b329553ecd8d1.png
[image-20200609181840684]: /images/20221123/6894b7dd9df1497abc61049d162ebe79.png
[image-20200609182115665]: /images/20221123/c4c27af56dc94c4d8fabfd6b45c659c4.png
[image-20200609182320143]: /images/20221123/7ea9494ff63847e3ad8db1257d59f90c.png
[image-20200919181539018]: /images/20221123/0578607689c64e5c98223bf087c8aa62.png
[image-20200609184347443]: /images/20221123/33158c4fbf77495b877f7820bc891aa9.png
[image-20200919170939478]: /images/20221123/80710659346f47d681914b405a06abb5.png
[image-20200609221458560]: /images/20221123/899e1111be9b4839a5c91ca34a8cc0a2.png
[image-20200609221626770]: /images/20221123/d640f8ee6c864744974cc00243c930c9.png
[image-20200609222642552]: /images/20221123/7c2e207d5c5a418487dc7f2af2fe8615.png
[image-20200609225433627]: /images/20221123/ef8534c660c547d79aa1b41556228bf3.png
[image-20200609231310652]: /images/20221123/5ccf9a4b90344581be2c9733976900a6.png
[image-20200609231121639]: /images/20221123/0651058304a54402a623ecb048ec804f.png
[image-20200609232521255]: /images/20221123/671db8c89f86423faff0e3454072ab2c.png
[image-20200610112230801]: /images/20221123/9d1359cd05894150855b04518cd79dba.png
[image-20200610113418571]: /images/20221123/f32eccdf1d4042ebb86955a6f0e30cc4.png
[image-20200610113306416]: /images/20221123/a46c88eb03fe4eb8bda6b8ad4808cff6.png
[image-20200610113015511]: /images/20221123/3669aaf1acf94de0894ca717cf6c645b.png
[image-20200919172116511]: /images/20221123/2d85ef9e80da473aa78bc8fd9e7e1499.png
[image-20200919181054979]: /images/20221123/956f9ee8fbc6444db9ba9668b391f69d.png
[image-20200610121801939]: /images/20221123/538d905b88bd44469e3a59da8b085d36.png
[image-20200610122006003]: /images/20221123/db6fd42b01cd40d78afa0361cfdd551f.png
[image-20200610134859465]: /images/20221123/d7e364a9b43c4591b5c6d8cf72bbe4d0.png
[image-20200610181314875]: /images/20221123/0e87f972a3094e7ead2983992ef5ea4c.png
[image-20200610181747470]: /images/20221123/2ab80c242c6c44dc8585cf4686e19320.png
[image-20200610181902876]: /images/20221123/dfb6801a1ec34cdfb007f3b126049905.png
[image-20200610182009159]: /images/20221123/83b1fa58d34640908475edad759a06b0.png
[image-20200610182256614]: /images/20221123/b957434f0f9649629b4a8199132beaca.png