利用反射简化mybatis代码的最终解决方案

之前写了个小工具。后来通过模板抽象，并借助MyBatis的IService接口，将那个工具取代了。。

总之

1.生成实体类：

2.生成mapper

3.创建service接口

4.实现service接口

5.创建BaseService

package com.example.server.service;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.IService;
import com.example.server.config.result.ResultDataVO;
import com.example.server.service.dto.base.BaseQueryDTO;
import lombok.Data;

@Data
public class BaseService<T> {
    private IService<T> service;

    public BaseService(IService<T> service) {
        this.service = service;
    }

    public BaseQueryDTO<T> queryAllList(long current, long size) {
        Page<T> result = service.page(new Page<>(current, size));
        return new BaseQueryDTO<>(result.getPages(), result.getRecords());
    }

    public BaseQueryDTO<T> queryList(String column, Object value, long current, long size) {
        QueryWrapper<T> query = new QueryWrapper<>();
        query.eq(column, value);
        Page<T> result = service.page(new Page<>(current, size), query);
        return new BaseQueryDTO<>(result.getPages(), result.getRecords());
    }

    public ResultDataVO update(T entity) {
        boolean r = service.update(entity, null);
        return ResultDataVO.build()
                .setSuccess(r);
    }

    public ResultDataVO delete(int id) {
        boolean r = service.removeById(id);
        return ResultDataVO.build()
                .setSuccess(r);
    }

    public ResultDataVO insert(T entity) {
        boolean r = service.save(entity);
        return ResultDataVO.build()
                .setSuccess(r);
    }
}

6.开始写服务层的具体业务代码（虽然这么说，这个版本的业务还是与controller耦合了）

package com.example.server.service;

import com.baomidou.mybatisplus.extension.service.IService;
import com.example.server.config.SpringContextUtil;
import com.example.server.config.result.ResultDataVO;
import com.example.server.service.dto.base.BaseQueryDTO;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

@Service
@RequiredArgsConstructor
@Slf4j
public class ManagerService {

    public <T> BaseQueryDTO<T> queryAll(Class<?> serviceType, long current, long size) {
        return (BaseQueryDTO<T>) getBaseService(serviceType).queryAllList(current, size);
    }

    public <T> BaseQueryDTO<T> queryByColumn(Class<?> serviceType, String column, Object value, long current, long size) {
        return (BaseQueryDTO<T>) getBaseService(serviceType).queryList(column, value, current, size);
    }

    public <T> ResultDataVO update(Class<?> serviceType, Object entity) {
        return getBaseService(serviceType).update(entity);
    }

    public <T> ResultDataVO delete(Class<?> serviceType, int id) {
        return getBaseService(serviceType).delete(id);
    }

    public <T> ResultDataVO insert(Class<?> serviceType, Object entity) {
        return getBaseService(serviceType).insert(entity);
    }


    private Object getService(Class<?> serviceType) {
        String serviceTypeName = serviceType.getName();
        Class<?> clazz = null; //获得service接口的类
        try {
            clazz = Class.forName(serviceTypeName);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
            log.atError().log("没有这个类，代码写错了. 类：" + serviceType.getSimpleName());
        }
        return SpringContextUtil.getBean(clazz);
    }

    private <T> BaseService<T> getBaseService(Class<?> serviceType) {
        Object service = getService(serviceType);
        @SuppressWarnings("unchecked")
        BaseService<T> baseService = new BaseService<>((IService<T>) service);
        return baseService;
    }
}

7.最终效果，控制器写法

package com.example.server.controller;

import com.example.server.bean.*;
import com.example.server.service.ManagerService;
import com.example.server.service.base.*;
import com.example.server.util.ObjectUtil;
import jakarta.servlet.http.HttpServletRequest;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RequiredArgsConstructor
@RestController
@RequestMapping("/api/manager")
public class ManagerController {
    private final ManagerService managerService;
    private final HttpServletRequest request;

    @RequestMapping("/queryAllCourse")
    public String queryAllCourse(@RequestParam long current, @RequestParam long size) {
        return managerService.queryAll(CourseService.class, current, size)
                .toResultStr();
    }

