Mybatis基础（一）

ゞ浴缸里的玫瑰 2022-05-31 04:43 262阅读 0赞

### **Mybatis是什么？** ###

MyBatis是一个优秀的持久层框架，它对JDBC的操作数据库的过程进行封装，使开发者只需要关注 SQL 本身，而不需要花费精力去处理例如注册驱动、创建Connection、创建Statement、手动设置参数、结果集检索等JDBC繁杂的过程代码。

Mybatis通过xml或注解的方式将要执行的各种Statement（Statement、PreparedStatemnt、CallableStatement）配置起来，并通过Java对象和Statement中的sql进行映射生成最终执行的sql语句，最后由Mybatis框架执行sql并将结果映射成Java对象并返回。

### **原生态JDBC** ###

**原生态JDBC程序代码**

public static void main(String[] args) {
    	Connection connection = null;
    	PreparedStatement preparedStatement = null;
    	ResultSet resultSet = null;
    	
    	try {
    		//1、加载数据库驱动
    		Class.forName("com.mysql.jdbc.Driver");
    		//2、通过驱动管理类获取数据库链接
    		connection =  DriverManager.getConnection("jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf-8", "root", "root");
    		//3、定义sql语句 ?表示占位符
    		String sql = "select * from user where username = ?";
    		//4、获取预处理statement
    		preparedStatement = connection.prepareStatement(sql);
    		//5、设置参数，第一个参数为sql语句中参数的序号（从1开始），第二个参数为设置的参数值
    		preparedStatement.setString(1, "王五");
    		//6、向数据库发出sql执行查询，查询出结果集
    		resultSet =  preparedStatement.executeQuery();
    		//7、遍历查询结果集
    		while(resultSet.next()){
    			System.out.println(resultSet.getString("id")+"  "+resultSet.getString("username"));
    		}
    	} catch (Exception e) {
    		e.printStackTrace();
    	}finally{
    		//8、释放资源
    		if(resultSet!=null){
    			try {
    				resultSet.close();
    			} catch (SQLException e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}
    		}
    		if(preparedStatement!=null){
    			try {
    				preparedStatement.close();
    			} catch (SQLException e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}
    		}
    		if(connection!=null){
    			try {
    				connection.close();
    			} catch (SQLException e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}
    		}
    	}
    }

**存在的问题**

*  数据库连接频繁开启和关闭，会严重影响数据库的性能。
 *  代码中存在硬编码，分别是数据库部分的硬编码和SQL执行部分的硬编码。

### **Mybatis框架原理** ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdGlhbnhpYW5nX2thb2xh_size_16_color_FFFFFF_t_70]

（1）Mybatis配置文件，包括Mybatis全局配置文件和Mybatis映射文件，其中全局配置文件配置了数据源、事务等信息；映射文件配置了SQL执行相关的信息。

（2）Mybatis通过读取配置文件信息（全局配置文件和映射文件），构造出SqlSessionFactory，即会话工厂。

（3）通过SqlSessionFactory，可以创建SqlSession即会话。Mybatis是通过SqlSession来操作数据库的。

（4）SqlSession本身不能直接操作数据库，它通过底层的Executor执行器接口来操作数据库。Executor接口有两个实现类，一个是普通执行器，一个是缓存执行器（默认）。

（5）Executor执行器将要处理的SQL信息封装到一个底层对象MappedStatement中。该对象包括：SQL语句、输入参数映射信息、输出结果集映射信息。其中输入参数和输出结果的映射类型包括Java的简单类型、HashMap集合对象、POJO对象类型。

### **Mybatis入门程序** ###

入门程序是对数据库的增删改查操作，增删改操作要对SqlSession执行commit。

**编程步骤**

（1）创建POJO类，根据需求创建；  
（2）创建全局配置文件SqlMapConfig.xml；  
（3）编写映射文件；  
（4）加载映射文件，在SqlMapConfig.xml中进行加载；  
（5）编写测试程序，即编写Java代码，连接并操作数据库。

**根据用户ID查询用户信息**

POJO类

public class User {
    	private int id;
    	private String username;// 用户姓名
    	private String sex;// 性别
    	private Date birthday;// 生日
    	private String address;// 地址
    
    	//getters、setters、toString
    }

SqlMapConfig.xml

