spring之mvc原理分析及简单模拟实现

<!-- 核心servlet -->
<servlet>
<servlet-name>dispatcherServlet</servlet-name>
<servlet-class>org.wl.test.spring.mvc.DispatcherServlet</servlet-class>
<!-- 初始化参数 -->
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:application.properties</param-value>
</init-param>
<!-- 启动时加载 -->
<load-on-startup>0</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>dispatcherServlet</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>

public class DispatcherServlet extends HttpServlet { private List<HandlerMapping> handlerMappingList = new ArrayList<HandlerMapping>(); private Map<HandlerMapping, HandlerAdapter> adapterMap = new HashMap<>(); @Override
public void init(ServletConfig config) throws ServletException {
// web.xml 配置核心servlet 获取配置的信息
String configFile = config.getInitParameter("contextConfigLocation");
//定义一个当前上下文对象，实现基础包的扫描、IOC、DI
ApplicationContext context = new ApplicationContext(configFile.replace("classpath:", ""));
//获取扫描到的有Controller注解的类
List<Object> controllerList = context.getControllerList();
//初始化HandlerMapping
initHandlerMapping(controllerList);
//初始化HandlerAdapter
initHandlerAdapter();
} private void initHandlerAdapter() {
if (handlerMappingList.size() == 0) {
return;
} handlerMappingList.forEach(handlerMapping -> {
Method method = handlerMapping.getMethod();
//方法的参数 <参数索引，参数名字>
Map<Integer, String> paramMap = new HashMap<>(); //使用了注解参数
Annotation[][] annos = method.getParameterAnnotations();
if(annos.length > 0){
for(int i=0; i<annos.length; i++){
for(Annotation anno : annos[i]){
if(anno instanceof RequestParam){
RequestParam requestParam = (RequestParam) anno;
String paramName = requestParam.value(); paramMap.put(i, paramName);
}
}
}
}
//直接用的servlet参数，如HttpServletRequest
Class<?>[] paramTypes = method.getParameterTypes();
if(paramTypes.length > 0){
for(int i=0; i<paramTypes.length; i++){
Class<?> typeClass = paramTypes[i];
if (typeClass == HttpServletRequest.class || typeClass == HttpServletResponse.class) {
String paramName = typeClass.getName(); paramMap.put(i, paramName);
}
}
} HandlerAdapter handlerAdapter = new HandlerAdapter(paramMap);
adapterMap.put(handlerMapping, handlerAdapter);
});
} /**
* 完成请求方法与请求处理实例的映射关系
* @param controllerList
*/
private void initHandlerMapping(List<Object> controllerList) {
if(controllerList.size() == 0){
return;
} controllerList.forEach(controllerObj -> {
//类上的请求路径
String classRequestUrl = "";
if (controllerObj.getClass().isAnnotationPresent(RequestMapping.class)) {
RequestMapping classRequestMapping = controllerObj.getClass().getAnnotation(RequestMapping.class);
if(classRequestMapping != null){
classRequestUrl += urlHandler(classRequestMapping.value());
}
}
//方法上的请求路径
Method[] methods = controllerObj.getClass().getDeclaredMethods();
if(methods.length > 0){
for(int i=0; i<methods.length; i++){
String methodRequestUrl = "";
Method method = methods[i];
//必须是public修饰的方法
if(method.getModifiers() == Modifier.PUBLIC){
if (method.isAnnotationPresent(RequestMapping.class)) {
RequestMapping methodRequestMapping = method.getAnnotation(RequestMapping.class);
if(methodRequestMapping != null){
methodRequestUrl += urlHandler(methodRequestMapping.value());
} String requestUrl = classRequestUrl + methodRequestUrl; HandlerMapping handlerMapping = new HandlerMapping();
handlerMapping.setMethod(method);
handlerMapping.setUrl(requestUrl); handlerMapping.setControllerInstance(controllerObj);
handlerMappingList.add(handlerMapping);
}
} }
} }); } /**
* url处理
* @param url
* @return
*/
public String urlHandler( String url){
if(!url.startsWith("/")){
url = "/" + url;
}
if(url.endsWith("/")){
url = url.substring(0, url.length() - 1);
}
return url;
} @Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
this.doPost(req, resp);
} @Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doDispatcher(req, resp);
} /**
* 请求处理
* @param req
* @param resp
*/
private void doDispatcher(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
req.setCharacterEncoding("utf-8");
resp.setContentType("text/html;charset=UTF-8"); String contextUrl = req.getContextPath();
String requestUrl = req.getRequestURI(); String url = requestUrl.replace(contextUrl, "");
HandlerMapping handlerMapping = null;
for(int i=0; i<handlerMappingList.size(); i++){
if(url.equals(handlerMappingList.get(i).getUrl())){
handlerMapping = handlerMappingList.get(i);
break;
}
}
if(handlerMapping == null){
resp.getWriter().write("404, 未知的请求！");
}else{
HandlerAdapter adapter = adapterMap.get(handlerMapping);
try {
Object result = adapter.handler(req, resp, handlerMapping); viewResolve(req, resp, result);
} catch (Exception e) {
e.printStackTrace();
resp.getWriter().write("500, 服务器发生异常！");
}
} } /**
* 视图解析 返回
* @param result
*/
private void viewResolve(HttpServletRequest request, HttpServletResponse response, Object result) throws Exception{
if (result.getClass() == ModelAndView.class) {
ModelAndView mv = (ModelAndView) result;
String view = mv.getViewName();
Map<String, Object> dataMap = mv.getData();
if(dataMap.size() > 0){
for(String key : dataMap.keySet()){
request.setAttribute(key, dataMap.get(key));
}
}
request.getRequestDispatcher(view).forward(request, response);
}
} }

