基于mybatisplus 实现的通用controller，标准dao、dto、vo结构

已于 2023-07-27 15:22:47 修改
阅读量1.3k 收藏
点赞数 2
分类专栏： 架构之路 文章标签： java 数据库 servlet
于 2023-06-16 16:36:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44424683/article/details/131249483
版权

废话不多说，直接上代码

2023-7-27更新了请移步查看下边仓库的代码

https://gitee.com/xue-aokun/mybatis-plus-demo.git

baseController

package org.jeecg.core.controller;

import cn.hutool.core.collection.CollectionUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.jeecg.common.api.vo.Result;
import org.jeecg.common.aspect.annotation.AutoLog;
import org.jeecg.common.constant.CommonConstant;
import org.jeecg.common.exception.JeecgBootException;
import org.jeecg.core.entity.BaseModel;
import org.jeecg.core.service.ICrudService;
import org.springframework.beans.BeanUtils;
import org.springframework.web.bind.annotation.*;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;


/**
 * 基于mp 基础controller
 *
 * @Author xak
 * @Version 1.0
 * @Date 2023-06-12 18:12
 **/
@Slf4j
public abstract class BaseController<S extends ICrudService<T, D, V>, T extends BaseModel<T>, D extends T, V extends T> {

    protected S baseService;

    public ThreadLocal<LambdaQueryWrapper<T>> wrapperThreadLocal = new ThreadLocal<>();

    /**
     * 分页查询所有数据
     *
     * @param page 分页对象
     * @param dto  查询dto
     * @return 所有数据
     */
    @GetMapping
    @ApiOperation("分页查询所有数据")
    @AutoLog(value = "分页查询所有数据", operateType = CommonConstant.OPERATE_TYPE_1)
    public Result<Page<V>> selectAll(Page<T> page, D dto) {
        try {
            //强转对应实体
            T model = (T) dto;
            wrapperThreadLocal.set(new LambdaQueryWrapper<>(model));
            //重新构造 wrapper
            reBuildQueryWrapper(wrapperThreadLocal.get(), dto);
            Page<T> list = this.baseService.page(page, wrapperThreadLocal.get());
            List<T> records = list.getRecords();
            Page<V> voPage = new Page<>();
            List<V> voList = new ArrayList<>();
            voPage.setRecords(voList);
            BeanUtils.copyProperties(list, voPage);
            if (CollectionUtil.isEmpty(records)) {
                return Result.ok("查询成功", voPage);
            }
            for (T record : records) {
                V vo = (V) record;
                voList.add(vo);
            }
            return Result.OK("查询成功", voPage);
        } catch (Exception e) {
            log.error("分页查询失败,{}", e.getMessage());
            return Result.error("查询失败");
        } finally {
            wrapperThreadLocal.remove();
        }
    }

    public void reBuildQueryWrapper(LambdaQueryWrapper<T> wrapper, D dto) {

    }

    /**
     * 通过id查询单条数据
     *
     * @param id 主键
     * @return 单条数据
     */
    @GetMapping("{id}")
    @ApiOperation("通过id查询单条数据")
    @AutoLog(value = "通过id查询单条数据", operateType = CommonConstant.OPERATE_TYPE_1)
    public Result<V> selectOne(@PathVariable Serializable id) {
        V vo = (V) baseService.selectOne(id);
        if (vo == null) {
            return Result.error("查询失败");
        } else {
            return Result.OK("查询成功", vo);
        }
    }

    /**
     * 新增
     *
     * @param model 实体对象
     * @return 新增结果
     */
    @PostMapping
    @ApiOperation("新增")
    @AutoLog(value = "新增", operateType = CommonConstant.OPERATE_TYPE_2)
    public Result<String> insert(@RequestBody T model) {
        boolean save = this.baseService.save(model);
        if (Boolean.TRUE.equals(save)) {
            return Result.OK("新增成功");
        } else {
            return Result.error("新增失败");
        }
    }

