Spring Data JPA 与 MyBatisPlus的比较

1 前言

JPA（Java Persistence API）和MyBatis Plus是两种不同的持久化框架，它们具有不同的特点和适用场景。

JPA是Java官方的持久化规范，它提供了一种基于对象的编程模型，可以通过注解或XML配置来实现对象与数据库的映射关系。JPA的优点是可以对数据库进行更高级的操作，如查询、更新、删除等，同时也支持事务管理和缓存机制，能够更好地支持复杂的业务逻辑。

MyBatis Plus (MPP) 是在MyBatis基础上进行封装的增强版本，它提供了更简单易用的API和更高效的性能。MyBatis Plus通过XML或注解的方式来配置数据库映射关系，并提供了丰富的查询、更新、删除操作的方法。相对于JPA，MyBatis Plus配置简单、易于上手，同时也灵活性较高，能够更好地满足项目的特定需求。

如果只是针对单表的增删改查，两者十分相似，本质上都算ORM框架，那么到底什么时候适合用JPA，什么时候用MyBatisPlus，下面做下这两者的详细对比。

2 POM依赖

  • JPA
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
  • MPP
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
</dependency>

3 Entity定义

  • JPA
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;
import javax.persistence.GeneratedValue;

@Entity
@Table(name = "dept")
public class Dept {
	@Id
	@Column(name = "id")
	@GeneratedValue(strategy = GenerationType.AUTO)
	private Long id;
	
	@Column(name = "code")
	private String code;
	
	@Column(name = "name")
	private String name;
}
  • MPP
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;

@TableName(value = "dept")
public class Dept {
    @TableId(value = "id", type = IdType.AUTO)
    private Long id;

    @TableField(value = "code")
    private String code;

    @TableField(value = "name")
    private String name;
}

4 DAO基类

  • JPA
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface DeptRepository extends JpaRepository<Dept, Long> {
}
  • MPP
import org.apache.ibatis.annotations.Mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;

@Mapper
public interface DeptMapper extends BaseMapper<Dept> {
}

4.1 基类主要方法

方法 JpaRepository MPP BaseMapper
插入一条记录 save(T entity) insert(T entity)
插入多条记录 saveAll(Iterable<T> entities) insertBatchSomeColumn(List<T> entityList)
根据 ID 删除 deleteById(ID id) deleteById(Serializable id)
根据实体(ID)删除 delete(T entity) deleteById(T entity)
根据条件删除记录 - delete(Wrapper<T> queryWrapper)
删除（根据ID或实体 批量删除） deleteAllById(Iterable<? extends ID> ids) deleteBatchIds(Collection<?> idList)
根据 ID 修改 save(T entity) updateById(T entity)
根据条件更新记录 - update(Wrapper<T> updateWrapper)
根据 ID 查询 findById(ID id) selectById(Serializable id)
查询（根据ID 批量查询） findAllById(Iterable<ID> ids) selectBatchIds(Collection<? extends Serializable> idList)
根据条件查询一条记录 - selectOne(Wrapper<T> queryWrapper)
根据条件判断是否存在记录 exists(Example<T> example) exists(Wrapper<T> queryWrapper)
根据条件查询总记录数 count(Example<T> example) selectCount(Wrapper<T> queryWrapper)
根据条件查询全部记录 findAll(Example<T> example, Sort sort) selectList(Wrapper<T> queryWrapper)
根据条件查询分页记录 findAll(Example<T> example, Pageable pageable) selectPage(P page, Wrapper<T> queryWrapper)

4.2 Example、Specification VS Wrapper

JPA使用Example和Specification 类来实现范本数据的查询，而MPP使用QueryWrapper来设置查询条件

4.2.1 JPA Example

Dept dept = new Dept();
dept.setCode("100");
dept.setName("Dept1");

// select * from dept where code = '100' and name = 'Dept1';
List<Dept> deptList = deptRepository.findAll(Example.of(dept));

默认是生成的条件都是 “=”，如果要设置其他比较符，需要使用ExampleMatcher

Dept dept = new Dept();
dept.setCode("100");
dept.setName("Dept1");

// select * from dept where code like '100%' and name like '%Dept1%';
List<Dept> deptList = deptRepository.findAll(Example.of(dept, ExampleMatcher.matching()
                .withMatcher("code", ExampleMatcher.GenericPropertyMatchers.startsWith())
                .withMatcher("name", ExampleMatcher.GenericPropertyMatchers.contains())));

