JAVA ORM框架学习

版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
本文链接:https://blog.csdn.net/liuyingan/article/details/84916002
根据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);
}
使用方法
使用步驟
声明持久层的接口,该接口继承 Repository,Repository 是一个标记型接口,它不包含任何方法,当然如果有需要,Spring Data 也提供了若干 Repository 子接口,其中定义了一些常用的增删改查,以及分页相关的方法。
在接口中声明需要的业务方法。Spring Data 将根据给定的策略(具体策略稍后讲解)来为其生成实现代码。
在 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 类型):

先判断 userAddressZip (根据 POJO 规范,首字母变为小写,下同)是否为 AccountInfo 的一个属性,如果是,则表示根据该属性进行查询;如果没有该属性,继续第二步;
从右往左截取第一个大写字母开头的字符串(此处为 Zip),然后检查剩下的字符串是否为 AccountInfo 的一个属性,如果是,则表示根据该属性进行查询;如果没有该属性,则重复第二步,继续从右往左截取;最后假设 user 为 AccountInfo 的一个属性;
接着处理剩下部分( 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<String> userList) ,方法的参数可以是 Collection 类型,也可以是数组或者不定长参数;
NotIn --- 等价于 SQL 中的 "not in",比如 findByUsernameNotIn(Collection<String> 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="......."/>
<jpa:repositories > 提供了一个 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的比较

作者:Caos
链接:https://www.jianshu.com/p/61724b0989e1
來源:简书
著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。
展开阅读全文

轻量级Java ORM框架JDBC ORM Framework (Jorm)

09-29

[b]> 特点[/b]rn 1.支持多数据源管理和配置rn 2.自动封装Entityrn 3.支持事务rn 4.支持存储过程的方便调用rn 5.支持lazy加载rn 6.支持分页查询rn 7.支持多种数据库H2,MySQL,Oracle,PostgrSQL,SQLServerrnrn[b]> 要求[/b]rn 1.JDK 1.5 or laterrn 2.如需要lazy加载,需要引入cglib或javaassit,具体可配置rnrn[b]> 示例[/b]rn 1.添加rn Session session = Jorm.getSession();rn User u = new User("Gerald.Chen", "男", 21, "job");;rn session.save(u);rnrn 2.删除rn session.clean(User.class);// 清空表rn session.delete(User.class, "id > 100");// 指定条件删除rnrn session.delete(user);rnrn 3.查询rn User user = session.read(User.class, 1);// 根据主键加载rnrn // 加载第一个rn User user = session.loadFirst(User.class, "(SELECT * FROM t_user WHERE id > ?)", 88);rnrn // 分页查询rn SqlParams params = new SqlParams("SELECT * FROM t_user WHERE id > ?", new Object[] 6 );rn params.setObjectClass(User.class);rn params.setFirstResult(3);rn params.setMaxResults(10);rn List users = session.list(params);rnrn // 查询单个属性rn String sql = "SELECT name FROM t_user WHERE id = 28";rn String name = session.queryUniqueObject(sql);rnrn // 查询属性列表rn List names = session.list(String.class, "SELECT name FROM t_user WHERE id > ?", 200);rn List ages = session.list(int.class, "SELECT age FROM t_user WHERE age > 18");rnrn 4.存储过程rn final String pro = "? = call hello_proc(?)";rn String r = session.call(new ProcedureCaller() rn rn public CallableStatement prepare() throws SQLException rn CallableStatement cs = this.getSession().getConnection().prepareCall(pro);rn cs.setString(2, "World");rn cs.registerOutParameter(1, Types.CHAR);rn return cs;rn rn rn public String callback(CallableStatement cs) throws SQLException rn cs.execute();rn return cs.getString(1);rn rn );rnrn 5.事务rn session.clean(User.class);rn User u;rn session.beginTransaction();rn try rn for(int i = 0; i < 1000; i++) rn String sex = (i % 2 == 0 ? "男" : "女");rn u = new User(Strings.fixed(6), sex, Numbers.random(100), Strings.random(16));rn session.save(u);rn if(i == 886) rn Integer.parseInt("kkk");rn rn rn session.commit();rn catch (Exception e) rn session.rollback();rn finally rn session.endTransaction();rn rnrn这是一个完全基于JDBC的轻量java orm framework, 目标定位于使用方便,简单,后续会增加许多新的特性rnrn项目地址:[url=http://javaclub.sourceforge.net/jorm.html]http://javaclub.sourceforge.net/jorm.html[/url]rn下载地址:[url=http://sourceforge.net/projects/javaclub/files/jorm]http://sourceforge.net/projects/javaclub/files/jorm/[/url]rnrnrnrnSimple CRUDrn[url=http://www.oschina.net/code/snippet_151926_6316]http://www.oschina.net/code/snippet_151926_6316[/url]rnrn处理特殊字段rn[url=http://www.oschina.net/code/snippet_151926_6355]http://www.oschina.net/code/snippet_151926_6355[/url]rnrn处理多个Oracle存储过程返回的游标rn[url=http://www.oschina.net/code/snippet_151926_6356]http://www.oschina.net/code/snippet_151926_6356[/url]rnrnrn 论坛

没有更多推荐了,返回首页