项目中使用 MyBatis（一）

1. 项目中使用 MyBatis（一）

1.1. 作用

简化数据库编程。

当使用了MyBatis后，只需要指定操作数据的接口及抽象方法，例如添加void insert(User user)，然后，配置这个方法对应的SQL语句，即可，无须编写该接口的实现类，更不需要通过JDBC等技术重写该抽象方法。

1.2. 开发步骤

1.2.1. 准备工作

1. 创建数据库student_ums

   CREATE DATABASE student_ums;
   

2. 在数据库中创建数据表t_user，并在其中添加username、password、phone、email、birthday字段，使用自动递增的id作为主键

   CREATE TABLE t_user (
   	id INT AUTO_INCREMENT,
   	username VARCHAR(16) UNIQUE NOT NULL,
   	password VARCHAR(16) NOT NULL,
   	phone VARCHAR(20),
   	email VARCHAR(32),
   	birthday DATETIME,
   	PRIMARY KEY(id)
   ) DEFAULT CHARSET=UTF8;
   

3. 添加不少于5条数据，要求支持中文

   INSERT INTO t_user (
   	username, email, password, phone
   ) VALUES 
   ('root', 'root@163.com', '123456', '13800138002'),
   ('java', 'java@163.com', '123456', '13800138003'),
   ('spring', 'spring@163.com', '123456', '13800138004'),
   ('mysql', 'mysql@163.com', '123456', '13800138005'),
   ('mybatis', 'mybatis@163.com', '123456', '13800138006');
   

4. 查询所有数据

   SELECT 
   	id, username, password, phone, email, birthday 
   FROM 
   	t_user;
   

5. 查询指定用户名的数据

   SELECT 
   	id, username, password, phone, email, birthday 
   FROM 
   	t_user
   WHERE 
   	username='admin';
   

6. 统计数据的数量

   SELECT 
   	COUNT(id) 
   FROM 
   	t_user;
   

7. 删除指定id的数据

   DELETE FROM t_user WHERE id=1;
   

8. 修改指定id的数据的password

   UPDATE t_user SET password='newpassword' WHERE id=1;
   

1.2.2. 创建项目

创建Maven Project，Group Id为com.company.mybatis，Artifact Id为MYBATIS-01-SAMPLE，Packaging选择war，后续步骤与前序项目一致。

前序项目中的依赖、web.xml的配置、Spring的配置、Tomcat运行环境，对于单一使用MyBatis而言，都是可以不需要的。

添加MyBatis的依赖：

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

MyBatis框架是可以独立使用的，但是，配置方式相对比较麻烦，通常会结合Spring一起使用，所以，还需要添加MyBatis与Spring整合使用的依赖：

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

由于MyBatis底层通过JDBC技术来实现，整合了Spring之后，还需要Spring-JDBC的支持，所以，添加：

<!-- Spring-JDBC -->
<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-jdbc</artifactId>
	<version>3.2.8.RELEASE</version>
</dependency>

注意：在同一个项目中使用的所有以 spring- 作为前缀的依赖，应该使用相同的版本！

1.2.3. 设定目标

使用昨天作业的数据库与数据表，向t_user表中插入1条数据。

1.2.4. 创建接口并设计抽象方法

由于需要操作的是用户数据，则应该创建与数据表完全匹配的实体类，即创建com.company.mybatis.entity.User类，类中的属性与数据表保持一致。

创建com.company.mybatis.mapper.UserMapper接口，并在接口中添加抽象方法：

Integer reg(User user);

由于MyBatis框架在执行INSERT、DELETE、UPDATE语句时，默认返回受影响的行数，所以，在设计抽象方法时，只要对应的SQL语句是增、删、改，方法的返回值就设计为Integer，且值的意义一定是受影响的行数！

1.2.5. 配置抽象方法对应的SQL语句

在srcmain esources下创建mappers文件夹（因为一个完整的项目中，可能需要多个关于MyBatis配置SQL语句的文件，为了便于管理，所以创建专门的文件夹），然后，将昨天下载的SomeMapper.zip解压，并将得到的SomeMapper.xml重命名为UserMapper.xml，复制到刚才的mappers文件夹下。

关于UserMapper.xml文件，一般称之为配置映射的文件，根节点是<mapper>，必须配置namespace属性，取值为该XML文件匹配的JAVA接口文件的名称：

<!-- namespace：与当前XML文件对应的Java接口 -->
<mapper namespace="com.company.mybatis.mapper.UserMapper">

</mapper>

关于数据操作，在<mapper>节点中，根据操作类型，可以选择<insert>、<delete>、<update>、<select>，此次，应该选择<insert>节点，该节点的id属性值是对应的抽象方法的名称，然后，手动添加parameterType属性，用于配置方法的参数类型，取值则是User的全名：

