MyBatis 学习笔记（一）MyBatis的简介与使用以及与其他ORM框架的比较-阿里云开发者社区

什么是MyBatis

MyBatis 前身是Apache基金会的开源项目iBatis，在2010年该项目脱离Apache基金会并正式更名为MyBatis，在2013年11月，MyBatis迁移到了GitHub。

MyBatis 是一个轻量级的，半自动的持久化（ORM）框架，其通过XML映射配置文件或者注解来配置和映射原生类型，接口和Java的POJO（Plain Old Java Objects,普通老式Java对象）为数据库中的记录。之所以是半自动化的框架，是因为其不能像Hibernate一样实现自动生成SQL，其需要用户手动编写SQL语句。方便用户对SQL语句进行优化，适用于大数据量，高并发场景。

MyBatis 是一块比较容易上手的框架，使用者只需要通过简单的学习即可掌握其常用特性。

为什么要使用MyBatis

使用MyBatis访问数据库

 <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.4.5</version>
        </dependency>

正如前面所说MyBatis 是一个半自动持久化框架。所以，需要我们自己来维护sql 语句，编写sql语句的xml文件叫做映射文件。在此处，我建立了一个StudentMapper.xml 文件来维护sql 语句。

<mapper namespace="com.jay.mapper.StudentMapper">
    <resultMap id="BaseColumn" type="com.jay.entity.Student">
        <id property="id" column="id"/>
        <result property="name" column="name"/>
        <result property="age" column="age"/>
    </resultMap>
     <select id="selectByName" resultMap="BaseColumn">
        select id,name,age from student where name LIKE '%'#{name}'%'
    </select>
</mapper>

上面的sql语句表示的意思是通过学生名称来模糊匹配学生

public interface StudentMapper {
    /**
     * @param name
     * @return
     */
    List<Student> selectByName(@Param("name") String name);
}

维护完映射文件和对应的接口之后，我们还需要一个XML配置文件来对MyBatis进行一些核心设置，包括获取数据库连接实例的数据源（DataSource）和决定事务作用域和控制方式的事务管理器（TransactionManager）以及SQL映射文件的位置信息等。本节所使用的配置如下：

<configuration>
    <!--加载配置文件->jdbc.properties 数据库文件 -->
    <properties resource="jdbc.properties"/>
    <!-- 设置一个默认的连接环境信息 -->
    <environments default="development">
        <!--连接环境信息，取一个任意唯一的名字 -->
        <environment id="development">
            <!-- mybatis使用jdbc事务管理方式 -->
            <transactionManager type="JDBC"/>
            <!-- mybatis使用连接池方式来获取连接 -->
            <dataSource type="POOLED">
                <!-- 配置与数据库交互的4个必要属性 -->
                <property name="driver" value="${jdbc.driver}"/>
                <property name="url" value="${jdbc.url}"/>
                <property name="username" value="${jdbc.username}"/>
                <property name="password" value="${jdbc.password}"/>
            </dataSource>
        </environment>
    </environments>
    <!-- 加载映射文件-->
    <mappers>
        <mapper resource="xml/StudentMapper.xml"/>
    </mappers>
</configuration>

到此，MyBatis所需的环境就配置好了，接下来我们将MyBatis跑起来。测试代码如下

