根据SpringSide4中涉及到的ORM框架,针对具体实践进行学习,做出比较和总结,以便在实际系统架构设计中能够更好地选择。

Spring Data JPA

概述

  • Spring Data :提供了一整套数据访问层(DAO)的解决方案,致力于减少数据访问层(DAO)的开发量。它使用一个叫作Repository的接口类为基础,它被定义为访问底层数据模型的超级接口。而对于某种具体的数据访问操作,则在其子接口中定义。
  • 所有继承这个接口的interface都被spring所管理,此接口作为标识接口,功能就是用来控制domain模型的。
  • Spring Data可以让我们只定义接口,只要遵循spring data的规范,就无需写实现类。

示例

public interface UserDao extends Repository<AccountInfo, Long> { 
    public AccountInfo save(AccountInfo accountInfo); 
 }

使用方法

使用步驟

  1. 声明持久层的接口,该接口继承 Repository,Repository 是一个标记型接口,它不包含任何方法,当然如果有需要,Spring Data 也提供了若干 Repository 子接口,其中定义了一些常用的增删改查,以及分页相关的方法。
  2. 在接口中声明需要的业务方法。Spring Data 将根据给定的策略(具体策略稍后讲解)来为其生成实现代码。
  3. 在 Spring 配置文件中增加一行声明,让 Spring 为声明的接口创建代理对象。配置了 jpa:repositories 后,Spring 初始化容器时将会扫描 base-package 指定的包目录及其子目录,为继承 Repository 或其子接口的接口创建代理对象,并将代理对象注册为 Spring Bean,业务层便可以通过 Spring 自动封装的特性来直接使用该对象。

接口类型

Spring Data JPA提供了四种不同的接口来满足不同的需求

  • Repository 接口
    默认只实现在接口中声明的方法,所以每一个接口都需要声明相似的增删改查方法,适用于严格控制查询方法的情况。

  • CrudRepository 接口
    能够默认的实现增删改查的持久化方法,适用于常规的持久化方法实现。

  • PagingAndSortingRepository 接口
    继承自 CrudRepository 接口,在 CrudRepository 基础上新增了两个与分页有关的方法。更灵活的方式是继承 Repository 或 CrudRepository 的基础上,在自己声明的方法参数列表最后增加一个 Pageable 或 Sort 类型的参数。

  • JpaRepository 接口
    继承自 PagingAndSortingRepository 的针对 JPA 技术提供的接口,并提供了其他一些方法,比如 flush(),saveAndFlush(),deleteInBatch() 等。

三种创建查询的方法

通过解析方法名创建查询

在创建查询时,我们通过在方法名中使用属性名称来表达,比如 findByUserAddressZip ()。框架在解析该方法时,首先剔除 findBy,然后对剩下的属性进行解析,详细规则如下(此处假设该方法针对的域对象为 AccountInfo 类型):

  1. 先判断 userAddressZip (根据 POJO 规范,首字母变为小写,下同)是否为 AccountInfo 的一个属性,如果是,则表示根据该属性进行查询;如果没有该属性,继续第二步;
  2. 从右往左截取第一个大写字母开头的字符串(此处为 Zip),然后检查剩下的字符串是否为 AccountInfo 的一个属性,如果是,则表示根据该属性进行查询;如果没有该属性,则重复第二步,继续从右往左截取;最后假设 user 为 AccountInfo 的一个属性;
  3. 接着处理剩下部分( AddressZip ),先判断 user 所对应的类型是否有 addressZip 属性,如果有,则表示该方法最终是根据 "AccountInfo.user.addressZip" 的取值进行查询;否则继续按照步骤 2 的规则从右往左截取,最终表示根据 "AccountInfo.user.address.zip" 的值进行查询。

    同时也考虑到了重复属性的情况,比如 AccountInfo 包含一个 user 的属性,也有一个 userAddress 属性,此时会存在混淆。读者可以明确在属性之间加上"_"以显式表达意图,比如 "findByUser_AddressZip()" 或者 "findByUserAddress_Zip()"。