4.2.2 JPA Specification

Example仅能实现对字符串类型的匹配模式，如果要设置其他类型的字段，可以实现JpaSpecificationExecutor接口来完成：

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.stereotype.Repository;

@Repository
public interface DeptRepository extends JpaRepository<Dept, Long>, JpaSpecificationExecutor<Dept>  {
}

增加以上接口后，会增加以下查询方法：

  • findOne(Specification spec)
  • findAll(Specification spec)
  • findAll(Specification spec, Pageable pageable)
  • count(Specification spec)
  • exists(Specification spec)

使用示例：

Dept dept = new Dept();
dept.setCode("100");
dept.setName("Dept1");

// select * from dept where code like '100%' and name like '%Dept1%';
Specification<Dept> spec = new Specification<Dept>() {
   @Override
   public Predicate toPredicate(Root<Dept> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
       List<Predicate> predicates = new ArrayList<>();
       predicates.add(cb.like(root.get("code"), dept.getCode() + "%"));
       predicates.add(cb.like(root.get("code"), '%' + dept.getCode() + "%"));
       return query.where(predicates.toArray(new Predicate[predicates.size()])).getRestriction();
    }
};
List<Dept> deptList = deptRepository.findAll(Example.of(dept));

除了equal、notEqual, 针对日期、数字类型，还有gt、ge、lt、le等常用比较符。

4.2.3 MPP Wrpper

MPP Wrapper类似于JPA的CriteriaBuilder，不过用法上更加便捷：

Dept dept = new Dept();
dept.setCode("100");
dept.setName("Dept1");

// select * from dept where code = '100' and name = 'Dept';
Wrapper<Dept> wrapper = Wrappers.lambdaQueryWrapper(detp);
List<Dept> deptList = deptRepository.selectList(wrapper);

默认是生成的条件都是 “=”，如果要设置其他比较符，需要单独设置Wrapper：

Dept dept = new Dept();
dept.setCode("100");
dept.setName("Dept1");

// select * from dept where code like '100%' and name like '%Dept1%';
Wrapper<Dept> wrapper = Wrappers.<Dept>lambdaQueryWrapper()
                        .likeRight(Dept::getCode, dept.getCode)
                        .like(Dept::getName, dept.getName);
List<Dept> deptList = deptRepository.selectList(wrapper);

4.2.4 JPA Specification 与 MPP Wrpper的方法汇总

方法 JPA Specification MPP Wrpper
等于 = equal eq
不等于 <> notEqual ne
大于 > greaterThan, gt gt
大于等于 >= greaterThanOrEqualTo, ge ge
小于 < lessThan, lt lt
小于等于 <= lessThanOrEqualTo, le le
BETWEEN 值1 AND 值2 between between
NOT BETWEEN 值1 AND 值2 - notBetween
LIKE ‘%值%’ like like
NOT LIKE ‘%值%’ notLike notLike
LIKE ‘%值’ like likeLeft
LIKE ‘值%’ like likeRight
NOT LIKE ‘%值’ notLike notLikeLeft
NOT LIKE ‘值%’ notLike notLikeRight
字段 IS NULL isNull isNull
字段 IS NOT NULL isNotNull isNotNull
字段 = true isTrue -
字段 = false isFalse -
字段 IN (v0, v1, …) in in
字段 NOT IN (v0, v1, …) - notIn
排序：ORDER BY 字段, … ASC asc orderByAsc
排序：ORDER BY 字段, … DESC desc orderByDesc
排序：ORDER BY 字段, … orderBy(CriteriaQuery) orderBy
拼接 OR or or
AND 嵌套 and and
正常嵌套 不带 AND 或者 OR - nested
拼接 sql - apply
无视优化规则直接拼接到 sql 的最后 - last
拼接 EXISTS ( sql语句 ) exists exists
拼接 NOT EXISTS ( sql语句 ) - notExists
去重 distinct(CriteriaQuery) -
设置查询字段 select, multiselect(CriteriaQuery) select
分组：GROUP BY 字段, … groupBy(CriteriaQuery) groupBy
SQL SET 字段 - set
设置 SET 部分 SQL - setSql
字段自增变量 val 值 - setIncrBy
字段自减变量 val 值 - setDecrBy
条件判断 selectCase -
平均值 avg -
加和 sum, sumAsLong, sumAsDouble -
计数 count, countDistinct -
最大值 max, greatest -
最小值 min, least -
取反 neg -
绝对值 abs -
Product prod -
差值 diff -
求商 quot -
取模 mod -
开根号 sqrt -
转换类型 toLong, toInteger, toFloat, toDouble, toBigDecimal, toBigInteger, toString -
集合是否为空 isEmpty, isNotEmpty -
集合大小 size -
是否包含 isMember, isNotMember -
键值对 keys, values -
字符串拼接 concat -
字符串分隔 substring -
去空白 trim -
大小写转换 upper, lower -
字符串长度 length -
空处理 nullif, coalesce -

