手写Spring-MVC之DispatcherServlet无组件版

已于 2024-07-04 15:42:07 修改
阅读量596 收藏 5
点赞数 6
分类专栏： 从零开始的Java学习 文章标签： java-ee
于 2024-06-27 20:22:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_67496588/article/details/140023597
版权

Day47

手写Spring-MVC之DispatcherServlet

DispatcherServlet的思路：

前端传来URI，在TypeContainer容器类中通过uri得到对应的类描述类对象（注意：在监听器封装类描述类对象的时候，是针对于每一个URI进行封装的，也就是说每一个方法（uri）都有一个类描述类），通过类描述类对象获得类对象和方法描述类对象，再通过方法描述类对象获得方法对象和参数描述类对象。对参数描述类对象进行处理获得参数数组，然后通过method.invoke()执行方法，并返回值，最后处理返回值。

public class DispatherServlet extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        this.doPost(request, response);
    }

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        request.setCharacterEncoding("UTF-8");
        response.setContentType("text/html;charSet=UTF-8");

        String uri = request.getRequestURI();
        HashMap<String, BeanDefinition> maps = TypeContainer.getMaps();
        BeanDefinition beanDefinition = maps.get(uri);
        if(beanDefinition==null){
            //System.out.println("没找到该uri下的类描述类");
            throw new FrameWorkException(ResponseCode.REQUEST_PATH_EXCEPTION.getCode(),ResponseCode.REQUEST_PATH_EXCEPTION.getMessage());
        }
        Object t = beanDefinition.getT();
        MethodDefinition methodDefinition = beanDefinition.getMethodDefinition();
        Method method = methodDefinition.getMethod();
        method.setAccessible(true);
        Model model = new Model();
        List<ParameterDefinition> parameterDefinitions = methodDefinition.getParameterDefinitions();
        Object[] args = handlerParameterArgs(parameterDefinitions, request, response,model);
        try{
            //调用Controller层里的某个方法
            Object returnVal = method.invoke(t, args);

            if(returnVal!=null){
                //处理返回值
                handlerReturnVal(methodDefinition,returnVal,request,response,model);
            }
        }catch (Exception e){
            System.out.println("出现异常了，处理全局异常");
        }


    }
    public void handlerReturnVal(MethodDefinition methodDefinition,Object returnVal,HttpServletRequest request,HttpServletResponse response,Model model) throws ServletException, IOException {

        if(methodDefinition.isResponseBodyHasOrNot()){
            //返回数据为JSON格式
            String jsonString = JSON.toJSONString(returnVal);
            sendResponse(response,jsonString);

        }
        else if(returnVal.getClass()==String.class){
            //如果返回值是字符串，先添加请求数据，再跳转（转发）

            handlerRequestVal(request,model.getMaps());
            jumpPage(returnVal,request,response);
        } else if (returnVal.getClass() == ModelAndView.class) {
            //如果返回值是ModelAndView，添加请求后跳转（转发）
            ModelAndView modelAndView = (ModelAndView) returnVal;
            handlerRequestVal(request,modelAndView.getMaps());
            jumpPage(modelAndView.getViewName(),request,response);

        }
    }
    public void sendResponse(HttpServletResponse response,String jsonString) throws IOException {
        response.getWriter().write(jsonString);
    }
    public void handlerRequestVal(HttpServletRequest request,Map<String,Object> maps){
        Set<Map.Entry<String, Object>> entries = maps.entrySet();
        for (Map.Entry<String, Object> entry : entries) {
            String key = entry.getKey();
            Object value = entry.getValue();
            request.setAttribute(key,value);


        }
    }

    public void jumpPage(Object returnVal,HttpServletRequest request,HttpServletResponse response) throws ServletException, IOException {
        String str = (String) returnVal;
        request.getRequestDispatcher(str).forward(request,response);
    }
    public Object[] handlerParameterArgs(List<ParameterDefinition> parameterDefinitions,HttpServletRequest request,HttpServletResponse response,Model model){
        if(parameterDefinitions==null){
            return null;
        }
        Object[] args = new Object[parameterDefinitions.size()];
        for (ParameterDefinition parameterDefinition : parameterDefinitions) {

            Class<?> clazz = parameterDefinition.getClazz();//获取参数的class对象
            String name = parameterDefinition.getName();//获取参数的名字
            int index = parameterDefinition.getIndex();//获取参数的下标
            if(judgeTypeIsJavaOrNot(clazz)){//判断是否是Java常用数据类型
                args = handlerJavaType(request, name, clazz, args, index);
            } else if (clazz==HttpServletRequest.class) {//判断是否是请求类型
                args[index] = request;
            } else if (clazz==HttpServletResponse.class) {//判断是否是响应类型
                args[index] = response;
            } else if (clazz == String[].class) {//判断是否是数组类型
                String[] arr = request.getParameterValues(name);
                args[index] = arr;
            } else if (clazz == List.class) {//判断是否是List集合类型
                handlerListType(request,parameterDefinition,args,index);

            } else if (clazz== Model.class) {//判断是否是Model类型
                args[index] = model;
            }else{//判断是否是自定义类型
                handlerOtherType(parameterDefinition,request,args,index);
            }
        }
        return args;
    }

    public void handlerOtherType(ParameterDefinition parameterDefinition,HttpServletRequest request,Object[] args,int index){
        try {
            if(parameterDefinition.isRequestBodyHasOrNot()){
                //如果返回的是JSON格式数据
                BufferedReader br = request.getReader();
                StringBuffer sb = new StringBuffer();
                char[] cs = new char[1024];
                int len;
                while((len= br.read(cs))!=-1){
                    sb.append(cs,0,len);
                }
                String jsonStr = sb.toString();
                Object obj = JSON.parseObject(jsonStr,parameterDefinition.getClazz());
                args[index] = obj;


            }else{
                Object obj = parameterDefinition.getClazz().newInstance();
                Map<String, String[]> parameterMap = request.getParameterMap();
                BeanUtils.populate(obj,parameterMap);
                args[index] = obj;
            }



        } catch (InstantiationException | IllegalAccessException | InvocationTargetException | IOException e) {
            throw new RuntimeException(e);
        }
    }
    public void handlerListType(HttpServletRequest request,ParameterDefinition parameterDefinition,Object[] args,int index){
        Map<String, String[]> parameterMap = request.getParameterMap();
        //key --- Value
        //user[0].username --- new String[]{"pengyuyan"};
        //user[0].password --- new String[]{"123123"};
        //user[1].username --- new String[]{"wuyanzu"};
        //user[1].password --- new String[]{"123456"};
        

        //获取泛型类型
        Type pt = parameterDefinition.getActualTypeArguments()[0];
        String className = pt.getTypeName();
        Class<?> aClass = null;
        try {
            aClass = Class.forName(className);
        } catch (ClassNotFoundException e) {
            throw new RuntimeException(e);
        }

        ArrayList<Object> list = new ArrayList<>();
        Set<Map.Entry<String, String[]>> entries = parameterMap.entrySet();
        for (Map.Entry<String, String[]> entry : entries) {
            String key = entry.getKey();//user[0].username
            String[] value = entry.getValue();//new String[]{"guodan"}
            int i = Integer.parseInt(key.substring(key.indexOf("[") + 1, key.indexOf("]")));//集合中的下标
            String fieldName = key.substring(key.indexOf(".") + 1);//集合中元素对象的属性名
            String fieldValue = value[0];//获取集合中元素对象里的属性值

            Object o =null;
            try{
                o = list.get(i);
            }catch (IndexOutOfBoundsException e){
                //该集合下标上没有元素
                try {
                    o = aClass.newInstance();//创建对象
                    list.add(o);//添加对象
                } catch (InstantiationException | IllegalAccessException ex) {
                    throw new RuntimeException(ex);
                }

            }
            try {
                    BeanUtils.setProperty(o,fieldName,fieldValue);//设置对象属性
                } catch (IllegalAccessException | InvocationTargetException ex) {
                    throw new RuntimeException(ex);
                }
                args[index] = list;


        }
    }
    public Object[] handlerJavaType(HttpServletRequest request,String name,Class<?> clazz,Object[] args,int index){
        String parameter = request.getParameter(name);
        if(clazz==byte.class || clazz==Byte.class){
            args[index] =  Byte.parseByte(parameter);
        }else if(clazz==short.class || clazz==Short.class){
            args[index] = Short.parseShort(parameter);
        }else if(clazz==int.class || clazz==Integer.class){
            args[index] = Integer.parseInt(parameter);
        }else if(clazz==long.class || clazz==Long.class){
            args[index] = Long.parseLong(parameter);
        }else if(clazz==float.class || clazz==Float.class){
            args[index] = Float.parseFloat(parameter);
        }else if(clazz==double.class || clazz==Double.class){
            args[index] = Double.parseDouble(parameter);
        }else if(clazz==char.class || clazz==Character.class){
            args[index] = parameter.toCharArray()[0];
        }else if(clazz==boolean.class || clazz==Boolean.class){
            args[index] = Boolean.parseBoolean(parameter);
        }if(clazz==String.class){
            args[index] = parameter;
        }
        return args;
    }
    public boolean judgeTypeIsJavaOrNot(Class<?> clazz){
        if(clazz==byte.class || clazz==Byte.class || clazz==short.class || clazz==Short.class || clazz==int.class || clazz== Integer.class || clazz==long.class || clazz== Long.class || clazz==float.class || clazz== Float.class || clazz==double.class || clazz==Double.class || clazz==char.class || clazz== Character.class || clazz==boolean.class || clazz==Boolean.class || clazz==String.class){
            return true;
        }
        return false;
    }


}

