# mybatis-plus-jpa-support

**Repository Path**: mybatis-plus-support/mybatis-plus-jpa-support

## Basic Information

- **Project Name**: mybatis-plus-jpa-support
- **Description**: 让 MybatisPlus拥有像Jpa一样的直接在mapper接口中定义方法名（如 findByUserNameOrderByCreatedAsc）查询的能力（无需配置xml）
- **Primary Language**: Java
- **License**: Apache-2.0
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2025-07-09
- **Last Updated**: 2025-08-13

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

## 介绍
让 _MybatisPlus_ 拥有像 _Jpa_ 一样的直接在 _mapper_ 接口中定义方法名（如 _findByUserNameOrderByCreatedAsc_ ）查询的能力（无需配置xml）

## 适用场景
假设有一个简单的场景，根据姓名查询用户并按照创建时间排序，如果用 _mybatisplus_ 来写的话，需要用下面的代码来完成：

```java
LambdaQueryWrapper<SysUser> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.orderByAsc(SysUser::getCreated);
lambdaQueryWrapper.like(SysUser::getUserName, "赵");
mapper.selectList(lambdaQueryWrapper);
```
但是如果用 _Jpa_ 来实现，代码就很简单了，只需要在 _Repository接口_ 定义下面的方法，在 _service_ 里直接就可以调用：

```Java
List<SysUser> findByUserNameOrderByCreatedAsc(String userName);
```
所以说，在某些场景下， _Jpa_ 确实是比 _MybatisPlus_ 更简单实用的。为了让 _Mybatisplus_ 拥有 _Jpa_ 的能力，你的项目中非常需要 _mybatis-plus-jpa-support_ !!!

##  _Maven_ 引用[点击此处查看最新版本号](https://central.sonatype.com/artifact/com.xiaoyudeguang/mybatis-plus-jpa-support)

```xml
<dependency>
    <groupId>com.xiaoyudeguang</groupId>
    <artifactId>mybatis-plus-jpa-support</artifactId>
    <version>${最新版本号}</version>
</dependency>
```

## 使用教程

1.  启动类声明 _@EnableMybatisJpaSupport_ 注解

```java
import com.xiaoyudeguang.annotation.EnableMybatisJpaSupport;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@MapperScan(basePackages = {"com.**.mapper"})
@EnableMybatisJpaSupport(basePackages = {"com.**.mapper"})
@SpringBootApplication
public class StartApp {

    public static void main(String[] args) {
        SpringApplication.run(StartApp.class, args);
    }
}
```

2.  所有 _mapper_ 接口的 _@Mapper_ 注解都要替换为 _@com.xiaoyudeguang.support.annotation.JpaMapper_ 注解

```java
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.xiaoyudeguang.annotation.JpaMapper;

import java.util.List;

@JpaMapper
public interface SysUserMapper extends BaseMapper<SysUser> {

    List<SysUser> findByUserNoAndUserNameLike(String userNo, String userName);

    List<SysUser> findAllOrderByUserNoDesc(String userName);

    List<SysUser> findByUserNameLikeOrderByUserNoDesc(String userName);

    long countByUserName(String userName);

    List<SysUser> findByUserNameLike(String userName);

    List<SysUser> findByUserNameStartingWith(String userName);

    List<SysUser> findByUserNameContaining(String userName);

    void deleteByUserName(String userName);
}
```

3.  在 _Service_ 中使用


```java
import com.example.mapper.SysUserMapper;
import com.example.model.SysUser;
import jakarta.annotation.Resource;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class UserServiceImpl {

    //注意，这里如果使用@Autowired注解，必须用@Qualifier("sysUserRepository")显示声明
    @Resource
    private SysUserMapper sysUserRepository;

    @Override
    public List<SysUser> testJpa(String userNo, String userName) {
        sysUserRepository.findByUserNoAndUserNameLike(userNo, userName);
        sysUserRepository.findByUserNameLike("findByUserNameLike");
        sysUserRepository.findAllOrderByUserNoDesc("findAllOrderByUserNoDesc");
        sysUserRepository.findByUserNameLikeOrderByUserNoDesc("findByUserNameLikeOrderByUserNoDesc");
        sysUserRepository.findByUserNameStartingWith("findByUserNameStartingWith");
        sysUserRepository.findByUserNameContaining("findByUserNameContaining");
        sysUserRepository.countByUserName("countByUserName");
        sysUserRepository.deleteByUserName("deleteByUserName");
        return List.of();
    }
}
```
4. 通过继承抽象层 _AbstractServiceImpl_ 类的来简化注入过程

```java
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.xiaoyudeguang.annotation.JpaMapper;
import com.xiaoyudeguang.web.mapper.AbstractMapper;
import com.xiaoyudeguang.web.service.AbstractService;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.util.StringUtils;

/**
 * AbstractServiceImpl类可以直接复制到项目中当做Service层的抽象类
 */
public abstract class AbstractServiceImpl<M extends BaseMapper<T>, T> extends ServiceImpl<M, T> implements AbstractService<M, T>, InitializingBean {

    @Autowired
    private M baseMapper;

    protected M mapper;
    @Autowired
    protected ApplicationContext context;

    @Override
    @SuppressWarnings("unchecked")
    public void afterPropertiesSet() throws Exception {
        mapper = baseMapper;
        Class<?> mapperClass = baseMapper.getClass().getInterfaces()[0];
        String repositoryName = StringUtils.uncapitalize(mapperClass.getSimpleName().replace("Mapper", "Repository"));
        if (context.containsBean(repositoryName) && mapperClass.getDeclaredAnnotation(JpaMapper.class) != null) {
            mapper = (M) context.getBean(repositoryName);
        }
    }
}

@Service
public class UserServiceImpl extends AbstractServiceImpl<SysUserMapper, SysUser> implements UserService {

    @Override
    public List<SysUser> testJpa(String userNo, String userName) {
        //mapper接口中的自定义方法
        mapper.findByUserNoAndUserNameLike(userNo, userName);
        mapper.findByUserNameLike("findByUserNameLike");
        mapper.findAllOrderByUserNoDesc("findAllOrderByUserNoDesc");
        mapper.findByUserNameLikeOrderByUserNoDesc("findByUserNameLikeOrderByUserNoDesc");
        mapper.findByUserNameStartingWith("findByUserNameStartingWith");
        mapper.findByUserNameContaining("findByUserNameContaining");
        mapper.countByUserName("countByUserName");
        mapper.deleteByUserName("deleteByUserName");
        return List.of();
    }

}

```