手写简易版SpringMVC框架

秒速五厘米 2022-03-20 15:48 309阅读 0赞

### 1.反射工具类 ###

package com.weichai.util;
 
 import java.io.File;
 import java.io.FileFilter;
 import java.io.IOException;
 import java.net.JarURLConnection;
 import java.net.URL;
 import java.net.URLDecoder;
 import java.util.ArrayList;
 import java.util.Enumeration;
 import java.util.List;
 import java.util.jar.JarEntry;
 import java.util.jar.JarFile;
 
 /**
 * 反射工具类
 * @author linhaiy
 * @date 2019.01.26
 */
 public class ClassUtil {
 
 	/**
 	 * 取得某个接口下所有实现这个接口的类
 	 * @param c
 	 * @return
 	 */
 	public static List<Class> getAllClassByInterface(Class c) {
 		List<Class> returnClassList = null;
 
 		if (c.isInterface()) {
 			// 获取当前的包名
 			String packageName = c.getPackage().getName();
 			// 获取当前包下以及子包下所以的类
 			List<Class<?>> allClass = getClasses(packageName);
 			if (allClass != null) {
 				returnClassList = new ArrayList<Class>();
 				for (Class classes : allClass) {
 					// 判断是否是同一个接口
 					if (c.isAssignableFrom(classes)) {
 						// 本身不加入进去
 						if (!c.equals(classes)) {
 							returnClassList.add(classes);
 						}
 					}
 				}
 			}
 		}
 
 		return returnClassList;
 	}
 
 	/**
 	 * 取得某一类所在包的所有类名 不含迭代
 	 * @param classLocation
 	 * @param packageName
 	 * @return
 	 */
 	public static String[] getPackageAllClassName(String classLocation, String packageName) {
 		// 将packageName分解
 		String[] packagePathSplit = packageName.split("[.]");
 		String realClassLocation = classLocation;
 		int packageLength = packagePathSplit.length;
 		for (int i = 0; i < packageLength; i++) {
 			realClassLocation = realClassLocation + File.separator + packagePathSplit[i];
 		}
 		File packeageDir = new File(realClassLocation);
 		if (packeageDir.isDirectory()) {
 			String[] allClassName = packeageDir.list();
 			return allClassName;
 		}
 		return null;
 	}
 
 	/**
 	 * 从包package中获取所有的Class
 	 * @param packageName
 	 * @return
 	 */
 	public static List<Class<?>> getClasses(String packageName) {
 
 		// 第一个class类的集合
 		List<Class<?>> classes = new ArrayList<Class<?>>();
 		// 是否循环迭代
 		boolean recursive = true;
 		// 获取包的名字 并进行替换
 		String packageDirName = packageName.replace('.', '/');
 		// 定义一个枚举的集合 并进行循环来处理这个目录下的things
 		Enumeration<URL> dirs;
 		try {
 			dirs = Thread.currentThread().getContextClassLoader().getResources(packageDirName);
 			// 循环迭代下去
 			while (dirs.hasMoreElements()) {
 				// 获取下一个元素
 				URL url = dirs.nextElement();
 				// 得到协议的名称
 				String protocol = url.getProtocol();
 				// 如果是以文件的形式保存在服务器上
 				if ("file".equals(protocol)) {
 					// 获取包的物理路径
 					String filePath = URLDecoder.decode(url.getFile(), "UTF-8");
 					// 以文件的方式扫描整个包下的文件 并添加到集合中
 					findAndAddClassesInPackageByFile(packageName, filePath, recursive, classes);
 				} else if ("jar".equals(protocol)) {
 					// 如果是jar包文件
 					// 定义一个JarFile
 					JarFile jar;
 					try {
 						// 获取jar
 						jar = ((JarURLConnection) url.openConnection()).getJarFile();
 						// 从此jar包 得到一个枚举类
 						Enumeration<JarEntry> entries = jar.entries();
 						// 同样的进行循环迭代
 						while (entries.hasMoreElements()) {
 							// 获取jar里的一个实体 可以是目录 和一些jar包里的其他文件 如META-INF等文件
 							JarEntry entry = entries.nextElement();
 							String name = entry.getName();
 							// 如果是以/开头的
 							if (name.charAt(0) == '/') {
 								// 获取后面的字符串
 								name = name.substring(1);
 							}
 							// 如果前半部分和定义的包名相同
 							if (name.startsWith(packageDirName)) {
 								int idx = name.lastIndexOf('/');
 								// 如果以"/"结尾 是一个包
 								if (idx != -1) {
 									// 获取包名 把"/"替换成"."
 									packageName = name.substring(0, idx).replace('/', '.');
 								}
 								// 如果可以迭代下去 并且是一个包
 								if ((idx != -1) || recursive) {
 									// 如果是一个.class文件 而且不是目录
 									if (name.endsWith(".class") && !entry.isDirectory()) {
 										// 去掉后面的".class" 获取真正的类名
 										String className = name.substring(packageName.length() + 1, name.length() - 6);
 										try {
 											// 添加到classes
 											classes.add(Class.forName(packageName + '.' + className));
 										} catch (ClassNotFoundException e) {
 											e.printStackTrace();
 										}
 									}
 								}
 							}
 						}
 					} catch (IOException e) {
 						e.printStackTrace();
 					}
 				}
 			}
 		} catch (IOException e) {
 			e.printStackTrace();
 		}
 
 		return classes;
 	}
 
 	/**
 	 * 以文件的形式来获取包下的所有Class
 	 * @param packageName
 	 * @param packagePath
 	 * @param recursive
 	 * @param classes
 	 */
 	public static void findAndAddClassesInPackageByFile(String packageName, String packagePath, final boolean recursive,
 			List<Class<?>> classes) {
 		// 获取此包的目录 建立一个File
 		File dir = new File(packagePath);
 		// 如果不存在或者 也不是目录就直接返回
 		if (!dir.exists() || !dir.isDirectory()) {
 			return;
 		}
 		// 如果存在 就获取包下的所有文件 包括目录
 		File[] dirfiles = dir.listFiles(new FileFilter() {
 			// 自定义过滤规则 如果可以循环(包含子目录) 或则是以.class结尾的文件(编译好的java类文件)
 			public boolean accept(File file) {
 				return (recursive && file.isDirectory()) || (file.getName().endsWith(".class"));
 			}
 		});
 		// 循环所有文件
 		for (File file : dirfiles) {
 			// 如果是目录 则继续扫描
 			if (file.isDirectory()) {
 				findAndAddClassesInPackageByFile(packageName + "." + file.getName(), file.getAbsolutePath(), recursive,
 						classes);
 			} else {
 				// 如果是java类文件 去掉后面的.class 只留下类名
 				String className = file.getName().substring(0, file.getName().length() - 6);
 				try {
 					// 添加到集合中去
 					classes.add(Class.forName(packageName + '.' + className));
 				} catch (ClassNotFoundException e) {
 					e.printStackTrace();
 				}
 			}
 		}
 	}
 
 	/**
 	 * 首字母转小写
 	 * @param s
 	 * @return
 	 */
 	public static String toLowerCaseFirstOne(String s) {
 		if (Character.isLowerCase(s.charAt(0)))
 			return s;
 		else
 			return (new StringBuilder()).append(Character.toLowerCase(s.charAt(0))).append(s.substring(1)).toString();
 	}
 
 	/**
 	 * 初始化对象
 	 * @param classInfo
 	 * @return
 	 * @throws ClassNotFoundException
 	 * @throws InstantiationException
 	 * @throws IllegalAccessException
 	 */
 	public static Object newInstance(Class<?> classInfo)
 			throws ClassNotFoundException, InstantiationException, IllegalAccessException {
 		return classInfo.newInstance();
 	}
 }