public class ApplicationContext { /**
* 配置文件
*/
private static String PROPERTIES_FILE = ""; /**
* 初始化一个集合，存放扫描到的class对象
*/
private List<Class<?>> classList = Collections.synchronizedList(new ArrayList<>()); /**
* 初始化map 存放别名与对象实例
*/
private Map<String, Object> aliasInstanceMap = new HashMap<>(); public ApplicationContext(String fileName) {
PROPERTIES_FILE = fileName;
try {
String basePackage = getBasePackage(PROPERTIES_FILE); buildAliasInstanceMap(basePackage); doAutowired(); } catch (Exception e) {
e.printStackTrace();
}
} /**
* 完成别名与实例的映射
*/
public void buildAliasInstanceMap(String basePackage) throws Exception { scanClasses(basePackage); if(classList.size() == 0){return;} for(Class<?> clazz : classList){
if (clazz.isAnnotationPresent(Controller.class) || clazz.isAnnotationPresent(Service.class)
|| clazz.isAnnotationPresent(Autowired.class)) {
String alias = getAlias(clazz);
Object obj = aliasInstanceMap.get(alias); //如果别名实例映射关系已经存在，则给出提示
if(obj != null){
throw new Exception("alias is exist!");
}else{
aliasInstanceMap.put(alias, clazz.newInstance());
}
}
} System.out.println(aliasInstanceMap);
} /**
* 属性对象的注入
*/
public void doAutowired(){
if (aliasInstanceMap.size() == 0) {
return;
} aliasInstanceMap.forEach((k, v)->{ Field[] fields = v.getClass().getDeclaredFields(); for(Field field : fields){
if (field.isAnnotationPresent(Autowired.class)) {
String alias = ""; Autowired autowired = field.getAnnotation(Autowired.class);
if(autowired != null){
//注入的对象是接口时，由于不知道接口有几个实现类，所以就必须在Autowired或者Qualifier上指定要注解的具体的实现类
if(!"".equals(autowired.value())){
alias = autowired.value();
}else{
Qualifier qualifier = field.getAnnotation(Qualifier.class);
if(qualifier != null){
alias = qualifier.value();
}
}
} if ("".equals(alias)) {
alias = getAlias(field.getType());
} Object instance = null;
if(!"".equals(alias)){
instance = aliasInstanceMap.get(alias);
} field.setAccessible(true); try {
field.set(v, instance);
} catch (IllegalAccessException e) {
e.printStackTrace();
}
} }
}); } /**
* 获取对象的别名，如果注解中配置了别名，别使用配置的别名，否则默认使用类名首字母小写
* @param clazz
* @return
*/
public String getAlias(Class<?> clazz){
String alias = "";
Controller controller = clazz.getAnnotation(Controller.class);
if(controller != null){
alias = controller.value();
}
Service service = clazz.getAnnotation(Service.class);
if (service != null) {
alias = service.value();
}
Autowired autowired = clazz.getAnnotation(Autowired.class);
if(autowired != null){
alias = autowired.value();
} //注解中没有配置别名
if("".equals(alias)){
String simpleName = clazz.getSimpleName();
alias = simpleName.substring(0, 1).toLowerCase() + simpleName.substring(1);
}
return alias;
} /**
* 跟据基础包名读取包及子包中的类对象
* @param basePackage
*/
public void scanClasses(String basePackage){
if(basePackage == null || "".equals(basePackage)){return;} doScan(basePackage);
System.out.println(classList);
} private void doScan(String basePackage) {
String path = basePackage.replaceAll("\\.","/");
URL url = this.getClass().getClassLoader().getResource(path);
File file = new File(url.getFile());
file.listFiles(new FileFilter() {
@Override
public boolean accept(File childFile) {
String fileName = childFile.getName();
if(childFile.isDirectory()){
//当前文件是目录，递归 扫描下级子目录下的class文件
doScan(basePackage + "." + fileName);
}else{
if(fileName.endsWith(".class")){
String className = basePackage + "." + fileName.replace(".class", "");
try {
Class<?> clazz = this.getClass().getClassLoader().loadClass(className);
classList.add(clazz);
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
return false;
}
});
} /**
* 从配置的属性文件中读取要扫描的包
* @return
*/
public String getBasePackage(String fileName) throws IOException {
String basePackage;
Properties prop = new Properties();
InputStream in = this.getClass().getClassLoader().getResourceAsStream(fileName);
prop.load(in);
basePackage = prop.getProperty("basePackage");
return basePackage;
} /**
* 根据beanName 获取
* @param beanName
* @return
*/
public Object getBean(String beanName){
return aliasInstanceMap.get(beanName);
} /**
* 获取所有标注了controller的注解
* @return
*/
public List<Object> getControllerList(){
List<Object> controllerList = new ArrayList<>();
if(aliasInstanceMap.size() > 0) {
aliasInstanceMap.values().forEach(obj -> {
if(obj.getClass().isAnnotationPresent(Controller.class)){
controllerList.add(obj);
}
});
}
return controllerList;
} public static void main(String[] args) throws Exception {
String fileName = "application.properties";
ApplicationContext context = new ApplicationContext(fileName);
String basePackage = context.getBasePackage(PROPERTIES_FILE); context.buildAliasInstanceMap(basePackage); context.doAutowired();
//测试
UserController controller = (UserController) context.getBean("userController");
controller.save();
}}

public class HandlerMapping { private String url;
private Method method;
private Object controllerInstance; //此处省去getter和setter
}

public class HandlerAdapter { private Map<Integer, String> paramMap; public HandlerAdapter(Map<Integer, String> paramMap){
this.paramMap = paramMap;
} public Object handler(HttpServletRequest request, HttpServletResponse response, HandlerMapping handlerMapping) throws Exception {
Method method = handlerMapping.getMethod();
Object classInstance = handlerMapping.getControllerInstance(); int paramNum = method.getParameterCount();
Object[] paramObj = new Object[paramNum];
for(int i=0; i<paramNum; i++){
String paramName = paramMap.get(i);
if(paramName.equals(HttpServletRequest.class.getName())){
paramObj[i] = request;
}else if(paramName.equals(HttpServletResponse.class.getName())){
paramObj[i] = response;
} else {
paramObj[i] = request.getParameter(paramName);
}
}
Object result = method.invoke(classInstance, paramObj);
return result;
} public Map<Integer, String> getParamMap() {
return paramMap;
} public void setParamMap(Map<Integer, String> paramMap) {
this.paramMap = paramMap;
}
}

public class ModelAndView { private String viewName;
private Map<String, Object> data = new HashMap<>(); public ModelAndView(String viewName) {
this.viewName = viewName;
} public void addAttribute(String name, Object value){
data.put(name, value);
} //此处省略getter和setter
}

<html>
<head>
<title>Title</title>
</head>
<body>
<h3>hello mvc...</h3>
<hr/>
用 户 信 息：<%=request.getAttribute("user") %>
</body>
</html>