其中的细节和难点：

1.处理参数

处理参数的思路：

获取参数的class对象、参数的名字、参数的下标。然后根据参数名利用请求从前端获取对应的参数对象并添加到参数数组args[]中，位置为对应下标的位置。

其中需要根据不同的参数类型分别进行处理：

如果是Java常用数据类型（8大基本数据类型+string），则进行装箱处理（String 直接添加），然后添加到参数数组args[]中；

public Object[] handlerJavaType(HttpServletRequest request,String name,Class<?> clazz,Object[] args,int index){
        String parameter = request.getParameter(name);
        if(clazz==byte.class || clazz==Byte.class){
            args[index] =  Byte.parseByte(parameter);
        }else if(clazz==short.class || clazz==Short.class){
            args[index] = Short.parseShort(parameter);
        }else if(clazz==int.class || clazz==Integer.class){
            args[index] = Integer.parseInt(parameter);
        }else if(clazz==long.class || clazz==Long.class){
            args[index] = Long.parseLong(parameter);
        }else if(clazz==float.class || clazz==Float.class){
            args[index] = Float.parseFloat(parameter);
        }else if(clazz==double.class || clazz==Double.class){
            args[index] = Double.parseDouble(parameter);
        }else if(clazz==char.class || clazz==Character.class){
            args[index] = parameter.toCharArray()[0];
        }else if(clazz==boolean.class || clazz==Boolean.class){
            args[index] = Boolean.parseBoolean(parameter);
        }if(clazz==String.class){
            args[index] = parameter;
        }
        return args;
    }
    public boolean judgeTypeIsJavaOrNot(Class<?> clazz){
        if(clazz==byte.class || clazz==Byte.class || clazz==short.class || clazz==Short.class || clazz==int.class || clazz== Integer.class || clazz==long.class || clazz== Long.class || clazz==float.class || clazz== Float.class || clazz==double.class || clazz==Double.class || clazz==char.class || clazz== Character.class || clazz==boolean.class || clazz==Boolean.class || clazz==String.class){
            return true;
        }
        return false;
    }

