- Mybatis的学习
- Mybaits快速入门案例
- Mybatis获取参数的5种方式
- Mybatis查询数据的各种情况
- 自定义映射ResultMap
- 为什么需要自定义ResultMap呢
- 定义并使用一个ResultMap
- ResultMap处理多对一映射的3种方式
- 级联方式
- 使用association处理映射关系
- 使用分布查询处理映射关系
- ResulMap处理一对多映射的2种方式
- 使用collection处理映射关系
- 使用分布查询处理映射关系
- Result小总结
- 动态SQL
- if进行模糊查询
- where配合if进行模糊查询
- trim
- choose、when、otherwise
- foreach（重要）
- sql（片段）
- MyBatis缓存
- 一级缓存
- 二级缓存
- 第三方二级缓存EHCache
- 缓存查询的先后顺序
- MyBatis逆向工程
- 正向工程与逆向工程的区别
- 引入jar包及Maven插件
- 添加generatorConfig.xml配置文件并运行
- MyBatis分页插件
- 在pom.xml文件中引入插件
- 在mybatis全局配置文件中配置
- PageInfo及参数解释
- 使用mybatis过程中出现的问题
- Spring的学习
- Spring的特性及五大功能模块
- SpringIOC容器
- SpringAOP
- SpringMVC的学习
- SpringMVC是什么？
- RequestMapping注解
- 获取请求参数
- 解决获取参数的乱码问题
- 域对象共享数据
- SpringMVC的视图
- RestFul风格
- 处理AJAX请求，使用axiso
- 文件上传与下载
- 拦截器
- 异常处理器
- 使用纯注解的方式代替SpringMVC配置文件和web.xml文件
- 整合SSM的步骤
- 需要思考的问题
- 正式开始整合SSM
Mybatis的学习
Mybaits快速入门案例
Mybatis开发环境搭建
- 下载Mybatis的jar包 或者 使用maven构建工具
- 使用Mybatis最基础需要引入如下jar包
- 连接数据库的驱动
- mybatis的jar包
- log4j日志(不使用mybaits也可以用，但是没有日志)
配置Mybaits的全局配置文件
<?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>
<!-- 引入外部配置文件，从根路径下找 -->
<properties resource="jdbc.properties">
<!-- 配置数据库字段下划线与JAVA实体类的驼峰映射 -->
<settings>
<setting name="mapUnderscoreToCamelCase" value="true">
</setting></settings>
<!-- 配置别名 -->
<typealiases>
<package name="com.codestarts.pojo">
</package></typealiases>
<!-- 配置一个个的环境，其中主要配置了事务管理的方式和数据源 -->
<environments default="development">
<environment id="development">
<!--
配置采用的事务管理方式，JDBC：编程式事务管理，
MANAGER：啥也不干，让容器来管理事务的整个生命周期
-->
<transactionmanager type="JDBC">
<!--
POOLED：采用数据库连接池的方式来获取连接
UNPOOLED：每一个连接都直接通过访问数据库获得
JNDI ：上下文数据源引用（了解）
-->
<datasource type="POOLED">
<property name="driver" value="${driverClassName}">
<property name="url" value="${url}">
<property name="username" value="${username}">
<property name="password" value="${password}">
</property></property></property></property></datasource>
</transactionmanager></environment>
<!-- 可以配置多个，自行选择 -->
<environment id="test">
<transactionmanager type="JDBC">
<datasource type="POOLED">
<property name="driver" value="${driverClassName}">
<property name="url" value="${url}">
<property name="username" value="${username}">
<property name="password" value="${password}">
</property></property></property></property></datasource>
</transactionmanager></environment>
</environments>
<!-- 配置*.xml映射文件-->
<mappers>
<!-- 配置单个的方式mappers/UserMapper.xml代表根路径下的mappers/UserMapper -->
<!--<mapper resource="mappers/UserMapper.xml"></mapper>-->
<!--
配置mapper接口与mapper.xml所在的包，
注意mapper接口和mapper.xml的名字必须一致
注意接口与mapper必须在同一个包下
-->
<package name="com.codestarts.mapper">
</package></mappers>
</properties></configuration>
配置一个Mapper接口文件
public interface UserMapper {
int insert();
}
配置一个Mapper接口对应的xml文件
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.codestarts.mapper.UserMapper">
<insert id="insert">
insert into user(name,gender,age) values('张三','女',15)
</insert>
</mapper>
编写一个测试类
public class SqlSessionTest {
public static void main(String[] args) throws IOException {
// 获取到Mybatis配置文件
InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
// 获取工厂
SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
SqlSessionFactory build = sqlSessionFactoryBuilder.build(is);
// 获得对应的Mapper接口，注意，这里得到的UserMapper是一个动态代理生成的实现类。
SqlSession sqlSession = build.openSession();
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
// 插入一条数据
mapper.insert();
// 提交与关闭
sqlSession.commit();
sqlSession.close();
}
}
目录结构
Mybatis获取参数的5种方式
#{}获取数据与${}获取数据的区别
-
{}相当于之前写JDBC时用的
占位符，使用时传递参数会自动帮忙加上双引号 - ${}则相当于
字符串拼接。
当需要获取的参数列表只有一个参数时
- 在xml文件中可以通过 #{任意标识符}、${任意标识符}的方式获取
当需要获取的参数列表有多个参数时
- 在xml文件中可以通过
#{arg0 | param1}、#{arg1 | param2}或者${arg0 | param1}、${arg1 | param2}
当需要获取的参数列表为一个Map集合时
- 在xml文件中通过Map集合中的键值即可直接获取
#{键值} 或者 ${键值}
当需要获取的参数列表为一个实体类时（掌握）
- 在xml文件中使用#{}或者${}时，直接写属性名即可
- 注意：属性名并不是指实体对象中的一个个成员变量，而是指一个个setter、getter
通过@Param注解的方式获取参数（掌握）
- 在编写Mapper文件的接口时，在参数前加上注解：
@Param("key") - 那么xml文件中就可以通过#{}或者${} 中写上该键值的方式直接获取到
添加日志功能
- 引入日志jar包
<!-- log4j日志 -->
<dependency>
<groupid>log4j</groupid>
<artifactid>log4j</artifactid>
<version>1.2.17</version>
</dependency>
- 在根目录下添加 log4j.xml文件，注意名称不能错
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">
<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">
<appender name="STDOUT" class="org.apache.log4j.ConsoleAppender">
<param name="Encoding" value="UTF-8">
<layout class="org.apache.log4j.PatternLayout">
<param name="ConversionPattern" value="%-5p %d{MM-dd HH:mm:ss,SSS}
%m (%F:%L) \n">
</layout>
</appender>
<logger name="java.sql">
<level value="debug">
</level></logger>
<logger name="org.apache.ibatis">
<level value="info">
</level></logger>
<root>
<level value="debug">
<appender-ref ref="STDOUT">
</appender-ref></level></root>
</log4j:configuration>
Mybatis查询数据的各种情况
返回一个实体类对象和一个实体类对象的集合
- xml文件中的select标签内将resultType写上需要映射的实体类全限定类名即可
- Mapper接口
// 获取一条记录
User selectUserById(@Param("id") Integer id);
// 获取多条记录
List<user> selectList();
</user>
- Mapper.xml文件，比较重要的式这个
resultType
<select id="selectUserById" resulttype="com.codestarts.pojo.User">
select * from user where id = #{id}
</select>
<select id="selectList" resulttype="com.codestarts.pojo.User">
select * from user
</select>
返回单行单列
- Mapper接口
// 获取单行单列记录
Integer selectCount();
- Mapper.xml文件
<select id="selectCount" resulttype="java.lang.Integer">
select count(1) from user
</select>
查询的结果为Map时（2种情况）
返回一个 List<map<string, object>></map<string,>
- Mapper接口如下
List<map<string, object>> selectMap();
</map<string,>
- Mapper.xml如下
<select id="selectMap" resulttype="java.util.Map">
select * from user
</select>
- 查询结果如下
[{gender=女, name=11三, id=1, age=15}, {gender=女, name=张三, id=2, age=15}, {gender=女, name=张三, id=3, age=15}]
返回一个 Map<string, map<string, object>></string,>
- Mapper接口（使用了@MapKey注解，选择查询出的哪个字段作为外层Map的Key）
@MapKey("id")
Map<string, object> selectMap02();
</string,>
- Mapper.xml（跟查询一个List
<select id="selectMap02" resulttype="java.util.Map">
select * from user
</select>
- 查询的结果直接打印
{1={gender=女, name=11三, id=1, age=15}, 2={gender=女, name=张三, id=2, age=15}, 3={gender=女, name=张三, id=3, age=15}}
特殊的Sql执行（有些地方必须使用SQL拼接${}完成）
模糊查询的四种方式
- Mapper接口
// 模糊查询的4种方式
List<user> selectUserLikeName(@Param("name") String name);
List<user> selectUserLikeName01(@Param("name") String name);
List<user> selectUserLikeName02(@Param("name") String name);
List<user> selectUserLikeName03(@Param("name") String name);
</user></user></user></user>
- Mapper.xml文件
<!--
使用这种方式会报错，因为#{name}是个占位符，也就是我们之前JDBC所写的?，那么拼接后就变成了 '%?%'
这个?占位符就被当成了一个字符串解析，因此报错
-->
<select id="selectUserLikeName" resulttype="com.codestarts.pojo.User">
select * from user where name like '%#{name}%'
</select>
<!-- 使用字符串拼接方式 -->
<select id="selectUserLikeName01" resulttype="com.codestarts.pojo.User">
select * from user where name like '%${name}%'
</select>
<!-- 使用concat实现 -->
<select id="selectUserLikeName02" resulttype="com.codestarts.pojo.User">
select * from user where name like concat('%',#{name},'%')
</select>
<!-- 推荐使用~~~ -->
<select id="selectUserLikeName03" resulttype="com.codestarts.pojo.User">
select * from user where name like "%"#{name}"%"
</select>
批量删除
- Mapper接口
int deleteBatch(@Param("ids") String ids);
- Mapper.xml文件
传入类似于："5,1,6"这样的字符串，使用#{}就不行了
<delete id="deleteBatch">
delete from user where id in (${ids})
</delete>
动态设置表名
- Mapper接口
List<map<string, object>> selectDynamicTableName(@Param("tableName") String tableName);
</map<string,>
- Mapper.xml文件
<select id="selectDynamicTableName" resulttype="java.util.Map">
select * from ${tableName}
</select>
新增记录时获取到自增的主键值
应用场景举例：添加一个班级，并且为该班级指定对应的学生。
前提该要：mybaits的增删改方法返回的结果 都是影响到的行数。因此如果想要得到自增的ID需要将该值 赋值到插入的实体类的一个属性当中。
- Mapper接口
void insertuseGeneratedKey(User user);
- Mapper.xml
<!--
useGeneratedKeys开启主键自增功能（JDBC的功能）
keyProperty：需要映射到实体类的哪个字段（注意是实体类）
-->
<insert id="insertuseGeneratedKey" usegeneratedkeys="true" keyproperty="id">
insert into user(name,gender,age) values(#{name},#{gender},#{age})
</insert>
- 测试一下
User user = new User(null, "王五", "女", 18);
mapper.insertuseGeneratedKey(user);
System.out.println(user);
// 得到的结果为：User(id=5, name=王五, gender=女, age=18)，可以看出自增的id已经得到了
自定义映射ResultMap
为什么需要自定义ResultMap呢
- （1）我们实体类中的属性名与数据库中的字段名不一定是相互对应的
- （2）当我们查询时，出现一对多、多对多的情况时，单纯的字段映射已经无法搞定
定义并使用一个ResultMap
<resultmap id="empResultMap" type="com.codestarts.pojo.Employee">
<id column="id" property="id"></id>
<result column="ename" property="eName"></result>
<result column="job" property="job"></result>
<result column="birth" property="birth"></result>
<result column="sal" property="sal"></result>
<result column="fk_dept_id" property="fkDeptId"></result>
</resultmap>
<select id="selectList" resultmap="empResultMap">
select * from employee
</select>
ResultMap处理多对一映射的3种方式
级联方式
- Mapper接口
/**
* 多对一第一种方式，级联
*/
List<employee> selectResultMapManyForOne01();
</employee>
- Mapper.xml文件
<resultmap id="empResultMap01" type="com.codestarts.pojo.Employee">
<id column="id" property="id"></id>
<result column="ename" property="eName"></result>
<result column="job" property="job"></result>
<result column="birth" property="birth"></result>
<result column="sal" property="sal"></result>
<result column="fk_dept_id" property="fkDeptId"></result>
<result column="fk_dept_id" property="dept.id"></result>
<result column="ename" property="dept.dname"></result>
<result column="loc" property="dept.loc"></result>
</resultmap>
<select id="selectResultMapManyForOne01" resultmap="empResultMap01">
select e.*,d.*
from employee e left join dept d
on e.fk_dept_id = d.id
</select>
使用association处理映射关系
- Mapper接口
List<employee> selectResultMapManyForOne02();
</employee>
- Mapper.xml文件
<resultmap id="empResultMap02" type="com.codestarts.pojo.Employee">
<id column="id" property="id"></id>
<result column="ename" property="eName"></result>
<result column="job" property="job"></result>
<result column="birth" property="birth"></result>
<result column="sal" property="sal"></result>
<result column="fk_dept_id" property="fkDeptId"></result>
<association property="dept" javatype="com.codestarts.pojo.Dept">
<id property="id" column="fk_dept_id"></id>
<result property="dname" column="dname"></result>
<result property="loc" column="loc"></result>
</association>
</resultmap>
<select id="selectResultMapManyForOne02" resultmap="empResultMap02">
select e.*,d.*
from employee e left join dept d
on e.fk_dept_id = d.id
</select>
使用分布查询处理映射关系
- EmployeeMapper接口
List<employee> selectResultMapManyForOne03();
</employee>
- EmployeeMapper.xml文件
<resultmap id="empResultMap03" type="com.codestarts.pojo.Employee">
<id column="id" property="id"></id>
<result column="ename" property="eName"></result>
<result column="job" property="job"></result>
<result column="birth" property="birth"></result>
<result column="sal" property="sal"></result>
<result column="fk_dept_id" property="fkDeptId"></result>
<association property="dept" select="com.codestarts.mapper.DeptMapper.selectDeptById" column="fk_dept_id">
</association></resultmap>
<select id="selectResultMapManyForOne03" resultmap="empResultMap03">
select * from employee
</select>
- DeptMapper接口
Dept selectDeptById(@Param("deptId") Integer deptId);
- DeptMapper.xml文件
<select id="selectDeptById" resulttype="com.codestarts.pojo.Dept">
select * from dept where id = #{deptId}
</select>
ResulMap处理一对多映射的2种方式
使用collection处理映射关系
- Mapper接口
List<dept> selectResultMapOneForMany01();
</dept>
- Mapper.xml文件
<resultmap id="deptResultMap01" type="com.codestarts.pojo.Dept">
<id column="id" property="id">
<result column="dname" property="dname">
<result column="loc" property="loc">
<collection property="emps" oftype="com.codestarts.pojo.Employee">
<id column="eid" property="id">
<result column="ename" property="eName">
<result column="job" property="job">
<result column="brith" property="brith">
<result column="sal" property="sal">
<result column="fk_dept_id" property="fkDeptId">
</result></result></result></result></result></id></collection>
</result></result></id></resultmap>
<select id="selectResultMapOneForMany01" resultmap="deptResultMap01">
select d.*,e.id eid,e.*
from dept d left join employee e
on d.id = e.fk_dept_id
</select>
使用分布查询处理映射关系
- DeptMapper接口
List<dept> selectResultMapOneForMany02();
</dept>
- DeptMapper.xml文件
<resultmap id="deptResultMap02" type="com.codestarts.pojo.Dept">
<id column="id" property="id">
<result column="dname" property="dname">
<result column="loc" property="loc">
<collection property="emps" select="com.codestarts.mapper.EmployeeMapper.selectEmployeeByDeptId" column="id">
</collection>
</result></result></id></resultmap>
<select id="selectResultMapOneForMany02" resultmap="deptResultMap02">
select d.*,e.id eid,e.*
from dept d left join employee e
on d.id = e.fk_dept_id
</select>
- EmployeeMapper接口
List<employee> selectEmployeeByDeptId(@Param("deptId") Integer deptId);
</employee>
- EmployeeMapper.xml文件
<select id="selectEmployeeByDeptId" resulttype="com.codestarts.pojo.Employee">
select * from employee where fk_dept_id = #{deptId}
</select>
Result小总结
association的作用
当需要映射的属性是一个实体类时，就可以考虑使用该标签。
- 非分布查询时
- property 实体的属性名称
- javaType 该属性的全限定类名
- 分布查询时
- property 实体的属性名称
- select 需要分布查询方法的唯一路径
- column 需要传递给select的字段列
collection的作用
当需要映射的属性是一个集合时，可以考虑使用该标签
- 非分布查询时
- property 实体的属性名称
- ofType 集合中的元素类型
- 分布查询时（与association一致）
- property 实体的属性名称
- select 需要分布查询方法的唯一路径
- column 需要传递给select的字段列
ResultMap实现分布查询时的延迟加载配置
- 修改mybaits全局配置文件，添加如下setting
<!--开启延迟加载功能-->
<setting name="lazyLoadingEnabled" value="true">
<!-- 关闭该功能后，才能进行按需加载，与lazyLoadingEnabled 配合使用-->
<setting name="aggressiveLazyLoading" value="false">
</setting></setting>
- 如果一个查询功能不想使用延迟加载，则需要在Mapper.xml文件的该方法的resultMap中的 collection或 association标签上添加
fetchType="eager"
动态SQL
if进行模糊查询
<select id="selectByCondition" resulttype="com.codestarts.pojo.Employee">
select * from employee where 1=1
<if test="ename!=null and ename!=''">
and ename like "%"#{ename}"%"
</if>
<if test="job!=null and job!=''">
and job like "%"#{job}"%"
</if>
<if test="sal!=null and sal!=''">
and sal like "%"#{sal}"%"
</if>
</select>
where配合if进行模糊查询
- 当where中的条件有任意匹配时，会自动拼接上where条件
- 会去除掉条件前多余的and（但是不会去掉条件后的and）
- 当where中没有条件匹配时，该标签无效
<select id="selectByCondition02" resulttype="com.codestarts.pojo.Employee">
select * from employee
<where>
<if test="ename!=null and ename!=''">
ename like "%"#{ename}"%"
</if>
<if test="job!=null and job!=''">
and job like "%"#{job}"%"
</if>
<if test="sal!=null and sal!=''">
and sal like "%"#{sal}"%"
</if>
</where>
</select>
trim
- prefix/suffix 在SQL语句的前后添加上任意前缀或后缀
- prefixOverrides / suffixOverrides 在SQL语句的前后删除任意前缀或后缀
choose、when、otherwise
- 相当于 if .. else if .. else
- 其中when至少需要出现一次
- otherwise最多出现一次
- 测试代码
<select id="selectByCondition03" resulttype="com.codestarts.pojo.Employee">
select * from employee
<where>
<choose>
<when test="ename!=null and ename!=''">
ename like "%"#{ename}"%"
</when>
<when test="job!=null and job!=''">
job like "%"#{job}"%"
</when>
</choose>
</where>
</select>
foreach（重要）
新增多条记录（使用了集合）
- Mapper接口
void insertBatchRecord(@Param("emps") List<employee> emps);
</employee>
- Mapper.xml文件
<insert id="insertBatchRecord">
insert into employee values
<foreach collection="emps" item="emp" separator=",">
(null, #{emp.ename}, #{emp.job}, #{emp.brith}, #{emp.sal}, #{emp.fkDeptId})
</foreach>
</insert>
删除多条记录（使用了数组）
- Mapper接口
void deleteBatchRecord(@Param("ids") Integer[] ids);
- Mapper.xml文件
<delete id="deleteBatchRecord">
delete from employee where id in
<foreach collection="ids" item="id" separator="," open="(" close=")">
#{id}
</foreach>
</delete>
sql（片段）
作用：将重复的SQL代码统一的封装起来
<sql id="allFiled">
id, ename, job, brith, sal, fk_dept_id
</sql>
<select id="selectList" resulttype="com.codestarts.pojo.Employee">
select <include refid="allFiled"> from employee
</include></select>
MyBatis缓存
一级缓存
- SqlSession级别，仅在同一个SqlSession有效，默认开启
- 失效条件
（1）使用同一条SQL语句查询时中间穿插了增删改操作
(2) 清空了SqlSession的缓存sqlSession.clearCache()
二级缓存
缓存的生效条件
- 在mybatis全局配置中开启二级缓存功能
<setting name="cacheEnabled" value="true"> </setting> - 二级缓存仅在同一个SqlSessionFactory创建的SqlSession中有效
- 开启二级缓存生效的四个条件
（1）在核心配置文件中，设置全局配置属性cacheEnabled=”true”，默认为true，不需要设置 （2）在映射文件中设置标签 （3）只有当一个SqlSession 提交或关闭时，才会 将该SqlSession的一级缓存存储到二级缓存当中 （4）查询的数据所转换的实体类类型必须实现序列化的接口
注意：两次查询之间执行了任意的增删改， 会使一级和二级缓存同时失效
二级缓存的相关配置
- （1）在mapper配置文件中添加的cache标签可以设置一些属性：
- （2） eviction属性：缓存回收策略
- LRU（Least Recently Used） – 最近最少使用的：移除最长时间不被使用的对象。
- FIFO（First in First out） – 先进先出：按对象进入缓存的顺序来移除它们。
- SOFT – 软引用：移除基于垃圾回收器状态和软引用规则的对象。
- WEAK – 弱引用：更积极地移除基于垃圾收集器状态和弱引用规则的对象。默认的是 LRU。
- （3） flushInterval属性：刷新间隔，单位毫秒默认情况是不设置，也就是没有刷新间隔，缓存仅仅调用语句时刷新
- （4） size属性：引用数目，正整数代表缓存最多可以存储多少个对象，太大容易导致内存溢出
- （5） readOnly属性：只读，true/false
- true：只读缓存；会给所有调用者返回缓存对象的相同实例。因此这些对象不能被修改。这提供了很重要的性能优势。
- false：读写缓存；会返回缓存对象的拷贝（通过序列化）。这会慢一些，但是安全，因此默认是false。
- 只读缓存，相当于把缓存中的引用直接交给了方法调用者。 读写缓存相当于每次都会拷贝一个对象交给调用者。
第三方二级缓存EHCache
引入依赖
<!-- Mybatis EHCache整合包 -->
<dependency>
<groupid>org.mybatis.caches</groupid>
<artifactid>mybatis-ehcache</artifactid>
<version>1.2.1</version>
</dependency>
<!-- slf4j日志门面的一个具体实现 -->
<dependency>
<groupid>ch.qos.logback</groupid>
<artifactid>logback-classic</artifactid>
<version>1.2.3</version>
</dependency>
各jar包的功能
- （1）mybatis-ehcache Mybatis和EHCache的整合包
- （2）ehcache EHCache核心包
- （3）slf4j-api SLF4J日志门面包
- （4）logback-classic 支持SLF4J门面接口的一个具体实现
在根路径下创建ehcache.xml
<?xml version="1.0" encoding="utf-8" ?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:nonamespaceschemalocation="../config/ehcache.xsd">
<!-- 磁盘保存路径 -->
<diskstore path="D:\mybatis_test\ehcache">
<defaultcache maxelementsinmemory="1000" maxelementsondisk="10000000" eternal="false" overflowtodisk="true" timetoidleseconds="120" timetoliveseconds="120" diskexpirythreadintervalseconds="120" memorystoreevictionpolicy="LRU">
</defaultcache>
</diskstore></ehcache>
配置文件的参数作用
属性名 是否必须 作用 maxElementsInMemory 是 在内存中缓存的element的最大数目 maxElementsOnDisk 是 在磁盘上缓存的element的最大数目，若是0表示无穷大 eternal 是 设定缓存的elements是否永远不过期。 如果为true，则缓存的数据始终有效， 如果为false那么还要根据timeToIdleSeconds、timeToLiveSeconds判断 overflowToDisk 是 设定当内存缓存溢出的时候是否将过期的element缓存到磁盘上 timeToIdleSeconds 否 当缓存在EhCache中的数据前后两次访问的时间超过timeToIdleSeconds的属性取值时， 这些数据便会删除，默认值是0,也就是可闲置时间无穷大 timeToLiveSeconds 否 缓存element的有效生命期，默认是0.,也就是element存活时间无穷大 diskSpoolBufferSizeMB 否 DiskStore(磁盘缓存)的缓存区大小。默认是30MB。每个Cache都应该有自己的一个缓冲区 diskPersistent 否 在VM重启的时候是否启用磁盘保存EhCache中的数据，默认是false。 diskExpiryThreadIntervalSeconds 否 磁盘缓存的清理线程运行间隔，默认是120秒。每隔120s， 相应的线程会进行一次EhCache中数据的清理工作 memoryStoreEvictionPolicy 否 当内存缓存达到最大，有新的element加入的时候， 移除缓存中element的策略。 默认是LRU（最近最少使用），可选的有LFU（最不常使用）和FIFO（先进先出）
修改二级缓存的类型
<cache type="org.mybatis.caches.ehcache.EhcacheCache">
</cache>
创建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="DEBUG">
<!-- 指定打印日志的appender，这里通过"STDOUT"引用了前面配置的appender -->
<appender-ref ref="STDOUT">
</appender-ref></root>
<!-- 根据特殊需求指定局部日志级别 -->
<logger name="com.codestarts.mapper" level="DEBUG">
</logger></configuration>
缓存查询的先后顺序
- （1）先查询二级缓存
- （2）再查询一级缓存
- （3）最后查询数据库
- SqlSession关闭之后，一级缓存中的数据会写入二级缓存
MyBatis逆向工程
正向工程与逆向工程的区别
- 正向工程：先创建实体类，再根据实体类生成数据库表
- 逆向工程：先创建数据库表，再根据数据库表生成实体类，逆向生成的资源如下
- Java实体类
- Mapper接口
- Mapper映射文件
引入jar包及Maven插件
<!-- 依赖MyBatis核心包 -->
<dependencies>
<dependency>
<groupid>org.mybatis</groupid>
<artifactid>mybatis</artifactid>
<version>3.5.7</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>
<!-- MySQL驱动 -->
<dependency>
<groupid>mysql</groupid>
<artifactid>mysql-connector-java</artifactid>
<version>8.0.28</version>
</dependency>
</dependencies>
</plugin>
</plugins>
</build>
添加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>
<!--
targetRuntime: 执行生成的逆向工程的版本
MyBatis3Simple: 生成基本的CRUD（清新简洁版）
MyBatis3: 生成带条件的CRUD（奢华尊享版）
-->
<context id="DB2Tables" targetruntime="MyBatis3">
<!-- 数据库的连接信息 -->
<jdbcconnection driverclass="com.mysql.jdbc.Driver" connectionurl="jdbc:mysql://localhost:3306/db_mybatis?useSSL=false&useUnicode=true&characterEncoding=utf8&serverTimezone=Asia/Shanghai" userid="root" password="abc123">
</jdbcconnection>
<!-- javaBean的生成策略-->
<javamodelgenerator targetpackage="com.codestats.mybatis.bean" targetproject=".\src\main\java">
<property name="enableSubPackages" value="true">
<property name="trimStrings" value="true">
</property></property></javamodelgenerator>
<!-- SQL映射文件的生成策略 -->
<sqlmapgenerator targetpackage="com.codestats.mybatis.mapper" targetproject=".\src\main\resources">
<property name="enableSubPackages" value="true">
</property></sqlmapgenerator>
<!-- Mapper接口的生成策略 -->
<javaclientgenerator type="XMLMAPPER" targetpackage="com.codestats.mybatis.mapper" targetproject=".\src\main\java">
<property name="enableSubPackages" value="true">
</property></javaclientgenerator>
<!-- 逆向分析的表 -->
<!-- tableName设置为*号，可以对应所有表，此时不写domainObjectName -->
<!-- domainObjectName属性指定生成出来的实体类的类名 -->
<table tablename="dept" domainobjectname="Dept">
<table tablename="employee" domainobjectname="Employee">
</table></table></context>
</generatorconfiguration>
MyBatis分页插件
在pom.xml文件中引入插件
<!-- https://mvnrepository.com/artifact/com.github.pagehelper/pagehelper -->
<dependency>
<groupid>com.github.pagehelper</groupid>
<artifactid>pagehelper</artifactid>
<version>5.2.0</version>
</dependency>
在mybatis全局配置文件中配置
<plugins>
<!--设置分页插件-->
<plugin interceptor="com.github.pagehelper.PageInterceptor"></plugin>
</plugins>
PageInfo及参数解释
// 开启分页
PageHelper.startPage(2, 3);
List<employee> employees = mapper.selectList();
// 获取PageInfo
PageInfo<employee> pageInfo = new PageInfo<employee>(employees);
// 导航分页的页码数量
PageInfo<employee> pageInfo2 = new PageInfo<employee>(employees, 3);
</employee></employee></employee></employee></employee>
- （1）pageNum：当前页的页码
- （2）pageSize：每页显示的条数
- （3）size：当前页显示的真实条数
- （4）total：总记录数
- （5）pages：总页数
- （6）prePage：上一页的页码
- （7）nextPage：下一页的页码
- （8）isFirstPage/isLastPage：是否为第一页/最后一页
- （9）hasPreviousPage/hasNextPage：是否存在上一页/下一页
- （10）navigatePages：导航分页的页码数
- （11）navigatepageNums：导航分页的页码，[1,2,3,4,5]
使用mybatis过程中出现的问题
在mapper.xml中，判断某个字段不是空字符串时，发现整数0会被当成空字符串..
判断的时候，要么先把int转换成string，要么不判断是否等于空字符串
Spring的学习
Spring的特性及五大功能模块
特性
- （1）非侵入式：使用 Spring Framework 开发应用程序时，Spring 对应用程序本身的结构影响非常小。对领域模型可以做到零污染；对功能性组件也只需要使用几个简单的注解进行标记，完全不会破坏原有结构，反而能将组件结构进一步简化。这就使得基于 Spring Framework 开发应用程序时结构清晰、简洁优雅。
- （2）控制反转：IOC——Inversion of Control，翻转资源获取方向。把自己创建资源、向环境索取资源变成环境将资源准备好，我们享受资源注入。
- （3）面向切面编程：AOP——Aspect Oriented Programming，在不修改源代码的基础上增强代码功能。 面向对象是纵向优化，优化的是从上往下执行的代码， 而面向切面是横向优化，可以在不改变原有代码的基础上对原有的代码进行功能的扩展。
- （4）容器：Spring IOC 是一个容器，因为它包含并且管理组件对象的生命周期。组件享受到了容器化的管理，替程序员屏蔽了组件创建过程中的大量细节，极大的降低了使用门槛，大幅度提高了开发效率。
- （5）组件化：Spring 实现了使用简单的组件配置组合成一个复杂的应用。在 Spring 中可以使用 XML和 Java 注解组合这些对象。这使得我们可以基于一个个功能明确、边界清晰的组件有条不紊的搭建超大型复杂应用系统。
- （6）声明式：很多以前需要编写代码才能实现的功能，现在只需要声明需求即可由框架代为实现。 编程式指的是自己编写代码完成功能，例如以前的事务控制，都需要手动编写代码完成事务的开启、提交、回滚。而声明式则可以将这一工作交由框架来实现，换句话说， 现在想要实现事务就只需要跟Spring声明一声即可。
- （7）一站式：在 IOC 和 AOP 的基础上可以整合各种企业应用的开源框架和优秀的第三方类库。而且Spring 旗下的项目已经覆盖了广泛领域，很多方面的功能性需求可以在 Spring Framework 的基础上全部使用 Spring 来实现。
五大功能模块
- （1）Core Container 核心容器，在 Spring 环境下使用任何功能都必须基于 IOC 容器。
- （2）AOP&Aspects 面向切面编程
- （3）Testing 提供了对 junit 或 TestNG 测试框架的整合。
- （4）Data Access/Integration 提供了对数据访问/集成的功能。DI依赖注入，可以理解为IOC思想的一种具体实现，通俗易懂的作用就是 为Spring容器中的属性进行赋值。
- （5）Spring MVC 提供了面向Web应用程序的集成功能。
SpringIOC容器
Spring对于IOC容器的实现
- （1） BeanFactory ：这是 IOC 容器的基本实现，是 Spring 内部使用的接口。面向 Spring 本身，不提供给开发人员使用。
- （2） ApplicationContext：BeanFactory 的子接口，提供了更多高级特性。面向 Spring 的使用者， 几乎所有场合都使用ApplicationContext 而不是底层的 BeanFactory。主要实现类如下：
类型名 简介 ClassPathXmlApplicationContext 通过读取类路径下的 XML 格式的配置文件创建 IOC 容器对象 FileSystemXmlApplicationContext 通过文件系统路径读取 XML 格式的配置文件创建 IOC 容器对象（不常用） ConfigurableApplicationContext ApplicationContext 的子接口，包含一些扩展方法
refresh() close()
，让 ApplicationContext 具有启动、关闭和刷新上下文的能力。 WebApplicationContext 专门为 Web 应用准备，基于 Web 环境创建 IOC 容器对象，并将对象引入存入
ServletContext
域中。
基于XML管理Bean
获取Bean的三种方式
- 注意：被Spring IOC容器所管理的bean，可以通过其bena对象的 父类或接口类型来获取
- applicationContext.xml文件
<bean id="userController" class="com.codestars.controller.UserController">
</bean>
- 测试类
// 通过bean的唯一标志id来获取
UserController userController1 = (UserController) ac.getBean("userController");
System.out.println("userController1 = " + userController1);
// 通过类型来获取（最常用）
UserController userController2 = ac.getBean(UserController.class);
System.out.println("userController2 = " + userController2);
// 通过id + 类型来获取
UserController userController3 = ac.getBean("userController", UserController.class);
System.out.println("userController3 = " + userController3);
DI依赖注入的2种方式
- set/get方式
<bean id="user1" class="com.codestars.pojo.User">
<property name="name" value="张三"></property>
<property name="age" value="15"></property>
</bean>
- 构造器方式
<bean id="user2" class="com.codestars.pojo.User">
<constructor-arg name="name" value="李四"></constructor-arg>
<constructor-arg name="age" value="18"></constructor-arg>
</bean>
字面量赋值
基本数据类型、 包装数据类型、 String类型这种看到什么就代表什么的值成为 字面量。进行以来依赖注入时，字面量使用value赋值。
<bean id="user1" class="com.codestars.pojo.User">
<property name="name" value="张三"></property>
</bean>
为属性赋值为null
<bean id="user1" class="com.codestars.pojo.User">
<property name="name">
<null>
</null></property>
</bean>
当遇到xml实体时的2种处理方案
- 使用xml实体对应的实体符号，例如大于号变成>，小于号变成<等
- 使用CDATA节
<bean id="user1" class="com.codestars.pojo.User">
<property name="name">
<value><!--[CDATA[><><><><><><><]]--></value>
</property>
</bean>
为类类型的属性赋值
引用外部已声明的bean
<bean id="user1" class="com.codestars.pojo.User">
<property name="cat" ref="myCat"></property>
</bean>
<bean id="myCat" class="com.codestars.pojo.Cat"></bean>
使用内部bean（内部bean无法在外部通过IOC容器获取）
<bean id="user1" class="com.codestars.pojo.User">
<property name="cat">
<bean class="com.codestars.pojo.Cat"></bean>
</property>
</bean>
为数组类型赋值
<bean id="user1" class="com.codestars.pojo.User">
<property name="catArr">
<array>
<!-- 注意：字面量使用value标签，类变量可以考虑内部bean，也可以考虑外部引用 -->
<!-- 赋值3个内部bean -->
<bean class="com.codestars.pojo.Cat"></bean>
<bean class="com.codestars.pojo.Cat"></bean>
<bean class="com.codestars.pojo.Cat"></bean>
<!-- 外部引用3个bean -->
<ref bean="cat1"></ref>
<ref bean="cat2"></ref>
<ref bean="cat3"></ref>
</array>
</property>
</bean>
<bean id="cat1" class="com.codestars.pojo.Cat"></bean>
<bean id="cat2" class="com.codestars.pojo.Cat"></bean>
<bean id="cat3" class="com.codestars.pojo.Cat"></bean>
为List集合属性赋值
<bean id="user1" class="com.codestars.pojo.User">
<property name="integerList">
<list>
<!-- 由于是存储字面量的List，所以使用value标签 -->
<value>12</value>
<value>33</value>
<value>22</value>
<value>141</value>
</list>
</property>
</bean>
为Map集合属性赋值
<bean id="user1" class="com.codestars.pojo.User">
<property name="map">
<!-- 这个map是 <String, Cat> 类型的 -->
<map>
<entry key="catOne" value-ref="cat1"></entry>
<entry key="catTwo" value-ref="cat2"></entry>
<entry key="catThree" value-ref="cat3"></entry>
</map>
</property>
</bean>
<bean id="cat1" class="com.codestars.pojo.Cat"></bean>
<bean id="cat2" class="com.codestars.pojo.Cat"></bean>
<bean id="cat3" class="com.codestars.pojo.Cat"></bean>
创建集合、数组、Map类型的bean并引用
<bean id="user1" class="com.codestars.pojo.User">
<property name="map" ref="catMap"></property>
</bean>
<bean id="cat1" class="com.codestars.pojo.Cat"></bean>
<util:map id="catMap">
<entry key="catOne">
<!-- 使用内部bean -->
<bean class="com.codestars.pojo.Cat"></bean>
</entry>
<entry key="catTwo" value-ref="cat1"></entry>
</util:map>
命名空间p（了解）
<bean id="user1" class="com.codestars.pojo.User" p:age="15" p:name="张三" p:integerlist-ref="integerList"></bean>
<util:list id="integerList">
<value>13</value>
<value>11</value>
<value>44</value>
<value>66</value>
</util:list>
引入外部配置文件
<!-- 引入外部properties配置文件，引入后可通过${key}的方式获取 -->
<context:property-placeholder location="jdbc.properties"></context:property-placeholder>
<bean id="user1" class="com.codestars.pojo.User">
<property name="strArr">
<array>
<value>${jdbc.driver}</value>
<value>${jdbc.url}</value>
<value>${jdbc.username}</value>
<value>${jdbc.password}</value>
</array>
</property>
</bean>
bean的作用域
- 通过修改bean标签的scope属性调整
- 默认为 singleton 单例模式，也可以修改为 prototype多例模式
- 在Web容器当中，还会有另外2个作用域
- request 一个请求内有效
- session 一个会话内有效
bean的生命周期
- （1）bean对象创建（调用无参构造器）、 实例化
- （2）给bean对象设置属性、 依赖注入
- （3）bean对象初始化之前操作（由bean的后置处理器负责）
- （4）bean对象初始化（需在 配置bean时指定初始化方法）、 初始化
- （5）bean对象初始化之后操作（由bean的后置处理器负责）
- （6）bean对象就绪可以使用、 使用状态
- （7）bean对象销毁（需在 配置bean时指定销毁方法）、只有当关闭IOC容器时才会销毁
- （8）IOC容器关闭、使用 ConfigurableApplicationContext调用close()方法可以关闭IOC容器
后置处理器BeanPostProcessor
- 可以在对象进行初始化之前以及初始化之后做一些事情（对 所有Spring容器中的bean都有效）
- 创建一个类实现该接口
public class PostProcessorTest implements BeanPostProcessor {
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
System.out.println("对象实例化之前");
return bean;
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
System.out.println("对象实例化后");
return bean;
}
}
- 在xml文件中配置
<bean class="com.codestars.PostProcessorTest"></bean>
FactoryBean（以后spring整合mybatis时，Mybatis就提供了一个FactoryBean）
- 获取该FactoryBean 就相当于获取一个其getObject()方法返回值类型的实例
- 创建一个类，实现该接口
public class UserFactory implements FactoryBean<user> {
@Override
public User getObject() throws Exception {
return new User();
}
@Override
public Class<?> getObjectType() {
return User.class;
}
/**
* 是否为单例，指的就是获取的实例是否为单例。
* @return
*/
@Override
public boolean isSingleton() {
return true;
}
}
</user>
- 在配置文件中进行配置
<!-- 通过getBean("user1") 得到的Bean对象类型就是User类型 -->
<bean id="user1" class="com.codestars.factory.UserFactory"></bean>
自动装配
基于XML的自动装配byType 和 byName（不常用）
- byType ： 根据类型自动装配。byName：根据bean的唯一标志与属性名称自动装配
- 为一个bean配置了自动装配后，则会按照自动装配的规则将该bean中的 所有非字面量
- xml配置文件
<bean id="user1" class="com.codestars.pojo.User" autowire="byName"></bean>
<bean id="user2" class="com.codestars.pojo.User" autowire="byType"></bean>
<bean id="isNullCat" class="com.codestars.pojo.Cat"></bean>
基于注解管理Bean
基于注解管理bean的4个注解以及配置包扫描
- 用于标识需要被SpringIOC容器所管理的注解，这四个注解的作用都是一样的，只是不同的名称有利于我们程序员开发。
@Controller 标识为一个控制层的组件
@Service 标识为一个业务层的组件
@Repository 标识为一个持久层的组件
@Component 标识为一个组件（当如上3个都不是时）
- 通过注解扫描的方式，bean的id默认为 类名的小驼峰。
扫描组件的3种方式
- 最基础的注解扫描
<!-- 这里表示扫描com.codestars这个包及其自包下的所有类 -->
<context:component-scan base-package="com.codestars">
</context:component-scan>
- 排除不需要扫描的注解
<!-- 这里表示扫描com.codestars这个包及其自包下的所有类 -->
<context:component-scan base-package="com.codestars">
<!-- type：annotation 按照注解排除不需要加载到IOC容器的类 -->
<context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller">
<!-- type：assignable 按照类型排除 -->
<context:exclude-filter type="assignable" expression="com.codestars.controller.UserController">
</context:exclude-filter></context:exclude-filter></context:component-scan>
- 添加需要扫描的注解，需要配合use-default-filters=”false”
<!-- 这里表示扫描com.codestars这个包及其自包下的所有类 -->
<context:component-scan base-package="com.codestars" use-default-filters="false">
<!-- type：annotation 按照注解添加需要加载到IOC容器的类 -->
<context:include-filter type="annotation" expression="org.springframework.stereotype.Controller">
<!-- type：assignable 按照类型扫描 -->
<context:include-filter type="assignable" expression="com.codestars.service.impl.UserServiceImpl">
</context:include-filter></context:include-filter></context:component-scan>
基于注解的自动装配
- 在 被Spring管理的组件中使用
@Autowired作用于 成员变量、set方法、构造器上均可以完成自动注入 @Autowired的注入原理：先使用byType的方式，若容器中包含有多个同类型的bean，则会使用byName的方式获取，若仍然没有获取到，则抛出异常。- 有一个注解：
@Qualifier可以标识byType获取组件时使用的beanId
SpringAOP
什么是AOP，OOP
- AOP ： Aspect Oriented Programming 面向切面编程，采用的是 横向拓展机制，可以在不影响原有功能实现的基础上，完成 非入侵式的功能扩展。
- OOP：Object Oriented Programming 面向对象编程，采用的是 纵向继承极致，当我们需要进行代码的重用时，需要将被重用的代码纵向抽取，无法解决横向扩展的问题。 例如一个计算器功能，我们想要在计算的前后添加上日志功能，通过面向对象的方法就无法解决。
静态代理、动态代理的区别
- 用生活中的例子来理解代理模式
例如我们的一个普通的饮水机，我们想要让饮水机具备水过滤的功能，因此我们将饮水机进行了改装，在不影响原有功能的情况下，添加了过滤功能。之后我们使用的时候就 只能使用带过滤功能的饮水机。
使用计算器功能完成一个静态代理
Calculate 计算器接口
public interface Calculate {
Integer add(int a, int b);
Integer sub(int a, int b);
Integer mul(int a, int b);
Integer div(int a, int b);
}
CalculateImpl 计算器实现类
public class CalculateImpl implements Calculate {
@Override
public Integer add(int a, int b) {
return a + b;
}
@Override
public Integer sub(int a, int b) {
return a - b;
}
@Override
public Integer mul(int a, int b) {
return a * b;
}
@Override
public Integer div(int a, int b) {
return a / b;
}
}
思考一下，这个时候如果我们想要增加一些 非核心代码 应该怎么办？
- 难道在计算器实现类中的每个方法的前后都添加这些非核心代码吗？
- 这么做的弊端有如下几个：
（1）会影响程序员开发核心代码，应该在开发核心代码时，还要考虑非核心代码，比如日志应该如何添加等问题。
（2）会造成大量的重复代码，形成代码的冗余，不便于管理。
编写一个静态代理类来完成功能的扩展
public class CalculateImplProxy implements Calculate{
private CalculateImpl calculateImpl = new CalculateImpl();
@Override
public Integer add(int a, int b) {
System.out.println("日志功能，当前执行的方法是：add" + "参数为：" + a + " ，" + b) ;
Integer result = calculateImpl.add(a, b);
System.out.println("日志功能，当前执行的方法是：add，执行结果为： " + result);
return result;
}
@Override
public Integer sub(int a, int b) {
System.out.println("日志功能，当前执行的方法是：sub" + "参数为：" + a + " ，" + b) ;
Integer result = calculateImpl.sub(a, b);
System.out.println("日志功能，当前执行的方法是：sub，执行结果为： " + result);
return result;
}
@Override
public Integer mul(int a, int b) {
System.out.println("日志功能，当前执行的方法是：mul" + "参数为：" + a + " ，" + b) ;
Integer result = calculateImpl.mul(a, b);
System.out.println("日志功能，当前执行的方法是：mul，执行结果为： " + result);
return result;
}
@Override
public Integer div(int a, int b) {
System.out.println("日志功能，当前执行的方法是：div" + "参数为：" + a + " ，" + b) ;
Integer result = calculateImpl.div(a, b);
System.out.println("日志功能，当前执行的方法是：div，执行结果为： " + result);
return result;
}
}
因此再使用的时候必须使用代理对象
public class Test {
public static void main(String[] args) {
Calculate calculate = new CalculateImplProxy();
calculate.add(5, 2);
calculate.sub(3, 2);
calculate.mul(2, 2);
calculate.div(5, 2);
}
}
静态代理的弊端
- 静态代理时， 一个代理类只能对应一个目标类，因此一旦有多个类都需要被代理时，那么就得编写多个代理类
- 并且如果有多个需要被代理的类， 想要扩展的都是同样的功能，那不就依然造成代码的冗余了吗？
在如上计算器的基础上使用JDK动态代理完成计算器代理功能
public class ProxyFactory {
public static Object getProxyObject(Object target) {
/**
* ClassLoader loader, 由于代理类需要被动态生成，因此需要一个类加载器
* Class<?>[] interfaces, 想想我们刚刚写的静态代理，代理类需要跟目标类实现一样的接口
* InvocationHandler h ， 进行对目标对象功能的增强处理
*/
ClassLoader classLoader = ProxyFactory.class.getClassLoader();
Class<?>[] interfaces = target.getClass().getInterfaces();
InvocationHandler invocationHandler = new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
try {
// 前置通知
System.out.println("增强方法：前置通知，运行的方法为：" + method.getName() + " 参数列表为：" + Arrays.toString(args));
// 代理类，执行的依然是目标类的方法。为什么呢？代理类就是为了扩展目标类的方法，实际上还是使用的目标类的方法
Object resultObj = method.invoke(target, args);
// 方法有返回值的通知
System.out.println("方法正常运行完毕，运行的结果为：" + resultObj);
// 结果一定要返回去，为什么呢？ 既然是扩展原有的目标类的方法，那么结果肯定不能变。
return resultObj;
} catch (Exception e) {
// 异常通知
System.out.println("增强方法：异常通知");
} finally {
// 后置通知
System.out.println("增强方法：后置通知");
}
return null;
}
};
return Proxy.newProxyInstance(classLoader, interfaces, invocationHandler);
}
}
AOP中的几个概念（7个，重要）
- 横切关注点（需要抽取的非核心代码，理解为刚刚计算器功能中的日志代码）
- 切面（将横切关注点中的代码进行抽取，抽取后放到一个类中，该类就是一个切面类）
- 通知（切面类中的一个个 存放横切关注点代码的方法）
- 连接点（当前的通知需要连接到哪个类上的哪个方法？需要连接到的地方就称之为连接点）
- 切入点（其实就是 连接点的具体表现形式，通过切入点表达式来表示需要连接的点）
- 代理（代理对象）
- 目标（需要扩展功能的被代理对象）
SpringAOP使用的步骤
将目标类和切面类都交由SpringIOC容器管理
- 可以通过注解、或者XML的方式交由IOC容器管理
- 一个类想要成为切面类，可以通过
@Aspect注解标识为一个切面类
将横切关注点的代码放在切面类中的通知方法中
// 定义一个全局切入点，大家可以一起使用
@Pointcut("execution(* com.codestars.service.impl.*.*(..))")
public void pointCut(){}
// 定义不同的通知
@Before("pointCut()")
@After("pointCut()")
@AfterReturning(value = "pointCut()",returning = "result")
@AfterThrowing(value = "pointCut()",throwing = "ex")
演示基于注解的AOP
添加SpringIOC、SpringAOP、spring-aspects的依赖
<dependencies>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
<dependency>
<groupid>org.springframework</groupid>
<artifactid>spring-context</artifactid>
<version>5.3.18</version>
</dependency>
<dependency>
<groupid>org.springframework</groupid>
<artifactid>spring-aop</artifactid>
<version>5.3.18</version>
</dependency>
<!-- spring-aspects会帮我们传递过来aspectjweaver -->
<dependency>
<groupid>org.springframework</groupid>
<artifactid>spring-aspects</artifactid>
<version>5.3.1</version>
</dependency>
<!-- https://mvnrepository.com/artifact/junit/junit -->
<dependency>
<groupid>junit</groupid>
<artifactid>junit</artifactid>
<version>4.13.2</version>
<scope>test</scope>
</dependency>
</dependencies>
在resources路径下添加spring配置文件
<!-- 这里表示扫描com.codestars这个包及其自包下的所有类 -->
<context:component-scan base-package="com.codestars"></context:component-scan>
<!-- 开启注解功能的AOP -->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
创建一个切面类（除了切入点表达式，还能使用@annotation）
用@annotation，MyLog是一个注解，这样会从spring容器中拦截@MyLog注解
@AfterReturning(value = "@annotation(log)",returning = "res")
public void afterReturningAdvice(JoinPoint point, MyLog log, Object res){
@Component
@Aspect
public class LoggerAspect {
/**
* 定义全局切入点，用于找到连接点
* 完整格式为： public int com.codestars.service.impl.UserServiceImpl.save(这里可以写参数列表，写类型即可);
* public int 可以简化为 *
* 包名 可以简化为 *
* 方法名 可以简化为 *
* 参数列表 可以简化为 ..
*/
@Pointcut("execution(* com.codestars.service.impl.*.*(..))")
public void pointCut(){}
/**
* 前置通知，方法执行前执行
* @param joinPoint 连接点信息
*/
@Before("pointCut()")
public void before(JoinPoint joinPoint) {
Signature signature = joinPoint.getSignature();
System.out.println("前置日志通知，方法执行前调用，当前执行的方法为：" + signature.getName());
}
/**
* 后置通知，在方法完毕后执行，相当于finally中的代码
* @param joinPoint 连接点信息
*/
@After("pointCut()")
public void after(JoinPoint joinPoint) {
Signature signature = joinPoint.getSignature();
System.out.println("后置通知，finally中执行的代码，当前执行的方法为：" + signature.getName());
}
/**
* 方法正常执行并为抛出异常时执行，可以获取到方法的返回值
* @param joinPoint
* @param result
*/
@AfterReturning(value = "pointCut()",returning = "result")
public void afterReturning(JoinPoint joinPoint, Object result) {
Signature signature = joinPoint.getSignature();
System.out.println("方法执行未抛出异常，执行的返回结果为：" + result);
}
/**
* 异常通知：方法抛出异常时执行
* @param joinPoint
* @param ex
*/
@AfterThrowing(value = "pointCut()",throwing = "ex")
public void AfterThrowing(JoinPoint joinPoint, Throwable ex) {
System.out.println("异常通知，当前的异常为： " + ex);
}
@Around(value = "pointCut()")
public Object aRound(ProceedingJoinPoint proceedingJoinPoint) {
Object resultObj = null;
try {
// 环绕：前置通知
System.out.println("环绕：前置通知");
// 方法执行
resultObj = proceedingJoinPoint.proceed();
// 环绕：后置通知
System.out.println("环绕：后置通知");
} catch (Throwable e) {
e.printStackTrace();
System.out.println("环绕：异常通知，当前异常为：" + e);
} finally {
System.out.println("环绕：后置通知，方法执行完毕");
}
// 一定要将目标对象执行方法的结果返回
return resultObj;
}
}
多个切面类的优先级
- 默认都为Integer的最大值
- 通过修改order属性（可以在切面类上使用@Order注解修改）
测试
ApplicationContext ioc = new ClassPathXmlApplicationContext("spring-annoation.xml");
UserService userService = ioc.getBean(UserService.class);
userService.save();
基于XML的AOP配置(xml文件)
<!-- 这里表示扫描com.codestars这个包及其自包下的所有类 -->
<context:component-scan base-package="com.codestars"></context:component-scan>
<aop:config>
<!-- 定义全局切入点表达式 -->
<aop:pointcut id="pointCut" expression="execution(* com.codestars.service.impl.*.*(..))">
<!-- 配置一个切面类 -->
<aop:aspect ref="loggerAspect">
<!-- 指定各个通知的方法名 -->
<aop:before method="before" pointcut-ref="pointCut">
<aop:after method="after" pointcut-ref="pointCut">
<aop:after-returning method="afterReturning" returning="result" pointcut-ref="pointCut">
<aop:after-throwing method="afterReturning" throwing="ex" pointcut-ref="pointCut">
<aop:around method="aRound" pointcut-ref="pointCut">
</aop:around></aop:after-throwing></aop:after-returning></aop:after></aop:before></aop:aspect>
</aop:pointcut></aop:config>
基于注解的AOP完成声明式事物处理
引入IOC、AOP、ORM、TX、数据源等依赖
<dependencies>
<!-- 基于Maven依赖传递性，导入spring-context依赖即可导入当前所需所有jar包 -->
<dependency>
<groupid>org.springframework</groupid>
<artifactid>spring-context</artifactid>
<version>5.3.1</version>
</dependency>
<dependency>
<groupid>org.springframework</groupid>
<artifactid>spring-aop</artifactid>
<version>5.3.18</version>
</dependency>
<dependency>
<groupid>org.springframework</groupid>
<artifactid>spring-aspects</artifactid>
<version>5.3.1</version>
</dependency>
<!-- Spring 持久化层支持jar包 -->
<!-- Spring 在执行持久化层操作、与持久化层技术进行整合过程中，需要使用orm、jdbc、tx三个
jar包 -->
<!-- 导入 orm 包就可以通过 Maven 的依赖传递性把其他两个也导入 -->
<dependency>
<groupid>org.springframework</groupid>
<artifactid>spring-orm</artifactid>
<version>5.3.1</version>
</dependency>
<!-- Spring 测试相关 -->
<dependency>
<groupid>org.springframework</groupid>
<artifactid>spring-test</artifactid>
<version>5.3.1</version>
</dependency>
<!-- junit测试 -->
<dependency>
<groupid>junit</groupid>
<artifactid>junit</artifactid>
<version>4.12</version>
<scope>test</scope>
</dependency>
<!-- MySQL驱动 -->
<dependency>
<groupid>mysql</groupid>
<artifactid>mysql-connector-java</artifactid>
<version>8.0.16</version>
</dependency>
<!-- 数据源 -->
<dependency>
<groupid>com.alibaba</groupid>
<artifactid>druid</artifactid>
<version>1.0.31</version>
</dependency>
</dependencies>
在Spring的xml文件中进行配置
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:context="http://www.springframework.org/schema/context" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:tx="http://www.springframework.org/schema/tx" 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.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">
<!-- 引入外部配置文件 -->
<context:property-placeholder location="jdbc.properties">
<!-- 扫描包 -->
<context:component-scan base-package="com.codestars">
<!-- 配置个数据源 -->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
<property name="driverClassName" value="${jdbc.driver}"></property>
<property name="url" value="${jdbc.url}"></property>
<property name="username" value="${jdbc.username}"></property>
<property name="password" value="${jdbc.password}"></property>
</bean>
<!-- spring提供的封装jdbc的类 -->
<bean class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="dataSource"></property>
</bean>
<!-- 这是一个切面类，帮我们完成了事物管理功能 -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"></property>
</bean>
<!-- 开启该功能后，会通过扫描@Transactional 注解来将类中的所有方法或单独的方法作为事物切面类的连接点 -->
<tx:annotation-driven transaction-manager="transactionManager">
</tx:annotation-driven></context:component-scan></context:property-placeholder></beans>
在需要进行事物管理的类或方法上加注解
- 在类上添加
@Transactional注解：标识该类中所有的方法都为连接点，会对该类中所有方法进行事物管理 - 在方法上添加
@Transactional注解：标识该方法为连接点，将会进行事物管理
事物的传播行为
思考：业务层的一个方法调用业务层的另外一个方法。那么事物应该怎么处理呢？
- REQUIRED 被调用者与调用者使用同一个事物（默认）
- REQUIRES_NEW 被调用者会开启一个新的事物（常用）
Spring提供的事物管理常用的配置
<!-- read-only属性：设置只读属性 -->
true：表示只读，false表示可读可写
<!-- rollback-for属性：设置回滚的异常 -->
<!-- no-rollback-for属性：设置不回滚的异常 -->
<!-- isolation属性：设置事务的隔离级别 -->
<!-- timeout属性：设置事务的超时属性 -->
<!-- propagation属性：设置事务的传播行为 -->
使用XML方式完成事物的管理
<!-- 这是一个切面类，帮我们完成了事物管理功能 -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"></property>
</bean>
<tx:advice id="txAdvice" transaction-manager="transactionManager">
<tx:attributes>
<!-- 指定连接点，为查询操作设置只读 -->
<tx:method name="query*" read-only="true">
<tx:method name="find*" read-only="true">
<tx:method name="get*" read-only="true">
<tx:method name="save*" read-only="false">
<tx:method name="buy*" read-only="false">
<tx:method name="update*" read-only="false">
<tx:method name="delete*" read-only="false">
</tx:method></tx:method></tx:method></tx:method></tx:method></tx:method></tx:method></tx:attributes>
</tx:advice>
<aop:config>
<aop:pointcut id="pointCut" expression="execution(* com.codestars.service.impl.*.*(..))">
<aop:advisor advice-ref="txAdvice" pointcut-ref="pointCut"></aop:advisor>
</aop:pointcut></aop:config>
SpringMVC的学习
SpringMVC是什么？
SpringMVC是Spring为我们提供的表现层的一站式解决方案。
开发WEB端的一些常见问题
服务器端的请求转发/重定向与浏览器解析路径： / 的区别
- 在服务器端解析
/时，路径为：协议+端口号+上下文路径 - 浏览器解析
/时，路径为：协议+端口号
mvc:annotation-driven 注解驱动的作用
- 在使用
view-controller标签时 - 在使用
@RequestBody与@RequestResponse时 - 在设置静态静态资源时需要配合
<mvc:default-servlet-handler></mvc:default-servlet-handler>使用
RequestMapping注解
value属性
- 表示需要跳转到逻辑视图
method属性
- 表示能够接收到请求方式，RequestMethod枚举类中可以看到能够设置的值
params属性（了解）
- “param”：要求请求映射所匹配的请求必须携带param请求参数
- “!param”：要求请求映射所匹配的请求必须不能携带param请求参数
- “param=value”：要求请求映射所匹配的请求必须携带param请求参数且param=value
-
“param!=value”：要求请求映射所匹配的请求必须携带param请求参数但是param!=value
-
“header”：要求请求映射所匹配的请求必须携带header请求头信息
- “!header”：要求请求映射所匹配的请求必须不能携带header请求头信息
- “header=value”：要求请求映射所匹配的请求必须携带header请求头信息且header=value
- “header!=value”：要求请求映射所匹配的请求必须携带header请求头信息且header!=value
- 提示：若当前请求满足@RequestMapping注解的value和method属性，但是不满足headers属性，此时页面显示404错误，即资源未找到
SpringMVC支持ant风格的路径（了解）
- ？：表示任意的单个字符
- *：表示任意的0个或多个字符
- **：表示任意层数的任意目录
- 注意：在使用时，只能使用//xxx的方式
支持路径中的占位符（重点）,RestFul风格接口
@RequestMapping("/testRest/{id}/{username}")
public String testRest(@PathVariable("id") String id, @PathVariable("username")
String username) {
System.out.println("id:" + id + ",username:" + username);
return "success";
}
获取请求参数
通过原生ServletAPI获取
@RequestMapping("/testParam")
public String testParam(HttpServletRequest request) {
String username = request.getParameter("username");
String password = request.getParameter("password");
System.out.println("username:" + username + ",password:" + password);
return "success";
}
通过控制器方法的形参获取请求参数
@RequestMapping("/testParam")
public String testParam(String username, String password) {
System.out.println("username:" + username + ",password:" + password);
return "success";
}
@RequestParam注解
- @RequestParam是将请求参数和控制器方法的形参创建映射关系
- @RequestParam注解一共有三个属性：
- value：指定为形参赋值的请求参数的参数名
- required：设置是否必须传输此请求参数，默认值为true
- 若设置为true时，则当前请求必须传输value所指定的请求参数，若没有传输该请求参数，且没有设置defaultValue属性，则页面报错400：Required String parameter ‘xxx’ is not present；若设置为false，则当前请求不是必须传输value所指定的请求参数，若没有传输，则注解所标识的形参的值为null
-
defaultValue：不管required属性值为true或false，当value所指定的请求参数没有传输或传输的值为””时，则使用默认值为形参赋值
-
@RequestHeader是将请求头信息和控制器方法的形参创建映射关系
- @RequestHeader注解一共有三个属性：value、required、defaultValue，用法同@RequestParam
@CookieValue（了解）
- @CookieValue是将浏览器发送的Cookie信息和控制器方法的形参创建映射关系
- 用法同@RequestParam
通过POJO获取请求参数
- 在控制器的形参列表写上一个POJO类型时，SpringMVC会自动通过request.getParameter()获取参数后封装到该POJO类中
@RequestMapping("/testPojoParam")
public String testParam(User user) {
System.out.println(user);
return "success";
}
解决获取参数的乱码问题
- 一旦使用了reqeust.getParameter() 获取了参数之后， 再设置编码就没有效果了。而SpringMVC帮助我们封装了Servlet，我们只需要编写控制器， 而进入到控制器方法之前，SpringMVC已经帮助我们获取过参数了，此时再设置编码就没有效果了。
- 因此我们需要在SpringMVC的Servlet执行之前进行编码的过滤，这个时候我们可以考虑使用 过滤器，虽然我们自己写一个过滤器也可以，但是SpringMVC已经为我们提供了编码过滤器了
在web.xml中配置SpringMVC提供的编码过滤器
<filter>
<filter-name>CharacterEncodingFilter</filter-name>
<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
<!-- 如果只配置encoding，则只会设置request.setCharacterEncoding的编码 ，但是不会设置response的响应编码 -->
<init-param>
<param-name>encoding</param-name>
<param-value>UTF-8</param-value>
</init-param>
<!-- 设置该参数后，还会设置response的响应编码 -->
<init-param>
<param-name>forceEncoding</param-name>
<param-value>true</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>CharacterEncodingFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
过滤器的过滤源码
protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
String encoding = this.getEncoding();
if (encoding != null) {
if (this.isForceRequestEncoding() || request.getCharacterEncoding() == null) {
request.setCharacterEncoding(encoding);
}
if (this.isForceResponseEncoding()) {
response.setCharacterEncoding(encoding);
}
}
filterChain.doFilter(request, response);
}
域对象共享数据
使用ServletAPI向request域对象共享数据
@RequestMapping("/index")
public String index(HttpServletRequest request) {
request.setAttribute("username","张三");
return "index";
}
使用ModelAndView向request域对象共享数据
@RequestMapping("/modelAndView")
public ModelAndView testModelAndView() {
ModelAndView mv = new ModelAndView();
mv.addObject("username","李四");
mv.setViewName("index");
return mv;
}
使用Model向request域对象共享数据
@RequestMapping("/model")
public String testModelAndView(Model model) {
model.addAttribute("username","王五");
return "index";
}
使用map向request域对象共享数据
@RequestMapping("/map")
public String testModelAndView(Map<string, object> map) {
map.put("username","赵流");
return "index";
}
</string,>
使用ModelMap向request域对象共享数据
@RequestMapping("/modelMap")
public String testModelAndView(ModelMap modelMap) {
// 两种方式都可以
modelMap.put("username","田七");
modelMap.addAttribute("username2","田七2");
return "index";
}
Model、ModelMap、Map的关系
- SpringMVC在进行视图解析时，最终都会将这些类转换为ModelAndView
- 在DispatcherServlet的第1067行可以看到
mv = ha.handle(processedRequest, response, mappedHandler.getHandler());，最终这些类型都会被转换为ModelAndView
向session域共享数据
@RequestMapping("/session")
public String session(HttpSession session) {
session.setAttribute("username","王八");
return "index";
}
向application域共享数据
@RequestMapping("/application")
public String application(HttpSession session) {
ServletContext servletContext = session.getServletContext();
servletContext.setAttribute("username","九九");
return "index";
}
SpringMVC的视图
ThymeleafView
- 当控制器中所设置的视图名称没有任何前缀时，此时的视图名称会被SpringMVC中所配置的视图解析器解析，如果视图解析器配置了Thymeleaf解析器，那么将会使用ThymeleafView来解析。
- 可以通过debug DispatcherServlet的render方法查看，1377行
InternalResourceView转发视图
- 当控制器中所设置的视图名称前缀为：
forward:时，将会使用InternalResourceView视图解析器来解析，但是如果使用了该视图解析器跳转视图，会导致页面无法被Thymeleaf模板引擎所渲染。
RedirectView 重定向视图
- 当控制器中所设置的视图名称前缀为：
redirect:时，将会使用RedirectView视图解析器所解析，进行页面的重定向。
视图控制器view-controller
- 当有一些控制器，我们 仅仅是用来进行页面跳转时，就可以使用view-controller
- 当SpringMVC中设置任何一个view-controller时， 其他控制器中的请求映射将全部失效，此时需要在SpringMVC的核心配置文件中设置开启mvc注解驱动的标签
- 在springmvc.xml文件中进行配置
- 添加注解驱动
- 添加一个view-contoller
<!--当SpringMVC中设置任何一个view-controller时，其他控制器中的请求映射将全部失效
此时需要在SpringMVC的核心配置文件中设置开启mvc注解驱动的标签-->
<mvc:annotation-driven></mvc:annotation-driven>
<mvc:view-controller path="/login" view-name="login">
</mvc:view-controller>
RestFul风格
操作 传统方式 RESTFul风格 查询单个用户 getUserById?id=1 user/1 –> get请求方式 查询所有用户 getUserList user –> get请求方式 新增用户 saveUser user –> post请求方式 删除用户 delUser?id=1 user/1 –> delete请求方式 更新用户 updateUser user –> put请求方式 更新用户界面 updateUserPage user/1 –> put请求方式
HiddenHttpMethodFilter过滤器
- 当我们的表单想要提交一个put或者delete请求时，可以使用该过滤器
- 使用方式：
（1）设置form表单的提交方式为post
（2）在form表单中添加一个隐藏的input，设置name为_method，其value值为需要请求的方式 - 配置HiddenHttpMethodFilter过滤器
<filter>
<filter-name>HiddenHttpMethodFilter</filter-name>
<filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>HiddenHttpMethodFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
- 页面的使用方式
<form th:action="@{/user/1}" method="post">
<input type="hidden" name="_method" value="delete">
<input type="submit" value="点击删除">
</form>
处理AJAX请求，使用axiso
@RequestBody（必须使用Post才有请求体）
- 会获取当前请求的请求体，为当前注解所标识的形参赋值（注意： 类型为实体类或Map）
- 使用步骤
（1）导入Jackson依赖
（2）添加注解驱动
（3）在控制器的形参前标志即可
<dependency>
<groupid>com.fasterxml.jackson.core</groupid>
<artifactid>jackson-databind</artifactid>
<version>2.12.1</version>
</dependency>
<!--开启mvc的注解驱动-->
<mvc:annotation-driven>
</mvc:annotation-driven>
@ResponseBody
- 将控制器方法的返回值作为响应报文直接响应给前端页面
- 使用步骤
（1）导入Jackson依赖
（2）添加注解驱动
（3）在控制器的方法上声明该注解即可
文件上传与下载
文件下载
@RequestMapping("/testDown")
public ResponseEntity<byte[]> testResponseEntity(HttpSession session) throws
IOException {
//获取ServletContext对象
ServletContext servletContext = session.getServletContext();
//获取服务器中文件的真实路径
String realPath = servletContext.getRealPath("/static/img/2.jpg");
//创建输入流
InputStream is = new FileInputStream(realPath);
//创建字节数组
byte[] bytes = new byte[is.available()];
//将流读到字节数组中
is.read(bytes);
//创建HttpHeaders对象设置响应头信息
MultiValueMap<string, string> headers = new HttpHeaders();
//设置要下载方式以及下载文件的名字
headers.add("Content-Disposition", "attachment;filename=1.jpg");
//设置响应状态码
HttpStatus statusCode = HttpStatus.OK;
//创建ResponseEntity对象
ResponseEntity<byte[]> responseEntity = new ResponseEntity<>(bytes, headers,
statusCode);
//关闭输入流
is.close();
return responseEntity;
}
</byte[]></string,></byte[]>
文件上传
- 配置文件上传解析器
<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver"></bean>
- 添加依赖
<dependency>
<groupid>commons-fileupload</groupid>
<artifactid>commons-fileupload</artifactid>
<version>1.3.1</version>
</dependency>
- 使用示例
### 前端代码
<form th:action="@{/testUpload}" method="post" enctype="multipart/form-data">
<input type="file" name="myFile">
<input type="submit" value="点击上传">
</form>
### 后端代码
@ResponseBody
@RequestMapping("/testUpload")
public String testUpload(MultipartFile myFile, HttpSession session) throws IOException {
// 获取当前得到的文件名
String oldFileName = myFile.getOriginalFilename();
String newFileName = UUID.randomUUID() + oldFileName.substring(oldFileName.lastIndexOf("."));
// 获取到服务器的资源路径
ServletContext servletContext = session.getServletContext();
String realPath = servletContext.getRealPath("/static/img");
File file = new File(realPath);
if (!file.exists()) {
file.mkdirs();
}
// 将文件转存到服务器上
File realFile = new File(realPath + File.separator + newFileName);
myFile.transferTo(realFile);
return "上传成功";
}
拦截器
- 用于拦截控制器方法的执行，如果配置了多个拦截器，将会按照配置的 顺序执行preHandle，然后 按照逆序执行postHandle和afterCompletion
- 配置一个拦截器
@Component
public class FirstInterceptor implements HandlerInterceptor {
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
System.out.println("控制器方法执行之前：FirstInterceptor --> preHandle");
return true;
}
@Override
public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
System.out.println("控制器方法执行之后：FirstInterceptor --> postHandle");
}
@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
System.out.println("控制器方法执行且视图渲染完毕后：afterCompletion --> afterCompletion");
}
}
- 在SpringMVC中配置
<mvc:interceptors>
<mvc:interceptor>
<!-- 可以直接通过bean的方式配置拦截器 <bean></bean>-->
<!-- /* 代表一层上下文路径，/**代表所有路径 -->
<mvc:mapping path="/**">
<!-- 排除的路径 -->
<mvc:exclude-mapping path="/testRequestEntity">
<!-- 通过引用的方式配置拦截器 -->
<ref bean="firstInterceptor"></ref>
</mvc:exclude-mapping></mvc:mapping></mvc:interceptor>
</mvc:interceptors>
异常处理器
SpringMVC的异常处理机制
- 通过HandlerExceptionResolver进行项目中异常的处理，其大致的关系如下
基于XML的异常处理
<bean class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">
<property name="exceptionMappings">
<props>
<!--
properties的键表示处理器方法执行过程中出现的异常
properties的值表示若出现指定异常时，设置一个新的视图名称，跳转到指定页面
-->
<prop key="java.lang.ArithmeticException">error</prop>
</props>
</property>
<!--
exceptionAttribute属性设置一个属性名，将出现的异常信息在请求域中进行共享
-->
<property name="exceptionAttribute" value="ex"></property>
</bean>
基于注解的异常处理
//@ControllerAdvice将当前类标识为异常处理的组件
@ControllerAdvice
public class DIYExceptionResolver{
//@ExceptionHandler用于设置所标识方法处理的异常
@ExceptionHandler(ArithmeticException.class)
//ex表示当前请求处理中出现的异常对象
public String handleArithmeticException(Exception ex, Model model){
model.addAttribute("ex", ex);
// 返回逻辑视图
return "error";
}
}
使用纯注解的方式代替SpringMVC配置文件和web.xml文件
在Servlet3.0环境中，容器会在类路径中查找实现javax.servlet. ServletContainerInitializer接口的类，如果找到的话就用它来配置Servlet容器。 Spring提供了这个接口的实现，名为 SpringServletContainerInitializer，这个类反过来又会查找实现WebApplicationInitializer的类并将配置的任务交给它们来完成。Spring3.2引入了一个便利的WebApplicationInitializer基础实现，名为 AbstractAnnotationConfigDispatcherServletInitializer，当我们的类扩展了 AbstractAnnotationConfigDispatcherServletInitializer并将其部署到Servlet3.0容器的时候，容器会自动发现它，并用它来配置Servlet上下文。
编写一个WebConfig用来代替web.xml文件
import org.springframework.web.filter.CharacterEncodingFilter;
import org.springframework.web.filter.HiddenHttpMethodFilter;
import org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer;
import javax.servlet.Filter;
public class WebConfig extends AbstractAnnotationConfigDispatcherServletInitializer {
/**
* 获取Spring容器的配置
*
* @return
*/
@Override
protected Class<?>[] getRootConfigClasses() {
return new Class[]{SpringConfig.class};
}
/**
* 获取SpringMVC的配置
*
* @return
*/
@Override
protected Class<?>[] getServletConfigClasses() {
return new Class[]{SpringmvcConfig.class};
}
/**
* @return 指定DispatcherServlet的映射规则，也就是url-pattern
*/
@Override
protected String[] getServletMappings() {
return new String[]{"/"};
}
@Override
protected Filter[] getServletFilters() {
CharacterEncodingFilter encodingFilter = new CharacterEncodingFilter();
encodingFilter.setEncoding("UTF-8");
encodingFilter.setForceRequestEncoding(true);
HiddenHttpMethodFilter hiddenHttpMethodFilter = new
HiddenHttpMethodFilter();
return new Filter[]{encodingFilter, hiddenHttpMethodFilter};
}
}
编写SpringmvcConfig代替springmvc配置文件
import com.codestars.interceptor.MyInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.context.ContextLoader;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.multipart.commons.CommonsMultipartResolver;
import org.springframework.web.servlet.HandlerExceptionResolver;
import org.springframework.web.servlet.ViewResolver;
import org.springframework.web.servlet.config.annotation.*;
import org.springframework.web.servlet.handler.SimpleMappingExceptionResolver;
import org.thymeleaf.spring5.SpringTemplateEngine;
import org.thymeleaf.spring5.view.ThymeleafViewResolver;
import org.thymeleaf.templatemode.TemplateMode;
import org.thymeleaf.templateresolver.ITemplateResolver;
import org.thymeleaf.templateresolver.ServletContextTemplateResolver;
import java.util.List;
// 1、配置包扫描
@ComponentScan("com.codestars")
// 4、配置注解驱动
@EnableWebMvc
// 标志为一个Spring配置类
@Configuration
public class SpringmvcConfig implements WebMvcConfigurer {
/**
* 3、配置视图控制器
* @param registry
*/
@Override
public void addViewControllers(ViewControllerRegistry registry) {
registry.addViewController("/").setViewName("index");
}
/**
* 5、配置让tomcat处理静态资源
* @param configurer
*/
@Override
public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
configurer.enable();
}
/**
* 6、配置拦截器
* @param registry
*/
@Override
public void addInterceptors(InterceptorRegistry registry) {
MyInterceptor myInterceptor = new MyInterceptor();
registry.addInterceptor(myInterceptor).addPathPatterns("/**");
}
/**
* 7、配置异常处理器
* @param resolvers
*/
@Override
public void extendHandlerExceptionResolvers(List<handlerexceptionresolver> resolvers) {
SimpleMappingExceptionResolver smer1 = new SimpleMappingExceptionResolver();
// 配置需要处理的异常、逻辑视图、共享异常的键
smer1.setMappedHandlerClasses(RuntimeException.class);
smer1.setDefaultErrorView("error");
smer1.setExceptionAttribute("ex");
resolvers.add(smer1);
}
/**
* 8、配置文件上传解析器
* @return
*/
@Bean
public CommonsMultipartResolver commonsMultipartResolver() {
return new CommonsMultipartResolver();
}
//配置生成模板解析器
@Bean
public ITemplateResolver templateResolver() {
WebApplicationContext webApplicationContext =
ContextLoader.getCurrentWebApplicationContext();
// ServletContextTemplateResolver需要一个ServletContext作为构造参数，可通过WebApplicationContext 的方法获得
ServletContextTemplateResolver templateResolver = new
ServletContextTemplateResolver(
webApplicationContext.getServletContext());
templateResolver.setPrefix("/WEB-INF/templates/");
templateResolver.setSuffix(".html");
templateResolver.setCharacterEncoding("UTF-8");
templateResolver.setTemplateMode(TemplateMode.HTML);
return templateResolver;
}
//生成模板引擎并为模板引擎注入模板解析器
@Bean
public SpringTemplateEngine templateEngine(ITemplateResolver
templateResolver) {
SpringTemplateEngine templateEngine = new SpringTemplateEngine();
templateEngine.setTemplateResolver(templateResolver);
return templateEngine;
}
//生成视图解析器并未解析器注入模板引擎
@Bean
public ViewResolver viewResolver(SpringTemplateEngine templateEngine) {
ThymeleafViewResolver viewResolver = new ThymeleafViewResolver();
viewResolver.setCharacterEncoding("UTF-8");
viewResolver.setTemplateEngine(templateEngine);
return viewResolver;
}
}
</handlerexceptionresolver>
配置SpringConfig代替spring的配置文件
/**
* 暂时没有内容
*/
@Configuration
public class SpringConfig {
}
整合SSM的步骤
需要思考的问题
SpringMVC容器的创建时机与Spring的创建时机，SpringMVC的控制层需要访问Spring的业务层该怎么办
- SpringMVC的中央控制器在配置了
load-on-startup后是跟随Tomcat容器启动时进行启动的 - SpringMVC的控制层会依赖Spring的管理的业务层，那么Spring的容器就一定要在SpringMVC创建之前进行创建。
- 根据WEB的三大组件我们可以知道他们的执行顺序为： Listener -> Filter -> Servlet
- 因此我们可以在Listener或Filter中来优先创建Spring的IOC容器，那么选择哪个更合适呢？
- 首先是可以通过Filter的初始化方法来完成对SpringIOC容器的初始化，但是过滤器本来应该做的事就是过滤请求，那之后的每一个请求都会经过该过滤器，而该过滤器就啥也不干就放行？这显然不太合理
- 因此我们考虑到了Listener，Listener一共有8个，首当其中我们选择的是ServletContextListener
- 因此我们只要配置一个ServletContextListener在我们的Web容器初始化时创建SpringIOC的容器，并且也可以使得创建的速度比SpringMVC的IOC容器更快
- SpringIOC容器和SpringMVC的IOC容器在创建后都会存放到Application作用域当中，当SpringMVC的IOC容器在进行创建时，会将Spring的容器作为SpringMVC容器的父容器，可以 访问父容器中的组件。但是父容器 不能访问子容器中的组件。
正式开始整合SSM
创建一个Javaweb项目
（1）引入maven依赖（spring、springmvc、mybaits、thymeleaf、数据库驱动、连接池）
<packaging>war</packaging>
<properties>
<spring.version>5.3.18</spring.version>
</properties>
<dependencies>
<dependency>
<groupid>org.springframework</groupid>
<artifactid>spring-context</artifactid>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupid>org.springframework</groupid>
<artifactid>spring-beans</artifactid>
<version>${spring.version}</version>
</dependency>
<!--springmvc-->
<dependency>
<groupid>org.springframework</groupid>
<artifactid>spring-web</artifactid>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupid>org.springframework</groupid>
<artifactid>spring-webmvc</artifactid>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupid>org.springframework</groupid>
<artifactid>spring-jdbc</artifactid>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupid>org.springframework</groupid>
<artifactid>spring-aspects</artifactid>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupid>org.springframework</groupid>
<artifactid>spring-test</artifactid>
<version>${spring.version}</version>
</dependency>
<!-- Mybatis核心 -->
<dependency>
<groupid>org.mybatis</groupid>
<artifactid>mybatis</artifactid>
<version>3.5.7</version>
</dependency>
<!--mybatis和spring的整合包-->
<dependency>
<groupid>org.mybatis</groupid>
<artifactid>mybatis-spring</artifactid>
<version>2.0.6</version>
</dependency>
<!-- 连接池 -->
<dependency>
<groupid>com.alibaba</groupid>
<artifactid>druid</artifactid>
<version>1.0.9</version>
</dependency>
<!-- junit测试 -->
<dependency>
<groupid>junit</groupid>
<artifactid>junit</artifactid>
<version>4.12</version>
<scope>test</scope>
</dependency>
<!-- MySQL驱动，连接数据库 -->
<dependency>
<groupid>mysql</groupid>
<artifactid>mysql-connector-java</artifactid>
<version>8.0.16</version>
</dependency>
<!-- log4j日志，mybatis需要 -->
<dependency>
<groupid>log4j</groupid>
<artifactid>log4j</artifactid>
<version>1.2.17</version>
</dependency>
<!-- mybatis的分页插件 -->
<dependency>
<groupid>com.github.pagehelper</groupid>
<artifactid>pagehelper</artifactid>
<version>5.2.0</version>
</dependency>
<!-- 日志，thymeleaf依赖于slf4j，而logback是slf4j的实现 -->
<dependency>
<groupid>ch.qos.logback</groupid>
<artifactid>logback-classic</artifactid>
<version>1.2.3</version>
</dependency>
<!-- ServletAPI -->
<dependency>
<groupid>javax.servlet</groupid>
<artifactid>javax.servlet-api</artifactid>
<version>3.1.0</version>
<scope>provided</scope>
</dependency>
<!-- ResponseBody与RequestBody依赖于jackson -->
<dependency>
<groupid>com.fasterxml.jackson.core</groupid>
<artifactid>jackson-databind</artifactid>
<version>2.12.1</version>
</dependency>
<!-- 文件上传 -->
<dependency>
<groupid>commons-fileupload</groupid>
<artifactid>commons-fileupload</artifactid>
<version>1.3.1</version>
</dependency>
<!-- Spring5和Thymeleaf整合包 -->
<dependency>
<groupid>org.thymeleaf</groupid>
<artifactid>thymeleaf-spring5</artifactid>
<version>3.0.12.RELEASE</version>
</dependency>
<!-- lombok插件-->
<dependency>
<groupid>org.projectlombok</groupid>
<artifactid>lombok</artifactid>
<version>1.18.24</version>
<scope>provided</scope>
</dependency>
</dependencies>
配置web.xml文件（2个过滤器、一个Servlet、一个监听器）
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemalocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd" version="4.0">
<!-- 1. 配置编码过滤器 -->
<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>forceEncoding</param-name>
<param-value>true</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>CharacterEncodingFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
<!-- 2.配置表单提交过滤器 -->
<filter>
<filter-name>HiddenHttpMethodFilter</filter-name>
<filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>HiddenHttpMethodFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
<!-- 3. 配置核心Servlet接收所有的请求，不包括.jsp结尾-->
<servlet>
<servlet-name>DispatcherServlet</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<!-- 配置springmvc的配置文件 -->
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:springmvc.xml</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>DispatcherServlet</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
<!-- 在ContextServlet上下文启动时就加载SpringIOC容器-->
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<!-- 配置SpringIOC容器的路径 -->
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:spring.xml</param-value>
</context-param>
</web-app>
配置springmvc.xml文件
<?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" xmlns:mvc="http://www.springframework.org/schema/mvc" xsi:schemalocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd">
<!-- 1. 扫描控制层组件 -->
<context:component-scan base-package="com.codestars.controller">
<!-- 2. 配置视图解析器ThymeleafView -->
<bean id="viewResolver" class="org.thymeleaf.spring5.view.ThymeleafViewResolver">
<property name="order" value="1">
<property name="characterEncoding" value="UTF-8">
<property name="templateEngine">
<bean class="org.thymeleaf.spring5.SpringTemplateEngine">
<property name="templateResolver">
<bean class="org.thymeleaf.spring5.templateresolver.SpringResourceTemplateResolver">
<!-- 视图前缀 -->
<property name="prefix" value="/WEB-INF/templates/">
<!-- 视图后缀 -->
<property name="suffix" value=".html">
<property name="templateMode" value="HTML5">
<property name="characterEncoding" value="UTF-8">
</property></property></property></property></bean>
</property>
</bean>
</property>
</property></property></bean>
<!-- 3. 配置注解驱动-->
<mvc:annotation-driven>
<!-- 4. 当springmvc处理不了时，让tomcat默认servlet来处理 -->
<mvc:default-servlet-handler>
<!-- 5. 配置仅用于页面跳转到view-controller，如果不配置注解驱动，将会只能访问view-controller中配置的处理器（报红不影响） -->
<mvc:view-controller path="/" view-name="index">
<!-- 6. 配置文件上传解析器 -->
<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver"></bean>
<!-- 7. 配置拦截器 -->
<!--<mvc:interceptors>-->
<!-- <bean class=""></bean>-->
<!-- <mvc:interceptor>-->
<!-- <!– /** 代表所有路径， /* 代表一层路径 –>-->
<!-- <mvc:mapping path="/user/**"/>-->
<!-- <!– 需要排除的路径–>-->
<!-- <mvc:exclude-mapping path=""/>-->
<!-- </mvc:interceptor>-->
<!--</mvc:interceptors>-->
<!-- 8. 配置异常处理器 -->
<bean class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">
<!-- 异常的逻辑视图-->
<property name="defaultErrorView" value="error"></property>
<!-- 定义需要处理的异常 -->
<property name="mappedHandlerClasses">
<array>
<value>java.lang.Throwable</value>
</array>
</property>
<!-- 请求域中错误信息的key -->
<property name="exceptionAttribute" value="ex"></property>
</bean>
</mvc:view-controller></mvc:default-servlet-handler></mvc:annotation-driven></context:component-scan></beans>
配置spring.xml文件
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:context="http://www.springframework.org/schema/context" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:util="http://www.springframework.org/schema/util" xmlns:tx="http://www.springframework.org/schema/tx" 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.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/util https://www.springframework.org/schema/util/spring-util.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">
<!-- 1. 配置需要加载的配置文件 -->
<context:property-placeholder location="classpath:jdbc.properties">
<!-- 2. 扫描包，排除控制层的包，因为控制层需要交给SpringMVC的IOC容器管理 -->
<context:component-scan base-package="com.codestars">
<context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller">
</context:exclude-filter></context:component-scan>
<!-- 3. 配置数据源 -->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
<property name="driverClassName" value="${jdbc.driver}"></property>
<property name="url" value="${jdbc.url}"></property>
<property name="username" value="${jdbc.username}"></property>
<property name="password" value="${jdbc.password}"></property>
<property name="initialSize" value="${jdbc.initialSize}"></property>
<property name="maxActive" value="${jdbc.maxActive}"></property>
<property name="maxWait" value="${jdbc.maxWait}"></property>
</bean>
<!-- 4. 整合mybatis第一步：配置SqlSessionFactoryBean，其中的getObject可以获取到SqlSessionFactory -->
<bean class="org.mybatis.spring.SqlSessionFactoryBean">
<!-- 配置mybatis的全局配置文件，如果该配置文件中的属性都在该SqlSessionFactoryBean配置完毕，则该属性可以删除 -->
<!--<property name="configLocation" value="classpath:mybatis-config.xml"></property>-->
<!-- 配置数据源 -->
<property name="dataSource" ref="dataSource"></property>
<!-- 配置别名-->
<property name="typeAliasesPackage" value="com.codestars.pojo"></property>
<!-- 如果xml映射文件与mapper接口不在一个包下，需要配置该属性 -->
<property name="mapperLocations" value="classpath:mappers/*.xml"></property>
<!-- 配置分页插件 -->
<property name="plugins">
<array>
<bean class="com.github.pagehelper.PageInterceptor">
<property name="properties">
<props>
<!-- 配置合理化页码 -->
<prop key="reasonable">true</prop>
</props>
</property>
</bean>
</array>
</property>
<!-- 配置SessionSqlFactory的全局setting -->
<property name="configurationProperties">
<props>
<!-- 延迟加载 -->
<prop key="lazyLoadingEnabled">true</prop>
<prop key="aggressiveLazyLoading">false</prop>
<!-- 二级缓存 -->
<prop key="cacheEnabled">true</prop>
<!-- 数据库下划线与实体类驼峰转换 -->
<prop key="mapUnderscoreToCamelCase">true</prop>
</props>
</property>
</bean>
<!--
4. 整合Mybatis第二步：获取第一步配置的SqlSessionFactory拿到所有Mapper接口映射的代理对象，
然后交给SpringIOC容器管理（非常重要）
-->
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
<property name="basePackage" value="com.codestars.mapper"></property>
</bean>
<!-- 5. 开启基于注解的aop功能 -->
<aop:aspectj-autoproxy>
<!-- 6. 配置声明式事物 -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"></property>
</bean>
<!-- 7. 配置使@Transactional标识的类或方法成为连接点 -->
<tx:annotation-driven>
<!-- 基于XML的AOP配置-->
<!--<aop:config>-->
<!-- <aop:pointcut id="pointCut" expression="execution(* com.codestars.service.impl.*.*(..))"/>-->
<!-- <aop:aspect ref="">-->
<!-- <aop:before method=""></aop:before>-->
<!-- <aop:after method=""></aop:after>-->
<!-- <aop:after-returning method=""></aop:after-returning>-->
<!-- <aop:after-throwing method=""></aop:after-throwing>-->
<!-- </aop:aspect>-->
<!--</aop:config>-->
</tx:annotation-driven></aop:aspectj-autoproxy></context:property-placeholder></beans>
配置log4j.xml文件
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">
<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">
<appender name="STDOUT" class="org.apache.log4j.ConsoleAppender">
<param name="Encoding" value="UTF-8">
<layout class="org.apache.log4j.PatternLayout">
<param name="ConversionPattern" value="%-5p %d{MM-dd HH:mm:ss,SSS}
%m (%F:%L) \n">
</layout>
</appender>
<logger name="java.sql">
<level value="debug">
</level></logger>
<logger name="org.apache.ibatis">
<level value="info">
</level></logger>
<root>
<level value="debug">
<appender-ref ref="STDOUT">
</appender-ref></level></root>
</log4j:configuration>
配置jdbc.properties文件
jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/ssm?useSSL=false&useUnicode=true&characterEncoding=utf8&serverTimezone=Asia/Shanghai
jdbc.username=root
jdbc.password=abc123
初始连接数量
jdbc.initialSize=5
最大连接数量
jdbc.maxActive=10
最大等待时间，单位毫秒
jdbc.maxWait=3000
配置mybatis-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>
<!-- 各个不同配置的顺序
properties?,settings?,typeAliases?,typeHandlers?,objectFactory?,objectWrapperFactory?,
reflectorFactory?,plugins?,environments?,databaseIdProvider?,mappers?
-->
<!-- 引入外部配置文件，从根路径下找 -->
<properties resource="jdbc.properties">
<settings>
<!--开启延迟加载功能-->
<setting name="lazyLoadingEnabled" value="true">
<!-- 关闭该功能后，才能进行按需加载，与lazyLoadingEnabled 配合使用-->
<setting name="aggressiveLazyLoading" value="false">
<!-- 开启二级缓存，作用范围为一个SqssionFactory -->
<setting name="cacheEnabled" value="true">
<!-- 配置数据库字段下划线与JAVA实体类的驼峰映射 -->
<setting name="mapUnderscoreToCamelCase" value="true">
</setting></setting></setting></setting></settings>
<!-- 配置别名 -->
<typealiases>
<package name="com.codestarts.pojo">
</package></typealiases>
<plugins>
<!--设置分页插件-->
<plugin interceptor="com.github.pagehelper.PageInterceptor"></plugin>
</plugins>
<!-- 配置一个个的环境，其中主要配置了事务管理的方式和数据源 -->
<environments default="development">
<environment id="development">
<!--
配置采用的事务管理方式，JDBC：编程式事务管理，
MANAGER：啥也不干，让容器来管理事务的整个生命周期
-->
<transactionmanager type="JDBC">
<!--
POOLED：采用数据库连接池的方式来获取连接
UNPOOLED：每一个连接都直接通过访问数据库获得
JNDI ：上下文数据源引用（了解）
-->
<datasource type="POOLED">
<property name="driver" value>
<property name="url" value>
<property name="username" value>
<property name="password" value>
</property></property></property></property></datasource>
</transactionmanager></environment>
<!-- 可以配置多个，自行选择 -->
<environment id="test">
<transactionmanager type="JDBC">
<datasource type="POOLED">
<property name="driver" value>
<property name="url" value>
<property name="username" value>
<property name="password" value>
</property></property></property></property></datasource>
</transactionmanager></environment>
</environments>
<mappers>
<!-- 配置单个的方式mappers/UserMapper.xml代表根路径下的mappers/UserMapper -->
<!--<mapper resource="mappers/UserMapper.xml"></mapper>-->
<!--
配置mapper接口与mapper.xml所在的包，
注意mapper接口和mapper.xml的名字必须一致
注意接口与mapper必须在同一个包下
-->
<package name="com.codestarts.mapper">
</package></mappers>
</properties></configuration>
最终项目目录结构
Original: https://www.cnblogs.com/itdqx/p/16630335.html
Author: code_Stars
Title: JAVA入门基础_从零开始的培训_SSM的学习
原创文章受到原创版权保护。转载请注明出处：https://www.johngo689.com/594018/
转载文章受原作者版权保护。转载请注明原作者出处！