尚筹网 -- 1️⃣后台 -- 环境搭建

         本篇文章记录尚硅谷官网的尚筹网开发过程以及遇到的问题！

01 - 简介

        从单一架构(后台)到分布式架构(前台)。

项目架构：

前置要求：
        ✔Spring
        ✔SpringMVC
        ✔Mybatis
        ✔Maven

小结：
        聚焦于目标，分析实现的思路，拆解大目标；分析思路，画出流程图；将流程图翻译为注释，对照注释编写代码。

02 - 项目介绍

众筹模式
        众筹系统，这个在网络上不断被搜索的热门词汇，从最初的陌生到熟悉，到现在不断被更新，出现各种不同的众筹模式，不得不承认众筹系统的出现，是对传统行业的一种冲击，对传统金融模式的一种冲击，同时对于年轻的一代而言，这也是一个契机、一个机遇、一个开创自己事业的平台，正是因为这些利好，让更多的人愿意去运用众筹系统，作为其项目发展孵化的平台。

业务模块

瀑布模型
        ✔把软件产品看成是一个工业化的标准品，以工厂生产产品的流水线思路来进行开发。

敏捷开发
        ✔敏捷开发是把一个软件产品看成是一个生物，每一个小功能的细微的迭代就好像是生物逐渐在进化一样。
        技术角度
                加速了根据需求开发出来可以运行的代码这个过程。
                需求→原型→编码
        商业角度
                加速了用户体验新功能的这个过程。“小步快跑”，让每一个功能都做尽量小的修改，但是加大更新的频率。

03 - 后台 - 环境搭建

1.创建工程

项目架构图

创建parent Maven工程，打包方式为pom；后面的为Maven 模块！Web工程打包方式war；其余打包方式为jar

                                                                       解决项目模块之间的依赖

2.创建数据库和数据可以表

        满足范式要求，但允许局部变通， 允许冗余字段，免去关联查询

        第一范式：原子性
        第二范式：每个字段都和主键 完整 相关，而不是仅和主键部分相关（主要针对联合主键而言），解决办法就是两张表要通过外键关联，不保存冗余字段
        第三范式：非主键字段和主键字段 直接 相关，不允许简介相关

CREATE DATABASE `project_crowd` CHARACTER SET utf8;

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.基于Maven的MyBatis逆向工程

        1.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 https://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>


	<!-- 依赖 MyBatis 核心包 -->
	<dependencies>
		<dependency>
			<groupId>org.mybatis</groupId>
			<artifactId>mybatis</artifactId>
			<version>3.2.8</version>
		</dependency>
	</dependencies>


	<!-- 控制 Maven 在构建过程中相关配置 -->
	<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>8.0.21</version>
					</dependency>
				</dependencies>
			</plugin>
		</plugins>
	</build>
</project>

        2.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>

	<!-- mybatis-generator:generate -->
	<context id="atguiguTables" targetRuntime="MyBatis3">
		<commentGenerator>

			<!-- 是否去除自动生成的注释 true:是;false:否 -->
			<property name="suppressAllComments" value="true" />
		</commentGenerator>

		<!--数据库连接的信息：驱动类、连接地址、用户名、密码 -->
		<jdbcConnection driverClass="com.mysql.cj.jdbc.Driver"
			connectionURL="jdbc:mysql://localhost:3306/project_crowd?useSSL=false&amp;serverTimezone=UTC"
			userId="root" password="123456">
		</jdbcConnection>

		<!-- 默认 false，把 JDBC DECIMAL 和 NUMERIC 类型解析为 Integer，为 true 时把 JDBC DECIMAL和 
			NUMERIC 类型解析为 java.math.BigDecimal -->
		<javaTypeResolver>
			<property name="forceBigDecimals" value="false" />
		</javaTypeResolver>

		<!-- targetProject:生成 Entity 类的路径 -->
		<javaModelGenerator targetProject=".\src\main\java"
			targetPackage="com.atguigu.crowd.entity">

			<!-- enableSubPackages:是否让 schema 作为包的后缀 -->
			<property name="enableSubPackages" value="false" />

			<!-- 从数据库返回的值被清理前后的空格 -->
			<property name="trimStrings" value="true" />
		</javaModelGenerator>

		<!-- targetProject:XxxMapper.xml 映射文件生成的路径 -->
		<sqlMapGenerator targetProject=".\src\main\java"
			targetPackage="com.atguigu.crowd.mapper">

			<!-- enableSubPackages:是否让 schema 作为包的后缀 -->
			<property name="enableSubPackages" value="false" />
		</sqlMapGenerator>

		<!-- targetPackage：Mapper 接口生成的位置 -->
		<javaClientGenerator type="XMLMAPPER"
			targetProject=".\src\main\java"
			targetPackage="com.atguigu.crowd.mapper">

			<!-- enableSubPackages:是否让 schema 作为包的后缀 -->
			<property name="enableSubPackages" value="false" />
		</javaClientGenerator>

		<!-- 数据库表名字和我们的 entity 类对应的映射指定 -->
		<table tableName="t_admin" domainObjectName="Admin" />
	</context>
