创建一个属于自己的MVC框架

最新推荐文章于 2024-07-14 11:32:09 发布

(“p”)

最新推荐文章于 2024-07-14 11:32:09 发布

阅读量621

点赞数

文章标签： mvc java

本文链接：https://blog.csdn.net/m0_51046603/article/details/126493953

版权

一、基础知识

在搭建框架前，我们先来了解什么是MVC以及MVC框架：

MVC的全称是：model（模型）、view（视图）、controller（控制器）
MVC是一种设计模式，能对具体的问题提出解决方案以提高代码的复用率，降低耦合度。
MVC框架是一种被广泛应用的主流框架，使用MVC的目的是将M和V的实现代码分离，从而使同一个程序可以使用不同的表现形式。

Java注解以及Annotation：

Annotation是Java注解（又称Java标注），是JDK5.0引入的一种注释机制；Java定义了一套机制，一共有7个，3个在java.lang中，4个在java.lang.annotation中。

@Override - 检查该方法是否是重写方法。如果发现其父类，或者是引用的接口中并没有该方法时，会报编译错误。
@Deprecated - 标记过时方法。如果使用该方法，会报编译警告。
@SuppressWarnings - 指示编译器去忽略注解中声明的警告。
作用在其他注解的注解(或者说元注解)是:
@Retention - 标识这个注解怎么保存，是只在代码中，还是编入class文件中，或者是在运行时可以通过反射访问。
@Documented - 标记这些注解是否包含在用户文档中。
@Target - 标记这个注解应该是哪种 Java 成员。
@Inherited - 标记这个注解是继承于哪个注解类(默认注解并没有继承于任何子类)

从 Java 7 开始，额外添加了 3 个注解:
@SafeVarargs - Java 7 开始支持，忽略任何使用参数为泛型变量的方法或构造函数调用产生的警告。
@FunctionalInterface - Java 8 开始支持，标识一个匿名函数或函数式接口。
@Repeatable - Java 8 开始支持，标识某注解可以在同一个声明上使用多次。

二、开始自定义框架

在Java中，如果想要自定义，可以通过以下的语法：

@Target(ElementType.xxxx)
@Retention(RetentionPolicy.xxxx)
public @interface 注解名 {
}

其中，@Target对应的是当前的注解能够定义在哪个位置

比如：
ElementType.Type – 类
ElementType.Field --字段
ElementType.Method --方法
Retention:在什么场景下能够起作用。
RetentionPolicy.CLASS - 定义类
RetentionPolicy.SOURCE - 编写代码
RetentionPolicy.RUNTIME --运行时

根据当前的需求，我们在package底下的annotation类中定义两个Annotation:
第一个：Controller.java

package com.csi.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Controller {
}

第二个：RequestMapping.java

package com.csi.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface RequestMapping {
	String value() default "" ;//定义默认值为空
}

解析Annotation，创建一个扫描包的工具类

package com.csi.utils;

import java.io.File;
import java.io.FileFilter;
import java.net.URL;
import java.net.URLDecoder;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.List;
/**
 * 找到某个包下的所有的以.class结尾的java文件
 */
public class ClassScanner {

    /**
     * 获得包下面的所有的class
     * @param
     * @return List包含所有class的实例
     */