如果是请求/响应类型的数据则直接添加到数组中；

如果是数组，则获取的是数组对象，并添加到args[]中；

String[] arr = request.getParameterValues(name);
args[index] = arr;

如果是List集合类型（前端设计页面的时候会规范返回的格式），则要先通过获取泛型（这里需要回到参数描述类中添加泛型类型这一属性）来获取集合里面元素的类型，然后获得传入的数据map，遍历每行数据拼接出元素的名字、下标和属性值。然后通过元素的类型利用反射创建类对象，创建List集合并添加对象，设置对象属性值（注意：这里有一个小技巧，利用try-catch先获取空集合里面的元素，在出现没有元素的异常后在catch中创建对象，并添加到list中。这样在同一个元素下标中的list位置就有了对象，就不会进入到异常处理中创建对象，而是在后续进行属性设置，直到下标改变再重新创建对象。），最后将List集合添加到args[]中；

参数类型描述类添加泛型属性(相应的需要修改监听器封装部分的代码)：

@NoArgsConstructor
@AllArgsConstructor
@Data
public class ParameterDefinition {
   private String name;//参数名
   private Class<?> clazz;//参数类型
   private int index;//参数下标
   private Type[] actualTypeArguments;//参数泛型的数组
   

}

监听器相关部分：

if(parameters.length!=0){
    for (int i = 0; i < parameters.length; i++) {
        //获取参数上泛型数组
        Type parameterizedType = parameters[i].getParameterizedType();
        Type[] actualTypeArguments = null;

        try{
            ParameterizedType pt = (ParameterizedType) parameterizedType;
            if(pt!=null){
                actualTypeArguments = pt.getActualTypeArguments();
            }
        }catch (Exception e){

        }

        String parameterName = parameters[i].getName();//获取参数名
        Class<?> parameterType = parameters[i].getType();//参数类型
        int index = i;//下标
        ParameterDefinition parameterDefinition = new ParameterDefinition(parameterName, parameterType, index,actualTypeArguments);//封装参数描述类对象
        parameterList.add(parameterDefinition);
    }
}

