Mybatis-Plus增删改查分页批量删除模版

一、概述

Mybatis-Plus增删改查分页批量删除模版

二、代码

package com.dbm.translationFeatureManagement.controller;

import com.dbm.translationFeatureManagement.entity.TranslationFeatureManagementEntity;
import com.dbm.translationFeatureManagement.service.TranslationFeatureManagementService;
import com.jgdf.core.filter.http.DisableEncryptResponse;
import com.jgdf.core.web.R;
import com.jgdf.core.web.RequestBean;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author zyj
 * @date 2023年04月23日
 */
@Api(tags = "")
@RestController
@RequestMapping("/interpreting")
@Slf4j
public class TranslationFeatureManagementController {

    @Autowired
    private TranslationFeatureManagementService translationFeatureManagementService;

    @ApiOperation("查询分页接口")
    @PostMapping("/page")
    @DisableEncryptResponse
    public R<Object> page(@RequestBody RequestBean<TranslationFeatureManagementEntity> requestBean) {
        return translationFeatureManagementService.getListByPage(requestBean);
    }

    @ApiOperation("新增")
    @PostMapping("/save")
    @DisableEncryptResponse
    public R<Object> save(@RequestBody TranslationFeatureManagementEntity translationFeatureManagementEntity) {
        return translationFeatureManagementService.saveInterpreting(translationFeatureManagementEntity);
    }

    @ApiOperation("删除")
    @PostMapping("/delete")
    @DisableEncryptResponse
    public R<Object> remove(@RequestBody TranslationFeatureManagementEntity translationFeatureManagementEntity) {
        return translationFeatureManagementService.removeInterpreting(translationFeatureManagementEntity);
    }

    @ApiOperation("批量删除")
    @PostMapping("/deletes")
    @DisableEncryptResponse
    public R<Object> removes(@RequestBody Collection<? extends Serializable> idList) {
        return translationFeatureManagementService.removeByIds(idList) ? R.ok("删除成功") : R.fail("删除失败");
    }

    @ApiOperation("修改")
    @PostMapping("/update")
    @DisableEncryptResponse
    public R<Object> update(@RequestBody TranslationFeatureManagementEntity translationFeatureManagementEntity) {
        translationFeatureManagementService.updateById(translationFeatureManagementEntity);
        return R.ok("修改成功");
    }

    @ApiOperation("查看")
    @PostMapping("/select")
    @DisableEncryptResponse
    public R<Object> detail(@RequestBody TranslationFeatureManagementEntity translationFeatureManagementEntity) {
        return translationFeatureManagementService.selectInterpreting(translationFeatureManagementEntity);
    }

}

@ApiModel(description = "")
@TableName(value = "tb_declare_feature")
public class TranslationFeatureManagementEntity {
    @ApiModelProperty("主键")
    @TableId("f_id")
    private Long id;

    @ApiModelProperty("类型")
    @TableField("f_type")
    private String type;

    @ApiModelProperty("面积(平方米)")
    @TableField("f_area")
    private String area;

    @ApiModelProperty("规模(立方米)")
    @TableField("f_scale")
    private String scale;

    @ApiModelProperty("照片")
    @TableField("f_photo")
    private String photo;

package com.dbm.translationFeatureManagement.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.dbm.translationFeatureManagement.entity.TranslationFeatureManagementEntity;
import org.apache.ibatis.annotations.Mapper;

/**
 * @author zyj
 * @description 针对表【】的数据库操作Mapper
 * @createDate 2023-04-23
 */
@Mapper
public interface TranslationFeatureManagementMapper extends BaseMapper<TranslationFeatureManagementEntity> {

}

package com.dbm.translationFeatureManagement.service;

import com.baomidou.mybatisplus.extension.service.IService;
import com.dbm.translationFeatureManagement.entity.TranslationFeatureManagementEntity;
import com.jgdf.core.web.R;
import com.jgdf.core.web.RequestBean;

/**
 * @author zyj
 * @description
 * @createDate 2023-04-23
 */
public interface TranslationFeatureManagementService extends IService<TranslationFeatureManagementEntity> {
    /**
     * 查询分页接口
     *
     * @return 查询对象
     */
    R<Object> getListByPage(RequestBean<TranslationFeatureManagementEntity> requestBean);

