MyBatis简介

MyBatis（一）
首篇介绍JDBC、Hibernate、MyBatis三种访问数据库的方法和优缺点
JDBC：
所有的java程序都是通过JDBC连接数据库通过SQL对数据库编程的。JDBC是SUN公司提出的一系列接口规范，具体实现由各个数据库厂商实现，
（所以我们得在自己的程序中根据不同的数据库引入不同的驱动jar包）。传统的JDBC编程，为我们实现了连接数据库的功能，但是工作量大、代码复杂，于是ORM框架孕育而生。
不过所有ORM框架都是基于JDBC进行封装的，只是它们的封装强度不同。

--使用SQL Server 2008 建如下表
CREATE TABLE [dbo].[T_RESOURCE](
    [RESOURCE_ID] [varchar](50) NULL,
    [RESOURCE] [varchar](50) NULL
) ON [PRIMARY]

GO

我们先看一段纯原生的JDBC获取单据主表的实现代码

package com.mybatis01.jdbc;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class MainTest {
    /**
     * 取得Connection
     * @return
     * @author kang
     */
    private Connection getConnection(){
        
        Connection conn = null;
        try {
            Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver");
            String url = "jdbc:sqlserver://127.0.0.1:1433;DatabaseName=mybatis";
            String user = "sa";
            String password = "1";
            conn = DriverManager.getConnection(url, user, password);
            
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return conn;
    }
    
    
    public List<Map<String,Object>> getResourceList(){
        List<Map<String,Object>> resultListMap = new ArrayList<Map<String,Object>>();
        StringBuffer whereSQL = new StringBuffer();
        Map<String,Object> map = null;
        whereSQL.append("where 1=1 ");
        
        StringBuffer querySQL = new StringBuffer();
        querySQL.append("select top 10 * from T_RESOURCE ");
        querySQL.append(whereSQL);
        
        Connection conn = this.getConnection();
        PreparedStatement ps = null;
        ResultSet rs = null;
        
        try {
            ps = conn.prepareStatement(querySQL.toString());
            rs = ps.executeQuery();
            while(rs.next()){
                map = new HashMap<String, Object>();
                String resource_id = rs.getString("resource_id");
                String resource = rs.getString("resource");
                map.put("resource_id", resource_id);
                map.put("resource", resource);
                resultListMap.add(map);
            }
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally{
        
            try {
                ps.close();
                rs.close();
                conn.close();
            } catch (SQLException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            }
        
        
        return resultListMap;
        
    }
    public static void main(String[] args) {
        
        MainTest test = new MainTest();
        List<Map<String,Object>> listMap = test.getResourceList();
        for(Map<String,Object> map:listMap){
            System.out.println(map.get("resource_id")+"---------"+map.get("resource"));
        }
    }
}
大致步骤如下：
1、使用JDBC获取Connection
2、打开Statement对象
3、Statement执行SQL返回结构ResultSet对象
4、根据ResultSet对象获得目标数据
5、关闭ResultSet、Statement、Connection

代码量略多，不建议使用JDBC的方式；不过笔者在很多小型项目中也有使用经过简易封装的JDBC的方式做开发，主要原因是其开发难度小，调试方便，新手接手快。
但是在中大型项目中我们很少使用JDBC进行编程，一般情况下会使用ORM框架，ORM(Object Relational Mapping)简单的说就是数据库的表和简单java对象的映射关系模型，
主要解决数据库数据和POJO对象的相互映射，通过这个映射可以简单迅速的将数据库的数据转化为JAVA的POJO对象。

Hibernate：

论ORM框架，那Hibernate无疑是必须要谈的。Hibernate是建立在POJO通过XML映射文件（或注释）提供的规则映射到数据库表上的，它提供的是一种全表映射的模型。
Hibernate对JDBC的封装程度比较高，基本无需编写SQL语言使用简单的HQL就可以了。


1、首先我们提供hbm.xml文件，制定映射规则，描述POJO和数据库的映射关系，hibernate通过映射配置文件可以把数据库的数据映射到POJO上，通过POJO操作数据库记录
<?xml version="1.0"?>
???? <!DOCTYPE hibernate-mapping PUBLIC
??????? "-//Hibernate/Hibernate Mapping DTD 2.0//EN"
        "http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd">?
???? <!-- 映射文件开始 -->???
<hibernate-mapping>
    ??<class name="com.mybatis01.hibernate.ResourceBean" table="T_RESOURCE">?
        ???? <id name="resource_id"  type="string">
                <column name="resource_id">
        ????     <generator class="native" />
        ???? </id>
        ???? <property name="resource" type="string" column="resource" ?not-null="true" length="50">??
        ???? </property>
    ?</class>
</hibernate-mapping>

2、配置Hibernate的配置信息，hibernate.cfg.xml
<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <session-factory>
        <property name="hibernate.dialect">org.hibernate.dialect.SQLServerDialect</property>
        <property name="hibernate.connection.driver_class">com.microsoft.sqlserver.jdbc.SQLServerDriver</property>
        <property name="hibernate.connection.url">jdbc:sqlserver://localhost:1433;DatabaseName=mybatis</property>
        <property name="hibernate.connection.username">sa</property>
        <property name="hibernate.connection.password">1</property>>
        <mapping resource="resource.hbm.xml"/>
    </session-factory>
</hibernate-configuration>
3、建立Hibernate的工厂对象（SessionFactory），用它来做全局对象，生产Session对象
public class HibernateUtil {

    private static final SessionFactory  sessionFactory;
    static{
        
        Configuration cfg = new Configuration().configure("hibernate.cfg.xml");
        sessionFactory = cfg.buildSessionFactory();
    }
    public static SessionFactory getSessionFactory(){
        
        return sessionFactory;
    }
}
4、测试
public static void main(String[] args) {
    Session session = null;
    session = HibernateUtil.getSessionFactory().openSession();
    ResourceBean rb = (ResourceBean)session.get(ResourceBean.class, 1);
    System.out.println(rb.getResource()+"++++++"+rb.getResource_id());
}

Hibernate的优点如下：
1、消除JDBC带来的大量代码，提高编程简易性和可读性
2、提供级联、缓存、映射、一对多等功能
Hibernate的缺点如下：
1、全表映射带来的不便，比如更新的时候要发送所有的字段
2、对多表关联和复杂的SQL查询支持较差，需要自己写SQL，返回后，需要自己将数据组装成POJO
3、不能有效的支持存储过程
4、无法对SQL做优化

MyBatis

为了弥补Hibernate的不足，一个半自动映射的框架MyBatis应运而生，因为需要手工匹提供的POJO、SQL和映射关系所以叫半自动。
MyBatis的前身是Apache的一个开源框架ibatis，后迁移到google code更名为MyBatis，再后迁移到Github，目前由github维护。
0、建立POJO对象
public class Resource {
    private String resource_id;
    private String resource;
        //省略get、set
}
1、Mybatis的基础配置 mybatis_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>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC" />
            <dataSource type="POOLED">
                <property name="driver" value="com.microsoft.sqlserver.jdbc.SQLServerDriver" />
                <property name="url" value="jdbc:sqlserver://127.0.0.1:1433;DatabaseName=mybatis" />
                <property name="username" value="sa" />
                <property name="password" value="1" />
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="resource.xml"/>
    </mappers>
</configuration>
2、resource.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">
<mapper namespace="com.ServiceImpl.ResourceMapper">
    <select id="getResource" parameterType="int" resultType="com.bean.Resource">
    select * from T_RESOURCE where resource_id=#{id}
    </select>
</mapper>
SQL的列名和POJO的属性名保持一致，这时MyBatis会自动提供映射规则
3、ResourceMapper.java，建立SqlSessionFactory
public interface ResourceMapper {

    public  Resource getResource(int id);    
}
4、MyBatisUtil
public class MyBatisUtil {

    
    private static SqlSessionFactory sqlSessionFactory = null;
    public static SqlSessionFactory getSqlSessionFactory(){
        
        InputStream inputStream = null;
        if(sqlSessionFactory==null){
            String resource = "mybatis_config.xml";
            try {
                sqlSessionFactory = new SqlSessionFactoryBuilder().build(Resources.getResourceAsReader(resource));
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        return sqlSessionFactory;
    }
}
5、Test
    public static void main(String[] args) {
        SqlSessionFactory sessionFactory = MyBatisUtil.getSqlSessionFactory();
        SqlSession session = sessionFactory.openSession();
        ResourceMapper resourceMap = session.getMapper(ResourceMapper.class);
        Resource resource = resourceMap.getResource(1);
        System.out.println(resource);
    }
    
以上我们队JDBC和、Hibernate、MyBatis都作了一个的介绍，那在什么情况下选择这些ORM策略呢。目前纯粹的JDBC极少用到生产的项目中去，
Hibernate作为主流的ORM框架，确实编辑简单但是其自身的限制也很明显，Hibernate只适用于场景不太复杂，要求性能不太苛刻的时候使用。
如果我们要求一个灵活的、可以动态生成映射关系的框架，就选择MyBatis，它几乎代替了JDBC    ，工作量比hibernate略大。