DispatcherServlet:

 public void handlerListType(HttpServletRequest request,ParameterDefinition parameterDefinition,Object[] args,int index){
        Map<String, String[]> parameterMap = request.getParameterMap();
        //key --- Value
        //user[0].username --- new String[]{"pengyuyan"};
        //user[0].password --- new String[]{"123123"};
        //user[1].username --- new String[]{"wuyanzu"};
        //user[1].password --- new String[]{"123456"};
        

        //获取泛型类型
        Type pt = parameterDefinition.getActualTypeArguments()[0];
        String className = pt.getTypeName();
        Class<?> aClass = null;
        try {
            aClass = Class.forName(className);
        } catch (ClassNotFoundException e) {
            throw new RuntimeException(e);
        }

        ArrayList<Object> list = new ArrayList<>();
        Set<Map.Entry<String, String[]>> entries = parameterMap.entrySet();
        for (Map.Entry<String, String[]> entry : entries) {
            String key = entry.getKey();//user[0].username
            String[] value = entry.getValue();//new String[]{"guodan"}
            int i = Integer.parseInt(key.substring(key.indexOf("[") + 1, key.indexOf("]")));//集合中的下标
            String fieldName = key.substring(key.indexOf(".") + 1);//集合中元素对象的属性名
            String fieldValue = value[0];//获取集合中元素对象里的属性值

            Object o =null;
            try{
                o = list.get(i);
            }catch (IndexOutOfBoundsException e){
                //该集合下标上没有元素
                try {
                    o = aClass.newInstance();//创建对象
                    list.add(o);//添加对象
                } catch (InstantiationException | IllegalAccessException ex) {
                    throw new RuntimeException(ex);
                }
                try {
                    BeanUtils.setProperty(o,fieldName,fieldValue);//设置对象属性
                } catch (IllegalAccessException | InvocationTargetException ex) {
                    throw new RuntimeException(ex);
                }
                args[index] = list;
            }


        }
    }

如果是Model类型（model需要创建，属性只有一个map，用来存放属性的名和值，同时有一个setAttribute()方法，即添加键值。model是用来跳转页面的，将前端的数据封装到自己的容器属性中，然后通过请求传递给前端。同时创建一个ModelAndView类，除了容器属性外还有一个字符串类型的路径，功能和model类似，但适用于需要动态指定跳转页面的复杂业务），则直接添加到args[]中；

