springMVC配置一个通配的url请求，替代@RequestMapping中指定的方式

最新推荐文章于 2024-06-22 08:15:00 发布
最新推荐文章于 2024-06-22 08:15:00 发布
阅读量1.2w 收藏 3
点赞数 3
分类专栏： springMVC 文章标签： spring mvc 通配url UrlHandler 统一约定url
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qiyongkang520/article/details/49456649
版权

第一步、创建一个自己的ControllerUrlHandlerMapping类

MyControllerClassNameHandlerMapping.java

package com.qiyongkang.sys.controller;

import org.springframework.util.ClassUtils;
import org.springframework.util.StringUtils;
import org.springframework.web.servlet.mvc.support.AbstractControllerUrlHandlerMapping;

/**
 * ClassName:MyControllerClassNameHandlerMapping <br/>
 * Function: TODO ADD FUNCTION. <br/>
 * Reason:   TODO ADD REASON. <br/>
 * Date:     2015年10月25日 下午5:03:01 <br/>
 * @author   qiyongkang
 * @version  
 * @since    JDK 1.6
 * @see      
 */
public class MyControllerClassNameHandlerMapping extends AbstractControllerUrlHandlerMapping {

    /**
     * 是否区分大小写
     */
    private boolean caseSensitive = false;

    /**
     * ctrl所在包路径的前缀
     */
    private String[] frameworkPackagePrefixs = new String[] {"com.qiyongkang."};

    /**
     * ctrl的类后缀
     */
    private String[] actionClassSuffixs = new String[]{"Ctrl", "Controller"};

    /**
     * ctrl所在包路径的后缀
     */
    private String[] actionPackageSuffixs = new String[] {"ctrl", "controller"};

    /**
     * 构造器
     */
    public MyControllerClassNameHandlerMapping() {
        super();
    }

    @SuppressWarnings("rawtypes")
    @Override
    protected String[] buildUrlsForHandler(String beanName, Class beanClass) {
        System.out.println("beanName:" + beanName + ",beanClass:" + beanClass.getName());
        //请求路径前缀
        StringBuilder pathMapping = buildPathPrefix(beanClass);
        System.out.println("pathMapping:" + pathMapping);

        //获取类名
        String className = ClassUtils.getShortName(beanClass);
        //请求路径后缀
        String path = getEndWithSuffixPath(className, actionClassSuffixs);
        System.out.println("path:" + path);

        if (path.length() > 0) {
            if (this.caseSensitive) {
                pathMapping.append(path.substring(0, 1).toLowerCase()).append(path.substring(1));
            }
            else {
                pathMapping.append(path.toLowerCase());
            }
        }

        //最终转换后的请求url路径
        String[] finalPath = null;
        if (isMultiActionControllerType(beanClass)) {
            finalPath = new String[] {pathMapping.toString(), pathMapping.toString() + "/*"};
        }
        else {
            finalPath = new String[] {pathMapping.toString() + "*"};
        }
        for (String str : finalPath) {
            System.out.println(str);
        }
        return finalPath;
    }

    /**
     * 
     * buildPathPrefix:生成请求前缀. <br/>
     *
     * @author qiyongkang
     * @param beanClass
     * @return
     * @since JDK 1.6
     */
    @SuppressWarnings("rawtypes")
    private StringBuilder buildPathPrefix(Class beanClass) {
        StringBuilder pathMapping = new StringBuilder();
        pathMapping.append("/");
        //在这里加入自己的URL映射逻辑规范
        pathMapping.append(buildPathByBeanClass(beanClass, frameworkPackagePrefixs, actionPackageSuffixs, caseSensitive));
        return pathMapping;
    }

    /**
     * 
     * buildPathByBeanClass:根据类名称和包名称来组成自定义的URL映射. <br/>
     *
     * @author qiyongkang
     * @param beanClass
     * @param frameworkPackagePrefixs
     * @param actionPackageSuffixs
     * @param caseSensitive
     * @return
     * @since JDK 1.6
     */
    @SuppressWarnings("rawtypes")
    private String buildPathByBeanClass(Class beanClass, String[] frameworkPackagePrefixs, String[] actionPackageSuffixs, boolean caseSensitive) {
        String packageName = ClassUtils.getPackageName(beanClass);
        if (StringUtils.isEmpty(packageName)) {
            return "";
        }
        String actionPackageSuffix = "";
        for (String packageSuffix : actionPackageSuffixs) {
            if (packageName.endsWith(packageSuffix)) {
                actionPackageSuffix = packageSuffix;
                break;
            }
        }
        String newpackageName="";
        for (String frameworkPackagePrefix : frameworkPackagePrefixs) {
            if (packageName.startsWith(frameworkPackagePrefix)) {
                newpackageName = StringUtils.replace(packageName, frameworkPackagePrefix, "");
//              break;
            }
        }
        newpackageName = StringUtils.replace(newpackageName, actionPackageSuffix, "");
        newpackageName = StringUtils.replace(newpackageName, ".", "/");
        return (caseSensitive ? newpackageName : newpackageName.toLowerCase()) + "/";
    }