<!-- id：该节点对应的抽象方法的名称 -->
<!-- parameterType：对应的抽象方法的参数的数据类型 -->
<insert id="reg"
	parameterType="com.company.mybatis.entity.User">
</insert>

然后，将需要执行的SQL语句写在节点内部，值部分使用#{}且内部是参数User类的属性名称即可：

<insert id="reg"
	parameterType="com.company.mybatis.entity.User">
	INSERT INTO t_user (
		username, email, 
		password, phone, birthday
	) VALUES (
		#{username}, #{email}, 
		#{password}, #{phone}, #{birthday}
	)
</insert>

1.2.6. 相关配置

首先，需要配置数据库连接相关参数，即：在srcmain esources下创建db.properties文件：

url=jdbc:mysql://localhost:3306/student_ums?useUnicode=true&characterEncoding=utf8
driver=com.mysql.jdbc.Driver
username=root
password=root
initialSize=5
maxActive=50

由于需要使用到MySQL的连接jar包与数据库连接池的dbcp包，所以，还应该添加依赖：

<!-- MySQL -->
<dependency>
	<groupId>mysql</groupId>
	<artifactId>mysql-connector-java</artifactId>
	<version>5.1.6</version>
</dependency>

<!-- DBCP -->
<dependency>
	<groupId>commons-dbcp</groupId>
	<artifactId>commons-dbcp</artifactId>
	<version>1.4</version>
</dependency>

接下来，需要通过Spring读取以上db.properties文件，将其配置的值应用于数据库的连接数据源（BasicDataSource），由于这些配置都是和持久层操作相关的，所以，将springmvc.xml重命名为spring-mvc.xml，然后复制spring-mvc.xml文件，并粘贴为spring-dao.xml，在新的spring-dao.xml中删除原有配置，并添加新的配置：

<!-- 读取db.properties -->
<util:properties id="dbConfig"
	location="classpath:db.properties" />
	
<!-- 配置数据源：BasicDataSource -->
<bean id="dataSource" 
	class="org.apache.commons.dbcp.BasicDataSource">
	<!-- 以下配置中 -->
	<!-- name的值是BasicDataSource中的属性名(方法名) -->
	<!-- value的值是引用以上读取的配置文件 -->
	<property name="url" 
		value="#{dbConfig.url}" />
	<property name="driverClassName" 
		value="#{dbConfig.driver}" />
	<property name="username" 
		value="#{dbConfig.username}" />
	<property name="password" 
		value="#{dbConfig.password}" />
	<property name="initialSize" 
		value="#{dbConfig.initialSize}" />
	<property name="maxActive" 
		value="#{dbConfig.maxActive}" />
</bean>

可以创建测试类，来检验以上配置是否正确：

public class TestDataSource {

	public static void main(String[] args) 
			throws SQLException {
		// 加载Spring配置，获取Spring容器
		AbstractApplicationContext ac
			= new ClassPathXmlApplicationContext(
				"spring-dao.xml");
		
		// 从Spring容器中获取对象
		BasicDataSource ds 
			= ac.getBean("dataSource", 
					BasicDataSource.class);
		
		// 测试
		java.sql.Connection conn = ds.getConnection();
		System.out.println(conn);

		// 释放资源
		ac.close();
	}

}

由于MyBatis相关的配置已经交给Spring进行管理，后续，在运行时，还需要使得整个环境知道：所使用的数据源、MyBatis的接口文件的位置、MyBatis的映射文件的位置，则继续在spring-dao.xml添加配置：

<!-- 配置MapperScannerConfigurer -->
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
	<!-- 配置接口文件所在的包 -->
	<property name="basePackage"
		value="com.company.mybatis.mapper" />
</bean>

<!-- 配置SqlSessionFactoryBean -->
<bean class="org.mybatis.spring.SqlSessionFactoryBean">
	<!-- 配置使用哪个数据源，ref属性的值是前序配置的数据源的bean id -->
	<property name="dataSource" 
		ref="dataSource" />
	<!-- 配置XML映射文件的位置 -->
	<property name="mapperLocations"
		value="classpath:mappers/*.xml" />
</bean>

至此，配置已经全部结束！

1.2.7. 执行单元测试

在src estjava下创建TestUserMapper类，编写测试方法：

@Test
public void reg() {
	// 加载Spring的配置文件，获取Spring容器
	AbstractApplicationContext ac
		= new ClassPathXmlApplicationContext(
			"spring-dao.xml");
	
	// 获取所需的对象：MyBatis接口的对象
	UserMapper userMapper 
		= ac.getBean("userMapper", UserMapper.class);
	
	// 测试执行
	User user = new User();
	user.setUsername("html");
	user.setPassword("888888");
	Integer rows = userMapper.reg(user);
	System.out.println("rows=" + rows);
	
	// 释放资源
	ac.close();
}