    /**
     * 修改
     *
     * @param model 实体对象
     * @return 修改结果
     */
    @PutMapping
    @ApiOperation("修改")
    @AutoLog(value = "修改", operateType = CommonConstant.OPERATE_TYPE_3)
    public Result<Boolean> update(@RequestBody T model) {
        if (model.getId() == null) {
            throw new JeecgBootException("修改失败id不能为空");
        }
        boolean update = this.baseService.updateById(model);
        if (Boolean.TRUE.equals(update)) {
            return Result.ok("修改成功");
        } else {
            return Result.error("修改失败");
        }
    }

    /**
     * 删除
     *
     * @param idList 主键集合
     * @return 删除结果
     */
    @DeleteMapping
    @ApiOperation("删除")
    @AutoLog(value = "删除", operateType = CommonConstant.OPERATE_TYPE_4)
    public Result<Boolean> delete(@RequestParam("idList") List<String> idList) {
        boolean remove = this.baseService.removeByIds(idList);
        if (Boolean.TRUE.equals(remove)) {
            return Result.OK("删除成功");
        } else {
            return Result.error("修改失败");
        }
    }

    /***
     * 返回日期代表的毫秒
     *
     * @param date
     *             日期
     * @return 返回毫秒
     */
    public long millis(Date date) {

        Calendar c = Calendar.getInstance();
        c.setTime(date);

        return c.getTimeInMillis();
    }

    /**
     * 获取当前天的后一天
     *
     * @param date
     * @return
     */
    public Date getAfterOneDay(Date date) {

        Calendar c = Calendar.getInstance();
        c.setTimeInMillis(millis(date) + (long) 24 * 3600 * 1000);

        return c.getTime();

    }

}

ICrudDao

package org.jeecg.core.dao;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.jeecg.core.entity.BaseModel;

/**
 * @Author xak
 * @Version 1.0
 * @Date 2023-06-12 18:21
 **/

public interface ICrudDao<T extends BaseModel<T>> extends BaseMapper<T> {

}

BaseModel

package org.jeecg.core.entity;


import com.baomidou.mybatisplus.extension.activerecord.Model;
import io.swagger.annotations.ApiModelProperty;

/**
 * @Author xak
 * @Version 1.0
 * @Date 2023-06-14 11:07
 **/
public abstract class BaseModel<T> extends Model<BaseModel<T>> {

    @ApiModelProperty(value = "id")
    private String id;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }
}

ICrudService

package org.jeecg.core.service;

import com.baomidou.mybatisplus.extension.service.IService;
import org.jeecg.core.entity.BaseModel;

import java.io.Serializable;

/**
 * @Author xak
 * @Version 1.0
 * @Date 2023-06-12 18:22
 **/

public interface ICrudService<T extends BaseModel<T>,D extends T,V extends T> extends IService<T> {

    /**
     * 根据id查询
     * @param id
     * @return
     */
    V selectOne(Serializable id);

}

CrudServiceImpl

package org.jeecg.core.service.impl;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import lombok.extern.slf4j.Slf4j;
import org.jeecg.core.dao.ICrudDao;
import org.jeecg.core.entity.BaseModel;
import org.jeecg.core.service.ICrudService;
import org.springframework.transaction.annotation.Transactional;

import java.io.Serializable;

/**
 * @Author xak
 * @Version 1.0
 * @Date 2023-06-12 18:22
 **/
@Slf4j
public abstract class CrudServiceImpl<E extends ICrudDao<T>, T extends BaseModel<T>, D extends T, V extends T> extends ServiceImpl<E, T> implements ICrudService<T, D, V> {


    public ThreadLocal<V> voThreadLocal = new ThreadLocal<>();

    @Override
    public V selectOne(Serializable id) {
        try {
            voThreadLocal.set((V) getById(id));
            afterSelectOne(voThreadLocal);
            return voThreadLocal.get();
        } catch (Exception e) {
            log.error("查询单个对象失败，{}",e.getMessage());
            return null;
        } finally {
            voThreadLocal.remove();
        }
    }

    @Transactional
    @Override
    public boolean save(T entity) {
        beforeSave(entity);
        boolean save = super.save(entity);
        afterSave(entity);
        return save;
    }

    @Transactional
    @Override
    public boolean updateById(T entity) {
        beforeUpdateById(entity);
        boolean update = super.updateById(entity);
        afterUpdateById(entity);
        return update;
    }

    public void afterSelectOne(ThreadLocal<V> voThreadLocal) {

    }