    /**
     * 
     * getEndWithSuffixPath:根据类后缀数组筛选出path的结果. <br/>
     *
     * @author qiyongkang
     * @param className
     * @param suffixs
     * @return
     * @since JDK 1.6
     */
    private String getEndWithSuffixPath(String className, String[] suffixs) {
        String path = "";
        for (String suffix : suffixs) {
            if (className.endsWith(suffix)) {
                path = className.substring(0, className.lastIndexOf(suffix));
                break;
            }
        }
        return StringUtils.isEmpty(path) ? className : path;
    }

    public boolean isCaseSensitive() {
        return caseSensitive;
    }

    public void setCaseSensitive(boolean caseSensitive) {
        this.caseSensitive = caseSensitive;
    }

    public String[] getFrameworkPackagePrefixs() {
        return frameworkPackagePrefixs;
    }

    public void setFrameworkPackagePrefixs(String[] frameworkPackagePrefixs) {
        this.frameworkPackagePrefixs = frameworkPackagePrefixs;
    }

    public String[] getActionClassSuffixs() {
        return actionClassSuffixs;
    }

    public void setActionClassSuffixs(String[] actionClassSuffixs) {
        this.actionClassSuffixs = actionClassSuffixs;
    }

    public String[] getActionPackageSuffixs() {
        return actionPackageSuffixs;
    }

    public void setActionPackageSuffixs(String[] actionPackageSuffixs) {
        this.actionPackageSuffixs = actionPackageSuffixs;
    }



}

第二步、在springMVC配置文件中配置UrlHandlerMap

spring-mvc.xml:

<?xml version="1.0" encoding="UTF-8"?>
<beans:beans xmlns="http://www.springframework.org/schema/mvc"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:mvc="http://www.springframework.org/schema/mvc"
    xmlns:beans="http://www.springframework.org/schema/beans" xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="
        http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd ">
  <!-- 设置controller注解所在包 -->
  <context:component-scan base-package="com.qiyongkang.**.controller" />

  <!-- 主要作用于@Controller，激活该模式，下面是一种简写形式，完全可以手动配置替代这种简写形式，它会自动注册DefaultAnnotationHandlerMapping与AnnotationMethodHandlerAdapter，是spring MVC为@Controllers分发请求所必须的   -->
  <!-- <mvc:annotation-driven/> -->

  <!-- 配置js,css,img等静态文件直接映射到对应的文件夹，不被DispatcherServlet处理 -->
  <mvc:resources location="/resources/**" mapping="/resources/**" />

  <!-- 配置一个缺省映射的UrlHandlerMap，尝试通配URL -->
  <beans:bean id="myControllerClassNameHandlerMapping" class="com.qiyongkang.sys.controller.MyControllerClassNameHandlerMapping">
      <!-- 过滤器 -->
      <beans:property name="interceptors">
          <beans:array>
              <beans:bean id="sysLogInterceptor" class="com.qiyongkang.sys.interceptor.SysLogInterceptor"></beans:bean>
          </beans:array>
      </beans:property>
      <!-- 打开URL大小写区分 -->
      <beans:property name="caseSensitive" value="true" />
      <!-- 配置框架的包名前缀,默认值是com.qiyongkang.，这里是区分大小写的 -->
      <beans:property name="frameworkPackagePrefixs" value="com.qiyongkang." />
      <!-- 配置Controller包后缀，默认值是controller，这里是区分大小写的 -->
      <beans:property name="actionPackageSuffixs" value=".ctrl,.controller" />
      <!-- 配置Controller类后缀，默认值是Controller，这里是区分大小写的 -->
      <beans:property name="actionClassSuffixs" value="Ctrl,Controller" />
  </beans:bean>

  <!-- 启动Spring MVC的注解功能，完成请求和注解POJO的映射 -->
  <beans:bean class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter">
      <!-- 配置转换器集合 -->
      <beans:property name="messageConverters">
          <beans:list>
              <beans:bean class="org.springframework.http.converter.BufferedImageHttpMessageConverter" />
              <beans:bean class="org.springframework.http.converter.ByteArrayHttpMessageConverter" />
              <beans:bean class="org.springframework.http.converter.StringHttpMessageConverter">
                <!-- 解决响应文本乱码问题 -->
                <beans:property name="supportedMediaTypes">
                    <beans:list>
                        <beans:value>text/html;charset=UTF-8</beans:value>
                    </beans:list>
                </beans:property>
              </beans:bean>
              <beans:bean class="org.springframework.http.converter.xml.XmlAwareFormHttpMessageConverter" />
              <beans:bean class="org.springframework.http.converter.json.MappingJacksonHttpMessageConverter">
                <beans:property name="supportedMediaTypes">
                  <beans:list>
                    <beans:value>application/json;charset=UTF-8</beans:value>
                  </beans:list>
                </beans:property>
              </beans:bean>
          </beans:list>
      </beans:property>
  </beans:bean>

  <!-- 对转向页面的路径解析。prefix：前缀， suffix：后缀 -->
  <beans:bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    <beans:property name="prefix" value="/WEB-INF/views/" />
    <beans:property name="suffix" value=".jsp" />
  </beans:bean>

  <!-- 配置文件上传组件 -->
  <beans:bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
      <!-- 配置编码，默认编码 (ISO-8859-1) -->
      <beans:property name="defaultEncoding" value="UTF-8" />
      <!-- 配置最大内存大小 (10240) -->
      <beans:property name="maxInMemorySize" value="10240" /> 
      <!-- 配置上传时的临时文件存放目录 
      <beans:property name="uploadTempDir" value="upload/temp" />
      -->
      <!-- 配置最大文件大小，-1为无限止(-1) -->
      <beans:property name="maxUploadSize" value="-1" /> 
  </beans:bean>
