学会使用框架,慢慢的就需要提升自己,学会手写框架。我们先从简单的 MVC 开始。本篇文章
本代码已经上传到Gitee上面:
https://gitee.com/li_kun_zang/do-mvc
技术包含了:
- 自定义注解
- 类加载
- 反射 & 注解扫描
主要实现功能:
- 统一请求控制
- 请求参数数据类型转换
- 统一请求转发、重定向
- 响应JSON数据。
思想
M:Model 模型 代表 @Controller修饰的内容
V:View 视图 图中 返回的结果 404 500 JSON 等等
C:Controller 控制器 图中代表 DispatcherServlet
实操
jdk 8 环境、tomcat 8 环境、maven 环境
1、创建 webapp 项目
自己补全 java、resources、 test 文件夹
2、引入 Maven 依赖
这里是封装的 反射的 操作。
<dependency>
<groupId>org.reflections</groupId>
<artifactId>reflections</artifactId>
<version>0.9.11</version>
</dependency>
3、创建相关注解
自创建一个 annoation 文件夹 并在 下面创建 @Controller 、@RequestMapping 注解
代码如下
@Controller 注解
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* @author : zanglikun
* @date : 2021/2/23 11:50
* @Version: 1.0
* @Desc : 自定义的 Controller 注解 需要声明 他的运行周期,我们采用元注解 进行 注解 Controller 注解 如果 这里 不理解 ,请去访问 https://www.zanglikun.com/1078.html 学习
*/
@Target(ElementType.TYPE) // 设置 只能修饰在类上
@Retention(RetentionPolicy.RUNTIME) // 设置 在运行期有效
public @interface Controller {
/**
* @Target(ElementType.METHOD)
* @Retention(RetentionPolicy.SOURCE)
*/
// @Override //我们进入 此注解,获取它的 注解格式,我们修改即可
}
@RequeseMapping 注解
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* @author : zanglikun
* @date : 2021/2/23 11:54
* @Version: 1.0
* @Desc : RequestMapping 注解 并加入一个 value 值。
*/
@Target({ElementType.METHOD,ElementType.TYPE}) // 注解在 类和方法上
@Retention(RetentionPolicy.RUNTIME) // 注解此注解 只在运行期
public @interface RequestMapping {
String value() default ""; // 设置注解 可传递的参数,默认值是 ""
}
4、去使用注解
创建 一个 Controller 文件夹 并创建 一个 Java 类
我们在写代码过程,就能看到我们自己的注解了。
写2个 Controller
UserController 其中 NoScanMethod 没有被 @RequestMapping 注解
import com.zanglikun.framework.annoation.Controller;
import com.zanglikun.framework.annoation.RequestMapping;
/**
* @author : zanglikun
* @date : 2021/2/23 12:27
* @Version: 1.0
* @Desc : 用户控制类
*/
@Controller
@RequestMapping("/user")
public class UserController {
@RequestMapping("/add")
public void ADD(){
System.out.println("UserController 执行了add方法");
}
@RequestMapping("/del")
public void DEL(){
System.out.println("UserController 执行了del方法");
}
@RequestMapping("/get")
public void GET(){
System.out.println("UserController 执行了get方法");
}
public void NoScanMethod(){
System.out.println("UserController 执行了NoScanMethod方法");
}
}
NewsController
import com.zanglikun.framework.annoation.Controller;
import com.zanglikun.framework.annoation.RequestMapping;
/**
* @author : zanglikun
* @date : 2021/2/23 12:27
* @Version: 1.0
* @Desc : 新闻控制类
*/
@Controller
@RequestMapping("/news")
public class NewsController {
@RequestMapping("/add")
public void ADD(){
System.out.println("NewsController 执行了add方法");
}
@RequestMapping("/del")
public void DEL(){
System.out.println("NewsController 执行了del方法");
}
@RequestMapping("/get")
public void GET(){
System.out.println("NewsController 执行了get方法");
}
}
5、创建一个 Model 包 下的UrlMapping 将来集合 收集 类的信息
import java.lang.reflect.Method;
/**
* @author : zanglikun
* @date : 2021/2/23 14:04
* @Version: 1.0
* @Desc : 费劲,没啥好说的
*/
public class UrlMapping {
private Object obj;
private Method method;
public UrlMapping() {
}
public UrlMapping(Object obj, Method method) {
this.obj = obj;
this.method = method;
}
public Object getObj() {
return obj;
}
public void setObj(Object obj) {
this.obj = obj;
}
public Method getMethod() {
return method;
}
public void setMethod(Method method) {
this.method = method;
}
}
6、扫描注解
创建一个 utils 包,ClassUtils 类
import com.zanglikun.framework.annoation.Controller;
import com.zanglikun.framework.annoation.RequestMapping;
import com.zanglikun.framework.model.UrlMapping;
import org.reflections.Reflections;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
/**
* @author : zanglikun
* @date : 2021/2/23 13:27
* @Version: 1.0
* @Desc : 费劲,没啥好说的
*/
public class ClassUtils {
// 创建 收集数据的对象
private static Map<String, UrlMapping> map = new HashMap<>();
static {
try {
getUrlMappings("com.zanglikun");
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
}
// 私有静态 代码块的方式,保证了 扫描 所有类的 注解、方法 信息 只执行一次
// 传递 一个 基础的 包名
private static Map<String, UrlMapping> getUrlMappings(String basePackageName) throws IllegalAccessException, InstantiationException, InvocationTargetException {
// 创建反射对象,
Reflections reflections = new Reflections(basePackageName);
// 获取 被 @Controller 修饰的对象的字节码信息
Set<Class<?>> classes = reflections.getTypesAnnotatedWith(Controller.class);
// 遍历 这些 类的字节码信息
for (Class<?> aClass : classes) {
// 判断 类上有 @RequestMapping 注解的 类
RequestMapping classAnnotation = aClass.getDeclaredAnnotation(RequestMapping.class);
// 定义 类上的 注解 值
String baseUri = "";
// 判断 是否有这个对象
if (classAnnotation != null) {
// 如果有 获取 类的注解名
String classAnnotationname = classAnnotation.value();
// baseUri 拼接上类的注解名
baseUri += classAnnotationname;
}
Object obj = aClass.newInstance();
// 拿到这些类,我们就获取其中所有的方法信息
Method[] methods = aClass.getMethods();
// 遍历 这些方法
for (Method method : methods) {
//判断 注解 其中被 @RequestMapping 修饰的方法
RequestMapping methodAnnotation = method.getDeclaredAnnotation(RequestMapping.class);
if (methodAnnotation != null) {
// 定义 方法上的 注解值
String value = methodAnnotation.value();
// 获取 最终结果 类名 + 方法名 + RequestMapping的 所有值
String requestUri = aClass.getName() + " -- " + method.getName() + " -- " + baseUri + value;
map.put(baseUri + value, new UrlMapping(obj, method));
}
}
}
return map;
}
public static UrlMapping getURLMapping(String url) {
return map.get(url);
}
// 测试 调用方法
public static void main(String[] args) throws IllegalAccessException, InvocationTargetException {
// 获取 被RequestMapping 从类 修饰到 方法 匹配到 /news/add 类和方法的信息
UrlMapping urlMapping = ClassUtils.getURLMapping("/news/add");
Method method = urlMapping.getMethod();
// 调用 获取到的类的信息, 准确的 有效的使用反射 进行调用方法!!!
method.invoke(urlMapping.getObj());
}
}
初步测试:
NewsController 执行了add方法
7、
引入 Servlet
<!-- 这里 封装了 反射的工具,我们一般 使用其中的 Reflections 对象 进行操作 -->
<dependency>
<groupId>org.reflections</groupId>
<artifactId>reflections</artifactId>
<version>0.9.11</version>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>4.0.1</version>
</dependency>
<dependency>
<groupId>javax.servlet.jsp</groupId>
<artifactId>javax.servlet.jsp-api</artifactId>
<version>2.3.3</version>
</dependency>
<dependency>
<groupId>javax.servlet.jsp.jstl</groupId>
<artifactId>jstl</artifactId>
<version>1.2</version>
</dependency>
8、创建 DispatcherSevlet
让其 继承于 HttpServlet 并重写 doGet、doPost 方法
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
/**
* @author : zanglikun
* @date : 2021/2/23 14:46
* @Version: 1.0
* @Desc : 配置 DispatcherServlet
*/
public class DispatcherServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
super.doGet(req, resp);
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 配置 所有请求都走 doGet 方法
// super.doPost(req, resp);
doGet(req,resp);
}
}
9、配置 Servlet
这里 强调 上述代码,使用的Tomcat 版本 是:apache-tomcat-8.5.31 ,经过 残忍的测试,长了教训,Tomcat 不同版本 ,支持的不同协议,以及实现方式 都发生变化。起码经过我测试,Tomcat10 就会报错
jakarta.servlet.ServletException: 类com.zanglikun.framework.servlet.DispatcherServlet不是Servlet
我们 学过 Java Web 都知道 Servlet 配置 有2 中方式 一个是 注解 @Servlet 另一个 是 webapps 下面的 WEB-INF 的 web.xml
DispatcherServlet
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
/**
* @author : zanglikun
* @date : 2021/2/23 14:46
* @Version: 1.0
* @Desc : 配置 DispatcherServlet
*/
public class DispatcherServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
System.out.println("doGet 方法 拦截到了:"+ req.getRequestURI());
super.doGet(req, resp);
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 配置 所有请求都走 doGet 方法
// super.doPost(req, resp);
doGet(req,resp);
}
}
因为 注解 形式,不好控制 他的初始化顺序,建议,使用 web.xml 进行控制。
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
version="4.0">
<!-- XML 按照 顺序 加载,优先加载上面的,下面不会覆盖上面的 -->
<!-- 在 servlet-mapping 中,当 servlet-name,相同时,url-pattern 必须不同 -->
<!-- 放行这里 一些前端的文件 为什么这样配置?理由:需要我们到 Tomcat的 源码 conf/web.xml查看一下 一个 叫 DefaultServlet 的 servlet
从命名 我们就能看出 默认的 servlet 同时 上面注释信息 写了:
这是个所有应用的默认servlet,他可以提供静态资源(放行),他处理所有 未映射 到其他服务上的映射
The default servlet for all web applications, that serves static resources.
It processes all requests that are not mapped to other servlets with servlet mappings
-->
<servlet-mapping>
<servlet-name>default</servlet-name>
<url-pattern>*.css</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>default</servlet-name>
<url-pattern>*.jpg</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>default</servlet-name>
<url-pattern>*.img</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>default</servlet-name>
<url-pattern>*.js</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>default</servlet-name>
<url-pattern>*.html</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>default</servlet-name>
<url-pattern>*.ico</url-pattern>
</servlet-mapping>
<!-- 首页 -->
<welcome-file-list>
<welcome-file>index.html</welcome-file>
<welcome-file>index.jpg</welcome-file>
</welcome-file-list>
<!-- 配置自己的解析器 -->
<servlet>
<servlet-name>DispatcherServlet</servlet-name>
<servlet-class>com.zanglikun.framework.servlet.DispatcherServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>DispatcherServlet</servlet-name>
<!-- 拦截所有 资源 -->
<!-- <url-pattern>/*</url-pattern> -->
<!-- 不拦截 .jsp 和 Servlet -->
<url-pattern>/</url-pattern>
</servlet-mapping>
</web-app>
访问 一些资源看看吧
10、配置 404、500 页面
我们需要修改我们的 DispatcherServlet
删除 doget 方法里的 super.doGet(req, resp);
修改 doget 方法立马的内容
最终结果如下:
package com.zanglikun.framework.servlet;
import com.zanglikun.framework.model.UrlMapping;
import com.zanglikun.framework.utils.ClassUtils;
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.Method;
/**
* @author : zanglikun
* @date : 2021/2/23 14:46
* @Version: 1.0
* @Desc : 配置 DispatcherServlet
*/
public class DispatcherServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 获取 用户请求的 相对路径
String replace = req.getRequestURI().replace(req.getContextPath(), "");
try {
req.setCharacterEncoding("utf-8");
resp.setContentType("text/html;charset=UTF-8");
System.out.println(replace);
// 调用我们的 工具类 通过 请求的相对路径 获取 需要执行操作 类的信息
UrlMapping urlMapping = ClassUtils.getURLMapping(replace);
// 人为 测试 制作服务端错误 500
//int i = 1/0;
// 如果 请求路径不存在
if (urlMapping == null) {
resp.setStatus(404);
resp.getWriter().write("请求路径不存在:<h1>404</h1> 请求路径是" + req.getRequestURI());
// 结束 下面代码执行
return;
}
Method method = urlMapping.getMethod();
Object obj = urlMapping.getObj();
// 执行方法
method.invoke(obj);
} catch (Exception e) {
// 向浏览器展示 消息 利用 HttpServletResponse 的枚举 SC_INTERNAL_SERVER_ERROR 其含义 代表 500
resp.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, "服务端 发生错误,请联系系统管理员 Tel :110 ");
/*
sendError 与 getWriter 同时 出现,会执行 sendError() 方法
resp.setStatus(500);
resp.getWriter().println("兄弟 500 错误了 <br>");
e.printStackTrace(resp.getWriter());
*/
// 控制台打印信息
e.printStackTrace();
}
//super.doGet(req, resp);
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 配置 所有请求都走 doGet 方法
// super.doPost(req, resp);
doGet(req, resp);
}
}
11、模拟一个框架不足点
首先 修改 NewsController 中 add()方法,我们要加入参数了
最终 add() 变为:
@RequestMapping("/add")
public void ADD(HttpServletRequest request, HttpServletResponse response){
System.out.println("request"+request);
System.out.println("response"+response);
//System.out.println("name"+name);
System.out.println("NewsController 执行了add方法");
}
我们重启服务器 再去访问 http://localhost:8080/news/add ,看下是什么结果
500 错误,我们去控制台看一下吧
参数数量 异常,这来自与哪里呢?我们联想,反射的时候,需要传递参数的,不能不传递参数调用。
异常 展示完成,请看接下来如何解决
12、解决 req 与 resp 传参问题
我们 去修改 DispatcherServlet 内容 新增 蓝色部分
import com.zanglikun.framework.model.UrlMapping;
import com.zanglikun.framework.utils.ClassUtils;
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.Method;
/**
* @author : zanglikun
* @date : 2021/2/23 14:46
* @Version: 1.0
* @Desc : 配置 DispatcherServlet
*/
public class DispatcherServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 获取 用户请求的 相对路径
String replace = req.getRequestURI().replace(req.getContextPath(), "");
try {
req.setCharacterEncoding("utf-8");
resp.setContentType("text/html;charset=UTF-8");
System.out.println(replace);
// 调用我们的 工具类 通过 请求的相对路径 获取 需要执行操作 类的信息
UrlMapping urlMapping = ClassUtils.getURLMapping(replace);
// 人为 测试 制作服务端错误 500
//int i = 1/0;
// 如果 请求路径不存在
if (urlMapping == null) {
resp.getWriter().write("请求路径不存在:<h1>404</h1> 请求路径是" + req.getRequestURI());
// 结束 下面代码执行
return;
}
Method method = urlMapping.getMethod();
Object obj = urlMapping.getObj();
// 获取方法上参数类型
Class<?>[] paramTypes = method.getParameterTypes();
// 创建 数组 将来放参数的地方
Object[] argurments = new Object[paramTypes.length];
// 定义一个 下标
int index = 0;
// 遍历一下 获取方法参数
for (Class<?> parameterType : paramTypes) {
// 如果是 HttpServletRequest 对象 就放进去 doGet的 req
if(parameterType == HttpServletRequest.class){
argurments[index] = req;
}
// 如果是 HttpServletResponse 对象 就放进去 doGet的 resp
else if(parameterType == HttpServletResponse.class){
argurments[index] = resp;
}else {
// 这里 是处理 其他参数的
argurments[index] = null;
}
// 相当于 for循环 的i
index++;
}
System.out.println(argurments.length);
// 执行方法
method.invoke(obj,argurments);
} catch (Exception e) {
// 向浏览器展示 消息 利用 HttpServletResponse 的枚举 SC_INTERNAL_SERVER_ERROR 其含义 代表 500
resp.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, "服务端 发生错误,请联系系统管理员 Tel :110 ");
/*
sendError 与 getWriter 同时 出现,会执行 sendError() 方法
resp.setStatus(500);
resp.getWriter().println("兄弟 500 错误了 <br>");
e.printStackTrace(resp.getWriter());
*/
// 控制台打印信息
e.printStackTrace();
}
//super.doGet(req, resp);
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 配置 所有请求都走 doGet 方法
// super.doPost(req, resp);
doGet(req, resp);
}
}
我们去测试 访问
http://localhost:8080/news/add
http://localhost:8080/news/del
控制台正常输出,通过
其实 这里 还有小问题,我们正常处理的是 req 和 resp 对象传递,其他参数,就无法处理。我们留着下面解决
13、根据 方法返回值进行 请求转发 与 重定向
通过方法的返回值,决定是请求转发,还是重定向,请求到那个路径上
在WEB-INF下面创建jsp页面 创建 news_del.jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>news_del</title>
</head>
<body>
我是 news_del 请求转发成功
</body>
</html>
修改 NewsController 的 ADD、DEL 方法 新增返回值 最终结果如下
@RequestMapping("/add")
public String ADD(HttpServletRequest request, HttpServletResponse response){
System.out.println("request"+request);
System.out.println("response"+response);
//System.out.println("name"+name);
System.out.println("NewsController 执行了add方法");
return "redirect:/indexA.html";
}
@RequestMapping("/del")
public String DEL(){
System.out.println("NewsController 执行了del方法");
return "news_del";
}
最后还是要修改 DispatcherServlet
import com.zanglikun.framework.model.UrlMapping;
import com.zanglikun.framework.utils.ClassUtils;
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.Method;
/**
* @author : zanglikun
* @date : 2021/2/23 14:46
* @Version: 1.0
* @Desc : 配置 DispatcherServlet
*/
public class DispatcherServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 获取 用户请求的 相对路径
String replace = req.getRequestURI().replace(req.getContextPath(), "");
try {
req.setCharacterEncoding("utf-8");
resp.setContentType("text/html;charset=UTF-8");
System.out.println(replace);
// 调用我们的 工具类 通过 请求的相对路径 获取 需要执行操作 类的信息
UrlMapping urlMapping = ClassUtils.getURLMapping(replace);
// 人为 测试 制作服务端错误 500
//int i = 1/0;
// 如果 请求路径不存在
if (urlMapping == null) {
resp.setStatus(404);
resp.getWriter().write("请求路径不存在:<h1>404</h1> 请求路径是" + req.getRequestURI());
// 结束 下面代码执行
return;
}
Method method = urlMapping.getMethod();
Object obj = urlMapping.getObj();
// 获取方法上参数类型
Class<?>[] paramTypes = method.getParameterTypes();
// 创建 数组 将来放参数的地方
Object[] argurments = new Object[paramTypes.length];
// 定义一个 下标
int index = 0;
// 遍历一下 获取方法参数
for (Class<?> parameterType : paramTypes) {
// 如果是 HttpServletRequest 对象 就放进去 doGet的 req
if (parameterType == HttpServletRequest.class) {
argurments[index] = req;
}
// 如果是 HttpServletResponse 对象 就放进去 doGet的 resp
else if (parameterType == HttpServletResponse.class) {
argurments[index] = resp;
} else {
// 这里 是处理 其他参数的
argurments[index] = null;
}
// 相当于 for循环 的i
index++;
}
System.out.println(argurments.length);
// 执行方法
Object result = method.invoke(obj, argurments);
// 如果方法有返回值
if (result != null) {
// 判断是不是 String
if (result instanceof String) {
String viewname = (String) result;
// 如果是重定向,走 重定向
if (viewname.startsWith("redirect:")) {
// 重定向 路径拼接 并发送重定向
// 这里有个 小Bug 没有 处理Https 协议,以及内外部资源 我们为了更好的处理,我们直接默认http 以及内部资源
System.out.println(viewname.replace("redirect:", ""));
resp.sendRedirect(viewname.replace("redirect:", ""));
}
// 如果 是重定向 那就走 重定向
else {
// 确保你的文件,在/WEB-INF/ 下 而不是 webapp 下 切记 我调试了 1个多小时,跳转不了,最后发现路径错了
req.getRequestDispatcher("/WEB-INF/jsp/" + viewname + ".jsp").forward(req,resp);
}
}
// 如果 返回 不是 String 类型的 我们回头在处理
else {
}
}
} catch (Exception e) {
// 向浏览器展示 消息 利用 HttpServletResponse 的枚举 SC_INTERNAL_SERVER_ERROR 其含义 代表 500
resp.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, "服务端 发生错误,请联系系统管理员 Tel :110 ");
/*
sendError 与 getWriter 同时 出现,会执行 sendError() 方法
resp.setStatus(500);
resp.getWriter().println("兄弟 500 错误了 <br>");
e.printStackTrace(resp.getWriter());
*/
// 控制台打印信息
e.printStackTrace();
}
//super.doGet(req, resp);
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 配置 所有请求都走 doGet 方法
// super.doPost(req, resp);
doGet(req, resp);
}
}
14 返回结果是Json : 响应到 浏览器上
引入阿里巴巴的 fastJson
<!-- FastJson -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.67</version>
</dependency>
继续 看:DispatcherServlet
import com.alibaba.fastjson.JSON;
import com.zanglikun.framework.model.UrlMapping;
import com.zanglikun.framework.utils.ClassUtils;
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.Method;
/**
* @author : zanglikun
* @date : 2021/2/23 14:46
* @Version: 1.0
* @Desc : 配置 DispatcherServlet
*/
public class DispatcherServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 获取 用户请求的 相对路径
String replace = req.getRequestURI().replace(req.getContextPath(), "");
try {
req.setCharacterEncoding("utf-8");
resp.setContentType("text/html;charset=UTF-8");
System.out.println(replace);
// 调用我们的 工具类 通过 请求的相对路径 获取 需要执行操作 类的信息
UrlMapping urlMapping = ClassUtils.getURLMapping(replace);
// 人为 测试 制作服务端错误 500
//int i = 1/0;
// 如果 请求路径不存在
if (urlMapping == null) {
resp.setStatus(404);
resp.getWriter().write("请求路径不存在:<h1>404</h1> 请求路径是" + req.getRequestURI());
// 结束 下面代码执行
return;
}
Method method = urlMapping.getMethod();
Object obj = urlMapping.getObj();
// 获取方法上参数类型
Class<?>[] paramTypes = method.getParameterTypes();
// 创建 数组 将来放参数的地方
Object[] argurments = new Object[paramTypes.length];
// 定义一个 下标
int index = 0;
// 遍历一下 获取方法参数
for (Class<?> parameterType : paramTypes) {
// 如果是 HttpServletRequest 对象 就放进去 doGet的 req
if (parameterType == HttpServletRequest.class) {
argurments[index] = req;
}
// 如果是 HttpServletResponse 对象 就放进去 doGet的 resp
else if (parameterType == HttpServletResponse.class) {
argurments[index] = resp;
} else {
// 这里 是处理 其他参数的
argurments[index] = null;
}
// 相当于 for循环 的i
index++;
}
System.out.println(argurments.length);
// 执行方法
Object modelview = method.invoke(obj, argurments);
// 如果方法有返回值
if (modelview != null) {
// 判断是不是 String
if (modelview instanceof String) {
String viewname = (String) modelview;
// 如果是重定向,走 重定向
if (viewname.startsWith("redirect:")) {
// 重定向 路径拼接 并发送重定向
// 这里有个 小Bug 没有 处理Https 协议,以及内外部资源 我们为了更好的处理,我们直接默认http 以及内部资源
System.out.println(viewname.replace("redirect:", ""));
resp.sendRedirect(viewname.replace("redirect:", ""));
}
// 如果 是重定向 那就走 重定向
else {
// 确保你的文件,在/WEB-INF/ 下 而不是 webapp 下 切记 我调试了 1个多小时,跳转不了,最后发现路径错了
req.getRequestDispatcher("/WEB-INF/jsp/" + viewname + ".jsp").forward(req, resp);
}
}
// 如果 返回 不是 String 类型的 我们现在处理 :按照Json 进行处理
// 1、修改 result 更名未 modelview
else {
resp.setContentType("application/json;charset=UTF-8");
// modelview 调用 阿里的 fastJson 转为 Json 打印在浏览器上
resp.getWriter().write(JSON.toJSONString(modelview).toString());
}
}
} catch (Exception e) {
// 向浏览器展示 消息 利用 HttpServletResponse 的枚举 SC_INTERNAL_SERVER_ERROR 其含义 代表 500
resp.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, "服务端 发生错误,请联系系统管理员 Tel :110 ");
/*
sendError 与 getWriter 同时 出现,会执行 sendError() 方法
resp.setStatus(500);
resp.getWriter().println("兄弟 500 错误了 <br>");
e.printStackTrace(resp.getWriter());
*/
// 控制台打印信息
e.printStackTrace();
}
//super.doGet(req, resp);
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 配置 所有请求都走 doGet 方法
// super.doPost(req, resp);
doGet(req, resp);
}
}
修改 NewsController 的 Get 方法
@RequestMapping("/get")
public Map<String,Object> GET(){
System.out.println("NewsController 执行了get方法");
Map<String,Object> map = new HashMap<>();
map.put("姓名","张三");
map.put("年龄","80");
map.put("爱好",new String[]{"抽烟","喝酒","烫头"});
return map;
}
启动测试:http://localhost:8080/news/get
测试 Json 处理 成功
15、映射其他基本类型参数
首先,原生的JDK 反射包 获取不到参数名称,能获取参数类型
所以 我们 还需要引入 新的java类库 javassist 以获取 参数 名称 方便 将来 参数做映射
时间类型 :只处理 JDK 1.8 新的时间类型,更在的JDK时间类型,不处理。并且,将来框架只支持JDK1.8
<!-- 利用反射获取 方法的参数名称 因为原生JDK 无法获取参数的名称 -->
<dependency>
<groupId>org.javassist</groupId>
<artifactId>javassist</artifactId>
<version>3.27.0-GA</version>
</dependency>
我们 修改 UrlMapping 新增加新的字段
private Map<String,Class<?>> parameter;
重写 get set 构造方法
ClassUtils 更变为
import com.zanglikun.framework.annoation.Controller;
import com.zanglikun.framework.annoation.RequestMapping;
import com.zanglikun.framework.model.UrlMapping;
import javassist.*;
import javassist.bytecode.CodeAttribute;
import javassist.bytecode.LocalVariableAttribute;
import javassist.bytecode.MethodInfo;
import org.reflections.Reflections;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
/**
* @author : zanglikun
* @date : 2021/2/23 13:27
* @Version: 1.0
* @Desc : 费劲,没啥好说的
*/
public class ClassUtils {
// 创建 收集数据的对象
private static Map<String, UrlMapping> map = new HashMap<>();
static {
try {
getUrlMappings("com.zanglikun");
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
} catch (NotFoundException e) {
e.printStackTrace();
}
}
// 私有静态 代码块的方式,保证了 扫描 所有类的 注解、方法 信息 只执行一次
// 传递 一个 基础的 包名
private static Map<String, UrlMapping> getUrlMappings(String basePackageName) throws IllegalAccessException, InstantiationException, InvocationTargetException, NotFoundException {
// 创建反射对象,
Reflections reflections = new Reflections(basePackageName);
// 获取 被 @Controller 修饰的对象的字节码信息
Set<Class<?>> classes = reflections.getTypesAnnotatedWith(Controller.class);
// 遍历 这些 类的字节码信息
for (Class<?> aClass : classes) {
// 判断 类上有 @RequestMapping 注解的 类
RequestMapping classAnnotation = aClass.getDeclaredAnnotation(RequestMapping.class);
// 定义 类上的 注解 值
String baseUri = "";
// 判断 是否有这个对象
if (classAnnotation != null) {
// 如果有 获取 类的注解名
String classAnnotationname = classAnnotation.value();
// baseUri 拼接上类的注解名
baseUri += classAnnotationname;
}
Object obj = aClass.newInstance();
// 拿到这些类,我们就获取其中所有的方法信息
Method[] methods = aClass.getMethods();
// 遍历 这些方法
for (Method method : methods) {
//判断 注解 其中被 @RequestMapping 修饰的方法
RequestMapping methodAnnotation = method.getDeclaredAnnotation(RequestMapping.class);
// 如果有被标注的方法
if (methodAnnotation != null) {
// 定义 方法上的 注解值
String value = methodAnnotation.value();
// 获取 最终结果 类名 + 方法名 + RequestMapping的 所有值
String requestUri = aClass.getName() + " -- " + method.getName() + " -- " + baseUri + value;
// 获取 新对象信息 即 方法参数 名字
ClassPool classPool = ClassPool.getDefault();
classPool.insertClassPath(new ClassClassPath(aClass));
CtMethod cm = classPool.getMethod(aClass.getName(), method.getName());
MethodInfo methodInfo = cm.getMethodInfo();
CodeAttribute codeAttribute = methodInfo.getCodeAttribute();
LocalVariableAttribute attribute =
(LocalVariableAttribute) codeAttribute.getAttribute(LocalVariableAttribute.tag);
// 我们需要定义一个集合,收取 参数名称、类型 等信息因为参数有顺序,我们K 防止 参数名称,Value 防止参数类型
Map<String,Class<?>> parameters = new LinkedHashMap<>();
Class<?>[] classTYPE = method.getParameterTypes();
if (attribute != null) {
int pos = Modifier.isStatic(cm.getModifiers()) ? 0 : 1;
for (int i = 0; i < method.getParameterCount(); i++) {
String argName = attribute.variableName(i + pos);
//System.out.println(argName);
parameters.put(argName,classTYPE[i]);
}
}
map.put(baseUri + value, new UrlMapping(obj, method,parameters));
}
}
}
return map;
}
public static UrlMapping getURLMapping(String url) {
return map.get(url);
}
// 测试 调用方法
public static void main(String[] args) throws IllegalAccessException, InvocationTargetException {
// 获取 被RequestMapping 从类 修饰到 方法 匹配到 /news/add 类和方法的信息
UrlMapping urlMapping = ClassUtils.getURLMapping("/news/add");
Method method = urlMapping.getMethod();
// 调用 获取到的类的信息, 准确的 有效的使用反射 进行调用方法!!!
method.invoke(urlMapping.getObj());
}
}
DispatcherServlet 更变为
import com.alibaba.fastjson.JSON;
import com.zanglikun.framework.model.UrlMapping;
import com.zanglikun.framework.utils.ClassUtils;
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.Method;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.Map;
/**
* @author : zanglikun
* @date : 2021/2/23 14:46
* @Version: 1.0
* @Desc : 配置 DispatcherServlet
*/
public class DispatcherServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 获取 用户请求的 相对路径
String replace = req.getRequestURI().replace(req.getContextPath(), "");
try {
req.setCharacterEncoding("utf-8");
resp.setContentType("text/html;charset=UTF-8");
System.out.println(replace);
// 调用我们的 工具类 通过 请求的相对路径 获取 需要执行操作 类的信息
UrlMapping urlMapping = ClassUtils.getURLMapping(replace);
// 人为 测试 制作服务端错误 500
//int i = 1/0;
// 如果 请求路径不存在
if (urlMapping == null) {
resp.setStatus(404);
resp.getWriter().write("请求路径不存在:<h1>404</h1> 请求路径是" + req.getRequestURI());
// 结束 下面代码执行
return;
}
Method method = urlMapping.getMethod();
Object obj = urlMapping.getObj();
Map<String, Class<?>> parameters = urlMapping.getParameter();
// 创建 数组 将来放参数的地方
Object[] argurments = new Object[method.getParameterTypes().length];
// 定义一个 下标
int index = 0;
for (String key : parameters.keySet()) {
// 请求的参数名称是 key
// 请求参数 的类型
Class<?> parameterType = parameters.get(key);
// 如果是 HttpServletRequest 对象 就放进去 doGet的 req
if (parameterType == HttpServletRequest.class) {
argurments[index] = req;
}
// 如果是 HttpServletResponse 对象 就放进去 doGet的 resp
else if (parameterType == HttpServletResponse.class) {
argurments[index] = resp;
} else {
String parameter = req.getParameter(key);
if (parameter != null) {
// 这里 是处理 8大基本类型 与String 利用请求参数类型与 方法参数类型进行匹配 成功就赋值
try {
if (parameterType == java.lang.String.class) {
argurments[index] = parameter;
} else if (parameterType == java.lang.Integer.class) {
argurments[index] = Integer.parseInt(parameter);
} else if (parameterType == java.lang.Double.class) {
argurments[index] = Double.parseDouble(parameter);
} else if (parameterType == java.lang.Float.class) {
argurments[index] = Float.parseFloat(parameter);
} else if (parameterType == java.lang.Short.class) {
argurments[index] = Short.parseShort(parameter);
} else if (parameterType == java.lang.Byte.class) {
argurments[index] = Byte.parseByte(parameter);
} else if (parameterType == java.lang.Long.class) {
argurments[index] = Long.parseLong(parameter);
} else if (parameterType == java.lang.Character.class) {
argurments[index] = parameter.toCharArray()[0];
} else if (parameterType == java.lang.Boolean.class) {
argurments[index] = Boolean.parseBoolean(parameter);
} else if (parameterType == java.time.LocalDate.class) {
argurments[index] = LocalDate.parse(parameter, DateTimeFormatter.ofPattern("yyyy-MM-dd"));
} else if (parameterType == java.time.LocalDateTime.class) {
argurments[index] = LocalDateTime.parse(parameter,DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
}
else {
// 非 Java 基本类型 和 String 类型 在这处理
argurments[index] = null;
}
} catch (Exception e) {
// 这里 可能会出现 类型转换异常
e.printStackTrace();
argurments[index] = null;
}
} else {
argurments[index] = null;
}
}
// 相当于 for循环 的i
index++;
}
// 执行方法
Object modelview = method.invoke(obj, argurments);
// 如果方法有返回值
if (modelview != null) {
// 判断是不是 String
if (modelview instanceof String) {
String viewname = (String) modelview;
// 如果是重定向,走 重定向
if (viewname.startsWith("redirect:")) {
// 重定向 路径拼接 并发送重定向
// 这里有个 小Bug 没有 处理Https 协议,以及内外部资源 我们为了更好的处理,我们直接默认http 以及内部资源
resp.sendRedirect(viewname.replace("redirect:", ""));
}
// 如果 是重定向 那就走 重定向
else {
// 确保你的文件,在/WEB-INF/ 下 而不是 webapp 下 切记 我调试了 1个多小时,跳转不了,最后发现路径错了
req.getRequestDispatcher("/WEB-INF/jsp/" + viewname + ".jsp").forward(req, resp);
}
}
// 如果 返回 不是 String 类型的 我们现在处理 :按照Json 进行处理
// 1、修改 result 更名未 modelview
else {
resp.setContentType("application/json;charset=UTF-8");
// modelview 调用 阿里的 fastJson 转为 Json 打印在浏览器上
resp.getWriter().write(JSON.toJSONString(modelview).toString());
}
}
} catch (Exception e) {
// 向浏览器展示 消息 利用 HttpServletResponse 的枚举 SC_INTERNAL_SERVER_ERROR 其含义 代表 500
resp.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, "服务端 发生错误,请联系系统管理员 Tel :110 ");
/*
sendError 与 getWriter 同时 出现,会执行 sendError() 方法
resp.setStatus(500);
resp.getWriter().println("兄弟 500 错误了 <br>");
e.printStackTrace(resp.getWriter());
*/
// 控制台打印信息
e.printStackTrace();
}
//super.doGet(req, resp);
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 配置 所有请求都走 doGet 方法
// super.doPost(req, resp);
doGet(req, resp);
}
}
测试
新写一个 DispatcherServlet 下的 put方法
@RequestMapping("/put")
public Map<String,Object> PUT(String string, Boolean bo, Short s, Byte by, Long l, Float f, Double d, Character c, Integer i, LocalDate localDate, LocalDateTime localDateTime){
System.out.println("NewsController 执行了PUT方法");
Map<String,Object> map = new HashMap<>();
map.put("String",string);
map.put("Boolean",bo);
map.put("Short",s);
map.put("Byte",by);
map.put("Long",l);
map.put("Float",f);
map.put("Double",d);
map.put("Character",c);
map.put("Integer",i);
map.put("LocalDate",localDate);
map.put("LocalDateTime",localDateTime);
return map;
}
浏览器发送请求,测试:
结果:
所有参数均获取
成功
16、处理 普通对象 类型
引入beanUtils
<!-- -->
<dependency>
<groupId>commons-beanutils</groupId>
<artifactId>commons-beanutils</artifactId>
<version>1.9.4</version>
</dependency>
NewsController 新增 HEAD 方法
@RequestMapping("/head")
public Map<String,Object> HEAD(News news){
System.out.println("NewsController 执行了head方法");
Map<String,Object> map = new HashMap<>();
if(news != null){
map.put("ID",news.getId());
map.put("Title",news.getTitle());
map.put("LocalDate",news.getLocalDate());
map.put("LocalDateTine",news.getLocalDateTime());
}
return map;
}
在model 创建实体类 News
import java.time.LocalDate;
import java.time.LocalDateTime;
/**
* @author : zanglikun
* @date : 2021/2/25 15:44
* @Version: 1.0
* @Desc : 新闻测试类
*/
public class News {
private Integer id;
private String title;
private LocalDate localDate;
private LocalDateTime localDateTime;
public News() {
}
public News(Integer id, String title, LocalDate localDate, LocalDateTime localDateTime) {
this.id = id;
this.title = title;
this.localDate = localDate;
this.localDateTime = localDateTime;
}
public LocalDate getLocalDate() {
return localDate;
}
public void setLocalDate(LocalDate localDate) {
this.localDate = localDate;
}
public LocalDateTime getLocalDateTime() {
return localDateTime;
}
public void setLocalDateTime(LocalDateTime localDateTime) {
this.localDateTime = localDateTime;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
}
创建 时间转换工具类 DateTimeConverter
import org.apache.commons.beanutils.Converter;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
/**
* @author : zanglikun
* @date : 2021/2/25 16:43
* @Version: 1.0
* @Desc : 费劲,没啥好说的
*/
public class DateTimeConverter implements Converter {
// 重写方法
@Override
public Object convert(Class aClass, Object o) {
if (o == null || "".equals(o)){
return null;
}
if (o instanceof java.lang.String){
String value = o.toString().trim();
if(aClass.equals(LocalDate.class)){
DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
return LocalDate.parse(value,dateTimeFormatter);
}
if(aClass.equals(LocalDateTime.class)){
DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
return LocalDateTime.parse(value,dateTimeFormatter);
}
}
return o;
}
}
新增 DispatcherServlet
package com.zanglikun.framework.servlet;
import com.alibaba.fastjson.JSON;
import com.zanglikun.framework.model.UrlMapping;
import com.zanglikun.framework.utils.ClassUtils;
import com.zanglikun.framework.utils.DateTimeConverter;
import org.apache.commons.beanutils.BeanUtils;
import org.apache.commons.beanutils.ConvertUtils;
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.Method;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.Map;
/**
* @author : zanglikun
* @date : 2021/2/23 14:46
* @Version: 1.0
* @Desc : 配置 DispatcherServlet
*/
public class DispatcherServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 获取 用户请求的 相对路径
String replace = req.getRequestURI().replace(req.getContextPath(), "");
try {
req.setCharacterEncoding("utf-8");
resp.setContentType("text/html;charset=UTF-8");
System.out.println(replace);
// 调用我们的 工具类 通过 请求的相对路径 获取 需要执行操作 类的信息
UrlMapping urlMapping = ClassUtils.getURLMapping(replace);
// 人为 测试 制作服务端错误 500
//int i = 1/0;
// 如果 请求路径不存在
if (urlMapping == null) {
resp.setStatus(404);
resp.getWriter().write("请求路径不存在:<h1>404</h1> 请求路径是" + req.getRequestURI());
// 结束 下面代码执行
return;
}
Method method = urlMapping.getMethod();
Object obj = urlMapping.getObj();
Map<String, Class<?>> parameters = urlMapping.getParameter();
// 创建 数组 将来放参数的地方
Object[] argurments = new Object[method.getParameterTypes().length];
// 定义一个 下标
int index = 0;
for (String key : parameters.keySet()) {
// 请求的参数名称是 key
// 请求参数 的类型
Class<?> parameterType = parameters.get(key);
// 如果是 HttpServletRequest 对象 就放进去 doGet的 req
if (parameterType == HttpServletRequest.class) {
argurments[index] = req;
}
// 如果是 HttpServletResponse 对象 就放进去 doGet的 resp
else if (parameterType == HttpServletResponse.class) {
argurments[index] = resp;
} else {
// 用方法名 获取 方法参数 与请求参数进行匹配
String parameter = req.getParameter(key);
if (parameter != null) {
// 这里 是处理 8大基本类型 与String 利用请求参数类型与 方法参数类型进行匹配 成功就赋值
try {
if (parameterType == java.lang.String.class) {
argurments[index] = parameter;
} else if (parameterType == java.lang.Integer.class) {
argurments[index] = Integer.parseInt(parameter);
} else if (parameterType == java.lang.Double.class) {
argurments[index] = Double.parseDouble(parameter);
} else if (parameterType == java.lang.Float.class) {
argurments[index] = Float.parseFloat(parameter);
} else if (parameterType == java.lang.Short.class) {
argurments[index] = Short.parseShort(parameter);
} else if (parameterType == java.lang.Byte.class) {
argurments[index] = Byte.parseByte(parameter);
} else if (parameterType == java.lang.Long.class) {
argurments[index] = Long.parseLong(parameter);
} else if (parameterType == java.lang.Character.class) {
argurments[index] = parameter.toCharArray()[0];
} else if (parameterType == java.lang.Boolean.class) {
argurments[index] = Boolean.parseBoolean(parameter);
} else if (parameterType == java.time.LocalDate.class) {
argurments[index] = LocalDate.parse(parameter, DateTimeFormatter.ofPattern("yyyy-MM-dd"));
} else if (parameterType == java.time.LocalDateTime.class) {
argurments[index] = LocalDateTime.parse(parameter,DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
}
else {
argurments[index] = parameter;
}
} catch (Exception e) {
// 这里 可能会出现 类型转换异常
e.printStackTrace();
argurments[index] = null;
}
} else {
// 处理 Java Bean 对象
try {
Object paramObj = parameterType.newInstance();
BeanUtils.populate(paramObj,req.getParameterMap());
argurments[index] = paramObj;
}catch (Exception e){
e.printStackTrace();
argurments[index] = null;
}
}
}
// 相当于 for循环 的i
index++;
}
// 执行方法
Object modelview = method.invoke(obj, argurments);
// 如果方法有返回值
if (modelview != null) {
// 判断是不是 String
if (modelview instanceof String) {
String viewname = (String) modelview;
// 如果是重定向,走 重定向
if (viewname.startsWith("redirect:")) {
// 重定向 路径拼接 并发送重定向
// 这里有个 小Bug 没有 处理Https 协议,以及内外部资源 我们为了更好的处理,我们直接默认http 以及内部资源
resp.sendRedirect(viewname.replace("redirect:", ""));
}
// 如果 是重定向 那就走 重定向
else {
// 确保你的文件,在/WEB-INF/ 下 而不是 webapp 下 切记 我调试了 1个多小时,跳转不了,最后发现路径错了
req.getRequestDispatcher("/WEB-INF/jsp/" + viewname + ".jsp").forward(req, resp);
}
}
// 如果 返回 不是 String 类型的 我们现在处理 :按照Json 进行处理
// 1、修改 result 更名未 modelview
else {
resp.setContentType("application/json;charset=UTF-8");
// modelview 调用 阿里的 fastJson 转为 Json 打印在浏览器上
resp.getWriter().write(JSON.toJSONString(modelview).toString());
}
}
} catch (Exception e) {
// 向浏览器展示 消息 利用 HttpServletResponse 的枚举 SC_INTERNAL_SERVER_ERROR 其含义 代表 500
resp.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, "服务端 发生错误,请联系系统管理员 Tel :110 ");
/*
sendError 与 getWriter 同时 出现,会执行 sendError() 方法
resp.setStatus(500);
resp.getWriter().println("兄弟 500 错误了 <br>");
e.printStackTrace(resp.getWriter());
*/
// 控制台打印信息
e.printStackTrace();
}
//super.doGet(req, resp);
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 配置 所有请求都走 doGet 方法
// super.doPost(req, resp);
doGet(req, resp);
}
}
ClassUtils 更变为:
import com.zanglikun.framework.annoation.Controller;
import com.zanglikun.framework.annoation.RequestMapping;
import com.zanglikun.framework.model.UrlMapping;
import javassist.*;
import javassist.bytecode.CodeAttribute;
import javassist.bytecode.LocalVariableAttribute;
import javassist.bytecode.MethodInfo;
import org.apache.commons.beanutils.ConvertUtils;
import org.reflections.Reflections;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
/**
* @author : zanglikun
* @date : 2021/2/23 13:27
* @Version: 1.0
* @Desc : 费劲,没啥好说的
*/
public class ClassUtils {
// 创建 收集数据的对象
private static Map<String, UrlMapping> map = new HashMap<>();
static {
try {
// 注册时间解析
ConvertUtils.register(new DateTimeConverter(), LocalDate.class);
ConvertUtils.register(new DateTimeConverter(), LocalDateTime.class);
getUrlMappings("com.zanglikun");
} catch (Exception e) {
e.printStackTrace();
}
}
// 私有静态 代码块的方式,保证了 扫描 所有类的 注解、方法 信息 只执行一次
// 传递 一个 基础的 包名
private static Map<String, UrlMapping> getUrlMappings(String basePackageName) throws IllegalAccessException, InstantiationException, InvocationTargetException, NotFoundException {
// 创建反射对象,
Reflections reflections = new Reflections(basePackageName);
// 获取 被 @Controller 修饰的对象的字节码信息
Set<Class<?>> classes = reflections.getTypesAnnotatedWith(Controller.class);
// 遍历 这些 类的字节码信息
for (Class<?> aClass : classes) {
// 判断 类上有 @RequestMapping 注解的 类
RequestMapping classAnnotation = aClass.getDeclaredAnnotation(RequestMapping.class);
// 定义 类上的 注解 值
String baseUri = "";
// 判断 是否有这个对象
if (classAnnotation != null) {
// 如果有 获取 类的注解名
String classAnnotationname = classAnnotation.value();
// baseUri 拼接上类的注解名
baseUri += classAnnotationname;
}
Object obj = aClass.newInstance();
// 拿到这些类,我们就获取其中所有的方法信息
Method[] methods = aClass.getMethods();
// 遍历 这些方法
for (Method method : methods) {
//判断 注解 其中被 @RequestMapping 修饰的方法
RequestMapping methodAnnotation = method.getDeclaredAnnotation(RequestMapping.class);
// 如果有被标注的方法
if (methodAnnotation != null) {
// 定义 方法上的 注解值
String value = methodAnnotation.value();
// 获取 最终结果 类名 + 方法名 + RequestMapping的 所有值
String requestUri = aClass.getName() + " -- " + method.getName() + " -- " + baseUri + value;
// 获取 新对象信息 即 方法参数 名字
ClassPool classPool = ClassPool.getDefault();
classPool.insertClassPath(new ClassClassPath(aClass));
CtMethod cm = classPool.getMethod(aClass.getName(), method.getName());
MethodInfo methodInfo = cm.getMethodInfo();
CodeAttribute codeAttribute = methodInfo.getCodeAttribute();
LocalVariableAttribute attribute =
(LocalVariableAttribute) codeAttribute.getAttribute(LocalVariableAttribute.tag);
// 我们需要定义一个集合,收取 参数名称、类型 等信息因为参数有顺序,我们K 防止 参数名称,Value 防止参数类型
Map<String,Class<?>> parameters = new LinkedHashMap<>();
Class<?>[] classTYPE = method.getParameterTypes();
if (attribute != null) {
int pos = Modifier.isStatic(cm.getModifiers()) ? 0 : 1;
for (int i = 0; i < method.getParameterCount(); i++) {
String argName = attribute.variableName(i + pos);
//System.out.println(argName);
parameters.put(argName,classTYPE[i]);
}
}
map.put(baseUri + value, new UrlMapping(obj, method,parameters));
}
}
}
return map;
}
public static UrlMapping getURLMapping(String url) {
return map.get(url);
}
// 测试 调用方法
public static void main(String[] args) throws IllegalAccessException, InvocationTargetException {
// 获取 被RequestMapping 从类 修饰到 方法 匹配到 /news/add 类和方法的信息
UrlMapping urlMapping = ClassUtils.getURLMapping("/news/add");
Method method = urlMapping.getMethod();
// 调用 获取到的类的信息, 准确的 有效的使用反射 进行调用方法!!!
method.invoke(urlMapping.getObj());
}
}
测试
http://localhost:8080/news/head?id=1&title=张三&localDate=2020-01-01&localDateTime=2020-01-01 01:01:01
结果:
成功
17、代码优化
因为 serlvet 只有在访问的时候 ClassUtils才会初始化。故 ClassUtils 需要提前加载
重写 DispatcherServlet 重写的 init(ServletConfig config) 方法
同时 我们提升DispatcherServlet加载时间,让其随着类加载而加载 ,
记录能处理的类型,不能处理 统一以 Java类型处理
修改 ClassUtils的代码,删除很多内容
import com.zanglikun.framework.annoation.Controller;
import com.zanglikun.framework.annoation.RequestMapping;
import com.zanglikun.framework.model.UrlMapping;
import javassist.*;
import javassist.bytecode.CodeAttribute;
import javassist.bytecode.LocalVariableAttribute;
import javassist.bytecode.MethodInfo;
import org.reflections.Reflections;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
/**
* @author : zanglikun
* @date : 2021/2/23 13:27
* @Version: 1.0
* @Desc : ClassUtils 扫描我们自定义注解的类 和 方法
*/
public class ClassUtils {
// 创建 收集数据的对象
private static Map<String, UrlMapping> map = new HashMap<>();
/** 此方法 用于扫描被 Controller 和 RequestMapping 类和方法的 集合,将来可以用来判断 */
public static Map<String, UrlMapping> getUrlMappings(String basePackageName) throws IllegalAccessException, InstantiationException, NotFoundException {
// 创建反射对象,
Reflections reflections = new Reflections(basePackageName);
// 获取 被 @Controller 修饰的对象的字节码信息
Set<Class<?>> classes = reflections.getTypesAnnotatedWith(Controller.class);
// 遍历 这些 类的字节码信息
for (Class<?> aClass : classes) {
// 判断 类上有 @RequestMapping 注解的 类
RequestMapping classAnnotation = aClass.getDeclaredAnnotation(RequestMapping.class);
// 定义 类上的 注解 值
String baseUri = "";
// 判断 是否有这个对象
if (classAnnotation != null) {
// 如果有 获取 类的注解名
String classAnnotationname = classAnnotation.value();
// baseUri 拼接上类的注解名
baseUri += classAnnotationname;
}
Object obj = aClass.newInstance();
// 拿到这些类,我们就获取其中所有的方法信息
Method[] methods = aClass.getMethods();
// 遍历 这些方法
for (Method method : methods) {
//判断 注解 其中被 @RequestMapping 修饰的方法
RequestMapping methodAnnotation = method.getDeclaredAnnotation(RequestMapping.class);
// 如果有被标注的方法
if (methodAnnotation != null) {
// 定义 方法上的 注解值
String value = methodAnnotation.value();
// 获取 新对象信息 即 方法参数 名字
ClassPool classPool = ClassPool.getDefault();
classPool.insertClassPath(new ClassClassPath(aClass));
CtMethod cm = classPool.getMethod(aClass.getName(), method.getName());
MethodInfo methodInfo = cm.getMethodInfo();
CodeAttribute codeAttribute = methodInfo.getCodeAttribute();
LocalVariableAttribute attribute =
(LocalVariableAttribute) codeAttribute.getAttribute(LocalVariableAttribute.tag);
// 我们需要定义一个集合,收取 参数名称、类型 等信息因为参数有顺序,我们K 防止 参数名称,Value 防止参数类型
Map<String,Class<?>> parameters = new LinkedHashMap<>();
Class<?>[] classTYPE = method.getParameterTypes();
if (attribute != null) {
int pos = Modifier.isStatic(cm.getModifiers()) ? 0 : 1;
for (int i = 0; i < method.getParameterCount(); i++) {
String argName = attribute.variableName(i + pos);
parameters.put(argName,classTYPE[i]);
}
}
map.put(baseUri + value, new UrlMapping(obj, method,parameters));
}
}
}
return map;
}
}
去修改 web.xml的内容
作用是 让DispatcherSerlvet 随着类加载而加载
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
version="4.0">
<!-- XML 按照 顺序 加载,优先加载上面的,下面不会覆盖上面的 -->
<!-- 在 servlet-mapping 中,当 servlet-name,相同时,url-pattern 必须不同 -->
<!-- 放行这里 一些前端的文件 为什么这样配置?理由:需要我们到 Tomcat的 源码 conf/web.xml查看一下 一个 叫 DefaultServlet 的 servlet
从命名 我们就能看出 默认的 servlet 同时 上面注释信息 写了:
这是个所有应用的默认servlet,他可以提供静态资源(放行),他处理所有 未映射 到其他服务上的映射
The default servlet for all web applications, that serves static resources.
It processes all requests that are not mapped to other servlets with servlet mappings
-->
<servlet-mapping>
<servlet-name>default</servlet-name>
<url-pattern>*.css</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>default</servlet-name>
<url-pattern>*.jpg</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>default</servlet-name>
<url-pattern>*.img</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>default</servlet-name>
<url-pattern>*.js</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>default</servlet-name>
<url-pattern>*.html</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>default</servlet-name>
<url-pattern>*.ico</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>default</servlet-name>
<url-pattern>*.png</url-pattern>
</servlet-mapping>
<!-- 首页 -->
<welcome-file-list>
<welcome-file>index.html</welcome-file>
<welcome-file>index.jpg</welcome-file>
</welcome-file-list>
<!-- 配置自己的解析器 -->
<servlet>
<servlet-name>DispatcherServlet</servlet-name>
<servlet-class>com.zanglikun.framework.servlet.DispatcherServlet</servlet-class>
<init-param>
<param-name>prefix</param-name>
<param-value>/WEB-INF/jsp</param-value>
</init-param>
<init-param>
<param-name>suffix</param-name>
<param-value>.jsp</param-value>
</init-param>
<init-param>
<param-name>basePackage</param-name>
<param-value>com.zanglikun</param-value>
</init-param>
<!-- 设为1 让其 随着类加载而加载 -->
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>DispatcherServlet</servlet-name>
<!-- 拦截所有 资源 -->
<!-- <url-pattern>/*</url-pattern> -->
<!-- 不拦截 .jsp 和 Servlet -->
<url-pattern>/</url-pattern>
</servlet-mapping>
</web-app>
DispatcherServlet 变化较大 定义了一些参数值 更多的修复 :减少循环次数 与 if 条件判断
import com.alibaba.fastjson.JSON;
import com.zanglikun.framework.model.UrlMapping;
import com.zanglikun.framework.utils.ClassUtils;
import com.zanglikun.framework.utils.DateTimeConverter;
import org.apache.commons.beanutils.BeanUtils;
import org.apache.commons.beanutils.ConvertUtils;
import javax.servlet.ServletConfig;
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.Method;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
/**
* @author : zanglikun
* @date : 2021/2/23 14:46
* @Version: 1.0
* @Desc : 配置 DispatcherServlet
*/
public class DispatcherServlet extends HttpServlet {
// 创建 收集数据的对象
private static Map<String, UrlMapping> map = new HashMap<>();
private static final String REQUEST_PREFIX = "prefix"; // 请求前缀
private static final String REQUEST_SUFFIX = "suffix"; // 请求后缀
private static final String BASKPACKAGE = "basePackage"; //controller 的包路径
private String prefix = "/WEB-INF/jsp";
private String suffix = ".jsp";
private String basePackage = "com.zanglikun";
// 可以处理的Java类型,作用是 如果不可以处理,就让Java对象处理
Set<Class> doCopy = new HashSet<>();
@Override
public void init(ServletConfig config) {
// 注册时间解析
ConvertUtils.register(new DateTimeConverter(), LocalDate.class);
ConvertUtils.register(new DateTimeConverter(), LocalDateTime.class);
try {
// 如果初始化 配置了值,就会使用web.xml 的信息
if (config.getInitParameter(REQUEST_PREFIX) != null) {
prefix = config.getInitParameter(REQUEST_PREFIX);
}
if (config.getInitParameter(REQUEST_SUFFIX) != null) {
suffix = config.getInitParameter(REQUEST_SUFFIX);
}
if (config.getInitParameter(BASKPACKAGE) != null) {
basePackage = config.getInitParameter(BASKPACKAGE);
}
map = ClassUtils.getUrlMappings(basePackage);
// 记录 能处理的类型,作用是 如果方法参数类型 不是记录的值,就以Java 对象处理
doCopy.add(java.lang.String.class);
doCopy.add(java.lang.Integer.class);
doCopy.add(java.lang.Long.class);
doCopy.add(java.lang.Double.class);
doCopy.add(java.lang.Float.class);
doCopy.add(java.lang.Short.class);
doCopy.add(java.lang.Byte.class);
doCopy.add(java.lang.Boolean.class);
doCopy.add(java.lang.Character.class);
doCopy.add(java.time.LocalDateTime.class);
doCopy.add(java.time.LocalDate.class);
} catch (Exception e) {
}
}
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
try {
req.setCharacterEncoding("utf-8");
resp.setContentType("text/html;charset=UTF-8");
/** 处理请求路径 */
String requestURI = req.getRequestURI();
// 调用我们的 工具类 通过 请求的相对路径 获取 需要执行操作 类的信息
UrlMapping urlMapping = map.get(requestURI.replace(req.getContextPath(), ""));
// 人为 测试 制作服务端错误 500
//int i = 1/0;
// 如果 请求路径不存在
if (urlMapping == null) {
resp.setStatus(404);
resp.getWriter().write("请求路径不存在:<h1>404</h1> 请求路径是" + req.getRequestURI());
// 结束 下面代码执行
return;
}
/** 处理请求参数 */
Method method = urlMapping.getMethod();
Object obj = urlMapping.getObj();
Map<String, Class<?>> parameters = urlMapping.getParameter();
// 创建 数组 将来放参数的地方
Object[] argurments = new Object[method.getParameterTypes().length];
// 定义一个 下标
int index = 0;
for (String key : parameters.keySet()) {
// 请求的参数名称是 key
// 获取方法参数的Java类型
Class<?> parameterType = parameters.get(key);
// 请求参数值 通过request 获取与 方法参数名称匹配的 参数值
String parameter = req.getParameter(key);
// 如果是 HttpServletRequest 对象 就放进去 doGet的 req
if (parameterType == HttpServletRequest.class) {
argurments[index++] = req;
continue;
}
// 如果是 HttpServletResponse 对象 就放进去 doGet的 resp
if (parameterType == HttpServletResponse.class) {
argurments[index++] = resp;
continue;
}
if (parameter != null) {
// 这里 是处理 8大基本类型 与String 利用请求参数类型与 方法参数类型进行匹配 成功就赋值
try {
if (parameterType == java.lang.String.class) {
argurments[index++] = parameter;
continue;
}
/** 基本数据类型转换开始 */
if (parameterType == java.lang.Integer.class) {
argurments[index++] = Integer.parseInt(parameter);
continue;
}
if (parameterType == java.lang.Double.class) {
argurments[index++] = Double.parseDouble(parameter);
continue;
}
if (parameterType == java.lang.Float.class) {
argurments[index++] = Float.parseFloat(parameter);
continue;
}
if (parameterType == java.lang.Short.class) {
argurments[index++] = Short.parseShort(parameter);
continue;
}
if (parameterType == java.lang.Byte.class) {
argurments[index++] = Byte.parseByte(parameter);
continue;
}
if (parameterType == java.lang.Long.class) {
argurments[index++] = Long.parseLong(parameter);
continue;
}
if (parameterType == java.lang.Character.class) {
argurments[index++] = parameter.toCharArray()[0];
continue;
}
if (parameterType == java.lang.Boolean.class) {
argurments[index++] = Boolean.parseBoolean(parameter);
continue;
}
// 基本数据类型转换结束
/** 日期类型转换开始 */
if (parameterType == java.time.LocalDate.class) {
argurments[index++] = LocalDate.parse(parameter, DateTimeFormatter.ofPattern("yyyy-MM-dd"));
continue;
}
if (parameterType == java.time.LocalDateTime.class) {
argurments[index++] = LocalDateTime.parse(parameter, DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
continue;
}
/** 日期类型转换结束 */
// 处理不了的参数 暂时以原来的值处理
else {
argurments[index++] = parameter;
continue;
}
} catch (Exception e) {
// 这里 可能会出现 类型转换异常
e.printStackTrace();
argurments[index++] = null;
continue;
}
} else {
// 如果不是 我们记录的能处理的类型 那就以Java对象转化
if (!doCopy.contains(parameterType)) {
/** Java 对象 转化开始 */
try {
Object paramObj = parameterType.newInstance();
BeanUtils.populate(paramObj, req.getParameterMap());
argurments[index++] = paramObj;
continue;
} catch (Exception e) {
e.printStackTrace();
argurments[index++] = null;
continue;
}
/** Java 对象 转化结束 */
}
}
}
// 执行方法
Object modelview = method.invoke(obj, argurments);
/**
处理方法的返回值
*/
if (modelview != null) {
// 判断是不是 String
if (modelview instanceof String) {
String viewname = (String) modelview;
// 如果是重定向,走 重定向
if (viewname.startsWith("redirect:")) {
// 重定向 路径拼接 并发送重定向
// 这里有个 小Bug 没有 处理Https 协议,以及内外部资源 我们为了更好的处理,我们直接默认http 以及内部资源
resp.sendRedirect(viewname.replace("redirect:", ""));
}
// 如果 是重定向 那就走 重定向
else {
// 确保你的文件,在/WEB-INF/ 下 而不是 webapp 下 切记 我调试了 1个多小时,跳转不了,最后发现路径错了
req.getRequestDispatcher(prefix + "/" + viewname + suffix).forward(req, resp);
}
}
// 如果 返回 不是 String 类型的 我们现在处理 :按照Json 进行处理
// 1、修改 result 更名未 modelview
else {
resp.setContentType("application/json;charset=UTF-8");
// modelview 调用 阿里的 fastJson 转为 Json 打印在浏览器上
resp.getWriter().write(JSON.toJSONString(modelview).toString());
}
}
} catch (Exception e) {
// 向浏览器展示 消息 利用 HttpServletResponse 的枚举 SC_INTERNAL_SERVER_ERROR 其含义 代表 500
resp.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, "服务端 发生错误,请联系系统管理员 Tel :110 ");
/*
sendError 与 getWriter 同时 出现,会执行 sendError() 方法
resp.setStatus(500);
resp.getWriter().println("兄弟 500 错误了 <br>");
e.printStackTrace(resp.getWriter());
*/
// 控制台打印信息
e.printStackTrace();
}
//super.doGet(req, resp);
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 配置 所有请求都走 doGet 方法
// super.doPost(req, resp);
doGet(req, resp);
}
}
优化完成
19、数组处理
DispatcherServlet 变更为:
import com.alibaba.fastjson.JSON;
import com.zanglikun.framework.model.UrlMapping;
import com.zanglikun.framework.utils.ClassUtils;
import com.zanglikun.framework.utils.DateTimeConverter;
import org.apache.commons.beanutils.BeanUtils;
import org.apache.commons.beanutils.ConvertUtils;
import javax.servlet.ServletConfig;
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.Method;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
/**
* @author : zanglikun
* @date : 2021/2/23 14:46
* @Version: 1.0
* @Desc : 配置 DispatcherServlet
*/
public class DispatcherServlet extends HttpServlet {
// 创建 收集数据的对象
private static Map<String, UrlMapping> map = new HashMap<>();
private static final String REQUEST_PREFIX = "prefix"; // 请求前缀
private static final String REQUEST_SUFFIX = "suffix"; // 请求后缀
private static final String BASKPACKAGE = "basePackage"; //controller 的包路径
private String prefix = "/WEB-INF/jsp";
private String suffix = ".jsp";
private String basePackage = "com.zanglikun";
// 可以处理的Java类型,作用是 如果不可以处理,就让Java对象处理
Set<Class> doCopy = new HashSet<>();
@Override
public void init(ServletConfig config) {
// 注册时间解析
ConvertUtils.register(new DateTimeConverter(), LocalDate.class);
ConvertUtils.register(new DateTimeConverter(), LocalDateTime.class);
try {
// 如果初始化 配置了值,就会使用web.xml 的信息
if (config.getInitParameter(REQUEST_PREFIX) != null) {
prefix = config.getInitParameter(REQUEST_PREFIX);
}
if (config.getInitParameter(REQUEST_SUFFIX) != null) {
suffix = config.getInitParameter(REQUEST_SUFFIX);
}
if (config.getInitParameter(BASKPACKAGE) != null) {
basePackage = config.getInitParameter(BASKPACKAGE);
}
map = ClassUtils.getUrlMappings(basePackage);
// 记录 能处理的类型,作用是 如果方法参数类型 不是记录的值,就以Java 对象处理
doCopy.add(java.lang.String.class);
doCopy.add(java.lang.Integer.class);
doCopy.add(java.lang.Long.class);
doCopy.add(java.lang.Double.class);
doCopy.add(java.lang.Float.class);
doCopy.add(java.lang.Short.class);
doCopy.add(java.lang.Byte.class);
doCopy.add(java.lang.Boolean.class);
doCopy.add(java.lang.Character.class);
doCopy.add(java.time.LocalDateTime.class);
doCopy.add(java.time.LocalDate.class);
} catch (Exception e) {
}
}
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
try {
req.setCharacterEncoding("utf-8");
resp.setContentType("text/html;charset=UTF-8");
/** 处理请求路径 */
String requestURI = req.getRequestURI();
// 调用我们的 工具类 通过 请求的相对路径 获取 需要执行操作 类的信息
UrlMapping urlMapping = map.get(requestURI.replace(req.getContextPath(), ""));
// 人为 测试 制作服务端错误 500
//int i = 1/0;
// 如果 请求路径不存在
if (urlMapping == null) {
resp.setStatus(404);
resp.getWriter().write("请求路径不存在:<h1>404</h1> 请求路径是" + req.getRequestURI());
// 结束 下面代码执行
return;
}
/** 处理请求参数 */
Method method = urlMapping.getMethod();
Object obj = urlMapping.getObj();
Map<String, Class<?>> parameters = urlMapping.getParameter();
// 创建 数组 将来放参数的地方
Object[] argurments = new Object[method.getParameterTypes().length];
// 定义一个 下标
int index = 0;
for (String key : parameters.keySet()) {
// 请求的参数名称是 key
// 获取方法参数的Java类型
Class<?> parameterType = parameters.get(key);
// 请求参数值 通过request 获取与 方法参数名称匹配的 参数值
String parameter = req.getParameter(key);
// 请求参数是数组形式的 请求参数值
String[] parameterValues = req.getParameterValues(key);
// 获取数组的长度
int shuzulength = 0;
if(parameterValues != null){
shuzulength = parameterValues.length;
}
// 请求参数如果是数组形式 获取数组数据类型
Class<?> shuzuType = parameterType.getComponentType();
// 如果是 HttpServletRequest 对象 就放进去 doGet的 req
if (parameterType == HttpServletRequest.class) {
argurments[index++] = req;
continue;
}
// 如果是 HttpServletResponse 对象 就放进去 doGet的 resp
if (parameterType == HttpServletResponse.class) {
argurments[index++] = resp;
continue;
}
if (parameter != null) {
// 这里 是处理 8大基本类型 与String 利用请求参数类型与 方法参数类型进行匹配 成功就赋值
try {
if (parameterType == java.lang.String.class) {
argurments[index++] = parameter;
continue;
}
/** 基本数据类型转换开始 */
if (parameterType == java.lang.Integer.class) {
argurments[index++] = Integer.parseInt(parameter);
continue;
}
if (parameterType == java.lang.Double.class) {
argurments[index++] = Double.parseDouble(parameter);
continue;
}
if (parameterType == java.lang.Float.class) {
argurments[index++] = Float.parseFloat(parameter);
continue;
}
if (parameterType == java.lang.Short.class) {
argurments[index++] = Short.parseShort(parameter);
continue;
}
if (parameterType == java.lang.Byte.class) {
argurments[index++] = Byte.parseByte(parameter);
continue;
}
if (parameterType == java.lang.Long.class) {
argurments[index++] = Long.parseLong(parameter);
continue;
}
if (parameterType == java.lang.Character.class) {
argurments[index++] = parameter.toCharArray()[0];
continue;
}
if (parameterType == java.lang.Boolean.class) {
argurments[index++] = Boolean.parseBoolean(parameter);
continue;
}
// 基本数据类型转换结束
/** 日期类型转换开始 */
if (parameterType == java.time.LocalDate.class) {
argurments[index++] = LocalDate.parse(parameter, DateTimeFormatter.ofPattern("yyyy-MM-dd"));
continue;
}
if (parameterType == java.time.LocalDateTime.class) {
argurments[index++] = LocalDateTime.parse(parameter, DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
continue;
}
/** 日期类型转换结束 */
/** 处理数组 开始*/
if (parameterValues != null && shuzuType != null && shuzulength >0){
if (shuzuType == java.lang.String.class) {
String[] str = new String[shuzulength];
for (int i = 0; i < shuzulength; i++) {
str[i] = parameterValues[i];
}
argurments[index++] = str;
continue;
}
if (shuzuType == java.lang.Integer.class) {
Integer[] arr = new Integer[shuzulength];
for (int i = 0; i < shuzulength; i++) {
arr[i] = Integer.valueOf(parameterValues[i]);
}
argurments[index++] = arr;
continue;
}
if (shuzuType == java.lang.Double.class) {
Double[] dob = new Double[shuzulength];
for (int i = 0; i < shuzulength; i++) {
dob[i] = Double.parseDouble(parameterValues[i]);
}
argurments[index++] = dob;
continue;
}
if (shuzuType == java.lang.Float.class) {
Float[] flo = new Float[shuzulength];
for (int i = 0; i < shuzulength; i++) {
flo[i] = Float.parseFloat(parameterValues[i]);
}
argurments[index++] = flo;
continue;
}
if (shuzuType == java.lang.Short.class) {
Short[] sho = new Short[shuzulength];
for (int i = 0; i < shuzulength; i++) {
sho[i] = Short.valueOf(parameterValues[i]);
}
argurments[index++] = sho;
continue;
}
if (shuzuType == java.lang.Byte.class) {
Byte[] byt = new Byte[shuzulength];
for (int i = 0; i < shuzulength; i++) {
byt[i] = Byte.valueOf(parameterValues[i]);
}
argurments[index++] = byt;
continue;
}
if (shuzuType == java.lang.Long.class) {
Long[] lon = new Long[shuzulength];
for (int i = 0; i < shuzulength; i++) {
lon[i] = Long.valueOf(parameterValues[i]);
}
argurments[index++] = lon;
continue;
}
if (shuzuType == java.lang.Character.class) {
Character[] cha = new Character[shuzulength];
for (int i = 0; i < shuzulength; i++) {
cha[i] = parameterValues[i].toCharArray()[0];
}
argurments[index++] = cha;
continue;
}
if (shuzuType == java.lang.Boolean.class) {
Boolean[] bol = new Boolean[shuzulength];
for (int i = 0; i < shuzulength; i++) {
bol[i] = Boolean.valueOf(parameterValues[i]);
}
argurments[index++] = bol;
continue;
}
if (shuzuType == java.time.LocalDate.class) {
LocalDate[] lol = new LocalDate[shuzulength];
for (int i = 0; i < shuzulength; i++) {
lol[i] = LocalDate.parse(parameterValues[i], DateTimeFormatter.ofPattern("yyyy-MM-dd"));
}
argurments[index++] = lol;
continue;
}
if (shuzuType == java.time.LocalDateTime.class) {
LocalDateTime[] lot = new LocalDateTime[shuzulength];
for (int i = 0; i < shuzulength; i++) {
lot[i] = LocalDateTime.parse(parameterValues[i],DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
}
argurments[index++] = lot;
continue;
}
}
// 处理不了的参数 暂时以原来的值处理
else {
argurments[index++] = parameter;
continue;
}
} catch (Exception e) {
// 这里 可能会出现 类型转换异常
e.printStackTrace();
argurments[index++] = null;
continue;
}
/** 处理数组结束 */
}
else {
// 如果不是 我们记录的能处理的类型 那就以Java对象转化
if (!doCopy.contains(parameterType) && shuzuType ==null) {
/** Java 对象 转化开始 */
try {
Object paramObj = parameterType.newInstance();
BeanUtils.populate(paramObj, req.getParameterMap());
argurments[index++] = paramObj;
continue;
} catch (Exception e) {
e.printStackTrace();
argurments[index++] = null;
continue;
}
/** Java 对象 转化结束 */
}
}
}
for (int i = 0; i < argurments.length; i++) {
System.out.println(argurments[i]);
}
// 执行方法
Object modelview = method.invoke(obj, argurments);
/**
处理方法的返回值
*/
if (modelview != null) {
// 判断是不是 String
if (modelview instanceof String) {
String viewname = (String) modelview;
// 如果是重定向,走 重定向
if (viewname.startsWith("redirect:")) {
// 重定向 路径拼接 并发送重定向
// 这里有个 小Bug 没有 处理Https 协议,以及内外部资源 我们为了更好的处理,我们直接默认http 以及内部资源
resp.sendRedirect(viewname.replace("redirect:", ""));
}
// 如果 是重定向 那就走 重定向
else {
// 确保你的文件,在/WEB-INF/ 下 而不是 webapp 下 切记 我调试了 1个多小时,跳转不了,最后发现路径错了
req.getRequestDispatcher(prefix + "/" + viewname + suffix).forward(req, resp);
}
}
// 如果 返回 不是 String 类型的 我们现在处理 :按照Json 进行处理
// 1、修改 result 更名未 modelview
else {
resp.setContentType("application/json;charset=UTF-8");
// modelview 调用 阿里的 fastJson 转为 Json 打印在浏览器上
resp.getWriter().write(JSON.toJSONString(modelview).toString());
}
}
} catch (Exception e) {
// 向浏览器展示 消息 利用 HttpServletResponse 的枚举 SC_INTERNAL_SERVER_ERROR 其含义 代表 500
resp.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, "服务端 发生错误,请联系系统管理员 Tel :110 ");
/*
sendError 与 getWriter 同时 出现,会执行 sendError() 方法
resp.setStatus(500);
resp.getWriter().println("兄弟 500 错误了 <br>");
e.printStackTrace(resp.getWriter());
*/
// 控制台打印信息
e.printStackTrace();
}
//super.doGet(req, resp);
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 配置 所有请求都走 doGet 方法
// super.doPost(req, resp);
doGet(req, resp);
}
}
NewsController 新增 post 方法
@RequestMapping("/post")
public Map<String,Object> post(String[] string, Boolean[] bo, Short[] s, Byte[] by, Long[] l, Float[] f, Double[] d, Character[] c, Integer[] i, LocalDate[] localDate, LocalDateTime[] localDateTime){
System.out.println("NewsController 执行了post方法");
Map<String,Object> map = new HashMap<>();
map.put("String",string);
map.put("Boolean",bo);
map.put("Short",s);
map.put("Byte",by);
map.put("Long",l);
map.put("Float",f);
map.put("Double",d);
map.put("Character",c);
map.put("Integer",i);
map.put("LocalDate",localDate);
map.put("LocalDateTime",localDateTime);
return map;
}
结果如下
成功
结果
我们目前的项目:可有处理String、8大基本数据类型、LocalDate、LocalDateTime 、JavaBean、数组 等等
源代码
请配合 Tomcat8 使用
第三方平台不会及时更新本文最新内容。如果发现本文资料不全,可访问本人的Java博客搜索:标题关键字。以获取最新全部资料 ❤
评论(0)