<?xml version="1.0" encoding="UTF-8" ?>
    <configuration>
    	
    	<environments default="development">
    		<environment id="development">
    			
    			<transactionManager type="JDBC"></transactionManager>
    			
    			<dataSource type="POOLED">
    				<property name="driver" value="com.mysql.jdbc.Driver" />
    				<property name="url" value="jdbc:mysql://localhost:3306/mybatisdemo?useUnicode=true&characterEncoding=utf8" />
    				<property name="username" value="root" />
    				<property name="password" value="123" />
    			</dataSource>
    		</environment>
    	</environments>
    
    	
    	<mappers>
    		<mapper resource="User.xml" />
    	</mappers>
    </configuration>

映射文件User.xml

<?xml version="1.0" encoding="UTF-8" ?>
    <mapper namespace="test">
    	
    	
    	
    	
    	
    	
    	
    	<select id="findUserById" parameterType="int"
    		resultType="org.po.User">
    		SELECT * FROM USER WHERE id =#{id}
    	</select>
    </mapper>

测试程序

/**
     * 根据用户ID查询用户
     */
    public void findUserByIdTest() throws Exception{
    	//读取配置文件
    	//全局配置文件的路径
    	String resource = "SqlMapConfig.xml";
    	InputStream inputStream = Resources.getResourceAsStream(resource);
    	
    	//创建SqlSessionFactory
    	SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
    	
    	//创建SqlSession
    	SqlSession sqlSession = sqlSessionFactory.openSession();
    	
    	//调用SqlSession的增删改查方法
    	//第一个参数：表示statement的唯一标示
    	User user = sqlSession.selectOne("test.findUserById", 1);
    	System.out.println(user);
    	
    	//关闭资源
    	sqlSession.close();
    }

**根据用户名称来模糊查询用户信息**

映射文件User.xml

<select id="findUsersByName" parameterType="java.lang.String"
    	resultType="org.po.User">
    	SELECT * FROM USER WHERE username LIKE '%${value}%'
    </select>

测试程序

/**
     * 根据用户名进行模糊查询
     */
    @Test
    public void findUsersByNameTest() throws Exception{
    	//读取配置文件
    	//全局配置文件的路径
    	String resource = "SqlMapConfig.xml";
    	InputStream inputStream = Resources.getResourceAsStream(resource);
    	
    	//创建SqlSessionFactory
    	SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
    	
    	//创建SqlSession
    	SqlSession sqlSession = sqlSessionFactory.openSession();
    	
    	//调用SqlSession的增删改查方法
    	//第一个参数：表示statement的唯一标示
    	List<User> list = sqlSession.selectList("test.findUsersByName", "小明");
    	System.out.println(list);
    	//关闭资源
    	sqlSession.close();
    }

**添加用户**

映射文件User.xml

