[关闭]
@caos 2014-08-23T13:04:41.000000Z 字数 20949 阅读 1553

ORM框架学习

编程


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



Spring Data JPA

概述

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

示例

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

使用方法

使用步驟

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

接口类型

Spring Data JPA提供了四种不同的接口来满足不同的需求
- Repository 接口
默认只实现在接口中声明的方法,所以每一个接口都需要声明相似的增删改查方法,适用于严格控制查询方法的情况。

三种创建查询的方法

通过解析方法名创建查询

在创建查询时,我们通过在方法名中使用属性名称来表达,比如 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 为此提供了一些表达条件查询的关键字,大致如下:

使用 @Query 创建查询

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

  1. // 使用 @Query 提供自定义查询语句示例
  2. public interface UserDao extends Repository<AccountInfo, Long> {
  3. @Query("select a from AccountInfo a where a.accountId = ?1")
  4. public AccountInfo findByAccountId(Long accountId);
  5. @Query("select a from AccountInfo a where a.balance > ?1")
  6. public Page<AccountInfo> findByBalanceGreaterThan(
  7. Integer balance,Pageable pageable);
  8. }

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

  1. public interface UserDao extends Repository<AccountInfo, Long> {
  2. public AccountInfo save(AccountInfo accountInfo);
  3. @Query("from AccountInfo a where a.accountId = :id")
  4. public AccountInfo findByAccountId(@Param("id")Long accountId);
  5. @Query("from AccountInfo a where a.balance > :balance")
  6. public Page<AccountInfo> findByBalanceGreaterThan(
  7. @Param("balance")Integer balance,Pageable pageable);
  8. }

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

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

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

  1. public interface UserDao extends Repository<AccountInfo, Long> {
  2. ......
  3. public List<AccountInfo> findTop5();
  4. }

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

  1. @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 带给我们的便利,同时又能够为部分方法提供自定义实现,我们可以采用如下的方法:

  1. <jpa:repositories base-package="footmark.springdata.jpa.dao">
  2. <jpa:repository id="accountDao" repository-impl-ref=" accountDaoPlus " />
  3. </jpa:repositories>
  4. <bean id="accountDaoPlus" class="......."/>

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

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

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

总结

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

使用方案

与Maven集成的配置

  1. <dependency>
  2. <groupId>org.springframework.data</groupId>
  3. <artifactId>spring-data-jpa</artifactId>
  4. <version>1.4.3.RELEASE</version>
  5. <exclusions>
  6. <exclusion>
  7. <groupId>junit</groupId>
  8. <artifactId>junit-dep</artifactId>
  9. </exclusion>
  10. </exclusions>
  11. </dependency>

在Spring配置文件中的配置

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

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

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

JPA/Hibernate

概述

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

用法

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

实体的状态

实体共有4种状态:

EntityManager的API