</generatorConfiguration>

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

mybatis-generator:generat

        3.逆向工程生成的资源各归各位
        WebUI 工程将来在 Tomcat 上运行时，现在 resources 目录下的资源会直接放在WEB-INF/classes 目录（也就是类路径）下，所以放在 resources 目录下运行的时候更容易找到

4.父工程依赖管理

        版本说明

<properties>
		<!-- 声明属性，对 Spring 的版本进行统一管理 -->
		<atguigu.spring.version>4.3.20.RELEASE</atguigu.spring.version>
		<!-- 声明属性，对 SpringSecurity 的版本进行统一管理 -->
		<atguigu.spring.security.version>4.2.10.RELEASE
		</atguigu.spring.security.version>
	</properties>

        依赖管理

<project xmlns="http://maven.apache.org/POM/4.0.0"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>com.atguigu.com</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>

	<properties>
		<!-- 声明属性，对 Spring 的版本进行统一管理 -->
		<atguigu.spring.version>4.3.20.RELEASE</atguigu.spring.version>
		<!-- 声明属性，对 SpringSecurity 的版本进行统一管理 -->
		<atguigu.spring.security.version>4.2.10.RELEASE
		</atguigu.spring.security.version>
	</properties>

	<dependencyManagement>
		<dependencies>

			<!-- Spring 依赖 -->

			<!-- https://mvnrepository.com/artifact/org.springframework/spring-orm -->
			<dependency>
				<groupId>org.springframework</groupId>
				<artifactId>spring-orm</artifactId>
				<version>${atguigu.spring.version}</version>
			</dependency>

			<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
			<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>

			<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
			<dependency>
				<groupId>org.aspectj</groupId>
				<artifactId>aspectjweaver</artifactId>
				<version>1.9.2</version>
			</dependency>

			<!-- https://mvnrepository.com/artifact/cglib/cglib -->
			<dependency>
				<groupId>cglib</groupId>
				<artifactId>cglib</artifactId>
				<version>2.2</version>
			</dependency>

			<!-- 数据库依赖 --> 
			<!-- MySQL 驱动 -->
			<dependency>
				<groupId>mysql</groupId>
				<artifactId>mysql-connector-java</artifactId>
				<version>8.0.21</version>
			</dependency>

			<!-- 数据源 -->
			<dependency>
				<groupId>com.alibaba</groupId>
				<artifactId>druid</artifactId>
				<version>1.0.31</version>
			</dependency>

			<!-- MyBatis -->
			<dependency>
				<groupId>org.mybatis</groupId>
				<artifactId>mybatis</artifactId>
				<version>3.2.8</version>
			</dependency>

			<!-- MyBatis 与 Spring 整合 -->
			<dependency>
				<groupId>org.mybatis</groupId>
				<artifactId>mybatis-spring</artifactId>
				<version>1.2.2</version>
			</dependency>

			<!-- MyBatis 分页插件 -->
			<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>

			<!-- Spring 进行 JSON 数据转换依赖 -->
			<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>

			<!-- JSTL 标签库 -->
			<dependency>
				<groupId>jstl</groupId>
				<artifactId>jstl</artifactId>
				<version>1.2</version>
			</dependency>

			<!-- junit 测试 -->
			<dependency>
				<groupId>junit</groupId>
				<artifactId>junit</artifactId>
				<version>4.12</version>
				<scope>test</scope>
			</dependency>

			<!-- 引入 Servlet 容器中相关依赖 -->
			<dependency>
				<groupId>javax.servlet</groupId>
				<artifactId>servlet-api</artifactId>
				<version>2.5</version>
				<scope>provided</scope>
			</dependency>

			<!-- JSP 页面使用的依赖 -->
			<dependency>
				<groupId>javax.servlet.jsp</groupId>
				<artifactId>jsp-api</artifactId>
				<version>2.1.3-b06</version>
				<scope>provided</scope>
			</dependency>

			<!-- https://mvnrepository.com/artifact/com.google.code.gson/gson -->
			<dependency>
				<groupId>com.google.code.gson</groupId>
				<artifactId>gson</artifactId>
				<version>2.8.5</version>
			</dependency>

			<!-- SpringSecurity 对 Web 应用进行权限管理 -->
			<dependency>
				<groupId>org.springframework.security</groupId>
				<artifactId>spring-security-web</artifactId>
				<version>4.2.10.RELEASE</version>
			</dependency>

			<!-- SpringSecurity 配置 -->
			<dependency>
				<groupId>org.springframework.security</groupId>
				<artifactId>spring-security-config</artifactId>
				<version>4.2.10.RELEASE</version>
			</dependency>

			<!-- SpringSecurity 标签库 -->
			<dependency>
				<groupId>org.springframework.security</groupId>
				<artifactId>spring-security-taglibs</artifactId>
				<version>4.2.10.RELEASE</version>
			</dependency>
		</dependencies>
	</dependencyManagement>