    /**
     * 新增
     *
     * @return 新增
     */
    R<Object> saveInterpreting(TranslationFeatureManagementEntity translationFeatureManagementEntity);

    /**
     * 删除
     *
     * @return 删除
     */
    R<Object> removeInterpreting(TranslationFeatureManagementEntity translationFeatureManagementEntity);

    /**
     * 查看
     *
     * @return 查看
     */
    R<Object> selectInterpreting(TranslationFeatureManagementEntity translationFeatureManagementEntity);
}

package com.dbm.translationFeatureManagement.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.dbm.translationFeatureManagement.entity.TranslationFeatureManagementEntity;
import com.dbm.translationFeatureManagement.mapper.TranslationFeatureManagementMapper;
import com.dbm.translationFeatureManagement.service.TranslationFeatureManagementService;
import com.dbm.utils.HnDbNextId;
import com.jgdf.common.toolset.ToolUtil;
import com.jgdf.core.web.R;
import com.jgdf.core.web.RequestBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

/**
 * @author zyj
 * @description 针对表【】的数据库操作Service实现
 * @createDate 2023-04-23
 */
@Service
public class TranslationFeatureManagementServiceImpl extends ServiceImpl<TranslationFeatureManagementMapper, TranslationFeatureManagementEntity> implements TranslationFeatureManagementService {
    @Autowired
    private TranslationFeatureManagementMapper translationFeatureManagementMapper;

    @Override
    public R<Object> getListByPage(RequestBean<TranslationFeatureManagementEntity> requestBean) {
        TranslationFeatureManagementEntity data = requestBean.getData();
        LambdaQueryWrapper<TranslationFeatureManagementEntity> query = new LambdaQueryWrapper<>();
        if (!ToolUtil.isEmpty(data.getId())) {
            query.like(TranslationFeatureManagementEntity::getId, data.getId());
        }
        if (!ToolUtil.isEmpty(data.getPhysicalGeographyLocation())) {
            query.like(TranslationFeatureManagementEntity::getPhysicalGeographyLocation, data.getPhysicalGeographyLocation());
        }
        if (!ToolUtil.isEmpty(data.getInterpretationPointGeologyDisasterType())) {
            query.like(TranslationFeatureManagementEntity::getInterpretationPointGeologyDisasterType, data.getInterpretationPointGeologyDisasterType());
        }
        return R.ok(page(new Page<>(requestBean.getCurrentPage(), requestBean.getPageSize()), query));
    }

    @Override
    public R<Object> saveInterpreting(TranslationFeatureManagementEntity translationFeatureManagementEntity) {
        Long id = HnDbNextId.getNextId("tb_declare_feature");
        translationFeatureManagementEntity.setId(id);
        return save(translationFeatureManagementEntity) ? R.ok("新增成功") : R.fail("新增失败");
    }

    @Override
    public R<Object> removeInterpreting(TranslationFeatureManagementEntity translationFeatureManagementEntity) {
        return removeById(translationFeatureManagementEntity.getId()) ? R.ok("删除成功") : R.fail("删除失败");
    }

