java封装controllerModel，重写RequestMappingHandlerMapping自动生成增删改以及全属性查询接口

最新推荐文章于 2023-05-17 01:21:22 发布
最新推荐文章于 2023-05-17 01:21:22 发布
阅读量8.1k 收藏 2
点赞数 1
文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39898191/article/details/116565944
版权 
## controller通过继承一个model模板类，不需要编写基础的接口，效果如下：

没有编写任何接口：
在这里插入图片描述

成功调用：
在这里插入图片描述

1、公用模板类，拥有基础的增删改查、分页、条件查询等接口：

package com.zx.repository.controller;

import com.zx.repository.annotation.ModelMapping;
import com.zx.repository.service.MyRepository;
import com.zx.repository.util.MyBaseConverter;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.*;

import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.List;
import java.util.Map;

/**
 * @author: zhaoxu
 * 公用controller
 */
public class MyControllerModel<S, E> implements ApplicationRunner {
    private static final Logger logger = LoggerFactory.getLogger(MyControllerModel.class);

    public MyRepository myRepository;

    private Type[] actualTypeArguments;

    private MyBaseConverter myBaseConverter = new MyBaseConverter();

    private ReflectUtil reflectUtil = new ReflectUtil();

    @RequestMapping(path = "", method = RequestMethod.POST)
    @ModelMapping
    @Transactional(isolation = Isolation.READ_COMMITTED, rollbackFor = Exception.class)
    public synchronized void add(@RequestBody S entityVO) {
        Object entity = myBaseConverter.convertSingleObject(entityVO, (Class<?>) actualTypeArguments[1]);
        try {
            reflectUtil.setValue(entity, "valid", 1);
        } catch (Exception e) {
            logger.warn("没有找到属性：valid");
        }

        myRepository.save(entity);
    }

    @RequestMapping(path = "", method = RequestMethod.PUT)
    @ModelMapping
    @Transactional(isolation = Isolation.READ_COMMITTED, rollbackFor = Exception.class)
    public void update(@RequestBody S entityVO) {
        Object entity = myBaseConverter.convertSingleObject(entityVO, (Class<?>) actualTypeArguments[1]);
        try {
            reflectUtil.setValue(entity, "valid", 1);
        } catch (Exception e) {
            logger.warn("没有找到属性：valid");
        }
        myRepository.save(entity);
    }

    @RequestMapping(path = "/{ids}", method = RequestMethod.DELETE)
    @ModelMapping
    @Transactional(isolation = Isolation.READ_COMMITTED, rollbackFor = Exception.class)
    public void deleteValid(@PathVariable String ids) {
        myRepository.deleteValid(ids);
    }

    @RequestMapping(path = "/{attr}/{condition}", method = RequestMethod.GET)
    @ModelMapping
    public Object findByAttr(@PathVariable String attr, @PathVariable String condition) {
        return myBaseConverter.convertSingleObject(myRepository.findOneByAttr(attr, condition), (Class<?>) actualTypeArguments[0]);
    }

    @RequestMapping(path = "/list/{attr}/{condition}", method = RequestMethod.GET)
    @ModelMapping
    public List findByAttrs(@PathVariable String attr,
                            @PathVariable String condition,
                            @RequestParam(name = "conditionType", required = false) String conditionType) {
        if (!StringUtils.isEmpty(conditionType) && Constants.LIST_TYPE.equals(conditionType)) {
            return myBaseConverter.convertMultiObjectToList((List<? extends Object>) myRepository.findByAttrs(attr, condition), (Class<?>) actualTypeArguments[0]);
        }
        return myBaseConverter.convertMultiObjectToList((List<? extends Object>)myRepository.findByAttr(attr, condition), (Class<?>) actualTypeArguments[0]);
    }