5 DAO子类

5.1 JPA Repository方法命名规范

JPA支持接口规范方法名查询，一般查询方法以 find、findBy、read、readBy、get、getBy为前缀，JPA在进行方法解析的时候会把前缀取掉，然后对剩下部分进行解析。例如：

@Repository
public interface DeptRepository extends JpaRepository<Dept, Long> {
    
    // 调用此方法时，会自动生成 where code = ? 的条件
	Dept getByCode(String code);
}

常用的方法命名有：

关键字 方法命名 sql条件
Distinct findDistinctByLastnameAndFirstname select distinct …​ where x.lastname = ?1 and x.firstname = ?2
And findByNameAndPwd where name= ? and pwd =?
Or findByNameOrSex where name= ? or sex=?
Is,Equals findById, findByIdIs, findByIdEquals where id= ?
Between findByIdBetween where id between ? and ?
LessThan findByIdLessThan where id < ?
LessThanEquals findByIdLessThanEquals where id <= ?
GreaterThan findByIdGreaterThan where id > ?
GreaterThanEquals findByIdGreaterThanEquals where id > = ?
After findByIdAfter where id > ?
Before findByIdBefore where id < ?
IsNull findByNameIsNull where name is null
isNotNull,NotNull findByNameNotNull where name is not null
Like findByNameLike where name like ?
NotLike findByNameNotLike where name not like ?
StartingWith findByNameStartingWith where name like ‘?%’
EndingWith findByNameEndingWith where name like ‘%?’
Containing findByNameContaining where name like ‘%?%’
OrderBy findByIdOrderByXDesc where id=? order by x desc
Not findByNameNot where name <> ?
In findByIdIn(Collection<?> c) where id in (?)
NotIn findByIdNotIn(Collection<?> c) where id not in (?)
True findByEnabledTue where enabled = true
False findByEnabledFalse where enabled = false
IgnoreCase findByNameIgnoreCase where UPPER(name)=UPPER(?)
First,Top findFirstByOrderByLastnameAsc order by lastname limit 1
FirstN,TopN findTop3ByOrderByLastnameAsc order by lastname limit 3

5.2 MPP自定义方法 + 接口默认实现

MyBatisPlus没有JPA那样可以根据接口的方法名自动组装查询条件，但是可以利用Java8的接口默认实现来达到同样的目的，只不过需要编写少量的代码：

import org.apache.ibatis.annotations.Mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;

@Mapper
public interface DeptMapper extends BaseMapper<Dept> {
    default Dept getByCode(String code) {
		return selectOne(Wrappers.<Dept>lambdaWrapper().eq(Dept::getCode, code));
	}
}

6 自定义SQL

JPA支持通过@Query注解和XML的形式实现自定义SQL，而MyBatis支持通过@Select、@Delete、@Update、@Script注解和XML的形式实现自定义SQL。

6.1 JPA

JPA的自定义SQL分为JPQL(Java Persistence Query Language Java 持久化查询语言)和原生SQL两种。
JPQL:

import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;

@Repository
public interface DeptRepository extends JpaRepository<Dept, Long> {
    @Query(value = "select d from Dept d where d.code = ?1")
	Dept getByCode(String code);

    @Modifying
    @Query(value = "delete from Dept d where d.code = :code")
    int deleteByCode(@Param("code") String code);
}

原生SQL

import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;

@Repository
public interface DeptRepository extends JpaRepository<Dept, Long> {
    @Query(value = "SELECT * FROM dept WHERE name = ?1", countQuery = "SELECT count(*) FROM dept WHERE name = ?1", nativeQuery = true)
    Page<Dept> findByName(@Param("name") String name, Pageable pageable);
}