    @Override
    public R<Object> selectInterpreting(TranslationFeatureManagementEntity translationFeatureManagementEntity) {
        return R.ok(getById(translationFeatureManagementEntity.getId()));
    }
}

#### mapper

```
@Mapper
@Repository
```

##### 添加

```
@Insert("insert into tg_file_servers(f_servertypeid,f_name,f_desc,f_user,f_password," +
            "f_port,f_pre_path,f_address,f_backup,f_rule," +
            "f_type,f_capacity,f_own_storage,f_use_type)" +
            " values(#{serverTypeId},#{name},#{desc},#{user},#{password}," +
            "#{port},#{prePath},#{address},#{backup},#{rule}," +
            "#{type},#{capacity},#{ownStorage},#{useType})")
    int insert(TgFileServers tgFileServers);
```

##### 删除

```
//删除
@Delete("delete from tg_file_servers where f_id=#{id}")
int delete(Long id);
```

##### 修改

```
@Update("update tg_file_servers set f_servertypeid=#{serverTypeId},f_name=#{name},f_desc=#{desc},f_user=#{user},f_password=#{password}," +
            "f_port=#{port},f_pre_path=#{prePath},f_address=#{address},f_backup=#{backup},f_rule=#{rule}," +
            "f_type=#{type},f_capacity=#{capacity},f_own_storage=#{ownStorage},f_use_type=#{useType} where f_id=#{id}")
    int updateById(TgFileServers tgFileServers);
```

##### 根据id查看详情

```
@Select("select f_id as id,f_servertypeid as serverTypeId,f_name as name,f_desc as desc,f_user as user," +
            "f_port as port,f_pre_path as prePath,f_address as address,f_backup as prePath,f_rule as rule," +
            "f_type as type,f_capacity as capacity,f_own_storage as ownStorage,f_use_type as useType " +
            "from tg_file_servers where f_id=#{id}")
    TgFileServersVO queryResult(Long id);
```

##### 分页查询

```
//分页查询(别名和类型）  使用PageHelper框架
@Select("select f_id as id,f_servertypeid as serverTypeId,f_name as name,f_desc as desc,f_user as user," +
        "f_port as port,f_pre_path as prePath,f_address as address,f_backup as prePath,f_rule as rule," +
        "f_type as type,f_capacity as capacity,f_own_storage as ownStorage,f_use_type as useType " +
        "from tg_file_servers where f_name like '%${name}%' or f_type=#{type}")
List<TgFileServers> findByNameOrType(@Param("name") String name, @Param("type") String type);
```

```
//分页查询（别名）  使用PageHelper框架
    @Select("select f_id as id,f_servertypeid as serverTypeId,f_name as name,f_desc as desc,f_user as user," +
            "f_port as port,f_pre_path as prePath,f_address as address,f_backup as prePath,f_rule as rule," +
            "f_type as type,f_capacity as capacity,f_own_storage as ownStorage,f_use_type as useType " +
            "from tg_file_servers where f_name like '%${name}%'")
    List<TgFileServers> findByName(@Param("name") String name);
```

##### 查询数量（count*)

```
@Select("select count(*) from tg_file_servers where f_name=#{name}")
int countName(String name);
```

##### 查询数据库列表

```
@Select("select f_id as id,f_servertypeid as serverTypeId,f_name as name,f_desc as desc,f_user as user," +
        "f_port as port,f_pre_path as prePath,f_address as address,f_backup as prePath,f_rule as rule," +
        "f_type as type,f_capacity as capacity,f_own_storage as ownStorage,f_use_type as useType " +
        "from tg_file_servers order by id")
List<TgFileServersVO> list();
```

#### service

```
@Transactional
```

```
//新增
void add(TgFileServersDTO tgFileServersDTO);

//根据id删除
void deleteById(Long id);

//修改
void update(Long id, TgFileServersDTO tgFileServersDTO);

//根据id查询详情
TgFileServersVO selectById(Long id);

//分页查询(别名和类型）  使用PageHelper框架
JsonPage<TgFileServers> getAllByNameOrType(String name, String type, Integer pageNum, Integer pageSize);

//分页查询（别名）  使用PageHelper框架
JsonPage<TgFileServers> getAllByName(String name,Integer pageNum, Integer pageSize);

//查询数据库列表信息
JsonPage<TgFileServersVO> list(Integer pageNum, Integer pageSize);

```

###### impl

```
@Slf4j
@Service
```

```
@Override
public void add(TgFileServersDTO tgFileServersDTO) {
    TgFileServers tgFileServers = new TgFileServers();
    BeanUtils.copyProperties(tgFileServersDTO, tgFileServers);

    if (tgFileServers.getName() == null) {
        String message = "别名不能为空";
        log.warn(message);
    }

    if (tgFileServers.getDesc() == null) {
        String message = "路径用途不能为空";
        log.warn(message);
    }

    if (tgFileServers.getUseType() == null) {
        String message = "路径类型不能为空";
        log.warn(message);
    }

    if (tgFileServers.getAddress() == null) {
        String message = "地址不能为空";
        log.warn(message);
    }

    if (tgFileServers.getUser() == null) {
        String message = "用户名不能为空";
        log.warn(message);
    }

    if (tgFileServers.getPassword() == null) {
        String message = "密码不能为空";
        log.warn(message);
    }

    int countName = mapper.countName(tgFileServers.getName());
    if (countName > 0) {
        String message = "别名已经存在，请替换其他名称";
        log.warn(message);
    }

    int countAddress = mapper.count(tgFileServers.getAddress());
    if (countAddress > 0) {
        String message = "路径已经存在";
        log.warn(tgFileServers.getAddress() + message);
    }

    File file = new File(tgFileServers.getAddress());

    if (file.exists()) {
        String message = "路径已经存在";
        log.warn(tgFileServers.getAddress() + message);
    }


    Long id = HnDbNextId.getNextId("tg_file_servers");
    tgFileServers.setId(id);
    mapper.insert(tgFileServers);
}
 /**
     * 根据id删除
     *
     * @param id
     */
    @Override
    public void deleteById(Long id) {
        if (id == null) {
            String message = "id为空，请稍后再尝试！";
            log.info("{}", message);
        }
        int rows = mapper.delete(id);
        if (rows != 1) {
            String message = "删除失败，请稍后再尝试！";
            log.info("{}", message);
        }
    }

    /**
     * 根据id修改
     *
     * @param id
     * @param tgFileServersDTO
     */
    @Override
    public void update(Long id, TgFileServersDTO tgFileServersDTO) {
        TgFileServers tgFileServers = new TgFileServers();
        BeanUtils.copyProperties(tgFileServersDTO, tgFileServers);
        tgFileServers.setId(id);
        log.debug("准备修改数据:{}", tgFileServers);
        mapper.updateById(tgFileServers);
    }

    /**
     * 根据id查看详情
     *
     * @param id
     * @return
     */
    @Override
    public TgFileServersVO selectById(Long id) {
        TgFileServersVO tgFileServersVO = mapper.queryResult(id);

        return tgFileServersVO;
    }

    /**
     * 分页查询(别名和类型）  使用PageHelper框架
     *
     * @param pageNum
     * @param pageSize
     * @return
     */
    @Override
    public JsonPage<TgFileServers> getAllByNameOrType(String name, String type, Integer pageNum, Integer pageSize) {
        PageHelper.startPage(pageNum, pageSize);

        if (name.isEmpty()) {
            log.warn("别名为空，请输入别名！");
        }
        List<TgFileServers> list = mapper.findByNameOrType(name, type);

        return JsonPage.restPage(new PageInfo<>(list));
    }

    /**
     * 分页查询（别名）  使用PageHelper框架
     *
     * @param name
     * @param pageNum
     * @param pageSize
     * @return
     */
    @Override
    public JsonPage<TgFileServers> getAllByName(String name, Integer pageNum, Integer pageSize) {
        PageHelper.startPage(pageNum, pageSize);

        if (name.isEmpty()) {
            log.warn("别名为空，请输入别名！");
        }
        List<TgFileServers> list = mapper.findByName(name);
        return JsonPage.restPage(new PageInfo<>(list));
    }

    /**
     * 查询数据库列表信息
     *
     * @return
     */
    @Override
    public JsonPage<TgFileServersVO> list(Integer pageNum, Integer pageSize) {
        PageHelper.startPage(pageNum, pageSize);

        List<TgFileServersVO> list = mapper.list();

        return JsonPage.restPage(new PageInfo<>(list));
    }
```

##### controller

```
@RestController
@RequestMapping("/TgFileServers")
@Api(tags = "TgFileServers接口")
```

```
@GetMapping("/add")
@ApiOperation("添加数据路径")
@DisableEncryptResponse
public R<Void> addNew(TgFileServersDTO tgFileServersDTO) {
    tgFileServersService.add(tgFileServersDTO);
    return R.ok();
}

@GetMapping("/delete")
@ApiOperation("删除")
@DisableEncryptResponse
public R<Void> delete(Long id) {
    tgFileServersService.deleteById(id);
    return R.ok();
}

@GetMapping("/update")
@ApiOperation("编辑")
@DisableEncryptResponse
public R<Void> update(Long id, TgFileServersDTO tgFileServersDTO) {
    tgFileServersService.update(id, tgFileServersDTO);

    return R.ok();
}

@GetMapping("/select")
@ApiOperation("根据id查看详情")
@DisableEncryptResponse
public R<TgFileServersVO> select(@RequestBody(required = false) Long id) {
    TgFileServersVO tgFileServersVO = tgFileServersService.selectById(id);

    return R.ok(tgFileServersVO);
}

//使用PageHelper框架
@GetMapping("/pageNameOrType")
@ApiOperation("分页查询数据路径别名、类型")
@ApiImplicitParams({
        @ApiImplicitParam(value = "页码", name = "pageNum", example = "1"),
        @ApiImplicitParam(value = "每页条数", name = "pageSize", example = "8")
})
public R<JsonPage<TgFileServers>> pageNameOrType(
        String name, String type, Integer pageNum, Integer pageSize) {
    JsonPage<TgFileServers> jsonPage = tgFileServersService.getAllByNameOrType(name, type, pageNum, pageSize);
    return R.ok(jsonPage);
}

//使用PageHelper框架
@GetMapping("/pageName")
@ApiOperation("分页查询数据路径别名")
@ApiImplicitParams({
        @ApiImplicitParam(value = "页码", name = "pageNum", example = "1"),
        @ApiImplicitParam(value = "每页条数", name = "pageSize", example = "8")
})
public R<JsonPage<TgFileServers>> pageName(
        String name,Integer pageNum, Integer pageSize) {
    JsonPage<TgFileServers> jsonPage = tgFileServersService.getAllByName(name, pageNum, pageSize);
    return R.ok(jsonPage);
}

@GetMapping("/list")
@ApiOperation("查询数据库列表")
public R<JsonPage<TgFileServersVO>> list(Integer pageNum, Integer pageSize) {
    JsonPage<TgFileServersVO> list = tgFileServersService.list(pageNum, pageSize);
    return R.ok(list);
}
```

##### 依赖

```
<dependency>
    <groupId>com.github.pagehelper</groupId>
    <artifactId>pagehelper</artifactId>
    <version>5.2.0</version>
</dependency>
<dependency>
    <groupId>com.github.pagehelper</groupId>
    <artifactId>pagehelper-spring-boot-starter</artifactId>
    <version>1.4.1</version>
</dependency>
```

##### 测试test

```
@Slf4j
@RunWith(SpringRunner.class)
@SpringBootTest(classes = HyManager.class)

```

```
//新增
@Test
public void testInsert(){
    TgFileServers tgFileServers = new TgFileServers();
    tgFileServers.setName("数据集别名");
    tgFileServers.setDesc("数据集用途");
    tgFileServers.setType("1");
    tgFileServers.setServerTypeId("");
    tgFileServers.setAddress("地址");
    tgFileServers.setUser("用户名");
    tgFileServers.setPassword("密码");

    mapper.insert(tgFileServers);
}
//根据id删除
    @Test
    public void testDelete(){
        mapper.delete(10007L);
    }
 //根据id查看详情
    @Test
    public void testSelect(){
        Long id = 10393L;
        TgFileServersVO result = mapper.queryResult(id);
        log.info(String.valueOf(result));
    }
//查询数据库列表信息
    @Test
    public void testList() {
        List<TgFileServersVO> list = mapper.list();

        for(TgFileServersVO admin : list) {
            log.debug("{}", admin);
        }
    }

```