使用步骤

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

  1. <persistence xmlns="http://java.sun.com/xml/ns/persistence"
  2. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3. xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd"
  4. version="1.0">
  5. <persistence-unit name="course">
  6. <properties>
  7. <property name="hibernate.dialect" value="org.hibernate.dialect.MySQL5Dialect"/>
  8. <property name="hibernate.connection.driver_class" value="org.gjt.mm.mysql.Driver"/>
  9. <property name="hibernate.connection.url" value="jdbc:mysql://localhost:3306/db_jpa"/>
  10. <property name="hibernate.connection.username" value="root"/>
  11. <property name="hibernate.connection.password" value="root"/>
  12. <property name="hibernate.show_sql" value="true"/>
  13. <property name="hibernate.hbm2ddl.auto" value="update"/>
  14. </properties>
  15. </persistence-unit>
  16. </persistence>

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

  1. @Entity
  2. @Table(name="t_course")
  3. public class Course {
  4. @Id
  5. @GeneratedValue
  6. private Long id;
  7. private String title;
  8. private Date beginDate;
  9. private Date endDate;
  10. private int fee;
  11. //省略get、set方法
  12. }

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

  1. public interface CourseDao {
  2. public void save(Course course);
  3. public void delete(Long id);
  4. public Course get(Long id);
  5. }

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

  1. public class JpaCourseDao implements CourseDao {
  2. //实体对象由实体管理器进行管理,通过EntityManager和持久化上下文进行交互
  3. private EntityManagerFactory entityManagerFactory;
  4. public JpaCourseDao() {
  5. //根据persistence.xml中定义的PersistenceUnit的命名来创建实体管理器
  6. entityManagerFactory = Persistence.createEntityManagerFactory("course");
  7. }
  8. @Override
  9. public void delete(Long id) {
  10. EntityManager manager = entityManagerFactory.createEntityManager();
  11. EntityTransaction tx = manager.getTransaction();
  12. try {
  13. tx.begin();
  14. Course course = manager.find(Course.class, id);
  15. manager.remove(course);
  16. tx.commit();
  17. } catch (RuntimeException e) {
  18. tx.rollback();
  19. throw e;
  20. } finally {
  21. manager.close();
  22. }
  23. }
  24. @Override
  25. public Course get(Long id) {
  26. EntityManager manager = entityManagerFactory.createEntityManager();
  27. try {
  28. return manager.find(Course.class, id);
  29. } finally {
  30. manager.close();
  31. }
  32. }
  33. @Override
  34. public void save(Course course) {
  35. EntityManager manager = entityManagerFactory.createEntityManager();
  36. EntityTransaction tx = manager.getTransaction();
  37. try {
  38. tx.begin();
  39. manager.merge(course);
  40. tx.commit();
  41. } catch (RuntimeException e) {
  42. tx.rollback();
  43. throw e;
  44. } finally {
  45. manager.close();
  46. }
  47. }
  48. }

