项目实战：抽取中央控制器 DispatcherServlet

 

package com.csdn.mymvc.core;
import jakarta.servlet.ServletException;
import jakarta.servlet.annotation.WebServlet;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import java.io.IOException;
@WebServlet("/*")
public class DispatcherServlet extends HttpServlet {
    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
 
    }
}

•  @WebServlet(“/*”)配置中的/*表示该Servlet可以处理所有的请求路径。也就是说，当访问任何路径时，都会被该Servlet处理

package com.csdn.fruit.servlet;
import com.csdn.fruit.dto.PageInfo;
import com.csdn.fruit.dto.PageQueryParam;
import com.csdn.fruit.dto.Result;
import com.csdn.fruit.pojo.Fruit;
import com.csdn.fruit.service.FruitService;
import com.csdn.fruit.service.impl.FruitServiceImpl;
import com.csdn.fruit.util.RequestUtil;
import com.csdn.fruit.util.ResponseUtil;
import jakarta.servlet.ServletException;
import jakarta.servlet.annotation.WebServlet;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import java.io.IOException;
@WebServlet("/fruit/*")
public class FruitServlet extends HttpServlet {
    private FruitService fruitService = new FruitServiceImpl();
    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //     /fruit/index
        String uri = req.getRequestURI();
        uri = uri.substring(1);
        String[] split = uri.split("/");
        String methodName = split[1];
        switch (methodName) {
            case "index" ->index(req,resp);
            case "add"-> add(req, resp);
            case "del"->del(req,resp);
            case "edit"->edit(req,resp);
            case "getFname"-> getFname(req, resp);
            case "update"  -> update(req, resp);
        }
    }
 
    protected void index(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        Integer pageNo = 1;
        String pageNoStr = req.getParameter("pageNo");
        if (pageNoStr != null && !"".equals(pageNoStr)) {
            pageNo = Integer.parseInt(pageNoStr);
        }
 
        String keyword = "";
        String keywordStr = req.getParameter("keyword");
        if (keywordStr != null) {
            keyword = keywordStr;
        }
        PageQueryParam pageQueryParam = new PageQueryParam(pageNo, 5, keyword);
        PageInfo pageInfo = fruitService.getFruitPageInfo(pageQueryParam);
 
        Result result = Result.OK(pageInfo);
 
        ResponseUtil.print(resp, result);
    }
 
    protected void add(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        Fruit fruit = (Fruit) RequestUtil.readObject(req, Fruit.class);
        fruitService.addFruit(fruit);
        ResponseUtil.print(resp, Result.OK());
    }
 
    protected void del(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        Integer fid = Integer.parseInt(req.getParameter("fid"));
        fruitService.delFruit(fid);
        ResponseUtil.print(resp, Result.OK());
    }
 
    protected void edit(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        Integer fid = Integer.parseInt(req.getParameter("fid"));
        Fruit fruit = fruitService.getFruitById(fid);
        ResponseUtil.print(resp, Result.OK(fruit));
    }
 
    public void getFname(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String fname = req.getParameter("fname");
        Fruit fruit = fruitService.getFruitByFname(fname);
        ResponseUtil.print(resp, fruit == null ? Result.OK() : Result.Fail());
    }
 
    protected void update(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        Fruit fruit = (Fruit) RequestUtil.readObject(req, Fruit.class);
        fruitService.updateFruit(fruit);
        ResponseUtil.print(resp, Result.OK());
    }
}

DispatcherServlet是Spring MVC框架中最核心的控制器，它的主要作用是接收客户端请求，并把请求分发给对应的处理器进行处理，并将处理结果返回给客户端。

具体来说，DispatcherServlet接收到客户端请求后，首先会根据请求的URL找到对应的HandlerMapping，然后通过HandlerAdapter调用对应的Controller进行处理，最后将处理结果封装成ModelAndView并返回给DispatcherServlet。DispatcherServlet会根据ViewResolver将ModelAndView中的模型数据和视图进行组合，生成最终的响应结果并返回给客户端。

除了请求分发的功能外，DispatcherServlet还负责一些其他的工作，比如维护Spring容器、处理异常、支持文件上传等。因此，DispatcherServlet可以说是整个Spring MVC框架的核心，也是实现Spring MVC框架各种功能的基础。

DispatcherServlet是Spring MVC框架中的一个关键组件，它是一个Servlet，用于将客户端请求分发到不同的Controller中进行处理，并将处理结果返回给客户端。

具体来说，DispatcherServlet的作用包括：

1. 接收客户端的请求：DispatcherServlet作为前端控制器，接收客户端的所有请求。

2. 根据请求路径选择对应的Controller：DispatcherServlet根据请求的URL路径，从HandlerMapping中找到匹配的Controller。

3. 执行Controller中的业务逻辑：DispatcherServlet将请求转发给Controller，由Controller执行相应的业务逻辑。

4. 返回处理结果：Controller处理完业务逻辑后，将处理结果返回给DispatcherServlet，由DispatcherServlet将结果封装成视图对象，并将视图对象返回给客户端。

5. 支持多视图：DispatcherServlet支持多种视图技术，可以将控制器的处理结果转换成JSP、Freemarker、Velocity、Thymeleaf等多种视图，并返回给客户端。

总之，DispatcherServlet是Spring MVC框架中非常重要的一个组件，它负责将客户端请求转发给对应的Controller，并将处理结果返回给客户端。  

DispatcherServlet是Spring MVC框架中的核心控制器，它负责接收用户的请求，并将请求分发到对应的Handler中进行处理。具体来说，它的作用如下：

1. 接收和处理HTTP请求：DispatcherServlet会拦截到所有的HTTP请求，并负责转发和调度这些请求到不同的处理方法中。

2. 将请求分发到对应的Handler中：DispatcherServlet会根据请求中的URI定位到对应的Handler，然后将请求转发到该Handler中进行处理。

3. 支持请求处理器的映射：DispatcherServlet会维护一个URL到处理器的映射关系，用于决定请求如何被处理。

4. 支持多种视图技术：DispatcherServlet可以根据请求中的Accept头信息，选择合适的视图解析器对处理结果进行视图渲染。

5. 提供统一的异常处理：DispatcherServlet可以捕获Controller方法抛出的异常，并选择合适的异常处理器进行处理。

DispatcherServlet是Spring框架中用于处理Web请求的核心组件之一。它的作用是接收客户端发来的请求，在Web应用程序中找到相应的处理程序并将请求分派给它，然后将处理程序处理后的响应结果返回给客户端。

具体来说，DispatcherServlet会把传入的HTTP请求分派给一个或多个处理器(Controller)，这些处理器会基于请求的内容或其他任何信息来执行所需的业务逻辑，然后生成合适的响应结果并返回给DispatcherServlet。DispatcherServlet会负责收集所有响应结果并将它们合并为一个完整的响应内容，然后发回给客户端。

此外，DispatcherServlet还能够支持处理多种不同类型的请求（例如GET、POST、PUT等），以及支持多种不同的视图技术（例如JSP、Thymeleaf、Freemarker等）来呈现响应结果。这些功能都使得DispatcherServlet成为了一个非常重要的组件，在简化Web开发、提高效率和灵活性方面都有着重要的作用。

DispatcherServlet 是 Spring MVC 中的核心组件之一，具有以下作用：

1. 请求分发：DispatcherServlet 接收到用户发起的请求，根据请求 URI 和 HandlerMapping 将其分发到对应的 Controller 中进行处理。

2. 视图解析：DispatcherServlet 将处理结果交给对应的 ViewResolver 进行视图解析，最终渲染成完整的响应返回给用户。

3. 异常处理：DispatcherServlet 捕获 Controller 中可能抛出的异常，并将其交给对应的 ExceptionResolver 进行处理，最终渲染成友好的错误页面返回给用户。

4. 拦截器：DispatcherServlet 支持对请求的拦截和处理，通过 HandlerInterceptor 可以实现类似登录拦截、权限拦截、日志记录等功能。

总之，DispatcherServlet 在 Spring MVC 中起到了请求分发、视图渲染、异常处理和拦截器等核心作用，是整个 Spring MVC 框架的核心驱动。

 

在Java中，DispatcherServlet是Spring MVC框架的核心组件，它的主要作用是将HTTP请求分派给合适的处理程序(Controller)来处理。DispatcherServlet接收来自客户端的请求，然后根据请求的URL路径找到对应的处理程序(Controller)并将请求转发给它来处理。在转发请求之前，DispatcherServlet还会调用一些拦截器(Interceptor)来处理一些通用的逻辑，如身份验证、日志记录等。而在处理程序(Controller)处理完请求后，DispatcherServlet还会将处理结果返回给客户端。

除了分派HTTP请求外，DispatcherServlet还具有其他一些作用，例如自动装配(autowiring)处理程序(Controller)、处理多种视图(View)类型、管理Web应用程序的上下文环境(Context)等。总之，DispatcherServlet是Spring MVC框架中非常重要的一部分，它承担了连接Web层和应用层的桥梁作用，使得开发人员能够轻松地开发出高效、易于维护的Web应用程序。

DispatcherServlet是Spring MVC框架中最核心的控制器，它的主要作用是接收客户端请求并进行分发处理，将请求分配到相应的处理器(Controller)进行处理。具体来说，DispatcherServlet执行以下几个步骤：

1. 接收客户端请求，并解析请求的URL；
2. 根据请求的URL，将请求分配给对应的Handler(处理器)进行处理；
3. 处理器处理完成后，将处理的结果返回给DispatcherServlet；
4. DispatcherServlet再根据处理的结果，选择适当的View(视图)进行渲染；
5. 将渲染后的视图返回给客户端。

因此，可以说DispatcherServlet是Spring MVC框架中请求处理的入口，起到了非常重要的作用。