手动实现一个简易版SpringMvc

Java框架

浏览数:133

2019-9-3

AD:资源代下载服务

版权声明:本篇博客大部分代码引用于公众号: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的能力,不过从最简单的实现开始,一步步的走,对我们的编程能力有推波助澜的功效!加油

作者:Yrion