MyBatis 学习（一）

一、MyBatis

1、MyBatis 介绍（百度）

　　MyBatis 是一款优秀的持久层框架，它支持定制化 SQL、存储过程以及高级映射。MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。MyBatis 可以使用简单的 XML 或注解来配置和映射原生信息，将接口和 Java 的 POJOs(Plain Old Java Objects,普通的 Java对象)映射成数据库中的记录。

2、MyBatis 历史（百度）

　　MyBatis前世今生：MyBatis 本是apache的一个开源项目iBatis, 2010年这个项目由apache software foundation 迁移到了google code，并且改名为MyBatis ,2013年11月迁移到Github。

　　iBATIS一词来源于“internet”和“abatis”的组合，是一个基于Java的持久层框架。iBATIS提供的持久层框架包括SQL Maps和Data Access Objects（DAOs)。

3、MyBatis的优势：

1、MyBatis 是支持普通 SQL查询，存储过程和高级映射的优秀持久层框架。

2、MyBatis 消除了几乎所有的JDBC代码和参数的手工设置以及结果集的检索。

3、MyBatis 使用简单的XML或注解用于配置和映射，将接口和 Java 的POJOs（Plain Old Java Objects，普通的Java对象）映射成数据库中的记录。

二、ORM

1、ORM介绍

　　对象关系映射（Object Relational Mapping，简称ORM/OR Mapping）：是一种为了解决面向对象与关系数据库存在的互不匹配的现象的技术。 简单的说，ORM是通过使用描述对象和数据库之间映射的元数据，将java程序中的对象自动持久化到关系数据库中。避免直接使用SQL语句对关系型数据库中的数据进行操作。减少代码编写量,提高产品质量。

2、ORM 主要解决对象-关系的映射

　　面向对象概念    面向关系概念
　　类                表
　　对象            表的行（记录）
　　属性            表的列（字段）

3、ORM 的实现思想

　　将关系数据库中表中的记录映射成为对象，以对象的形式展现，程序员可以把对数据库的操作转化为对对象的操作。因此ORM的目的是为了方便开发人员以面向对象的思想来实现对数据库的操作。

　　ORM 采用元数据来描述对象-关系映射细节：元数据通常采用 XML 格式，并且存放在专门的对象-关系映射文件中。

4、目前流行的ORM框架

1、JPA：本身是一种ORM规范，不是ORM框架，由各大ORM框架提供实现。

2、Hibernate：目前最流行的ORM框架，设计灵巧，性能优秀，文档丰富。

3、MyBatis：本是apache的一个开源项目iBatis，提供的持久层框架包括SQL Maps和DAO，允许开发人员直接编写SQL。

三、MyBatis 完成 CRUD（增删改查）

1、使用框架第一步：拷贝jar包

　　a：MySQL驱动：mysql-connector-java-5.1.22-bin.jar   

　　b：MyBatis的核心jar：mybatis-3.2.1.jar

　　c：MyBatis的依赖jar：MyBatis目录\lib中所有jar   

2、MyBatis的主配置文件：

　　MyBatis-config.xml

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <!DOCTYPE configuration
 3         PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
 4         "http://mybatis.org/dtd/mybatis-3-config.dtd">
 5 <configuration>
 6     <!--配置别名-->
 7     <typeAliases>
 8     <package name="com.mybatis.pojo"/>
 9     </typeAliases>
10     <environments default="development">
11         <environment id="development">
12             <!--事务管理:JDBC的事务管理机制-->
13             <transactionManager type="JDBC"/>
14             <!--配置链接池:数据源-->
15             <dataSource type="POOLED">
16                 <property name="driver" value="com.mysql.jdbc.Driver"/>
17                 <property name="url" value="jdbc:mysql://localhost:3306/how2java?characterEncoding=UTF-8"/>
18                 <property name="username" value="root"/>
19                 <property name="password" value="admin"/>
20             </dataSource>
21         </environment>
22     </environments>
23     <!--关系映射文件-->
24     <mappers>
25         <mapper resource="com/mybatis/pojo/Product.xml"/>
26     </mappers>
27 </configuration>

3、映射文件(写sql语句的文件)

Product 类：

 1 package com.mybatis.pojo;
 2 
 3 public class Product {
 4     private Integer id;
 5     private String name;
 6     private float price;
 7 
 8     public Integer getId() {
 9         return id;
10     }
11 
12     public void setId(Integer id) {
13         this.id = id;
14     }
15 
16     public String getName() {
17         return name;
18     }
19 
20     public void setName(String name) {
21         this.name = name;
22     }
23 
24     public float getPrice() {
25         return price;
26     }
27 
28     public void setPrice(float price) {
29         this.price = price;
30     }
31 
32     @Override
33     public String toString() {
34         return "Product{" +
35                 "id=" + id +
36                 ", name='" + name + '\'' +
37                 ", price=" + price +
38                 '}';
39     }
40 }

