纯手写SpringMVC框架，用注解实现springmvc过程
2019-03-13 15:29
771 查看
闲话不多说，直接上代码！
1、第一步，首先搭建如下架构，其中，annotation中放置自己编写的注解，主要包括service controller qualifier RequestMapping
第二步：完成对应的annotation:
-
package com.chaoyue.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; /** * Controller注解 * @author 超越 * @Date 2016年11月29日,上午10:37:30 * @motto 人在一起叫聚会，心在一起叫团队 * @Version 1.0 */ @Target({ ElementType.TYPE }) @Retention(RetentionPolicy.RUNTIME) @Documented public @interface Controller { String value() default ""; } package com.chaoyue.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; /** * Quatifier注解 * @author 超越 * @Date 2016年11月29日,上午10:47:52 * @motto 人在一起叫聚会，心在一起叫团队 * @Version 1.0 */ @Target({ ElementType.FIELD }) // 代表注解的注解 @Retention(RetentionPolicy.RUNTIME) @Documented public @interface Quatifier { String value() default ""; } package com.chaoyue.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; /** * RequestMapping注解 * @author 超越 * @Date 2016年11月29日,上午10:39:32 * @motto 人在一起叫聚会，心在一起叫团队 * @Version 1.0 */ @Target({ ElementType.METHOD }) // 在方法上的注解 @Retention(RetentionPolicy.RUNTIME) @Documented public @interface RequestMapping { String value() default ""; }
-
package com.chaoyue.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; /** * 注解Service * @author 超越 * @Date 2016年11月29日,上午10:49:47 * @motto 人在一起叫聚会，心在一起叫团队 * @Version 1.0 */ @Target({ ElementType.TYPE }) @Retention(RetentionPolicy.RUNTIME) @Documented public @interface Service { String value() default ""; }
2、第二步：编写对应的servlet类，记得勾选init()方法，用来进行相应的实例化和注解反转控制。
① 进行包扫描，就是初始化的时候先将整个项目中的包进行扫描，扫描各个文件分别存起来。
scanPackage("com.chaoyue");//自己的项目，测试用的 所以 扫描包函数的地址写死了
存在List<String> packageNames=new ArrayList<String>();其中都是这样：com.chaoyue.annotation.Controller.class，com.chaoyue.annotation.Quatifier.class, com.chaoyue.annotation.RequestMapping.class，有.class后缀。
②过滤和实例化 ：由于已经将所有的文件都存在了packageNames中了，那么我们必须将对应的Controller实例化才可以进行相应函数调用，然后其中的所有文件并不一定都是对应的controller文件，所以要进行相应的过滤和处理
filterAndInstance();
过滤后的结果保存在： Map<String,Object> instanceMap=new HashMap<String,Object>();
其中 String是注解的value, Object是所对应类的实例
③建立一个映射关系（地址映射，不同的地址映射到不同的方法）：
handerMap();
结果： Map<String,Object> handerMap=new HashMap<String,Object>();
实例：
④ 反转控制，根据注解，把service中的注入到controller中的service;
欢迎留言讨论，带着谦虚的心一起学习！也可以进我私人群一起交流学习！
void ioc()
package com.chaoyue.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.HashMap;
import java.util.List;
import java.util.Map;
import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import com.chaoyue.annotation.Controller;
import com.chaoyue.annotation.Quatifier;
import com.chaoyue.annotation.RequestMapping;
import com.chaoyue.annotation.Service;
import com.chaoyue.controller.SpringmvcController;
@WebServlet("/DispatcherServlet")
public class DispatcherServlet extends HttpServlet {
private static final long serialVersionUID = 1L;
List<String> packageNames = new ArrayList<String>();
// 所有类的实例，key是注解的value,value是所有类的实例
Map<String, Object> instanceMap = new HashMap<String, Object>();
Map<String, Object> handerMap = new HashMap<String, Object>();
public DispatcherServlet() {
super();
}
public void init(ServletConfig config) throws ServletException {
// 包扫描,获取包中的文件
scanPackage("com.chaoyue");
try {
filterAndInstance();
} catch (Exception e) {
e.printStackTrace();
}
// 建立映射关系
handerMap();
// 实现注入
ioc();
}
private void filterAndInstance() throws Exception {
if (packageNames.size() <= 0) {
return;
}
for (String className : packageNames) {
Class<?> cName = Class.forName(className.replace(".class", "").trim());
if (cName.isAnnotationPresent(Controller.class)) {
Object instance = cName.newInstance();
Controller controller = (Controller) cName.getAnnotation(Controller.class);
String key = controller.value();
instanceMap.put(key, instance);
} else if (cName.isAnnotationPresent(Service.class)) {
Object instance = cName.newInstance();
Service service = (Service) cName.getAnnotation(Service.class);
String key = service.value();
instanceMap.put(key, instance);
} else {
continue;
}
}
}
private void ioc() {
if (instanceMap.isEmpty())
return;
for (Map.Entry<String, Object> entry : instanceMap.entrySet()) {
// 拿到里面的所有属性
Field fields[] = entry.getValue().getClass().getDeclaredFields();
for (Field field : fields) {
field.setAccessible(true);// 可访问私有属性
if (field.isAnnotationPresent(Quatifier.class));
Quatifier quatifier = field.getAnnotation(Quatifier.class);
String value = quatifier.value();
field.setAccessible(true);
try {
field.set(entry.getValue(), instanceMap.get(value));
} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}
}
}
/**
* 扫描包下的所有文件
*
* @param Package
*/
private void scanPackage(String Package) {
URL url = this.getClass().getClassLoader().getResource("/" + replaceTo(Package));// 将所有的.转义获取对应的路径
String pathFile = url.getFile();
File file = new File(pathFile);
String fileList[] = file.list();
for (String path : fileList) {
File eachFile = new File(pathFile + path);
if (eachFile.isDirectory()) {
scanPackage(Package + eachFile.getName());
} else {
packageNames.add(Package + "." + eachFile.getName());
}
}
}
/**
* 建立映射关系
*/
private void handerMap() {
if (instanceMap.size() <= 0)
return;
for (Map.Entry<String, Object> entry : instanceMap.entrySet()) {
if (entry.getValue().getClass().isAnnotationPresent(Controller.class)) {
Controller controller = (Controller) entry.getValue().getClass().getAnnotation(Controller.class);
String ctvalue = controller.value();
Method[] methods = entry.getValue().getClass().getMethods();
for (Method method : methods) {
if (method.isAnnotationPresent(RequestMapping.class)) {
RequestMapping rm = (RequestMapping) method.getAnnotation(RequestMapping.class);
String rmvalue = rm.value();
handerMap.put("/" + ctvalue + "/" + rmvalue, method);
} else {
continue;
}
}
} else {
continue;
}
}
}
private String replaceTo(String path) {
return path.replaceAll("\\.", "/");
}
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
this.doGet(req, resp);
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
String url = req.getRequestURI();
String context = req.getContextPath();
String path = url.replace(context, "");
Method method = (Method) handerMap.get(path);
SpringmvcController controller = (SpringmvcController) instanceMap.get(path.split("/")[1]);
try {
method.invoke(controller, new Object[] { req, resp, null });
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
}
}
package com.chaoyue.controller;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import com.chaoyue.annotation.Controller;
import com.chaoyue.annotation.Quatifier;
import com.chaoyue.annotation.RequestMapping;
import com.chaoyue.service.impl.MyService;
import com.chaoyue.service.impl.SpringmvcServiceImpl;
@Controller("chaoyue")
public class SpringmvcController {
@Quatifier("MyServiceImpl")
MyService myService;
@Quatifier("SpringmvcServiceImpl")
SpringmvcServiceImpl smService;
@RequestMapping("insert")
public String insert(HttpServletRequest request, HttpServletResponse response, String param) {
myService.insert(null);
smService.insert(null);
return null;
}
@RequestMapping("delete")
public String delete(HttpServletRequest request, HttpServletResponse response, String param) {
myService.delete(null);
smService.delete(null);
return null;
}
@RequestMapping("update")
public String update(HttpServletRequest request, HttpServletResponse response, String param) {
myService.update(null);
smService.update(null);
return null;
}
@RequestMapping("select")
public String select(HttpServletRequest request, HttpServletResponse response, String param) {
myService.select(null);
smService.select(null);
return null;
}
}
package com.chaoyue.service.impl;
import java.util.Map;
public interface MyService {
int insert(Map map);
int delete(Map map);
int update(Map map);
int select(Map map);
}
package com.chaoyue.service.impl;
import java.util.Map;
import com.chaoyue.annotation.Service;
@Service("MyServiceImpl")
public class MyServiceImpl implements MyService {
@Override
public int insert(Map map) {
System.out.println("MyServiceImpl:" + "insert");
return 0;
}
@Override
public int delete(Map map) {
System.out.println("MyServiceImpl:" + "delete");
return 0;
}
@Override
public int update(Map map) {
System.out.println("MyServiceImpl:" + "update");
return 0;
}
@Override
public int select(Map map) {
System.out.println("MyServiceImpl:" + "select");
return 0;
}
}
package com.chaoyue.service.impl;
import java.util.Map;
public interface SpringmvcService {
int insert(Map map);
int delete(Map map);
int update(Map map);
int select(Map map);
}
package com.chaoyue.service.impl;
import java.util.Map;
public class SpringmvcServiceImpl implements SpringmvcService {
@Override
public int insert(Map map) {
System.out.println("SpringmvcServiceImpl:" + "insert");
return 0;
}
@Override
public int delete(Map map) {
System.out.println("SpringmvcServiceImpl:" + "delete");
return 0;
}
@Override
public int update(Map map) {
System.out.println("SpringmvcServiceImpl:" + "update");
return 0;
}
@Override
public int select(Map map) {
System.out.println("SpringmvcServiceImpl:" + "select");
return 0;
}
}
欢迎留言讨论，带着谦虚的心一起学习！也可以进我私人群一起交流学习
欢迎加入QQ群架构华山论剑：836442475【点击进入】（大牛聚集地）一起交流学习探讨！
我们提供免费的架构资料 以及免费的解答
不懂得问题都可以来问我们老师，之后还会有职业生涯规划，以及面试指导
我们每天晚上八点也有公开课免费学习：
10年架构师分享经验，Dubbo、Redis、Netty、zookeeper、Spring cloud、分布式、高并发等架构技术
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- 纯手写SpringMVC框架，用注解实现springmvc过程
- 纯手写SpringMVC框架，用注解实现springmvc过程
- 纯手写SpringMVC架构，用注解实现springmvc过程
- 纯手写SpringMVC架构，用注解实现springmvc过程（动脑学院Jack老师课后自己练习的体会）
- SpringMVC验证框架Validation自定义注解实现传递参数到国际化资源文件
- 2 手写实现SpringMVC，第二节：自定义注解及反射赋值
- 源码分析之动手实现手写一个自己的SpringMVC框架（三）
- SpringMVC验证框架Validation自定义注解实现传递参数到国际化资源文件
- 如何在SpringMVC框架中利用Java反射机制和Javassist实现Java对象、属性、注解的动态创建生成
- Maven构建SpringMVC项目实现注解、数据库事务管理及存储过程操作
- SpringMVC验证框架Validation自定义注解实现传递参数到国际化资源文件
- JavaEE之--------SpringMVC框架的搭建（注解实现）
- SpringMVC框架搭建步骤以及注解功能实现
- 深度解析SpringMvc实现原理手写SpringMvc框架
- 自己手写一个SpringMVC框架
- 深度学习-传统神经网络使用TensorFlow框架实现MNIST手写数字识别
- 1.1XAF框架开发视频教程-简单的订单管理实现过程,视频,提纲,及教程源码
- C#实现插件框架--过程
- springmvc 动态代理 JDK实现与模拟JDK纯手写实现。
- SSM框架——以注解形式实现事务管理