Mybatis入门介绍

Mybatis入门介绍

应用场景

最开始学习jdbc知识的时候，考虑一下我们是如何编写程序的？
大概分为几个步骤:

1. 配置基本参数
2. 获取连接资源
3. 编译sql
4. 设置参数
5. 执行sql
6. 获取查询结果集
7. 遍历结果集
8. 释放连接资源

我们写个最简单的例子看一下：

import java.sql.*;
import java.util.*;
    public class JDBCUtil{
    
     private static String url;
         private static String username;
         private static String pwd;
         private static String driverClass;
         
         //step 1:
         static {
             url = "jdbc:mysql://127.0.0.1:3306/jdbc?useUnicode=true&characterEncoding=UTF-8&autoReconnect=true&failOverReadOnly=false";
             username = "root";
             pwd = "123456";
             driverClass = "com.mysql.jdbc.Driver";
         }
     
         public static Connection getConnection() throws ClassNotFoundException, SQLException {
             Class.forName(driverClass);
             return java.sql.DriverManager.getConnection(url, username, pwd);
         }
     
         /**
          * 查询接口
          *
          * @param sql    执行的查询sql,参数使用?占位
          * @param params 占位符对应的参数列表
          * @return List<Map<String,Object>> 查询结果，每行数据采用map存储，key=columnName,value = columnValue
          */
         public static List<Map<String,Object>> query(String sql, java.util.List<Object> params) throws SQLException, ClassNotFoundException {
             //step 2:
             java.sql.Connection connection = getConnection();
             
             //step 3:
             // 这里使用预编译的statement，防止sql注入
             java.sql.PreparedStatement preparedStatement = connection.prepareStatement(sql);
             
             //step 4: 
             // 设置参数
             invokeParams(preparedStatement, params);
             
             //step 5 and 6:
             java.sql.ResultSet resultSet = preparedStatement.executeQuery();
             
             //step 7: 
             // 解析查询结果
             List<Map<String,Object>> result = parseResult(resultSet);
            
             //step 8:
             // 关闭资源
             close(resultSet, preparedStatement, connection);
             return result;
         }
     
     
         /**
          * 参数设置
          *
          * @param preparedStatement
          * @param params
          * @throws SQLException
          */
         public static void invokeParams(java.sql.PreparedStatement preparedStatement, java.util.List params) throws SQLException {
             if (null == preparedStatement || null == params)
                 throw new IllegalArgumentException("[NullPointerException],params can not be null");
     
             ParameterMetaData parameterMetaData = preparedStatement.getParameterMetaData();
             int parameterCount = parameterMetaData.getParameterCount();
             if (parameterCount < params.size()) {
                 throw new IllegalArgumentException("params's size is worn, the size should be " + parameterCount);
             }
     
             for (int index = 1; index <= parameterCount; index++) {
                 preparedStatement.setObject(index, params.get(index-1));
             }
         }
     
     
         /**
          * 结果解析
          *
          * @param resultSet
          */
         private static List<Map<String, Object>> parseResult(ResultSet resultSet) throws SQLException {
             List<Map<String, Object>> resultList = new LinkedList<Map<String, Object>>();
             ResultSetMetaData metaData = resultSet.getMetaData();
             int columnCount = metaData.getColumnCount();
             while (resultSet.next()) {
                 Map<String, Object> rowData = new HashMap<String, Object>();
                 for (int index = 1; index <= columnCount; index++) {
                     String key = metaData.getColumnLabel(index);
                     Object value = resultSet.getObject(index);
                     rowData.put(key, value);
                 }
                 resultList.add(Collections.unmodifiableMap(rowData));
             }
             return resultList;
         }
     
         private static void close(ResultSet resultSet, PreparedStatement preparedStatement, Connection connection) {
             try {
                 if (null != resultSet)
                     resultSet.close();
                 if (null != preparedStatement)
                     preparedStatement.close();
                 if (null != connection)
                     connection.close();
             } catch (SQLException e) {
                 e.printStackTrace();
             }
         }
     
     
         public static void main(String[] args) throws SQLException, ClassNotFoundException {
             String sql = "select * from customer where id=?";
             List<Object> params = new LinkedList<Object>();
             params.add(1);
             List<Map<String, Object>> query = query(sql, params);
             System.out.println(query);
         }
     
     }

我们可以看到就简单的查询就这么多复杂的代码，既要连接数据库，又要设置参数，遍历结果集，而且其中很大一部分都是通用的，每次都写太麻烦了。
有人就想到写一些工具类,来处理这些事情，类似于模板模式，同时在利用反射机制，就可以直接注入对象，结果集也可以直接反射成对象。完美！
这种工具有一个高大上的名称叫ORM(对象关系映射)，Mybatis就是这么一个工具，节省开发工作量。

利弊

比较常用的ORM框架就是Hibernate和Mybatis,那么各自有什么优缺点呢？

• Hibernate
  Hibernate的DAO层开发比MyBatis简单，Mybatis需要维护SQL和结果映射。
  Hibernate对对象的维护和缓存要比MyBatis好，对增删改查的对象的维护要方便。
  Hibernate数据库移植性很好，MyBatis的数据库移植性不好，不同的数据库需要写不同SQL。
  Hibernate有更好的二级缓存机制，可以使用第三方缓存。MyBatis本身提供的缓存机制不佳。
  强大、方便、高效、复杂、间接、全自动化

• Mybatis
  Mybatis可以进行更为细致的SQL优化，可以减少查询字段。
  Mybatis容易掌握，而Hibernate门槛较高。
  小巧、方便、高效、简单、直接、半自动化

主要的几个类

• Configuration: Mybatis的配置信息都在该类中
• SqlSession: 作为MyBatis工作的主要顶层API，表示和数据库交互的会话，完成必要数据库增删改查功能，类似于connection
• Executor: 执行器，是MyBatis 调度的核心，负责SQL语句的生成和查询缓存的维护
• StatementHandler: 封装了JDBC Statement操作，负责对JDBC statement 的操作，如设置参数、将Statement结果集转换成List集合。
• ParameterHandler: 负责将用户传递的参数转换成JDBC statement锁需要的参数。
• ResultHandler: 负责将JDBC返回的ResultSet结果集装换为List集合
• TypeHandler: 负责java数据类型和JDBC数据类型之间的映射和转化
• MappedStatement: MappedStatement维护了一条<select|update|delete|insert>节点的封装
• SqlSource: 负责根据用户传递的parameterObject，动态地生成SQL语句，将信息封装到BoundSql对象中，并返回
• BoundSql: 表示动态生成的SQL语句以及相应的参数信息

本文内容可移至Mybatis笔记查看