</project>

        依赖信息来源

5.Spring整合MyBatis

1.目标
        ✔adminMapper 通过 IOC 容器装配到当前组件中后，就可以直接调用它的方法，享受到框架给我们提供的方便

2.思路

3.操作清单
在子工程中加入搭建环境所需要的具体依赖
准备 jdbc.properties
创建 Spring 配置文件专门配置 Spring 和 MyBatis 整合相关
在 Spring 的配置文件中加载 jdbc.properties 属性文件
配置数据源
测试从数据源中获取数据库连接
配置 SqlSessionFactoryBean
        装配数据源
        指定 XxxMapper.xml 配置文件的位置
        指定 MyBatis 全局配置文件的位置（可选）
配置 MapperScannerConfigurer
测试是否可以装配 XxxMapper 接口并通过这个接口操作数据库

4.操作步骤详解
        4.1在子工程中加入搭建环境所需的具体依赖

子工程：选择 component 工程。原因是具体依赖和 component 工程相关。

<!-- Spring 依赖 -->
		<!-- https://mvnrepository.com/artifact/org.springframework/spring-orm -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-orm</artifactId>
		</dependency>
		<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-webmvc</artifactId>
		</dependency>
		<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
		<dependency>
			<groupId>org.aspectj</groupId>
			<artifactId>aspectjweaver</artifactId>
		</dependency>
		<!-- https://mvnrepository.com/artifact/cglib/cglib -->
		<dependency>
			<groupId>cglib</groupId>
			<artifactId>cglib</artifactId>
		</dependency>
		<!-- MySQL 驱动 -->
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
		</dependency>
		<!-- 数据源 -->
		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>druid</artifactId>
		</dependency>
		<!-- MyBatis -->
		<dependency>
			<groupId>org.mybatis</groupId>
			<artifactId>mybatis</artifactId>
		</dependency>
		<!-- MyBatis 与 Spring 整合 -->
		<dependency>
			<groupId>org.mybatis</groupId>
			<artifactId>mybatis-spring</artifactId>
		</dependency>
		<!-- MyBatis 分页插件 -->
		<dependency>
			<groupId>com.github.pagehelper</groupId>
			<artifactId>pagehelper</artifactId>
		</dependency>
		<!-- Spring 进行 JSON 数据转换依赖 -->
		<dependency>
			<groupId>com.fasterxml.jackson.core</groupId>
			<artifactId>jackson-core</artifactId>
		</dependency>
		<dependency>
			<groupId>com.fasterxml.jackson.core</groupId>
			<artifactId>jackson-databind</artifactId>
		</dependency>
		<!-- JSTL 标签库 -->
		<dependency>
			<groupId>jstl</groupId>
			<artifactId>jstl</artifactId>
		</dependency>
		<!-- https://mvnrepository.com/artifact/com.google.code.gson/gson -->
		<dependency>
			<groupId>com.google.code.gson</groupId>
			<artifactId>gson</artifactId>
		</dependency>

        4.2数据库连接信息

jdbc.properties

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

        4.3mybatis-config.xml

<?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>

        4.4创建spring-persist-mybatis.xml

        4.5Spring具体配置：第一步 配置数据源

在 spring-persist-mybatis.xml 配置文件进行配置
<!-- 加载 jdbc.properties -->
<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}"/>
<!-- 目标数据库的 URL 地址 -->
<property name="url" value="${jdbc.url}"/>
<!-- 数据库驱动全类名 -->
<property name="driverClassName" value="${jdbc.driver}"/>
</bean>