### 2.框架需要的注解类 ###

package com.weichai.annotation;
    
    import java.lang.annotation.ElementType;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.annotation.Target;
    
    /**
        * 自定义控制器注解 
     * @author linhaiy
     * @date 2019.01.26
     */
    @Target({ ElementType.TYPE })
    @Retention(RetentionPolicy.RUNTIME)
    public @interface ExtController {
    
    }

package com.weichai.annotation;
    
    import java.lang.annotation.ElementType;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.annotation.Target;
    
    /**
        * 自定义RequestMapping
     * @author linhaiy
     * @date 2019.01.26
     */
    @Target({ ElementType.METHOD, ElementType.TYPE })
    @Retention(RetentionPolicy.RUNTIME)
    public @interface ExtRequestMapping {
    	String value() default "";
    }

### 3. 自定义前端控制器（SpringMVC框架核心处理） ###

package com.weichai.servlet;
 
 import java.io.IOException;
 import java.lang.reflect.Method;
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
 
 import javax.servlet.ServletException;
 import javax.servlet.http.HttpServlet;
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 
 import org.apache.commons.lang.StringUtils;
 
 import com.weichai.annotation.ExtController;
 import com.weichai.annotation.ExtRequestMapping;
 import com.weichai.util.ClassUtil;
 
 /**
 * 自定义前端控制器
 * 手写springmvc 原理分析 
 * 1.创建一个前端控制器（）ExtDispatcherServlet 拦截所有请求(springmvc 基于servlet实现) 
 * ####2.初始化操作 重写servlet init 方法 
 * #######2.1 将扫包范围所有的类,注入到springmvc容器里面，存放在Map集合中 key为默认类名小写，value 对象 
 * #######2.2 将url映射和方法进行关联 
 * ##########2.2.1 判断类上是否有注解,使用java反射机制循环遍历方法 ,判断方法上是否存在注解，进行封装url和方法对应存入集合中 
 * ####3.处理请求 重写Get或者是Post方法 
 * ##########3.1
 * 获取请求url,从urlBeans集合获取实例对象,获取成功实例对象后,调用urlMethods集合获取方法名称,使用反射机制执行 2. 
 * @author linhaiy
 * @date 2019.01.26
 */
 public class ExtDispatcherServlet extends HttpServlet {
 
 	// SpringMVC容器对象 key:类名id ,value 对象
 	private ConcurrentHashMap<String, Object> springmvcBeans = new ConcurrentHashMap<String, Object>();
 	// SpringMvc 容器对象 keya:请求地址 ,vlue类
 	private ConcurrentHashMap<String, Object> urlBeans = new ConcurrentHashMap<String, Object>();
 	// SpringMvc 容器对象 key:请求地址 ,value 方法名称
 	private ConcurrentHashMap<String, String> urlMethods = new ConcurrentHashMap<String, String>();
 	
 	public void init() throws ServletException {
 		// 1.获取当前包下的所有的类
 		List<Class<?>> classes = ClassUtil.getClasses("com.weichai.controller");
 		try {
 			// 2.将扫包范围所有的类,注入到SpringMvc容器里面，存放在Map集合中 key为默认类名小写，value 对象
 			findClassMVCAnnotation(classes);
 		} catch (Exception e) {
 			// TODO Auto-generated catch block
 			e.printStackTrace();
 		}
 		//3.将url映射和方法进行关联
 		handlerMapping();
 	}
 	
 	/**
 	 * get请求方法
 	 */
 	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException{
 		doPost(request,response);
 	}
 
 	/**
 	 * post请求方法
 	 */
 	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
 		// #################处理请求####################
 		// 1.获取请求url地址
 		String requestURL = request.getRequestURI(); //此处获取的是带工程名的路径
 		String URL = requestURL.substring(requestURL.indexOf("/", 2) + 1); //去除工程名
 		if(StringUtils.isEmpty(requestURL)) {
 			return;
 		}
 		URL = "/"+URL;
 		// 2.从Map集合中获取控制对象
 		Object object = urlBeans.get(URL); // /Main/test
 		if(object == null) {
 			response.getWriter().println(" not found 404 url");
 			return;
 		}
 		// 3.使用url地址获取方法
 		String methodName = urlMethods.get(URL);
 		if(StringUtils.isEmpty(methodName)) {
 			response.getWriter().println(" not found method");
 		}
 		// 4.使用java的反射机制调用方法
 		String resultPage = (String) methodInvoke(object, methodName);
 		// 5.调用视图转换器渲染给页面展示
 		extResourceViewResolver(resultPage, request, response);
 	}
 	
 	/**
 	 * 调用视图转换器渲染给页面展示
 	 * @param resultPage
 	 * @param request
 	 * @param response
 	 * @throws IOException 
 	 * @throws ServletException 
 	 */
 	private void extResourceViewResolver(String resultPage, HttpServletRequest request, HttpServletResponse response)
 			throws ServletException, IOException {
 		// TODO Auto-generated method stub
 		String prefix = "/"; // 根路径
 		String suffix = ".jsp";
 		request.getRequestDispatcher(prefix + resultPage + suffix).forward(request, response);
 	}
 
 	/**
 	 * 使用java的反射机制调用方法
 	 * @param object
 	 * @param methodName
 	 * @return
 	 */
 	private Object methodInvoke(Object object, String methodName) {
 		// TODO Auto-generated method stub
 		try {
 			Class<? extends Object> classInfo = object.getClass();
 			Method method = classInfo.getMethod(methodName);
 			Object result = method.invoke(object);
 			return result;
 		} catch (Exception e) {
 			// TODO Auto-generated catch block
 			e.printStackTrace();
 		} 
 		return null;
 	}
 
 	/**
 	 * 将url映射和方法进行关联
 	 */
 	private void handlerMapping() {
 		// TODO Auto-generated method stub
 		// 1.遍历springmvc bean容器 判断类上属否有url映射注解
 		for(Map.Entry<String, Object> mvcBean : springmvcBeans.entrySet()) {
 			// 2.遍历所有的方法上是否有url映射注解
 			Object object = mvcBean.getValue(); // 获取bean的对象
 			// 3.判断类上是否有加url映射注解
 			Class<? extends Object> classInfo = object.getClass();
 			ExtRequestMapping declaredAnnotation = classInfo.getDeclaredAnnotation(ExtRequestMapping.class);
 			String baseUrl = "";
 			if(declaredAnnotation !=null) {
 				baseUrl = declaredAnnotation.value(); //获取类上的url映射地址
 			}
 			//4.判断方法上是否有加url映射地址
 			Method[] declaredMethods = classInfo.getDeclaredMethods();
 			for(Method method : declaredMethods) {
 				// 判断方法上是否有加url映射注解
 				ExtRequestMapping methodExtRequestMapping = method.getDeclaredAnnotation(ExtRequestMapping.class);
 				if(methodExtRequestMapping !=null) {
 					String methodUrl = baseUrl + methodExtRequestMapping.value();
 					// springmvc 容器对象 keya:请求地址 ,vlue类
 					urlBeans.put(methodUrl, object);
 					// springmvc 容器对象 key:请求地址 ,value 方法名称
 					urlMethods.put(methodUrl, method.getName());
 				}
 			}
 		}
 	}
 
 	/**
 	 * 将扫包范围所有的类,注入到SpringMvc容器里面，存放在Map集合中 key为默认类名小写，value 对象
 	 * @param classes
 	 */
 	private void findClassMVCAnnotation(List<Class<?>> classes)
 			throws ClassNotFoundException, InstantiationException, IllegalAccessException {
 		// TODO Auto-generated method stub
 		for (Class<?> classInfo : classes) {
 			ExtController extController = classInfo.getDeclaredAnnotation(ExtController.class); // 判断类上是否有加上注解
 			if (extController != null) {
 				String beanId = ClassUtil.toLowerCaseFirstOne(classInfo.getSimpleName()); // 默认类名是小写
 				Object object = ClassUtil.newInstance(classInfo); // 实例化对象
 				springmvcBeans.put(beanId, object);
 			}
 		}
 	}
 }

### 4.前端控制器web.xm配置文件 ###

<?xml version="1.0" encoding="UTF-8"?>
 <web-app xmlns="http://java.sun.com/xml/ns/j2ee"
 	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 	xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"
 	version="2.4">
 
 	
 	<servlet>
 		<servlet-name>dispatcher</servlet-name>
 		<servlet-class>com.weichai.servlet.ExtDispatcherServlet
 		</servlet-class>
 		<load-on-startup>1</load-on-startup>
 	</servlet>
 	<servlet-mapping>
 		<servlet-name>dispatcher</servlet-name>
 		
 		<url-pattern>/</url-pattern>
 	</servlet-mapping>
 </web-app>

### 5.控制层测试类 ###

package com.weichai.controller;
    
    import com.weichai.annotation.ExtController;
    import com.weichai.annotation.ExtRequestMapping;
    
    @ExtController
    @ExtRequestMapping("/Main")
    public class ExtIndexController {
    	
    	@ExtRequestMapping("/test")
    	public String test() {
    		System.out.println("手写springmvc框架...");
    		return "index";
    	}
    }