在查询时,通常需要同时根据多个属性进行查询,且查询的条件也格式各样(大于某个值、在某个范围等等),Spring Data JPA 为此提供了一些表达条件查询的关键字,大致如下:

  • And --- 等价于 SQL 中的 and 关键字,比如 findByUsernameAndPassword(String user, Striang pwd);
  • Or --- 等价于 SQL 中的 or 关键字,比如 findByUsernameOrAddress(String user, String addr);
  • Between --- 等价于 SQL 中的 between 关键字,比如 findBySalaryBetween(int max, int min);
  • LessThan --- 等价于 SQL 中的 "<",比如 findBySalaryLessThan(int max);
  • GreaterThan --- 等价于 SQL 中的">",比如 findBySalaryGreaterThan(int min);
  • IsNull --- 等价于 SQL 中的 "is null",比如 findByUsernameIsNull();
  • IsNotNull --- 等价于 SQL 中的 "is not null",比如 findByUsernameIsNotNull();
  • NotNull --- 与 IsNotNull 等价;
  • Like --- 等价于 SQL 中的 "like",比如 findByUsernameLike(String user);
  • NotLike --- 等价于 SQL 中的 "not like",比如 findByUsernameNotLike(String user);
  • OrderBy --- 等价于 SQL 中的 "order by",比如 findByUsernameOrderBySalaryAsc(String user);
  • Not --- 等价于 SQL 中的 "! =",比如 findByUsernameNot(String user);
  • In --- 等价于 SQL 中的 "in",比如 findByUsernameIn(Collection userList) ,方法的参数可以是 Collection 类型,也可以是数组或者不定长参数;
  • NotIn --- 等价于 SQL 中的 "not in",比如 findByUsernameNotIn(Collection userList) ,方法的参数可以是 Collection 类型,也可以是数组或者不定长参数;

使用 @Query 创建查询

@Query 注解的使用非常简单,只需在声明的方法上面标注该注解,同时提供一个 JP QL(HQL) 查询语句即可,如下所示:

// 使用 @Query 提供自定义查询语句示例
 public interface UserDao extends Repository<AccountInfo, Long> { 

 @Query("select a from AccountInfo a where a.accountId = ?1") 
 public AccountInfo findByAccountId(Long accountId); 

 @Query("select a from AccountInfo a where a.balance > ?1") 
 public Page<AccountInfo> findByBalanceGreaterThan( 
 Integer balance,Pageable pageable); 
 }

很多开发者在创建 JP QL 时喜欢使用命名参数来代替位置编号,@Query 也对此提供了支持。JP QL 语句中通过": 变量"的格式来指定参数,同时在方法的参数前面使用 @Param 将方法参数与 JP QL 中的命名参数对应,示例如下:

public interface UserDao extends Repository<AccountInfo, Long> { 

 public AccountInfo save(AccountInfo accountInfo); 

 @Query("from AccountInfo a where a.accountId = :id") 
 public AccountInfo findByAccountId(@Param("id")Long accountId); 

   @Query("from AccountInfo a where a.balance > :balance") 
   public Page<AccountInfo> findByBalanceGreaterThan( 
 @Param("balance")Integer balance,Pageable pageable); 
 }

此外,开发者也可以通过使用 @Query 来执行一个更新操作,为此,我们需要在使用 @Query 的同时,用 @Modifying 来将该操作标识为修改查询,这样框架最终会生成一个更新的操作,而非查询。如下所示:

@Modifying 
@Query("update AccountInfo a set a.salary = ?1 where a.salary < ?2") 
public int increaseSalary(int after, int before);

通过调用 JPA 命名查询语句创建查询

public interface UserDao extends Repository<AccountInfo, Long> { 

 ...... 

 public List<AccountInfo> findTop5(); 
 }

如果希望为 findTop5() 创建命名查询,并与之关联,我们只需要在适当的位置定义命名查询语句,并将其命名为 "AccountInfo.findTop5",框架在创建代理类的过程中,解析到该方法时,优先查找名为 "AccountInfo.findTop5" 的命名查询定义,如果没有找到,则尝试解析方法名,根据方法名字创建查询。

@NamedQuery(name="AccountInfo.findTop5",query="SELECT u FROM User u"),

Spring Data JPA 对事务的支持

默认情况下,Spring Data JPA 实现的方法都是使用事务的。针对查询类型的方法,其等价于 @Transactional(readOnly=true);增删改类型的方法,等价于 @Transactional。可以看出,除了将查询的方法设为只读事务外,其他事务属性均采用默认值。
也可以在接口方法上使用 @Transactional 显式指定事务属性,该值覆盖 Spring Data JPA 提供的默认值。

为接口中的部分方法提供自定义实现

