Mybatis使用及原理解析

MyBatis 是一个基于Java的持久层框架。它提供的持久层框架包括SQL Maps和Data Access Objects（DAO）。

MyBatis 是支持普通 SQL查询，存储过程和高级映射的优秀持久层框架。MyBatis 消除了几乎所有的JDBC代码和参数的手工设置以及结果集的检索。MyBatis 使用简单的 XML或注解用于配置和原始映射，将接口和 Java 的POJO（Plain Old Java Objects，普通的 Java对象）映射成数据库中的记录

每个MyBatis应用程序主要都是使用SqlSessionFactory实例的，一个SqlSessionFactory实例可以通过SqlSessionFactoryBuilder获得。SqlSessionFactoryBuilder从一个xml配置文件或者一个预定义的配置类的实例获得配置信息。

 

使用：

1准备资源

1.1数据库中建立相应的表

CREATE DATABASE mybatis;
USE mybatis;
CREATE TABLE tb_user(
	id INT PRIMARY KEY AUTO_INCREMENT,
	NAME VARCHAR(16),
	age INT
	);
INSERT INTO tb_user(NAME, age) VALUES('phf1', 12);
INSERT INTO tb_user(NAME, age) VALUES('phf2', 20);
INSERT INTO tb_user(NAME, age) VALUES('phf3', 30);

1.2 jar包

 

2.在eclipse中测试使用

 

2.1导入jar包。

 

 

2..2建一个mybatis-config.xml配置文件

可以在工程的src目录下

<?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">
  <!--  XML 配置文件包含对 MyBatis 系统的核心设置,包含获取数据库连接实例的数据源和 决定事务范围和控制的事务管理器. -->
<configuration>
	<settings>
		 <setting name="cacheEnabled" value="true"/>
  		 <setting name="lazyLoadingEnabled" value="true"/>
	</settings>
	<!-- 给对象取别名  -->
	<typeAliases>
		<typeAlias alias="User" type="org.phf.pojo.User"/>
		<typeAlias alias="Student" type="org.phf.pojo.Student"/>
		<typeAlias alias="Clazz" type="org.phf.pojo.Clazz"/>
	</typeAliases>
	<!-- 配置JDBC连接参数 -->
	<environments default="development">
		<environment id="development">
			<transactionManager type="JDBC"/>
			<dataSource type="POOLED">
				<property name="driver" value="com.mysql.jdbc.Driver"/>
			      <property name="url" value="jdbc:mysql://127.0.0.1:3306/mybatis"/>
			      <property name="username" value="root"/>
			      <property name="password" value="root"/>
			</dataSource>
		</environment>
	</environments>
	<!-- 指明每个关系表的配置文件 -->
	<mappers>
		<mapper resource="org/phf/mapping/UserMapper.xml"/>
		<mapper resource="org/phf/mapping/ClazzMapper.xml"/>
     	 	<mapper resource="org/phf/mapping/StudentMapper.xml"/>
	</mappers>
</configuration>

2.3 为封装SqlSessionFactory建个单例

package org.phf.factory;

import java.io.InputStream;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

public class MybatisFactory {
	/**
	 * SqlSessionFactory对象可以看成DataSource（数据库连接池）
	 * 在应用执行期间，应该只创建一次，建议使用单例模式
	 * 通过SqlSessionFactoryBuilder来获得数据库配置参数并创建 
	 */
	private static SqlSessionFactory sqlSessionFactory;