    @RequestMapping("/queryAllLab")
    public String queryAllLab(@RequestParam long current, @RequestParam long size) {
        return managerService.queryAll(LabService.class, current, size)
                .toResultStr();
    }

    @RequestMapping("/queryAllLabTable")
    public String queryAllLabTable(@RequestParam long current, @RequestParam long size) {
        return managerService.queryAll(LabTableService.class, current, size)
                .toResultStr();
    }

    @RequestMapping("/queryAllOrderCourse")
    public String queryAllOrderCourse(@RequestParam long current, @RequestParam long size) {
        return managerService.queryAll(OrderCourseService.class, current, size)
                .toResultStr();
    }

    @RequestMapping("/queryAllOrderTable")
    public String queryAllOrderTable(@RequestParam long current, @RequestParam long size) {
        return managerService.queryAll(OrderTableService.class, current, size)
                .toResultStr();
    }

    @RequestMapping("/queryAllUser")
    public String queryAllUser(@RequestParam long current, @RequestParam long size) {
        return managerService.queryAll(UserService.class, current, size)
                .toResultStr();
    }

    @RequestMapping("/queryLabTable")
    public String queryLabTable(@RequestParam int labId, @RequestParam long current, @RequestParam long size) {
        return managerService.queryByColumn(LabTableService.class, "labId", labId, current, size)
                .toResultStr();
    }

    @RequestMapping("/queryOrderCourseByUser")
    public String queryOrderCourseByUser(@RequestParam int userId, @RequestParam long current, @RequestParam long size) {
        return managerService.queryByColumn(OrderCourseService.class, "userId", userId, current, size)
                .toResultStr();
    }

    @RequestMapping("/queryOrderCourseByCourse")
    public String queryOrderCourseByCourse(@RequestParam int courseId, @RequestParam long current, @RequestParam long size) {
        return managerService.queryByColumn(OrderCourseService.class, "courseId", courseId, current, size)
                .toResultStr();
    }

    @RequestMapping("/queryOrderTableByUser")
    public String queryOrderTableByUser(@RequestParam int userId, @RequestParam long current, @RequestParam long size) {
        return managerService.queryByColumn(OrderCourseService.class, "userId", userId, current, size)
                .toResultStr();
    }

    @RequestMapping("/queryOrderTableByTable")
    public String queryOrderTableByTable(@RequestParam int tableId, @RequestParam long current, @RequestParam long size) {
        return managerService.queryByColumn(OrderCourseService.class, "tableId", tableId, current, size)
                .toResultStr();
    }

    @RequestMapping("/updateCourse")
    public String updateCourse() throws ObjectUtil.ParameterError, ClassNotFoundException {
        Course course = (Course) ObjectUtil.getObjectByRequest(Course.class, request);
        return managerService.update(CourseService.class, course)
                .toResultStr();
    }

    @RequestMapping("/updateLab")
    public String updateLab() throws ObjectUtil.ParameterError, ClassNotFoundException {
        Lab lab = (Lab) ObjectUtil.getObjectByRequest(Lab.class, request);
        return managerService.update(LabService.class, lab)
                .toResultStr();
    }

    @RequestMapping("/updateLabTable")
    public String updateLabTable() throws ObjectUtil.ParameterError, ClassNotFoundException {
        LabTable labTable = (LabTable) ObjectUtil.getObjectByRequest(LabTable.class, request);
        return managerService.update(LabTableService.class, labTable)
                .toResultStr();
    }

    @RequestMapping("/updateOrderCourse")
    public String updateOrderCourse() throws ObjectUtil.ParameterError, ClassNotFoundException {
        OrderCourse orderCourse = (OrderCourse) ObjectUtil.getObjectByRequest(OrderCourse.class, request);
        return managerService.update(OrderCourseService.class, orderCourse)
                .toResultStr();
    }

    @RequestMapping("/updateOrderTable")
    public String updateOrderTable() throws ObjectUtil.ParameterError, ClassNotFoundException {
        OrderTable orderTable = (OrderTable) ObjectUtil.getObjectByRequest(OrderTable.class, request);
        return managerService.update(OrderTableService.class, orderTable)
                .toResultStr();
    }

