MVC(Model-View-Controller,模型-视图-控制器)是一种常见的设计模式,可以使用这个模式将应用程序进行解耦。
上一章我们使用Servlet来充当MVC模式中的Controller。这样做虽然可以实现基本功能,但Servlet的数量会随着业务功能的拓展而不断增加。因此有必要减少Servlet的数量,将某类业务交给Controller来处理,它负责调用Service的相关方法,并将返回值放入Request或Response中。此外,Service不是通过new 的方式来创建的,而是通过一种名为“依赖注入”的方式,让框架为我们来创建所需要的对象。
目的:
1.快速搭建开发框架
2.加载并读取配置文件
3.实现一个简单的IOC的容器
4.加载指定的类
5.初始化框架
确定目标
打造一个轻量级MVC框架,而Controller是MVC的核心。我们想要的是如下代码:
@Controller public class CustomerController { @Inject private CustomerService customerService; /** * 进入客户端界面 */ @Action("get:/customer") public View index(){ List<Customer> customerList = customerService.getCustomerList(); return new View("customer.jsp").addModel("customerList",customerList); } /** * 显示客户基本信息 */ @Action("get:/customer_show") public View show(Param param){ long id = param.getLong(id); Customer customer = customerService.getCustomer(id); return new View("customer_show.jsp").addModel("customer",customer); } /** * 删除客户信息 * @param param * @return */ @Action("delete:/customer_edit") public Data delete(Param param){ long id = param.getLong(id); boolean result = customerService.deleteCustomer(id); return new Data(result); } }
通过Controller注解来定义Controller类,在该类中,可通过Inject注解定义一系列Service成员变量,这就是“依赖注入”。此外,有一系列被Action注解所定义的方法(简称Action方法),在这些Action方法中,调用了Service成员变量的方法来完成具体的业务和逻辑。若返回View对象,则表示JSP页面;若返回Data对象,则表示一个JSON数据。
Controller代码非常清晰,一个Controller类包含了多个Action方法,可返回View或Data对象,分别对应JSP页面或JSON数据。
提示:在普通请求的情况下,可返回JSP页面;在Ajax请求的情况下,需要返回JSON数据。
创建框架项目
创建一个名为smart-framework的项目,它是一个普通的java项目,在pom.xml中需要添加Maven三坐标:
<groupId>org.smart4j</groupId> <artifactId>smart-framework</artifactId> <version>1.0.0</version>
因为该框架是Java Web框架,所以一定会依赖Servlet、JSP、JSTL。
<!--servlet--> <dependency> <groupId>javax.servlet</groupId> <artifactId>javax.servlet-api</artifactId> <version>3.1.0</version> <scope>provided</scope> </dependency> <!--jsp--> <dependency> <groupId>javax.servlet.jsp</groupId> <artifactId>jsp-api</artifactId> <version>2.2</version> <scope>provided</scope> </dependency> <!--jstl--> <dependency> <groupId>javax.servlet</groupId> <artifactId>jstl</artifactId> <version>1.2</version> <scope>runtime</scope> </dependency>
在框架中会大量使用日志输出,最流行的日志框架就是Log4j了,但它只是日志的一种具体实现,如果将来需要使用其他更好的日志框架,那么代码中所有日志输出的地方都要修改。为了解决这个问题,我们使用一个名为SLF4J的日志框架,它实际上是日志框架的接口,而Log4J只是日志框架的一种实现而已。只需要添加以下依赖,就能同时引入SLF4J和Log4J两个依赖。
<dependency> <groupId>org.slf4j</groupId> <artifactId>slf4j-log4j12</artifactId> <version>1.7.25</version> </dependency>
mysql驱动
<!--mysql--> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>5.1.33</version> </dependency>
由于在Controller的Action方法返回值中是可以返回json数据的,因此需要选择一款JSON序列化工具,目前在功能、性能、稳定性各方面表现好的JSON序列化工具就是Jackson了。
<!--Jackson--> <dependency> <groupId>com.fasterxml.jackson.core</groupId> <artifactId>jackson-databind</artifactId> <version>2.4.4</version> </dependency>
常用的Apache Commons工具类
<!--常用的两个Apache Commons工具类--> <!--Apache Commons Lang--> <dependency> <groupId>org.apache.commons</groupId> <artifactId>commons-lang3</artifactId> <version>3.3.2</version> </dependency> <!--Apache Commons Collections--> <dependency> <groupId>org.apache.commons</groupId> <artifactId>commons-collections4</artifactId> <version>4.0</version> </dependency>
对于JDBC,我们选择了轻量级的DbUtils,它也是Apache Commons的项目之一。
<!--Apache Commons DbUtils-->
<dependency>
<groupId>commons-dbutils</groupId>
<artifactId>commons-dbutils</artifactId>
<version>1.6</version>
</dependency>
在框架中需要用到数据库连接池,我们选择了总和能力强的连接池框架DBCP,同样是Apache Commons项目之一。
<!--Apache DBCP连接池--> <dependency> <groupId>org.apache.commons</groupId> <artifactId>commons-dbcp2</artifactId> <version>2.0.1</version> </dependency>
除了smart-framework这个项目外,我们有必要再创建一个使用该框架的项目,名为chapter3,chapter3是一个java web项目,只需要依赖于smart-framework即可,详细的pom.xml如下
<!--Smart Framework--> <dependency> <groupId>org.smart4j</groupId> <artificatId>smart-framework</artifactId> <version>1.0.0</version> </dependency>
定义框架配置项
在chapter3项目的src/main/resources目录下,创建一个名为smart.properties的文件,内容如下
smart.framework.jdbc.driver=com.mysql.jdbc.Driver smart.framework.jdbc.url=jdbc:mysql://localhost:3306/demo smart.framework.jdbc.username=root smart.framework.jdbc.password=root smart.framework.app.base_package=org.smart4j.chapter3 --扫描包 smart.framework.app.jsp_path=/WEB-INF/view/ --视图所在路径 smart.framework.app.asset_path=/asset/ --静态资源
在chapter3中添加引用
<dependency> <groupId>org.smart4j</groupId> <artifactId>smart-framework</artifactId> <version>1.0.0</version> </dependency>
加载配置项
配置文件已经有了,下面要根据配置项的名称获取配置项的取值,只是框架需要做的事。我们在smart-framework项目中创建一个名为ConfigHelper的助手类,让它来读取smart.properties配置文件。
首先,创建一个名为ConfigConstant的常量类,用来维护配置文件中相关的配置项名称。
package org.smart4j.framework.helper; /** * @program: ConfigConstant * @description: 相變量配置 **/ public interface ConfigConstant { String CONFIG_FILE = "smart.properties"; String JDBC_DRIVER = "smart.framework.jdbc.driver"; String JDBC_URL = "smart.framework.jdbc.url"; String JDBC_USERNAME = "smart.framework.jdbc.username"; String JDBC_PASSWORD = "smart.framework.jdbc.password"; String APP_BASE_PACKAGE = "smart.framework.app.base_package"; String APP_JSP_PATH = "smart.framework.app.jsp_path"; String APP_ASSET_PATH = "smart.framework.app.asset_path"; }
然后借助PropsUtil工具类实现ConfigHelper类,此类中是一些静态方法,分别获取smart.properties配置文件中的配置项。
package org.smart4j.framework.helper; import org.smart4j.framework.PropsUtil; import java.util.Properties; /** * @program: ConfigHelper * @description: 属性文件助手类 **/ public class ConfigHelper { private static final Properties CONFIG_PROPS = PropsUtil.loadProps(ConfigConstant.CONFIG_FILE); /** * 獲取JDBC驅動 * @return */ public static String getJdbcDriver(){ return PropsUtil.getString(CONFIG_PROPS,ConfigConstant.JDBC_DRIVER); } /** * 獲取JDBC URL * @return */ public static String getJdbcUrl(){ return PropsUtil.getString(CONFIG_PROPS,ConfigConstant.JDBC_URL); } /** * 獲取JDBC 用戶名 * @return */ public static String getJdbcUsername(){ return PropsUtil.getString(CONFIG_PROPS,ConfigConstant.JDBC_USERNAME); } /** * 獲取JDBC 密碼 * @return */ public static String getJdbcPassword(){ return PropsUtil.getString(CONFIG_PROPS,ConfigConstant.JDBC_PASSWORD); } /** * 獲取應用基礎包名 * @return */ public static String getAppBasePackage(){ return PropsUtil.getString(CONFIG_PROPS,ConfigConstant.APP_BASE_PACKAGE); } /** * 獲取應用JSP路徑 * @return */ public static String getAppJspPath(){ return PropsUtil.getString(CONFIG_PROPS,ConfigConstant.APP_JSP_PATH,"/WEB-INF/view/"); } /** * 獲取應用靜態資源路徑 * @return */ public static String getAppAssetPath(){ return PropsUtil.getString(CONFIG_PROPS,ConfigConstant.APP_ASSET_PATH,"/asset/"); } }
在ConfigHelper类中,为smart.framework.app.jsp_path与smart.framework.app.asset_path配置项提供了默认值。也就是说smart.properties配置文件中这两个配置项是可选的,如果不是特殊要求,可以修改这里两个配置。换句话说,这两个配置会以smart.properties配置文件中所配置的值为优先值。
开发一个类加载器
开发一个类加载器用来加载该基础包名下的所有类,例如:使用了注解的类、实现了某接口的类、继承了某父类的所有子类等。
写一个ClassUtil工具类,提供与类操作相关的方法,比如获取类加载器、加载类、获取指定包名下的所有类。
package org.smart4j.framework.util; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.smart4j.framework.StringUtil; import java.io.File; import java.io.FileFilter; import java.io.IOException; import java.net.JarURLConnection; import java.net.URL; import java.util.Enumeration; import java.util.HashSet; import java.util.Set; import java.util.jar.JarEntry; import java.util.jar.JarFile; /** * @program: ClassUtil * @description: 類加載器 * @author: qiuyu * @create: 2018-09-11 19:00 **/ public class ClassUtil { private static final Logger LOGGER = LoggerFactory.getLogger(ClassUtil.class); /** * 獲取類加載器 * 給下面的加載類用 * @return */ public static ClassLoader getClassLoader(){ return Thread.currentThread().getContextClassLoader(); } /** * 加載類 * 将类加载到方法区中 * @param className 类名 packageName.className * @param isInitialized 是否初始化静态代码块和静态字段 * @return */ public static Class<?> loadClass(String className,boolean isInitialized){ Class<?> cls; try { //className為類全名,isInitialized為是否初始化靜態代碼塊和靜態字段 cls = Class.forName(className,isInitialized,getClassLoader()); } catch (ClassNotFoundException e) { LOGGER.error("load class failure",e); throw new RuntimeException(e); // e.printStackTrace(); } return cls; } /** * 獲取指定包名下的所有類文件/文件夹和jar包 * @param packageName * @return */ public static Set<Class<?>> getClassSet(String packageName){ Set<Class<?>> classSet = new HashSet<Class<?>>(); try { //获取资源的url枚举 Enumeration<URL> urls = getClassLoader().getResources(packageName.replace(".", "/")); while(urls.hasMoreElements()){ //如果存在该包 URL url = urls.nextElement(); //获取包的url if (url!=null){ String protocol = url.getProtocol(); //查看url的协议(file、http) if (protocol.equals("file")){ //如果是文件或者文件夹 String packagePath = url.getPath().replaceAll("%20"," "); //空格的转义字符替换为空格,这个是java一个历史悠久的bug addClass(classSet,packagePath,packageName); }else if (protocol.equals("jar")){ //如果是jar包 JarURLConnection jarURLConnection = (JarURLConnection) url.openConnection(); //根据url获取jar的Connection if (jarURLConnection!=null){ JarFile jarFile = jarURLConnection.getJarFile(); //根据connection获取jar文件 if (jarFile!=null){ Enumeration<JarEntry> jarEntries = jarFile.entries(); //获取jar文件中的实体枚举 while (jarEntries.hasMoreElements()){ //遍历枚举 JarEntry jarEntry = jarEntries.nextElement(); String jarEntryName = jarEntry.getName(); if (jarEntryName.endsWith(".class")){ String className = jarEntryName.substring(0,jarEntryName.lastIndexOf(".")).replaceAll("/","."); doAddClass(classSet,className); } } } } } } } } catch (IOException e) { e.printStackTrace(); } return classSet; } /** * 加载指定包下面的jar和class文件 * @param classSet 存class的集合 * @param packagePath 包的真实路径 D:*** * @param packageName 包名 *.*.* */ private static void addClass(Set<Class<?>> classSet,String packagePath,String packageName){ //System.out.println(packageName); //System.out.println(packagePath); //获得包下面的所有文件(.class和文件夹) File[] files = new File(packagePath).listFiles(new FileFilter() { //文件过滤器,只获取.class结尾的文件和文件将夹 public boolean accept(File file) { return (file.isFile()&&file.getName().endsWith(".class"))||file.isDirectory(); } }); for (File file:files){ String fileName = file.getName(); //获取文件名 if (file.isFile()){ //如果是文件 String className = fileName.substring(0,fileName.lastIndexOf('.')); if (StringUtil.isNotEmpty(packageName)){ className = packageName+"."+className; //根据传进来的包名packageName和获取的.class文件名拼接成packageName.className doAddClass(classSet,className); } }else { //如果是目录 String subPackagePath = fileName; //子文件夹名 if (StringUtil.isNotEmpty(packagePath)){ subPackagePath=packagePath+"/"+subPackagePath; //子目录路径 } String subPackageName = fileName; if (StringUtil.isNotEmpty(subPackageName)){ subPackageName=packageName+"."+subPackageName; //子包名 } addClass(classSet,subPackagePath,subPackageName); // 将子包和子包路径传进去 } } } /** * 将类加载到方法区,并放入Set集合中 * @param classSet 存被加载类的集合 * @param className 类的全名 packageName.className */ private static void doAddClass(Set<Class<?>> classSet,String className){ Class<?> cls = loadClass(className,false); classSet.add(cls); } public static void main(String[] args) { //loadClass("org.smart4j.framework.util.Cls",false); //Cls cls = new Cls(); //加載環境中的jar包中的報名 Set<Class<?>> classSet = getClassSet("org.smart4j.framework.util"); System.out.println(classSet); } }
注解
为了实现在控制器上使用Controller注解,在控制器类的方法上使用Action注解,在服务类上使用Service注解,在控制器类中使用Inject注解将服务类依赖注入进来。因此需要四个注解类。
控制器注解代码
package org.smart4j.framework.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 { }
Action方法注解代码
/** * 控制器注解 * Action方法注解 */ @Target(ElementType.METHOD) @Retention(RetentionPolicy.RUNTIME) public @interface Action { /** * 请求类型与路径 */ String value(); }
服务类注解代码
/** * 服务类注解 */ @Target(ElementType.TYPE) @Retention(RetentionPolicy.RUNTIME) public @interface Service { }
依赖注入注解代码
/** * 依赖注入注解 */ @Target(ElementType.FIELD) @Retention(RetentionPolicy.RUNTIME) public @interface Inject { }
在smart.properties配置文件中指定了smart.framework.app.base_package,它是整个应用的基础包名,通过ClassUtil加载的类都需要基于该基础包名。所以有必要提供一个ClassHelper助手类,让它分别获取应用包名下的所有类、应用宝名下所有Service类、应用包名下所有Controller类。此外,我们可以将带有Controller注解与Service注解的类所产生的对象,理解为由Smart框架所管理的Bean,所以有必要在ClassHelper类中增加一个获取应用包名下所有Bean类的方法。ClassHelper代码
/** * @program: ClassHelper * @description: 类操作助手 * 获取所有Controller和Service类的集合 **/ public class ClassHelper { /** * 定义类集合 */ private static final Set<Class<?>> CLASS_SET; static { String basePackage = ConfigHelper.getAppBasePackage(); CLASS_SET = ClassUtil.getClassSet(basePackage); } /** * 获取应用包名下的所有类 * @return */ public static Set<Class<?>> getClassSet(){ return CLASS_SET; } /** * 获取所有Controller类 * @return */ public static Set<Class<?>> getControllerClassSet(){ Set<Class<?>> classSet = new HashSet<Class<?>>(); for (Class<?> cls : CLASS_SET){ if (cls.isAnnotationPresent(Controller.class)){ classSet.add(cls); } } return classSet; } /** * 获取所有Service类 * @return */ public static Set<Class<?>> getServiceClassSet(){ Set<Class<?>> classSet = new HashSet<Class<?>>(); for (Class<?> cls : CLASS_SET){ if (cls.isAnnotationPresent(Service.class)){ classSet.add(cls); } } return classSet; } /** * 获取应用包名下的所有bean类(Controller和Service) * @return */ public static Set<Class<?>> getBeanClassSet(){ Set<Class<?>> beanClassSet = new HashSet<Class<?>>(); beanClassSet.addAll(getControllerClassSet()); beanClassSet.addAll(getServiceClassSet()); return beanClassSet; } }
实现Bean容器
使用ClassHelper类可以获取所加载的类,但是无法通过类来实例化对象。因此,需要提供一个反射工具类,让它封装Java反射相关的API,对外提供更好用的工具方法。命名为ReflectionUtil。
package org.smart4j.framework.util; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import java.lang.reflect.Field; import java.lang.reflect.Method; /** * 反射工具 * 实现bean容器 */ public class ReflectionUtil { private static final Logger LOGGER = LoggerFactory.getLogger(ReflectionUtil.class); /** * 创建实例 * @param cls 已经加载的类 * @return */ public static Object newInstance(Class<?> cls){ Object instance = null; try { instance = cls.newInstance(); } catch (Exception e) { e.printStackTrace(); LOGGER.error("new instance failure",e); throw new RuntimeException(e); } return instance; } /** * 调用方法 * @param obj 调用方法的实例对象 * @param method 方法 * @param args 方法参数 * @return */ public static Object invokeMethod(Object obj, Method method,Object... args){ Object result = null; try { method.setAccessible(true); result = method.invoke(obj,args); } catch (Exception e) { //e.printStackTrace(); LOGGER.error("invoke method failure",e); throw new RuntimeException(e); } return result; } /** * 设置成员变量的值 * @param obj 实例对象 * @param field 字段 * @param value 字段值 */ public static void setField(Object obj, Field field,Object value){ try { field.setAccessible(true); field.set(obj,value); } catch (IllegalAccessException e) { //e.printStackTrace(); LOGGER.error("set field failure",e); throw new RuntimeException(e); } } }
要获取所有被框架管理的Bean类,需要调用ClassHelper类的getBeanClassSet方法,然后循环调用ReflectionUtil类的newInstance方法,根据类来实例化对象,然后将每次创建的对象放在一个静态的Map<Class<?>,Object>中。我们需要随时获取该Map,还需要通过该Map的Key(类名)去获取所对应的value(Bean)对象。BeanHelper类代码如下:
package org.smart4j.framework.helper; import org.smart4j.framework.util.ReflectionUtil; import java.util.HashMap; import java.util.Map; import java.util.Set; /** * Bean助手类 * */ public class BeanHelper { /** * 定义bean映射(用于存放Bean类与Bean实例的映射关系) */ private static final Map<Class<?>,Object> BEAN_MAP = new HashMap<Class<?>, Object>(); static{ //获取所有Controller和Service Set<Class<?>> beanClassSet = ClassHelper.getBeanClassSet(); //遍历所有的Controlller和Service类 for (Class<?> beanClass:beanClassSet){ Object obj = ReflectionUtil.newInstance(beanClass); //将类实例化 BEAN_MAP.put(beanClass,obj); //将类和实例放入Map中 Map<Class,Obj> } } /** * 获取Bean映射 * @return */ public static Map<Class<?>, Object> getBeanMap() { return BEAN_MAP; } /** * 根据Class获取bean实例 * @param cls bean实例所属的类 * @param <T> 类的实例对象 * @return */ public static <T> T getBean(Class<T> cls){ if (!BEAN_MAP.containsKey(cls)){ throw new RuntimeException("can not get bean by class"+cls); } return (T) BEAN_MAP.get(cls); } }
BeanHelper就相当于一个“Bean容器”了,因为在Bean Map中存放了Bean类与Bean实例的映射关系,我们只需通过调用getBean方法,传入一个Bean类,就能获取Bean实例。
实现依赖注入
Controller中定义的Service成员变量,在Controller的Action方法中调用Service成员变量的方法。这里Service并没有通过new的方式实例化,而是通过框架自身来实例化,像这类实例化过程,称为IOC(Inversion of Control,控制反转)。控制不是由开发者来决定的,而是反转给框架了。一般地,我们也将反转称为DI(Dependency Injection,依赖注入),可以理解为将某个类需要依赖的成员注入到这个类中。那么,如何来实现依赖注入呢?
最简单的方式是,先通过BeanHelper获取所有BeanMap(是一个Map<Class<?>>,Object结构,记录了类与对象的映射关系)。然后遍历这个映射关系,分别取出Bean类与Bean实例,进而通过反射获取类中所有的成员变量。继续遍历这些成员变量,在循环中判断当前成员变量是否带有Inject注解,若带有该注解,则从Bean Map 中根据Bean实例。最后通过ReflectionUtil#setField方法来修改当前成员变量的值。
package org.smart4j.framework.helper; import org.smart4j.framework.ArrayUtil; import org.smart4j.framework.annotation.Inject; import org.smart4j.framework.util.ReflectionUtil; import java.lang.reflect.Field; import java.util.Map; /** * 依赖注入助手类 */ public class IocHelper { static { //获取所有bean类与Bean实例类之间的关系的集合(简称BeanMap) Map<Class<?>,Object> beanMap = BeanHelper.getBeanMap(); if (CollectionUtil.isNotEmpty(beanMap)){ //遍历beanMap for (Map.Entry<Class<?>,Object> beanEntry:beanMap.entrySet()){ //从Bean中获取Bean类与Bean实例 Class<?> beanClass = beanEntry.getKey(); Object beanInstance = beanEntry.getValue(); //获取bean类定义的所有成员变量(简称Bean Field) Field[] beanFields = beanClass.getDeclaredFields(); if (ArrayUtil.isNotEmpty(beanFields)){ //遍历Bean Field for (Field beanField:beanFields){ //判断是否带有Inject注解 if (beanField.isAnnotationPresent(Inject.class)){ //在Bean Map中获取Bean Field对应的实例 Class<?> beanFieldClass = beanField.getType(); Object beanFieldInstance = beanMap.get(beanFieldClass); if (beanFieldInstance!=null){ //通过反射初始化BeanField的值 ReflectionUtil.setField(beanInstance,beanField,beanFieldInstance); } } } } } } } }
只需要在IocHelper的静态代码块中实现相关逻辑,就能完成IOC容器的初始化工作。在IOCHelper这个类被加载的时候,就会加载它的静态块。后面我们需要找一个统一的地方来加载这个IocHelper。其中涉及了ArrayUtil类,代码如下
package org.smart4j.framework; import org.apache.commons.lang3.ArrayUtils; /** * 数组工具类 */ public class ArrayUtil { /** * 判断数组是否为空 * @param array * @return */ public static boolean isNotEmpty(Object[] array){ return !isEmpty(array); } /** * 判断数组是否非空 * @param array * @return */ public static boolean isEmpty(Object[] array){ return array==null||array.length==0; } }
需要注意的是,此时IOC框架中所管理的对象都是单例的,由于IOC框架底层还是从BeanHelper中获取的Bean Map的,而Bean Map中的对象都是事先创建好并放入这个Bean容器中的,所有的对象都是单例的。
加载Controller
我们需要创建一个ControllerHelper类,让它来处理如下逻辑:
通过ClassHelper,我们可以获取所有定义了Controller注解的类,可以通过反射获取该类中所有带有Action注解的方法(简称“Action方法”),获取Action注解中的请求表达式,进而获取请求方法与请求路径,封装一个请求对象(Request)与处理对象(Handler),最后将Request与Handler建立一个映射关系,放入一个Action Map中,并提供一个可根据请求方法与请求路径获取处理对象的方法。
Request类
package org.smart4j.framework.bean; import org.apache.commons.lang3.builder.EqualsBuilder; import org.apache.commons.lang3.builder.HashCodeBuilder; /** * 封装请求信息 */ public class Request { /** * 请求方法 */ private String requestMethod; /** * 请求路径 */ private String requestPath; public Request(String requestMethod,String requestPath){ this.requestMethod = requestMethod; this.requestPath = requestPath; } public String getRequestMethod() { return requestMethod; } public void setRequestMethod(String requestMethod) { this.requestMethod = requestMethod; } public String getRequestPath() { return requestPath; } public void setRequestPath(String requestPath) { this.requestPath = requestPath; } @Override public int hashCode() { return HashCodeBuilder.reflectionHashCode(this); } @Override public boolean equals(Object obj) { return EqualsBuilder.reflectionEquals(this,obj); } }
Handler类
package org.smart4j.framework.bean; import java.lang.reflect.Method; /** * @program: Handler * @description: 封装Action信息 **/ public class Handler { /** * Controller类 */ private Class<?> controllerClass; /** * Action方法 */ private Method actionMethod; public Handler(Class<?> controllerClass, Method actionMethod) { this.controllerClass = controllerClass; this.actionMethod = actionMethod; } public Class<?> getControllerClass() { return controllerClass; } public Method getActionMethod() { return actionMethod; } }
ControllerHelper类
package org.smart4j.framework.helper; import org.smart4j.framework.ArrayUtil; import org.smart4j.framework.annotation.Action; import org.smart4j.framework.bean.Handler; import org.smart4j.framework.bean.Request; import java.lang.reflect.Method; import java.util.HashMap; import java.util.Map; import java.util.Set; /** * @program: ControllerHelper * @description: 控制器助手类 * @author: QiuYu * @create: 2018-09-27 15:34 **/ public final class ControllerHelper { /** * 用于存放请求与处理器的映射关系(简称Action Map) */ private static final Map<Request,Handler> ACTION_MAP = new HashMap<Request, Handler>(); static{ //获取所有Controller类 Set<Class<?>> controllerClassSet = ClassHelper.getControllerClassSet(); if (org.smart4j.framework.helper.CollectionUtil.isNotEmpty(controllerClassSet)){ //遍历这些Controller类 for (Class<?> controllerClass : controllerClassSet){ //获取Controller类中定义的方法 Method[] methods = controllerClass.getDeclaredMethods(); if (ArrayUtil.isNotEmpty(methods)){ //遍历这些Controller类中的方法 for (Method method:methods){ //判断当前方法是否带有Action注解 if (method.isAnnotationPresent(Action.class)){ //从Action注解中获取URL映射规则 Action action = method.getAnnotation(Action.class); String mapping = action.value(); //验证URL映射规则 if (mapping.matches("\w+:/\w*")){ String[] array =mapping.split(":"); if (ArrayUtil.isNotEmpty(array)&&array.length==2){ //获取请求方法与路径 String requestMethod = array[0]; String requestPath = array[1]; Request request = new Request(requestMethod,requestPath); Handler handler = new Handler(controllerClass,method); //初始化Action Map ACTION_MAP.put(request,handler); } } } } } } } } /** * 获取Handler * @param requestMethod * @param requestPath * @return */ public static Handler getHandler(String requestMethod,String requestPath){ Request request = new Request(requestMethod,requestPath); return ACTION_MAP.get(request); } }
在ControllerHelper中封装了一个ActionMap,通过它来存放Request和Handler之间的映射关系,然后通过ClassHelper来获取所有带有Controller注解的类,接着遍历这些Controller类,从Action注解中提取URL,最后初始化Request与Handler之间的映射关系。
初始化框架
通过上面的过程,我们创建了ClassHelper、BeanHelper、IOCHelper、ControllerHelper,这四个Helper类需要通过一个入口程序来加载他们。
package org.smart4j.framework; import org.smart4j.framework.helper.BeanHelper; import org.smart4j.framework.helper.ClassHelper; import org.smart4j.framework.helper.ControllerHelper; import org.smart4j.framework.helper.IocHelper; import org.smart4j.framework.util.ClassUtil; /** * @program: HelperLoader * @description: 加载相应的Helper类 **/ public class HelperLoader { public static void init(){ Class<?>[] classList={ ClassHelper.class, BeanHelper.class, IocHelper.class, ControllerHelper.class }; for (Class<?> cls:classList){ ClassUtil.loadClass(cls.getName(),true); } } }
当我们第一次访问类时,就会加载其static块。这里只是为了让它们加载更集中,所以才写了一个HelperLoader类。
请求转发器
以上所有过程都为这一步做准备,现在需要实现一个Servlet,让它来处理所有的请求。从HttpServletRequest对象中获取请求方法与请求路径,通过ControllerHelper#getHandler方法来获取。
当拿到Handler对象后,我们可以获取Controller类,进而通过BeanHelper.个体Bean方法获取Controller的实例对象。
随后可以从HttpServletRequest对象中获取所有请求参数,并将其初始化到一个名为Param的对象中
Param参数类代码:
package org.smart4j.framework.bean; import org.smart4j.framework.CastUtil; import java.util.Map; /** * @program: Param * @description: 请求参数对象 * @author: Created by Autumn * @create: 2018-10-24 10:47 */ public class Param { private Map<String,Object> paramMap; public Param(Map<String, Object> paramMap) { this.paramMap = paramMap; } /** * 根据参数名获取long型参数值 * @param name * @return */ public long getLong(String name){ return CastUtil.castLong(paramMap.get(name)); } /** * 获取所有字段信息 * @return */ public Map<String,Object> getMap(){ return paramMap; } }
Param可以通过参数名获取指定类型的参数值,也可以获取所有参数的Map结构。
还可从Handler对象中获取Action的方法返回值,该返回值可能有两种情况。
(1)若返回值是View类型的视图对象,则返回一个JSP页面。
(2)若返回值是Data类型的数据对象,则返回一个JSON数据。
View类
package org.smart4j.framework.bean; import java.util.Map; /** * @program: View * @description: 视图对象 */ public class View { /** * 视图路径 */ private String path; /** * 模型数据 */ private Map<String,Object> model = new HashMap<String,Object>(); public View(String path, Map<String, Object> model) { this.path = path; this.model = model; } public View addModel(String key,Object value){ model.put(key,value); return this; } public String getPath() { return path; } public Map<String, Object> getModel() { return model; } }
Data类
package org.smart4j.framework.bean; /** * @program: Data * @description: 返回数据对象 */ public class Data { /** * 模型数据 */ private Object model; public Data(Object model) { this.model = model; } public Object getModel() { return model; } }
返回的Data类型的数据封装了一个Object类型的模型数据,框架会将该对象写入HttpServletResponse对象中,从而直接输出至浏览器。
MVC框架中核心的DispatcherServlet类
package org.smart4j.framework; import org.smart4j.framework.bean.Data; import org.smart4j.framework.bean.Handler; import org.smart4j.framework.bean.Param; import org.smart4j.framework.bean.View; import org.smart4j.framework.helper.BeanHelper; import org.smart4j.framework.helper.ConfigHelper; import org.smart4j.framework.helper.ControllerHelper; import org.smart4j.framework.util.CodecUtil; import org.smart4j.framework.util.JsonUtil; import org.smart4j.framework.util.ReflectionUtil; import org.smart4j.framework.util.StreamUtil; import javax.servlet.*; import javax.servlet.annotation.WebServlet; import javax.servlet.http.HttpServlet; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import java.io.IOException; import java.io.PrintWriter; import java.lang.reflect.Method; import java.util.Enumeration; import java.util.HashMap; import java.util.Map; /** * @program: DispatcherServlet * @description: 请求转发器 * @author: Created by Autumn * @create: 2018-10-24 11:34 */ @WebServlet(urlPatterns = "/*",loadOnStartup = 0) public class DispatcherServlet extends HttpServlet { @Override public void init(ServletConfig servletConfig) throws ServletException { //初始化相关Helper类 HelperLoader.init(); //获取ServletContext对象(用于注册Servlet) ServletContext servletContext = servletConfig.getServletContext(); //注册处理JSP的Servlet ServletRegistration jspServlet = servletContext.getServletRegistration("jsp"); jspServlet.addMapping(ConfigHelper.getAppJspPath()+"*"); //注册处理静态资源的默认Servlet ServletRegistration defaultServlet = servletContext.getServletRegistration("default"); defaultServlet.addMapping(ConfigHelper.getAppAssetPath()+"*"); } @Override protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { //获取请求方法与请求路径 String requestMethod = req.getMethod().toLowerCase(); String requestPath = req.getPathInfo(); //获取Action处理器 Handler handler= ControllerHelper.getHandler(requestMethod,requestPath); if(handler!=null){ //获取Controller类机器Bean实例 Class<?> controllerClass = handler.getControllerClass(); Object controllerBean = BeanHelper.getBean(controllerClass); //创建请求参数对象 Map<String,Object> paramMap = new HashMap<String, Object>(); Enumeration<String> paramNames = req.getParameterNames(); while(paramNames.hasMoreElements()){ String paramName = paramNames.nextElement(); String paramValue = req.getParameter(paramName); paramMap.put(paramName,paramValue); } //获取请求body中的参数 String body = CodecUtil.dencodeURL(StreamUtil.getString(req.getInputStream())); if (StringUtil.isNotEmpty(body)){ String[] params = StringUtil.splitString(body,"&"); if (ArrayUtil.isNotEmpty(params)){ for (String param:params){ String[] array = StringUtil.splitString(param,"="); if (ArrayUtil.isNotEmpty(array)&&array.length==2){ String paramName = array[0]; String paramValue = array[1]; paramMap.put(paramName,paramValue); } } } } Param param = new Param(paramMap); //调用Action方法 Method actionMethod = handler.getActionMethod(); Object result = ReflectionUtil.invokeMethod(controllerBean,actionMethod,param); //处理Action方法返回值 if (result instanceof View){ //返回JSP页面 View view = (View) result; String path = view.getPath(); if (StringUtil.isNotEmpty(path)){ if (path.startsWith("/")){ //这里应该是判断是否有数据 resp.sendRedirect(req.getContextPath()+path); } else { Map<String,Object> model = view.getModel(); for (Map.Entry<String,Object> entry:model.entrySet()){ req.setAttribute(entry.getKey(),entry.getValue()); } req.getRequestDispatcher(ConfigHelper.getAppJspPath()+path).forward(req,resp); } } }else if (result instanceof Data){ //返回Json数据 Data data = (Data) result; Object model = data.getModel(); if (model!=null){ resp.setContentType("application/json"); resp.setCharacterEncoding("UTF-8"); PrintWriter writer = resp.getWriter(); String json = JsonUtil.toJson(model); writer.write(json); writer.flush(); writer.close(); } } } } }
其中涉及到流工具类、编码工具类、Json工具类。
一款简单的MVC框架开发完毕,通过这个DispatcherServlet来处理所有的请求,根据请求信息从ControllerHelper中获取对应的Action方法,然后使用反射技术调用Action方法,同事需要传入具体的方法参数,最后拿到返回值的类型并进行相应的处理。
安装到Maven本地仓库
1.用Maven将项目打包成jar
2.用Maven将jar包安装到仓库
此种方式的jar包不会把依赖jar包打包进去
mvn install:install-file -Dfile=smart-framework-1.0.0.jar -DgroupId=org.smart4j -DartifactId=smart-framework -Dversion=1.0.0 -Dpackaging=jar
此种为IDEA中安装包的代码
java -Dmaven.multiModuleProjectDirectory=F:intellijIDEAworkspacesmart-framework -Dmaven.home=D:Programmer_QYapache-maven-3.5.0 -Dclassworlds.conf=D:Programmer_QYapache-maven-3.5.0inm2.conf "-javaagent:D:Programmer_QYIntelliJ IDEA 2017.1.1libidea_rt.jar=51430:D:Programmer_QYIntelliJ IDEA 2017.1.1in" -Dfile.encoding=UTF-8 -classpath D:Programmer_QYapache-maven-3.5.0ootplexus-classworlds-2.5.2.jar org.codehaus.classworlds.Launcher -Didea.version=2017.1.1 -s D:Programmer_QYapache-maven-3.5.0confsettings.xml install
相当于以下两步
总结
通过Controller注解来定义Controller类;通过Inject注解来实现依赖注入;通过Action注解来定义Action方法。通过一系列的Helper类来初始化MVC框架;通过DispatcherServlet来处理所有的请求;根据请求方法与请求路径来调用具体的Action方法,判断Action方法的返回值,若为View类型,则跳转到JSP页面,若为Data类型,则返回JSON数据。
整个框架基本能跑起来了,但里面还存在大量需要优化的地方。此外,还有一些非常好的特性尚未提供,比如AOP(Aspect Oriented Programming,面向方面编程)。我们可以使用这个特性来实现一些横向拦截操作,比如性能分析、日志收集、安全监控等,下一章我们将介绍如何实现AOP特性。
结果截图