5. 自实现SpringMVC

1.源码下载地址

源码下载地址

2.代码架构

1. com.ys.annotation包下是自定义注解
2. com.ys.controller包下是自定义controller
3. com.ys.service包下是自定义service
4. com.ys.servlet包下是自定义servlet，类似于DispatcherServlet，是核心类
   

2.1 web.xml配置

这里注意要让所有的请求通过，所以设置为/，并且设置，让程序加载时就启动servlet

2.2 引包

pom.xml中仅需引入servlet的jar包

2.3 自定义注解类

仿照springmvc注解做简单模仿，五个注解均仅有一个value方法，除定义的注解位置不同，无其他区别

2.4 自定义Controller类

@MyController
@MyRequestMapping("/my")
public class TestController{
	@MyAutowired(value = "testService")
	private TestService testService;

	@MyRequestMapping("/ok")
	public void updateUser(HttpServletRequest request,HttpServletResponse response,
						@MyRequestParam("name") String name,
						@MyRequestParam("password") String password){
		String user = testService.updateUser(name,password);
		try {
			response.getWriter().write(user);
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	@MyRequestMapping("/no")
	public void noUser(HttpServletRequest request,HttpServletResponse response,
						@MyRequestParam("name") String name,
						@MyRequestParam("password") String password){
		String user = testService.updateUser(name,password);
		try {
			response.getWriter().write(user);
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

2.5 自定义Service类

import com.ys.annotation.MyService;

@MyService("testService")
public class TestService {
	public String updateUser(String name, String password){
		return "name:"+name+"password:"+password;
	}
}

2.6 Servlet类核心功能（类似于MVC中的DispatcherServlet前置控制器）

该核心servlet类在服务启动是会执行其中的init方法，init方法主要实现了5个功能

1.扫描包，根据基础包路径进行递归，找出所有class文件。这也就是为什么spring规范启动类默认要在主路径下
2.实例化类对象缓存到map中。过滤所有class文件，将注解的value作为map的key值，通过全包名反射得到的对象实例作为map的value值
3.扫描MyAutowired，给标注了@MyController，@MyService的类注入对象实例
4.扫描MyRequestMapping，解析标注了@MyControlle的类，扫描其中标注了@MyRequestMapping的方法，将@MyControlle的value值 + @MyRequestMapping的value值拼接，作为map的key值，方法实例作为map的value值缓存
5.处理请求，当servlet收到post请求时，在dopost方法中通过解析请求地址得到缓存map的key值，从而得到缓存map中的方法实例，通过调用方法，传入参数，得到处理结果

import java.io.File;
import java.io.IOException;
import java.lang.annotation.Annotation;
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.HashMap;
import java.util.List;
import java.util.Map;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import com.ys.annotation.MyAutowired;
import com.ys.annotation.MyController;
import com.ys.annotation.MyRequestMapping;
import com.ys.annotation.MyRequestParam;
import com.ys.annotation.MyService;
import com.ys.controller.TestController;

public class TestServlet extends HttpServlet {
	private static final long serialVersionUID = 1L;
	//用来存储class文件路径
	List<String> classNames = new ArrayList<String>();
	//用来存储controller类对象
	Map<String,Object> beans = new HashMap<String,Object>();
	//创建一个存储autowire的集合
	Map<String,Object> handlerMap = new HashMap<String,Object>();
	
	//tomcat启动扫描controller，service
	//通过反射实例化对象
	//处理autowired
	//path-method
	@Override
	public void init() throws ServletException {
		// 1.扫描所有class文件
		scanPackage("com.ys");
		// 2.实例化类对象
		instance();
		// 3.扫描MyAutowired
		doAutowired();
		// 4.处理requestMapping
		UrlHanding();
		// 5.输出测试日志
		test();
	}

	private void test() {
		System.out.println("---------------------------");
		for (String name : classNames) {
			System.out.println(name);
		}		
		System.out.println("beans-------------------------------------");
		for (String key : beans.keySet()) {
			System.out.println("key:"+key+"\t"+"value:"+beans.get(key));
		}
		System.out.println("handlerMap--------------------------------");
		for (String key : handlerMap.keySet()) {
			System.out.println("key:"+key+"\t"+"value:"+handlerMap.get(key));
		}
	}

	private void UrlHanding() {
		// 遍历容器里的bean
		for (Map.Entry<String, Object> entry : beans.entrySet()) {
			// 获取到map中的对象
			Object instance = entry.getValue();
			// 获取到当前类的路径,可以利用反射对对象进行实例化
			Class<?> clazz = instance.getClass();
			// 注意:在controller下使用autowired注解
			if (clazz.isAnnotationPresent(MyController.class)) {
				//MyController类上会存在MyRequestMapping注解
				MyRequestMapping map1 = clazz.getAnnotation(MyRequestMapping.class);
				//获取类路径,类上的值，需要和方法上的进行拼接
				String classPath = map1.value();
				//获取对象所有的方法
				Method[] methods = clazz.getMethods();
				//遍历方法
				for (Method method : methods) {
					//判断方法上是否有注解
					if(method.isAnnotationPresent(MyRequestMapping.class)){
						//获取方法上的注解值
						MyRequestMapping map2 = method.getAnnotation(MyRequestMapping.class);
						//获取注解上的value
						String methodPath = map2.value();
						//拼接,并以路径为key，方法名为value存到map中
						handlerMap.put(classPath+methodPath, method);
					}else{
						continue;
					}
				}
			}else{
				continue;
			}
		}
	}

	private void doAutowired() {
		//遍历容器里的bean
		for (Map.Entry<String, Object> entry: beans.entrySet()) {
			//获取到map中的value值
			Object instance = entry.getValue();
			//获取到当前类的路径,可以利用反射对对象进行实例化
			Class<?> clazz = instance.getClass();
			//注意:在controller下使用autowired注解
			if(clazz.isAnnotationPresent(MyController.class)){
				//获取控制层中所有的属性
				Field[] fields = clazz.getDeclaredFields();
				//遍历属性
				for (Field field : fields) {
					//判断属性上是否有Autowired注解
					if(field.isAnnotationPresent(MyAutowired.class)){
						//获取属性上的注解
						MyAutowired ea = field.getAnnotation(MyAutowired.class);
						//获取注解值
						String key = ea.value();
						//根据注解值，获取bean的类路径
						//service上的值和autowired的值相同
						Object ins = beans.get(key);
						//暴力破解获取私有值
						field.setAccessible(true);
						//
						try {
							field.set(instance, ins);
						} catch (IllegalArgumentException e) {
							e.printStackTrace();
						} catch (IllegalAccessException e) {
							e.printStackTrace();
						}
					}else{//如果有dao层，加一个else if
						continue;
					}
				}
			}
		}
	}

	private void instance() {
		for (String className : classNames) {
			//com.ys.xxx.xxx.class
			//截取掉当前的.class后缀
			String cn = className.replace(".class", "");
			try {
				//获取到当前类的路径,可以利用反射对对象进行实例化
				Class<?> clazz = Class.forName(cn);
				//判断当前类里是否声明了类上注解
				if(clazz.isAnnotationPresent(MyController.class)){
					//控制类
					Object instance = clazz.newInstance();
					//获取类上的requestmapping注解
					MyRequestMapping map1 = clazz.getAnnotation(MyRequestMapping.class);
					//获取注解的值
					String key = map1.value();
					//将注解上的值作为key值存入到map集合中
					beans.put(key, instance);
				}else if(clazz.isAnnotationPresent(MyService.class)){
					//业务类
					Object instance = clazz.newInstance();
					//获取类上的Myservice注解
					MyService map2 = clazz.getAnnotation(MyService.class);
					//获取注解的值
					String key = map2.value();
					//将注解上的值作为key值存入到map集合中
					beans.put(key, instance);
				}else{
					continue;
				}
			} catch (ClassNotFoundException e) {
				e.printStackTrace();
			} catch (InstantiationException e) {
				e.printStackTrace();
			} catch (IllegalAccessException e) {
				e.printStackTrace();
			}
		}
	}

	//扫描所有的基础包下的文件，将所有的类路径存在list集合下
	private void scanPackage(String basepackage) {
		//将路径中的.换成java认识的/
		URL url = this.getClass().getClassLoader().getResource("/"+basepackage.replaceAll("\\.", "/"));
		//E:workpace/abc
		String fileStr = url.getFile();
		//找到基础包路径
		File file = new File(fileStr);
		//获取该文件下所有的文件
		String[] fileNames = file.list();
		//只需要文件，所以遍历
		for (String path : fileNames) {
			//fileStr+filename  基础包路径拼接上对应路径名
			File filePath = new File(fileStr+path);
			//判断是否是文件
			if(filePath.isDirectory()){
				//是文件的话递归直到是文件为止
				scanPackage(basepackage+"."+path);
			}else{
				//com.ys.xxx.xxx.class
				classNames.add(basepackage+"."+filePath.getName());
			}
		}
	}

	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		this.doPost(request, response);
	}
	
	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		//  http://ip+端口/项目名/请求路径
		//  uri获取得是            /项目名/请求路径
		String uri = request.getRequestURI();
		System.out.println("uri:"+uri);
		//获取工程名
		String contextPath = request.getContextPath();
		System.out.println("contextPath:"+contextPath);
		//剪切   /请求路径
		String path = uri.replace(contextPath, ""); 
		System.out.println("path:"+path);
		//获取handlerMap中的方法
		Method method = (Method)handlerMap.get(path);
		System.out.println("method:"+method);
		//不足：进行了强转：因为只有一个controller类，所以，多个情况使用Object类型，具体使用时进行强转
		TestController instance = (TestController)beans.get("/"+path.split("/")[1]);
		System.out.println(instance);
		//参数处理
		Object[] args = hand(request, response, method);
		//调用方法
		try {
			method.invoke(instance, args);
		} catch (IllegalAccessException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IllegalArgumentException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (InvocationTargetException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
	//获取方法中的参数
	private static Object[] hand(HttpServletRequest request, HttpServletResponse response,Method method){
		//拿到当前执行方法有哪些参数
		Class<?>[] paramClazzs = method.getParameterTypes();
		//根据参数个数，new一个参数的数组，将方法里的所有参数赋值大agrs中
		Object[] args = new Object[paramClazzs.length];
		
		int args_i = 0;
		int index = 0;
		for (Class<?>  paramClazz : paramClazzs) {
			if(ServletRequest.class.isAssignableFrom(paramClazz)){
				args[args_i++] = request;
			}
			if(ServletResponse.class.isAssignableFrom(paramClazz)){
				args[args_i++] = response;
			}
			
			Annotation[] paramAns = method.getParameterAnnotations()[index];
			if(paramAns.length>0){
				for (Annotation paramAn : paramAns) {
					if(MyRequestParam.class.isAssignableFrom(paramAn.getClass())){
						MyRequestParam mp = (MyRequestParam) paramAn;
						//找到注解里的name和password
						args[args_i++] = request.getParameter(mp.value());
					}
				}
			}
			index++;
		}
		return args;
	}
}

3.结果

servlet中的init方法中test测试 ：遍历已经完成存储的容器结果

最终运行结果