    @RequestMapping("/updateUser")
    public String updateUser() throws ObjectUtil.ParameterError, ClassNotFoundException {
        User user = (User) ObjectUtil.getObjectByRequest(User.class, request);
        return managerService.update(UserService.class, user)
                .toResultStr();
    }

    @RequestMapping("/deleteCourse")
    public String deleteCourse(@RequestParam int id) {
        return managerService.delete(CourseService.class, id)
                .toResultStr();
    }

    @RequestMapping("/deleteLab")
    public String deleteLab(@RequestParam int id) {
        return managerService.delete(LabService.class, id)
                .toResultStr();
    }

    @RequestMapping("/deleteLabTable")
    public String deleteLabTable(@RequestParam int id) {
        return managerService.delete(LabTableService.class, id)
                .toResultStr();
    }

    @RequestMapping("/deleteOrderCourse")
    public String deleteOrderCourse(@RequestParam int id) {
        return managerService.delete(OrderCourseService.class, id)
                .toResultStr();
    }

    @RequestMapping("/deleteOrderTable")
    public String deleteOrderTable(@RequestParam int id) {
        return managerService.delete(OrderTableService.class, id)
                .toResultStr();
    }

    @RequestMapping("/deleteUser")
    public String deleteUser(@RequestParam int id) {
        return managerService.delete(UserService.class, id)
                .toResultStr();
    }

    @RequestMapping("/insertCourse")
    public String insertCourse() throws ObjectUtil.ParameterError, ClassNotFoundException {
        Course course = (Course) ObjectUtil.getObjectByRequest(Course.class, request);
        return managerService.insert(CourseService.class, course)
                .toResultStr();
    }

    @RequestMapping("/insertLab")
    public String insertLab() throws ObjectUtil.ParameterError, ClassNotFoundException {
        Lab lab = (Lab) ObjectUtil.getObjectByRequest(Lab.class, request);
        return managerService.insert(LabService.class, lab)
                .toResultStr();
    }

    @RequestMapping("/insertLabTable")
    public String insertLabTable() throws ObjectUtil.ParameterError, ClassNotFoundException {
        LabTable labTable = (LabTable) ObjectUtil.getObjectByRequest(LabTable.class, request);
        return managerService.insert(LabTableService.class, labTable)
                .toResultStr();
    }

    @RequestMapping("/insertOrderCourse")
    public String insertOrderCourse() throws ObjectUtil.ParameterError, ClassNotFoundException {
        OrderCourse orderCourse = (OrderCourse) ObjectUtil.getObjectByRequest(OrderCourse.class, request);
        return managerService.insert(OrderCourseService.class, orderCourse)
                .toResultStr();
    }

    @RequestMapping("/insertOrderTable")
    public String insertOrderTable() throws ObjectUtil.ParameterError, ClassNotFoundException {
        OrderTable orderTable = (OrderTable) ObjectUtil.getObjectByRequest(OrderTable.class, request);
        return managerService.insert(OrderTableService.class, orderTable)
                .toResultStr();
    }

    @RequestMapping("/insertUser")
    public String insertUser() throws ObjectUtil.ParameterError, ClassNotFoundException {
        User user = (User) ObjectUtil.getObjectByRequest(User.class, request);
        return managerService.insert(UserService.class, user)
                .toResultStr();
    }
}

这里controller只是简单的增删改查，如果要联表查询或者其他的复杂查询，只需要在类似managerService的类中写具体代码便可以了。

该架构简化的只是基础的增删改查。

这是在具体的业务服务层里面要调用BaseService必有的两个方法，

    private Object getService(Class<?> serviceType) {
        String serviceTypeName = serviceType.getName();
        Class<?> clazz = null; //获得service接口的类
        try {
            clazz = Class.forName(serviceTypeName);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
            log.atError().log("没有这个类，代码写错了. 类：" + serviceType.getSimpleName());
        }
        return SpringContextUtil.getBean(clazz);
    }

    private <T> BaseService<T> getBaseService(Class<?> serviceType) {
        Object service = getService(serviceType);
        @SuppressWarnings("unchecked")
        BaseService<T> baseService = new BaseService<>((IService<T>) service);
        return baseService;
    }

