【Java后端】MVC学习笔记（完整详细版）

符号说明

🔥开发中较多使用，因文章多为干货，因此较难而且重要的才会标此符号

💧开发中较少使用

一、SSM

SSM是市面上最流行的Web开发框架，由SpringMVC、Spring、MyBatis整合而成。其中，SpringMVC负责接收浏览器发送的请求，并响应浏览器数据；Spring使用IOC思想管理服务器中各个组件，使用AOP思想面向切面编程，在不改变源码的基础上实现功能增强；MyBatis封装JDBC，负责访问数据库，完成持久化操作。

二、Mybatis--持久层框架

2.1 Introduction

Mybatis是支持定制化SQL、存储过程以及高级映射的优秀持久层框架，避免了JDBC和手动设置参数，使用XML文件进行配置

2.2 IDE

2.2.1 Empty project

创建一个空项目，选择JDK和语言

配置Maven工具

设置打包方式和导入依赖类

 <!-- 设置打包方式 --> <packaging>jar</packaging> <dependencies> <!-- Mybatis核心 --> <dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis</artifactId> <version>3.5.10</version> </dependency> <!-- junit测试 --> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.13.2</version> <scope>test</scope> </dependency> <!-- MySQL驱动 --> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>8.0.29</version> </dependency> <dependency> <groupId>org.projectlombok</groupId> <artifactId>lombok</artifactId> <version>RELEASE</version> <scope>compile</scope> </dependency> </dependencies>

安装MybatisX插件

这个可是宝藏插件了，为提高开发效率而生，其主要功能如下

红蓝小鸟图标，长得好看，图标快速跳转对应页面
⭐️提示快速生产xml、sql语句等信息
⭐️逆向工程，详看2.10

2.2.2 Pojo

创建实体类对象User

@Data：ToString()、Getter()、Setter()等一些常见方法

@AllArgsConstructor：全参构造方法

@NoArgsConstructor：无参构造方法

package com.bcn.mybatis.pojo; import lombok.AllArgsConstructor; import lombok.Data; import lombok.NoArgsConstructor; / * @author 大白菜 * {@code @date} Created in 2022/7/22 12:31 */ @Data @AllArgsConstructor @NoArgsConstructor public class User { private Integer id; private String username; private String password; private Integer age; private String gender; private String email; }

2.2.3 Configuration File

一般叫做mybatis-config.xml，在整合Spring之后，这个配置文件可以直接省略了

主要用于配置数据库环境、pojo和mapper的映射文件

放置在src/main/resources目录下

<?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> <!--pojo映射文件--> <typeAliases> <package name="com.bcn.mybatis.pojo"/> </typeAliases> <!--配置连接数据库的环境--> <environments default="development"> <environment id="development"> <transactionManager type="JDBC"/> <dataSource type="POOLED"> <property name="driver" value="com.mysql.cj.jdbc.Driver"/> <property name="url" value="jdbc:mysql://localhost:3306/ssm?serverTimezone=UTC"/> <property name="username" value="root"/> <property name="password" value=""/> </dataSource> </environment> </environments> <!--Mapper映射文件--> <mappers> <package name="com.bcn.mybatis.mapper" /> </mappers> </configuration>

2 transactionManager：事务管理方式，共两种，一个是JDBC也就是原生的，一个是MANAGED是被管理的，在Spring整合Mybatis的时候是使用这种方式

2.2.4 Mapper.xml

相关概念：ORM（Object Relationship Mapping）对象关系映射。

对象：Java的实体类对象

关系：关系型数据库

映射：二者之间的对应关系

所以~Mapper.xml是MyBatis的映射文件，主要功能是编写SQL语句，位于src/main/resources/com.bcn.mybatis.mapper目录下

注意：这里的创建com.bcn.mybatis.mapper文件夹时，输入的内容得是com/bcn/mybatis/mapper而不能是com.bcn.mybatis.mapper。该文件夹应该与java目录下的mapper文件夹的名字是一样的额

要想实现映射无非是关注我们调用了什么接口下的什么方法，因此需要保持两者一致

调用了什么接口？namespace

调用了什么方法？id

<?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.bcn.mybatis.mapper.UserMapper"> <!--int insertUser();--> <insert id ="insertUser"> insert into t_user values (null,'admin','','23','男',''); </insert> </mapper>

2.2.5 log4j.xml

该文件的主要功能是在控制台获取日志信息，方便我们调试错误

