Spring源码分析之大结局-手写springmvc

最新推荐文章于 2022-10-26 20:56:49 发布
最新推荐文章于 2022-10-26 20:56:49 发布
阅读量236 收藏
点赞数 1
分类专栏： spring Spring源码分析
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a1173537204/article/details/91864378
版权

1.创建一个maven工程，并生成web工程

 

pom文件如下：

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>com.caojiulu</groupId>
	<artifactId>jiulu-springmvc</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>war</packaging>

	<dependencies>
		<dependency>
			<groupId>javax.servlet</groupId>
			<artifactId>servlet-api</artifactId>
			<version>3.0-alpha-1</version>
			<scope>provided</scope>
		</dependency>
	</dependencies>

</project>

2.创建对应的注解：

package com.caojiulu.annotation;

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

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface JiuluController {
	
	String value() default "";

}

package com.caojiulu.annotation;

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

@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface JiuluAutowired {
	
	String value() default "";

}

package com.caojiulu.annotation;

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

@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface JiuluRequestMapping {
	
	String value() default "";

}

package com.caojiulu.annotation;

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

@Target({ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface JiuluRequestParam {
	
	String value() default "";

}

package com.caojiulu.annotation;

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

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface JiuluService {
	
	String value() default "";

}

 

3.创建接口以及实现类：

package com.caojiulu.service;

public interface CaojiuluService {

	
	String query(String name,String age);
}

package com.caojiulu.service.impl;

import com.caojiulu.annotation.JiuluService;
import com.caojiulu.service.CaojiuluService;

@JiuluService("CaojiuluServiceImpl")
public class CaojiuluServiceImpl implements CaojiuluService{

	@Override
	public String query(String name, String age) {
		return "{name="+name+",age="+age+"}";
	}
	

}

 

2.修改web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" version="2.5">
  <display-name>jiulu-springmvc</display-name>
  <servlet>
  	<servlet-name>DispatcherServlet</servlet-name>
  	<servlet-class>com.caojiulu.service.servlet.DispatcherServlet</servlet-class>
  	<load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
  	<servlet-name>DispatcherServlet</servlet-name>
  	<url-pattern>/</url-pattern>
  </servlet-mapping>
</web-app>

3.编写核心DispatcherServlet

package com.caojiulu.service.servlet;

import java.io.File;
import java.io.IOException;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.URL;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import com.caojiulu.annotation.JiuluAutowired;
import com.caojiulu.annotation.JiuluController;
import com.caojiulu.annotation.JiuluRequestMapping;
import com.caojiulu.annotation.JiuluService;
import com.caojiulu.controller.CaoJiuluController;
import com.caojiulu.handlerAdapter.HandlerAdapterService;

public class DispatcherServlet extends HttpServlet{

	List<String> classNames = new ArrayList<String>();
	Map<String, Object> beans = new HashMap<String, Object>();
	Map<String, Object> handlerMap = new HashMap<String, Object>();
	@Override
	public void init(ServletConfig config) throws ServletException {
		//扫描package
		scanPackage("com.caojiulu");
		
		System.out.println(Arrays.asList(classNames));
		//实例化
		instance();
		for (Map.Entry<String, Object> entry : beans.entrySet()) {
			System.out.println(entry.getKey() + ":" + entry.getValue());
		}
		//ioc 
		ioc();
		//建立path和method的映射关系
		handlerMapping();
		
		for (Map.Entry<String, Object> entry : handlerMap.entrySet()) {
			System.out.println(entry.getKey() + ":" + entry.getValue());
		}
	}
	

	private void handlerMapping() {
		if(beans.entrySet().size()<=0){
			System.out.println("没有类的实例化");
			return ;
		}
		
		for (Map.Entry<String, Object> entry : beans.entrySet()) {
			
			Object instance = entry.getValue();
			Class<?> clazz = instance.getClass();
			
			if(clazz.isAnnotationPresent(JiuluController.class)){
				JiuluRequestMapping jiuluRequestMappingclass = clazz.getAnnotation(JiuluRequestMapping.class);
				
				String classPath = jiuluRequestMappingclass.value();
				
				Method[] methods = clazz.getMethods();
				for (Method method : methods) {
					if(method.isAnnotationPresent(JiuluRequestMapping.class)){
						
						JiuluRequestMapping annotation = method.getAnnotation(JiuluRequestMapping.class);
						String value = annotation.value();
						handlerMap.put(classPath+value, method);
					}else{
						continue;
					}
				}
			}
			
		}
		
		
	}


	private void ioc() {
		if(classNames.size()<=0){
			System.out.println("包扫描失败");
			return ;
		}
		
		for (Map.Entry<String, Object> entry : beans.entrySet()) {
			Object value = entry.getValue();
			//获取对象的类型
			Class<?> class1 = value.getClass();
			if(class1.isAnnotationPresent(JiuluController.class)){
				Field[] fields = class1.getDeclaredFields();
				for (Field field : fields) {
					if(field.isAnnotationPresent(JiuluAutowired.class)){
						JiuluAutowired jiuluAutowired = field.getAnnotation(JiuluAutowired.class);
						//field.set
						String value2 = jiuluAutowired.value();
						field.setAccessible(true);
						try {
							field.set(value, beans.get(value2));
						} catch (IllegalArgumentException | IllegalAccessException e) {
							// TODO Auto-generated catch block
							e.printStackTrace();
						}
					}else{
						continue;
					}
				}
			}else{
				continue;
			}
			
		}
		
	}


	private void instance() {
		if(classNames.size()<=0){
			System.out.println("包扫描失败");
			return ;
		}
		
		for (String className : classNames) {
			String cn = className.replace(".class", "");
			
			try {
				Class<?> clazz = Class.forName(cn);
				if(clazz.isAnnotationPresent(JiuluController.class)){
					Object newInstance = clazz.newInstance();
					JiuluRequestMapping annotation = clazz.getAnnotation(JiuluRequestMapping.class);
					String value = annotation.value();
					beans.put(value, newInstance);
				}else if(clazz.isAnnotationPresent(JiuluService.class)){
					Object newInstance = clazz.newInstance();
					JiuluService annotation = clazz.getAnnotation(JiuluService.class);
					String value = annotation.value();
					beans.put(value, newInstance);
				}else{
					continue;
				}
				
				
				
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}


	@Override
	protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
		// TODO Auto-generated method stub
		doPost(req, resp);
	}

	@Override
	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		
		//jiulu-springmvc/jiulu/query
		String requestURI = request.getRequestURI();
		
		// /jiulu-springmvc
		String contextPath = request.getContextPath();
		String path = requestURI.replace(contextPath, "");
		
		Method method = (Method)handlerMap.get(path);
		
		//拿到控制类
		CaoJiuluController jiuluController = (CaoJiuluController) beans.get("/"+path.split("/")[1]);
	
		HandlerAdapterService ha = (HandlerAdapterService) beans.get("jiuluHandlerAdapter");
	
		Object[] args = ha.hand(request, response, method, beans);
		try {
			method.invoke(jiuluController, args);
		} catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	

	private void scanPackage(String filePath) {
		URL resource = this.getClass().getClassLoader().getResource("/"+filePath.replace(".", "/"));
		String path = resource.getPath();
		File file = new File(path);
		String[] list = file.list();
		for (String string : list) {
			File file2 = new File(path+"/"+string);
			if(file2.isDirectory()){
				scanPackage(filePath +"."+string);
			}else{
				classNames.add(filePath+"."+file2.getName());
			}
		}
	}
	

	
}

4.策略模式处理请求参数

package com.caojiulu.argumentResolver;

import java.lang.reflect.Method;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public interface ArgumentResolver {

    public boolean support(Class<?> type, int paramIndex, Method method);
    
    //参数解析方法
    public Object argumentResolver(HttpServletRequest request,
            HttpServletResponse response, Class<?> type, 
            int paramIndex,//参数索引下坐标,有很多注解,你得知道是哪个参数的注解,每个参数的索引顺序不一样
            Method method);
	
}

package com.caojiulu.argumentResolver;

import java.lang.reflect.Method;

import javax.servlet.ServletRequest;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import com.caojiulu.annotation.JiuluService;
@JiuluService("httpServletRequestArgumentResolver")
public class HttpServletRequestArgumentResolver implements ArgumentResolver{

	@Override
	public boolean support(Class<?> type, int paramIndex, Method method) {
		return ServletRequest.class.isAssignableFrom(type);
	}

	@Override
	public Object argumentResolver(HttpServletRequest request, HttpServletResponse response, Class<?> type,
			int paramIndex, Method method) {
		return request;
	}

}

package com.caojiulu.argumentResolver;

import java.lang.reflect.Method;

import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import com.caojiulu.annotation.JiuluService;

@JiuluService("httpServletResponseArgumentResolver")
public class HttpServletResponseArgumentResolver implements ArgumentResolver{

	@Override
	public boolean support(Class<?> type, int paramIndex, Method method) {
		return ServletResponse.class.isAssignableFrom(type);
	}

	@Override
	public Object argumentResolver(HttpServletRequest request, HttpServletResponse response, Class<?> type,
			int paramIndex, Method method) {
		return response;
	}

}

package com.caojiulu.argumentResolver;

import java.lang.annotation.Annotation;
import java.lang.reflect.Method;

import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import com.caojiulu.annotation.JiuluRequestParam;
import com.caojiulu.annotation.JiuluService;

@JiuluService("requestParamArgumentResolver")
public class RequestParamArgumentResolver implements ArgumentResolver{

	@Override
	public boolean support(Class<?> type, int paramIndex, Method method) {
		Annotation[][] parameterAnnotations = method.getParameterAnnotations();
		
		Annotation[] annotations = parameterAnnotations[paramIndex];
		for (Annotation annotation : annotations) {
			if(JiuluRequestParam.class.isAssignableFrom(annotation.getClass())){
				return true;
			}
		}
		return false;
	}

	@Override
	public Object argumentResolver(HttpServletRequest request, HttpServletResponse response, Class<?> type,
			int paramIndex, Method method) {
		Annotation[][] parameterAnnotations = method.getParameterAnnotations();
		
		Annotation[] annotations = parameterAnnotations[paramIndex];
		for (Annotation annotation : annotations) {
			if(JiuluRequestParam.class.isAssignableFrom(annotation.getClass())){
				JiuluRequestParam jiuluRequestParam = (com.caojiulu.annotation.JiuluRequestParam) annotation;
				String value = jiuluRequestParam.value();
				return request.getParameter(value);
			}
		}
		return null;
	}

}

5.处理器的实现

package com.caojiulu.handlerAdapter;

import java.lang.reflect.Method;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public interface HandlerAdapterService {
	
	public Object[] hand(HttpServletRequest request,//拿request请求里的参数
            HttpServletResponse response,Method method,Map<String,Object> beans);

}

package com.caojiulu.handlerAdapter;

import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import com.caojiulu.annotation.JiuluService;
import com.caojiulu.argumentResolver.ArgumentResolver;
@JiuluService("jiuluHandlerAdapter")
public class JiuluHandlerAdapter implements HandlerAdapterService{

	@Override
	public Object[] hand(HttpServletRequest request, HttpServletResponse response, Method method,
			Map<String, Object> beans) {


		Class<?>[] parameterTypes = method.getParameterTypes();
		
		Object[] args = new Object[parameterTypes.length];
		
		Map<String, Object> argumentResolvers = getBeansOfType(beans,ArgumentResolver.class);
		int paramIndex = 0 ;
		int i = 0;
		for (Class<?> param : parameterTypes) {
			for (Map.Entry<String, Object> entry : argumentResolvers.entrySet()) {
				ArgumentResolver ar = (ArgumentResolver) entry.getValue();
				if(ar.support(param, paramIndex, method)){
					args[i++] = ar.argumentResolver(request, response, param, paramIndex, method);
				}
			}
			paramIndex ++;
		}
		
		return args;
	}

	private Map<String, Object> getBeansOfType(Map<String, Object> beans, Class<ArgumentResolver> class1) {
		
		Map<String, Object> resultBeans = new HashMap<String,Object>();
		
		for (Map.Entry<String, Object> entry : beans.entrySet()) {
			Class<?>[] interfaces = entry.getValue().getClass().getInterfaces();
			if(interfaces!=null & interfaces.length>0){
				for (Class<?> class2 : interfaces) {
					if(class2.isAssignableFrom(class1)){
						resultBeans.put(entry.getKey(), entry.getValue());
					}
				}
			}
		}
		
		return resultBeans;
	}
	
	

}

6.运行测试情况：

完成手写springmvc！

日薪灬越亿
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
手把手教你手写SpringMvc框架(附源码)
06-21
帮助广大学员手把手教学，本课程从无到有，循序渐进的手写mvc框架，由于官方的框架比较复杂，为了让同学们能够学懂，先从简单地MVC框架入手，然后不断地升级和迭代，逐渐成为官方比较接近的springMVC框架。...
最新springmvc源码分析与实战
03-21
最新springmvc源码分析与实战，绝对超值，亲测，高清，完整标签，已读。
SpringMVC拓展
weixin_30326515的博客
02-16 122
### 原生SpringMVC有如下缺陷 参数的JSON反序列化只支持@RequestBody注解，这意味着不能在controller方法中写多个参数，如下代码是不对的 public Map test(@RequestBody User user, @RequestBody Role role) 如下代码，User和Role类都有id字段。假如请求方式是默认的x-www-form-ur...
SpringMVC参数绑定及各自意义
kitonGao的博客
06-06 666
转自：https://blog.csdn.net/walkerjong/article/details/7946109#@RequestMapping简介：@RequestMappingRequestMapping是一个用来处理请求地址映射的注解，可用于类或方法上。用于类上，表示类中的所有响应请求的方法都是以该地址作为父路径。RequestMapping注解有六个属性，下面我们把她分成三类进行说明...
tomcat + spring mvc原理（十二）:spring mvc请求的适配处理和返回2
孙新的铁匠铺
02-12 676
tomcat + spring mvc原理（十二）:spring mvc请求的适配处理和返回2前言处理流程request转换获取WebDataBinderFactory创建ModelFactory和初始化model方法和方法的参数参数解析与方法调用参数解析的分析参数解析器的管理参数解析器的分类设置返回值返回值处理器的分类 前言     HandleAdapt......
Spring源码梳理--SpringMVC是怎样解析请求参数的
Feverasa的博客
03-01 647
SpringMVC是怎样处理一个请求的在前面有写，这里就不在重复，以后再去描叙的更有条理一些。这里说下SpringMVC是怎样解析url上的请求参数的。 请求的URL：http://localhost:8080/hello?name=jhf&age=16 Controller : @RestController public class MyController { ...
手写SpringMVC源码-梳理清楚这些你也能手写出来
波波烤鸭的博客
10-26 1247
手写SpringMVC源码
SpringMvc源码分析第六弹 - 基于SpringMvc源码后的手写高仿版
生生不息，则源源不断
01-12 261
SpringMvc源码分析第六弹 - 基于SpringMvc源码后的手写高仿版 上一篇：Spring源码分析第五弹 - 神级的spring还有其他什么功效？ 下一篇：Springboot源码分析第一弹 - 自动装配实现 问渠那得清如许，为有源头活水来
spring源码合集spring源码合集
04-09
《Spring源码合集：揭示Java后端开发的基石》 Spring框架作为Java后端开发的核心，其源码的研究对于提升开发者对系统架构理解和优化能力至关重要。本合集深入剖析了Spring的诸多关键特性，包括依赖注入、配置类解析...
手写SpringMVC
03-07
在这个“手写SpringMVC”的项目中，我们将深入理解SpringMVC的工作原理，并尝试使用纯Java代码来实现其核心功能。 1. **URL映射**：在SpringMVC中，请求URL通过DispatcherServlet被拦截，然后根据`@RequestMapping`...
MySSM:手写的Springmvc + spring + mybatis框架，加深对源码的理解
03-23
手写SpringMVC可以帮助我们理解请求的生命周期，包括DispatcherServlet的初始化、HandlerMapping的解析、Controller的调用以及View的渲染。同时，深入学习ModelAndView、Interceptor、Converter/GenericConverter等...
SpringMVC源码解析HandlerMethod
JavaEdge全是干货的技术号
06-04 2089
封装关于处理器方法信息的方法和bean类 。 提供了对方法参数，方法返回值，方法注释等方便地访问入口。 该类可以使用bean实例或具有bean名称（例如lazy-init bean，prototype bean）来创建。 使用createWithResolvedBean()获得HandlerMethod实例，被BeanFactory解析过的。 1 字段 public class HandlerMethod { // Object类型，可以是Bean，也可以是个String 的 BeanName pri
仿SpringMVC
Jeff的专栏
02-26 333
最近在看Spring的源码，开始的时候看的没有头绪，自己大脑都是乱麻；自己就在网上找资料，自己慢慢的看，到现在只是刚刚开始，把自己总结的SpringMVC的个人心得分享个大家，很多都是在网上找的资料，现在开始....首先展示目录结构：现在开始正文：创建注解，可以仿照Spring的源码中的注解@Controllerpackage com.stone.annotation; import java....
Quartz修改定时任务时间，无须重启服务
日薪灬越亿的博客
11-09 3231
quartz通过动态设置读取配置文件，有时排查问题需要重新执行定时任务，因为重启一次服务器所需的成本太多。 这时，就需要我们仅仅修改数据库就能实现动态的更新定时任务的定时时间。 但仅仅修改表qrtz_cron_triggers对应cronExpression并不能生效，原因在于表qrtz_triggers中的所有时间相关的值并没有变动。 1.更改表qrtz_cron_triggers的cronExpression（定时任务时间） 例子： update QRTZ_CRON_TRIGGERS set
Spring源码分析(四)-注解lazy懒加载
日薪灬越亿的博客
05-14 756
lazy 懒加载，主要针对单实例bean，容器启动时候不创建对象，仅当第一次使用的bean才创建 新建Cap4MainConfig.java package com.caojiulu.cap4; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation....
Spring源码分析(八) - Spring底层对BeanPostProcessor的使用
日薪灬越亿的博客
05-19 695
Spring底层对BeanPostProcessor的使用 1,ApplicationContextAwareProcessor实现分析: 此类帮我们组建IOC容器,跟进ApplicationContextAwareProcessor我们发现, 这个后置处理器其实就是判断我们的bean有没有实现ApplicationContextAware接口,并处理相应的逻辑,其实所有的后置处理器原...
Spring源码分析(七) - bean的生命周期
日薪灬越亿的博客
05-19 372
bean的生命周期:指 bean创建-----初始化----销毁 的过程 bean的生命周期是由容器进行管理的 我们可以自定义 bean初始化和销毁 方法: 容器在bean进行到当前生命周期的时候, 来调用自定义的初始化和销毁方法 如何定义和销毁(4种方式): 1)指定初始化和销毁方法 <之前在beanx.xml, 可以指定init-method和destory-mot...
spring-boot-starter-web在springmvc中的版本
最新发布
07-13
在Spring MVC中使用Spring Boot时，你可以使用`spring-boot-starter-web`依赖项来引入Spring MVC的相关依赖。Spring Boot会自动管理所需的依赖项版本，因此你无需手动指定特定的版本。 当你添加`spring-boot-...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值