public class Model {
    private Map<String,Object> maps= new ConcurrentHashMap<>();
    public void setAttributes(String key,Object value){maps.put(key,value);}

    public Map<String, Object> getMaps() {
        return maps;
    }
}

public class ModelAndView {
    private Map<String,Object> maps = new HashMap<>();
    private String viewName;
    public void setAttributes(String key,Object value){
        maps.put(key,value);
    }

    public Map<String, Object> getMaps() {
        return maps;
    }

    public void setMaps(Map<String, Object> maps) {
        this.maps = maps;
    }

    public String getViewName() {
        return viewName;
    }

    public void setViewName(String viewName) {
        this.viewName = viewName;
    }
}

如果是自定义类型，则用反射创建对象，将数据利用BeanUtils工具类的populate方法将参数整合到类对象中，并添加到args[]中。

public void handlerOtherType(Class<?> clazz,HttpServletRequest request,Object[] args,int index){
        try {
            Object obj = clazz.newInstance();
            Map<String, String[]> parameterMap = request.getParameterMap();
            BeanUtils.populate(obj,parameterMap);
            args[index] = obj;

        } catch (InstantiationException e) {
            throw new RuntimeException(e);
        } catch (IllegalAccessException e) {
            throw new RuntimeException(e);
        } catch (InvocationTargetException e) {
            throw new RuntimeException(e);
        }
    }
2.处理返回值

思路：

如果返回值不为空，即该方法有返回值，则要对返回值的类型进行判断，然后添加请求数据，再进行转发。

不同类型返回值的处理：

这里返回值有两种情况，本质是跳转逻辑的不同。一种是字符串类型的路径，controller层会将前端的数据封装到Model对象中，servlet就获取model的map属性，遍历里面的数据利用请求设置到页面，而返回的字符串路径直接用来跳转，一种是ModelAndView类型的对象，同样遍历map属性，将属性通过请求设置到页面，并利用类里面的路径属性进行跳转。

public void handlerReturnVal(Object returnVal,HttpServletRequest request,HttpServletResponse response,Model model) throws ServletException, IOException {
        if(returnVal.getClass()==String.class){
            //如果返回值是字符串，先添加请求数据，再跳转（转发）

            handlerRequestVal(request,model.getMaps());
            jumpPage(returnVal,request,response);
        } else if (returnVal.getClass() == ModelAndView.class) {
            //如果返回值是ModelAndView，添加请求后跳转（转发）
            ModelAndView modelAndView = (ModelAndView) returnVal;
            handlerRequestVal(request,modelAndView.getMaps());
            jumpPage(modelAndView.getViewName(),request,response);

        }
    }
	//遍历Model/ModelAndView类对象的容器属性，把属性数据添加到请求
    public void handlerRequestVal(HttpServletRequest request,Map<String,Object> maps){
        Set<Map.Entry<String, Object>> entries = maps.entrySet();
        for (Map.Entry<String, Object> entry : entries) {
            String key = entry.getKey();
            Object value = entry.getValue();
            request.setAttribute(key,value);


        }
    }
	//页面跳转
    public void jumpPage(Object returnVal,HttpServletRequest request,HttpServletResponse response) throws ServletException, IOException {
        String str = (String) returnVal;
        request.getRequestDispatcher(str).forward(request,response);
    }
3.处理JSON数据

如果接收的是JSON格式数据，那么如何识别数据以及怎样传递数据呢？

**思路：**参数注解用来识别判断客户端传递过来的数据是否是JSON数据，需要将JSON格式的字符串解析成参数类型的数据；方法注解表示服务器传输过去的数据为JSON数据，需要将返回值解析成JSON格式的字符串。

具体实现：添加RequestBody注解用在参数上，和ResponseBody注解用在方法上。

@Target(ElementType.PARAMETER)
@Retention(RetentionPolicy.RUNTIME)
public @interface RequestBody {
}


@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface ResponseBody {
}

DispatcherServlet中在创建参数数组的时候判断参数上是否有注解，所以要在参数描述类中添加用来判断是否参数有注解的布尔值。在方法描述类中添加布尔值判断方法上是否有注解。(相应的要修改监听器中封装类的那部分代码)