</beans:beans>

beanId为myControllerClassNameHandlerMapping的类，便是我们将所有controller的请求按照自己的约定方式生成请求路径的处理类。

第三步，生成的url格式

首先，我们来看看，我们的两个controller类。
UserController.java:

package com.qiyongkang.sys.controller;

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

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;

import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.view.RedirectView;

import com.qiyongkang.sys.model.User;
import com.qiyongkang.sys.service.UserService;
import com.qiyongkang.sys.util.Page;

@Controller
@RequestMapping
public class UserController extends BaseController{

    private static Logger log = Logger.getLogger(UserController.class);

    @Autowired
    private UserService userService;

    @RequestMapping
    public ModelAndView login(HttpServletRequest request) {
        ModelAndView mav = new ModelAndView(new RedirectView(request.getContextPath() + "/index.jsp"));
        HttpSession session = request.getSession();
        session.setAttribute("user", new User());
        return mav;
    }

    @RequestMapping
    @ResponseBody
    public Page<User> getPageModel(User user, int page, int rows) {
        Page<User> pageModel = new Page<User>();
        try {
            user.setCurrentPage(page);
            user.setPageSize(rows);

            //Get total
            int total = userService.getUserCount(user);
            pageModel.setTotal(total);

            //Get list
            List<User> users = userService.listUser(user);
            pageModel.setRows(users);

        } catch (Exception e) {
            log.error("分页信息失败",e);
        }
        return pageModel;
    }

    @RequestMapping
    @ResponseBody
    public List<User> getUserList() {
        User user = new User();
        user.setCurrentPage(1);
        user.setPageSize(10);
        return userService.listUser(user);
    }

    @RequestMapping
    @ResponseBody
    public User getEntity(int id) {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return userService.getUserById(id);
    }

    @RequestMapping
    @ResponseBody
    public void editEntity(User user) {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Edit user:" + user);
        userService.updateUser(user);
    }

    @RequestMapping
    @ResponseBody
    public void addEntity(User user) {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Add user:" + user);
        userService.addUser(user);
    }

    @RequestMapping
    @ResponseBody
    public void deleteEntity(@RequestParam(value = "ids[]", required=true) int[] ids) {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(ids);
        List<Integer> nums = new ArrayList<Integer>();
        for (int i : ids) {
            nums.add(i);
        }
        userService.deleteUser(nums);
    }
}