与Spring集成方案

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

  1. <!-- entityManagerFactory 有以下2种方式提供 -->
  2. <!-- class="org.springframework.orm.jpa.LocalEntityManagerFactoryBean">-->
  3. <!-- class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">-->
  4. <bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
  5. <property name="persistenceUnitName" value="Test_PU" />
  6. </bean>
  7. <bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
  8. <property name="entityManagerFactory" ref="entityManagerFactory" />
  9. </bean>
  10. <tx:annotation-driven transaction-manager="transactionManager" />

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

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <persistence xmlns="http://java.sun.com/xml/ns/persistence"
  3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4. xsi:schemaLocation="http://java.sun.com/xml/ns/persistence
  5. http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd" version="1.0">
  6. <persistence-unit name="Test_PU" transaction-type="RESOURCE_LOCAL">
  7. <!-- provider>org.eclipse.persistence.jpa.PersistenceProvider</provider-->
  8. <provider>org.hibernate.ejb.HibernatePersistence</provider>
  9. <!-- MYSql 的连接-->
  10. <properties>
  11. <property name="hibernate.connection.driver_class" value="com.mysql.jdbc.Driver" />
  12. <property name="hibernate.connection.url" value="jdbc:mysql://localhost:3306/tester?useUnicode=true&characterEncoding=utf-8" />
  13. <property name="hibernate.connection.username" value="tester" />
  14. <property name="hibernate.connection.password" value="tester" />
  15. <property name="hibernate.connection.provider_class" value="org.hibernate.connection.C3P0ConnectionProvider"/>
  16. <property name="hibernate.c3p0.max_size" value="100"/>
  17. <property name="hibernate.c3p0.min_size" value="20"/>
  18. <property name="hibernate.c3p0.timeout" value="120"/>
  19. <property name="hibernate.c3p0.max_statements" value="0"/>
  20. <property name="hibernate.c3p0.idle_test_period" value="120"/>
  21. <property name="hibernate.c3p0.acquire_increment" value="5 "/>
  22. <property name="hibernate.cache.provider_class" value="org.hibernate.cache.EhCacheProvider"/>
  23. <property name="hibernate.cache.use_query_cache" value="false"/>
  24. <property name="hibernate.show_sql" value="false"/>
  25. <property name="hibernate.useUnicode" value="true"/>
  26. <property name="hibernate.characterEncoding" value="utf8"/>
  27. </properties>
  28. </persistence-unit>
  29. </persistence>

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

  1. //此处定义为全部的服务方法都由事物控制
  2. @Transactional
  3. @Service("com.alcor.test.service.TestaService")
  4. public class TestaService {
  5. /**
  6. * Logger for this class
  7. */
  8. private static final Logger logger = Logger.getLogger(TestaService.class);
  9. @Autowired
  10. private EchoService echoService;
  11. @PersistenceContext
  12. EntityManager em;
  13. //覆盖默认的事物配置
  14. @Transactional(propagation = Propagation.NOT_SUPPORTED, readOnly = true)
  15. public Testa findByID(TestaPK id) {
  16. if (logger.isDebugEnabled()) {
  17. logger.debug("findByID(TestaPK) - start");
  18. }
  19. logger.debug(id.getId()+"|"+id.getName());
  20. Testa returnTesta = em.find(Testa.class, id);
  21. if (logger.isDebugEnabled()) {
  22. logger.debug("findByID(TestaPK) - end");
  23. }
  24. return returnTesta;
  25. }
  26. //使用了默认的事物机制
  27. public void add(){
  28. if (logger.isDebugEnabled()) {
  29. logger.debug("add() - start");
  30. }
  31. //保存A表
  32. Testa testa = new Testa();
  33. TestaPK testaPK = new TestaPK();
  34. testaPK.setId(UUID.randomUUID().toString());
  35. testaPK.setName(UUID.randomUUID().toString());
  36. testa.setId(testaPK);
  37. em.persist(testa);
  38. //保存B表
  39. Testb testb = new Testb();
  40. testb.setId(UUID.randomUUID().toString());
  41. em.persist(testb);
  42. //调用一个autowired 的service
  43. echoService.doNothing();
  44. if (logger.isDebugEnabled()) {
  45. logger.debug("add() - end");
  46. }
  47. }
  48. /**
  49. * 通过使用JPQL 来做查询
  50. */
  51. @Transactional(propagation = Propagation.NOT_SUPPORTED, readOnly = true)
  52. public List<Testa> findAllBySex (){
  53. if (logger.isDebugEnabled()) {
  54. logger.debug("findAllBySex() - start");
  55. }
  56. String queryString = "SELECT a FROM Testa a WHERE a.age < :age AND a.id.name like :name";
  57. Query query = em.createQuery(queryString);
  58. query.setParameter("name", "%xv%");
  59. query.setParameter("age", 20);
  60. List<Testa> results = query.getResultList();
  61. if (logger.isDebugEnabled()) {
  62. logger.debug("findAllBySex() - end");
  63. }
  64. return results;
  65. }
  66. }