之所以将测试类放在这个位置，是因为最终部署项目时，在test下的内容将不会被部署！不影响项目的实际开发！

1.3. 通过MyBatis执行查询所有数据

1.3.1. 设定目标

查询出当前t_user表中所有的数据

1.3.2. 设计抽象方法

在UserMapper.java接口添加新的抽象方法：

List<User> getList();

1.3.3. 配置映射SQL

在UserMapper.xml文件中添加配置：

<select id="getList"
	resultType="com.company.mybatis.entity.User">
	SELECT 
		id, username, password, phone, email, birthday
	FROM
		t_user
</select>

在MyBatis中，执行的查询，必须在<select>节点上配置resultType属性！（也可以配置resultMap，二选一）

在MyBatis中，所有的查询默认返回List集合，所以，在指定resultType时，取值为List集合中存放的数据类型！

1.4. 通过MyBatis指定条件查询

1.4.1. 设定目标

根据用户名，查询某个用户的信息

1.4.2. 设计抽象方法

在UserMapper.java接口添加新的抽象方法：

User getUserByUsername(String username);

在查询时，如果查询的结果定义为某种具体的数据类型，而不是List集合，则MyBatis会对查询到的List集合做进一步的处理（MyBatis的查询结果一定是List集合），尝试取出List集合中的第1个数据，如果集合中没有数据，则返回null。

1.4.3. 配置映射SQL

在UserMapper.xml文件中添加配置：

<select id="getUserByUsername"
	resultType="com.company.mybatis.entity.User">
	SELECT 
		id, username, password, phone, email, birthday
	FROM
		t_user
	WHERE
		username=#{username}
</select>

如果查询的SQL映射对应的方法只有1个参数，则不需要配置parameterType属性！

1.5. 统计数据的数量

1.5.1. 设定目标

统计当前t_user表中数据的数量

1.5.2. 设计抽象方法

在UserMapper.java接口添加新的抽象方法：

Integer getCount();

1.5.3. 配置映射SQL

在UserMapper.xml文件中添加配置：

<select id="getCount" resultType="java.lang.Integer">
	SELECT COUNT(id) FROM t_user
</select>

即使查询结果是Integer这种非常常见的数据类型，也必须配置resultType！

1.6. 删除指定id的数据

1.6.1. 设定目标

根据id删除t_user表中对应的数据

1.6.2. 设计抽象方法

在UserMapper.java接口添加新的抽象方法：

Integer deleteUserById(Integer id);

1.6.3. 配置映射SQL

在UserMapper.xml文件中添加配置：

<delete id="deleteUserById">
	DELETE FROM t_user WHERE id=#{id}
</delete>

1.7. 修改指定id的数据的password

1.7.1. 设定目标

修改密码

1.7.2. 设计抽象方法

在UserMapper.java接口添加新的抽象方法：

Integer changePassword(
		@Param("id") Integer id, 
		@Param("password") String password);

在使用MyBatis处理持久层的数据操作时（无论是增、删、改、查中的哪一种），只要方法的参数超过1个（2个或更多），则每个参数之前必须使用@Param()注解，并且，在注解中定义参数的名称，后续，在配置SQL语句时，使用#{}语法时填写的名称也就是此时注解中使用的名称！

1.7.3. 配置映射SQL

在UserMapper.xml文件中添加配置：

<update id="changePassword">
	UPDATE 
		t_user 
	SET 
		password=#{password}
	WHERE 
		id=#{id}
</update>

1.8. MyBatis基本使用的小结

• MyBatis的作用：简化持久层开发，无须编写JDBC相关代码；

• 每个功能都需要有抽象方法，及匹配的SQL映射；

• 如果抽象方法的参数超过1个，必须使用@Param注解；

• 如果执行增、删、改，抽象方法的返回值可以是Integer，表示受影响的行数，当然，如果不关心这个返回值，也可以将返回值设计为void；

• 如果执行查询操作，抽象方法的返回值可以是List或匹配的实体类的类型，甚至是其它例如Integer类型，可根据需要自行设计；其实，每次查询返回的都是List，只不过，如果设计的返回值是实体类的类型，则MyBatis会尝试从List中取出第1个数据，如果取出失败，则返回null；

• 配置SQL映射时，应该根据执行的SQL语句的种类来选择节点；

• 每个节点上都必须配置id属性，表示匹配的抽象方法的名称；

• 所有<select>节点必须配置resultType；