	/**
	 * SqlSession对象可以理解成对Connection的封装，即一个数据连接会话
	 * 它同时也封装了连接和断开过程，提供sql语句的映射
	 * SqlSession实例不能被共享，它不是线程安全的。
	 * 所以应该一次性用完后要确保使用finally块来关闭它，关闭时会被收回SqlSessionFactory所管理的连接池中
	 */
	//private static SqlSession session;
	static
	{
		try {
			String resource = "mybatis-config.xml";
			InputStream is = Resources.getResourceAsStream(resource);
			sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
			System.out.println(sqlSessionFactory);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	//
	public static SqlSession getSqlSession()
	{
		return sqlSessionFactory.openSession();
	}
	//
	public static void close(SqlSession session)
	{
		if(session != null)
			session.close();
	}
}

 

2.4为每个表建一个映射类

package org.phf.pojo;
/**
 * 数据库表的映射类，每个实例对象映射到表中的一行数据
 * 属性的名称和类型对应表中字段名和类型，并提供getter和setter方法
 * @author Administrator
 */
public class User {
 private Integer id;
 private String name;
 private Integer age;

 public Integer getId() {
  return id;
 }
 public void setId(Integer id) {
  this.id = id;
 }
 public String getName() {
  return name;
 }
 public void setName(String name) {
  this.name = name;
 }
 public Integer getAge() {
  return age;
 }
 public void setAge(Integer age) {
  this.age = age;
 }
 @Override
 public String toString() {
  return "User [id=" + id + ", name=" + name + ", age=" + age + "]\n";
 }

}

2.5建XXXmapper.xml文件和XXXmapper.java接口文件

创建每个表映射类创建的XXXmapper.xml配置文件，并创建相应XXXmapper接口(即数据存取接口),mapper配置文件和接口文件放在同一包目录下

<!-- UserMapper.xml -->
<?xml version="1.0" encoding="gbk"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" 
 "mybatis-3-mapper.dtd">
<!-- MyBatis 真正的力量是在映射语句中。这里是奇迹发生的地方。
对于所有的力量,SQL 映射的 XML 文件是相当的简单。
当然如果你将它们和对等功能的 JDBC 代码来比较,你会 发现映射文件节省了大约 95%的代码量。
MyBatis 的构建就是聚焦于 SQL 的,使其远离于 普通的方式。Mybatis封装处理了连接和查询结果获取 -->
<mapper namespace="org.phf.mapping.UserMapper">

	<!--开启缓存-->
  <cache />  
	<!-- 
	select 查询语句是使用 MyBatis 时最常用的元素之一。
	id（方法）是 get, parameterType(参数类型)是Integer, resultType(返回类型)是 User对象,其属性就是列名,值是列对应的值。
	 -->
  <select id="find" parameterType="Integer" resultType="User">
  	SELECT * FROM TB_USER WHERE ID = #{id}
  </select>
  <!--单条数据返回类型可以是HashMap,key为列名，value为值 -->
  <select id="findMap" parameterType="Integer" resultType="HashMap">
  	SELECT * FROM TB_USER WHERE ID = #{id}
  	</select>

  <!-- 返回多条数据时会自动封装成List集合返回-->
  <select id="findAll" resultType="User">
  	SELECT * FROM TB_USER 
  </select>

    <!-- 最多接受一个参数，所以多个参数可以封装成对象传参,可进行判断处理-->
  <select id="findWithIf" parameterType="User" resultType="User">
  	SELECT * FROM TB_USER 
	<where>
		<if test="name!= null">name = #{name}</if>
		<if test="age!= null">and age = #{age}</if>
	</where>
  </select>
    <!-- 多个键值对参数也可以用map传参，key对应列名-->
  <select id="findByNameAndAge" parameterType="Map" resultType="User">
  	SELECT * FROM TB_USER 
	<where>
		<if test="name!= null">name = #{name}</if>
		<if test="age!= null">and age = #{age}</if>
	</where>
  </select>
    <!-- 多个单值参数也可以用List传参，循环处理-->
  <select id="findWithIn" parameterType="list" resultType="User">
  	SELECT * FROM TB_USER WHERE id IN
	<foreach item="item" index="index" collection="list"
      open="(" separator="," close=")">
        #{item}
 	</foreach>
  </select>
    <!-- 多个单值参数也可以用List传参，循环处理-->
  <select id="findWithLike" parameterType="String" resultType="User">
  	<bind name="pattern" value="'%' + _parameter + '%'" />
  	SELECT * FROM tb_user 
  	WHERE name LIKE #{pattern}
  </select>

</mapper>

//UserMapper.java
package org.phf.mapping;

import java.util.List;
import java.util.Map;

import org.phf.pojo.User;

/**
 * 只要定义接口方法，所需sql语句在相应UserMapper.xml中映射
 */
public interface UserMapper {

	//一条数据可以返回表对象，属性对应列名
	User find(Integer id);
	//一条数据还可以返回Map，key对应列名
	Map findMap(Integer id);
	//多条数据返回List集合
	List<User> findAll();
	//最多接受一个参数，所以多个参数可以封装成对象传参,
	List<User> findWithIf(User user);
	//多个键值对参数也可以用map传参，key对应列名，value对应列值
	List<User> findByNameAndAge(Map<String, Object> map);
	//多个单值参数也可以用List传参,条件中使用IN操作符
	List<User> findWithIn(List<Integer> ids);
	//条件中使用like操作符
	List<User> findWithLike(String name);
}

 

2.6测试代码

package org.phf.test;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.junit.Test;
import org.phf.factory.MybatisFactory;
import org.phf.mapping.UserMapper;
import org.phf.pojo.User;

public class TestUserMapper {

	@Test
	public void test()
	{
		SqlSession session = null;
		try {
			//获取SqlSession的对象(需要手动关闭该资源)
			session = MybatisFactory.getSqlSession();
			//获取业务接口，通过接口类型获取由mybatis生成的匿名实例
			UserMapper userMapper = session.getMapper(UserMapper.class);
			//调用接口方法，执行操作且获得数据

			System.out.println("<---------find by id----------->");
			User user = userMapper.find(1);
			System.out.println(user);

			System.out.println("<---------findMap----------->");
			Map map = userMapper.findMap(2);
			System.out.println(map);

			System.out.println("<---------findAll----------->");
			List<User> userList = userMapper.findAll();
			System.out.println(userList);

			System.out.println("<---------findWithIf----------->");
			user = new User();
			user.setName("phf");
			userList = userMapper.findWithIf(user);
			System.out.println(userList);

			System.out.println("<---------findByNameAndAge----------->");
			Map<String, Object> map1 = new HashMap<String, Object>();
			map1.put("age", 10);
			userList = userMapper.findByNameAndAge(map1);
			System.out.println(userList);

			System.out.println("<---------findWithIn----------->");
			List<Integer> list = new ArrayList<>();
			list.add(1);
			list.add(5);
			list.add(10);
			userList = userMapper.findWithIn(list);
			System.out.println(userList);

			System.out.println("<---------findWithLike----------->");
			String likeName = "ph";
			userList = userMapper.findWithLike(likeName);
			System.out.println(userList);


		} catch (Exception e) {
			e.printStackTrace();
		}
		finally{
			MybatisFactory.close(session);
		}
	}
}

 3.多对一，一对多 关联的处理

3.1数据库建两表

USE mybatis;
CREATE TABLE tb_clazz(
	id INT PRIMARY KEY AUTO_INCREMENT,
	CODE VARCHAR(16)
	);

CREATE TABLE tb_student(
	id INT PRIMARY KEY AUTO_INCREMENT,
	NAME VARCHAR(32),
	sex VARCHAR(2),
	age INT ,
	clazz_id INT,
	CONSTRAINT clazz_fk FOREIGN KEY (clazz_id) REFERENCES  tb_clazz(id)
	);

INSERT INTO tb_clazz(CODE) VALUES('12345');
INSERT INTO tb_clazz(CODE) VALUES('11122');

INSERT INTO tb_student(NAME,sex,age,clazz_id) VALUES('phf1','男',12,1);
INSERT INTO tb_student(NAME,sex,age,clazz_id) VALUES('phf2','男',13,1);
INSERT INTO tb_student(NAME,sex,age,clazz_id) VALUES('phf3','男',25,1);
INSERT INTO tb_student(NAME,sex,age,clazz_id) VALUES('phf4','男',24,2);
INSERT INTO tb_student(NAME,sex,age,clazz_id) VALUES('phf5','女',23,1);
INSERT INTO tb_student(NAME,sex,age,clazz_id) VALUES('phf6','男',26,2);

3.2 表映射类

package org.phf.pojo;

public class Student {
	private Integer id;
	private String name;
	private String sex;
	private Integer age;
	//多对一
	private Clazz clazz;


	public Student() {
		super();
		// TODO Auto-generated constructor stub
	}
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}
	public Clazz getClazz() {
		return clazz;
	}
	public void setClazz(Clazz clazz) {
		this.clazz = clazz;
	}
	@Override
	public String toString() {
		return "Student [id=" + id + ", name=" + name + ", sex=" + sex
				+ ", clazz=" + clazz + "]\n";
	}
}

package org.phf.pojo;

import java.util.List;

public class Clazz {
	private Integer id;
	private String code;
	//一对多
	private List<Student> studentList;

