mybatis

1    Mybatis是什么？

        MyBatis 本是apache的一个开源项目iBatis, 2010年这个项目由apache software foundation 迁移到了google code，并且改名为MyBatis，实质上Mybatis对ibatis进行一些改进。 
        MyBatis是一个优秀的持久层框架，它对jdbc的操作数据库的过程进行封装，使开发者只需要关注 SQL 本身，而不需要花费精力去处理例如注册驱动、创建connection、创建statement、手动设置参数、结果集检索等jdbc繁杂的过程代码。
Mybatis通过xml或注解的方式将要执行的各种statement（statement、preparedStatemnt、CallableStatement）配置起来，并通过java对象和statement中的sql进行映射生成最终执行的sql语句，最后由mybatis框架执行sql并将结果映射成java对象并返回。
 

2    分析原生态jdbc程序中存在的问题 

2.1    原生态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();
			}
		}

	}

 2.2    Jdbc问题总结

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

3    Mybatis的框架原理 

 

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对象类型。

 

4   入门程序 

4.1    下载mybatis 

mybaits的代码由github.com管理，下载地址：https://github.com/mybatis/mybatis-3/releases 

 

 4.2 user 表结构

 4.3 工程搭建

4.3.1    第一步：创建java工程

用eclipse创建一个java工程，jdk使用1.7.0_72。 

 

4.3.2    第二步：加入jar包

加入以下四部分jar包，其中junit的jar包，是非必须的。
 

4.3.3   添加log4j.properties文件

Mybatis使用的日志包是log4j的，所以需要添加log4j.properties。

在classpath下创建log4j.properties如下：

文件内容可以从mybatis-3.2.7.pdf中拷贝

# Global logging configuration

log4j.rootLogger=DEBUG, stdout

# Console output...

log4j.appender.stdout=org.apache.log4j.ConsoleAppender

log4j.appender.stdout.layout=org.apache.log4j.PatternLayout

log4j.appender.stdout.layout.ConversionPattern=%5p [%t] - %m%n

日志级别在开发阶段设置成DEBUG，在生产阶段设置成INFO或者ERROR。

4.4 、编程步骤

4.4.1 创建PO类 

创建的po类的属性要和数据库中表的列名一致（如果表中的列名是带有下划线，那么po类中对应的的属性名要采用驼峰式命名）

User.java类如下：

public class User implements Serializable {
	private static final long serialVersionUID = 1L;
	private int id;
	private String username;// 用户姓名
	private String sex;// 性别
	private Date birthday;// 生日
	private String address;// 地址
get/set……
}

 4.4.2 创建全局配置文件

首选  db.properties

db.driver=com.mysql.jdbc.Driver
db.url=jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf8
db.username=root
db.password=321210

 在config目录下，创建SqlMapConfig.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>
    <!-- 加载java的配置文件或者声明属性信息 -->
    <properties resource="db.properties">
        <property name="db.username" value="root" />
    </properties>
    <!-- <settings></settings> -->
    <!-- 自定义别名 -->
    <typeAliases>
        <!-- 单个别名定义 -->
        <!-- <typeAlias type="com.mybatis.po.User" alias="user"/> -->
        <!-- 批量别名定义（推荐） -->
        <!-- package：指定包名称来为该包下的po类声明别名，默认的别名就是类名（首字母大小写都可） -->
        <package name="com.domain" />
    </typeAliases>

    <!-- 配置mybatis的环境信息，与spring整合，该信息由spring来管理 -->
    <environments default="development">
        <environment id="development">
            <!-- 配置JDBC事务控制，由mybatis进行管理 -->
           <transactionManager type="JDBC"></transactionManager>
            <!-- 配置数据源，采用mybatis连接池 -->
            <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>

    <!-- 加载映射文件 -->
    <mappers>
        <mapper resource="User.xml" />
    <!-- <mapper resource="mapper/UserMapper.xml" /> -->
        <!-- 批量加载映射文件 -->
    <!--    <package name="com.mybatis.mapper" /> -->
    </mappers>
</configuration>

4.4.3 User.xml映射文件

 在config目录下，创建User.xml（这种命名规范是由ibatis遗留下来）