XML形式：
/resource/META-INFO/orm.xml

<named-query name="Dept.getByCode">
  <query> select d from Dept d where d.code = ?1</query>
</named-query>
<named-native-query name="Dept.deleteByCode">
  <query> DELETE FROM dept WHERE code = ?1</query>
</named-native-query>

6.2 MyBatis

JPA的自定义SQL分为注解形式和XML形式
注解形式:

import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.core.metadata.IPage;

@Mapper
public interface DeptMapper extends BaseMapper<Dept> {
    @Select(value = "SELECT * FROM dept WHERE code = #{code}")
	Dept getByCode(@Param("code") String code);

    @Delete("DELETE FROM dept WHERE code = #{code}")
    int deleteByCode(@Param("code") String code);
    
    @Select(value = "SELECT * FROM dept WHERE name = #{name}")
    IPage<Dept> findByName(@Param("name") String name, IPage<Dept> page);
}

XML形式：
/resource/mapper/DeptMapper.xml

<mapper namespace="DeptMapper">
	<select id = "getByCode", resultType = "Dept">
		SELECT * FROM dept WHERE code = #{code}
	</select>
	<delete id = "deleteByCode">
		DELETE FROM dept WHERE code = #{code}
	</select>
	<select id = "findByName">
		SELECT * FROM dept WHERE name = #{name}
	</select>
</mapper>

7 表关联

待补充

8 其他

对于简单的CRUD操作，JPA和MPP都提供了丰富的API简化开发人员的操作，但是有些差异化的地方需要总结下：

比较点 JPA MPP
成熟度 JPA毕竟是javax标准，成熟度自然高 MyBatis成熟度也很高，但是MPP毕竟是国内个人维护，质量和成熟度相对还是比较低的，但是使用起来更加适配国内开发者的习惯
自动DDL JPA可以根据Entity的定义自动更新实际数据库的DDL, 使用起来比较便利 利用MPP的脚本自动维护或Flyway进行SQL脚本的自动执行
实体关系 使用@OneToMany、@OneToOne、@ManyTo@Many注解描述表与表之间的关联，查询时自动进行表的关联，并且支持更新和删除时自动级联到关联的实体 使用<association>和<collection>标签以及@One、@Many注解来映射结果集和Java对象，只支持查询，不支持更新和删除, 另外还有一个MyBatis-Plus-Join项目, 可以实现Java中表Join的操作。
复杂SQL查询 不太方便 使用xml结构化语言 + 动态SQL 标签 可以实现非常复杂的SQL场景
数据库差异 使用自带的API和JPQL的话，是不用关心具体用什么数据库，但是用原生SQL的话无法解决数据库的差异 使用自带API的话，基本上不需要关注数据库的差异，如果切换了不同类型的数据库，通过配置databaseIdProvider 就可以根据当前使用数据库的不同选择不同的SQL脚本
学习曲线 较为难，主要是思路的转变，使用JPA更加关注的是实体间的关系，表的结构会根据实体关系自动维护 对于传统的关系型数据库的操作，MyBatisPlus可以与JQuery操作DOM元素那么顺手

9 个人建议

目前对比下来整体的感觉是JPA侧重数据建模，关注数据一致性，屏蔽SQL操作，MyBatis侧重构建灵活的SQL，而MyBatisPlus在MyBatis的基础上较少了日常的CRUD操作，JPA更适合事务性系统，MyBatisPlus更适合做分析型系统。

个人是从SQL -> MyBatis -> MyBatisPlus的路线过来的，所以更习惯与用MPP解决数据的问题，在使用MPP的过程中，越来越发现自定义SQL用到越来越少，大部分场景下是可以用MPP的API组合来实现的，即便是MPP不支持多表关联，通过抽象视图的形式，也能达到单表查询的效果，只有在极限、特别复杂的情况下才会写SQL。

这么看来，其实JPA也是能满足日常的开发需求的。但是从传统SQL向JPA的转变是需要一个过程的，就跟面向过程开发到面向对象的开发，是需要一个大的开发思维一个转变，可能需要在项目的实践中不断体会和适应。

posted @ 2024-10-24 15:39  CharyGao  阅读(135)  评论(0)  编辑  收藏  举报