	public Clazz() {
		super();
		// TODO Auto-generated constructor stub
	}
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public String getCode() {
		return code;
	}
	public void setCode(String code) {
		this.code = code;
	}

	public List<Student> getStudentList() {
		return studentList;
	}
	public void setStudentList(List<Student> studentList) {
		this.studentList = studentList;
	}
	@Override
	public String toString() {
		return "Clazz [id=" + id + ", code=" + code + ", studentList=\n"
				+ studentList + "]";
	}
}

3.3 XXXMapper.xml和XXXMapper.java接口文件

package org.phf.mapping;
import org.phf.pojo.Student;
public interface StudentMapper {
	Student find(Integer id);
}

<!--StudentMapper.xml--->
<?xml version="1.0" encoding="gbk"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" 
 "mybatis-3-mapper.dtd">
<mapper namespace="org.phf.mapping.StudentMapper">
	<!--开启缓存-->
  <cache />  
   <!--resultMap标签将column属性(数据库表中的列名) 映射到 property属性(Student对象中的字段)-->
  <resultMap id="clazzResult" type="Clazz">
  	<id column="id" property="id"/>
	<result column="code" property="code"/>
  	</resultMap>

 <resultMap id="studentResult" type="Student">
  	<id column="id" property="id"/>
	<result column="name" property="name"/>
	<result column="sex" property="sex"/>
	<result column="age" property="age"/>
	<!--<association>标签体现的是多对一关联关系,-->
	<association property="clazz" javaType="Clazz" resultMap="clazzResult"/>
  	</resultMap>