private SqlSessionFactory sqlSessionFactory;
    @Before
    public void setUp() {
        String resource = "chapter1/mybatis-cfg.xml";
        try {
            InputStream inputStream = Resources.getResourceAsStream(resource);
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream, "development");
            inputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    @Test
    public void mybatisTest() {
        SqlSession sqlSession = sqlSessionFactory.openSession();
        StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
        List<Student> studentList = mapper.selectByName("点点");
        if (studentList != null) {
            System.out.println("----->"+studentList.get(0).toString());
        }
        sqlSession.commit();
        sqlSession.close();
    }

如上测试代码，首先，我们根据配置文件得到文件流，然后通过SqlSessionFactoryBuilder工厂类构造器得到SqlSessionFactory，再通过SqlSessionFactory工厂类得到SqlSession。然后根据SqlSession的getMapper()方法得到需要执行的mapper。得到之后调用相应的方法得到结果。

运行结果如下：

使用JDBC访问数据库

现在我们使用原生的JDBC来操作数据库，主要流程有以下几个：1. 加载数据库驱动，2. 连接数据库，3，通过PreparedStatement执行sql得到ResultSet，4，对ResultSet 进行处理。流程固定。

public class JdbcTest {
    public static void main(String[] args) {
        String driver = "com.mysql.jdbc.Driver";
        String url = "jdbc:mysql://localhost:3306/mybatisdemo";
        String userName = "root";
        String password = "admin";
        Connection conn = null;
        PreparedStatement statement = null;
        ResultSet resultSet = null;
        try {
            Class.forName(driver);
            conn = DriverManager.getConnection(url, userName, password);
            String sql = "select id,name,age from student where name LIKE ?";
            statement = conn.prepareStatement(sql);
            statement.setString(1, "%点点%");
            resultSet = statement.executeQuery();
            List<Student> studentList = new ArrayList<Student>();
            if (resultSet != null) {
                while (resultSet.next()) {
                    Student student = new Student();
                    student.setId(resultSet.getInt("id"));
                    student.setName(resultSet.getString("name"));
                    student.setAge(resultSet.getInt("age"));
                    studentList.add(student);
                }
            }
      System.out.println("----->执行的sql={}"+sql);
            System.out.println("----->resultSet={}"+studentList.get(0).toString());
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {
                if (statement != null) {
                    statement.close();
                }
                if (conn != null) {
                    conn.close();
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}

代码比较简单，执行结果如下：

上面的代码的步骤比较多，但是核心步骤只有两步，分别是执行SQL和处理查询结果。从开发人员的角度来说，我们只关心这两个步骤。原生的JDBC的缺点主要有如下几点：

1.每次为了执行某个SQL需要写很多额外的代码，比如加载驱动，创建数据库连接，代码冗余。

2.将SQL写在代码中，如果要改动SQL，就需要到代码中进行修改，这样做不合适，因为改动了Java代码就需要重新编译Java文件，在打包发布，同时将SQL和Java代码混在一起，会降低代码的可读性，不利于维护。

3.关于执行结果的处理，需要手动的将数据从ResultSet中取出，并设置到我们需要的对象中，如果属性过多，用这种方式处理会非常繁琐。

4.每次都要手动管理数据库连接，使用好之后又要手动关闭。

MyBatis VS JDBC

首先我们来看看MyBatis访问数据库的过程

1.读取配置文件

2.创建SqlSessionFactoryBuilder对象

3.通过SqlSessionFactoryBuilder创建SqlSessionFactory对象

4.通过SqlSessionFactory创建SqlSession

为Dao 接口生成代理类

6.调用接口方法访问数据库

需要注意的是，在MyBatis中SqlSessionFactoryBuilder 和 SqlSessionFactory 以及 SqlSession 等对象的作用域和生命周期是不一样的。

SqlSessionFactoryBuilder

这个类可以被实例化，使用和丢弃，一旦创建了SqlSessionFactory，就不需要它了，所以，SqlSessionFactoryBuilder实例的最佳作用域是方法作用域（也就是局部方法变量）

SqlSessionFactory

SqlSessionFactory一旦被创建就应该在应用的运行期间一直存在，没有任何理由丢弃它或重新创建另外一个实例，使用SqlSessionFactory的最佳实践食杂应用运行期间不要重复创建多起，多次重建SqlSessionFactory被视为一种代码”坏味道“。因此SqlSessionFactory的最佳作用域是应用作用域，有很多方法可以做到，最简单的就是使用单例模式或者静态单例模式。

SqlSession

每个线程都应该有它自己的SqlSession实例，SqlSession的实例不是线程安全的，因此是不能被共享的，所有它的最佳的作用域是请求或方法作用域，绝对不能讲SqlSession实例的引用放在了一个类的静态域，比如Servlet框架中的HttpSession中。

映射器实例

映射器是一些由你创建的，绑定你映射的语句的接口，映射器接口的实例是从SqlSession中获得的，因此从技术层面讲，任何映射器实例的最大作用域是请求他们的的SqlSession相同的，尽管如此，映射器实例的最佳作用域是方法作用域。也就是说，映射器实例应该在调用它们的方法中被请求，用过之后即可丢弃。并不需要显示地关闭映射器实例。

总的来说，MyBatis在易用性上要比JDBC好太多，不过JDBC与MyBatis的目标不同，JDBC是作为一种基础服务，而MyBatis则是构建在基础服务之上的框架。所以JDBC的流程繁琐，从JDBC的角度来说，这里的每一个步骤对于完成数据访问请求来说都是必须的。

使用Spring JDBC访问数据库

Spring JDBC是在JDBC上面做的一层比较薄的封装，主要是为了解决直接使用JDBC的一些痛点，易用性得到了不少的提升。

引入的依赖

<properties>
        <spring.version>4.3.17.RELEASE</spring.version>
    </properties>
 <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>${spring.version}</version>
        </dependency>

在使用Spring JDBC之前我们需要做一些配置，我们新建一个配置文件，命名为application.xml，在此配置文件中，我们配置了

数据库的连接信息dataSource，注册了JdbcTemplate实例。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
    <context:property-placeholder  location="jdbc.properties"/>
    <bean id="dataSource" class="org.apache.ibatis.datasource.pooled.PooledDataSource">
        <!-- 配置与数据库交互的4个必要属性 -->
        <property name="driver" value="${jdbc.driver}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"/>
    </bean>
</beans>

配置完成之后，我们可以写一个测试类来测试一下。

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:chapter1/application.xml")
public class SpringJdbcTest {
    @Autowired
    private JdbcTemplate jdbcTemplate;
    @Test
    public void  testSpringJdbc() {
        String sql = "select id,name,age from student where name LIKE ?";
        List<Student> studentList = jdbcTemplate.query(sql, new Object[]{"%点点%"}, new BeanPropertyRowMapper<Student>(Student.class));
        System.out.println("----->执行的sql={}"+sql);
        System.out.println("----->查询结果={}"+studentList.get(0).toString());
    }
}

运行结果

从上面的测试代码我们可以看出，相对于原生JDBC，Spring JDBC 易用性大大提升，注入jdbcTemplate之后，我们就可以通过jdbcTemplate来操作，只关注sql的执行以及结果的处理即可。代码简化了很多。但是SQL语句仍然写在代码中。

使用Hibernate 访问数据库

本节会像之前的章节一样，我会先写代码进行演示，然后在对比Hibernate 和MyBatis的区别。

Hibernate 访问数据库的过程演示

首先，在POM文件中添加所需依赖

<dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>5.3.2.Final</version>
        </dependency>

接着进行环境配置，主要是关于数据库方面的配置。

<hibernate-configuration>
    <session-factory>
        <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/mybatisdemo</property>
        <property name="hibernate.connection.username">root</property>
        <property name="hibernate.connection.password">admin</property>
        <property name="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</property>
        <property name="hibernate.show_sql">true</property>
        <mapping resource="chapter1/xml/Student.hbm.xml" />
    </session-factory>
</hibernate-configuration>

环境配置完成之后，我们接着编写映射文件，将表字段与实体类的属性关联起来。如下Student.hbm.xml

<hibernate-mapping package="com.jay.entity">
    <class table="student" name="Student">
        <id name="id" column="id">
            <generator class="native"/>
        </id>
        <property name="name" column="name"/>
        <property name="age" column="age"/>
        <property name="classId" column="class_id"/>
    </class>
</hibernate-mapping>

所有配置完成之后，我们就可以开始编写测试代码进行测试：

public class HibernateTest {
    private SessionFactory sessionFactory;
    @Before
    public void init() {
        Configuration configuration = new Configuration();
        configuration.configure("chapter1/hibernate.cfg.xml");
        sessionFactory = configuration.buildSessionFactory();
    }
    @After
    public void destroy() {
        sessionFactory.close();
    }
    @Test
    public void testORM() {
        System.out.println("--------------ORM Query-------------");
        Session session = null;
        try {
            session = sessionFactory.openSession();
            int id = 1;
            Student student = session.get(Student.class, id);
            System.out.println("ORM Query Result:");
            System.out.println(student.toString());
            System.out.println();
        } finally {
            if (Objects.nonNull(session)) {
                session.close();
            }
        }
    }
    @Test
    public void testHQL() {
        System.out.println("--------------HQL Query-----------");
        Session session = null;
        try {
            session = sessionFactory.openSession();
            String hql = "FROM Student WHERE name=:name";
            Query query = session.createQuery(hql);
            query.setParameter("name", "点点");
            List<Student> studentList = query.list();
            System.out.println("HQL Query Result:");
            studentList.forEach(System.out::println);
            System.out.println();
        } finally {
            if (Objects.nonNull(session)) {
                session.close();
            }
        }
    }
   @Test
    public void testJpaCriteria() {
       System.out.println("-------------JPA Criteria-------------");
       Session session = null;
       try {
           session = sessionFactory.openSession();
           CriteriaBuilder criteriaBuilder = session.getCriteriaBuilder();
           CriteriaQuery<Student> criteriaQuery = criteriaBuilder.createQuery(Student.class);
//       定义FROM子句
           Root<Student> student = criteriaQuery.from(Student.class);
//       构建查询条件
           Predicate equal = criteriaBuilder.equal(student.get("name"), "点点");
//       通过具有语义化的方法构建SQL，等价于SELECT ... FROM student WHERE ...
           criteriaQuery.select(student).where(equal);
           Query<Student> query = session.createQuery(criteriaQuery);
           List<Student> studentList = query.getResultList();
           System.out.println("JPA Criteria Query Result:");
           studentList.forEach(System.out::println);
       } finally {
           if (Objects.nonNull(session)) {
               session.close();
           }
       }
   }
}

如上代码清单所示，我编写了三个测试用例，第一个直接使用Hibernate生成SQL的功能，如果查询比较简单可以采用此种方式，生成的SQL是

select student0_.id as id1_0_0_, student0_.name as name2_0_0_, student0_.age as age3_0_0_, student0_.class_id as class_id4_0_0_ from student student0_ where student0_.id=?

第二个测试用例，我编写了一条HQL语句，并通过Query来设置参数，同样Hibernate在运行时会将HQL转化成对应的SQL,转化后的SQL如下：

select student0_.id as id1_0_, student0_.name as name2_0_, student0_.age as age3_0_, student0_.class_id as class_id4_0_ from student student0_ where student0_.name=?

第三个测试用例，我们使用JPA Criteria 进行查询，JPA Criteria 具有类型安全，面向对象和语义化的特点，使用JPA Criteria，我们可以用写Java 代码的方式进行数据库操作，无需手写SQL,第三个用例和第二个用例进行的是同样的查询，所以生成的SQL区别不大。

测试代码的运行结果：

02430f871bcb924de3b912d2db0447ea_watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQ1MzQ4MDg=,size_16,color_FFFFFF,t_70.png

MyBatis VS Hibernate

至此，我们已经对MyBatis和Hibernate访问数据库的过程都做了一次演示，下面我们来对比下MyBatis和Hibernate

MyBatis 需要使用者自行维护SQL，灵活性高，方便对sql进行优化，Hibernate 可以自动生成SQL，使用成本小。

MyBatis 适合于需求变动频繁，业务量的系统，Hibernate 更加适合于变动比较小的系统，比如OA系统

使用Spring Data JPA 访问数据库

首先引入依赖

<properties>
        <spring.version>4.3.17.RELEASE</spring.version>
    </properties>
 <!--///Spring JPA-->
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-jpa</artifactId>
            <version>1.11.8.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjrt</artifactId>
            <version>1.6.12</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.6.12</version>
        </dependency>

接着添加配置文件application-jpa.xml，主要是配置数据库连接信息，以及事务相关的信息

<!--启用注解配置和包扫描-->
    <context:annotation-config/>
    <context:component-scan base-package="com.jay"/>
    <!--创建Spring Data JPA实例对象-->
    <jpa:repositories base-package="com.jay.chapter1"/>
    <context:property-placeholder  location="jdbc.properties"/>
    <bean id="dataSource"
          class="org.apache.ibatis.datasource.pooled.PooledDataSource">
        <!-- 配置与数据库交互的4个必要属性 -->
        <property name="driver" value="${jdbc.driver}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>
    <bean id="entityManagerFactory"
          class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <property name="packagesToScan" value="com.jay.entity"/>
        <property name="jpaVendorAdapter">
            <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
                <property name="generateDdl" value="true"/>
                <property name="showSql" value="true"/>
            </bean>
        </property>
    </bean>
    <!--事务管理器-->
    <bean id="transactionManager"
          class="org.springframework.orm.jpa.JpaTransactionManager">
        <property name="entityManagerFactory" ref="entityManagerFactory"/>
    </bean>
    <!--事务管理-->
    <tx:advice id="transactionAdvice"
               transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="get*" read-only="true"/>
            <tx:method name="*"/>
        </tx:attributes>
    </tx:advice>
    <aop:config>
        <aop:pointcut id="daoPointCut" expression="execution(* com.jay.chapter1.mapper.*.*(..))"/>
        <aop:advisor advice-ref="transactionAdvice" pointcut-ref="daoPointCut"/>
    </aop:config>

配置文件添加完成之后，接着我们编写一个接口继承CrudRepository接口，使其具备基本的增删改查功能。

public interface JpaStudentDao extends CrudRepository<JpaStudent,Integer>{
    /**
     * @param name
     * @return
     */
    List<JpaStudent> getByNameLike(String name);
}

DAO接口添加完成之后，接着我们添加一个测试类进行测试。

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:chapter1/application-jpa.xml")
public class JPATest {
    @Autowired
    JpaStudentDao jpaStudentDao;
    @Before
   public void init() {
        JpaStudent jpaStudent = new JpaStudent("张三", 12, "121");
        jpaStudentDao.save(jpaStudent);
    }
    @Test
    public void testCrudRepostitory() {
        List<JpaStudent> jpaStudents = jpaStudentDao.getByNameLike("张三");
        jpaStudents.forEach(System.out::println);
        System.out.println();
    }
}

如上测试类所示，我先使用了JPA自带的save方法向数据库中插入了一条数据，接着自定义了一个查询方法。JPA中查询方法可以由我们声明的命名查询生成，也可以由方法名解析

方法名以find…By, read…By, query…By, count…By和 get…By做开头。在By之前可以添加Distinct表示查找不重复数据。By之后是真正的查询条件。

可以查询某个属性，也可以使用条件进行比较复杂的查询，例如Between, LessThan, GreaterThan, Like，And,Or等。

字符串属性后面可以跟IgnoreCase表示不区分大小写，也可以后跟AllIgnoreCase表示所有属性都不区分大小写。

可以使用OrderBy对结果进行升序或降序排序。

可以查询属性的属性，直接将几个属性连着写即可，如果可能出现歧义属性，可以使用下划线分隔多个属性。

运行结果如下：

MyBatis VS JPA

通过上面的实例，我们可以了解到JPA的使用，JPA类似于Hibernate都可以自动生成SQL,不同之处是，JPA还可以根据方法名来解析生成sql。MyBatis 还是需要使用者自行维护sql。

总结

本篇文章对MyBatis 是什么，为什么使用，以及与其他ORM框架进行了对比。

参考文献

MyBatis官方文档

MyBatis 源码分析系列文章导读

《MyBatis 技术内幕》- 徐郡明

Spring Data JPA 介绍和使用

源代码

https://github.com/XWxiaowei/MyBatisLearn/tree/master/mybatisDemo

MyBatis 学习笔记（一）MyBatis的简介与使用以及与其他ORM框架的比较

什么是MyBatis

为什么要使用MyBatis

使用MyBatis访问数据库

使用JDBC访问数据库

MyBatis VS JDBC

使用Spring JDBC访问数据库

使用Hibernate 访问数据库

Hibernate 访问数据库的过程演示

MyBatis VS Hibernate

使用Spring Data JPA 访问数据库

MyBatis VS JPA

总结

参考文献

源代码

热门文章

最新文章

相关课程

相关电子书

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

MyBatis 学习笔记（一）MyBatis的简介与使用以及与其他ORM框架的比较

什么是MyBatis

为什么要使用MyBatis

使用MyBatis访问数据库

使用JDBC访问数据库

MyBatis VS JDBC

使用Spring JDBC访问数据库

使用Hibernate 访问数据库

Hibernate 访问数据库的过程演示

MyBatis VS Hibernate

使用Spring Data JPA 访问数据库

MyBatis VS JPA

总结

参考文献

源代码

热门文章

最新文章

相关课程

相关电子书