注意：为了能够在webui工程中执行Junit，需要把spring-test和junit依赖转移到webui工程

注意要将测试代码写在Maven工程下的src/test/java目录下面，测试代码！

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

创建 Spring 的 Junit 测试类
// 指定 Spring 给 Junit 提供的运行器类
@RunWith(SpringJUnit4ClassRunner.class)
// 加载 Spring 配置文件的注解
@ContextConfiguration(locations = {
    
    "classpath:spring-persist-mybatis.xml"})
public class CrowdSpringTest {
    
    
@Autowired
private DataSource dataSource;
@Test
public void testDataSource() throws SQLException {
    
    
// 1.通过数据源对象获取数据源连接
Connection connection = dataSource.getConnection();
// 2.打印数据库连接
System.out.println(connection);
}
}

        4.6Spring具体配置：第二步 配置SqlSessionFactoryBean

<!-- 配置 SqlSessionFactoryBean -->
<bean id="sqlSessionFactoryBean" class="org.mybatis.spring.SqlSessionFactoryBean">
<!-- 装配数据源 -->
<property name="dataSource" ref="dataSource"/>
<!-- 指定 MyBatis 全局配置文件位置 -->
<property name="configLocation" value="classpath:mybatis-config.xml"/>
<!-- 指定 Mapper 配置文件位置 -->
<property name="mapperLocations" value="classpath:mybatis/mapper/*Mapper.xml"/>
</bean>

        4.7Spring具体配置：第三步 配置MapperScannerConfigurer

<!-- 配置 MapperScannerConfigurer -->
<!-- 把 MyBatis 创建的 Mapper 接口类型的代理对象扫描到 IOC 容器中 -->
<bean id="mapperScannerConfigurer" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
<!-- 使用 basePackage 属性指定 Mapper 接口所在包 -->
<property name="basePackage" value="com.atguigu.crowd.mapper"/>
</bean>

6.日志系统

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

2.技术选型
        2.1总体介绍

        2.2不同日志系统的整合

3.具体操作
        3.1初始状态
Spring 使用 commons-logging 日志包。打印的日志是下面这样的。不用细看，截图放在这是为了和后面日志打印的情况对比。

        3.2加入slf4j+logback
依赖信息是：

<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>

        3.3我们主动打印的日志

把查询到的 Admin 对象以日志的方式打印出来，代码如下：

Admin admin = adminMapper.selectByPrimaryKey(1511);
// 获取日志记录对象
Logger logger = LoggerFactory.getLogger(CrowdTest.class);
// 按照 Debug 级别打印日志
logger.debug(admin.toString());

※使用日志打印信息和使用 sysout 打印信息的区别：sysout 如果不删除，那么执行到这里必然会打印；如果使用日志方式打印，可以通过日志级别控制信息是否打印。

        3.4更换框架的日志系统
第一步：排除commons-logging

然后保存 pom.xml

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

第二步：加入转换包

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

打印效果局部：

        3.5logback配置文件
logback 工作时的具体细节可以通过 logback.xml 来配置。

<?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>
	<!-- 设置全局日志级别。日志级别按顺序分别是：DEBUG、INFO、WARN、ERROR -->
	<!-- 指定任何一个日志级别都只打印当前级别和后面级别的日志。 -->
	<root level="INFO">
		<!-- 指定打印日志的 appender，这里通过“STDOUT”引用了前面配置的 appender -->
		<appender-ref ref="STDOUT" />
	</root>
	<!-- 根据特殊需求指定局部日志级别 -->
	<logger name="com.atguigu.crowd.mapper" level="DEBUG" />
</configuration>

7.声明式事务

1.目标
        从事务角度：一个事务方法中包含的多个数据库操作，要么一起提交、要么一起回滚。也就是说事务方法中的多个数据库操作，有任何一个失败，整个事务全部回滚。
        从声明式角度：由 Spring 来全面接管数据库事务。用声明式代替编程式。

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();	
	}
}

2.思路

3.操作
        3.1加入AOP依赖包
/atcrowdfunding03-admin-component

<!-- AOP 所需依赖 -->
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
</dependency>
<!-- AOP 所需依赖 -->
<dependency>
<groupId>cglib</groupId>
<artifactId>cglib</artifactId>
</dependency>

        3.2第一步：创建Spring配置文件

        3.3第二步：配置自动扫描