  <select id="find" parameterType="Integer" resultMap="studentResult">
  	SELECT * FROM tb_student s,tb_clazz c
	WHERE s.clazz_id=c.id AND s.id = #{id}
  </select>
</mapper>

 

package org.phf.mapping;
import org.phf.pojo.Clazz;
public interface ClazzMapper {
	Clazz find(Integer id);
}

<!---ClazzMapper.xml---->
<?xml version="1.0" encoding="gbk"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" 
 "mybatis-3-mapper.dtd">
<mapper namespace="org.phf.mapping.ClazzMapper">
	<!--开启缓存-->
  <cache />  

	<resultMap id="clazzResult" type="Clazz">
		<id column="id" property="id"/>
		<result column="code" property="code"/>
		<collection property="studentList" ofType="Student" 
			column="id" select="findStudentById"/>
	</resultMap>

	<resultMap id="studentResult" type="Student">
		<association property="clazz" javaType="Clazz" column="class_id" select="find"/>
	</resultMap>

	<select id="findStudentById" parameterType="Integer" resultMap="studentResult">
		select * from tb_student where clazz_id=#{class_id}
	</select>

	<select id="find" parameterType="Integer" resultMap="clazzResult">
		select * from tb_clazz where id=#{id} 
	</select>
</mapper>

3.4 在mybatis-config.xml文件中增加配置

 

	<typeAliases>
		<typeAlias alias="User" type="org.phf.pojo.User" />
		<typeAlias alias="Student" type="org.phf.pojo.Student" />
		<typeAlias alias="Clazz" type="org.phf.pojo.Clazz" />
	</typeAliases>

	<mappers>
		<mapper resource="org/phf/mapping/UserMapper.xml"/>
		<mapper resource="org/phf/mapping/StudentMapper.xml"/>
		<mapper resource="org/phf/mapping/ClazzMapper.xml"/>
	</mappers>

3.5 测试代码增加

	@Test
	public void testMulti()
	{
		SqlSession session = null;
		try {
			session = MybatisFactory.getSqlSession();
			StudentMapper studentMapper = session.getMapper(StudentMapper.class);

			System.out.println("<-----testMulti----Student--find by id------------>");
			Student stu = studentMapper.find(1);
			System.out.println(stu);

			ClazzMapper clazzMapper = session.getMapper(ClazzMapper.class);
			System.out.println("<-----testMulti---Clazz--find by id------------>");
			Clazz clazz = clazzMapper.find(1);
			System.out.println(clazz);

		} catch (Exception e) {
			e.printStackTrace();
		}
		finally{
			MybatisFactory.close(session);
		}
	}