springMVC学习笔记手写springmvc
Posted 拐柒
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了springMVC学习笔记手写springmvc相关的知识，希望对你有一定的参考价值。
springMVC学习笔记（三）手写springmvc
手写springmvc
1、tomcat加载web.xml，配置了dispatchServlet，会加载指定的配置文件
2、包扫描，扫描注解，@Controller、@Service、@RequestMapping、@AutoWired
3、IOC容器就要进行相应的Bean初始化以及依赖注入，维护
4、springmvc相关组件的初始化，需要简历url和method之间的映射关系，handlermapping（处理器映射器）
5、等待请求进来，处理请求
手写LgDispatcherServlet
public class LgDispatcherServlet extends HttpServlet {
private Properties properties=new Properties();
private List<String> classNames=new ArrayList<>();//缓存扫描到的全限定类名
//IOC容器
private Map<String,Object> map=new HashMap<>();
//handlerMapping 存储url和method之间的映射关系
// private Map<String,Method> handlerMapping=new HashMap<>();
private List<Handler> handlerMapping=new ArrayList<>();
@Override
public void init(ServletConfig config) throws ServletException {
String contextConfigLocation = config.getInitParameter("contextConfigLocation");
//1、加载配置文件 springmvc.properties
doLoadConfig(contextConfigLocation);
//2、扫描相关类，扫描注解
doScan(properties.getProperty("scanPackage"));
//3、初始化bean对象（实现IOC容器，基于注解）
doInstance();
//4、实现依赖注入
doAutoWired();
//5、构造一个handlerMapping（处理器映射器），将配置好的url和method建立映射关系
initHandlerMapping();
System.out.println("mvc初始化完成");
//6、等待请求进入，处理请求
}
@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 {
//进行请求
//根据url找到对应的method，进行调用处理
// String requestURI = req.getRequestURI();
//获取到一个反射方法
// Method method = handlerMapping.get(requestURI);
//反射调用，需要传入对象和参数，此处无法完成调用，没有把对象存储起来，也没有参数，改造initHandlerMapping方法
// method.invoke()
//根据url获取到能够处理当前请求的handler，
Handler handler=getHandler(req);
if (handler==null){
resp.getWriter().write("404 not found");
return;
}
//参数绑定
//获取所有参数类型数组，数组的长度就是最后我们要传入args数组的长度
Class<?>[] parameterTypes = handler.getMethod().getParameterTypes();
//根据上述数组长度，创建一个新数组（参数数组，args，传入反射调用）
Object[] paraValues=new Object[parameterTypes.length];
//以下就是为了向参数数组中添加值，而且还要保证参数的顺序和方法中形参顺序一致
Map<String, String[]> parameterMap = req.getParameterMap();
//遍历req中所有参数（填充出了request、response之外的参数）
for (Map.Entry<String, String[]> param : parameterMap.entrySet()) {
//name=1&name=2 name=[1,2]
String value = StringUtils.join(param.getValue(), ",");//如同 1,2
//填充数据，如果参数和方法上的参数匹配上了
if(!handler.getParamIndexMapping().containsKey(param.getKey())){
continue;
}
//证明确实有该参数，找到他的索引位置，paraValues
Integer index = handler.getParamIndexMapping().get(param.getKey());
//把前段传递过来的值放到对应的形参中
paraValues[index]=value;
}
int requestIndex=handler.getParamIndexMapping().get(HttpServletRequest.class.getSimpleName());
paraValues[requestIndex]=req;
int responseIndex=handler.getParamIndexMapping().get(HttpServletResponse.class.getSimpleName());
paraValues[responseIndex]=resp;
//最终调用handler中的mehtod对象
try {
handler.getMethod().invoke(handler.getController(),paraValues);
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
}
}
加载配置文件
//加载配置文件
private void doLoadConfig(String contextConfigLocation) {
InputStream resourceAsStream = this.getClass().getClassLoader().getResourceAsStream(contextConfigLocation);
try {
properties.load(resourceAsStream);
} catch (IOException e) {
e.printStackTrace();
}
}
扫描注解
private void doScan(String scanPackage) {
String scanPackagePath = Thread.currentThread().
getContextClassLoader().
getResource("").
getPath() + scanPackage.
replaceAll("\\\\.", "/");
File pack=new File(scanPackagePath);
File[] files = pack.listFiles();
for (File file : files) {
if(file.isDirectory()){//子package
doScan(scanPackage+"."+file.getName());
}else if (file.getName().endsWith(".class")){
String className = scanPackage + "." + file.getName().replaceAll(".class","");
classNames.add(className);
}
}
}
初始化bean对象
private void doInstance() {
if(classNames.size()==0) return;
try {
for (int i=0;i<classNames.size();i++){
String className = classNames.get(i); //全限定类名
Class<?> aClass = Class.forName(className);
if(aClass.isAnnotationPresent(LagouController.class)){
//controller的id不做过多处理,就拿类的首字母小写，作为id，保存到容器中
String simpleName = aClass.getSimpleName();
String lowerFirstSimpleName = lowerFirst(simpleName);
Object o = aClass.newInstance();
map.put(lowerFirstSimpleName,o);
}else if(aClass.isAnnotationPresent(LagouService.class)){
LagouService annotation = aClass.getAnnotation(LagouService.class);
String beanName = annotation.value();
//如果指定id就以指定id为准
if ("".equals(beanName.trim())) {
beanName = lowerFirst(aClass.getSimpleName());
}
map.put(beanName,aClass.newInstance());
//service经常是面向接口开发的，此时，再以接口名为ID，放入一份对象到IOC容器中，便于后期根据接口注入
Class<?>[] interfaces = aClass.getInterfaces();
for (int j = 0; j < interfaces.length; j++) {
Class<?> anInterface = interfaces[j];
map.put(anInterface.getName(),aClass.newInstance());
}
}else {
continue;
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
//首字母小写
public String lowerFirst(String string){
char[] chars = string.toCharArray();
if('A'<= chars[0] && chars[0] <='Z'){
chars[0]+=32;
}
return String.valueOf(chars);
}
实现依赖注入
private void doAutoWired() {
if (map.isEmpty()) return;
//如果有对象，再进行依赖注入
//遍历ioc中所有对象，查看对象字段是否有@LagouAutoWried这个注解，如果有，需要维护依赖注入关系
for (Map.Entry<String, Object> entry : map.entrySet()) {
//获取bean对象中的字段
Field[] declaredFields = entry.getValue().getClass().getDeclaredFields();
//遍历字段数组
for (Field declaredField : declaredFields) {
boolean annotationPresent = declaredField.isAnnotationPresent(LagouAutoWried.class);
if(!annotationPresent){
continue;
}
LagouAutoWried annotation = declaredField.getAnnotation(LagouAutoWried.class);
//需要注入的bean的id
String beanName = annotation.value();
if("".equals(beanName.trim())){
//没有配置配置具体的id，那就需要根据当前字段类型注入（接口注入）
beanName = declaredField.getType().getName();
}
//开启赋值
declaredField.setAccessible(true);
try {
declaredField.set(entry.getValue(),map.get(beanName));
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}
}
}
构造一个handlerMapping
手写mvc框架关键环节，将url和method进行关联
private void initHandlerMapping() {
if (map.isEmpty()) return;
for (Map.Entry<String, Object> entry : map.entrySet()) {
//获取ioc容器中当前遍历的class类型
Class<?> aClass = entry.getValue().getClass();
if(!aClass.isAnnotationPresent(LagouController.class)){
continue;
}
String baseUrl="";
if (aClass.isAnnotationPresent(LagouRequestMapping.class)){
baseUrl=aClass.getAnnotation(LagouRequestMapping.class).value();
}
//获取方法
Method[] methods = aClass.getMethods();
for (int i = 0; i < methods.length; i++) {
Method method = methods[i];
if(!method.isAnnotationPresent(LagouRequestMapping.class)){
continue;
}
String methodUrl=method.getAnnotation(LagouRequestMapping.class).value();
String url=baseUrl+methodUrl;
//把method所有信息封装成一个handler
Object value = entry.getValue();
Handler handler=new Handler(value,method, Pattern.compile(url));
//处理方法的计算参数位置信息 //query(HttpServletRequest request, HttpServletResponse response,String name)
TypeVariable<Method>[] typeParameters = method.getTypeParameters();
Parameter[] parameters = method.getParameters();
for (int j = 0; j < parameters.length; j++) {
Parameter parameter = parameters[j];
if(parameter.getType()==HttpServletRequest.class||parameter.getType()==HttpServletResponse.class){
//如果是HttpServletRequest和HttpServletResponse对象，那么参数名称为HttpServletRequest,HttpServletResponse
handler.getParamIndexMapping().put(parameter.getType().getSimpleName(),j);
}else {
handler.getParamIndexMapping().put(parameter.getName(),j);
}
}
//建立url和method之间的映射(使用map缓存起来)
handlerMapping.add(handler);
}
}
}
Handler类
public class Handler {
private Object controller;//method.invoke中的obj
private Method method;//需要调用的方法
private Pattern pattern;//spring中url是支持正则的
private Map<String,Integer> paramIndexMapping;//参数顺序，是为了进行参数绑定，key是参数名，Integer是代表第几个参数，例如<name,2>
public Handler(Object controller, Method method, Pattern pattern) {
this.controller = controller;
this.method = method;
this.pattern = pattern;
this.paramIndexMapping = new HashMap<>();
}
public Object getController() {
return controller;
}
public void setController(Object controller) {
this.controller = controller;
}
public Method getMethod() {
return method;
}
public void setMethod(Method method) {
this.method = method;
}
public Pattern getPattern() {
return pattern;
}
public void setPattern(Pattern pattern) {
this.pattern = pattern;
}
public Map<String, Integer> getParamIndexMapping() {
return paramIndexMapping;
}
public void setParamIndexMapping(Map<String, Integer> paramIndexMapping) {
this.paramIndexMapping = paramIndexMapping;
}
}
以上是关于springMVC学习笔记手写springmvc的主要内容，如果未能解决你的问题，请参考以下文章