手写MVC之IOC,DI

电玩女神 2022-05-16 07:29 195阅读 0赞

手写IOC和DI，全部代码只使用了javax.servlet.\*包，无其他任何工具包

![70][]

目录结构如图所示，最终实现效果如下:

![70 1][]

依次写好一下几个注解：

![70 2][]这几个代码就不发了，代码放在[这里。][Link 1]

![70 3][]

最重要的步骤如下：

1.新建一个web项目，配置web.xml文件

<servlet>
            <servlet-name>dispatchServlet</servlet-name>
            <servlet-class>com.panfan.config.MyDispatcherServlet</servlet-class>
            <init-param>
                <param-name>scanPackage</param-name>
                <param-value>com.panfan</param-value>
            </init-param>
            <load-on-startup>1</load-on-startup>
        </servlet>
        <servlet-mapping>
            <servlet-name>dispatchServlet</servlet-name>
            <url-pattern>/*</url-pattern>
        </servlet-mapping>

2.新建sevlet，如下：

package com.panfan.config;
    
    import java.io.ByteArrayOutputStream;
    import java.io.File;
    import java.io.IOException;
    import java.io.PrintWriter;
    import java.lang.annotation.Annotation;
    import java.lang.reflect.Field;
    import java.lang.reflect.Method;
    import java.net.URL;
    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.LinkedList;
    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.panfan.annotation.Autowired;
    import com.panfan.annotation.Controller;
    import com.panfan.annotation.RequestMapping;
    import com.panfan.annotation.RequestParam;
    import com.panfan.annotation.Service;
    
    
    @SuppressWarnings("serial")
    public class MyDispatcherServlet extends HttpServlet {
    
    	// 保存需要被托管的类名（全类名）
    	private List<String> classNames = new ArrayList<>();
    	// 保存beanname到bean实例的映射map
    	private Map<String, Object> beanMap = new HashMap<>();
    	// Url 到方法的映射，MappingModel里面有Method，参数名，controller的全类名
    	private Map<String, MappingModel> handlerMap = new HashMap<>();
    	
    	
    	@Override
    	public void init(ServletConfig config) throws ServletException {
    		System.out.println("MyDispatcherServlet -- 各种初始化操作");
    		// 得到包，扫描web.xml配置中的init-param指定的路径下文件，并打印结果
    		scanPackage(config.getInitParameter("scanPackage"));
        	System.out.println(" 包扫描完成,所有被扫描到类有： ");
    		classNames.forEach(name -> System.out.println(name));
    		// 得到注解的实例，为之后注入做准备
    		doInject();
    		// 注入AutoWired标注的属性
    		doAutowired();
    		// 路径url和方法之间映射管理建立
    		doHandlerMapping();
    	}
    	
    	
    	@Override
    	protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    		doPost(req, resp);
    	}
    
    	@Override
    	protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    		try {
    			// 映射url到方法
                boolean isMatcher = mapping(req, resp);
                if (!isMatcher) {
                    out(resp,"404 not found");
                }
            } catch (Exception e) {
            	e.printStackTrace();
                ByteArrayOutputStream buf = new java.io.ByteArrayOutputStream();
                e.printStackTrace(new PrintWriter(buf, true));
                String expMessage = buf.toString();
                buf.close();
                out(resp, "500 Exception" + "\n" + expMessage);
            }
    		System.out.println("doPost完毕-------------------------------");
        }
     
        
        // 扫描包，并保存扫描到的所有符合的类的全类名
        private void scanPackage(String packageName) {
        	 //获取指定的包的实际路径url，将com.panfan变成目录结构com/panfan
        	URL url = this.getClass().getClassLoader().getResource("/" + packageName.replace(".", "/"));
        	//转化成file对象
        	File dir = new File(url.getFile());
        	for(File file : dir.listFiles()) {
        		if (file.isDirectory()) {
        			scanPackage(packageName + "." + file.getName());
        		}else {
        			if (!file.getName().endsWith(".class")) {
        				continue;
        			}
        			String className = packageName + "." + file.getName().replace(".class", "");
        			
        			//判断是否被Controller或者Service注解了
                    try {
                        Class<?> clazz = Class.forName(className);
                        if (clazz.isAnnotationPresent(Controller.class) || clazz.isAnnotationPresent(Service.class)) {
                            // 保存需要托管的类的全类名
                        	classNames.add(className);
                        }
                    } catch (ClassNotFoundException e) {
                        e.printStackTrace();
                    }
        		}
        	}
        }
        
        // 保存所有添加了注解的bean，放入map,注意key为类的全类名，
        private void doInject() {
        	if (classNames.size() <= 0) {
        		return ;
        	}
        	classNames.forEach(classname -> {
        		try {
        			Class<?> clazz = Class.forName(classname);
        			// 如果是Controller，则放入一个新的实例到beanMap,controller
        			if (clazz.isAnnotationPresent(Controller.class)) {
    					beanMap.put(classname, clazz.newInstance());
        			}else if (clazz.isAnnotationPresent(Service.class)) {
        				// 如果是Service，因为@Service注解是在ServiceImpl实现类上，所以我们需要先扫描这个实现类的所有接口
    					Service service = clazz.getAnnotation(Service.class);
    					// 如果@Service 注解的value属性不为空，bean的名字就是value的值
    					String value = service.value();
    					if (!"".equals(value)) {
    						beanMap.put(value, clazz.newInstance());
    					}else {
    						Class[] interfaces = clazz.getInterfaces();
    						for (Class c : interfaces) {
    							/** 有可能有多个接口，例如UserSerivceImpl实现UserService接口和AccountServcie接口，
    							     这里判断UserSerivceImpl名字中包含UserService，所以默认bean名字就是com.panfan.service.UserService
    							   你可以自定义此处的规则 */
    							if (clazz.getSimpleName().contains(c.getSimpleName())) {
    								beanMap.put(c.getName(), clazz.newInstance());
    								break;
    							}
    						}
    					}
    				}
        		}catch (ClassNotFoundException e) {
    				e.printStackTrace();
    			}catch (IllegalAccessException e) {
    				e.printStackTrace();
    			}catch (InstantiationException e) {
    				e.printStackTrace();
    			}
        	});
        	// 打印一下
        	System.out.println("所有完成映射的实例");
    		beanMap.forEach((k, v) -> System.out.println(k + ":" + v));
        }
        
        
        // 为autowired注入属性
        private void doAutowired() {
        	if (beanMap.isEmpty()) {
        		return ;
        	}
        	// 遍历所有被托管的对象
        	beanMap.forEach((k, v) -> {
        		// 取出所有字段
        		Field[] fields = v.getClass().getDeclaredFields();
        		for (Field field : fields) {
        			if (!field.isAnnotationPresent(Autowired.class)) {
        				continue;
        			}
        			// 设置对象的访问权限，保证对private的属性的访问
                    field.setAccessible(true);
        			// 获取autowired标注属性的类型，autowired 先按类型注入
                    String className = field.getType().getName();
                    if (null != beanMap.get(className)) {
                    	try {
    						field.set(v, beanMap.get(className));
    						System.out.println("根据类型为 " + v.getClass().getSimpleName() + " 注入 " + field.getName() + " 成功");
    					} catch (Exception e) {
    						System.out.println("======================AutoWired注入失败=====================");
    					}
                    }// autowired 按类型寻找不到bean，则按属性名字注入
                    else if (null != beanMap.get(field.getName())) {
                    	try {
    						field.set(v, beanMap.get(field.getName()));
    						System.out.println("根据属性名为 " + v.getClass().getSimpleName() + " 注入 " + field.getName() + " 成功");
    					} catch (Exception e) {
    						System.out.println("======================AutoWired注入失败=====================");
    					}
                    }
        		}
        		
        	});
        }
        
        
        // 把url对方法的映射保存到map
        public void doHandlerMapping() {
        	if (beanMap.isEmpty()) {
        		return ;
        	}
        	beanMap.forEach((k, v) -> {
        		Class<?> clazz = v.getClass();
        		// 只处理Controller的，只有Controller才有RequestMapping
        		if (clazz.isAnnotationPresent(Controller.class)) {
        			// 方法对应uri地址
        			String url = null ;
        			// 获取类上的路径,自动补前面的斜杠，后面不能有斜杠
        			if (clazz.isAnnotationPresent(RequestMapping.class)) {
        				RequestMapping requestMapping = clazz.getAnnotation(RequestMapping.class);
        				String value = requestMapping.value();
        				if (value.startsWith("/")) {
        					url = value;
        				}else {
        					url = "/" + value;
        				}
        			}
        			// 获取方法上路径
        			Method[] methods = clazz.getDeclaredMethods();
        			// 只处理有RequestMapping的方法
        			for (Method method : methods) {
        				if (!method.isAnnotationPresent(RequestMapping.class)) {
                            continue;
                        }
    					RequestMapping requestMapping = method.getAnnotation(RequestMapping.class);
    					String value = requestMapping.value();
    					String realUrl ;
        				if (value.startsWith("/")) {
        					realUrl = url + value;
        				}else {
        					realUrl = url + "/" + value;
        				}
        				
        				LinkedList<String> list = new LinkedList<String>() ;
        				// 第一个维度对应参数列表里参数的数目，第二个维度对应参数列表里对应的注解
        				Annotation[][] annotations = method.getParameterAnnotations();
        				// 扫描@RequestParam注解
        				int t =0;
        				for (int i=0; i<annotations.length; i++,t++) {
        					// 如果前面有注解的话
    						if (annotations[i].length > 0 ) {
    							// 循环遍历是否有RequestParam注解
    							for (int j=0; j<annotations[i].length; j++) {
    								Class<?> type = annotations[i][j].annotationType();
        							if (type == RequestParam.class) {
        								RequestParam requestParam = (RequestParam) annotations[i][j];
        								list.add(requestParam.value());
        								break;
        							}
        						}
        					}
        				}
        				// 得到一个url映射，MappingModel包括controller,参数列表，和method
        				MappingModel mappingModel = new MappingModel(method, list.toArray(), clazz.getName());
        				handlerMap.put(realUrl, mappingModel);
        			}
        		}
        	});
        	
        	// 打印一下
        	System.out.println("所有url对应方法的映射关系");
    		handlerMap.forEach((k, v) -> {
    			System.out.println(k + ":" + v.method.getName() + "()  方法所有参数如下：");
    			System.out.println(v.list);
    		});
        	
        }
        
        
        // 通过请求地址和参数进行映射，成功后执行对应方法代码
        protected boolean mapping(HttpServletRequest request, HttpServletResponse response) {
        	if (handlerMap.isEmpty()) {
        		return false;
        	}
        	// 用户请求地址
            String requestUri = request.getRequestURI();
            String contextPath = request.getContextPath();
            // 找出除项目外的uri,用户写了多个"///"，只保留一个
            requestUri = requestUri.replace(contextPath, "").replaceAll("/+", "/");
            MappingModel mappingModel = handlerMap.get(requestUri);
            // 得到目标方法
            Method method = mappingModel.method;
        	// 得到参数列表
            Object[] list = mappingModel.list;
            LinkedList<Object> values = new LinkedList<>() ;
            Class<?>[] classes = method.getParameterTypes();
        	for (int i=0; i<classes.length; i++) {
        		if (classes[i]== HttpServletRequest.class) {
        			values.add(request);
        			continue;
        		}else if (classes[i]== HttpServletResponse.class) {
        			values.add(response);
        			continue;
    			}
        		values.add(convert(request.getParameter(list[i].toString()), classes[i]));
        	}
            try {
    			method.invoke(beanMap.get(mappingModel.controller), values.toArray());
    			return true;
    		} catch (Exception e) {
    			e.printStackTrace();
    			return false;
    		} 
        	
    		
    	}
        
        
        
        // 头个字母大写变小写，这里用到ascii码
        private String lowerFirstChar(String className) {
            char[] chars = className.toCharArray();
            chars[0] += 32;
            return String.valueOf(chars);
        }
        
        // 参数转换
        private Object convert(String parameter, Class<?> targetType) {
            if (targetType == String.class) {
                return parameter;
            } else if (targetType == Integer.class || targetType == int.class) {
                return Integer.valueOf(parameter);
            } else if (targetType == Long.class || targetType == long.class) {
                return Long.valueOf(parameter);
            } else if (targetType == Boolean.class || targetType == boolean.class) {
                if (parameter.toLowerCase().equals("true") || parameter.equals("1")) {
                    return true;
                } else if (parameter.toLowerCase().equals("false") || parameter.equals("0")) {
                    return false;
                }
                throw new RuntimeException("不支持的参数");
            }
            else {
                //TODO 还有很多其他的类型，char、double之类的依次类推，也可以做List<>, Array, Map之类的转化
                return null;
            }
        }
        
        // 疯狂输出
        private void out(HttpServletResponse response, String str) {
            try {
                response.setContentType("application/json;charset=utf-8");
                response.getWriter().print(str);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    
    }

还有一个java类

import java.lang.reflect.Method;
    import java.util.LinkedList;
    
    public class MappingModel {
    	
    	// url对应的Method
    	Method method;
    	// 对应的Controller全类名，可以得到MyDispatcherServlet中的beanMap中的Controller实例
    	Object controller;
    	// 记录此方法中的所有@RequestParam注解的参数，有序放置
    	Object[] list;
    	
    	public MappingModel(Method method, Object[] list, Object controller) {
    		this.method = method;
    		this.list = list;
    		this.controller = controller;
    	}
    }

注释很全，自己看看吧，累死了。

![70 4][]

![70 5][]

![70 6][]

[70]: /images/20220516/fcf40d80cf4d4da2aed1b198fd2c1a57.png
[70 1]: /images/20220516/fa9e34302b39477c8d0f5b718e35483c.png
[70 2]: /images/20220516/073932425d5942ecad475bbe9a2aeb07.png
[Link 1]: https://download.csdn.net/download/qq_32953079/10610836
[70 3]: /images/20220516/f60555d39a0e443197e50195307ae149.png
[70 4]: /images/20220516/4b72b50aaf6c4b058db0b6ac01ccc024.png
[70 5]: /images/20220516/a527afbfb9a4451b85e7bfb3f7f13bfb.png
[70 6]: /images/20220516/95ca141637374fdbbe0086b7cdde905c.png