1、mybatis的两种CRUD

1.mybatis概述

1.1、mybatis简介

MyBatis是支持定制化SQL、存储过程以及高级映射的优秀的持久层框架。
MyBatis避免了几乎所有的JDBC代码和手动设置参数以及获取结果集。
MyBatis可以使用简单的XML或注解用于配置和原始映射，将接口和java的POJO映射成数据库中的记录。

1.2、mybatis历史

原是Apache的一个开源项目ibatis，2010年6月这个项目由apache software foundation 迁移到了Google code，随着开发团队转投Google Code旗下，ibatis3.x正式更名为Mybatis，代码于2013年11月迁移到GitHub，ibatis一词源于internet和abatis的组合，是一个基于java的持久层框架，ibatis提供的持久层框架包括SQL Maps和Data Access Objects(DAO).

1.3、为什么要使用mybatis

Mybatis是一个半自动化的持久层框架。
jdbc编程–当我们使用jdbc持久化的时候，sql语句被硬编码到java代码中，这样耦合度太高，代码不易于维护，在实际项目开发中会经常添加sql或者修改sql，这样我们就只能到java代码中去修改。

Hibernate和JPA
长难复杂SQL，对于Hibernate而言处理也不容易。
内部自动生产的SQL，不容易做特殊优化。
基于全映射的全自动化框架，javaBean存在大量字段时无法只映射部分字段，导致数据库性能下降。

对于开发人员而言，核心sql还是需要自己优化。java和sql编码分开，功能边界清晰，一个专注业务一个专注数据。
可以使用简单的xml或注解用于配置和原始映射，将接口和java的pjpo映射成数据库中的记录，成为业务代码+底层数据库的媒介。

2.mybatis的Hello示例程序

2.1、创建一个数据库和一个单表

mysql> drop database if exists mybatis;
Query OK, 0 rows affected

mysql> create database mybatis;
Query OK, 1 row affected

mysql> use mybatis;
Database changed

mysql> create table person(
    -> id int primary key auto_increment,
    -> name varchar(50),
    -> age int
    -> );
Query OK, 0 rows affected

mysql> insert into person values(null,'ccc',11);
Query OK, 1 row affected

mysql> select * from person where id = 1;
+----+------+-----+
| id | name | age |
+----+------+-----+
|  1 | ccc  |  11 |
+----+------+-----+
1 row in set

2.2、MyBatis-Statement方式的增删改查

导入mybatis的jar包和mysql驱动
config.xml:配置数据库信息和需要加载的映射文件
表 – 类：映射文件xxMapper.xml ：增删改查标签<select>

//person类
public class Person {
	private int id;
	private String name;
	private int age;
	public Person() {
	}
	public Person(int id, String name, int age) {
		this.id = id;
		this.name = name;
		this.age = age;
	}
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	@Override
	public String toString() {
		return this.id+"-"+this.name+"-"+this.age;
	}
}

//config.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>
	<!-- default和id值相同时才能连接成功，测试类中也可以修改默认值 -->
	<environments default="development">
		<!-- 开发环境(自己的计算机) -->
		<environment id="development">
			<!-- 事务提交方式： 
			  JDBC：利用JDBC方式处理事务(手工) 
			  MANAGED：将事务交由其他组件去托管(spring,jobss)默认会关闭连接
			 -->
			<transactionManager type="JDBC" />
			<!-- 取消MANAGED的默认关闭连接 -->
			<!-- <property name="closeConnection" value="false" /> -->
			
			<!-- 数据源类型：
			  POOLED：使用数据库连接池(三方)
			  UNPOOLED：传统的JDBC模式，每次访问数据库，均需要打开、关闭等数据库操作，比较消耗性能 
			  JNDI：从tomcat中获取一个内置的数据库连接池
			   -->
			<dataSource type="POOLED">
				<!-- 配置数据库信息 -->
				<property name="driver" value="com.mysql.jdbc.Driver" />
				<property name="url"
					value="jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf8" />
				<property name="username" value="root" />
				<property name="password" value="123456" />
			</dataSource>
		</environment>

		<!-- 真正的项目应该在 发布的那台计算机上运行 -->
		<environment id="shishi">
			<!-- 数据库事务处理 -->
			<transactionManager type="JDBC" />
			<!-- 配置数据库信息 -->
			<dataSource type="POOLED">
				<property name="driver" value="com.mysql.jdbc.Driver" />
				<property name="url"
					value="jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf8" />
				<property name="username" value="root" />
				<property name="password" value="123456" />
			</dataSource>
		</environment>

	</environments>
	<mappers>
		<!-- 加载映射文件 -->
		<mapper resource="org/lanqiao/entity/personMapper.xml" />
	</mappers>