<!-- 配置自动扫描的包：主要是为了把Service扫描到IOC容器中 -->
	<context:component-scan
		base-package="com.atguigu.crowd.service" />

        3.4第三步：配置事务管理器

<!-- 配置事务管理器 -->
	<bean id="txManager"
		class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<!-- 装配数据源 -->
		<property name="dataSource" ref="dataSource" />

	</bean>

        3.5第四步：配置AOP

<!-- 配置事务切面 -->
	<aop:config>
		<!-- 考虑到后面我们整合SpringSecurity，避免把UserDetailsService加入事务控制，让切入点表达式定位到ServiceImpl -->
		<aop:pointcut
			expression="execution(* *..*ServiceImpl.*(..))" id="txPointcut" />

		<!-- 将切入点表达式和事务通知关联起来 -->
		<aop:advisor advice-ref="txAdvice"
			pointcut-ref="txPointcut" />
	</aop:config>

        3.6第五步：配置事务属性

<!-- 配置事务通知 -->
	<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" />

			<!-- 增删改方法：配置事务传播行为、回滚异常 -->
			<!-- propagation属性： REQUIRED：默认值，表示当前方法必须工作在事务中，如果当前线程上没有已经开启的事务，则自己开新事务。如果已经有了，那么就使用这个已有的事务。 
				顾虑：用别人的事务有可能“被”回滚。 REQUIRES_NEW：建议使用的值，表示不管当前线程上有没有事务，都要自己开事务，在自己的事务中运行。 
				好处：不会受到其他事务回滚的影响。 -->
			<!-- rollback-for属性：配置事务方法针对什么样的异常回滚 默认：运行时异常回滚 建议：编译时异常和运行时异常都回滚 -->
			<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>

在基于XML的声明式事务中，事务属性的tx：method是必须配置的，如果某个方法没有配置对应的tx：method，那么事务就对这个方法就不生效！

测试

包名敲错了，导致无法扫描到AdminService将其装入IOC

8.表述层工作机制

1.启动过程
web.xml和Spring配置文件关系
目标1：handler中装配Service
目标2：页面能够访问到handler

2.访问过程
页面 -> handler(@RequestMapping) -> Service -> Mapper -> 数据库

9.表述层环境搭建

1.加入依赖
使用 SpringMVC 环境引入 spring-webmvc 依赖即可，同时可以把 spring-context 依赖去掉，因为根据依赖的传递性，spring-webmvc 会依赖 spring-context。

<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
</dependency>

2.web.xml配置
        2.1 ContextLoaderListener
作用：加载 Spring 的配置文件，根据 Spring 的配置文件初始化 IOC 容器。

<!-- 配置 ContextLoaderListener 加载 Spring 配置文件 -->
<!-- needed for ContextLoaderListener -->
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:spring-persist-*.xml</param-value>
</context-param>
<!-- Bootstraps the root web application context before servlet initialization -->
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>

        2.2 CharacterEncodingFilter
解决 POST 请求的字符乱码问题。需要注意的是：在 web.xml 中存在多个 Filter时，让这个 Filter 作为过滤器链中的第一个 Filter。
request.setCharacterEncoding(encoding) 要 求 必 须 在 所 有request.getParameter(xxx)操作前面
response.setCharacterEncoding(encoding)要求必须在所有 response.getWriter()操作前面
不满足这个顺序要求字符集设定无法生效

