标签：xtend static autowire 简单 mem response 遍历 append pattern
版权声明:本篇博客大部分代码引用于公众号：java团长，我只是在作者基础上稍微修改一些内容，内容仅供学习与参考
前言：目前mvc框架经过大浪淘沙，由最初的struts1到struts2,到目前的主流框架SpringMvc,并逐渐区域占领市场主流稳定状态，由于其背后强大的Spring家族提供了一系列高可用的组件和服务，SpringMvc在短时间内肯定是无法被超越的。公司里开发的项目第一首先框架就是SpringMvc，在市场上如火如荼，甚嚣尘上。今天我们就来自己手动实现一个简历的阉割版SpringMvc，主要的目的就是体会SpringMvc的设计思路和理念，了解其幕后工作流程，当然需要注意的是本次实现的是简易版，代码不超过500行，所以本篇博客姑且只可领会设计思路，抛砖引玉，不可陷入细枝末节、吹毛求疵的死胡同里
本篇博客的目录
一：springMvc的使用方法
二：项目开发结构
三：简易版springmvc的实现
四：总结
一：springMvc的使用方法
1.1：开发基本过程
springmvc开发过程是典型的mvc模式，首先在xml里配置dispatcherServlet（假如没有用到springboot的话）,然后再配置扫描包,注解驱动配置，在代码层面又用Controller上注解@RequestMapping映射请求，请求进入后，方法中用各种注解比如@pathvarible获得url请求参数，再到业务方法中的调用service，service再调用dao层，实现数据库的增删改查的业务性操作，之后再返回视图或者用@responseBoby修饰的返回数据，这已经成为一种典型的调用和开发模式！
1.2：基本原理
首先是xml配置，springmvc需要读取xml里面的配置，然后放在简单的一个集合数据模型里（Map）,再然后就是装载用户的配置，扫描基准包，获取用户添加的注解，获取注解信息和配置的参数，再用spring的IOC初始化配置的Bean实例，自动注入类实例（比如contoller的依赖service、dao层mappeer等,等容器启动起来，如果有请求进来，就会按照路径映射对应的controller,再选择方法进行处理完成一系列操作后返回给客户端。
二：项目开发结构
2.1：项目基本结构
这是一个简易版的springmvc，其中包含了基本的使用注解自己实现，和后台的默认控制器DispatcherServlet，还有解析xml的工具，和默认xml配置资源,我们使用的serlvet是3.1版本，采用了对基本servlet进行了二次封装，以下是基本的代码：
2.2：具体的开发过程示例
@MyRequestMapping(name = "/orderApi") @MyController(name = "order") public class OrderController { @MyQualifer(name = "orderServiceImpl") private OrderServiceImpl orderServiceImPl; @MyRequestMapping(name = "/create") public void create() { orderServiceImPl.createOrder(); } }
@MyRepository(name = "orderDao")
public class OrderDao {
public void insert() {
System.out.println("数据库中插入一条记录");
}
}
public interface OrderServiceEx {
public void createOrder();
}
@MyService(name = "orderServiceImpl")
public class OrderServiceImpl implements OrderServiceEx {
@MyQualifer(name = "orderDao")
private OrderDao orderDao;
public void createOrder() {
}
}
三：简易版springmvc的实现
3.1：读取xml配置
解析xml采用的是dom4j的1.6.1版本，目的是模仿springmvc解析用户的配置文件，读取用户配置的扫描包，以下是xmlUtil的源码：
public class XmlUtil { public static String getNodeValue(String nodeName, String xmlPath) { try { // 将字符串转为xml Document document = DocumentHelper.parseText(xmlPath); // 查找节点 Element element = (Element) document.selectSingleNode(nodeName); if (element != null) { return element.getStringValue(); } } catch (DocumentException e) { e.printStackTrace(); } return ""; } }
3.2：定义注解
3.2.1:模拟Reposity注解
作用就是告诉spring容器将依赖实例化注入到需要的调用类里面，其中用了name这个属性，就是让spring根据名字去寻找对应的bean进行依赖注入。并标识其运行在类上面（无法放在方法上）
@Documented @Target(ElementType.TYPE) @Retention(RetentionPolicy.RUNTIME) public @interface MyRepository { public String name(); }
3.2.2：模拟controller注解
作用就是告诉spring容器这是一个控制器，并交给spring去实例化，可以运行在类和方法上
@Documented @Target({ElementType.TYPE,ElementType.METHOD}) @Retention(RetentionPolicy.RUNTIME) public @interface MyController { public String name(); }
3.2.3：模拟Quanlifer注解
作用于成员变量上，主要的作用是让spring根据配置的bean的名字进行注入：
@Documented @Target(ElementType.FIELD) @Retention(RetentionPolicy.RUNTIME) public @interface MyQualifer { public String name(); }
3.2.4：模拟@service注解
作用于类或者接口上，主要的作用就是标识一个类为service层，并交给spring去初始化！
@Documented @Target(ElementType.Type) @Retention(RetentionPolicy.RUNTIME) public @interface MyService { public String name(); }
3.2.5：MyDispatcherServlet
模拟DispatcherServlet，主要的作用就是作为请求控制器，处理客户端请求,继承自HttpServlet,我使用的版本是3.1.0,因此可以用注解来取得一些参数：
@WebServlet(name = "dispatherServlet", urlPatterns = "/", loadOnStartup = 1) public class MyDispatcherServlet extends HttpServlet { /** * 扫描的基准包 */ private String basePackage = ""; /** * 包名 */ private List<String> packageNames = new ArrayList<>(); /** * 注解名和类实例 */ private Map<String, Object> instanceMap = new HashMap<String, Object>(); /** * 包名和注解名 */ private Map<String, String> nameMap = new HashMap<>(); /** * url和方法 */ private Map<String, Method> urlMethodMap = new HashMap<>(); /** * Method和包名 */ private Map<Method, String> methodPackageMap = new HashMap<>(); @Override public void init(ServletConfig config) { try { getBasePackageFromConfigXml(); scanBasePackage(basePackage); instance(packageNames); springIoc(); handleUrlMethodMap(); } catch (ClassNotFoundException e) { e.printStackTrace(); } catch (IllegalAccessException e) { e.printStackTrace(); } catch (InstantiationException e) { e.printStackTrace(); } }
这里是一个流程处理类，第一步从xml里面获取用户配置的信息，这里的主要作用就是扫描出配置的包名，第二步就是扫描基准包的路径然后放在一个List中，保存起来。第三步：根据扫描出来的包，获取包里面的类class，然后利用反射获取类上的class信息（不包含方法），然后把注解名和对应的类实例保存在map中，再把包名和注解的参数（这里主要是controller、service等在类上的）保存起来。第四步：模拟spring的IOC注入实例的过程，遍历第三步中的注解名和类实例map，然后利用反射实例化字段!第五步：遍历整个包下的类，然后获取类中的所有方法，再取得MyRequestMapping的注解上的配置的参数，把它存在urlMethodMap中，这里的作用就是把类上的MyRequestingMapping的配置的参数和方法上的注解配置的参数组装起来！最终在dopost方法中处理：
3.2.6：getBasePackFromConfig方法
整个方法的目的就是解析xml，获取基准包，这是我们继续往下的基础，因为只有获取包路径，我们才能扫描到注解，才能知道自己要开发的类在哪个目录
/** * 从xml中获取basePackage * @return */ private void getBasePackageFromConfigXml() { final String basePackageName = XmlUtil.getNodeValue("scan-package-path", "springmvcConfig.xml"); basePackage=basePackageName; }
3.2.7：scanBasePackage
扫描基础包：这是一个递归的方法，主要是解析路径，获取目录下的文件，然后添加文件名到packageNames这个list,保存了我们扫描的路径下的所有文件，接下来就是循环遍历这个list，取出其中的class再进一步的处理
/** * 扫描基础包，保存类路径到list中 * @param basePackage */ private void scanBasePackage(String basePackage) { final URL url = this.getClass().getClassLoader().getResource(basePackage.replaceAll("\\.", "/")); final File basePackageFile = new File(url.getPath()); System.out.println("扫描到的文件是:" + basePackageFile.getName()); final File[] files = basePackageFile.listFiles(); for (File file : files) { if (file.isDirectory()) { scanBasePackage(basePackage + "." + file.getName()); } else if (file.isFile()) { packageNames.add(basePackage + "." + file.getName().split("\\.")[0]); } } }
3.2.8：instance(packageNames)
该方法的主要目的就是遍历包下面的类，扫描类上面的注解，主要是@MyController、@MyService、@MyRepository，然后利用反射获取类上的注解，取得注解上配置的参数（就是name上的值，在下面的实例中，比如:instanceMap将会存放("order",OrderController.class),nameMap将会存放（"test.java.com.wyq","order"）
/** * 初始化 * * @param packageNames */ private void instance(List<String> packageNames) throws ClassNotFoundException, IllegalAccessException, InstantiationException { if (packageNames.size() < 1) { return; } for (String packageName : packageNames) { Class<?> fileClass = Class.forName(packageName); if (fileClass.isAnnotationPresent(MyController.class)) { MyController myController = fileClass.getAnnotation(MyController.class); final String controllerName = myController.name(); instanceMap.put(controllerName, fileClass.newInstance()); nameMap.put(packageName, controllerName); System.out.println("Controller:" + packageName + "name" + controllerName); } else if (fileClass.isAnnotationPresent(MyService.class)) { final MyService service = fileClass.getAnnotation(MyService.class); final String serviceName = service.name(); instanceMap.put(serviceName, fileClass.newInstance()); nameMap.put(packageName, serviceName); } else if (fileClass.isAnnotationPresent(MyRepository.class)) { final MyRepository repository = fileClass.getAnnotation(MyRepository.class); final String repositoryName = repository.name(); instanceMap.put(repositoryName, fileClass.newInstance()); nameMap.put(packageName, repositoryName); } } }
3.2.9:springIoc
springIoc的注入：该方法的目的主要是遍历instanceMap,找到有@MyController、@MyService、@MyRepository中的成员字段上有@Myqualifer的注解，（注：Myqualifer的作用类似于@AutoWired自动注入）然后获取这个注解，利用反射机制，实例化这个成员变量。
/** * springIOC的注入 * * @throws IllegalAccessException */ private void springIoc() throws IllegalAccessException { for (Map.Entry<String, Object> annotationNameAndInstance : instanceMap.entrySet()) { final Field[] fields = annotationNameAndInstance.getValue().getClass().getDeclaredFields(); for (Field field : fields) { if (field.isAnnotationPresent(MyQualifer.class)) { final String myQualiferName = field.getAnnotation(MyQualifer.class).name(); field.setAccessible(true); field.set(annotationNameAndInstance.getValue(), instanceMap.get(myQualiferName)); } } } }
3.3.0：handleUrlMethodMap
这个方法的主要作用就是获取@MyRequestMapping中配置的url链接，然后将他们封装到一个methodPackageMap的map中，其首先是取类上面的@MyRequestMapping配置的url，然后再取方法上的@MyRequestMapping配置的url,拼接在一起，作为键，映射其对应的方法，这样当请求进来时，就可以直接根据url匹配到对应的处理的方法。向下面的实例：methodPackageMap将会存放的数据是（"/orderApi/create",create(method)),而methodPackageMap将会存放的是（create,"com.wyq"）
/** * 处理请求的url和method * @throws ClassNotFoundException */ private void handleUrlMethodMap() throws ClassNotFoundException { if (packageNames.size() < 1) { return; } for (String packageName : packageNames) { final Class<?> fileClass = Class.forName(packageName); final Method[] methods = fileClass.getMethods(); final StringBuffer baseUrl = new StringBuffer(); if (fileClass.isAnnotationPresent(MyRequestMapping.class)) { MyRequestMapping myRequest = (MyRequestMapping) fileClass.getAnnotation(MyRequestMapping.class); baseUrl.append(myRequest.name()); } for (Method method : methods) { if (method.isAnnotationPresent(MyRequestMapping.class)) { final MyRequestMapping myrequest = method.getAnnotation(MyRequestMapping.class); baseUrl.append(myrequest.name()); urlMethodMap.put(baseUrl.toString(), method); methodPackageMap.put(method, packageName); } } } }
3.3.1:doPost方法
这个方法的主要的思路就是把上面组装的map数据然后再反向解析，首先就是获取请求的url，然后获取contextPath（项目的地址),比如请求http://172.123.344.122:8080/order/create,那么最终的path就是order/create,再根据请求的url获取对应的处理方法，这里会找到create方法，再根据方法名找到类所在的包路径，再根据包路径获取Controller的名字，再根据Controller的名字获取具体的Controller（用户写的），再利用反射机制调用具体的Controller里的方法，这样从请求进入到解析处理就完成了！
/** * 具体的处理请求的方法 * @param req * @param resp * @throws ServletException * @throws IOException */ @Override protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { final String requestURI = req.getRequestURI(); final String contextPath = req.getContextPath(); final String path = requestURI.replaceAll(contextPath, ""); //根据请求的路径反向获取方法 final Method method = urlMethodMap.get(path); if (null != method) { //获取包名 final String packageName = methodPackageMap.get(method); //根据包名获取到Controller的名字 final String controllerName = nameMap.get(packageName); //根据controller的名字得到控制器 Object orderController = instanceMap.get(controllerName); try { method.setAccessible(true); method.invoke(orderController); } catch (IllegalAccessException e) { e.printStackTrace(); } catch (InvocationTargetException e) { e.printStackTrace(); } } }
四:总结
本篇博客主要是讲解了简易版SpringMvc的实现，其中主要包括了基本注解定义，还有springmv的具体处理模式，当然真实的springmvc实现很复杂，这里只是冰山一角的简单实现一个功能，不过举一反三，基本思路我们要思考，虽然没有搭建一个完成版springmvc的能力，不过从最简单的实现开始，一步步的走，对我们的编程能力有推波助澜的功效！加油
标签：xtend static autowire 简单 mem response 遍历 append pattern
原文地址：https://www.cnblogs.com/wyq178/p/9795640.html