有些时候,开发者可能需要在某些方法中做一些特殊的处理,此时自动生成的代理对象不能完全满足要求。为了享受 Spring Data JPA 带给我们的便利,同时又能够为部分方法提供自定义实现,我们可以采用如下的方法:

  • 将需要开发者手动实现的方法从持久层接口(假设为 AccountDao )中抽取出来,独立成一个新的接口(假设为 AccountDaoPlus ),并让 AccountDao 继承 AccountDaoPlus;
  • 为 AccountDaoPlus 提供自定义实现(假设为 AccountDaoPlusImpl );
  • 将 AccountDaoPlusImpl 配置为 Spring Bean; 在 jpa:repositories 中按如下方式进行配置。
<jpa:repositories base-package="footmark.springdata.jpa.dao"> 
 <jpa:repository id="accountDao" repository-impl-ref=" accountDaoPlus " /> 
 </jpa:repositories> 
 <bean id="accountDaoPlus" class="......."/>

提供了一个 repository-impl-postfix 属性,用以指定实现类的后缀。

<jpa:repositories base-package="footmark.springdata.jpa.dao"
 repository-impl-postfix="Impl"/>

则在框架扫描到 AccountDao 接口时,它将尝试在相同的包目录下查找 AccountDaoImpl.java,如果找到,便将其中的实现方法作为最终生成的代理类中相应方法的实现。

总结

Spring Data JPA 能够和Spring无缝集成,但不依赖Spring,能够作为更好的ORM框架来使用,通过用持久层继承不同的接口,Spring Data JPA能够帮助开发人员免去为持久层接口编写实现类的工作,同时多样话的接口、查询方法名解析与灵活的注解,都能够满足简单到复杂业务的持久化需求。

使用方案

与Maven集成的配置

<dependency>
    <groupId>org.springframework.data</groupId>
    <artifactId>spring-data-jpa</artifactId>
    <version>1.4.3.RELEASE</version>
    <exclusions>
        <exclusion>
            <groupId>junit</groupId>
            <artifactId>junit-dep</artifactId>
        </exclusion>
    </exclusions>
</dependency>

在Spring配置文件中的配置

下载Spring Data JPA 的发布包(需要同时下载 Spring Data Commons 和 Spring Data JPA 两个发布包,Commons 是 Spring Data 的公共基础包),并把相关的依赖 JAR 文件加入到 CLASSPATH 中。

并在Spring配置文件中添加如下配置

<-- 需要在 <beans> 标签中增加对 jpa 命名空间的引用 --> 
 <jpa:repositories base-package="footmark.springdata.jpa.dao"
 entity-manager-factory-ref="entityManagerFactory" 
 transaction-manager-ref="transactionManager"/>

JPA/Hibernate

概述

Hibernate提供了一套JPA标准的实现,拥有强大的持久化方法,简化开发人员在持久层的编码工作,同时也提供了完善的缓存的机制,帮助开发者更好地进行复杂业务逻辑的持久化操作。

用法

Hibernate/JPA不但实现了Java的注解接口,也加入了一些扩展的注解。
Hibernate通过三个组件来实现JPA:

  • hibernate-annotation:是Hibernate支持annotation方式配置的基础,它包括了标准的JPA annotation以及Hibernate自身特殊功能的annotation。
  • hibernate-entitymanager:是Hibernate的核心实现,提供了Hibernate所有的核心功能
  • hibernate-core:实现了标准的JPA,可以把它看成hibernate-core和JPA之间的适配器,它并不直接提供ORM的功能,而是对hibernate-core进行封装,使得Hibernate符合JPA的规范。

实体的状态

实体共有4种状态:

  • 新建态:新创建的实体对象,尚未拥有持久化主键,没有和一个持久化上下文关联起来
  • 受控态:已经拥有持久化主键和持久化上下文建立了联系
  • 游离态:拥有持久化主键,但尚未和持久化上下文建立联系
  • 删除态:拥有持久化主键,已经和持久化上下文建立了联系,但已经被安排从数据库中删除