<insert id="insertUser" parameterType="org.po.User">
    	INSERT INTO USER
    	(username,birthday,sex,address)
    	VALUES(#{username},#{birthday},#{sex},#{address})
    </insert>

测试程序

/**
     * 插入数据
     */
    @Test
    public void insertUserTest() throws Exception{
    	//读取配置文件
    	//全局配置文件的路径
    	String resource = "SqlMapConfig.xml";
    	InputStream inputStream = Resources.getResourceAsStream(resource);
    	
    	//创建SqlSessionFactory
    	SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
    	
    	//创建SqlSession
    	SqlSession sqlSession = sqlSessionFactory.openSession();
    	
    	User user = new User();
    	user.setUsername("弗兰克");
    	user.setAddress("查令街84号");
    	
    	//调用SqlSession的增删改查方法
    	sqlSession.insert("test.insertUser", user);
    
    	//提交事务
    	sqlSession.commit();
    	//关闭资源
    	sqlSession.close();
    }

**主键返回之MySQL自增主键**

MySQL自增主键，是指在insert之前MySQL会自动生成一个自增的主键，我们可以通过MySQL的函数获取到刚插入的自增主键：LAST\_INSERT\_ID()。这个函数是在insert语句之后去调用。

修改映射文件User.xml

<insert id="insertUser" parameterType="org.po.User">
    	<selectKey keyProperty="id" resultType="int" order="AFTER">
    		SELECT LAST_INSERT_ID() 
    	</selectKey>
    
    	INSERT INTO USER
    	(username,birthday,sex,address)
    	VALUES(#{username},#{birthday},#{sex},#{address})
    </insert>

测试程序

/**
     * 插入数据
     */
    @Test
    public void insertUserTest() throws Exception{
    	String resource = "SqlMapConfig.xml";
    	InputStream inputStream = Resources.getResourceAsStream(resource);
    
    	SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
    	SqlSession sqlSession = sqlSessionFactory.openSession();
    	
    	User user = new User();
    	user.setUsername("弗兰克");
    	user.setAddress("查令街84号");
    	sqlSession.insert("test.insertUser", user);
    	
    	//输出自增ID
    	System.out.println(user.getId());
    
    	sqlSession.commit();
    	sqlSession.close();
    }

**主键返回之MySQL函数UUID**

注意：uuid()是MySQL的函数，生成的主键是35位的字符串。使用MySql的uuid()函数生成主键，需要修改表中id字段类型为String，长度设置成35位。

修改映射文件User.xml

<insert id="insertUser2" parameterType="org.po.User">
    	<selectKey keyProperty="id" resultType="string" order="BEFORE">
    		SELECT UUID() 
    	</selectKey>
    
    	INSERT INTO USER
    	(id,username,birthday,sex,address)
    	VALUES(#{id},#{username},#{birthday},#{sex},#{address})
    </insert>

**主键返回之Oracle序列返回**

修改映射文件User.xml

<insert id="insertUser2" parameterType="org.po.User">
    	<selectKey keyProperty="id" resultType="int" order="BEFORE">
    		SELECT user_seq.nextval() FROM dual 
    	</selectKey>
    
    	INSERT INTO USER
    	(id,username,birthday,sex,address)
    	VALUES(#{id},#{username},#{birthday},#{sex},#{address})
    </insert>

**删除用户**

映射文件

<delete id="deleteUser" parameterType="int">
    	DELETE FROM USER WHERE id= #{id}
    </delete>

测试程序

public void deleteUserTest() throws Exception{
    	//读取配置文件
    	//全局配置文件的路径
    	String resource = "SqlMapConfig.xml";
    	InputStream inputStream = Resources.getResourceAsStream(resource);
    	
    	//创建SqlSessionFactory
    	SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
    	
    	//创建SqlSession
    	SqlSession sqlSession = sqlSessionFactory.openSession();
    	
    	sqlSession.delete("test.deleteUser", 30);
    
    	//提交事务
    	sqlSession.commit();
    	//关闭资源
    	sqlSession.close();
    }

**修改用户**

映射文件

<update id="updateUser" parameterType="org.po.User">
    	UPDATE USER SET username = #{username},sex=#{sex} WHERE id=#{id}
    </update>

测试程序

public void updateUserTest() throws Exception{
    	//读取配置文件
    	//全局配置文件的路径
    	String resource = "SqlMapConfig.xml";
    	InputStream inputStream = Resources.getResourceAsStream(resource);
    	
    	//创建SqlSessionFactory
    	SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
    	
    	//创建SqlSession
    	SqlSession sqlSession = sqlSessionFactory.openSession();
    	
    	User user = new User();
    	user.setId(28);
    	user.setUsername("海莲");
    	user.setAddress("查令街84号");
    	
    	sqlSession.update("test.updateUser", user);
    	
    	//提交事务
    	sqlSession.commit();
    	//关闭资源
    	sqlSession.close();
    }

### **$\{\}与\#\{\}的区别** ###

（1）\#\{\} 表示一个占位符？，它将传入的数据当成一个字符串，自动加上两个单引号‘’，而 $\{\} 将传入的数据直接显示生成在sql中

（2）\#\{\} 接收简单类型的参数时，里面的名称可以任意。$\{\} 接收简单类型的参数时，里面的名称必须是value。

（3）\#\{\} 方式能够很大程度防止sql注入，而 $\{\} 方式无法防止Sql注入。

（4）$\{\} 方式一般用于传入数据库对象，例如传入表名。

（5）MyBatis排序时使用order by，动态参数时需要注意，用 $\{\} 而不是 \#\{\}。

### **Mybatis开发dao** ###

Mybatis在项目中主要使用的地方就是开发dao（数据访问层），所以下面讲解一下Mybatis开发dao的方法。有两种方式：原始dao开发方式、mapper代理开发方式（推荐）。

**编程步骤**  
（1）根据需求创建POJO类  
（2）编写全局配置文件  
（3）根据需求编写映射文件  
（4）加载映射文件  
（5）编写dao接口  
（6）编写dao实现类  
（7）编写测试代码

dao接口

public interface UserDao {
    	// 1、 根据用户ID查询用户信息
    	public User findUserById(int id) throws Exception;
    
    	// 2、 根据用户名称模糊查询用户列表
    	public List<User> findUsersByName(String name) throws Exception;
    
    	// 3、 添加用户
    	public void insertUser(User user) throws Exception;
    }

dao实现类

public class UserDaoImpl implements UserDao {
    
    	// 依赖注入
    	private SqlSessionFactory sqlSessionFactory;
    
    	public UserDaoImpl(SqlSessionFactory sqlSessionFactory) {
    		this.sqlSessionFactory = sqlSessionFactory;
    	}
    
    	public User findUserById(int id) throws Exception {
    		// 创建SqlSession
    		SqlSession sqlSession = sqlSessionFactory.openSession();
    		// 调用SqlSession的增删改查方法
    		// 第一个参数：表示statement的唯一标示
    		User user = sqlSession.selectOne("test.findUserById", id);
    		System.out.println(user);
    		// 关闭资源
    		sqlSession.close();
    		return user;
    	}
    
    	public List<User> findUsersByName(String name) {
    		// 创建SqlSession
    		SqlSession sqlSession = sqlSessionFactory.openSession();
    
    		// 调用SqlSession的增删改查方法
    		// 第一个参数：表示statement的唯一标示
    		List<User> list = sqlSession.selectOne("test.findUsersByName", name);
    		System.out.println(list);
    		// 关闭资源
    		sqlSession.close();
    		return list;
    	}
    
    	public void insertUser(User user) {
    		// 创建SqlSession
    		SqlSession sqlSession = sqlSessionFactory.openSession();
    
    		// 调用SqlSession的增删改查方法
    		// 第一个参数：表示statement的唯一标示
    		sqlSession.insert("test.insertUser", user);
    
    		System.out.println(user.getId());
    		// 提交事务
    		sqlSession.commit();
    		// 关闭资源
    		sqlSession.close();
    	}
    }

测试代码

public class UserDaoTest {
    
    	private SqlSessionFactory sqlSessionFactory;
    	@Before
    	public void setUp() throws Exception {
    		// 读取配置文件
    		// 全局配置文件的路径
    		String resource = "SqlMapConfig.xml";
    		InputStream inputStream = Resources.getResourceAsStream(resource);
    
    		// 创建SqlSessionFactory
    		sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
    	}
    	@Test
    	public void testFindUserById() throws Exception {
    		// 创建UserDao
    		UserDao dao = new UserDaoImpl(sqlSessionFactory);
    		//调用UserDao对象的方法
    		User user = dao.findUserById(1);
    		System.out.println(user);
    	}
    
    	@Test
    	public void testFindUsersByName() {
    		//构造UserDao对象
    		UserDao userDao = new UserDaoImpl(sqlSessionFactory);
    		//调用UserDao对象的方法
    		List<User> list = userDao.findUsersByName("小明");
    		System.out.println(list);
    	}
    
    	@Test
    	public void testInsertUser() {
    		//构造UserDao对象
    		UserDao userDao = new UserDaoImpl(sqlSessionFactory);
    		//构造User对象
    		User user = new User();
    		user.setUsername("海莲");
    		user.setAddress("查令街84号");
    		
    		//调用UserDao对象的方法
    		userDao.insertUser(user);
    		
    		System.out.println(user.getId());
    	}
    }

**原始dao开发存在一些问题：**

*  存在一定量的模板代码。比如：通过SqlSessionFactory创建SqlSession；调用SqlSession的方法操作数据库；关闭Sqlsession。
 *  存在一些硬编码。调用SqlSession的方法操作数据库时，需要指定statement的id，这里存在了硬编码。

### **Mapper代理开发方式** ###

Mapper代理的开发方式，程序员只需要编写mapper接口（相当于dao接口）即可。Mybatis会自动的为mapper接口生成动态代理实现类。不过要实现mapper代理的开发方式，需要遵循一些开发规范。

**开发规范**

（1）mapper接口的全限定名要和mapper映射文件的namespace的值相同。

（2）mapper接口的方法名称要和mapper映射文件中的statement的id相同；

（3）mapper接口的方法参数只能有一个，且类型要和mapper映射文件中statement的parameterType的值保持一致。

（4）mapper接口的返回值类型要和mapper映射文件中statement的resultType值或resultMap中的type值保持一致。

**编程步骤**

（1）根据需求创建POJO类  
（2）编写全局配置文件  
（3）根据需求编写映射文件  
（4）加载映射文件  
（5）编写mapper接口  
（6）编写测试代码

mapper接口

public interface UserMapper {
    	//根据用户ID查询用户信息
    	public User findUserById(int id) throws Exception;
    }

mapper映射文件

<?xml version="1.0" encoding="UTF-8" ?>
    <mapper namespace="org.mapper.UserMapper">
    	
    	<select id="findUserById" parameterType="int" resultType="User">
    		SELECT
    		* FROM USER WHERE id =#{id}
    	</select>
    </mapper>

测试代码

public class UserMapperTest {
    
    	private SqlSessionFactory sqlSessionFactory;
    
    	@Before
    	public void setUp() throws Exception {
    		// 读取配置文件
    		// 全局配置文件的路径
    		String resource = "SqlMapConfig.xml";
    		InputStream inputStream = Resources.getResourceAsStream(resource);
    
    		// 创建SqlSessionFactory
    		sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
    	}
    
    	/**
    	 * 通过Id查询用户
    	 */
    	@Test
    	public void testFindUserById() throws Exception {
    		// 创建UserMapper对象
    		SqlSession sqlSession = sqlSessionFactory.openSession();
    
    		// 由mybatis通过sqlsession来创建代理对象
    		UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    
    		User user = mapper.findUserById(1);
    
    		System.out.println(user);
    
    		sqlSession.close();
    	}
    }

### **Mybatis全局配置文件** ###

SqlMapConfig.xml是Mybatis的全局配置文件，它的名称可以是任意命名的。

**全部配置内容**

SqlMapConfig.xml的配置内容和顺序如下（顺序不能乱）：

*  Properties（属性）
 *  Settings（全局参数设置）
 *  typeAliases（类型别名）
 *  typeHandlers（类型处理器）
 *  objectFactory（对象工厂）
 *  plugins（插件）
 *  environments（环境信息集合）
    
     *  environment（单个环境信息）
        
         *  transactionManager（事务管理）
         *  dataSource（数据源）
 *  mappers（映射器）

**常用配置详解**

（1）Properties

SqlMapConfig.xml文件中可以引用Java属性文件中的配置信息。

db.properties配置信息如下：  
![在这里插入图片描述][20190328154018791.png]

SqlMapConfig.xml使用properties标签后，如下所示：

<properties resource="db.properties" />
    
    
    <environments default="development">
    	<environment id="development">
    		
    		<transactionManager type="JDBC"></transactionManager>
    		
    		<dataSource type="POOLED">
    			<property name="driver" value="${db.driver}"/>
    			<property name="url" value="${db.url}"/>
    			<property name="username" value="${db.username}"/>
    			<property name="password" value="${db.password}"/>
    		</dataSource>
    	</environment>
    </environments>

使用$\{\}，可以引用已经加载的Java配置文件中的信息。

注意：Mybatis将按照下面的顺序加载属性：

*  Properties标签体内定义的属性首先被读取。
 *  Properties引用的属性会被读取，如果发现上面已经有同名的属性了，那后面会覆盖前面的值。
 *  parameterType接收的值会最后被读取，如果发现上面已经有同名的属性了，那后面会覆盖前面的值。

所以说，Mybatis读取属性的顺序由高到低分别是：parameterType接收的属性值、properties引用的属性、properties标签内定义的属性。

（2）Settings  
Mybatis全局配置参数。Mybatis框架在运行时可以调整一些运行参数，比如开启二级缓存、延迟加载；参考mybatis-settings.xlsx文件。

（3）typeAliases  
别名是使用是为了在映射文件中，更方便的去指定入参和结果集的类型，不再用写很长的一段全限定名。

（4）Mybatis支持的别名

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdGlhbnhpYW5nX2thb2xh_size_16_color_FFFFFF_t_70 1]

自定义别名

SqlMapConfig.xml

<typeAliases>
    	
    	<typeAlias type="org.po.User" alias="user"/> 
    
    	
    	
    	<package name="org.po" />
    </typeAliases>

mapper.xml

<mapper namespace="org.mapper.UserMapper">
    	
    	<select id="findUserById" parameterType="int" resultType="user">
    		SELECT
    		* FROM USER WHERE id =#{id}
    	</select>
    </mapper>

（5）mappers

映射器，用来加载映射文件。

（1）< mapper resource="/">，使用相对于类路径的资源，如：

（2）< mapper url="/">,使用完全限定路径，如：

（3）< mapper class="/">，使用mapper接口的全限定名，如：

（4）< package name="/">，注册指定包下的所有映射文件（推荐）。注意：此种方法要求mapper接口和mapper映射文件要名称相同，且放到同一个目录下。

<mappers>
    	
    	<mapper resource="User.xml" />
    
    	
    	<package name="org.mapper" />
    </mappers>

### **Mybatis映射文件** ###

**输入映射 parameterType**

指定输入参数的Java类型，可以使用别名或者类的全限定名。它可以接收简单类型、POJO、HashMap。

（1）传递简单类型

参考入门程序：根据用户ID查询用户信息

<select id="findUserById" parameterType="int"
        resultType="org.po.User">
        SELECT * FROM USER WHERE id =#{id}
    </select>

（2）传递POJO对象

参考入门程序：添加用户

<insert id="insertUser" parameterType="org.po.User">
        <selectKey keyProperty="id" resultType="int" order="AFTER">
            SELECT LAST_INSERT_ID() 
        </selectKey>
    
        INSERT INTO USER
        (username,birthday,sex,address)
        VALUES(#{username},#{birthday},#{sex},#{address})
    </insert>

（3）传递POJO包装对象

开发中通过POJO传递查询条件 ，如果查询条件是综合的查询条件，不仅包括用户信息还包括其它的查询条件（比如将用户购买商品信息也作为查询条件），这时可以使用包装对象传递输入参数。

定义包装对象

一般User类要和数据库表字段一致，最好不要在这里面添加其他字段，所以针对要扩展的POJO类，我们需要创建一个扩展类，来继承它。

public class UserExtend extends User{
    	//在这里定义User的一些扩展信息
    }
    
    public class UserQueryVO {
    	//在这里加上复杂查询的其他条件，比如商品信息、订单信息
    
    	//用户信息
    	private UserExtend userExtend;
    	//getters、setters、toString
    }

Mapper接口

public interface UserMapper {
    	//通过包装类来进行复杂的用户信息综合查询
    	public List<UserExtend> findUserList(UserQueryVO vo);
    }

mapper映射文件

入参的类型变为UserQueryVO、结果集的类型变为UserExtend，\#\{\}里面的参数变为UserQueryVO对象中的userExtend属性的sex和username子属性。

<mapper namespace="org.mapper.UserMapper">
    	
    	<select id="findUserList" parameterType="UserQueryVO" resultType="UserExtend">
    		SELECT * FROM USER 
    		WHERE sex=#{userExtend.sex} AND username LIKE '%${userExtend.username}%'
    	</select>
    </mapper>

测试代码

public class UserMapperTest {
    
    	private SqlSessionFactory sqlSessionFactory;
    
    	@Before
    	public void setUp() throws Exception {
    		// 读取配置文件
    		// 全局配置文件的路径
    		String resource = "SqlMapConfig.xml";
    		InputStream inputStream = Resources.getResourceAsStream(resource);
    
    		// 创建SqlSessionFactory
    		sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
    	}
    
    	/**
    	 * 通过包装类来进行复杂的用户信息综合查询 
    	 */
    	@Test
    	public void testFindUserList() throws Exception {
    		SqlSession sqlSession = sqlSessionFactory.openSession();
    		UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    
    		//构造UserQueryVO对象
    		UserQueryVO vo = new UserQueryVO();
    		
    		//构造UserExtend对象
    		UserExtend userExtend = new UserExtend();
    		userExtend.setSex("1");
    		userExtend.setUsername("小明");
    		
    		vo.setUserExtend(userExtend);
    		
    		List<UserExtend> list = mapper.findUserList(vo);
    		System.out.println(list);
    	
    		sqlSession.close();
    	}
    }

（4）传递HashMap

同传递POJO对象一样，Map的key相当于POJO的属性名，value 相当于属性值。

mapper映射文件

<mapper namespace="org.mapper.UserMapper">
    	
    	<select id="findUserByHashMap" parameterType="HashMap" resultType="UserExtend">
    		SELECT * FROM USER 
    		WHERE sex=#{sex} AND username LIKE '%${username}%'
    	</select>
    </mapper>

Mapper接口

public interface UserMapper {
    	//传递hashmap综合查询用户信息
    	public List<UserExtend> findUserByHashMap(HashMap hashmap);
    }

测试代码

/**
     * 传递HashMap综合查询用户信息
     * @throws Exception
     */
    @Test
    public void testFindUserByHashMap() throws Exception {
    	SqlSession sqlSession = sqlSessionFactory.openSession();
    	UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    
    	//构造HashMap对象
    	HashMap<String, Object> map = new HashMap<String, Object>();
    	map.put("sex", "1");
    	map.put("username", "小明");
    	
    	List<UserExtend> list = mapper.findUserByHashMap(map);
    	System.out.println(list);
    
    	sqlSession.close();
    }

**输出映射 resultType**

使用resultType进行结果映射时，查询的列名和映射的POJO属性名必须完全一致（还有一种情况，POJO属性名必须是查询列名的驼峰命名），该列才能映射成功。

（1）输出简单类型

参考入门程序：根据用户ID查询用户信息

<select id="findUserCount" parameterType="UserQueryVO" resultType="int">
    		SELECT count(*) FROM USER WHERE sex = #{userExtend.sex} AND username LIKE '%${userExtend.username}%'
    </select>

（2）输出POJO对象

参考入门程序：根据用户ID查询用户信息

<select id="findUserById" parameterType="int"
        resultType="org.po.User">
        SELECT * FROM USER WHERE id =#{id}
    </select>

（3）输出Mapper接口

下面看下Mapper接口的不同之处：

输出单个pojo对象

//根据用户名称来模糊查询用户信息
    public User findUsersByName(String username);

输出POJO列表

//根据用户名称来模糊查询用户信息列表
    public List<User> findUsersByName(String username);

mapper映射文件

<mapper namespace="test">
    	<select id="findUsersByName" parameterType="java.lang.String"
    		resultType="org.po.User">
    		SELECT * FROM USER WHERE username LIKE '%${value}%'
    	</select>
    </mapper>

同样的mapper映射文件，返回单个对象和对象列表时，mapper接口在生成动态代理的时候，会根据返回值的类型，决定调用selectOne方法还是selectList方法。

（4）resultMap  
resultMap可以进行高级结果映射（一对一、一对多、多对多映射），下面先简单介绍下SQL查询的列名与属性名之间的映射，这样属性名就不用必须与查询列名保持一致。

mapper映射文件

<resultMap id="userResultMap" type="user">
    	<id column="id_" property="id"/>
    	<result column="username_" property="username"/>
    	<result column="sex_" property="sex"/>
    </resultMap>
    
    
    <select id="findUserByIdResultMap" parameterType="int" resultMap="userResultMap">
    	SELECT id id_,username username_,sex sex_ FROM USER WHERE id = #{id}
    </select>

Mapper接口

在上面映射文件中，resultMap=“userResultMap”，而"userResultMap"的type类型为Mapper接口对应方法的返回值类型。

public interface UserMapper {
    	public User findUserByIdResultMap(int id);
    }

测试代码

@Test
    public void findUserByIdResultMapTest() {
    	// 创建SqlSession
    	SqlSession sqlSession = sqlSessionFactory.openSession();
    	// 通过SqlSession，获取mapper接口的动态代理对象
    	UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
    
    	// 调用mapper对象的方法
    	User user = userMapper.findUserByIdResultMap(1);
    
    	System.out.println(user);
    	// 关闭SqlSession
    	sqlSession.close();
    }

### **动态SQL** ###

通过Mybatis提供的各种动态标签实现动态拼接sql，使得mapper映射文件在编写SQL时更加灵活、方便。常用动态SQL标签有：if、where、set、choose（when、otherwise）、foreach；

**if、where、choose（when、otherwise）**

（1）用if进行判断是否为空时，不仅要判断null，也要判断空字符串‘’。  
（2）where标签会去掉条件中的第一个and符号。  
（3）choose标签类似 Java 中的 switch 语句，只能在where标签后面使用。(注意当有多个when条件时, 只执行一个)

<select id="queryList" parameterType="HashMap" resultType="Project">
    	select p.*  from t_project p
    	<where>
    		<if test="projectname != null and projectname.trim() != ''">
    			and p.`project_name` like concat('%',#{projectname},'%')
    		</if>
    			and is_delete != -1
    	</where>
    	<choose>
    		<when test="sidx != null and sidx.trim() != ''">
    			order by p.sidx
    		</when>
    		<otherwise>
    			order by p.id desc
    		</otherwise>
    	</choose>
    	<if test="offset != null and limit != null">
    		limit #{offset}, #{limit}
    	</if>
    </select>

**set**

<update id="update" parameterType="ProjectDTO" resultType="int">
    	update t_project
    	<set> 
    		<if test="projectName != null">`project_name` = #{projectName}, </if>
    		<if test="userName != null">`user_name` = #{userName}, </if>
    		<if test="remark != null">`remark` = #{remark} </if>
    	</set>
    	where id = #{id}
    </update>

**foreach**

foreach 的传入参数有三种情况，分别是带有集合属性的对象、List集合、数组。

List 集合或者数组作为参数对象传给 MyBatis，MyBatis 会自动将它包装在一个 Map 中并以名称为键。List 实例将会以“list”作为键，而数组实例的键将是“array”。留意下面映射文件 \[collection\] 标签的值。

（1）带有集合属性的对象

POJO类

public class UserQueryVO {	
    	//商品ID集合
    	private List<Integer> idList;
    }

映射文件

<mapper namespace="org.mapper.UserMapper">
    	<select id="findUserCount" parameterType="UserQueryVO" resultType="int">
    		SELECT count(1) FROM USER 
    		<where>
    			
    			
    			
    			
    			
    			
    			<if test="idList != null and idList.size > 0">
    				<foreach collection="idList" item="id" open="AND id IN (" close=")" separator=",">
    						#{id}
    				</foreach>
    			</if>
    		</where>
    	</select>
    </mapper>

测试程序

@Test
    public void testFindUserCount() throws Exception {
    	SqlSession sqlSession = sqlSessionFactory.openSession();
    	UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    
    	//构造UserQueryVO对象
    	UserQueryVO vo = new UserQueryVO();
    	List<Integer> idList = new ArrayList<>();
    	idList.add(1);
    	idList.add(2);
    	idList.add(10);
    	vo.setIdList(idList);
    
    	int count = mapper.findUserCount(vo);
    	System.out.println(count);
    	
    	sqlSession.close();
    }

（2）List集合

映射文件

<mapper namespace="org.mapper.UserMapper">
    	<select id="findUserCount" parameterType="List" resultType="int">
    		SELECT count(1) FROM USER 
    		<where>
    			<if test="list != null and list.size > 0">
    				<foreach collection="list" item="id" open="AND id IN (" close=")" separator=",">
    						#{id}
    				</foreach>
    			</if>
    		</where>
    	</select>
    </mapper>

测试程序

@Test
    public void testFindUserCount() throws Exception {
    	SqlSession sqlSession = sqlSessionFactory.openSession();
    	UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    
    	List<Integer> idList = new ArrayList<>();
    	idList.add(1);
    	idList.add(2);
    	idList.add(10);
    
    	int count = mapper.findUserCount(idList);
    	System.out.println(count);
    	
    	sqlSession.close();
    }

（3）数组

映射文件

<mapper namespace="org.mapper.UserMapper">
    	<select id="findUserCount" resultType="int">
    		SELECT count(1) FROM USER 
    		<where>
    			<foreach collection="array" item="id" open="AND id IN (" close=")" separator=",">
    					#{id}
    			</foreach>
    		</where>
    	</select>
    </mapper>

测试程序

**SQL片段**

Mybatis提供了SQL片段功能，可以提高SQL的可重用性。使用< include refid=""> 来引用SQL片段。

<mapper namespace="org.mapper.UserMapper">		
    	
    	
    	<sql id="select_user_where">
    		<if test="userExtend != null">
    			<if test="userExtend.sex != null and userExtend.sex.trim() != ''">
    				AND sex = #{userExtend.sex}
    			</if>
    			<if test="userExtend.username != null and userExtend.username != ''">
    				AND username LIKE '%${userExtend.username}%'
    			</if>
    		</if>
    	</sql>
    	
    	
    	
    	<select id="findUserCount" parameterType="UserQueryVO" resultType="int">
    		SELECT count(*) FROM USER 
    		<where>
    			<include refid="select_user_where"/>
    		</where>
    	</select>
    </mapper>

### **Mybatis与Hibernate的区别及各自应用场景** ###

**Mybatis技术特点**

（1）通过直接编写SQL语句，可以直接对SQL进行性能的优化。

（2）学习门槛低，学习成本低。只要有SQL基础，就可以学习Mybatis，而且很容易上手。

（3）由于直接编写SQL语句，所以灵活多变，代码维护性更好。

（4）不能支持数据库无关性，即数据库发生变更，要写多套代码进行支持，移植性不好。

（5）需要编写结果映射。

**Hibernate技术特点**

（1）标准的ORM框架，程序员不需要编写SQL语句。

（2）具有良好的数据库无关性，即数据库发生变化的话，代码无需再次编写。

（3）学习门槛高，需要对数据关系模型有良好的基础，而且在设置ORM映射的时候，需要考虑好性能和对象模型的权衡。

（4）程序员不能自主的去进行SQL性能优化。

**Mybatis应用场景**

需求多变的互联网项目，例如电商项目。

**Hibernate应用场景**

需求明确、业务固定的项目，例如OA项目、ERP项目等。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdGlhbnhpYW5nX2thb2xh_size_16_color_FFFFFF_t_70]: /images/20220531/c2824b90c0ba49fe93391533b8085d7d.png
[20190328154018791.png]: /images/20220531/d63d798e6af341029917c793e912975d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdGlhbnhpYW5nX2thb2xh_size_16_color_FFFFFF_t_70 1]: /images/20220531/94306b73a05446b79d5101d7b283ae74.png