    @RequestMapping(path = "/findAll", method = RequestMethod.GET)
    @ModelMapping
    public List findAllByConditions(@RequestParam Map<String, Object> tableMap,
                                    @RequestParam(name = "excludeAttr", required = false) String excludeAttr) {
        String sortAttr;
        List<String> excludeAttrs;
        //取消模糊查询不为空并且排序不为空
        if (!StringUtils.isEmpty(excludeAttr) & (tableMap.get(Constants.SORTER) != null && !Constants.EMPTY_SORTER.equals(tableMap.get(Constants.SORTER)))) {
            excludeAttrs = Arrays.asList(excludeAttr.split(","));
            JSONObject sorter = JSONObject.parseObject(tableMap.get(Constants.SORTER).toString());
            Iterator<String> iterator = sorter.keySet().iterator();
            sortAttr = iterator.next();
            return myBaseConverter.convertMultiObjectToList((List<? extends Object>) myRepository.findByConditions(tableMap, excludeAttrs, sortAttr), (Class<?>) actualTypeArguments[0]);

        } else if (!StringUtils.isEmpty(excludeAttr)) {
            //取消模糊查询不为空
            excludeAttrs = Arrays.asList(excludeAttr.split(","));
            return myBaseConverter.convertMultiObjectToList((List<? extends Object>)myRepository.findByConditions(tableMap, excludeAttrs), (Class<?>) actualTypeArguments[0]);

        } else if ((tableMap.get(Constants.SORTER) != null && !Constants.EMPTY_SORTER.equals(tableMap.get(Constants.SORTER)))) {
            //排序不为空
            JSONObject sorter = JSONObject.parseObject(tableMap.get(Constants.SORTER).toString());
            Iterator<String> iterator = sorter.keySet().iterator();
            sortAttr = iterator.next();
            return myBaseConverter.convertMultiObjectToList((List<? extends Object>)myRepository.findByConditions(tableMap, null, sortAttr), (Class<?>) actualTypeArguments[0]);

        }

        return myBaseConverter.convertMultiObjectToList((List<? extends Object>)myRepository.findByConditions(tableMap), (Class<?>) actualTypeArguments[0]);
    }

    @RequestMapping(path = "/findByPage", method = RequestMethod.GET)
    @ModelMapping
    public Map findByPage(@RequestParam Map<String, Object> tableMap,
                                          @RequestParam(name = "excludeAttr", required = false) String excludeAttr) {
        String sortAttr;
        List<String> excludeAttrs;
        //取消模糊查询不为空并且排序不为空
        if (!StringUtils.isEmpty(excludeAttr) & (tableMap.get(Constants.SORTER) != null && !Constants.EMPTY_SORTER.equals(tableMap.get(Constants.SORTER)))) {
            excludeAttrs = Arrays.asList(excludeAttr.split(","));
            JSONObject sorter = JSONObject.parseObject(tableMap.get(Constants.SORTER).toString());
            Iterator<String> iterator = sorter.keySet().iterator();
            sortAttr = iterator.next();
            Page byPage = myRepository.findByPage(tableMap, excludeAttrs, sortAttr);

            return myBaseConverter.convertMultiObjectToMap(byPage, (Class<?>) actualTypeArguments[0]);
        } else if (!StringUtils.isEmpty(excludeAttr)) {
            //取消模糊查询不为空
            excludeAttrs = Arrays.asList(excludeAttr.split(","));
            Page byPage = myRepository.findByPage(tableMap, excludeAttrs);
            return myBaseConverter.convertMultiObjectToMap(byPage, (Class<?>) actualTypeArguments[0]);

        } else if (tableMap.get(Constants.SORTER) != null && !Constants.EMPTY_SORTER.equals(tableMap.get(Constants.SORTER))) {
            //排序不为空
            JSONObject sorter = JSONObject.parseObject(tableMap.get(Constants.SORTER).toString());
            Iterator<String> iterator = sorter.keySet().iterator();
            sortAttr = iterator.next();
            Page byPage = myRepository.findByPage(tableMap, null, sortAttr);
            return myBaseConverter.convertMultiObjectToMap(byPage, (Class<?>) actualTypeArguments[0]);

        }

        Page<E> byPage = myRepository.findByPage(tableMap);
        return myBaseConverter.convertMultiObjectToMap(byPage, (Class<?>) actualTypeArguments[0]);
    }

    @Override
    public void run(ApplicationArguments args) throws Exception {
        Class<? extends MyControllerModel> aClass = this.getClass();
        //获取泛型类型
        Type genericSuperclass = aClass.getGenericSuperclass();
        ParameterizedType parameterizedType = (ParameterizedType) genericSuperclass;
        Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
        this.actualTypeArguments = actualTypeArguments;
        //查找Repository
        List<String> strings = Arrays.asList(aClass.getName().split("\\."));
        String controllerName = strings.get(strings.size() - 1);
        String serviceApi = Character.toLowerCase(controllerName.charAt(0)) + controllerName.split("Controller")[0].substring(1);
        this.myRepository = (MyRepository) SpringTool.getBean(serviceApi + "Repository");
    }
}

2、注解类ModelMapping：

package com.zx.repository.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * @author : zhaoxu
 */
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface ModelMapping {
}

3、MyRequestMappingHandlerMapping.class

package com.zx.repository.mvc;