EntityManager的API

  • void persist(Object entity) 通过persist方法,新实体实例将转换为受控状态,就是说,当persist()方法所在的事务提交时,实体的数据保存到数据库中。 如果实体已经被持久化,那么调用persist()方法不会发生任何事情。 如果对一个已经删除的实体调用persist()方法,删除态的实体又转变为受控态 如果对游离状态的实体执行persist()操作,抛出IllegalArgumentException 一个实体调用persist()方法后,所有与之关联的实体,都将执行持久化操作
  • void remove(Object entity) 删除一个受控态的实体。 如果实体声明为级联删除(cascade=REMOVE或者cascade=ALL),被关联的实体也会被删除 在一个新建态或删除态的实体上调用remove()方法,将被忽略 在游离态的实体上调用remove()方法,将抛出IllegalArgumentException,相关事务将回滚
  • void flush() 将受控态的实体数据同步到数据库中
  • T merge(T entity) 将一个游离态的实体持久化到数据库中,并转换为受控态的实体
  • T find(Class entityClass.Object primaryKey) 以主键查询实体对象,entityClass是实体的类,primaryKey是主键值 Eg:Topic t = em.find(Topic.class,1);

使用步骤

1.在classpath根部META-INF目录下创建persistence.xml文件,内容如下:

<persistence xmlns="http://java.sun.com/xml/ns/persistence"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd"
   version="1.0">
   <persistence-unit name="course">
      <properties>
         <property name="hibernate.dialect" value="org.hibernate.dialect.MySQL5Dialect"/>
         <property name="hibernate.connection.driver_class" value="org.gjt.mm.mysql.Driver"/>
         <property name="hibernate.connection.url" value="jdbc:mysql://localhost:3306/db_jpa"/>
         <property name="hibernate.connection.username" value="root"/>
         <property name="hibernate.connection.password" value="root"/>
         <property name="hibernate.show_sql" value="true"/>
         <property name="hibernate.hbm2ddl.auto" value="update"/>
      </properties>
   </persistence-unit>
</persistence>

2.创建实体类,并加上JPA注解(也可以使用XML形式的注解),代码如下:

@Entity  
@Table(name="t_course")  
public class Course {  
    @Id  
    @GeneratedValue  
    private Long id;  

    private String title;  

    private Date beginDate;  

    private Date endDate;  

    private int fee;  

    //省略get、set方法
}

3.编写Dao接口,代码如下:

public interface CourseDao {
    public void save(Course course);
    public void delete(Long id);
    public Course get(Long id);
}

4.编写Dao接口的JPA实现类,代码如下:

public class JpaCourseDao implements CourseDao {  
    //实体对象由实体管理器进行管理,通过EntityManager和持久化上下文进行交互
    private EntityManagerFactory entityManagerFactory;  

    public JpaCourseDao() {  
        //根据persistence.xml中定义的PersistenceUnit的命名来创建实体管理器
        entityManagerFactory = Persistence.createEntityManagerFactory("course");  
    }  

    @Override  
    public void delete(Long id) {  
        EntityManager manager = entityManagerFactory.createEntityManager();  
        EntityTransaction tx = manager.getTransaction();  
        try {  
            tx.begin();  
            Course course = manager.find(Course.class, id);  
            manager.remove(course);  
            tx.commit();  
        } catch (RuntimeException e) {  
            tx.rollback();  
            throw e;  
        } finally {  
            manager.close();  
        }  
    }  

    @Override  
    public Course get(Long id) {  
        EntityManager manager = entityManagerFactory.createEntityManager();  
        try {  
            return manager.find(Course.class, id);  
        } finally {  
            manager.close();  
        }  
    }  

    @Override  
    public void save(Course course) {  
        EntityManager manager = entityManagerFactory.createEntityManager();  
        EntityTransaction tx = manager.getTransaction();  
        try {  
            tx.begin();  
            manager.merge(course);  
            tx.commit();  
        } catch (RuntimeException e) {  
            tx.rollback();  
            throw e;  
        } finally {  
            manager.close();  
        }  
    }  
}

与Spring集成方案

1.在Spring的applicationContext.xml中引入如下配置

<!-- entityManagerFactory 有以下2种方式提供 -->  
    <!-- class="org.springframework.orm.jpa.LocalEntityManagerFactoryBean">-->  
    <!-- class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">-->  
    <bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">  
        <property name="persistenceUnitName" value="Test_PU" />  
    </bean>  
    <bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">  
        <property name="entityManagerFactory" ref="entityManagerFactory" />  
    </bean>  

    <tx:annotation-driven transaction-manager="transactionManager" />

2.在src的META-INF目录下建立persistence.xml文件