统一返回结果：

package com.example.server.service.dto.base;

import com.example.server.config.result.ResultDataVO;
import lombok.Data;

import java.util.ArrayList;
import java.util.List;

@Data
public class BaseQueryDTO<T> implements DtoResult{
    protected long totalPage = 0;
    protected List<T> dataList = new ArrayList<>();

    public BaseQueryDTO(long totalPage, List<T> dataList){
        this.totalPage = totalPage;
        this.dataList = dataList;
    }

    @Override
    public String toResultStr() {
        return ResultDataVO.build()
                .success()
                .putData("totalPage",getTotalPage())
                .putData("dataList",getDataList())
                .toResultStr();
    }
}

package com.example.server.service.dto.base;

public interface DtoResult {
    String toResultStr();
}

package com.example.server.config.result;

import com.alibaba.fastjson2.JSONObject;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;

@Data
@Builder
@AllArgsConstructor
public class ResultDataVO {
    private ResultDataVO() {}
    public static ResultDataVO build(){
        return new ResultDataVO();
    }

    private DataClass dataClass = new DataClass();

    public ResultDataVO setRC(Integer code,String message){
        this.dataClass.code = code;
        this.dataClass.message = message;
        return this;
    }
    public ResultDataVO setRC(ExceptionCodeEnum exceptionCodeEnum){
        this.dataClass.code = exceptionCodeEnum.getCode();
        this.dataClass.message = exceptionCodeEnum.getMessage();
        return this;
    }
    public ResultDataVO setSuccess(Boolean isSuccess){
        this.dataClass.success = isSuccess;
        return this;
    }
    public ResultDataVO putDate(String key,Object object){
        this.dataClass.data.put(key,object);
        return this;
    }

    public DataClass success() {
        this.dataClass.success = true;
        this.dataClass.code = ExceptionCodeEnum.EC0.getCode();
        this.dataClass.message = ExceptionCodeEnum.EC0.getMessage();
        return this.dataClass;
    }
    public DataClass success(String key,Object data){
        this.dataClass.success = true;
        this.dataClass.code = ExceptionCodeEnum.EC0.getCode();
        this.dataClass.message = ExceptionCodeEnum.EC0.getMessage();
        this.dataClass.data.put(key,data);
        return this.dataClass;
    }
    public DataClass failure(Integer code,String message){
        this.dataClass.success = false;
        this.dataClass.code = code;
        this.dataClass.message = message;
        return this.dataClass;
    }
    public DataClass failure(ExceptionCodeEnum exceptionCodeEnum){
        this.dataClass.success = false;
        this.dataClass.code = exceptionCodeEnum.getCode();
        this.dataClass.message = exceptionCodeEnum.getMessage();
        return this.dataClass;
    }
    public DataClass failure(ExceptionCodeEnum exceptionCodeEnum,String key,Object data){
        this.dataClass.success = false;
        this.dataClass.code = exceptionCodeEnum.getCode();
        this.dataClass.message = exceptionCodeEnum.getMessage();
        this.dataClass.data.put(key,data);
        return this.dataClass;
    }

    public static class DataClass{
        private Boolean success;
        private Integer code;
        private String message;
        private JSONObject data = new JSONObject();
        public DataClass putData(String key,Object object){
            this.data.put(key, object);
            return this;
        }
        public String toResultStr(){
            JSONObject jsonObject = new JSONObject();
            jsonObject.put("success",this.success);
            jsonObject.put("code",this.code);
            jsonObject.put("message",this.message);
            jsonObject.put("data",this.data);
            System.out.println(jsonObject.toString());
            return jsonObject.toJSONString();
        }
    }
    public String toResultStr(){
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("success",this.dataClass.success);
        jsonObject.put("code",this.dataClass.code);
        jsonObject.put("message",this.dataClass.message);
        jsonObject.put("data",this.dataClass.data);
        return jsonObject.toJSONString();
    }
}