<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执行的顺序要在所有其他Filter前面 -->
	<!-- 原因如下： -->
	<!-- request.setCharacterEncoding(encoding)必须在request.getParameter()前面 -->
	<!-- response.setCharacterEncoding(encoding)必须在response.getWriter()前面 -->
	<filter-mapping>
		<filter-name>CharacterEncodingFilter</filter-name>
		<url-pattern>/*</url-pattern>
	</filter-mapping>

        2.3 HiddenHttpMethodFilter
遵循 RESTFUL 风格将 POST 请求转换为 PUT 请求、DELETE 请求时使用。
省略不配。
        2.4 DispatcherServlet
基本配置

<!-- The front controller of this Spring Web application, responsible for 
		handling all application requests -->
	<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>
		<!-- Servlet默认生命周期中，创建对象是在第一次接收到请求时 -->
		<!-- 而DispatcherServlet创建对象后有大量的“框架初始化”工作，不适合在第一次请求时来做 -->
		<!-- 设置load-on-startup就是为了让DispatcherServlet在Web应用启动时创建对象、初始化 -->
		<load-on-startup>1</load-on-startup>
	</servlet>

	<!-- Map all requests to the DispatcherServlet for handling -->
	<servlet-mapping>
		<servlet-name>springDispatcherServlet</servlet-name>
		<!-- url-pattern配置方式一：/表示拦截所有请求 -->
		<!-- <url-pattern>/</url-pattern> -->

		<!-- url-pattern配置方式二：配置请求扩展名 -->
		<!-- 优点1：xxx.css、xxx.js、xxx.png等等静态资源完全不经过SpringMVC，不需要特殊处理 -->
		<!-- 优点2：可以实现伪静态效果。表面上看起来是访问一个HTML文件这样的静态资源，但是实际上是经过Java代码运算的结果。 -->
		<!-- 伪静态作用1：给黑客入侵增加难度。 -->
		<!-- 伪静态作用2：有利于SEO优化（让百度、谷歌这样的搜索引擎更容易找到我们项目）。 -->
		<!-- 缺点：不符合RESTFul风格 -->
		<url-pattern>*.html</url-pattern>

		<!-- 为什么要另外再配置json扩展名呢？ -->
		<!-- 如果一个Ajax请求扩展名是html，但是实际服务器给浏览器返回的是json数据，二者就不匹配了，会出现406错误。 -->
		<!-- 为了让Ajax请求能够顺利拿到JSON格式的响应数据，我们另外配置json扩展名 -->
		<url-pattern>*.json</url-pattern>
	</servlet-mapping>

3.请求扩展名
        3.1 *.html扩展名
●举例
http://localhost:8080/atcrowdfunding02-admin-webui/save/emp.html
● 作用：伪静态
表面上看起来是一个访问静态资源的请求，但是实际上是由 SpringMVC交给 handler 来处理的动态资源。
✔ 好处 1：有利于 SEO 优化
让搜索引擎更容易找到我们的网站，有利于网站的推广
✔ 好处 2：隐藏后端技术实现细节
给黑客入侵系统增加难度
✔ 好处 3：自动解决静态资源访问问题
访问 a.png 本身不符合*.html 这个 url-pattern，和 SpringMVC 完全没有关系，当前请求由 Tomcat 处理。

如 果 url-pattern 映 射 了 “ / ”， 那 么 SpringMVC 中 还 需 要 配 置DefaultServletHandler。
● 缺陷：不符合 RESTFUL 风格

        3.2 *.json扩展名
提出问题

描述问题
请求扩展名 http://localhost:8080/extra01-ajax/get/emp/by/ajax.html服务器端打算返回的数据：JSON 格式

二者不匹配！！！

分析问题
请求扩展名和响应体的数据格式不匹配！！！

解决问题
让请求扩展名和预计的响应体数据格式一致。
http://localhost:8080/extra01-ajax/get/emp/by/ajax.json

同时让 SpringMVC 在映射*.html 扩展名之外再映射*.映射json扩展名
扩展名，不然会返回 404

<!-- Map all requests to the DispatcherServlet for handling -->
<servlet-mapping>
<servlet-name>springDispatcherServlet</servlet-name>
<url-pattern>*.html</url-pattern>
<url-pattern>*.json</url-pattern>
</servlet-mapping>

4.spring-web-mvc.xml配置
        4.1导入名称空间
context
mvc

        4.2 创建 SpringMVC 扫描的包
com.atguigu.crowd.mvc

        4.3 具体配置

<!-- 配置自动扫描的包 -->
<context:component-scan base-package="com.atguigu.crowd.mvc"/>
<!-- 配置视图解析器 -->
<!-- 拼接公式→前缀+逻辑视图+后缀=物理视图 -->
<!-- @RequestMapping("/xxx/xxx")
public String xxx() {
// 这个返回值就是逻辑视图
return "target";
}
物理视图是一个可以直接转发过去的地址
物理视图："/WEB-INF/"+"target"+".jsp" 转发路径："/WEB-INF/target.jsp"
-->
<bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<!-- 前缀：附加到逻辑视图名称前 -->
<property name="prefix" value="/WEB-INF/"/>
<!-- 后缀：附加到逻辑视图名称后 -->
<property name="suffix" value=".jsp"/>
</bean>
<!-- 启用注解驱动 -->
<mvc:annotation-driven/>

5.页面上的base标签
        5.1 加入依赖

<!-- 引入 Servlet 容器中相关依赖 -->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>servlet-api</artifactId>
<scope>provided</scope>
</dependency>
<!-- JSP 页面使用的依赖 -->
<dependency>
<groupId>javax.servlet.jsp</groupId>
<artifactId>jsp-api</artifactId>
<scope>provided</scope>
</dependency>

        5.2 作用
将页面上路径中的${pageContext.request.contextPath} 部分提取到页面开头
        5.3 写法

<base
href="http://${pageContext.request.serverName }:${pageContext.request.serverPort }${page
Context.request.contextPath }/"/>

        5.4 需要注意的点
● base 标签必须写在 head 标签内部
● base 标签必须在所有“带具体路径”的标签的前面
● serverName 部分 EL 表达式和 serverPort 部分 EL 表达式之间必须写“:”
● serverPort 部分 EL 表达式和 contextPath 部分 EL 表达式之间绝对不能写“/”
        ✔ 原因：contextPath 部分 EL 表达式本身就是“/”开头
        ✔ 如果多写一个“/”会干扰 Cookie 的工作机制

●端口号前面的冒号不能省略
●contextPath前面不能写“/”
●contextPath后面必须写“/”
●页面上所有参照base标签的标签的路径都不能以“/”开头

6.初步测试
        6.1 创建 Handler 类

        6.2 编写 handler 方法

@Controller
public class TestHandler {
    
    

	@Autowired
	private AdminService adminService;

	@RequestMapping("/test/ssm.html")
	public String testSsm(ModelMap modelMap) {
    
    
		List<Admin> adminLiat = adminService.getAll();

		modelMap.addAttribute("adminList", adminLiat);
		return "target";
	}
}

        6.3 创建目标 JSP 页面（视图）

<%@ 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>Success</h1>

	${
    
    requestScope.adminList }

</body>
</html>

10.SpringMVC环境下的Ajax请求

1.建立意识
前端发送过来，后端要处理的请求有两种：
        普通请求 ：后端处理完成后返回页面 ，浏览器使用使用页面替换整个窗口中的内容
        Ajax 请求 ：后端处理完成后通常返回 JSON 数据，jQuery 代码使用 JSON 数据对页面局部更新
2.测试
        2.1 加入依赖

@ResponseBody和@RequestBody要想正常工作必须有jackson的支持，请确认当前环境引入了如下依赖：

<!-- Spring 进行 JSON 数据转换依赖 -->
			<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>

同时必须配置了mvc:annotation-driven

        2.2 加入 jQuery

<script type="text/javascript" src="jquery/jquery-2.1.1.min.js"></script>

3.@ResponseBody 注解
        3.1作用
让 handler 方法的返回值本身就是当前请求的响应数据。不再参考视图处理器中配置的前后缀信息。

@Controller
public class TestHandler {
    
    
@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";
	}
}

        3.2注意
✔ 开启 SpringMVC 的注解驱动
<mvc:annotation-driven/>
✔ 必须有 jackson 依赖
jackson-core
jackson-databind
✔ 扩展名需要和实际返回的数据格式一致
响应体返回 JSON
请求扩展名 *.json

web.xml 中 DispatcherServlet 必须映射 *.json 扩展名

4@RequestBody 注解
        4.1场景设定
jQuery 通过 Ajax 请求给服务器端发送一个数组：[5,8,12]
        4.2尝试方案一
✔ 前端发送数据

$.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);
				}
			});

✔ 浏览器开发者工具看到的请求体

jQuery 私自在请求参数名字后面附加了“[]”
✔ 后端接收数据

@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";
	}

这里一定要带上多出来的方括号！！！
结论：不建议采用这个方案！！！

        4.3尝试方案二
✔ 前端发送数据

$.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);
				}
			});

✔ 浏览器开发者工具看到的请求体

✔后端接收数据

@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";
	}

结论：这个方案不成立！

        4.4尝试方案三
✔ 前端发送数据

// 准备好要发送到服务器端的数组
			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);
				}
			});

浏览器开发者工具看到的请求体

✔后端接收数据

@ResponseBody
	@RequestMapping("/send/array/three.html")
	public String testReceiveArrayThree(@RequestBody List<Integer> array) {
    
    
		
		for (Integer number : array) {
    
    
			logger.info("number="+number);
		}
		
		return "success";
	}
}

结论：建议使用的方案！！！
        4.5需要注意的点
✔ 前端
✔ 首先准备好要发送的 JSON 数据
✔ JSON 对象
✔ JSON 数组
✔ 将 JSON 对象或 JSON 数组转换为 JSON 字符串
var arrayStr = JSON.stringify(array);
✔ 将 JSON 字符串直接赋值给 data 属性
“data”:arrayStr
✔ 必须要设置 contentType
“contentType”:“application/json;charset=UTF-8”
✔ 后端
✔ 加入 jackson 依赖
✔ 开启注解驱动
✔ 使用注解

✔ 浏览器开发者工具中看到的请求体

后端接收数据

	private Logger logger = LoggerFactory.getLogger(TestHandler.class);

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

        4.7小结
@RequestBody 使用的场景：传统发送请求参数方式不方便发送的数据，使用JSON 请求体的方式发送。特别是要发送复杂对象的时候。

5对比

6统一返回数据格式

/**
 * 统一整个项目中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;
	}

}

11.异常映射

03，04都需要加入Servelt依赖，没有继承父工程的04需要自己声明版本！
1.作用
使用异常映射机制将整个项目的异常和错误提示进行统一管理
✔ 抛出异常
✔ 显示异常信息
✔ 普通请求：在页面上显示异常信息
✔ Ajax 请求：返回 JSON 数据
2.异常映射的工作机制


注意：SpringMVC提供了基于XML和基于注解两种异常映射机制

3.基于注解方式，判断请求类型的工具方法

3.1判断依据

3.2创建工具类

加入依赖

<dependencies>
		<!-- 引入 Servlet 容器中相关依赖 -->
		<dependency>
			<groupId>javax.servlet</groupId>
			<artifactId>servlet-api</artifactId>
			<version>2.5</version>
			<scope>provided</scope>
		</dependency>
	</dependencies>

3.3代码

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"));
	}

}

4异常映射实现方式
4.1基于 XML
✔ spring-web-mvc.xml 文件中的配置

<!-- 配置基于XML的异常映射 -->
	<bean id="simpleMappingExceptionResolver"
		class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">
		<!-- 配置异常类型和具体视图页面的对应关系 -->
		<property name="exceptionMappings">
			<props>
				<!-- key属性指定异常全类名 -->
				<!-- 标签体中写对应的视图（这个值要拼前后缀得到具体路径） -->
				<prop key="java.lang.Exception">system-error</prop>
			</props>
		</property>
	</bean>

✔ 新建 system-error.jsp 页面
✔ 位置

代码

<%@ 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>
	
	<!-- 从请求域取出Exception对象，再进一步访问message属性就能够显示错误消息 -->
	${
    
    requestScope.exception.message }

</body>
</html>

4.2基于注解
✔ 加入 gson 依赖

<!-- 处理 JSON 数据 -->

<dependency>
<groupId>com.google.code.gson</groupId>
<artifactId>gson</artifactId>
<version>2.8.5</version>
</dependency>

✔ 创建异常处理器类

// @ControllerAdvice表示当前类是一个基于注解的异常处理器类
@ControllerAdvice
public class CrowdExceptionResolver {
    
    
	
	@ExceptionHandler(value = ArithmeticException.class)
	public ModelAndView resolveMathException(
				ArithmeticException 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("system-error");
		
		// 11.返回ModelAndView对象
		return modelAndView;
	}
	
	// @ExceptionHandler将一个具体的异常类型和一个方法关联起来
	@ExceptionHandler(value = NullPointerException.class)
	public ModelAndView resolveNullPointerException(
			
			// 实际捕获到的异常类型
			NullPointerException 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("system-error");
		
		// 11.返回ModelAndView对象
		return modelAndView;
	}

}

12.以常量管理属性名和异常消息

public class CrowdConstant {
    
    
	
	public static final String MESSAGE_LOGIN_FAILED = "抱歉！账号密码错误！请重新输入！";
	public static final String MESSAGE_LOGIN_ACCT_ALREADY_IN_USE = "抱歉！这个账号已经被使用了！";
	public static final String MESSAGE_ACCESS_FORBIDEN = "请登录以后再访问！";
	public static final String MESSAGE_STRING_INVALIDATE = "字符串不合法！请不要传入空字符串！";
	public static final String MESSAGE_SYSTEM_ERROR_LOGIN_NOT_UNIQUE = "系统错误：登录账号不唯一！";
	
	public static final String ATTR_NAME_EXCEPTION = "exception";
	public static final String ATTR_NAME_LOGIN_ADMIN = "loginAdmin";
	public static final String ATTR_NAME_PAGE_INFO = "pageInfo";

}

好处：减少打字错误！！！