<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="http://java.sun.com/xml/ns/persistence"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/persistence
    http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd" version="1.0">

    <persistence-unit name="Test_PU" transaction-type="RESOURCE_LOCAL">

        <!-- provider>org.eclipse.persistence.jpa.PersistenceProvider</provider-->
        <provider>org.hibernate.ejb.HibernatePersistence</provider>


        <!-- MYSql 的连接-->
        <properties>
             <property name="hibernate.connection.driver_class"                 value="com.mysql.jdbc.Driver" />
             <property name="hibernate.connection.url"     value="jdbc:mysql://localhost:3306/tester?useUnicode=true&characterEncoding=utf-8" />
             <property name="hibernate.connection.username"                 value="tester" />
             <property name="hibernate.connection.password"                 value="tester" />
             <property name="hibernate.connection.provider_class" value="org.hibernate.connection.C3P0ConnectionProvider"/>
             <property name="hibernate.c3p0.max_size" value="100"/>
             <property name="hibernate.c3p0.min_size"  value="20"/>
             <property name="hibernate.c3p0.timeout"   value="120"/>
             <property name="hibernate.c3p0.max_statements" value="0"/>
             <property name="hibernate.c3p0.idle_test_period"  value="120"/>
             <property name="hibernate.c3p0.acquire_increment" value="5  "/>
             <property name="hibernate.cache.provider_class" value="org.hibernate.cache.EhCacheProvider"/>
             <property name="hibernate.cache.use_query_cache" value="false"/>
             <property name="hibernate.show_sql" value="false"/>
             <property name="hibernate.useUnicode" value="true"/>
             <property name="hibernate.characterEncoding" value="utf8"/>
         </properties>

    </persistence-unit>
</persistence>

3.建立TestaService.java,实现了findbyID 和add方法以及一个JPQL的用法。

//此处定义为全部的服务方法都由事物控制
@Transactional  
@Service("com.alcor.test.service.TestaService")
public class TestaService {
    /**
     * Logger for this class
     */
    private static final Logger logger = Logger.getLogger(TestaService.class);

    @Autowired
    private EchoService echoService;


    @PersistenceContext 
    EntityManager em;  
    //覆盖默认的事物配置
    @Transactional(propagation = Propagation.NOT_SUPPORTED, readOnly = true)  
    public Testa findByID(TestaPK id) {
        if (logger.isDebugEnabled()) {
            logger.debug("findByID(TestaPK) - start"); 
        }  

        logger.debug(id.getId()+"|"+id.getName());
        Testa returnTesta = em.find(Testa.class, id);
        if (logger.isDebugEnabled()) {
            logger.debug("findByID(TestaPK) - end"); 
        }
        return returnTesta;  
     }

    //使用了默认的事物机制
    public void add(){
        if (logger.isDebugEnabled()) {
            logger.debug("add() - start"); 
        }
        //保存A表
        Testa testa = new Testa();
        TestaPK testaPK = new TestaPK();
        testaPK.setId(UUID.randomUUID().toString());
        testaPK.setName(UUID.randomUUID().toString());
        testa.setId(testaPK);
        em.persist(testa);  
        //保存B表
        Testb testb = new Testb();
        testb.setId(UUID.randomUUID().toString());
        em.persist(testb);

        //调用一个autowired 的service
        echoService.doNothing();

        if (logger.isDebugEnabled()) {
            logger.debug("add() - end"); 
        }
    }

    /**
     * 通过使用JPQL 来做查询
     */
    @Transactional(propagation = Propagation.NOT_SUPPORTED, readOnly = true)  
    public List<Testa> findAllBySex (){
        if (logger.isDebugEnabled()) {
            logger.debug("findAllBySex() - start"); 
        }
        String queryString = "SELECT a FROM Testa a WHERE a.age < :age  AND a.id.name like :name";
        Query query = em.createQuery(queryString);
        query.setParameter("name", "%xv%");
        query.setParameter("age", 20);
        List<Testa> results  = query.getResultList();
        if (logger.isDebugEnabled()) {
            logger.debug("findAllBySex() - end"); 
        }
        return results;
    }
}

总结

Hibernate/JPA在用法上根据不同的集成方式而改变,但其核心的功能都是一样的,其重点是实现了JPA的标准ORM规范,使持久层的操作与具体的框架解耦。
它在Hibernate里写法上是session,而在JPA中变成了manager,所以从Hibernate到JPA的代价应该是非常小的。


MyBatis

概述

