纯手写SpringMVC框架，用注解实现springmvc过程

最新推荐文章于 2022-01-07 18:08:31 发布
奋斗成就男人
最新推荐文章于 2022-01-07 18:08:31 发布
阅读量128
点赞数
分类专栏： SSM/SSH 文章标签： springmvc
原文链接：https://blog.csdn.net/chaoyueygw/article/details/53393952
版权
SSM/SSH 专栏收录该内容
38 篇文章 0 订阅
订阅专栏
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;
	}
 
}