总结

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在不同的框架环境下有不同的配置方式,但具体的步骤如下:

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
  3. "http://mybatis.org/dtd/mybatis-3-config.dtd">
  4. <configuration>
  5. <environments default="development">
  6. <environment id="development">
  7. <transactionManager type="JDBC" />
  8. <dataSource type="POOLED">
  9. <property name="driver" value="com.mysql.jdbc.Driver" />
  10. <property name="url" value="jdbc:mysql://localhost:3306/hlp?useUnicode=true&amp;characterEncoding=UTF-8&amp;zeroDateTimeBehavior=convertToNull" />
  11. <property name="username" value="root" />
  12. <property name="password" value="1234" />
  13. </dataSource>
  14. </environment>
  15. </environments>
  16. <mappers>
  17. <mapper resource="com/mybatis/config/UserDaoMapper.xml"/>
  18. </mappers>
  19. </configuration>
  1. package com.mybatis.config;
  2. public class User {
  3. private int userId;
  4. private String userName;
  5. private String password;
  6. private String comment;
  7. //省略get/set方法
  8. }
  1. package com.mybatis.config;
  2. import java.util.List;
  3. public interface UserDao {
  4. public int insert(User user);
  5. public int update(User user);
  6. public int delete(String userName);
  7. public List<User> selectAll();
  8. public int countAll();
  9. public User findByUserName(String userName);
  10. }
  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  3. <mapper namespace="com.mybatis.config.UserDao">
  4. <select id="countAll" resultType="int">
  5. select count(*) c from user;
  6. </select>
  7. <select id="selectAll" resultType="com.mybatis.config.User">
  8. select * from user order by userName asc
  9. </select>
  10. <insert id="insert" parameterType="com.mybatis.config.User">
  11. insert into user(userName,password,comment) values(#{userName},#{password},#{comment})
  12. </insert>
  13. <update id="update" parameterType="com.mybatis.config.User">
  14. update user set userName=#{userName},password=#{password},comment=#{comment} where userName=#{userName}
  15. </update>
  16. <delete id="delete" parameterType="int">
  17. delete from user where userName=#{userName}
  18. </delete>
  19. <select id="findByUserName" parameterType="String" resultType="com.mybatis.config.User">
  20. select * from user where userName=#{userName}
  21. </select>
  22. </mapper>
  1. package com.mybatis.config;
  2. import java.io.Reader;
  3. import java.util.Iterator;
  4. import java.util.List;
  5. import org.apache.ibatis.io.Resources;
  6. import org.apache.ibatis.session.SqlSession;
  7. import org.apache.ibatis.session.SqlSessionFactory;
  8. import org.apache.ibatis.session.SqlSessionFactoryBuilder;
  9. import org.junit.Test;
  10. public class UserDaoTest {
  11. @Test
  12. public void userDaoTest() throws Exception
  13. {
  14. String resource = "MyBatis-Configuration.xml";
  15. Reader reader = Resources.getResourceAsReader(resource);
  16. SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
  17. SqlSessionFactory factory = builder.build(reader);
  18. SqlSession session = factory.openSession();
  19. UserDao userDao = session.getMapper(UserDao.class);
  20. User user = new User();
  21. user.setUserName("hongye");
  22. user.setPassword("123456");
  23. user.setComment("备注");
  24. userDao.insert(user);
  25. System.out.println("记录条数:"+userDao.countAll());
  26. List<User> users = userDao.selectAll();
  27. Iterator<User> iter = users.iterator();
  28. while(iter.hasNext()){
  29. User u = iter.next();
  30. System.out.println("用户名:"+u.getUserName()+"密码:"+u.getPassword());
  31. }
  32. user.setComment("comment");
  33. userDao.update(user);
  34. User u = userDao.findByUserName("hongye");
  35. System.out.println(u.getComment());
  36. userDao.delete("hongye");
  37. System.out.println("记录条数:"+userDao.countAll());
  38. session.commit();
  39. session.close();
  40. }
  41. }

与Spring整合方案

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

  1. <!-- mybatis -->
  2. <dependency>
  3. <groupId>org.mybatis</groupId>
  4. <artifactId>mybatis</artifactId>
  5. <version>3.2.3</version>
  6. </dependency>
  7. <dependency>
  8. <groupId>org.mybatis</groupId>
  9. <artifactId>mybatis-spring</artifactId>
  10. <version>1.2.1</version>
  11. </dependency>
  1. <!-- MyBatis配置 -->
  2. <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
  3. <property name="dataSource" ref="dataSource" />
  4. <!-- 自动扫描entity目录, 省掉Configuration.xml里的手工配置 -->
  5. <property name="typeAliasesPackage" value="org.springside.examples.showcase.entity" />
  6. <!-- 显式指定Mapper文件位置 -->
  7. <property name="mapperLocations" value="classpath:/mybatis/*Mapper.xml" />
  8. </bean>
  9. <!-- 扫描basePackage下所有以@MyBatisRepository标识的 接口-->
  10. <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
  11. <property name="basePackage" value="org.springside.examples.showcase" />
  12. <property name="annotationClass" value="org.springside.examples.showcase.repository.mybatis.MyBatisRepository"/>
  13. </bean>
  1. //通过@MapperScannerConfigurer扫描目录中的所有接口,动态在Spring Context中生成实现.
  2. @MyBatisRepository
  3. public interface UserMybatisDao {
  4. User get(Long id);
  5. List<User> search(Map<String, Object> parameters);
  6. void save(User user);
  7. void delete(Long id);
  8. }
  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  3. "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  4. <!-- namespace必须指向Dao接口 -->
  5. <mapper namespace="org.springside.examples.showcase.repository.mybatis.UserMybatisDao">
  6. <!--
  7. 获取用户: 输出直接映射到对象, login_name列要"as loginName"以方便映射 ,team_id as "team.id"创建team对象并赋值
  8. -->
  9. <select id="get" parameterType="int" resultType="User">
  10. select id, name, email,
  11. login_name as loginName,
  12. team_id as "team.id"
  13. from ss_user
  14. where id=#{id}
  15. </select>
  16. <!-- 查询用户,演示: 1.输入用map传入多个参数 2.<where>语句, 智能添加where和and关键字 3.输出直接映射对象 -->
  17. <select id="search" parameterType="map" resultType="User">
  18. select id, name, email,
  19. login_name as loginName,
  20. team_id as "team.id"
  21. from ss_user
  22. <where>
  23. <if test="loginName != null">
  24. login_name=#{loginName}
  25. </if>
  26. <if test="name != null">
  27. and name=#{name}
  28. </if>
  29. </where>
  30. </select>
  31. <!-- 插入用户: 1.由数据库生成id并赋值到user对象 2.输入用对象, 嵌套属性表达式#{team.id} -->
  32. <insert id="save" parameterType="User" useGeneratedKeys="true" keyProperty="id">
  33. insert into ss_user (
  34. login_name, name, password, email, team_id)
  35. values (
  36. #{loginName}, #{name}, #{password}, #{email},
  37. #{team.id})
  38. </insert>
  39. <!-- 删除用户 -->
  40. <delete id="delete" parameterType="int">
  41. delete from ss_user where id=#{id}
  42. </delete>
  43. </mapper>
  1. @DirtiesContext
  2. @ContextConfiguration(locations = { "/applicationContext.xml" })
  3. public class UserMybatisDaoTest extends SpringTransactionalTestCase {
  4. @Autowired
  5. private UserMybatisDao userDao;
  6. @Test
  7. public void getUser() throws Exception {
  8. User user = userDao.get(1L);
  9. assertNotNull("User not found", user);
  10. assertEquals("admin", user.getLoginName());
  11. }
  12. @Test
  13. public void searchUser() throws Exception {
  14. Map<String, Object> parameter = Maps.newHashMap();
  15. parameter.put("name", "管理员");
  16. List<User> result = userDao.search(parameter);
  17. assertEquals(1, result.size());
  18. assertEquals("admin", result.get(0).getLoginName());
  19. }
  20. @Test
  21. public void createAndDeleteUser() throws Exception {
  22. // create
  23. int count = countRowsInTable("ss_user");
  24. User user = UserData.randomUser();
  25. userDao.save(user);
  26. Long id = user.getId();
  27. assertEquals(count + 1, countRowsInTable("ss_user"));
  28. User result = userDao.get(id);
  29. assertEquals(user.getLoginName(), result.getLoginName());
  30. // delete
  31. userDao.delete(id);
  32. assertEquals(count, countRowsInTable("ss_user"));
  33. assertNull(userDao.get(id));
  34. }
  35. }

总结

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

添加新批注
在作者公开此批注前,只有你和作者可见。
回复批注