SpringBoot整合MyBatis-plus

第一步：添加必要的依赖

第一种是在已存在MyBatis的情况下，直接添加mybatis-plus包即可。

<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus</artifactId>
    <version>2.1.8</version>
</dependency>

第二种是直接添加mybatis-plus的starter，它会自动导入mybatis的依赖包及其他相关依赖包

<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.0.1</version>
</dependency>

第二步：添加必要的配置

注意：Mybatis-plus是MyBatis的再封装，添加MyBatis-plus之后我们的设置针对的应该是MyBatis-plus，而不是MyBatis。

mybatis-plus:
  mapper-locations: classpath*:/mapper/*. 
  type-aliases-package: com.example.springbootdemo.entity
  type-aliases-super-type: java.lang. 
  type-handlers-package: com.example.springbootdemo.typeHandler
  type-enums-package: com.example.springbootdemo.enums

第三步：添加必要的配置类

@EnableTransactionManagement
@Configuration
@MapperScan(\"com.example.springbootdemo.plusmapper\")
public class MyBatisPlusConfig {
    
    // mybatis-plus分页插件
    @Bean
    public PaginationInterceptor paginationInterceptor() {
        return new PaginationInterceptor();
    }
    
}

第四步：定义实体

@Data
@Builder
@ToString
@EqualsAndHashCode
@NoArgsConstructor
@AllArgsConstructor
@TableName(value = \"ANIMAL\")
public class Animal {
    @TableId(value = \"ID\",type = IdType.AUTO)
    private Integer id;
    @TableField(value = \"NAME\",exist = true)
    private String name;
    @TableField(value = \"TYPE\",exist = true)
    private AnimalType type;
    @TableField(value = \"SEX\",exist = true)
    private AnimalSex sex;
    @TableField(value = \"MASTER\",exist = true)
    private String master;
}

public enum AnimalType implements IEnum {
    CAT(\"1\",\"猫\"),DOG(\"2\",\"狗\"),TIGER(\"3\",\"虎\"),MOUSE(\"4\",\"鼠\"),MONKEY(\"5\",\"猴\"),LOAN(\"6\",\"狮\"),OTHER(\"7\",\"其他\");
    private final String value;
    private final String desc;
    AnimalType(final String value,final String desc){
        this.value=value;
        this.desc = desc;
    }
    @Override
    public Serializable getValue() {
        return value;
    }
    public String getDesc() {
        return desc;
    }
}

public enum AnimalSex implements IEnum {
    MALE(\"1\",\"公\"),FEMALE(\"2\",\"母\");
    private final String value;
    private final String desc;
    AnimalSex(final String value,final String desc){
        this.value = value;
        this.desc = desc;
    }
    @Override
    public Serializable getValue() {
        return value;
    }
    public String getDesc() {
        return desc;
    }
}

第五步：定义mapper接口

public interface AnimalRepository extends  Mapper<Animal> {
}

解说：使用MyBatis Plus后Mapper只要继承 Mapper接口即可，即使不添加 映射文件也可以实现该接口提供的增删改查功能，还可以配合Wrapper进行条件操作，当然这些操作都仅仅限于单表操作，一旦涉及多表联查，那么还是乖乖添加**Mapper. 来自定义SQL吧！！！

第六步：定义service（重点）

@Service
@Log4j2
public class AnimalService {

    @Autowired
    private AnimalRepository animalRepository;

    //增
    public ResponseEntity<Animal> addAnimal(final Animal animal) {
        animalRepository.insert(animal);
        return ResponseEntity.ok(animal);
    }

    //删
    public ResponseEntity<Integer> deleteAnimalById(final int id){
        return ResponseEntity.ok(animalRepository.deleteById(id));
    }

    public ResponseEntity<Integer> deleteAnimals(final Animal animal){
        return ResponseEntity.ok(animalRepository.delete(packWrapper(animal, WrapperType.QUERY)));
    }

    public ResponseEntity<Integer> deleteAnimalsByIds(List<Integer> ids){
        return ResponseEntity.ok(animalRepository.deleteBatchIds(ids));
    }

    public ResponseEntity<Integer> deleteAnimalsByMap(final Animal animal){
        Map<String,  > params = new HashMap<>();
        if( s.nonNull(animal.getId())){
            params.put(\"ID\",animal.getId());
        }
        if(StringUtils.isNotEmpty(animal.getName())){
            params.put(\"NAME\", animal.getName());
        }
        if( s.nonNull(animal.getType())){
            params.put(\"TYPE\", animal.getType());
        }
        if( s.nonNull(animal.getSex())){
            params.put(\"SEX\", animal.getSex());
        }
        if (StringUtils.isNotEmpty(animal.getMaster())){
            params.put(\"MASTER\", animal.getMaster());
        }
        return ResponseEntity.ok(animalRepository.deleteByMap(params));
    }

    //改
    public ResponseEntity<Integer> updateAnimals(final Animal animal, final Animal condition){
        return ResponseEntity.ok(animalRepository.update(animal, packWrapper(condition, WrapperType.UPDATE)));
    }

    public ResponseEntity<Integer> updateAnimal(final Animal animal){
        Wrapper<Animal> animalWrapper = new UpdateWrapper<>();
        ((UpdateWrapper<Animal>) animalWrapper).eq(\"id\",animal.getId());
        return ResponseEntity.ok(animalRepository.update(animal, animalWrapper));
    }

    //查
    public ResponseEntity<Animal> getAnimalById(final int id){
        return ResponseEntity.ok(animalRepository.selectById(id));
    }

    public ResponseEntity<Animal> getOneAnimal(final Animal animal){
        return ResponseEntity.ok(animalRepository.selectOne(packWrapper(animal, WrapperType.QUERY)));
    }

    public ResponseEntity<List<Animal>> getAnimals(final Animal animal){
        return ResponseEntity.ok(animalRepository.selectList(packWrapper(animal, WrapperType.QUERY)));
    }

    public ResponseEntity<List<Animal>> getAnimalsByIds(List<Integer> ids){
        return ResponseEntity.ok(animalRepository.selectBatchIds(ids));
    }

    public ResponseEntity<List<Animal>> getAnimalsByMap(final Animal animal){
        Map<String,  > params = new HashMap<>();
        if( s.nonNull(animal.getId())){
            params.put(\"ID\",animal.getId());
        }
        if(StringUtils.isNotEmpty(animal.getName())){
            params.put(\"NAME\", animal.getName());
        }
        if( s.nonNull(animal.getType())){
            params.put(\"TYPE\", animal.getType());
        }
        if( s.nonNull(animal.getSex())){
            params.put(\"SEX\", animal.getSex());
        }
        if (StringUtils.isNotEmpty(animal.getMaster())){
            params.put(\"MASTER\", animal.getMaster());
        }
        return ResponseEntity.ok(animalRepository.selectByMap(params));
    }

    public ResponseEntity<List<Map<String,  >>> getAnimalMaps(final Animal animal){
        return ResponseEntity.ok(animalRepository.selectMaps(packWrapper(animal, WrapperType.QUERY)));
    }

    //查个数
    public ResponseEntity<Integer> getCount(final Animal animal){
        return ResponseEntity.ok(animalRepository.selectCount(packWrapper(animal, WrapperType.QUERY)));
    }

    //分页查询
    public ResponseEntity<Page<Animal>> getAnimalPage(final Animal animal,final int pageId,final int pageSize){
        Page<Animal> page = new Page<>();
        page.setCurrent(pageId);
        page.setSize(pageSize);
        return ResponseEntity.ok((Page<Animal>) animalRepository.selectPage(page,packWrapper(animal, WrapperType.QUERY)));
    }

    private Wrapper<Animal> packWrapper(final Animal animal, WrapperType wrapperType){
        switch (wrapperType){
            case QUERY:
                QueryWrapper<Animal> wrapper = new QueryWrapper<>();
                if ( s.nonNull(animal.getId()))
                    wrapper.eq(\"ID\", animal.getId());
                if (StringUtils.isNotEmpty(animal.getName()))
                    wrapper.eq(\"name\", animal.getName());
                if ( s.nonNull(animal.getType()))
                    wrapper.eq(\"type\", animal.getType());
                if ( s.nonNull(animal.getSex()))
                    wrapper.eq(\"sex\", animal.getSex());
                if (StringUtils.isNotEmpty(animal.getMaster()))
                    wrapper.eq(\"master\", animal.getMaster());
                return wrapper;
            case UPDATE:
                UpdateWrapper<Animal> wrapper2 = new UpdateWrapper<>();
                if ( s.nonNull(animal.getId()))
                    wrapper2.eq(\"ID\", animal.getId());
                if (StringUtils.isNotEmpty(animal.getName()))
                    wrapper2.eq(\"name\", animal.getName());
                if ( s.nonNull(animal.getType()))
                    wrapper2.eq(\"type\", animal.getType());
                if ( s.nonNull(animal.getSex()))
                    wrapper2.eq(\"sex\", animal.getSex());
                if (StringUtils.isNotEmpty(animal.getMaster()))
                    wrapper2.eq(\"master\", animal.getMaster());
                return wrapper2;
            case QUERYLAMBDA:
                LambdaQueryWrapper<Animal> wrapper3 = new QueryWrapper<Animal>().lambda();
                if ( s.nonNull(animal.getId()))
                    wrapper3.eq(Animal::getId, animal.getId());
                if (StringUtils.isNotEmpty(animal.getName()))
                    wrapper3.eq(Animal::getName, animal.getName());
                if ( s.nonNull(animal.getType()))
                    wrapper3.eq(Animal::getType, animal.getType());
                if ( s.nonNull(animal.getSex()))
                    wrapper3.eq(Animal::getSex, animal.getSex());
                if (StringUtils.isNotEmpty(animal.getMaster()))
                    wrapper3.eq(Animal::getMaster, animal.getMaster());
                return wrapper3;
            case UPDATELAMBDA:
                LambdaUpdateWrapper<Animal> wrapper4 = new UpdateWrapper<Animal>().lambda();
                if ( s.nonNull(animal.getId()))
                    wrapper4.eq(Animal::getId, animal.getId());
                if (StringUtils.isNotEmpty(animal.getName()))
                    wrapper4.eq(Animal::getName, animal.getName());
                if ( s.nonNull(animal.getType()))
                    wrapper4.eq(Animal::getType, animal.getType());
                if ( s.nonNull(animal.getSex()))
                    wrapper4.eq(Animal::getSex, animal.getSex());
                if (StringUtils.isNotEmpty(animal.getMaster()))
                    wrapper4.eq(Animal::getMaster, animal.getMaster());
                return wrapper4;
            default:return null;
        }
    }
}
enum WrapperType{
    UPDATE,UPDATELAMBDA,QUERY,QUERYLAMBDA;
}