    public static List<Class<?>> getClasssFromPackage(String packageName) {
        List<Class<?>> clazzs = new ArrayList<>();
        // 是否循环搜索子包
        boolean recursive = true;
        // 包名对应的路径名称
        String packageDirName = packageName.replace('.', '/');
        Enumeration<URL> dirs;

        try {

            //从当前正在运行的线程中，加载类加载器，通过给定的包名，找到所有该包下的类
            dirs = Thread.currentThread().getContextClassLoader().getResources(packageDirName);
            while (dirs.hasMoreElements()) {

                URL url = dirs.nextElement();
                String protocol = url.getProtocol();
                if ("file".equals(protocol)) {
                    String filePath = URLDecoder.decode(url.getFile(), "UTF-8");
                    findClassInPackageByFile(packageName, filePath, recursive, clazzs);
                }
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
        return clazzs;
    }

    /**
     * 在package对应的路径下找到所有的class
     */
    public static void findClassInPackageByFile(String packageName, String filePath, final boolean recursive,
                                                List<Class<?>> clazzs) {
        File dir = new File(filePath);
        if (!dir.exists() || !dir.isDirectory()) {
            return;
        }
        // 在给定的目录下找到所有的文件，并且进行条件过滤
        File[] dirFiles = dir.listFiles(new FileFilter() {

            public boolean accept(File file) {
                boolean acceptDir = recursive && file.isDirectory();// 接受dir目录
                boolean acceptClass = file.getName().endsWith("class");// 接受class文件
                return acceptDir || acceptClass;
            }
        });

        for (File file : dirFiles) {
            if (file.isDirectory()) {
                findClassInPackageByFile(packageName + "." + file.getName(), file.getAbsolutePath(), recursive, clazzs);
            } else {
                String className = file.getName().substring(0, file.getName().length() - 6);
                try {
                    clazzs.add(Thread.currentThread().getContextClassLoader().loadClass(packageName + "." + className));
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

创建WebApplicationContext.java

package com.csi.listener;

import java.lang.reflect.Method;
import java.util.concurrent.ConcurrentHashMap;

public class WebApplicationContext {
    public static ConcurrentHashMap<String, Method> methodMap = new ConcurrentHashMap<>() ;//属性字段（static：静态共享）
}

创建监听器ClassLoaderContextListener.java

package com.csi.listener;

import com.csi.annotation.Controller;
import com.csi.annotation.RequestMapping;
import com.csi.utils.ClassScanner;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
import java.lang.reflect.Method;
import java.util.List;

public class ClassLoaderContextListener implements ServletContextListener {
    @Override
    public void contextInitialized(ServletContextEvent sce) {
        initClassLoader();
    }

    private void initClassLoader() {
        //根据包找到包下面所有类
        List<Class<?>> classList = ClassScanner.getClasssFromPackage("com.csi.controller");

        for (Class<?> clazz : classList) {
            //如果当前类上存在Controller，就要获取方法
            //A.isAnnotationPresent(B.class):B类型的注解是否在A上->Controller的注解是否在clazz上,在则返回true
            if (clazz.isAnnotationPresent(Controller.class)){

                Method[] methods = clazz.getMethods();//获取方法

                //遍历当前包含了Controller注解的所有方法
                for (Method method : methods) {

                    //判断方法上是否添加了RequestMapping注解
                    if(method.isAnnotationPresent(RequestMapping.class)){
                        //在的话获取到包含RequestMapping注解的value值
                        String urlPath = method.getAnnotation(RequestMapping.class).value();

                        //将值作为键，将方法作为值，存储在map集合中
                        WebApplicationContext.methodMap.put(urlPath,method);
                    }
                }
            }
        }
    }
}

解析用户的请求路径，创建DispatcherServlet.java

package com.csi.servlet;

import com.csi.listener.WebApplicationContext;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class DispatcherServlet extends HttpServlet {

    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

        //步骤一：获取到用户请求的URL
        String urlPath = req.getServletPath();

        Method method = WebApplicationContext.methodMap.get(urlPath);

        if (method != null){
            //步骤二：调用对应的Method方法
            Object instance = null ;
            try {
                //如何找到要对应的类
                //.getDeclaringClass():获取此类的声明类 .newInstance()：创建新的类
                instance = method.getDeclaringClass().newInstance();

            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }

            try {
                //如何传输参数，request,response
                //调用invoke方法来调用
                method.invoke(instance,req,resp);//invoke：调用我们提供的方法以及调用的方法的参数来完成动态调用
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            }

        }else{
            resp.sendRedirect("failure.jsp");
        }
    }
}

三、使用

在此框架内使用：

如果直接使用框架（在写好的框架里写代码），需要在此工程底下建立com.csi.controller的包
在controller包中新建类，在此类上添加@Controller注解
建立类中的方法，并在适当的方法上添加@RequestMapping注解
在@RequestMapping注解中添加url地址

package com.csi.controller;

import com.alibaba.fastjson.JSON;
import com.csi.annotation.Controller;
import com.csi.annotation.RequestMapping;
import com.csi.domain.Product;
import com.csi.domain.Result;
import com.csi.service.ProductService;
import com.csi.service.impl.ProductServiceImpl;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.List;

@Controller
public class ProductController {
	@RequestMapping("/product/toshowpage.do")
	public void to_show_page(HttpServletRequest request,HttpServletResponse response) throws ServletException,IOException {
		request.setAttribute("hello","world");
		request.getRequestDispatcher("/show.jsp").forward(request,response);
	}
	
	@RequestMapping("/product/list.do")
	public void list(HttpServletRequest request,HttpServletResponse response)throws IOException {
		response.setContentType("application/json;charset=utf-8");
		int categoryId = Integer.parseInt(request.getParameter("categoryId")) ;
		ProductService productService = new ProductServiceImpl() ;
		List<Product> products = productService.listByCategory4Index(categoryId);
		Result result = new Result() ;
		if(products.size() != 0) {
			result.setMsg("success");
			result.setCode(200);
			result.setData(products);
		}else{
			result.setCode(400);
			result.setMsg("数据为空!");
		}
		String jsonStr = JSON.toJSONString(result) ;
		PrintWriter out = response.getWriter() ;
		out.println(jsonStr);
	}
}

jsp页面：

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
    <head>
        <title>Title</title>
        <script src="http://libs.baidu.com/jquery/1.11.3/jquery.min.js"></script>
        <script type="text/javascript">
            $(function() {
                $.get("/product/list.do?categoryId = 548 ",function(data) {
                    if (data.code == 200) {
                        $(data.data).each(function(i, o) {
                            var divTag = "<div class = 'product_info' > <img src = '" + o.fileName + "' ></img><p>" + o.name + "</p><p> ￥" + o.price + " </p> </div>" ;
                            $("#data_show").append(divTag);
                        });
                    }else{
                        $("#data_show").html(data.msg);
                    }
                });
            })
        </script>
        <style type="text/css">
            .product_info {
                border: 1px solid #c2e0d9;
                float: left;
                width: 200px;
            }
        </style>
    </head>
    <body>
        <div id="data_show">
        </div>
    </body>
</html>

三、其他

最后，附上几个上文中用到的方法

A.isAnnotationPresent(B.class)：A类中是否存在B类型的注释。是就返回true，不是返回false。
getDeclaringClass()：获取类的声明类。
newInstance()：通过反射创建新的类。调用无参的构造函数（默认的），如果没有则会跑出一个异常。
invoke()：有调用的意思，就是说我们可以通过反射包下的Method类调用invoke方法，调用我们提供的方法以及调用方法的参数来完成动态调用。

(“p”)

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
创建一个属于自己的MVC框架

Target(ElementType . xxxx) @Retention(RetentionPolicy . xxxx) public @interface 注解名 {}其中，@Target对应的是当前的注解能够定义在哪个位置
复制链接

扫一扫