参数描述类和方法描述类修改：

@NoArgsConstructor
@AllArgsConstructor
@Data
public class ParameterDefinition {
    private String name;//参数名
    private Class<?> clazz;//参数类型
    private int index;//参数下标
    private Type[] actualTypeArguments;//参数泛型的数组
    private boolean requestBodyHasOrNot;//参数上是否有@RequestBody注解

}


@NoArgsConstructor
@AllArgsConstructor
@Data
public class MethodDefinition {

    private String requestMappingPath;//子级URi
    private String name;//方法名
    private Method method;//方法对象

    private Class<?> returnClazz;//返回值类型
    private List<ParameterDefinition> parameterDefinitions;//参数描述类对象的集合
    private boolean responseBodyHasOrNot;//方法上是否有@ResponseBody注解
}

监听器相关部分：

if(parameters.length!=0){
    for (int i = 0; i < parameters.length; i++) {
        //获取参数上泛型数组
        Type parameterizedType = parameters[i].getParameterizedType();
        Type[] actualTypeArguments = null;

        try{
            ParameterizedType pt = (ParameterizedType) parameterizedType;
            if(pt!=null){
                actualTypeArguments = pt.getActualTypeArguments();
            }
        }catch (Exception e){
        }

        String parameterName = parameters[i].getName();//获取参数名
        Class<?> parameterType = parameters[i].getType();//参数类型
        int index = i;//下标

        //获取参数上是否有@RequestBody注解
        boolean requestBodyHasOrNot = false;
        RequestBody requestBody = parameters[i].getAnnotation(RequestBody.class);
        if(requestBody!=null){
            requestBodyHasOrNot = true;
        }
        ParameterDefinition parameterDefinition = new ParameterDefinition(parameterName, parameterType, index,actualTypeArguments,requestBodyHasOrNot);//封装参数描述类对象
        parameterList.add(parameterDefinition);
    }
}

//获取方法上是否有@ResponseBody注解
boolean responseBodyHasOrNot = false;
ResponseBody responseBody = method.getAnnotation(ResponseBody.class);
if(responseBody!=null){
    responseBodyHasOrNot = true;
}
MethodDefinition methodDefinition = new MethodDefinition(sonUri, methodName, method, returnType, parameterList,responseBodyHasOrNot);//封装方法描述类对象

servlet中在自定义类型中要判断是否有对应的注解，如果有就解析json数据封装成对象然后添加到数组。

public void handlerOtherType(ParameterDefinition parameterDefinition,HttpServletRequest request,Object[] args,int index){
    try {
        if(parameterDefinition.isRequestBodyHasOrNot()){
            //如果返回的是JSON格式数据
            BufferedReader br = request.getReader();
            StringBuffer sb = new StringBuffer();
            char[] cs = new char[1024];
            int len;
            while((len= br.read(cs))!=-1){
                sb.append(cs,0,len);
            }
            String jsonStr = sb.toString();
            Object obj = JSON.parseObject(jsonStr,parameterDefinition.getClazz());
            args[index] = obj;


        }else{
            Object obj = parameterDefinition.getClazz().newInstance();
            Map<String, String[]> parameterMap = request.getParameterMap();
            BeanUtils.populate(obj,parameterMap);
            args[index] = obj;
        }



    } catch (InstantiationException | IllegalAccessException | InvocationTargetException | IOException e) {
        throw new RuntimeException(e);
    }
}

在方法处理中判断是否有对应的方法注解，如果有就将返回的JSON转换为字符串写回前端。

public void handlerReturnVal(MethodDefinition methodDefinition,Object returnVal,HttpServletRequest request,HttpServletResponse response,Model model) throws ServletException, IOException {

        if(methodDefinition.isResponseBodyHasOrNot()){
            //返回数据为JSON格式
            String jsonString = JSON.toJSONString(returnVal);
            sendResponse(response,jsonString);

        }
        else if(returnVal.getClass()==String.class){
            //如果返回值是字符串，先添加请求数据，再跳转（转发）

            handlerRequestVal(request,model.getMaps());
            jumpPage(returnVal,request,response);
        } else if (returnVal.getClass() == ModelAndView.class) {
            //如果返回值是ModelAndView，添加请求后跳转（转发）
            ModelAndView modelAndView = (ModelAndView) returnVal;
            handlerRequestVal(request,modelAndView.getMaps());
            jumpPage(modelAndView.getViewName(),request,response);

        }
    }
    public void sendResponse(HttpServletResponse response,String jsonString) throws IOException {
        response.getWriter().write(jsonString);
    }