mapper接口：

 1 import com.mybatis.pojo.Product;
 2 
 3 import java.util.List;
 4 
 5 public interface ProductMapper {
 6 
 7     /**
 8      * 添加产品
 9      * @param product
10      * @return
11      */
12     int addProduct(Product product);
13 
14     /**
15      * 根据id删除产品
16      * @param id
17      */
18     void deleteProduct(int id);
19 
20     /**
21      * 更新产品信息
22      * @param product
23      * @return
24      */
25     int updateProduct(Product product);
26 
27     /**
28      * 获取产品列表
29      * @return
30      */
31     List<Product> listProduct();
32 }

映射文件：

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <!DOCTYPE mapper
 3         PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
 4         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
 5 
 6 <mapper namespace="com.mybatis.mapper.ProductMapper">
 7     <insert id="addProduct" parameterType="Product">
 8       INSERT INTO product (name, price) VALUES (#{name}, #{price})
 9     </insert>
10 
11     <delete id="deleteProduct" parameterType="Product">
12         DELETE FROM product WHERE id=#{id}
13     </delete>
14 
15     <update id="updateProduct" parameterType="Product">
16         UPDATE product SET name=#{name}, price=#{price} WHERE id=#{id}
17     </update>
18 
19     <select id="listProduct" resultType="Product">
20         SELECT * FROM product
21     </select>
22 </mapper>

4、创建链接（dao层实现）

无论是用 Hibernate 还是 MyBatis，通用的操作步骤：

1、 从配置文件(通常是XML配置文件中)得到 sessionfactory(相当于DataSource)。

2、由sessionfactory  产生 session(相当于Connection)。

3、在session 中完成对数据的增删改查和事务提交等。

4、在用完之后关闭session 。

  1 import com.mybatis.pojo.Product;
  2 import org.apache.ibatis.io.Resources;
  3 import org.apache.ibatis.session.SqlSession;
  4 import org.apache.ibatis.session.SqlSessionFactory;
  5 import org.apache.ibatis.session.SqlSessionFactoryBuilder;
  6 
  7 import java.io.IOException;
  8 import java.io.InputStream;
  9 import java.util.List;
 10 
 11 /**
 12  * @author zt1994 2018/3/6 10:55
 13  */
 14 public class ProductDao {
 15 
 16     /**
 17      * 添加产品
 18      * @param product
 19      */
 20     public void addProduct(Product product){
 21         String resource = "mybatis-config.xml";
 22         InputStream inputStream = null;
 23         try {
 24             inputStream = Resources.getResourceAsStream(resource);
 25             //1.从配置文件(通常是XML配置文件中)得到 sessionfactory(相当于DataSource)。
 26             SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
 27             //2.由sessionfactory  产生 session(相当于Connection)。
 28             SqlSession session = sessionFactory.openSession();
 29             //3.在session 中完成对数据的增删改查和事务提交等。
 30             session.insert("com.mybatis.mapper.ProductMapper.addProduct", product);
 31             session.commit();
 32             //4.在用完之后关闭session。
 33             session.close();
 34         } catch (IOException e) {
 35             e.printStackTrace();
 36         }
 37     }
 38 
 39 
 40     /**
 41      * 通过id删除产品
 42      * @param id
 43      */
 44     public void deleteProduct(Integer id){
 45         String resource = "mybatis-config.xml";
 46         InputStream inputStream = null;
 47         try {
 48             inputStream = Resources.getResourceAsStream(resource);
 49             //1.从配置文件(通常是XML配置文件中)得到 sessionfactory(相当于DataSource)。
 50             SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
 51             //2.由sessionfactory  产生 session(相当于Connection)。
 52             SqlSession session = sessionFactory.openSession();
 53             //3.在session 中完成对数据的增删改查和事务提交等。
 54             session.delete("com.mybatis.mapper.ProductMapper.deleteProduct", id);
 55             session.commit();
 56             //4.在用完之后关闭session。
 57             session.close();
 58         } catch (IOException e) {
 59             e.printStackTrace();
 60         }
 61     }
 62 
 63 
 64     /**
 65      * 更新产品
 66      * @param product
 67      */
 68     public void updateProduct(Product product){
 69         String resource = "mybatis-config.xml";
 70         InputStream inputStream = null;
 71         try {
 72             inputStream = Resources.getResourceAsStream(resource);
 73             SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
 74             SqlSession session = sessionFactory.openSession();
 75             session.update("com.mybatis.mapper.ProductMapper.updateProduct", product);
 76             session.commit();
 77             session.close();
 78         } catch (IOException e) {
 79             e.printStackTrace();
 80         }
 81     }
 82 
 83 
 84     /**
 85      * 查询产品列表
 86      * @return
 87      */
 88     public List<Product> listProduct(){
 89         String resource = "mybatis-config.xml";
 90         InputStream inputStream = null;
 91         try {
 92             inputStream = Resources.getResourceAsStream(resource);
 93             SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
 94             SqlSession session = sessionFactory.openSession();
 95             List<Product> productList = session.selectList("com.mybatis.mapper.ProductMapper.listProduct");
 96             session.commit();
 97             session.close();
 98             return productList;
 99         } catch (IOException e) {
100             e.printStackTrace();
101         }
102         return null;
103     }
104 }

5、测试dao

测试dao代码：

 1 import com.mybatis.dao.ProductDao;
 2 import com.mybatis.pojo.Product;
 3 import org.junit.Test;
 4 
 5 import java.util.List;
 6 
 7 /**
 8  * @author zt1994 2018/3/6 11:01
 9  */
10 public class TestProductDao {
11     private ProductDao productDao = new ProductDao();
12 
13     /**
14      * 测试添加产品
15      */
16     @Test
17     public void testAddProduct(){
18         Product product = new Product();
19         product.setName("product5");
20         product.setPrice(5);
21 
22         productDao.addProduct(product);
23     }
24 
25     /**
26      * 测试删除产品
27      */
28     @Test
29     public void testDeleteProduct(){
30         productDao.deleteProduct(1);
31     }
32 
33     /**
34      * 更新产品
35      */
36     @Test
37     public void testUpdateProduct(){
38         Product product = new Product();
39         product.setId(1);
40         product.setName("product5");
41         product.setPrice(5);
42         productDao.updateProduct(product);
43     }
44 
45     /**
46      * 查询产品列表
47      */
48     @Test
49     public void testListProduct(){
50         List<Product> productList = productDao.listProduct();
51         for (Product product : productList) {
52             System.out.println(product);
53         }
54     }
55 }

6、代码优化操作

　　SqlSessionFactory 一旦被创建，应该在你的应用执行期间都存在，没有理由来处理或重新创建它。最简单的是使用单例模式或静态单例模式；最好的是使用Spring框架来管理 SqlSessionFactory 的生命周期。

　　现在来实现 SqlSessionFactory 的静态单例模式创建。使用Spring框架来管理 SqlSessionFactory 的生命周期以后再说。

把创建 SqlSessionFactory 和 sqlSession 的代码抽取为工具类：

 1 import org.apache.ibatis.io.Resources;
 2 import org.apache.ibatis.session.SqlSession;
 3 import org.apache.ibatis.session.SqlSessionFactory;
 4 import org.apache.ibatis.session.SqlSessionFactoryBuilder;
 5 
 6 import java.io.IOException;
 7 import java.io.InputStream;
 8 
 9 /**
10  * @author zt1994 2018/3/6 11:38
11  */
12 public class MyBatisUtils {
13 
14     private static SqlSessionFactory sessionFactory;
15     static {
16         try {
17             String resource = "mybatis-config.xml";
18             InputStream inputStream= Resources.getResourceAsStream(resource);
19             //1.从配置文件(通常是XML配置文件中)得到 sessionfactory(相当于DataSource)。
20             sessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
21         }catch (IOException e){
22             e.printStackTrace();
23         }
24     }
25 
26     public static SqlSession getSqlSession(){
27         //2.由sessionfactory  产生 session(相当于Connection)。
28         return sessionFactory.openSession();
29     }
30 }

优化后的 dao 层代码：

 1 import com.mybatis.pojo.Product;
 2 import com.mybatis.util.MyBatisUtils;
 3 import org.apache.ibatis.session.SqlSession;
 4 
 5 import java.util.List;
 6 
 7 /**
 8  * @author zt1994 2018/3/6 11:55
 9  */
10 public class ProductDao {
11 
12     /**
13      * 添加产品
14      * @param product
15      */
16     public void addProduct(Product product){
17         SqlSession session = MyBatisUtils.getSqlSession();
18         session.insert("com.mybatis.mapper.ProductMapper.addProduct", product);
19         session.commit();
20         session.close();
21     }
22 
23 
24     /**
25      * 通过id删除产品
26      * @param id
27      */
28     public void deleteProduct(Integer id){
29         SqlSession session = MyBatisUtils.getSqlSession();
30         session.delete("com.mybatis.mapper.ProductMapper.deleteProduct", id);
31         session.commit();
32         session.close();
33     }
34 
35 
36     /**
37      * 更新产品
38      * @param product
39      */
40     public void updateProduct(Product product){
41         SqlSession session = MyBatisUtils.getSqlSession();
42         session.update("com.mybatis.mapper.ProductMapper.updateProduct", product);
43         session.commit();
44         session.close();
45     }
46 
47 
48     /**
49      * 查询产品列表
50      * @return
51      */
52     public List<Product> listProduct(){
53         SqlSession session = MyBatisUtils.getSqlSession();
54         List<Product> productList = session.selectList("com.mybatis.mapper.ProductMapper.listProduct");
55         session.commit();
56         session.close();
57         return productList;
58     }
59 }

 7、项目整体结构