import com.zx.repository.annotation.ModelMapping;
import lombok.SneakyThrows;
import org.springframework.core.annotation.AnnotationUtils;
import org.springframework.util.CollectionUtils;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.mvc.condition.RequestCondition;
import org.springframework.web.servlet.mvc.method.RequestMappingInfo;
import org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.List;

/**
 * @author : zhaoxu
 */
public class MyRequestMappingHandlerMapping extends RequestMappingHandlerMapping {
    RequestMappingInfo.BuilderConfiguration config = new RequestMappingInfo.BuilderConfiguration();

    public MyRequestMappingHandlerMapping() {
    }

    @SneakyThrows
    @Override
    public void afterPropertiesSet() {
        Field config = this.getClass().getSuperclass().getDeclaredField("config");
        config.setAccessible(true);
        this.config = (RequestMappingInfo.BuilderConfiguration) config.get(this);
        super.afterPropertiesSet();
    }

    @Override
    protected RequestMappingInfo getMappingForMethod(Method method, Class handlerType) {
        RequestMappingInfo info = super.getMappingForMethod(method, handlerType);
        // 读取方法上的RequestMapping注解信息
        RequestMapping methodAnnotation = method.getDeclaredAnnotation(RequestMapping.class);
        if (method.isAnnotationPresent(ModelMapping.class)) {
            RequestCondition methodCondition = getCustomMethodCondition(method);
            info = createRequestMappingInfo(methodAnnotation, methodCondition);

            // 读取类上的RequestMapping注解信息
            RequestMapping typeAnnotation = AnnotationUtils.findAnnotation(handlerType, RequestMapping.class);

            // 生成类上的匹配条件,并合并方法上的
            List<String> strings = Arrays.asList(handlerType.getName().split("\\."));
            if (CollectionUtils.isEmpty(strings)) {
                return null;
            }
            String controllerName = strings.get(strings.size() - 1);
            String serviceApi = Character.toLowerCase(controllerName.charAt(0)) + controllerName.split("Controller")[0].substring(1);

            RequestCondition typeCondition = getCustomTypeCondition(handlerType);
            if (typeAnnotation != null) {
                // 生成类上的匹配条件,并合并方法上的
                info = createRequestMappingInfo(typeAnnotation, typeCondition).combine(RequestMappingInfo.paths(serviceApi).build().combine(info));
            } else {
                info = RequestMappingInfo.paths(serviceApi).build().combine(info);
            }
        }
        return info;
    }

    @Override
    protected RequestMappingInfo createRequestMappingInfo(RequestMapping requestMapping, RequestCondition customCondition) {
        return RequestMappingInfo
                .paths(resolveEmbeddedValuesInPatterns(requestMapping.path()))
                .methods(requestMapping.method())
                .params(requestMapping.params())
                .headers(requestMapping.headers())
                .consumes(requestMapping.consumes())
                .produces(requestMapping.produces())
                .mappingName(requestMapping.name())
                .customCondition(customCondition)
                .options(this.config)
                .build();
    }
}

4、配置类：

package com.zx.repository.mvc;

import org.springframework.boot.autoconfigure.web.servlet.WebMvcRegistrations;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.Ordered;
import org.springframework.core.annotation.Order;
import org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping;

@Configuration
/**
 * @author : zhaoxu
 * 这个是自定义repository工厂
 */
@EnableJpaRepositories(basePackages = {"test.supcon"}, repositoryFactoryBeanClass = BaseJpaRepositoryFactoryBean.class)
public class MyJpaRepositoryConfig extends WebMvcConfigurationSupport {
    @Override
    @Bean
    public RequestMappingHandlerMapping requestMappingHandlerMapping() {
        return new MyRequestMappingHandlerMapping();
    }
}

最后每一个controller继承就可以了，借口url路径为类上方的requestMapping+controller类名（比如TestController则为test）+模板类里面的路径

5、例子：

controller如下：
在这里插入图片描述

新增save方法的接口为：http://localhost:8889/oms/test

查找某一个实体方法findByAttr的接口为：http://localhost:8889/oms/test/name/李白

GitHub地址：https://github.com/zhao458114067/zx-util