?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">
<!-- namespace：命名空间，对statement的信息进行分类管理 -->
<!-- 注意：在mapper代理时，它具有特殊及重要的作用 -->
<mapper namespace="test">
	<!-- 根据用户ID查询用户信息 -->
	<!-- select：表示一个MappedStatement对象 -->
	<!-- id：statement的唯一标示 -->
	<!-- #{}：表示一个占位符？ -->
	<!-- #{id}：里面的id表示输入参数的参数名称，如果该参数是简单类型，那么#{}里面的参数名称可以任意 -->
	<!-- parameterType：输入参数的java类型 -->
	<!-- resultType：输出结果的所映射的java类型（单条结果所对应的java类型） -->
	<select id="findUserById" parameterType="int"
		resultType="com.domain.User">
		SELECT * FROM USER WHERE id =#{id}
	</select>
	<!-- 根据用户名称模糊查询用户列表 -->
	<!-- ${}：表示一个sql的连接符 -->
	<!-- ${value}：里面的value表示输入参数的参数名称，如果该参数是简单类型，那么${}里面的参数名称必须是value -->
	<!-- ${}这种写法存在sql注入的风险，所以要慎用！！但是在一些场景下，必须使用${}，比如排序时，动态传入排序的列名，${}会原样输出，不加解释 -->
	<select id="findUsersByName" parameterType="java.lang.String"
		resultType="com.domain.User">
		SELECT * FROM USER WHERE username LIKE '%${value}%'
	</select>
	<!-- 添加用户 -->
	<!-- selectKey：查询主键，在标签内需要输入查询主键的sql -->
	<!-- order：指定查询主键的sql和insert语句的执行顺序，相当于insert语句来说 -->
	<!-- LAST_INSERT_ID：该函数是mysql的函数，获取自增主键的ID，它必须配合insert语句一起使用 -->
	<insert id="insertUser" parameterType="com.domain.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>
	<!-- 自增主键之UUID -->
	<insert id="insertUser2" parameterType="com.domain.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>
	<!-- 自增主键之UUID -->
	<insert id="insertUser3" parameterType="com.domain.User">
		<selectKey keyProperty="id" resultType="int" order="BEFORE">
			SELECT seq.nextval FROM dual
		</selectKey>
		INSERT INTO USER
		(id,username,birthday,sex,address)
		VALUES(#{id},#{username},#{birthday},#{sex},#{address})
	</insert>
</mapper>

 在全局配置文件中加载映射文件

	<!-- 加载映射文件 -->
	<mappers>
		<mapper resource="User.xml" />
	<!-- <mapper resource="mapper/UserMapper.xml" /> -->
		<!-- 批量加载映射文件 -->
	<!-- 	<package name="com.itheima.mybatis.mapper" /> -->
	</mappers>

 4.3.4 测试代码根据id查询

 

public class mybatistest {
	public static void main(String[] args) throws IOException {
		//读取配置文件
		//全局配置文件的路径
		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();
	}
}

 java.io.IOException: Could not find resource SqlMapConfig.xm

http://blog.csdn.net/jj_nan/article/details/63685929

 4.3.5 根据用户名模糊匹配

public static void main(String[] args) throws IOException {
		//读取配置文件
		//全局配置文件的路径
		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.selectOne("test.findUsersByName", "小明");
		List<User> list2 = sqlSession.selectList("test.findUsersByName", "小明");
		System.out.println(list2);
		//关闭资源
		sqlSession.close();
	}

4.3.4 添加用户

public void insertUserTest() throws Exception {
		// 1、读取配置文件
		String resource = "SqlMapConfig.xml";
		InputStream inputStream = Resources.getResourceAsStream(resource);
		// 2、根据配置文件创建SqlSessionFactory
		SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder()
				.build(inputStream);
		// 3、SqlSessionFactory创建SqlSession
		SqlSession sqlSession = sqlSessionFactory.openSession();
		// 4、SqlSession执行statement，并返回映射结果
		
		//构建user参数，没有赋值的属性采取默认值
		User user = new User();
		user.setUsername("东哥1");
		user.setAddress("清河宝盛西里");
		
		// 第一个参数：statement的id，建议：namespace.statementId（确保唯一）
		// 第二个参数：入参的值，它的类型要和映射文件中对应的statement的入参类型一致
		sqlSession.insert("insertUser", user);

		//切记：增删改操作时，要执行commit操作
		sqlSession.commit();

		// 5、关闭SqlSession
		sqlSession.close();
	}

4.3.5 删除 

user.xml

<!-- 根据ID删除用户 -->
<delete id="deleteUser" parameterType="int">
	DELETE FROM USER WHERE id= #{id}
</delete>

测试

@Test
public void deleteUserTest() throws Exception{
	// 1、读取配置文件
	String resource = "SqlMapConfig.xml";
	InputStream inputStream = Resources.getResourceAsStream(resource);
	// 2、根据配置文件创建SqlSessionFactory
	SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder()
				.build(inputStream);
	// 3、SqlSessionFactory创建SqlSession
	SqlSession sqlSession = sqlSessionFactory.openSession();
	// 4、SqlSession执行statement，并返回映射结果
	// 第一个参数：statement的id，建议：namespace.statementId（确保唯一）
	// 第二个参数：入参的值，它的类型要和映射文件中对应的statement的入参类型一致
	sqlSession.delete("test.deleteUser", 30);
		
	//切记：增删改操作时，要执行commit操作
	sqlSession.commit();

	// 5、关闭SqlSession
	sqlSession.close();
}

 4.3.6 修改

user.xml

<!-- 根据传入的用户信息修改用户 -->
<update id="updateUser" parameterType="cn.po.User">
	UPDATE USER SET username = #{username},sex=#{sex} WHERE id=#{id}
</update>

 test

@Test
public void updateUserTest() throws Exception{
	// 1、读取配置文件
	String resource = "SqlMapConfig.xml";
	InputStream inputStream = Resources.getResourceAsStream(resource);
	// 2、根据配置文件创建SqlSessionFactory
	SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
	// 3、SqlSessionFactory创建SqlSession
	SqlSession sqlSession = sqlSessionFactory.openSession();
	// 4、SqlSession执行statement，并返回映射结果
		
	//构建user参数，没有赋值的属性采取默认值
	User user = new User();
	user.setId(28);
	user.setUsername("东哥11");
	user.setAddress("清河宝盛西里");
		
	// 第一个参数：statement的id，建议：namespace.statementId（确保唯一）
	// 第二个参数：入参的值，它的类型要和映射文件中对应的statement的入参类型一致
	sqlSession.update("test.updateUser", user);
		
	//切记：增删改操作时，要执行commit操作
	sqlSession.commit();

	// 5、关闭SqlSession
	sqlSession.close();
}

 5

5.1主键返回之自增主键（mysql）

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

 

<!-- 添加用户之自增主键返回（selectKey方式） -->
<!-- 
		[selectKey标签]：通过select查询来生成主键
		[keyProperty]：指定存放生成主键的属性
		[resultType]：生成主键所对应的Java类型
		[order]：指定该查询主键SQL语句的执行顺序，相对于insert语句
		[last_insert_id]：MySQL的函数，要配合insert语句一起使用
-->
<insert id="insertUser" parameterType="cn.po.User">
	<selectKey keyProperty="id" resultType="int" order="AFTER">
		SELECT LAST_INSERT_ID()
	</selectKey>
	INSERT INTO USER(username,sex,birthday,address) VALUES (#{username},#{sex},#{birthday},#{address})
</insert>

5.2主键返回之MySQL函数UUID 

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

<!-- 添加用户之UUID主键返回 -->
<!-- 
	[uuid]：MySQL的函数，生成的主键是35位的字符串，所以使用它时要修改id的类型为字符类型
	注意：
		1、此时order采用BEFORE，因为需要先生成出主键，再执行insert语句
		2、显式的给ID赋值
-->
<insert id="insertUser" parameterType="cn.po.User">
	<selectKey keyProperty="id" resultType="string" order="BEFORE">
		SELECT UUID()
	</selectKey>
	INSERT INTO USER(id,username,sex,birthday,address) VALUES (#{id},#{username},#{sex},#{birthday},#{address})
</insert>

5.3主键返回之Oracle序列返回 

<!-- 添加用户之sequence返回 -->
<!-- 
	通过Oracle的sequence获取主键方式与MySQL的uuid方式基本一致	
-->
<insert id="insertUser" parameterType="cn.po.User">
	<selectKey keyProperty="id" resultType="int" order="BEFORE">
		SELECT user_seq.nextval() FROM dual
	</selectKey>
	INSERT INTO USER(id,username,sex,birthday,address) VALUES (#{id},#{username},#{sex},#{birthday},#{address})
</insert>

 6、总结

 

6.1   parameterType和resultType

parameterType指定输入参数的java类型，可以填写别名或Java类的全限定名。
resultType指定输出结果的java类型，可以填写别名或Java类的全限定名。

parameterType指定输入参数的java类型，parameterType只有一个，也就是说入参只有一个。

resultType指定输出结果的java类型（是单条记录的java类型）

6.2  #{}和${} 面试必考 

#{}：

相当于预处理中的占位符？。

#{}里面的参数表示接收java输入参数的名称。

#{}可以接受HashMap、简单类型、POJO类型的参数。

当接受简单类型的参数时，#{}里面可以是value，也可以是其他。

#{}可以防止SQL注入。

${}：

相当于拼接SQL串，对传入的值不做任何解释的原样输出。

${}里面的值会原样输出，不加解析（如果该参数值是字符串，不会添加引号）

${}会引起SQL注入，所以要谨慎使用。

${}可以接受HashMap、简单类型、POJO类型的参数。

当接受简单类型的参数时，${}里面只能是value。

 6.3 selectOne和selectList

 

selectOne：只能查询0或1条记录，大于1条记录的话，会报错：

selectList：可以查询0或N条记录

 

7   Mybatis开发dao

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

7.1  原始dao的开发方式

即开发dao接口和dao实现类 

7.1.1 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;
}

 7.1.2 dao实现

 

SqlSession使用范围
通过入门程序，大家可以看出，在测试代码中，有大量的重复代码。所以我们第一反应就是想给它抽取出共性的部分，但是SqlSession、SqlSessionFactory、SqlSessionFactoryBuilder有着各自的生命周期，因为这些生命周期的不同，抽取时要有针对性的处理。
所以在抽取之前，我们先来了解并总结下它们三个的生命周期。
SqlSessionFactoryBuilder
它的作用只是通过配置文件创建SqlSessionFactory，所以只要创建出SqlSessionFactory，它就可以销毁了。所以说，它的生命周期是在方法之内。

SqlSessionFactory
它的作用是创建SqlSession的工厂，工厂一旦创建，除非应用停掉，不要销毁。
所以说它的生命周期是在应用范围内。这里可以通过单例模式来管理它。
在mybatis整合spring之后，最好的处理方式是把SqlSessionFactory交由spring来做单例管理。
SqlSession
SqlSession是一个面向用户（程序员）的接口，它的默认实现是DefaultSqlSession。
Mybatis是通过SqlSession来操作数据库的。SqlSession中不仅包含要处理的SQL信息，还包括一些数据信息，所以说它是线程不安全的，因此它最佳的生命周期范围是在方法体之内。

public class UserDaoImpl implements UserDao {
	// 依赖注入
	private SqlSessionFactory sqlSessionFactory;
	public UserDaoImpl(SqlSessionFactory sqlSessionFactory) {
		this.sqlSessionFactory = sqlSessionFactory;
	}
	@Override
	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 sqlSession.selectOne("test.findUserById", 1);
	}
	@Override
	public List<User> findUsersByName(String name) {
		// 创建SqlSession
		SqlSession sqlSession = sqlSessionFactory.openSession();
		// 调用SqlSession的增删改查方法
		// 第一个参数：表示statement的唯一标示
		List<User> list = sqlSession.selectList("test.findUsersByName", name);
		System.out.println(list);
		// 关闭资源
		sqlSession.close();
		return list;
	}
	@Override
	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();
	}
}

7.1.3 测试

public class UserDaoTest {

	//声明全局的SqlSessionFactory
	private SqlSessionFactory sqlSessionFactory;
	
	@Before
	public void setUp() throws Exception {
		// 1、读取配置文件
		String resource = "SqlMapConfig.xml";
		InputStream inputStream = Resources.getResourceAsStream(resource);
		// 2、根据配置文件创建SqlSessionFactory
		sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
	}

	@Test
	public void testFindUserById() {
		//构造UserDao对象
		UserDao userDao = new UserDaoImpl(sqlSessionFactory);
		//调用UserDao对象的方法
		User user = userDao.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("东哥3");
		user.setAddress("清河宝盛西里3");
		
		//调用UserDao对象的方法
		userDao.insertUser(user);
		
		System.out.println(user.getId());
	}

}

7.1.4 问题 

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

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

org.apache.ibatis.executor.ExecutorException: Executor was closed.

7.2  Mapper代理的开发方式

 

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

不过要实现mapper代理的开发方式，需要遵循一些开发规范。

Mapper代理使用的是jdk的代理策略。

7.2.1 规范

1. mapper接口的全限定名要和mapper映射文件的namespace值一致。
2. mapper接口的方法名称要和mapper映射文件的statement的id一致。
3. mapper接口的方法参数类型要和mapper映射文件的statement的parameterType的值一致，而且它的参数是一个。
4. mapper接口的方法返回值类型要和mapper映射文件的statement的resultType的值一致。

 7.2.2 编写mapper 映射文件

config目录下创建（mapper目录然后）创建UserMapper.xml（这是mybatis的命名规范，当然，也不是必须是这个名称）

sqlSession内部的数据区域本身就是一级缓存，是通过map来存储的。

重新定义mapper映射文件UserMapper.xml（内容同Users.xml，除了namespace的值），放到新创建的目录mapper下

<?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">
<!-- namespace：此时用mapper代理方式，它的值必须等于对应mapper接口的全限定名  -->
<mapper namespace="cn.mapper.UserMapper">

	<!-- 根据用户ID，查询用户信息 -->
	<!-- 
		[id]：statement的id，要求在命名空间内唯一  
		[parameterType]：入参的java类型，可是是简单类型、POJO、HashMap
		[resultType]：查询出的单条结果集对应的java类型
		[#{}]： 表示一个占位符?
		[#{id}]：表示该占位符待接收参数的名称为id。注意：如果参数为简单类型时，#{}里面的参数名称可以是任意定义
	 -->
	<select id="findUserById" parameterType="int" resultType="cn.po.User">
		SELECT * FROM USER WHERE id = #{id}
	</select>
	
	
	<!-- 根据用户名称模糊查询用户信息列表 -->
	<!-- 
		[${}]：表示拼接SQL字符串，即不加解释的原样输出
	 	[${value}]：表示要拼接的是简单类型参数。
		 注意：
		1、如果参数为简单类型时，${}里面的参数名称必须为value 
		2、${}会引起SQL注入，一般情况下不推荐使用。但是有些场景必须使用${}，比如order by ${colname}
	-->
	<select id="findUsersByName" parameterType="java.lang.String" resultType="cn.itcast.mybatis.po.User">
		SELECT * FROM USER WHERE username LIKE '%${value}%'
	</select>
	
	<!-- 添加用户之自增主键返回（selectKey方式） -->
	<!-- 
		[selectKey标签]：通过select查询来生成主键
		[keyProperty]：指定存放生成主键的属性
		[resultType]：生成主键所对应的Java类型
		[order]：指定该查询主键SQL语句的执行顺序，相对于insert语句，此时选用AFTER
		[last_insert_id]：MySQL的函数，要配合insert语句一起使用
	 -->
	<insert id="insertUser" parameterType="cn.po.User">
		<selectKey keyProperty="id" resultType="int" order="AFTER">
			SELECT LAST_INSERT_ID()
		</selectKey>
		INSERT INTO USER(username,sex,birthday,address) VALUES (#{username},#{sex},#{birthday},#{address})
	</insert>
	
</mapper>

 7.2.3 加载mapper 

Type interface com.zhaoka.mapper.DatKcardKmMapper is not known to the MapperRegistry   没有在sqlConfig.xml中配置对应mapper.xml文件 

<mappers>
		<!-- <mapper resource="User.xml" /> -->
		<mapper resource="UserMapper.xml" />
</mappers>

 7.2.4 编写mapper接口

内容同UserDao接口一样：

public interface UserMapper {
	//根据用户ID来查询用户信息
	public User findUserById(int id);
	//根据用户名称来模糊查询用户信息列表
	public List<User> findUsersByName(String username);
	//添加用户
	public void insertUser(User user);
}

 7.2.5 测试

public class UserMapperTest {

	// 声明全局的SqlSessionFactory
	private SqlSessionFactory sqlSessionFactory;

	@Before
	public void setUp() throws Exception {
		// 1、读取配置文件
		String resource = "SqlMapConfig.xml";
		InputStream inputStream = Resources.getResourceAsStream(resource);
		// 2、根据配置文件创建SqlSessionFactory
		sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
	}

	@Test
	public void testFindUserById() {
		// 创建SqlSession
		SqlSession sqlSession = sqlSessionFactory.openSession();
		// 通过SqlSession，获取mapper接口的动态代理对象
		UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
		// 调用mapper对象的方法
		User user = userMapper.findUserById(1);

		System.out.println(user);
		// 关闭SqlSession
		sqlSession.close();

	}

	@Test
	public void testFindUsersByName() {
		// 创建SqlSession
		SqlSession sqlSession = sqlSessionFactory.openSession();
		// 通过SqlSession，获取mapper接口的动态代理对象
		UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
		// 调用mapper对象的方法
		List<User> list = userMapper.findUsersByName("小明");

		System.out.println(list);
		// 关闭SqlSession
		sqlSession.close();
	}

	@Test
	public void testInsertUser() {
		// 创建SqlSession
		SqlSession sqlSession = sqlSessionFactory.openSession();
		// 通过SqlSession，获取mapper接口的动态代理对象
		UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
		
		//构造User对象
		User user = new User();
		user.setUsername("东哥4");
		user.setAddress("清河宝盛西里4");
		
		// 调用mapper对象的方法
		userMapper.insertUser(user);

		System.out.println(user.getId());
		
		//执行SqlSession的commit操作
		sqlSession.commit();
		// 关闭SqlSession
		sqlSession.close();
	}

}

 8 全局配置文件解释

 

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

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

Properties（属性）

Settings（全局参数设置）

typeAliases（类型别名）

typeHandlers（类型处理器）

objectFactory（对象工厂）

plugins（插件）

environments（环境信息集合）

         environment（单个环境信息）

                   transactionManager（事物）

                   dataSource（数据源）

mappers（映射器）

 

 8.1 properties

如上所述sqlmapconfig.xml

加载的顺序

1. 先加载properties中property标签声明的属性
2. 再加载properties标签引入的java配置文件中的属性
3. parameterType的值会和properties的属性值发生冲突。

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

db.properties配置信息如下：

db.driver=com.mysql.jdbc.Driver

db.url=jdbc:mysql://localhost:3306/mybatis?useUnicode=true&characterEncoding=utf8

db.username=root

db.password=root

 

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

<!-- 通过properties标签，读取java配置文件的内容 -->

<properties resource="db.properties" />



<!-- 配置mybatis的环境信息 -->

<environments default="development">

    <environment id="development">

       <!-- 配置JDBC事务控制，由mybatis进行管理 -->

       <transactionManager type="JDBC"></transactionManager>

       <!-- 配置数据源，采用dbcp连接池 -->

       <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将按照下面的顺序加载属性：

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

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

8.2 settings

 

 

 

8.3 typeAliases

对po类进行别名的定义 

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

mybatis支持的别名

别名	映射的类型
_byte	byte
_long	long
_short	short
_int	int
_integer	int
_double	double
_float	float
_boolean	boolean
string	String
byte	Byte
long	Long
short	Short
int	Integer
integer	Integer
double	Double
float	Float
boolean	Boolean
date	Date
decimal	BigDecimal
bigdecimal	BigDecimal

 自定义别名

 SqlMapConfig.xml配置信息如下：

<!-- 定义别名 -->
	<typeAliases>
		<!-- 单个定义别名 -->
		<typeAlias type="cn.po.User" alias="user"/>
		
		<!-- 批量定义别名（推荐） -->
		<!-- [name]：指定批量定义别名的类包，别名为类名（首字母大小写都可） -->
		<package name="cn.po"/>
	</typeAliases>

 

8.4 Mappers

 

1    <mapper resource=’’/>
使用相对于类路径的资源
如：<mapper resource="sqlmap/User.xml" />

2    <mapper url=’’/>
使用完全限定路径
如：<mapper url="file:///D:\workspace_spingmvc\mybatis_01\config\sqlmap\User.xml" />
3    <mapper class=’’/>
使用mapper接口的全限定名
如：<mapper class="cn.mapper.UserMapper"/>

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

注意：此种方法要求mapper接口和mapper映射文件要名称相同，且放到同一个目录下；
 

9 mybatis 映射文件 核心 

9.1    输入映射

9.1.1    简单类型

参考入门程序之根据用户ID查询用户信息的映射文件

9.1.2    Pojo类型

参考入门程序之添加用户的映射文件

 

9.1.3     传递pojo包装对象
 

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

 创建包装pojo

public class UserQueryVO {
	private User user;//用户信息
	private List<Integer> idList;//商品ID集合
	public List<Integer> getIdList() {//商品信息
		return idList;
	}

映射文件

UserQueryVOMapper.xml

<select id="findUserList" parameterType="com.domain.UserQueryVO" resultType="User">

       SELECT * FROM user WHERE username like '%${u.username}%'

    </select>

报错There is no getter for property named 'u' in 'class com.domain.UserQueryVO'

 属性名称要一致

  SELECT * FROM user WHERE username like '%${user.username}%' 

 

 Mapper接口

public interface UserQueryVOMapper {
	public List<User> findUserList(UserQueryVO vo);
}

 ceshi

public class VOMtest {
	private SqlSessionFactory sqlSessionFactory;
	public void setUp() throws Exception {
		// 读取配置文件
		// 全局配置文件的路径
		String resource = "SqlMapConfig.xml";
		InputStream inputStream = Resources.getResourceAsStream(resource);
		// 创建SqlSessionFactory
		sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
	}
	public void testFindUserList() throws Exception {
		// 创建UserMapper对象
		SqlSession sqlSession = sqlSessionFactory.openSession();
		// 由mybatis通过sqlsession来创建代理对象
		UserQueryVOMapper mapper = sqlSession.getMapper(UserQueryVOMapper.class);
		UserQueryVO vo = new UserQueryVO();
		User u = new User();
		u.setUsername("小明");
		vo.setUser(u);
		List<User> userList = mapper.findUserList(vo);
		System.out.println(userList);
		sqlSession.close();
	}
	public static void main(String[] args) throws Exception {
		VOMtest vt = new VOMtest();
		vt.setUp();
		vt.testFindUserList();
	}
}

9.1.4 传递hashmap

同传递POJO对象一样，map的key相当于pojo的属性。 

映射文件

<!-- 传递hashmap综合查询用户信息 -->

    <select id="findUserByHashMap" parameterType="hashmap" resultType="user">

       select * from user where id=#{id} and username like '%${username}%'

    </select>

public User findUserbyHashMap(HashMap<Integer, String> hm);

上边红色标注的是hashmap的key。

测试

public class test {
	private SqlSessionFactory sqlSessionFactory;
	public void setUp() throws Exception {
		// 读取配置文件
		// 全局配置文件的路径
		String resource = "SqlMapConfig.xml";
		InputStream inputStream = Resources.getResourceAsStream(resource);
		// 创建SqlSessionFactory
		sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
	}
	public void testFindUserByHashmap()throws Exception{
		//获取session
		SqlSession session = sqlSessionFactory.openSession();
		//获限mapper接口实例
		UserMapper mapper = session.getMapper(UserMapper.class);
		//构造查询条件Hashmap对象
		HashMap<String, Object> map = new HashMap<String, Object>();
		map.put("id", 1);
		map.put("username", "小明");
		//传递Hashmap对象查询用户列表
		User u = mapper.findUserbyHashMap(map);
		System.out.println(u);
		//关闭session
		session.close();
	}
	public static void main(String[] args) throws Exception {
		test t = new test();
		t.setUp();
		t.testFindUserByHashmap();
	}
}

 

异常测试：

传递的map中的key和sql中解析的key不一致。

测试结果没有报错，只是通过key获取值为空。

9.2 、输出映射 resultType

使用resultType进行结果映射时，需要查询出的列名和映射的对象的属性名一致，才能映射成功。

如果查询的列名和对象的属性名全部不一致，那么映射的对象为空。

如果查询的列名和对象的属性名有一个一致，那么映射的对象不为空，但是只有映射正确那一个属性才有值。

如果查询的sql的列名有别名，那么这个别名就是和属性映射的列名。

 9.2.1 简单类型

当输出结果只有一列时，可以使用ResultType指定简单类型作为输出结果类型。 

查询用户的总数

映射

<select id="findUserCount" resultType="int">

      select count(*) from user

   </select>

接口

public int findUserCount();

测试

public class test {
	private SqlSessionFactory sqlSessionFactory;
	public void setUp() throws Exception {
		// 读取配置文件
		// 全局配置文件的路径
		String resource = "SqlMapConfig.xml";
		InputStream inputStream = Resources.getResourceAsStream(resource);
		// 创建SqlSessionFactory
		sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
	}
	public void testfindUserCount()throws Exception{
		//获取session
		SqlSession session = sqlSessionFactory.openSession();
		//获限mapper接口实例
		UserMapper mapper = session.getMapper(UserMapper.class);
		int count = mapper.findUserCount();
		System.out.println(count);
		//关闭session
		session.close();
	}
	public static void main(String[] args) throws Exception {
		test t = new test();
		t.setUp();
		t.testfindUserCount();;
	}
}

 

9.2.2 Pojo对象和pojo列表 

参考入门程序之根据用户ID查询用户信息和根据用户名称模糊查询用户列表

注意：输出单个pojo对象和pojo列表（盛放pojo对象）时，他们两mapper映射文件中的resultType的类型是一样的，mapper接口的方法返回值不同。

 

Mapper映射文件是同一个

<select id="findUsersByName" parameterType="java.lang.String" resultType="cn.po.User">

       SELECT * FROM USER WHERE username LIKE '%${value}%'

</select>

 

下面看下mapper接口的不同之处

1. 输出单个pojo对象

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

public User findUsersByName(String username);

1. 输出pojo列表

//根据用户名称来模糊查询用户信息列表

    public List<User> findUsersByName(String username);

 

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

 

9.2.3resultMap

resultMap可以进行高级结果映射（一对一、一对多映射）。

 

如果查询出来的列名和属性名不一致，通过定义一个resultMap将列名和pojo属性名之间作一个映射关系。

 

 

1. 定义resultMap
2. 使用resultMap作为statement的输出映射类型。

对以下sql查询的结果集进行对象映射

Select id id_,username username_,sex sex_ from user where id = 1;

映射文件

<!-- 定义resultMap -->

<!--

    [id]：定义resultMap的唯一标识

    [type]：定义该resultMap最终映射的pojo对象

    [id标签]：映射结果集的唯一标识列，如果是多个字段联合唯一，则定义多个id标签

    [result标签]：映射结果集的普通列

    [column]：SQL查询的列名，如果列有别名，则该处填写别名

    [property]：pojo对象的属性名

-->

<resultMap type="user" id="userResultMap">

    <id column="id_" property="id"/>

    <result column="username_" property="username"/>

    <result column="sex_" property="sex"/>

</resultMap>

定义statement：

<!-- 根据ID查询用户信息（学习resultMap） -->

<select id="findUserByIdResultMap" parameterType="int" resultMap="userResultMap">

SELECT id id_,username username_,sex sex_ FROM USER WHERE id = #{id}

</select>

mapper接口

//根据ID查询用户信息（resultMap）

    public User findUserByIdResultMap(int id);

定义Statement使用resultMap映射结果集时，Mapper接口定义方法的返回值类型为mapper映射文件中resultMap的type类型。

测试 

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

 

10  动态sql

在mybatis中，它提供了一些动态sql标签，可以让程序员更快的进行mybatis的开发，这些动态sql可以通过sql的可重用性。。

常用的动态sql标签：if标签、where标签、sql片段、foreach标签

10.1  if where

• If标签：作为判断入参来使用的，如果符合条件，则把if标签体内的SQL拼接上。

注意：用if进行判断是否为空时，不仅要判断null，也要判断空字符串‘’；

• Where标签：会去掉条件中的第一个and符号。

 

综合查询时，查询条件由用户来输入，用户名称可以为空，需要满足这种情况下的sql编写。

 

测试

 

 

 

 10.2 sql片段

Sql片段可以让代码有更高的可重用性

Sql片段需要先定义后使用

使用sql标签来定义一个SQL片段：

<!-- 定义SQL片段 -->

<!--

    [sql标签]：定义一个SQL片段

    [id]：SQL片段的唯一标识

    建议：

       1、SQL片段中的内容最好是以单表来定义

       2、如果是查询字段，则不要写上SELECT

       3、如果是条件语句，则不要写上WHERE

 -->

<sql id="select_user_where">
    <if test="user != null">
      <if test="user.username != null and user.username != ''">
         AND username LIKE '%${user.username}%'
      </if>
   </if>
</sql>

 引用sql片段

 使用<include refid=’’ /> 来引用SQL片段：

<!-- 根据用户id来查询用户信息（使用SQL片段） -->
<!-- 
    [include标签]：引用已经定义好的SQL片段
    [refid]：引用的SQL片段id
-->
<select id="findUserList" parameterType="userQueryVO" resultType="userExt">

    SELECT * FROM USER 
<where>
        <include refid="select_user_where"/>
    </where>
</select>
<!-- 综合查询用户信息总数，需要传入查询条件复杂，比如（用户信息、订单信息、商品信息） -->
<select id="findUsersCount" parameterType="QueryUserVO"
        resultType="int">
    SELECT count(1) FROM USER 
    <where>
        <include refid="select_user_where"/>
    </where>
</select>

 

10.3 foreach 标签 

可以循环传入参数值

向sql传递数组或List时，mybatis使用foreach解析数组里的参数并拼接到SQL中。

综合查询时，会根据用户ID集合进行查询

SELECT * FROM USER WHERE id IN (1,2,10)

修改包装pojo

映射文件

<!-- 根据用户ID的集合查询用户列表（学习foreach标签之直接传ID集合） -->

<!--

    [foreach标签]：表示一个foreach循环

    [collection]：集合参数的名称，如果是直接传入集合参数，则该处的参数名称只能填写[list]。

    [item]：定义遍历集合之后的参数名称

    [open]：开始遍历之前需要拼接的SQL串

    [close]：结束遍历之后需要拼接的SQL串

    [separator]：遍历出的每个对象之间需要拼接的字符

 -->

<select id="findUsersByIdList" parameterType="java.util.List" resultType="user">
    SELECT * 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>

 

 

接口

//根据用户ID的集合查询用户列表（学习foreach标签之直接传ID集合）

public List<User> findUsersByIdList (List<Integer> idList);

 测试

 

 

10.4 直接传递list

<!-- 根据用户ID的集合查询用户列表（学习foreach标签之直接传ID集合） -->
<!-- 
	[foreach标签]：表示一个foreach循环
	[collection]：集合参数的名称，如果是直接传入集合参数，则该处的参数名称只能填写[list]。
	[item]：定义遍历集合之后的参数名称
	[open]：开始遍历之前需要拼接的SQL串
	[close]：结束遍历之后需要拼接的SQL串
	[separator]：遍历出的每个对象之间需要拼接的字符
 -->
<select id="findUsersByIdList" parameterType="java.util.List" resultType="user">
	SELECT * 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>

@Test
public void findUsersByIdListTest() {
	// 创建SqlSession
	SqlSession sqlSession = sqlSessionFactory.openSession();
	// 通过SqlSession，获取mapper接口的动态代理对象
	UserMapper userMapper = sqlSession.getMapper(UserMapper.class);

	// 构造List<Integer>集合
	List<Integer> idList = new ArrayList<Integer>();
	idList.add(1);
	idList.add(10);
idList.add(16);

	// 调用mapper对象的方法
	List<User> list = userMapper.findUsersByIdList (idList);
	System.out.println(list);
	// 关闭SqlSession
	sqlSession.close();
}

 

11  mybatis与hibernate的区别及各自应用场景

Mybatis技术特点：

1. 通过直接编写SQL语句，可以直接对SQL进行性能的优化；
2. 学习门槛低，学习成本低。只要有SQL基础，就可以学习mybatis，而且很容易上手；
3. 由于直接编写SQL语句，所以灵活多变，代码维护性更好。
4. 不能支持数据库无关性，即数据库发生变更，要写多套代码进行支持，移植性不好。
5. 需要编写结果映射。

Hibernate技术特点：

1. 标准的orm框架，程序员不需要编写SQL语句。
2. 具有良好的数据库无关性，即数据库发生变化的话，代码无需再次编写。
3. 学习门槛高，需要对数据关系模型有良好的基础，而且在设置OR映射的时候，需要考虑好性能和对象模型的权衡。
4. 程序员不能自主的去进行SQL性能优化。

 

Mybatis应用场景：

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

Hibernate应用场景：

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