    /**
     * mp基础  新增前执行
     *
     * @param model
     */
    protected void beforeSave(T model) {

    }

    /**
     * mp基础 新增后执行
     *
     * @param model
     */
    protected void afterSave(T model) {

    }

    /**
     * mp基础 更新前执行
     *
     * @param model
     */
    protected void beforeUpdateById(T model) {

    }

    /**
     * mp基础 更新后执行
     *
     * @param model
     */
    protected void afterUpdateById(T model) {

    }

    // TODO: 2023/6/14 有需要再拓展其他方法
}

实战代码

AkXak

package org.jeecg.entity;

import java.util.Date;

import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.jeecg.core.entity.BaseModel;

/**
 * xak测试通用框架(AkXak)表实体类
 *
 * @author xak
 * @since 2023-06-16 16:08:14
 */
@EqualsAndHashCode(callSuper = true)
@Data
@ApiModel("xak测试通用框架")
public class AkXak extends BaseModel<AkXak> {

    @ApiModelProperty(value = "id")
    private String id;

    @ApiModelProperty(value = "创建人")
    private String createdBy;

    @ApiModelProperty(value = "创建时间")
    private Date createdTime;

    @ApiModelProperty(value = "更新人")
    private String updateBy;

    @ApiModelProperty(value = "更新时间")
    private Date updateTime;

}

AkXakDto

package org.jeecg.dto;


import io.swagger.annotations.ApiModel;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.jeecg.entity.AkXak;

/**
 * xak测试通用框架(AkXak)表参数类
 *
 * @author xak
 * @since 2023-06-16 16:08:14
 */
@EqualsAndHashCode(callSuper = true)
@Data
@ApiModel("xak测试通用框架 dto")
public class AkXakDto extends AkXak {

}

AkXakVo

package org.jeecg.vo;

import io.swagger.annotations.ApiModel;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.jeecg.entity.AkXak;

/**
 * xak测试通用框架(AkXak)表出参类
 *
 * @author xak
 * @since 2023-06-16 16:08:14
 */
@EqualsAndHashCode(callSuper = true)
@Data
@ApiModel("xak测试通用框架 vo")
public class AkXakVo extends AkXak {

}

AkXakController

package org.jeecg.controller;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import io.swagger.annotations.Api;
import org.jeecg.core.controller.BaseController;
import org.jeecg.dto.AkXakDto;
import org.jeecg.entity.AkXak;
import org.jeecg.service.AkXakService;
import org.jeecg.vo.AkXakVo;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.PostConstruct;
import javax.annotation.Resource;
import java.util.Date;

/**
 * xak测试通用框架(AkXak)表控制层
 *
 * @author xak
 * @since 2023-06-16 16:08:13
 */
@Api(tags = "xak测试通用框架")
@RestController
@RequestMapping("akXak")
public class AkXakController extends BaseController<AkXakService, AkXak, AkXakDto, AkXakVo> {
    /**
     * 服务对象
     */
    @Resource
    private AkXakService service;

    @PostConstruct
    void fatherService() {
        this.baseService = service;
    }

    @Override
    public void reBuildQueryWrapper(LambdaQueryWrapper<AkXak> wrapper, AkXakDto dto) {
        if (dto.getCreatedTime() == null) {
            return;
        }
        Date createdTime = dto.getCreatedTime();
        dto.setCreatedTime(null);

        LambdaQueryWrapper<AkXak> queryWrapper = new LambdaQueryWrapper<>(dto);
        if (createdTime != null) {
            queryWrapper.between(AkXak::getCreatedTime, createdTime, getAfterOneDay(createdTime));
        }
        wrapperThreadLocal.set(queryWrapper);
    }
}

AkXakService

package org.jeecg.service;

import org.jeecg.entity.AkXak;
import org.jeecg.dto.AkXakDto;
import org.jeecg.vo.AkXakVo;
import org.jeecg.core.service.ICrudService;

/**
 * xak测试通用框架(AkXak)表服务接口
 *
 * @author xak
 * @since 2023-06-16 16:08:14
 */
public interface AkXakService extends ICrudService<AkXak, AkXakDto, AkXakVo> {

}

AkXakDao

package org.jeecg.dao;