注意：

1.@WebServlet不要加，在web项目中配置。因为是在项目中使用到，而不是全局。

postman

代替浏览器发送请求的工具

请求里面输入url，body选择raw->JSON，发送一个JSON格式的字符串

测试能否成功。

求学小火龙
关注
  • 6
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
DispatcherServlet 中央调度器的由来，手写简单的DispatcherServlet
qq_48010634的博客
05-04 1004
Servlet 版本一： 在不使用 DispatcherServlet 之前我们通常在 web.xml 文件中注册 Servlet 接口实现类来完成对客户请求的处理，且每一个请求对应一个 Servlet接口实现类 <servlet> <servlet-name>Demo01Servlet</servlet-name> <servlet-class>com.Servlet.www.Demo01Servlet</servlet-clas
手写Spring框架之MVC
Tyshawn的博客
01-25 4795
简介 手写Spring框架第一篇博客(必读): 手写Spring框架 上一篇博客实现了Bean容器和IOC功能, 本篇博客来实现简化版的 Spring MVC. 在看下面的内容之前, 我们首先来回顾下 Spring MVC的架构图: Spring MVC 最核心部分的就是前端控制器DispatcherServlet, 而DispatcherServlet其实就是一个Servlet, 所以我们有必...
关于DispatherServlet（手写）
清风半夜鸣蛙
10-29 967
DispatherServlet在Spring中充当一个前端控制器的角色，他的核心功能就是分发请求，请求会被分发给对应处理的类MSpringMVC中称为handle。接下来我们就去实现这个分发请求。框架的实现一般离不开反射代理，这次我们手动写DispatherServlet也是一样。简单的映射处理 首先接收一下几个文件 1.userInfoController:这个设计处理请求的类 并且具...
手写SpringMVC-DispatcherServlet
liukezheng3的博客
01-28 395
web.xml配置 <?xml version="1.0" encoding="UTF-8"?> <web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp..
DispatcherServlet详解
weixin_34262482的博客
02-19 168
一、DispatcherServlet 处理流程 在整个 Spring MVC 框架中，DispatcherServlet 处于核心位置，它负责协调和组织不同组件完成请求处理并返回响应工作。DispatcherServlet 是 SpringMVC统一的入口，所有的请求都通过它。DispatcherServlet 是前端控制器，配置在web.xml文件中，Servlet依自已定义的具体规则拦截匹配...
模仿SpringMVC的DispatcherServlet 手撸300行代码提炼精华设计思想并保证功能可用（1.0版本）
Jarvis.y的博客
10-04 508
前言 博客内容全部出自于咕泡学院架构师课程第三期。 内容为手写SpringMVC的DistapcherServlet的核心功能，从V1版本到V2版本再到V3版本。 1、SpringMVC中的DispatcherServlet的核心功能是哪些？ 首先看一下mvc的流程： 用户发送请求至前端控制器DispatcherServlet。 DispatcherServlet收到请求调用HandlerMapping处理器映射器。 处理器映射器找到具体的处理器(可以根据xml配置、注解进行查找)，生成处理器对象及处
手写spring mvc框架
09-22
在手写Spring MVC框架的过程中，你需要实现上述组件的功能，并通过配置文件或注解来设置它们之间的关联。例如，你可能需要编写一个简单的Controller类，实现处理请求的方法；创建一个基本的HandlerMapping实现，解析...
02-01-08-用30个类高仿真提炼纯手写Spring框架V2.0之MVC1
08-04
【Spring 框架模拟构建】：本课程旨在深度解析并模拟实现Spring框架的核心部分，特别是Spring MVC，通过创建30个类来构建一个高度仿真的简易版Spring框架。这将帮助开发者深入理解Spring的系统架构和实现原理，以及...
Spring+Mvc手写基本源码+思维导图，快速理解spring+mvc原理
06-27
Spring MVC 是一款强大的Java Web开发框架，用于构建可...手写Spring MVC源码是一个挑战性的实践过程，但能带来深入的理解和技能提升。在这个过程中，思维导图是一个有效的辅助工具，帮助我们梳理和可视化整个流程。
仿 Spring 手写 MVC 框架_源码.rar
11-02
通过手写这样一个MVC框架，你可以更深入地理解Spring MVC的工作原理，了解Web应用的请求处理流程，以及各组件之间的协作方式。这将对你的Java Web开发技能提升大有裨益。在实践中，你还可以考虑如何优化性能，提高...
springmvc ---DispatcherServlet详解
被世界遗弃的江的博客
11-15 717
DispatcherServlet作用 DispatcherServlet是前端控制器设计模式的实现，提供Spring Web MVC的集中访问点，而且负责职责的分派。 DispatcherServlet主要用作职责调度工作，本身主要用于控制流程： 1、文件上传解析，如果请求类型是multipart将通过MultipartResolver进行文件上传解析；
仿springmvc流程自写DispatcherServlet
最新发布
qq_51621767的博客
11-09 178
以框架的运行模式，自我模拟
DispatcherServlet的一点理解
Bear的博客
06-07 238
与Spring Ioc无缝集成,可以获得所有Spring的好处.看了很久,发现直接阅读源码是不正确的选择,除非在没有文档的情况下,否则应该以文档为主.
DispatcherServlet源码剖析及工作原理
我爱娃娃菜的博客
04-02 3565
做基于Spring MVC框架的web开发，DispatcherServlet几乎是web.xml中必须配置的一个Servlet，绝大部分情况下也只需要配置这个Servlet就够用了。它有什么作用呢？顾名思义，它是一个派发器，即对任意一个web请求都会根据一定的规则派发到对应的处理器上处理，并最终将结果返回。它实现了Request to Handler的路由，而我们只需要实现处理器的逻辑，大大简化...
使用反射手写自己的DispatchServlet
qq_44621891的博客
10-03 314
在此诞生一个属于自己的DispatchServletSpring MVC 的核心DispatchServlet 本文章只是让我们能够更详细的了解DispatchServlet的大致流程 Spring MVC 的核心DispatchServlet 大致做了哪些事情： 拦截请求 解析url 根据解析后的url去执行具体方法 返回数据，进行页面跳转 知道了大致流程，使用反射来实现一下这个过程， 项目目录: DispatchServlet 类 package cn.servlet; impo
第三章 DispatcherServlet详解 ——跟开涛学SpringMVC
jinnianshilongnian的专栏
07-21 3253
3.1、DispatcherServlet作用 DispatcherServlet是前端控制器设计模式的实现，提供Spring Web MVC的集中访问点，而且负责职责的分派，而且与Spring IoC容器无缝集成，从而可以获得Spring的所有好处。 具体请参考第二章的图2-1。   DispatcherServlet主要用作职责调度工作，本身主要用于控制流程，主要职责如下： 1...
深入解读springmvc--2，处理Http请求以及自定义一个DispatcherServlet
rubbertree的专栏
02-25 779
一，一个Http请求进入SpringMVC的完整流程： 首先看下动态请求的处理：（静态资源请求的处理其实比较简单，只是以流的方式把静态资源写入response中而已） 在Servlet容器中，一个请求的完整流程是： 1.Servlet容器调用Servlet.service() 2.HttpServlet.service()分发get,post等 3.FrameworkServlet....
深入理解Spring MVC：DispatcherServlet与HandlerMapping解析
"Spring MVC 学习资料，涵盖了Spring MVC的核心组件和工作流程，以及DispatcherServlet和HandlerMapping的介绍。" Spring MVC 是一个基于Java的Web应用程序框架，它为构建MVC（模型-视图-控制器）模式的应用提供了...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值