</configuration>

//personMapper.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">
  
<!-- namespace:该mapper.xml映射文件的唯一标识 -->
<mapper namespace="org.lanqiao.entity.PersonMapper">
    <!-- 后续通过namespace+"."+id唯一定位sql语句 -->
    <!-- 
         parameterType:输入参数的类型
         resultType:查询结果的返回值类型
         resultType值如果没有别名需要写全包名+"."+类名
         parameterType和resultType在形式上都只能有一个,但多个参数可以使用对象和集合来代替
         parameterType和resultType如果是简单类型(8个基本类型和String),可以使用任何占位符:#{xxx};如果是对象类型,则必须是对象的属性:#{属性名}
         resultType如果是一个对象,查询结果无论是一个还是多个,resultType都写对象：org.lanqiao.entity.Person
     -->
	<select id="queryPersonById" resultType="org.lanqiao.entity.Person" parameterType="int">
		select * from Person where id = #{id}
	</select>
	<insert id="addPerson" parameterType="org.lanqiao.entity.Person">
	    insert into person values(#{id},#{name},#{age})
	</insert>
	<update id="updatePersonById" parameterType="org.lanqiao.entity.Person">
	    update person set id=#{id},name=#{name},age=#{age} where id= #{id}
	</update>
	<delete id="deletePersonById" parameterType="int">
	    delete from person where id= #{id}
	</delete>
	<select id="queryAllPerson" resultType="org.lanqiao.entity.Person">
		select * from Person
	</select>
</mapper>

//TestMybatis类
import java.io.IOException;
import java.io.Reader;
import java.util.List;
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 TestMybatis {	
	public static void main(String[] args) throws IOException {
		//加载Mybatis配置文件(为了访问数据库)
		Reader reader = Resources.getResourceAsReader("config.xml");
		//可以在build中修改config.xml中developments的默认值
		SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(reader,"shishi");
		//session - connection
		SqlSession session = sessionFactory.openSession();
		//参数statement是personMapper.xml中的namespace+"."+id,参数parameter在这里是id值：1
		//只有personMapper.xml中resultType的值为Person，才能赋给Person对象
		Person person = session.selectOne("org.lanqiao.entity.PersonMapper.queryPersonById",2);
		System.out.println("查询id为2的对象:"+person);
		
		List<Person> persons1=session.selectList("org.lanqiao.entity.PersonMapper.queryAllPerson");
		System.out.println("查询所有对象:"+persons1);
		
		session.delete("org.lanqiao.entity.PersonMapper.deletePersonById",1);
		List<Person> persons2=session.selectList("org.lanqiao.entity.PersonMapper.queryAllPerson");
		System.out.println("查询删除id为1的对象后的所有对象:"+persons2);
		
		session.insert("org.lanqiao.entity.PersonMapper.addPerson",new Person(1,"czw",11));
		List<Person> persons3=session.selectList("org.lanqiao.entity.PersonMapper.queryAllPerson");
		System.out.println("查询增加id为1的对象后的所有对象:"+persons3);
		
		session.insert("org.lanqiao.entity.PersonMapper.updatePersonById",new Person(1,"czw",13));
		List<Person> persons4=session.selectList("org.lanqiao.entity.PersonMapper.queryAllPerson");
		System.out.println("查询修改id为1的对象后的所有对象:"+persons4);
		//关闭连接
		session.close();
	}
}

2.3、mapper动态代理方式的增删改查(MyBatis接口开发)

增删改查也称CRUD

原则：约定优于配置

硬编码方法：xxx.java中
Configuration conf=new Configuration();
conf.setName(“myProject”);

配置方式(优于硬编码)：xxx.xml中<name>myProject</name>

约定：默认值就是myProject，后面可通过配置或硬编码修改

具体实现步骤：
1.基础环境：mybatis.jar、mysql.jar、config.xml、mapper.xml
2.不同之处
约定的目标：省略掉statement，即根据约定直接可以定位出SQL语句
a、接口，接口中的方法必须遵循以下约定：
1、方法名和mapper.xml文件中标签的id相同
2、方法的输入参数和mapper.xml文件中标签的parameterType一致
3、方法的返回值和mapper.xml文件中标签的resultType一致

除了以上约定，要实现接口中的方法和Mapper.xml中SQL标签一一对应，还需要以下一点：
namespace的值就是接口的全类名

匹配的过程：(约定的过程)
1.根据接口名找到mapper.xml文件(根据的是namespace=接口全类名)
2.根据接口的方法名找到mapper.xml文件中的sql标签(方法名=sql标签Id值)
以上两点可以保证：当我们调用接口中的方法时，程序能自动定位到某一个mapper.xml文件中的SQL标签。

习惯：SQL映射文件(mapper.xml)和接口放在同一个包中。

//config.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>
	<!-- default和id值相同时才能连接成功，测试类中也可以修改默认值 -->
	<environments default="development">
		<!-- 开发环境(自己的计算机) -->
		<environment id="development">
			<!-- 事务提交方式： 
			  JDBC：利用JDBC方式处理事务(手工) 
			  MANAGED：将事务交由其他组件去托管(spring,jobss)默认会关闭连接
			 -->
			<transactionManager type="JDBC" />
			<!-- 取消MANAGED的默认关闭连接 -->
			<!-- <property name="closeConnection" value="false" /> -->
			
			<!-- 数据源类型：
			  POOLED：使用数据库连接池(三方)
			  UNPOOLED：传统的JDBC模式，每次访问数据库，均需要打开、关闭等数据库操作，比较消耗性能 
			  JNDI：从tomcat中获取一个内置的数据库连接池
			   -->
			<dataSource type="POOLED">
				<!-- 配置数据库信息 -->
				<property name="driver" value="com.mysql.jdbc.Driver" />
				<property name="url"
					value="jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf8" />
				<property name="username" value="root" />
				<property name="password" value="123456" />
			</dataSource>
		</environment>

		<!-- 真正的项目应该在 发布的那台计算机上运行 -->
		<environment id="shishi">
			<!-- 数据库事务处理 -->
			<transactionManager type="JDBC" />
			<!-- 配置数据库信息 -->
			<dataSource type="POOLED">
				<property name="driver" value="com.mysql.jdbc.Driver" />
				<property name="url"
					value="jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf8" />
				<property name="username" value="root" />
				<property name="password" value="123456" />
			</dataSource>
		</environment>

	</environments>
	<mappers>
		<!-- 加载映射文件 -->
		<mapper resource="org/lanqiao/mapper/personMapper.xml" />
	</mappers>
</configuration>

//personMapper.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">
  
<!-- namespace:该mapper.xml映射文件的唯一标识 -->
<mapper namespace="org.lanqiao.mapper.PersonMapper">
    <!-- 后续通过namespace+"."+id唯一定位sql语句 -->
    <!-- 
         parameterType:输入参数的类型
         resultType:查询结果的返回值类型
         resultType值如果没有别名需要写全包名+"."+类名
         parameterType和resultType在形式上都只能有一个,但多个参数可以使用对象和集合来代替
         parameterType和resultType如果是简单类型(8个基本类型和String),可以使用任何占位符:#{xxx};如果是对象类型,则必须是对象的属性:#{属性名}
         resultType如果是一个对象,查询结果无论是一个还是多个,resultType都写对象：org.lanqiao.entity.Person
     -->
	<select id="queryPersonById" resultType="org.lanqiao.entity.Person" parameterType="int">
		select * from Person where id = #{id}
	</select>
	<insert id="addPerson" parameterType="org.lanqiao.entity.Person">
	    insert into person values(#{id},#{name},#{age})
	</insert>
	<update id="updatePersonById" parameterType="org.lanqiao.entity.Person">
	    update person set id=#{id},name=#{name},age=#{age} where id= #{id}
	</update>
	<delete id="deletePersonById" parameterType="int">
	    delete from person where id= #{id}
	</delete>
	<select id="queryAllPerson" resultType="org.lanqiao.entity.Person">
		select * from Person
	</select>
</mapper>

//Person类
public class Person {
	private int id;
	private String name;
	private int age;
	public Person() {
	}
	public Person(int id, String name, int age) {
		this.id = id;
		this.name = name;
		this.age = age;
	}
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	@Override
	public String toString() {
		return this.id+"-"+this.name+"-"+this.age;
	}
}

//PersonMapper接口
import java.util.List;
import org.lanqiao.entity.Person;
//操作mybatis的接口
public interface PersonMapper {
	/* 1、方法名和mapper.xml文件中标签的id相同
	 * 2、方法的输入参数和mapper.xml文件中标签的parameterType一致
	 * 3、方法的返回值和mapper.xml文件中标签的resultType一致
	 * 4、接口里的方法默认public abstract，所以可以省略 
	 */
	Person queryPersonById(int id);
	List<Person> queryAllPerson();
	void addPerson(Person person);
	void deletePersonById(int id);
	void updatePersonById(Person person);
}

//测试类
import java.io.IOException;
import java.io.Reader;
import java.util.List;
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.lanqiao.entity.Person;
import org.lanqiao.mapper.PersonMapper;

public class TestMybatis {	
	public static void queryPersonById(int id) throws IOException {
		//加载Mybatis配置文件(为了访问数据库)
		Reader reader = Resources.getResourceAsReader("config.xml");
		//可以在build中修改config.xml中developments的默认值
		SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(reader,"shishi");
		//session - connection
		SqlSession session = sessionFactory.openSession();
		PersonMapper personMapper=session.getMapper(PersonMapper.class);
		//接口中的方法--》SQL语句
		Person person=personMapper.queryPersonById(id);
		System.out.println(person);
		session.close();
	}
	public static void queryAllPerson() throws IOException {
		//加载Mybatis配置文件(为了访问数据库)
		Reader reader = Resources.getResourceAsReader("config.xml");
		//可以在build中修改config.xml中developments的默认值
		SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(reader,"shishi");
		//session - connection
		SqlSession session = sessionFactory.openSession();
		PersonMapper personMapper=session.getMapper(PersonMapper.class);
		//接口中的方法--》SQL语句
		List<Person> persons=personMapper.queryAllPerson();
		System.out.println(persons);
		session.close();
	}
	public static void addPerson(Person person) throws IOException {
		//加载Mybatis配置文件(为了访问数据库)
		Reader reader = Resources.getResourceAsReader("config.xml");
		//可以在build中修改config.xml中developments的默认值
		SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(reader,"shishi");
		//session - connection
		SqlSession session = sessionFactory.openSession();
		PersonMapper personMapper=session.getMapper(PersonMapper.class);
		//接口中的方法--》SQL语句
		personMapper.addPerson(person);
		//提交事务，不然数据进不去数据库中,增删改  
		session.commit();
		session.close();
	}
	public static void deletePersonById(int id) throws IOException {
		//加载Mybatis配置文件(为了访问数据库)
		Reader reader = Resources.getResourceAsReader("config.xml");
		//可以在build中修改config.xml中developments的默认值
		SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(reader,"shishi");
		//session - connection
		SqlSession session = sessionFactory.openSession();
		PersonMapper personMapper=session.getMapper(PersonMapper.class);
		//接口中的方法--》SQL语句
		personMapper.deletePersonById(id);
		//提交事务，不然数据进不去数据库中,增删改
		session.commit();
		session.close();
	}
	public static void updatePersonById(Person person) throws IOException {
		//加载Mybatis配置文件(为了访问数据库)
		Reader reader = Resources.getResourceAsReader("config.xml");
		//可以在build中修改config.xml中developments的默认值
		SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(reader,"shishi");
		//session - connection
		SqlSession session = sessionFactory.openSession();
		PersonMapper personMapper=session.getMapper(PersonMapper.class);
		//接口中的方法--》SQL语句
		personMapper.updatePersonById(person);
		//提交事务，不然数据进不去数据库中,增删改
		session.commit();
		session.close();
	}
	public static void main(String[] args) throws IOException {
		queryPersonById(1);
		deletePersonById(1);
		queryAllPerson();
		addPerson(new Person(1,"ccc",11));
		queryAllPerson();
		updatePersonById(new Person(1,"ccc",12));
		queryAllPerson();
	}
}

优化

1.可以将配置信息单独放入xx.properties文件中，然后再动态引入xx.properties：k=v

//xx.properties
driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf8
username=root
password=123456

//config.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>
    
    <properties resource="db.properties" />
     
    <!-- 
    <settings>
       <setting name="cacheEnabled" value="false"/>
       <setting name="lazyLoadingEnabled" value="false"/>
    </settings>
     -->
    
    <!-- 设置单个/多个别名(别名忽略大小写) -->
    <typeAliases>
       <!-- 设置单个别名 -->
       <!-- <typeAlias type="org.lanqiao.entity.Person" alias="Person"/> -->
       <!-- 批量设置别名,以下会自动将该包中的所有类批量定义别名：别名就是类名 -->
       <package name="org.lanqiao.entity"/>
    </typeAliases>
    
	<!-- default和id值相同时才能连接成功，测试类中也可以修改默认值 -->
	<environments default="development">
		<!-- 开发环境(自己的计算机) -->
		<environment id="development">
			<!-- 事务提交方式： 
			  JDBC：利用JDBC方式处理事务(手工) 
			  MANAGED：将事务交由其他组件去托管(spring,jobss)默认会关闭连接
			 -->
			<transactionManager type="JDBC" />
			<!-- 取消MANAGED的默认关闭连接 -->
			<!-- <property name="closeConnection" value="false" /> -->
			
			<!-- 数据源类型：
			  POOLED：使用数据库连接池(三方)
			  UNPOOLED：传统的JDBC模式，每次访问数据库，均需要打开、关闭等数据库操作，比较消耗性能 
			  JNDI：从tomcat中获取一个内置的数据库连接池
			   -->
			<dataSource type="POOLED">
				<!-- 配置数据库信息 -->
				<property name="driver" value="${driver}" />
				<property name="url" value="${url}" />
				<property name="username" value="${username}" />
				<property name="password" value="${password}" />
			</dataSource>
		</environment>

		<!-- 真正的项目应该在 发布的那台计算机上运行 -->
		<environment id="shishi">
			<!-- 数据库事务处理 -->
			<transactionManager type="JDBC" />
			<!-- 配置数据库信息 -->
			<dataSource type="POOLED">
				<property name="driver" value="${driver}" />
				<property name="url" value="${url}" />
				<property name="username" value="${username}" />
				<property name="password" value="${password}" />
			</dataSource>
		</environment>

	</environments>
	<mappers>
		<!-- 加载映射文件 -->
		<mapper resource="org/lanqiao/mapper/personMapper.xml" />
	</mappers>
</configuration>

2.mybatis全局参数
在config.xml中设置

<settings>
   <setting name="cacheEnabled" value="false"/>
   <setting name="lazyLoadingEnabled" value="false"/>
</settings>

3.别名 config.xml
a.设置单个别名
b.批量设置别名

<!-- 设置单个/多个别名(别名忽略大小写) -->
<typeAliases>
   <!-- 设置单个别名 -->
   <!-- <typeAlias type="org.lanqiao.entity.Person" alias="Person"/> -->
   <!-- 批量设置别名,以下会自动将该包中的所有类批量定义别名：别名就是类名 -->
   <package name="org.lanqiao.entity"/>
</typeAliases>

除了自定义别名外，Mybatis还内置了一些常见类的别名