旭旭1998
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
Java利用反射自动封装成实体对象的方法
09-03
主要介绍了Java利用反射自动封装成实体对象的方法,可实现自动封装成bean对象功能,具有一定参考借鉴价值,需要的朋友可以参考下
Java-JDBC【之】数据类型、封装JDBCUtil、封装通用增删改、ResultSet与ResultSetMetaData
05-01
文章地址：https://blog.csdn.net/m0_37969197/article/details/124522810 Java-JDBC【之】数据类型、封装JDBCUtil、封装通用增删改、ResultSet与ResultSetMetaData、查询结果集映射Map与ListMap 1.数据类型 2.封装通用增删改 2.1.封装JDBCUtil 2.2.封装Dao通用增删改 2.3.测试 3.ResultSet与ResultSetMetaData 4.查询对象映射Map 4.1.封装queryMap() 4.2.测试 5.查询结果集映射ListMap 5.1.封装queryListMap() 5.2.测试 6.完整源码
java封装前端查询条件通用版
08-26
主要为大家详细介绍了java封装前端查询条件的通用版，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
Java封装统一的Result Model案例
08-24
主要介绍了Java封装统一的Result Model案例，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
java语言整合API接口自动化测试框架
06-04
接口测试框架 https://blog.csdn.net/qq_15283475/article/details/106494544 com.bjci.api #包名 ApiInfoModel.java ## Api类 ExcelUtills.java ##操作excel的类 HandlsUtils.java ##根据judge分发不同的judgeEvent HttpClientDemo.java ##模拟post 和 get 方法 JudgeEvent.java ##各种校验方法，比如code的校验，是否包含关键词的校验等 MyFileUtils.java ##文件的操作类 Out.java ##重新封装了System.out.println()方法，打印当前的时间 TaskModel.java ##创建本次API测试的任务 TestApi.java ##执行测试 TimeUtils.java ##操作时间的类 ———————————————— 版权声明：本文为CSDN博主「雨水的早晨」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。 原文链接：https://blog.csdn.net/qq_15283475/article/details/106494544
Controller、Model、View等的概念和使用方法
lonely_baby的博客
03-15 1631
在/hello请求处理方法中，我们使用Redirect的方式将请求重定向到/hello/redirect，这意味着浏览器会向/hello/redirect发起新的请求，并显示该请求的结果。而在/hello/forwarded请求处理方法中，我们没有向Model中添加任何数据，仅仅返回"hello"视图的名称，这意味着将会使用名为"hello"的JSP页面进行渲染，但是渲染结果是由/hello/forward方法中添加的数据决定的。在Controller中，可以通过返回值的方式指定View的名称。
Controller封装基础的增删改查BaseController，简化单表业务
Toushang_的博客
11-15 2654
配置代码生成器生成出controller、service、mapper，虽然大部分开源框架service与mapper都生成好了，但是controller中还遗留冗余代码，我的想法是能不能把基本的单表CRUD抽出来，提供一个公共的Controller控制器。
Spring MVC controller路径是否能够重复？
做一个有思想的技术人
04-28 1724
Spring MVC controller路径是否能够重复？
在JAVA中，一个类同时继承且实现时，父类与实现接口存在相同方法名的抽象方法时，如何处理？实现多个接口时，存在相同抽象方法名，如何处理？
Letol的博客
05-17 1238
先说结论：结论1、当父类和实现的接口之间，存在同名方法时，就近优先实现父类的抽象方法。结论2、当同名方法同时触发重写时，方法的：返回值类型、参数列表完全相同，实现类权限修饰符大于任意父类、接口的权限修饰符时（即：仅权限修饰符满足重载要求时）。可视为方法完全相同。所以：子类一次重写即可，不会报错。结论3、当同名方法触发重写时，参数列表不同、并且权限修饰符满足重载要求时。所以：子类可分别重写这些方法，不会报错。结论4、当同名方法触发重写时，参数列表相同、返回值类型不同、并且权限修饰符满足重载要求时。
当父类和父接口有相同的方法时
weixin_50730264的博客
10-19 489
当父类和父接口有相同的方法时
springboot2中重写RequestMappingHandlerMapping实现为指定包下所有的控制器(Controller|RestController)添加统一URI前缀...
chuantian3080的博客
03-13 4905
springboot2中重写RequestMappingHandlerMapping实现为指定包下所有的控制器(Controller|RestController)添加统一URI前缀 SpringBoot + 指定包下所有控制器 + 添加统一前缀 需求源自最近公司要求提供一套APP2.0的接...
springmvc里面controller能不能重载方法
你就像甜甜的益达
06-20 7121
导航了解重载编写代码ReqiestMapping里面value能一样吗?结论 了解重载 重载：重载字面意思多次的意思，也就是同一个方法实现多个不同的逻辑，并可以在同一个类中可以实现。其实现的原理是，方法名相同，参数的个数或者类型不同即可。 重写：重写就是要重新去写（实现），一个类中不可能两个定义一样的方法。因此，重写就是子类对父类定义的方法重新实现一次。 编写代码 然后后启动,访问正常 Reqi...
java方法重写
weixin_41781946的博客
02-01 152
package myOverride; /* 基本介绍 1、方法重写(覆盖)就是子类中有一个与父类中某个方法名成、参数列表、返回类型完全相同的方法 那么我们就说子类的这个方法覆盖了父类中的方法 注意事项（方法重写也叫方法覆盖，需要满足下面的条件） 1、子类的方法的 参数、方法名称，要和父类中对应方法完全一致 2、子类方法的返回类型和父类方法的返回类型一致，或是父类返回方法的子类 3、子类方法不能缩小父类方法的访问权限(如果父类中同名方法是public，那么
实现javaWeb对数据库的增删改查-MVC开发思想-Controller层之不同的请求使用一个Servlet的原理
qq_23937341的博客
08-06 979
1.项目简介 从jsp或者html发送请求给Servlet，这些请求包含数据的增删改查，如果每个功能都写一个Servlet，那显得也太不上档次了。 因此，如何实现页面发送的增删改查等不同的请求，用同一个Servlet来处理呢？ 1.1解决方案一：使用Get方式发送请求能够自定义携带参数的特性 1.1.1原理图 1.1.2具体实现 在WebContent目录...
JAVA方法重写（韩顺平）
wztmds的博客
03-27 250
一.方法重写 1.基本介绍 方法重写（覆盖）就是子类有一个方法，和父类的某个方法的名称，返回类型，参数一样，那么我们就说子类的这个方法覆盖了父类的方法 2.简单入门 public class Animal { public void sayOk(){ System.out.println("动物叫"); } } public class Dog extends Animal{ public void sayOk(){ System...
日常笔记--写一个简单的完整的查询接口
weixin_44388890的博客
11-04 6016
需求明确 1.现有剧场信息，需要给前端提供一个查询接口，方便用户能够根据自己的订单号和手机号查询出对应的剧场票详情信息。 2.比如订单号为“U820102819562509301”，查询出的信息应该如下： U820102819562509301 OFFLINE 新剧目 新剧目 2020-10-28 21:00:00 新产品 韩宾 410821199000000000 13930000000 T1321420552467152896 F -99 1 1 0 C区 01排06座 1.首先要明确需要
通过controller进行url重写
Terry - 专注外贸B2C
06-17 1003
改功能是将http://www.sample.com/tag/product/list/tagId/2，重写成http://www.sample.com/tag/2!1通过controller，具体详细原理我也说不清楚，大致是通过抓取一个事件来进行的！！这个事件就是controller_front_init_routers，然后把填写                  
SpringBoot 中的mapper，service，controller，model理解
热门推荐
qq_38973118的博客
05-08 2万+
springboot 只是组装了spring和springmvc。 目录直通车 一、SSM（Spring+SpringMVC+MyBatis）架构 1、 SSM的工作原理 （1） SSM系统架构 （2） SSM程序执行流程 2、 MSCM是什么及其作用 （1） controller （2） model  （3） service （4） mapper 二、 SpringBoot + Myb...
记一次重写RequestMappingHandlerMapping的经历
he_qiao_2010的专栏
06-20 4196
近期公司的产品做了一次安全审查，发现后端提供的接口有不安全的Http方法漏洞。不安全的HTTP方法一般包括：TRACE、PUT、DELETE、COPY 等。其中最常见的为TRACE方法可以回显服务器收到的请求，主要用于测试或诊断，恶意攻击者可以利用该方法进行跨站跟踪攻击（即XST攻击），从而进行网站钓鱼、盗取管理员cookie等。 原因分析 引起这个问题的原因其实很简单，因为开发人员开发接口的...
java的controller方法的查询参数的封装类应该如何命名
最新发布
07-15
对于Java的Controller方法的查询参数的封装类，一种常见的命名约定是以"DTO"（Data Transfer Object）结尾。根据具体场景和需求，可以考虑以下几种命名方式： 1. **[Entity]DTO**：使用与实体类相关的名称作为前缀，例如`UserDTO`、`ProductDTO`等。 2. **[Function]DTO**：根据功能或操作命名，例如`CreateUserDTO`、`UpdateProductDTO`等。 3. **[Action]DTO**：根据具体的动作命名，例如`SearchQueryDTO`、`FilterOptionsDTO`等。 这些命名约定可以根据项目的规范和个人偏好进行调整。重要的是保持一致性和可读性，使其他开发人员能够轻松理解代码的含义。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值