import org.jeecg.core.dao.ICrudDao;
import org.jeecg.entity.AkXak;

/**
 * xak测试通用框架(AkXak)表数据库访问层
 *
 * @author xak
 * @since 2023-06-16 16:08:13
 */
public interface AkXakDao extends ICrudDao<AkXak> {

}

AkXakServiceImpl

package org.jeecg.service.impl;

import org.jeecg.core.service.impl.CrudServiceImpl;
import org.jeecg.dto.AkXakDto;
import org.jeecg.vo.AkXakVo;
import org.jeecg.dao.AkXakDao;
import org.jeecg.entity.AkXak;
import org.jeecg.service.AkXakService;
import org.springframework.stereotype.Service;

/**
 * xak测试通用框架(AkXak)表服务实现类
 *
 * @author xak
 * @since 2023-06-16 16:08:14
 */
@Service("akXakService")
public class AkXakServiceImpl extends CrudServiceImpl<AkXakDao, AkXak, AkXakDto, AkXakVo> implements AkXakService {

}

代码使用easyCode插件生成的，手写是不可能的，插件就不贴了，想搞这种东西的人应该有实力把插件模版改好的，嘻嘻嘻

最烦起名字了0_o
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
mybatis_plus_demo自动生成实体类，mapper，service，controller
08-17
使用mybatis_plus自动生成mapper，service，controller的代码，单表的crud全都自动生成
MybatisPlus-Generator自定义模版生成CRUD、DTO、VO、Convert等
wnhyang的博客
03-18 1107
如标题所言，本篇文章介绍如何使用MybatisPlus-Generator自定义模版生成CRUD、DTO、VO、Convert等。使用范围：数据源：MySQL，因为我主要使用的是MySQL，其他数据源没测试过，不敢保证。工具：lombok、mapstruct，因为项目使用mapstruct做DTO、VO的转换工具，所以这些是必要的。
idea配置SpringBoot+MybatisPlus的Controller模板，一键生成Controller
最新发布
m0_52640724的博客
04-12 653
我用的MybatisX-Generator生成了entity和service等，但是他没有controller，还得自己创建好麻烦，于是写了模板。我想在com.xx.controller中输入UserInfoController，让他给我创建基本的接口，且自动引入service和entity接口返回类型为R，代码放下面。
使用MybatisPlus+SpringMBVC完成的CUID以及分页查询实现Demo
04-08
使用MyBatisPlus的逆向工程自动生成Mapper接口,xml文件,service接口,service实现以及controller并整合Spring框架完成单表CUID和分页操作，代码讲解请参看：https://blog.csdn.net/u010158540/article/details/79833011
【我的开源】拿来即用！代码生成器：mybatis-plus-generator自定义模板生成 DTO、VO、Convertor、增删改查方法
万物皆字节
08-06 7827
在开发后台管理系统的时候，感觉基本上操作都是一样的：curd，于是借助并扩展mp的代码生成器自动生成一套api,减少重复劳动而且还统一规范，何乐而不为
SpringBoot整合MybatisPlus 自动生成controller、mapper、entity、service
暖风
06-26 2119
java自动生成controller、mapper、entity、service，相对应的文件配置可自行修改
Mybatis-Plus代码生成器-自定义Controller
不愧是暮言的博客
02-12 3343
在我们开发项目的时候，最烦的也是最累的就是手码代码了，那么就不可以自己生成代码吗？作者今天给大家带来的就是如何利用mybatis-Plus自动生成代码，且配置成自己想要的效果出来。回想我们之前进行开发的过程，首先我们需要编写与数据库表对应的实体类，接着再进行创建各种层次的包（mapper,service,impl)，这个过程是不是感觉特别漫长呢，而现在一款神器myBatis-Plus的代码自动生成器。
mybatis plus配置以及controller层增删改查、分页
我是老伯的博客
03-14 4609
mybatis plus配置以及controller层增删改查、分页
POJO/PO/DTO/VO的区别及MyBatis-plus的基本使用
weixin_49782730的博客
06-06 1125
PO对象主要用于与数据库进行交互，将数据从数据库读取到PO对象中，或将PO对象中的数据写入到数据库中。VO（Value Object）：VO是值对象的缩写，表示一个不可变的对象，它的值在创建后不可更改。VO的设计目标是提供一个轻量级的对象，用于存储和传输值，具有较低的内存消耗和更好的性能。POJO（Plain Old Java Object）：POJO是指一个普通的java对象，通常是一个简单的java类，没有任何的限制或附加条件，不依赖于特定的框架或库，用于存储数据及提供简单的方法。
Mybatis-plus 自定义模板生成代码DTO、VO等
王林的博客
09-18 3788
这里主要是介绍 Mybatis-plus 通过自定义模板自动生成增删改查等代码等，方便以后查阅！！！
SpringBoot使用mybatis-plus中代码生成器操作，自定义controller,service
m0_64348392的博客
11-18 505
在resources文件夹下创建templates文件夹然后可以在外部库里面找到如下目录，复制controller.java.vm,service.java.vm,serviceImpl.java.vm这几个文件，也可以直接在templates文件夹下创建这几个文件。{table.comment} 前端控制器* */#else#end#else#else#end@Resource。
基于java spring的前后端分离单体结构的快速开发框架
03-14
spring-boot-plus是一套前后端分离单体...快速生成后台代码: entity/dto/query/vo/controller/service/mapper/xml 集成Swagger/Knife4j，可自动生成api文档 集成Redis缓存 集成HikariCP连接池，JDBC性能和慢查询检测
java 自动生成代码 entity,dao,service
11-12
对于经常写重复性代码的entity，dao,service，本例子中写了一个简单的自动生成小程序，有需要者可以下载
Java一键生成代码到controller层【源码】
11-26
3、可大大提高开发效率，数据表创建完以后，自动生成entity,mapper.xml,dao,service,controller,vo,dto相关代码。 4、本项目集成了spring,aop,mybatis plus,swagger2,异常处理,分页,freemarker等多种技术。 5、操作...
Smart Admin通用型中后台解决方案-其他
06-11
同时身心愉悦的规范后端代码规范：1、好多种分包，哪种更合理一些2、四层架构（controller, service, manager, dao） 是什么，为什么要有四层3、各个层的代码该怎么写才能让团队配合默契，高度一致4、vo, bo, dto, ...
Smart Admin通用型中后台解决方案 v1.0.9
04-22
4、vo, bo, dto, entity 怎么区分和使用 5、spring的 @Transactional 你用对了吗 6、方法参数个数、注释、todo这些也要有规范，你遵守过吗 7、以上举例，只是沧海一粟，更多的细节等待你的发现！ ps：以上规范...
Mybatis-Plus生成器生成Controller、Service、Entity、Mapper、xml-超简单好用
热门推荐
玩转Java
04-06 1万+
mybatis-plus
mybatisplus自动生成实体类，mapper，controller
weixin_53244007的博客
08-10 726
mybatisplus自动生成实体类，mapper，controller。
MyBatis-Plus 在 Controller 层注入 Service 接口，让您的业务操作更便捷！
奇妙的Bug之旅
01-05 544
在使用 MyBatis-Plus 的过程中，我们经常需要在 Controller 层注入 Service 接口来进行业务操作。假设我们要操作一个名为 User 的实体类，我们创建一个 UserService 接口和一个 UserServiceImpl 实现类。接下来，我们创建一个 Controller 类，用于处理客户端的请求，并调用相应的 Service 接口方法进行业务操作。通过以上步骤，我们成功地在 Controller 层注入了 Service 接口，可以通过调用相应的方法进行业务操作。
controller入参用dto还是vo
05-18
一般来说，Controller层应该接收DTO对象作为参数。DTO（Data Transfer Object）是一种数据传输对象，它的作用是封装业务数据，减少对外部的暴露。它通常包含了一些业务实体对象的属性，但并不是全部属性，而是根据业务需求选择需要传递的属性。 VO（View Object）是一种视图对象，它的作用是封装视图展示所需的数据。VO通常是在Controller中调用Service方法得到业务实体对象后，将业务实体对象的属性拷贝到VO中，再将VO对象传递给前端页面进行渲染。 因此，Controller层应该接收DTO对象作为参数，而不是VO对象。因为DTO可以根据实际业务需求灵活选择需要传递的属性，而VO是专门用于视图展示的，不应该直接作为Controller的入参。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值