MyBatis 是支持普通 SQL查询,存储过程和高级映射的优秀持久层框架。MyBatis 消除了几乎所有的JDBC代码和参数的手工设置以及结果集的检索。MyBatis 使用简单的XML或注解用于配置和原始映射,将接口和 Java 的POJOs(Plain Old Java Objects,普通的 Java
对象)映射成数据库中的记录。

用法

每个MyBatis应用程序主要都是使用SqlSessionFactory实例的,一个SqlSessionFactory实例可以通过SqlSessionFactoryBuilder获得。SqlSessionFactoryBuilder可以从一个xml配置文件或者一个预定义的配置类的实例获得。

使用步骤

MyBatis在不同的框架环境下有不同的配置方式,但具体的步骤如下:

  • 配置sqlSessionFactory实例
    sqlSessionFactory为MyBatis框架的核心实体,我们需要在项目中配置sqlSessionFactory极其属性,包括数据源,实体映射配置,查询语句的配置等信息。详情查看MyBatis配置文件详解

    <?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.mysql.jdbc.Driver" />
                <property name="url" value="jdbc:mysql://localhost:3306/hlp?useUnicode=true&characterEncoding=UTF-8&zeroDateTimeBehavior=convertToNull" />
                <property name="username" value="root" />
                <property name="password" value="1234" />
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="com/mybatis/config/UserDaoMapper.xml"/>
    </mappers>
    </configuration>
  • 创建实体类

package com.mybatis.config;

public class User {
    private int userId;
    private String userName;
    private String password;
    private String comment;

    //省略get/set方法
}
  • 创建数据层接口(Dao) 只需要创建接口,不用担心实现类
package com.mybatis.config;

import java.util.List;

public interface UserDao {

    public int insert(User user);

    public int update(User user);

    public int delete(String userName);

    public List<User> selectAll();

    public int countAll();