log4j的配置文件名为log4j.xml，存放的位置是src/main/resources目录下，这里的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" /> </logger> <logger name="org.apache.ibatis"> <level value="info" /> </logger> <root> <level value="debug" /> <appender-ref ref="STDOUT" /> </root> </log4j:configuration>

2.2.6 Little Test

其实到了这里，我们已经复现了JSP中的三层架构模式，现在来测试一下

package com.bcn.mybatis; import com.bcn.mybatis.mapper.UserMapper; import org.apache.ibatis.io.Resources; import org.apache.ibatis.session.SqlSession; import org.apache.ibatis.session.SqlSessionFactory; import org.apache.ibatis.session.SqlSessionFactoryBuilder; import org.junit.Test; import java.io.IOException; import java.io.InputStream; / * @author 大白菜 * @date Created in 2022/7/24 15:28 */ public class test { @Test public void testInserter() throws IOException { //读取MyBatis的核心配置文件 InputStream is = Resources.getResourceAsStream("mybatis-config.xml"); //创建SqlSessionFactoryBuilder对象 SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder(); //通过SqlSessionFactoryBuilder创建sqlSessionFactory对象 SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(is); //通过SqlSessionFactory创建sqlSession对象,是最终操作数据库的对象 SqlSession sqlSession = sqlSessionFactory.openSession(true); //通过代理模式创建UserMapper接口的代理实现类对象 UserMapper userMapper = sqlSession.getMapper(UserMapper.class); //调用UserMapper接口中的方法，就可以根据UserMapper的全类名匹配素文件，通过调用的方法名匹映射文件中的SQL标签，并执行标签中的SQL语句 int result = userMapper.insertUser(); System.out.println("The result is "+result); //commit没有设置有时候数据库读不进去，因为没有提交事务，所以稳妥一点都写上好了 sqlSession.commit(); sqlSession.close(); } }

执行结果，这里的输出了log4j配置产生的日志信息。默认结果输出为1就是执行成功了

小灶知识点

1 SqlSession是Java Projct 和 Database之间的会话

2 代理模式：想访问一个正常情况下不能访问的对象，就创建一个该对象的代理对象，主要表现为接口实例化对象

2.3 Parameters Get

Mybatis获取参数主要有两种方式：${} 和 #{}

${}：本质是字符串拼接，因此若为字符串类型或日期类型的字段进行赋值时，需要手动加单引号

#{}：本质是占位符赋值，此时为字符串类型或日期类型的字段进行赋值时，可以自动添加单引号，还能避免SQL注入问题，所以一般都是用#{}

非实体对象化的参数默认名字是param1，param2等等，如下

 <!--int updateUser();--> <update id="updateUser"> update t_user set username=#{param1},gender=#{param2} where id=#{param3} </update>

实体对象的参数得是实体对象的属性名，如下

 <!--int insertUser();--> <insert id ="insertUser"> insert into t_user values (null,#{username},#{password},#{age},#{gender},#{email}); </insert>

非实体对象高级版-->@param，这样在mapper.xml文件中统一的命名都是#{属性名}，在Mapper中的代码如下

 User getUserById(@Param("id") int id);

2.4 CRUD

2.4.1 SqlSessionUtils

在开发过程中，如果我们遇到一些常用的操，可以创建对应的工具类，放到Utils包里面，随后使用委派模式使用该类对象

package com.bcn.mybatis.utils; import org.apache.ibatis.io.Resources; import org.apache.ibatis.session.SqlSession; import org.apache.ibatis.session.SqlSessionFactory; import org.apache.ibatis.session.SqlSessionFactoryBuilder; import java.io.IOException; import java.io.InputStream; / * @author 大白菜 * @date Created in 2022/7/24 16:24 */ public class SqlSessionUtil { public static SqlSession getSqlSession(){ SqlSession sqlSession=null; try { InputStream is = Resources.getResourceAsStream("mybatis-config.xml"); SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder(); SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(is); sqlSession = sqlSessionFactory.openSession(true); } catch (IOException e) { throw new RuntimeException(e); } return sqlSession; } }

2.4.2 CRUD

UserMapper.java

package com.bcn.mybatis.mapper; import com.bcn.mybatis.pojo.User; import org.apache.ibatis.annotations.Param; import java.util.List; / * 用户映射器 * * @author 大白菜 * @date Created in 2022/7/24 14:53 */ public interface UserMapper { / * 增 * @return */ int insertUser(User user); / * 删 * @return */ int deleteUser(@Param("id") int id); / * 改 * @return */ int updateUser(@Param("username") String userName,@Param("gender") String gender,@Param("id") int id); / * 查 * @return */ User getUserById(@Param("id") int id); / * 查多个 */ List<User> getUserList(); }

UserMapper.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.bcn.mybatis.mapper.UserMapper"> <!--int insertUser();--> <insert id ="insertUser"> insert into t_user values (null,#{username},#{password},#{age},#{gender},#{email}); </insert> <!--int delete();--> <delete id="deleteUser"> delete from t_user where id=#{id} </delete> <!--int updateUser();--> <update id="updateUser"> update t_user set username=#{username},gender=#{gender} where id=#{id} </update> <!--User getUserById();--> <select id="getUserById" resultType="User"> select * from t_user where id= #{id} </select> <!--List<User> getUserList();--> <select id="getUserList" resultType="User"> select * from t_user </select> </mapper>

test.java

package com.bcn.mybatis; import com.bcn.mybatis.mapper.UserMapper; import com.bcn.mybatis.pojo.User; import com.bcn.mybatis.utils.SqlSessionUtil; import org.apache.ibatis.io.Resources; import org.apache.ibatis.session.SqlSession; import org.apache.ibatis.session.SqlSessionFactory; import org.apache.ibatis.session.SqlSessionFactoryBuilder; import org.junit.Test; import java.io.IOException; import java.io.InputStream; / * @author 大白菜 * @date Created in 2022/7/24 15:28 */ public class test { @Test public void testInserter() throws IOException { SqlSession sqlSession= SqlSessionUtil.getSqlSession(); UserMapper userMapper =sqlSession.getMapper(UserMapper.class); userMapper.insertUser(new User(null,"root","",18,"男","")); sqlSession.commit(); sqlSession.close(); } @Test public void testDeleteUser() throws Exception { SqlSession sqlSession= SqlSessionUtil.getSqlSession(); UserMapper userMapper =sqlSession.getMapper(UserMapper.class); userMapper.deleteUser(5); sqlSession.commit(); sqlSession.close(); } @Test public void testUpdateUser() throws Exception { SqlSession sqlSession= SqlSessionUtil.getSqlSession(); UserMapper userMapper =sqlSession.getMapper(UserMapper.class); userMapper.updateUser("bcn","女",3); sqlSession.commit(); sqlSession.close(); } @Test public void testgetUserById() throws Exception { SqlSession sqlSession= SqlSessionUtil.getSqlSession(); UserMapper userMapper =sqlSession.getMapper(UserMapper.class); User user=userMapper.getUserById(3); System.out.println(user); sqlSession.commit(); sqlSession.close(); } @Test public void testgetUserList() throws Exception { SqlSession sqlSession= SqlSessionUtil.getSqlSession(); UserMapper userMapper =sqlSession.getMapper(UserMapper.class); userMapper.getUserList(); sqlSession.commit(); sqlSession.close(); } }

注意点

1 查询标签select必须设置属性resultType或resultMap，用于设置实体类和数据库表的映射关系

2 resultType：自动映射，用于属性名和表中字段名一致的情况

3 resultMap：自定义映射，用于一对多或多对一或字段名和属性名不一致的情况

4 因为在核心配置文件里我们写过了pojo的映射，因此在这里不需要写上类地址全名，写类名即可

2.5 Quary

查询一个实体类对象

/ * 根据用户id查询用户信息 * @param id * @return */ User getUserById(@Param("id") int id);

<!--User getUserById(@Param("id") int id);--> <select id="getUserById" resultType="User"> select * from t_user where id = #{id} </select>

查询一个list集合

/ * 查询所有用户信息 * @return */ List<User> getUserList();

<!--List<User> getUserList();--> <select id="getUserList" resultType="User"> select * from t_user </select>

查询单个数据

/ * 查询用户的总记录数 * @return * 在MyBatis中，对于Java中常用的类型都设置了类型别名 * 例如： java.lang.Integer-->int|integer * 例如： int-->_int|_integer * 例如： Map-->map,List-->list */ int getCount();

<!--int getCount();--> <select id="getCount" resultType="_integer"> select count(id) from t_user </select>

查询一条数据为map集合

/ * 根据用户id查询用户信息为map集合 * @param id * @return */ Map<String, Object> getUserToMap(@Param("id") int id);

<!--Map<String, Object> getUserToMap(@Param("id") int id);--> <!--结果： {password=, sex=男 , id=1, age=23, username=admin}--> <select id="getUserToMap" resultType="map"> select * from t_user where id = #{id} </select>

查询多条数据为map的集合

/ * 查询所有用户信息为map集合 * @return * 将表中的数据以map集合的方式查询，一条数据对应一个map；若有多条数据，就会产生多个map集合，此 时可以将这些map放在一个list集合中获取 */ List<Map<String, Object>> getAllUserToMap();

<!--Map<String, Object> getAllUserToMap();--> <select id="getAllUserToMap" resultType="map"> select * from t_user </select>

模糊查询

/ * 测试模糊查询 * @param mohu * @return */ List<User> testMohu(@Param("mohu") String mohu);

<!--List<User> testMohu(@Param("mohu") String mohu);--> <select id="testMohu" resultType="User"> select * from t_user where username like "%"#{mohu}"%" </select>

2.6 Special SQL

批量删除

/ * 批量删除 * @param ids * @return */ int deleteMore(@Param("ids") String ids);

<!--int deleteMore(@Param("ids") String ids);--> <delete id="deleteMore"> delete from t_user where id in (${ids}) </delete>

 @Test public void testDeleteMor() throws Exception { SqlSession sqlSession= SqlSessionUtil.getSqlSession(); UserMapper userMapper =sqlSession.getMapper(UserMapper.class); userMapper.deleteMore("2,3,4,5"); sqlSession.commit(); sqlSession.close(); }

注意

1 所要删除对象表现不是用list或者map来表示，而是使用字符串的，格式如"1,2,3"

2 参数使用方式得是${}，因为#{}会默认加上 ' 从而导致最终查询失败

动态设置表名

/ * 动态设置表名，查询所有的用户信息 * @param tableName * @return */ List<User> getAllUser(@Param("tableName") String tableName);

<!--List<User> getAllUser(@Param("tableName") String tableName);--> <select id="getAllUser" resultType="User"> select * from ${tableName} </select>

注意

1 参数的表示只能是${}，因为表名也是不能加单引号的

添加功能获取自增的主键(重点知识)

场景：在添加信息之后想获取它的主键

具体做法：使用useGeneratedKeys和keyProperty

/ * 添加用户信息 * @param user * @return * useGeneratedKeys：设置使用自增的主键 * keyProperty：因为增删改有统一的返回值是受影响的行数，因此只能将获取的自增的主键放在传输的参数user对象的某个属性中 */ int insertUser(User user);

<!--int insertUser(User user);--> <insert id="insertUser" useGeneratedKeys="true" keyProperty="id"> insert into t_user values(null,#{username},#{password},#{age},#{sex}) </insert>

🔥2.7 Custom Map

2.7.1 Custom setting

当数据库中的字段名和实体类中的属性名不一致时，可以使用resultMap来实现自定义映射

方式一

使用resultMap来获取映射标签

id	映射标签的id
type	实体类对象
id	主键映射
result	普通键映射
association	多对一映射
collection	一对多映射
property	实体类属性名
column	数据库字段名

<resultMap id="userMap" type="User"> <id property="id" column="id"></id> <result property="userName" column="user_name"></result> <result property="password" column="password"></result> <result property="age" column="age"></result> <result property="sex" column="sex"></result> </resultMap> <select id="testMohu" resultMap="userMap"> select * from t_user where username like '%${mohu}%' </select>

注意：

1 传统的Sql语句中我们使用的是resultType，而这里使用的是resultMap

方式二：

Mysql中的字段名的格式要求是_，Java中属性名的格式要求是驼峰，命名都规范的话直接使用一个setting全局配置即可

 <!--下划线转驼峰--> <settings> <setting name="mapUnderscoreToCamelCase" value="true"/> </settings>

2.7.2 Many to one

遇到多对一的i情况如何查询？比如说查询一个员工的全部信息和它公司的全部信息

Employee实体类中的一个属性是Company对象，而不是Company的属性

方式一：级联

<resultMap id="EmpMap" type="User"> <id property="empId" column="emp_id"></id> ~ <result property="company.comId" column="comp_id"></result> <result property="company.comName" column="comp_name"></result> </resultMap> <select id="getEmpAndComByEmpId" resultMap="EmpMap"> select emp.*,comp.* from emp left join comp on emp.comp_id=comp.emp_id where emp.emp_id=#{empId} </select>

方式二：association

其实就是一个套娃，在resultMap里面再套上一个resultMap，只不过这里的resultMap换了名字叫做association

property	需要映射的属性名
javaType	该属性的类型

<resultMap id="EmpMap" type="Emplyee"> <id property="empId" column="emp_id"></id> ~ <association property="company" javaType="Company"> <id property="comId" column="com_id"></id> <result property="comName" column="com_name"></result> </association> </resultMap>

方式三：分布查询

就是将一个Sql语句拆分为多个Sql语句

Step1：查询员工的基本信息

Employee getEmpByStep(@Param("empId") int empId)

<resultMap id="EmpMapStepMap" type="Emplyee"> <id property="empId" column="emp_id"></id> ~ <association property="company" select="com.bcn.mybatis.mapper.EmpMapper.getEmpAndCompByStepTwo" column="comp_id"> </association> </resultMap>

Step2：查询公司的基本信息

Company getEmpCompByStep(@Param("compId") int compId);

<select id="getEmpCompByStep" resultType="Company"> select * from comp where compId = #{compId} </select>

2.7.3 One To Many

查询一对多的数据，比如说查询一个公司的信息和它所有员工的信息

Company对象的一个属性是 private List<Employee> Emps

方式一：collection

Company getCompEmpByCompId(@Param("CompId") int CompId);

<resultMap id="compEmpMap" type="Company"> <id property="CompId" column="comp_id"></id> ~ <collection property="emps" ofType="Employee"> <id property="empId" column="emp_id"></id> ~ </collection> </resultMap> <select id="getCompEmpByCompId" resultMap="compEmpMap"> select comp.*,emp.* from comp left join emp on comp.compId=emp.compId where comp.compId=#{compId} </select>

方式二：分布查询

Step1：查询公司信息

Company getCompByStep(@Param("compId") int compId);

<resultMap id="CompEmpStep" type="Company"> <id> ~ <collection property="emps" fetch="eager" select="com.bcn.Mybatis.mapper.EmpMapper.getEmpListByCompId" column="compId"> </collection> </resultMap> <select id="getCompByStep" resultMap="CompEmpStep"> select * from comp where comp_Id=#{compId} </select>

Sep2：查询所有员工信息

List<Employee> getEmpListByCompId(@param("compId") int CompId);

<select id="getEmpListByCompId" resultType="Employee"> select * from emp where empId=#{empId} </select>

2.7.4 Lazy loeading

分布查询的优点是能够实现延迟加载（懒加载），简单的说就是分布是有多个Sql语句的，我想使用员工信息的时候它才会它，我想使用公司信息的时候它才会加载它。这样的按需加载就可以灵活的使用系统资源。

比如下面的例子，虽然我们中间有很多的Sql语句，但是我们最终使用到的就是员工的名字，因此它只会执行查找员工信息的语句

 @Test public void testGetEmpAndCompByStep() throws Exception { SqlSession sqlSession= SqlSessionUtil.getSqlSession(); EmpMapper EmpMapper =sqlSession.getMapper(EmpMapper.class); Employee emp=EmpMapper.getEmpAndCompByStepOne(2); System.out.println(emp.getEmpName()); sqlSession.commit(); sqlSession.close(); }

做法：在mybatis-config.xml核心配置文件中配置全局配置信息

lazyLoadingEnabled	全局是否开启延迟加载
aggressiveLazyLoading	全局是否强制关闭延迟加载
fetchType	局部分布查询中是否同意延迟加载 eager or lazy

 <settings> <!--开启延迟加载--> <setting name="lazyLoadingEnabled" value="true"/> <!--是否强制关闭延迟加载--> <setting name="aggressiveLazyLoading" value="false"/> </settings>

 <association property="company" fetchType="eager" ~ </association>

2.8 Dynamic Sql

解决复杂Sql查询，来进行动态拼装Sql语句的功能，本质就是映射中的各种标签

2.8.1 if、where

if是通过test中的表达式来判断标签中的信息是否有效，有效则拼接到sql中

例：若输入的员工信息全部是非空的，则把他给找出来

where常和if一起使用

a) 若where中有标签成立，则自动生成where关键字，且会将多余的and去掉

b) 若a不成立，则无where

package com.bcn.mybatis.mapper; import com.bcn.mybatis.pojo.Employee; import java.util.List; / * @author 大白菜 * @date Created in 2022/7/29 21:04 */ public interface EmployeeMapper { List<Employee> getEmployeeListByCondition(Employee employee); }

<?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.bcn.mybatis.mapper.EmployeeMapper"> <select id="getEmployeeListByCondition" resultType="com.bcn.mybatis.pojo.Employee"> select * from t_employee <where> <if test="name != null and name != '' "> and name = #{name} </if> <if test="age != null and age != '' "> and age = #{age} </if> <if test="sex != null and sex != '' "> and sex = #{sex} </if> </where> </select> </mapper>

package com.bcn.mybatis; import com.bcn.mybatis.mapper.EmployeeMapper; import com.bcn.mybatis.pojo.Employee; import com.bcn.mybatis.utils.SqlSessionUtil; import org.apache.ibatis.session.SqlSession; import org.junit.Test; import java.io.IOException; import java.util.List; / * @author 大白菜 * @date Created in 2022/7/29 21:12 */ public class EmployeeTest { @Test public void testInserter() throws IOException { SqlSession sqlSession= SqlSessionUtil.getSqlSession(); EmployeeMapper EmployeeMapper =sqlSession.getMapper(EmployeeMapper.class); Employee employee=new Employee(null,"张三", 18,"男"); List<Employee> list=EmployeeMapper.getEmployeeListByCondition(employee); list.forEach(System.out::println); sqlSession.commit(); sqlSession.close(); } }

2.8.2 trim

有时候我们的and加在后面，where处理不了，就需要用到trim了

prefix、suffix：在标签的前面或后面添加指定内容

prefexOverrides、suffixOverrides：在标签的前面或后面删除指定内容

<?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.bcn.mybatis.mapper.EmployeeMapper"> <select id="getEmployeeListByCondition" resultType="com.bcn.mybatis.pojo.Employee"> select * from t_employee <trim prefix="where" suffixOverrides="and"> <if test="name != null and name != '' "> name = #{name} and </if> <if test="age != null and age != '' "> age = #{age} and </if> <if test="sex != null and sex != '' "> sex = #{sex} and </if> </trim> </select> </mapper>

🔥2.8.3 foreach

批量操作，比如添加、删除多个用户

collection	列表
item	每个列表中的素
separator	分隔符

<!-- int insertMoreEmployees(@Param("employees") List<Employee> employees);--> <insert id="insertMoreEmployees"> insert into t_employee values <foreach collection="employees" item="employee" separator=","> (null,#{employee.name},#{employee.age},#{employee.sex}) </foreach> </insert> <!-- int deleteMoreByArray(@Param("ids") int[] ids);--> <delete id="deleteMoreByArray"> delete from t_employees where <foreach collection="ids" item="is" separator="or"> eid=#{eid} </foreach> </delete>

2.8.4 SQL

有时候我们想反复的用到sql语句，那么就可以将其封装成一个sql片段，从而提高代码的复用性

2.9 Cache

2.9.1 L1 Cache

Mybatis中的缓存主要针对查询

L1即1级缓存，L1是SqlSession级别的（可以理解为对象级别），通过同一个（如同一个sqlsession1）SqlSession查询的数据会被缓存下来，下次查询的时候也会先从缓存中进行查询。默认自动开启

L1失效（不能从Cache中查询，需要从Database中查询）主要有以下几种情况

同一个SqlSession，查询条件不同
~，两次查询之间出现了增删改
~，两次查询之间手动清空缓存

💧2.9.2 L2 Chche

L2,即2级缓存，L2是SqlSessionFactory级别的（可以理解为类级别），通过同一个（如sqlsession1和sqlsession2）SqlSessionFactory查询的数据被缓存，下次查询会先从L2中查询。开启的条件必须满足以下四个条件

核心配置文件中，使用cacheEnabled="true"
xml映射文件中加一行<cache/>
每次SqlSession对象操作完之后进行关闭和提交
查询的实体对象加上 implements Serializable

每次执行完之后会有一个Cache Hit Ratio缓存命中率的信息，只要不是0就是查询成功啦

失效的条件：两次查询之间执行了增删改

💧2.9.3 Cache query policy

类似于OS中的MMU内存管理单机制，L2就是TLB快表
程序首先查询的是L2，如果L2没有命中则查询L1，若还是没有命中则查询数据库
SqlSession关闭之后，L1中的数据才会写入到L2中
只有L2可以使用第三方缓存如EHCache，有需要可以配置

🔥2.10 Reverse Engineering

RE逆向工程，即代码生成器，即你在开始一个新的项目的时候，它可以帮你自动生成如Mapper、Pojo之类的包和对象，减少一点的开发时间吧

网上有很多说用mybatis-generator-maven-plugin之类的插件，经过笔者测试使用MybatisX最好

使用方法

1 数据库建表

2 创建一个新的工程，连接到数据库

3 选择MybatisX-Generator

4 按照以下配置

5 查看最终结果，MybatisX逆向工程创建成功，而且xml文件中自动帮我们建好了一个Map

2.11 Paging

分页即如图所示，具体做法是使用分页查询的一个插件，在每次查询功能之前开启PageHelper.startPage(int pageNum, int pageSize)

pageNum：总页面数

pageSize：每页记录的条数

依赖

 <!--<paging>--> <dependency> <groupId>com.github.pagehelper</groupId> <artifactId>pagehelper</artifactId> <version>5.3.0</version> </dependency>

在config-xml文件中配置分页插件

 <plugins> <!--设置分页插件--> <plugin interceptor="com.github.pagehelper.PageInterceptor"/> </plugins>

getUserList函数

 <!--List<User> getUserList();--> <select id="getUserList" resultType="User"> select * from t_user </select>

测试类

 @Test public void testPage(){ SqlSession sqlSession= SqlSessionUtil.getSqlSession(); UserMapper userMapper =sqlSession.getMapper(UserMapper.class); //查询功能之前开启分页功能 PageHelper.startPage(1,3); List<User> users=userMapper.getUserList(); users.forEach(System.out::println); }

运行结果

如果想获取分页的所有数据也可以

 @Test public void testPage(){ SqlSession sqlSession= SqlSessionUtil.getSqlSession(); UserMapper userMapper =sqlSession.getMapper(UserMapper.class); //查询功能之前开启分页功能 Page<Objects> page=PageHelper.startPage(1,3); List<User> users=userMapper.getUserList(); //查询功能之后可以获取分页相关的所有数据 PageInfo<User> pageInfo = new PageInfo<>(users,5); users.forEach(System.out::println); System.out.println(page); }

Page{count=true, pageNum=1, pageSize=3, startRow=0, endRow=3, total=7, pages=3, reasonable=false, pageSizeZero=false} [User(id=3, username=bcn, password=, age=23, gender=女, email=), User(id=4, username=admin, password=, age=23, gender=男, email=), User(id=6, username=admin, password=, age=23, gender=男, email=)]

三、Spring--轻量级Java开发框架

3.1 Introduction

使用其核心思想IOC管理组件，使用AOP思想实现功能增强。

Spring全家桶

SpringFramework	Spring系列的核心，业务层框架，所有的项目都需要依赖于SpringFramework
SpringMVC	Web层框架
SpringBoot	基于Spring的脚手架，简化了SpringFramework和SpringMvc，可理解升级版Spring
SpringCloud	微服务，将大型单个拆分成多个组件

3.2 Spring Framework

3.2.1 properties

SpringFramework有以下特性

非侵入式：使用 Spring Framework 开发应用程序时，Spring 对应用程序本身的结构影响非常小。对领域模型可以做到零污染；对功能性组件也只需要使用几个简单的注解进行标记，完全不会破坏原有结构，反而能将组件结构进一步简化。这就使得基于 Spring Framework 开发应用程序时结构清晰、简洁优雅。
控制反转：IOC——Inversion of Control，翻转资源获取方向。把自己创建资源、向环境索取资源变成环境将资源准备好，我们享受资源注入。
面向切面编程：AOP——Aspect Oriented Programming，在不修改源代码的基础上增强代码功能。
容器：Spring IOC 是一个容器，因为它包含并且管理组件对象的生命周期。组件享受到了容器化的管理，替程序员屏蔽了组件创建过程中的大量细节，极大的降低了使用门槛，大幅度提高了开发效率。
组件化：Spring 实现了使用简单的组件配置组合成一个复杂的应用。在 Spring 中可以使用 XML 和 Java 注解组合这些对象。这使得我们可以基于一个个功能明确、边界清晰的组件有条不紊的搭建超大型复杂应用系统。
声明式：很多以前需要编写代码才能实现的功能，现在只需要声明需求即可由框架代为实现。
一站式：在 IOC 和 AOP 的基础上可以整合各种企业应用的开源框架和优秀的第三方类库。而且 Spring 旗下的项目已经覆盖了广泛领域，很多方面的功能性需求可以在 Spring Framework 的基础上全部使用 Spring 来实现。

3.2.2 Five functional modules

Core Container	核心容器，在Spring环境下使用任何功能都必须基于IOC容器
AOP&Aspects	面向切面编程
Testing	Junit或TestNG测试框架
Data Access/Integration	提供对数据访问/集成的功能
Spring MVC	提供面向Web程序的集成功能

🔥 3.3 IOC

3.3.1 Ideology

IOC：Inversion of Control反转控制，是一种资源获取的方式，简单的理解为之前所有的资源都需要自己创建，现在是Spring为我们提供啥我们就用啥，不必关心资源是如何创建的

DI：Dependency Injection依赖注入，是IOC的具体实现方式，具体来说A依赖对象B，那么就会对B进行赋值

3.3.2 Achieve

针对IOC思想，Spring中有一个专门的容器就叫做IOC容器，该容器中的管理的组件叫做Bean。注意，在创建bean之前一定是需要创建IOC容器。IOC容器的两种实现方式如下

BeanFactory：Spring内部使用，不提供给开发者使用
ApplicationContext：BeanFactory的子接口，有更多的特性。提供给开发者使用，开发中都需要用到这个

主要的实现类：搜索BeanFactory，再按ctrl+H

类名	介绍
WebApplicationContext	如果是Java工程，则叫做ApplicationContext，如果是Web工程，则叫做WebApplicationContext。该类将对象引入存储于ServletContext域中
ConfigurableApplicationContext	ApplicationContext 的子接口，包含一些扩展方法 refresh() 和 close() ，让 ApplicationContext 具有启动、关闭和刷新上下文的能力。
FileSystemXmlApplicationContext	通过文件系统路径读取 XML 格式的配置文件创建 IOC 容器对象
ClassPathXmlApplicationContext	通过读取类路径下的 XML 格式的配置文件创建 IOC 容器对象

3.4 Bean

3.4.1 Tag and Scan

Bean主要可以通过XML和注解来管理，XML管理会非常的复杂，在实战中使用的比较少，一般都是使用注解来管理

注解：以@为标志符Tag，其主要是一个标记，当框架扫描Scan注解，就会按照注解的功能来具体执行

关键注解

名称	作用
@Component	将类标志为普通组件，只要类中有了这个组件之后，就可以被IOC容器所管理
@Controller	将类标识为控制层组件
@Service	将类标识为业务层组件
@Repository	将类表示为持久层组件
@mapper	是Myabtis的注解，并非是Spring 的，所以用到Mybatis的时候才用它

联系：阅读源码后，我们发现@Controller，@Service和@Repositort都只是在@Component的基础上新起另一个名字，所以从IOC容器管理的角度看，这三个本质上无区别，只是让程序员看的更加清楚一点。

使用xml管理bean的时候，每个bean都有一个唯一的标志符，使用注解的时候每个bean也会有一个唯一的标志符，如UserController对应的bean就是userController，当然我们也可以自定义bean的id，方法如下

具体实现步骤如下

1. 创建各个对象，并给各个对象加上注释

2.创建spring的xml文件，并向其中添加扫描组件

exclude-filter	不扫描某个组件，因为在整合Spring和SpirngMVC中，SpringMVC主要负责Controller层组件，而Spring负责除Controller层组件之外的所有组件
include-filter	只扫描某个组件
type:"annotation"	根据注解类型来进行排除
experssion	组件的名称，需要填写注解全类名，可由以下操作来进行获取

<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd"> <!--扫描组件--> <context:component-scan base-package="com.bcn.spring"></context:component-scan> </beans>

3. 测试

public class IOCByAnnotationTest { @Test public void test(){ //获取配置文件 ApplicationContext ioc=new ClassPathXmlApplicationContext("spring-ioc-annotation.xml"); //获取Bean对象 UserController userController=ioc.getBean(UserController.class); UserService userService=ioc.getBean(UserService.class); UserMapper userMapper=ioc.getBean(UserMapper.class); System.out.println(userController); System.out.println(userService); System.out.println(userMapper); } }

4. 测试结果

四、SpringMVC

接受浏览器发送的请求，并响应浏览器数据

五、整合

今天的文章【Java后端】MVC学习笔记（完整详细版）分享到此就结束了，感谢您的阅读。