手动实现一个简易版SpringMvc
版权声明:本篇博客大部分代码引用于公众号: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的能力,不过从最简单的实现开始,一步步的走,对我们的编程能力有推波助澜的功效!加油
手动实现一个简易版SpringMvc的更多相关文章
- 【react】---手动封装一个简易版的redux
export let createStore = (reducer)=>{ //定义默认的state let state; //定义默认的action let actionTypes = &qu ...
- 【react】---手动封装一个简易版的redux---【巷子】
export let createStore = (reducer)=>{ //定义默认的state let state = {}; //定义默认的action let actionTypes ...
- .NET Core的文件系统[5]:扩展文件系统构建一个简易版“云盘”
FileProvider构建了一个抽象文件系统,作为它的两个具体实现,PhysicalFileProvider和EmbeddedFileProvider则分别为我们构建了一个物理文件系统和程序集内嵌文 ...
- 依赖注入[5]: 创建一个简易版的DI框架[下篇]
为了让读者朋友们能够对.NET Core DI框架的实现原理具有一个深刻而认识,我们采用与之类似的设计构架了一个名为Cat的DI框架.在<依赖注入[4]: 创建一个简易版的DI框架[上篇]> ...
- 依赖注入[4]: 创建一个简易版的DI框架[上篇]
本系列文章旨在剖析.NET Core的依赖注入框架的实现原理,到目前为止我们通过三篇文章(<控制反转>.<基于IoC的设计模式>和< 依赖注入模式>)从纯理论的角度 ...
- .NET CORE学习笔记系列(2)——依赖注入[4]: 创建一个简易版的DI框架[上篇]
原文https://www.cnblogs.com/artech/p/net-core-di-04.html 本系列文章旨在剖析.NET Core的依赖注入框架的实现原理,到目前为止我们通过三篇文章从 ...
- 如何实现一个简易版的 Spring - 如何实现 Setter 注入
前言 之前在 上篇 提到过会实现一个简易版的 IoC 和 AOP,今天它终于来了...相信对于使用 Java 开发语言的朋友们都使用过或者听说过 Spring 这个开发框架,绝大部分的企业级开发中都离 ...
- 如何实现一个简易版的 Spring - 如何实现 Constructor 注入
前言 本文是「如何实现一个简易版的 Spring」系列的第二篇,在 第一篇 介绍了如何实现一个基于 XML 的简单 Setter 注入,这篇来看看要如何去实现一个简单的 Constructor 注入功 ...
- 如何实现一个简易版的 Spring - 如何实现 @Component 注解
前言 前面两篇文章(如何实现一个简易版的 Spring - 如何实现 Setter 注入.如何实现一个简易版的 Spring - 如何实现 Constructor 注入)介绍的都是基于 XML 配置文 ...
随机推荐
- spark提交任务的两种的方法
在学习Spark过程中,资料中介绍的提交Spark Job的方式主要有两种(我所知道的): 第一种: 通过命令行的方式提交Job,使用spark 自带的spark-submit工具提交,官网和大多数参 ...
- Mount qcow2 image
1.Mount a qcow2 image qemu-nbd - QEMU Disk Network Block Device Server: Export QEMU disk image using ...
- Halcon图像采集助手提示找不到指定DLL文件
问题原因: Halcon软件更新导致某些图像采集DLL失效,这个时候就需要去MVTEC官网下载图像采集接口补丁程序,MVTEC官网地址http://www.mvtec.com/. 对于其他模块失效的D ...
- Struts2中Action各种转发类型
Struts2:Action中result的各种转发类型: 内部请求转发dispatcher(默认值) redirect.redirectAction.plainText1.redirect是重定向到 ...
- Easy Summation
Description You are encountered with a traditional problem concerning the sums of powers. Given two ...
- 第三周的psp
PSP: 进度条: 累计进度图: 本周PSP饼状图:
- wf效能分析
听从了老师的建议我请教了其他的同学,修改了代码实现了功能四,以下是我的效能测试: 1.采用ptime.exe测试的3次截图 可以看到的是三次执行时间分别为:1.449秒:0.915秒:0.871秒,取 ...
- POJ 1995 (快速幂)
这道题普通做法会发生溢出且会超时,应当用快速幂来求解. 快速幂讲解 #include <cstdio> #include <cmath> using namespace std ...
- 【IdentityServer4文档】- 打包和构建
打包和构建 IdentityServer 由多个 nuget 软件包组成的. IdentityServer4 nuget | github 包含 IdentityServer 核心对象模型,服务和中间 ...
- PokeCats开发者日志(十四)——终章
已经不知道离PokeCats游戏开始开发有多少个晚上了,今晚心血来潮整理随笔的时候发现这个故事还没有划上句号. 故事的结局是最终我拿到了软著权,但是没办法上架到任何一个知名的安卓app市场,连 ...