    public User findByUserName(String userName);
}
  • 配置查询映射文件
    将与实体相关的查询语句和数据层接口对应配置,详细参照MyBatis中Mapper文件详解

    <?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.mybatis.config.UserDao">
    <select id="countAll" resultType="int">
        select count(*) c from user;
    </select>
    
    <select id="selectAll" resultType="com.mybatis.config.User">
        select * from user order by userName asc
    </select>
    
    <insert id="insert" parameterType="com.mybatis.config.User">
        insert into user(userName,password,comment) values(#{userName},#{password},#{comment})
    </insert>
    
    <update id="update" parameterType="com.mybatis.config.User">
        update user set userName=#{userName},password=#{password},comment=#{comment} where userName=#{userName}
    </update>
    
    <delete id="delete" parameterType="int">
        delete from user where userName=#{userName}
    </delete>
    
    <select id="findByUserName" parameterType="String" resultType="com.mybatis.config.User">
        select * from user where userName=#{userName}
    </select>
    </mapper>
  • 测试查询

package com.mybatis.config;

import java.io.Reader;
import java.util.Iterator;
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.junit.Test;

public class UserDaoTest {
    @Test
    public void userDaoTest() throws Exception
    {
        String resource = "MyBatis-Configuration.xml";
        Reader reader = Resources.getResourceAsReader(resource);
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        SqlSessionFactory factory = builder.build(reader);

        SqlSession session = factory.openSession();
        UserDao userDao = session.getMapper(UserDao.class);

        User user = new User();
        user.setUserName("hongye");
        user.setPassword("123456");
        user.setComment("备注");

        userDao.insert(user);
        System.out.println("记录条数:"+userDao.countAll());

        List<User> users = userDao.selectAll();
        Iterator<User> iter = users.iterator();
        while(iter.hasNext()){
            User u = iter.next();
            System.out.println("用户名:"+u.getUserName()+"密码:"+u.getPassword());
        }

        user.setComment("comment");
        userDao.update(user);
        User u = userDao.findByUserName("hongye");
        System.out.println(u.getComment());

        userDao.delete("hongye");
        System.out.println("记录条数:"+userDao.countAll());

        session.commit();
        session.close();
    }
}

与Spring整合方案

根据MyBatis的使用步骤,按照SpringSide4中的最佳实践,给出与Spring整合的方案

  • 引入MyBatis依赖
<!-- mybatis -->
        <dependency>
                <groupId>org.mybatis</groupId>
                <artifactId>mybatis</artifactId>
                <version>3.2.3</version>
            </dependency>
            <dependency>
                <groupId>org.mybatis</groupId>
                <artifactId>mybatis-spring</artifactId>
                <version>1.2.1</version>
            </dependency>
  • 配置核心sqlSessionFactory实体,在applicationContext.xml中如下配置
<!-- MyBatis配置 -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource" />
        <!-- 自动扫描entity目录, 省掉Configuration.xml里的手工配置 -->
        <property name="typeAliasesPackage" value="org.springside.examples.showcase.entity" />
        <!-- 显式指定Mapper文件位置 -->
        <property name="mapperLocations" value="classpath:/mybatis/*Mapper.xml" />
    </bean>
    <!-- 扫描basePackage下所有以@MyBatisRepository标识的 接口-->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="org.springside.examples.showcase" />
        <property name="annotationClass" value="org.springside.examples.showcase.repository.mybatis.MyBatisRepository"/>
    </bean>
  • 实体类(略过)
  • 数据层接口
//通过@MapperScannerConfigurer扫描目录中的所有接口,动态在Spring Context中生成实现.

@MyBatisRepository
public interface UserMybatisDao {

    User get(Long id);

    List<User> search(Map<String, Object> parameters);

    void save(User user);

    void delete(Long id);
}
  • Mapper文件
<?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必须指向Dao接口 -->
<mapper namespace="org.springside.examples.showcase.repository.mybatis.UserMybatisDao">
    <!--
        获取用户: 输出直接映射到对象, login_name列要"as loginName"以方便映射 ,team_id as "team.id"创建team对象并赋值
    -->
    <select id="get" parameterType="int" resultType="User">
        select id, name, email,
        login_name as loginName,
        team_id as "team.id"
        from ss_user
        where id=#{id}
    </select>

    <!-- 查询用户,演示: 1.输入用map传入多个参数 2.<where>语句, 智能添加where和and关键字 3.输出直接映射对象 -->
    <select id="search" parameterType="map" resultType="User">
        select id, name, email,
        login_name as loginName,
        team_id as "team.id"
        from ss_user
        <where>
            <if test="loginName != null">
                login_name=#{loginName}
            </if>
            <if test="name != null">
                and name=#{name}
            </if>
        </where>
    </select>

    <!-- 插入用户: 1.由数据库生成id并赋值到user对象 2.输入用对象, 嵌套属性表达式#{team.id} -->
    <insert id="save" parameterType="User" useGeneratedKeys="true" keyProperty="id">
        insert into ss_user (
        login_name, name, password, email, team_id)
        values (
        #{loginName}, #{name}, #{password}, #{email},
        #{team.id})
    </insert>

    <!-- 删除用户 -->
    <delete id="delete" parameterType="int">
         delete from ss_user where id=#{id}
    </delete>
</mapper>
  • 測試
@DirtiesContext
@ContextConfiguration(locations = { "/applicationContext.xml" })
public class UserMybatisDaoTest extends SpringTransactionalTestCase {

    @Autowired
    private UserMybatisDao userDao;

    @Test
    public void getUser() throws Exception {
        User user = userDao.get(1L);
        assertNotNull("User not found", user);
        assertEquals("admin", user.getLoginName());
    }

    @Test
    public void searchUser() throws Exception {
        Map<String, Object> parameter = Maps.newHashMap();
        parameter.put("name", "管理员");
        List<User> result = userDao.search(parameter);
        assertEquals(1, result.size());
        assertEquals("admin", result.get(0).getLoginName());
    }

    @Test
    public void createAndDeleteUser() throws Exception {
        // create
        int count = countRowsInTable("ss_user");
        User user = UserData.randomUser();
        userDao.save(user);
        Long id = user.getId();

        assertEquals(count + 1, countRowsInTable("ss_user"));
        User result = userDao.get(id);
        assertEquals(user.getLoginName(), result.getLoginName());

        // delete
        userDao.delete(id);
        assertEquals(count, countRowsInTable("ss_user"));
        assertNull(userDao.get(id));
    }

}

总结

iBATIS 的着力点,则在于POJO与SQL之间的映射关系。然后通过映射配置文件,将SQL所需的参数,以及返回的结果字段映射到指定POJO。相对Hibernate“O/R”而言,iBATIS 是一种“Sql Mapping”的ORM实现。
MyBatis的学习难度相对较低,但需要手写大量的sql语句,且不如Hibernate封装性强,适合使用在对于没有那么高的对象模型要求的项目。
具体与Hibernate的比较参考Hibernate与 MyBatis的比较