RedirectCtrl.java:

package com.qiyongkang.sys.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;

@Controller
@RequestMapping
public class RedirectCtrl extends BaseController {

    @RequestMapping
    public ModelAndView redirectHomePage(String path) {
        ModelAndView mav = new ModelAndView(path);
        return mav;
    }
}

再来看看项目的包结构，如下图：
这里写图片描述

最后，再来看看控制台输出的请求路径格式：
这里写图片描述
这样，我们在前端请求后台时，只需发送如下格式的请求，例如：
http://localhost:8080/qyk_testSpringMVC/sys/user/getPageModel.do

关于通配url请求就讲到这儿啦，它的好处可想而知，以后无需在@RequestMapping中指定值，同时也可以按照一定的规则来配置整个后台请求的格式，方便前端调用。
另外，哪位小伙伴有啥疑问的，都可以给我留言，谢谢！

qiyongkang520
关注
专栏目录
Spring-MVC配置项目框架、注释@Repository/@Service/@Controller/@RequestMapping入门讲解
qq_53092699的博客
07-16 556
主要讲解Mvc项目框架配置，以及部分后端基本运用的注解
SpringMVC——入门使用SpringMVC和@RequestMapping
Stay Hungry Stay Foolish
03-15 462
初步使用 首先我们在springmvc.xml中加入 <!-- 视图解析器 --> <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="internalResourceViewResolver"> <!--下面两个...
springboot controller中的@RequestMapping @Controller @RestController
切yi的博客
02-10 1406
Controller控制器层主要用到的注解几乎都是依赖于SpringMVC框架 我们在控制器层主要用到的注解有： 一般情况下写在类上的注解 注解 作用 @RequestMapping 你可以使用@RequestMapping注解来将请求URL映射到整个类上或某个特定的方法上，即@RequestMapping 既可以定义在类上，也可以定义方法上 @Controller @Cont...
@RequestMapping注解
ustbbsy的博客
12-28 307
@RequestMapping(path = "/user") @RequestMapping(path="/login",method=RequestMethod.GET) org.springframework.web.bind.annotation.RequestMethod来定义浏览器请求的方式。 RequestMethod. GET POST PUT DELETE 注解的位置 注解在方法上 @Controller p...
Spring中的ContextPath总结
最新发布
技术研究中心
06-22 661
ContextPath是Spring Web应用程序中重要的概念之一，它用于标识和定位Web应用程序，并且在URL映射和资源定位中起着关键作用。了解ContextPath的用法和获取方法对于开发和维护Spring应用程序是非常重要的。在实际应用中，我们应该根据具体情况合理设置ContextPath，并在开发过程中注意路径的拼接和处理。
springmvc所有方法url映射获取
05-16
通过重写dispatcherservlet的一个doservice方法把springmvc的url对应方法打印出来。 所需要做的是： 1，使用本文件作为原先springmvc的xml文件的dispatcherservlet。 2，启动项目，随意发送一个请求，可以在控制台看到打印的所有映射的关系。
Spring MVC URI 通配
ywb201314的专栏
04-19 807
@RequestMapping(value={"url1","url2","url3"....}) //还可以配置通配符匹配多个请求 value的uri值为以下三类： A）  可以指定为普通的具体值； B)   可以指定为含有某变量的一类值(URI Template Patterns with Path Variables)； 1
Spring MVC的@RequestMapping多个URL映射到同一个方法
angou6476的博客
09-13 1320
@RequestMapping可以是一个URL对应一个方法，也可以多个URL对应同一个方法，写法如下： @RequestMapping(value={"url","resturl"}) public String url() { 　　return "url"; } 转载于:https://www.cnblogs.com/EasonJim/p/7517...
springMVC（四）—— 简化配置之不用再写@Repository类
qq_44886213的博客
07-17 278
service层的实例就要去调用dao层的实例，那我们就得写BookMapper接口的实现类BookMapperImpl。如何简化一下，不用写实现类了呢？在我们只用mybatis这一个框架的时候，假如我们有一个BookMapper.java接口，有一个对应的BookMapper.xml配置文件，并不需要写BookMapper接口的实现类BookMapperImpl.java。在spring配置文件中进行如下的配置，不仅能够自动生成dao层的实现类，还能自动注入到bean中。
Spring MVC中的URL匹配规则
qq_40927579的博客
07-18 2004
个人博客www.ylhwan.com URL匹配规则有如下几种： （1）精准匹配 中的配置项必须与URL完全精确匹配 spring-dispatcher /ay /index.html /test/ay.html 当在浏览器中输入如下几种URL，都会被匹配到该Servlet，具体代码如下 http://localhost/...
2.ssm配置RequestMapping/获取请求中的参数
weixin_42561980的博客
05-11 1915
@RequestMapping 请求映射 告诉SpringMVC， 控制器里的这个方法处理哪个请求 从源码中发现，RequestMapping可以标明在方法上，也可以标明在类上。
SpringMVC基于代码的配置方式（零配置，无web.xml）
12-20
2. 创建WebApplicationInitializer：在无web.xml的配置中，我们需要创建一个实现了`WebApplicationInitializer`接口的类，用来初始化DispatcherServlet，这是SpringMVC的核心组件，负责处理请求。 3. 配置...
3.springmvc之@RequestMapping
weixin_48377011的博客
06-27 155
3.springmvc之@RequestMapping @RequestMapping ​ @RequestMapping用来匹配客户端发送的请求，可以在方法上使用，也可以在类上使用。 ​ 方法：表示用来匹配要处理的请求 ​ 类上：表示为当前类的所有方法的请求地址添加一个前置路径，访问的时候必须要添加此路径 package com.mashibing.controller; import org.springframework.stereotype.Controller; import org.sp
springmvc controller @requestMapping 完成url请求通配
相互分享，共同进步
12-09 3178
1.匹配一级路径, 一个通配符只匹配/comfirm/asfsa, 而无法匹配/confirm/asf/asfsaf: @RequestMapping("/confirm/*") public String confirm(HttpServletRequest request, Model model) { return ""; }2.匹配所有前缀为/conf
探索SpringMVC-HandlerMapping之RequestMappingHandlerMapping
Evan_L的博客
12-17 1183
那么为什么要单独给@RequestMapping实现一个HandlerMapping？这次咱们就来专门看看这个RequestMappingHandlerMapping
SpringMVC技巧之通用Controller
夫礼者的专栏
05-25 7135
一个通用Controller。大多数情况下不再需要编写任何Controller层代码，将开发人员的关注点全部集中到Service层。
SpringMVC04-Controller控制器配置
weixin_39395819的博客
01-26 1244
Controller控制器配置总结 控制器 Controller，复杂提供访问应用程序的行为，通常通过接口定义或者注解定义两种方式实现 控制器Controller ： 负责解析用户的请求并将其转换为一个模型 在spring mvc中一个控制器可以包含多个方法 在spring mvc中，对于controller的配置方式有很多种，下面讲述下具体的配置方式 1 方式一：实现Controller接口 第1步，新建一个maven子项目，并添加web能力支持，配置项目的lib包内容 第2步，编写web.xml，配置D
Idea全局替换@RequestMapping
tinkBelll的博客
05-07 804
项目场景： 场景是这样的：老大发现一个老旧的项目请求量很少但是响应时间却在100ms以上，然后@我让我在所有请求上监控，项目用到就是 @Timed，就是让我补上这个注解... 解决方案 这要是一个一个加，我特么不得加一天，那还怎么摸鱼，果断用正则全局替换，如下： 正则表达式： ((\@RequestMapping)+\((value)?\s*=?\s*\{?"(/\w+)+"(,*\s*\w+\s*=\s*\w*\.?/*\w+\s*)*\)) 我正则功底不咋的，凑合看吧！完事把@RequestM
SpringMVC(5) —— Controller配置总结
Jzandth的博客
09-20 643
目录1.控制器Controller2.代码实现方式1 实现controller接口方式2 使用注解 1.控制器Controller 控制器复杂提供访问应用程序的行为，通常通过接口定义或注解定义两种方法实现 控制器负责解析用户的请求并将其转换为一个模型 在Spring MVC中一个控制器类可以包含多个方法 在Spring MVC中，对于Controller的配置方式有很多种 2.代码实现 创建新项目：SpringMVC-04-Controller pom.xml <build>
SpringMVC注解驱动详解：简化Controller配置
通过在方法上添加多个`@RequestMapping`注解，一个控制器方法可以处理多个URL请求。 ### 3. 绑定URL参数 - `@PathVariable`: 用于获取URL模板变量的值，例如`/user/{id}`，`@PathVariable("id")`会将URL中的`id`...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值