在这里说的底层机制的实现主要是指：前端控制器、Controller、Service注入容器、对象自动装配、控制器方法获取参数、视图解析、返回json数据。
前端控制器
前端控制器就是核心控制器。在这里我们可以设计一个Servlet来充当核心控制器：LingDispatcherServlet.java.这个控制器的作用主要是接收响应前端过来的Http请求和Response响应。一开始需要在web.xml中配置好控制器的 请求路径，还要配置好SpringMVC的xml文件： lingspringmvc.xml.
lingspringmvc.xml：
<?xml version="1.0" encoding="UTF-8" ?>
<beans>
<component-scan base-package="com.linghu.controller"></component-scan>
</beans>
有了这个xml文件就好办了，里面写了Controller层的类路径，只需要通过dom4j技术将类路径读出来，就可以轻松的将该文件下的类文件进行读取遍历，再去分析他们是否加了我们设计的注解，如果加了就保留类路径，甚至加入到我们自己设计的ioc容器中。在读取xml文件里的内容的时候，可以单独写一个工具类XMLParser.java：
package com.linghu.springmvc.xml;
import org.dom4j.Attribute;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import java.io.InputStream;
/**
* @author linghu
* @date 2023/9/11 14:22
*/
public class XMLParser {
public static String getBasePackage(String xmlFile){
SAXReader saxReader = new SAXReader();
InputStream resourceAsStream =
XMLParser.class.getClassLoader().getResourceAsStream(xmlFile);
try {
Document document = saxReader.read(resourceAsStream);
Element rootElement = document.getRootElement();
Element componentScanElement =
rootElement.element("component-scan");
Attribute attribute = componentScanElement.attribute("base-package");
String basePackage = attribute.getText();
System.out.println("basePackage="+basePackage);
return basePackage;
} catch (DocumentException e) {
e.printStackTrace();
}
return null;
}
}
Controller注解
在Controller层，我们会在类上标注Controller注解，容器就会将这个类路径扫描加入到我们的容器中。在这里我们将自己设计一个自己的注解Controller注解。
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Controller {
String value() default "";
}
RequestMapping注解
前端发出请求的时候，请求地址为：IP+端口+URI。RequestMapping注解可以规定我们请求的URI。同样我们需要自己设计一个属于自己的RequestMapping注解：
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface RequestMapping {
String value() default "";
}
前端发出请求的时候，如果携带了参数，后端接收的时候就要标注接收的参数字段，会用到注解 RequestMapping注解。
自定义容器LingWebApplicationContext
需要自己设计一个容器，将我们从lingspringmvc.xml中读取到的类路径下的.class文件的路径列表全部存起来。具体来说 就是：
<?xml version="1.0" encoding="UTF-8" ?>
<beans>
<component-scan base-package="com.linghu.controller"></component-scan>
</beans>
需要将上面com.linghu.controller这个路径下的类文件的路径进行存储。以后这个扫描的包不光有controller，还会有service，dao等等。
这个容器里最重要的就是要保存我们扫描包和子包下的全类路径，所以我们定义了一个 classFullPathList集合用来存储。
private ArrayList<String> classFullPathList=new ArrayList<>();
接下来就是利用工具类 XMLParser去读取springmvc.xml配置文件里的包路径，接着利用文件和IO的知识去扫描这个包路径下的文件和目录，将这个路径下的所有.class文件的后缀.class裁剪掉，将路径名和文件名进行拼接就得到了类文件的类路径了，我们将他们存储到classFullPathList集合中即可。如下：
这个类路径就对应下图：
这里目前只讨论controller注解的类，因为springmvc.xml扫描的包只写了controller这个包。
利用文件和IO的知识去扫描这个包路径下的文件和目录是重点，在扫描以后，我们要将这个路径下的所有.class文件的后缀.class裁剪掉，将路径名和文件名进行拼接。这两步是最重要的。scanPackage()函数可以完成这两个重要的东西。
public void init(){
String basePackage = XMLParser.getBasePackage("lingspringmvc.xml");
String[] packages = basePackage.split(",");
if (packages.length>0){
for (String pack :packages) {
scanPackage(pack);
}
}
System.out.println("classFullPathList="+classFullPathList);
}
public void scanPackage(String pack){
URL url = this.getClass().
getClassLoader().
getResource("/" + pack.replaceAll("\\.", "/"));
String path = url.getFile();//获取所有文件的目录
File dir = new File(path);
for (File f :dir.listFiles()) {
if (f.isDirectory()){
scanPackage(pack+"."+f.getName());
}else {
String classFullPath=pack+"."+f.getName().replaceAll(".class","");
classFullPathList.add(classFullPath);
}
}
}
将classFullPathList存放的扫描的全类路径文件的类名提出来，将第一个字母小写，作为bean对象的名称，类似于以前xml配置bean对象的时候，声明的bean的id。然后将类路径进行反射创建对象，同时将beanName和反射创建好的对象放到ioc容器中。如下：
public void executeInstance(){
if (classFullPathList.size()==0){
return;
}
try {
for (String classFullPath:classFullPathList) {
Class<?> clazz = Class.forName(classFullPath);
if (clazz.isAnnotationPresent(Controller.class)){
String beanName=clazz.getSimpleName().substring(0,1).toLowerCase()+
clazz.getSimpleName().substring(1);
//同时将beanName和反射创建好的对象放到ioc容器中
ioc.put(beanName,clazz.newInstance());
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
设计handlerList
Controller层会写很多接口，规范化请求的地址，用注解RequestMapping进行了标识，RequestMapping的Value值其实就是请求的地址，我们把它取出来单独命名成url，在把RequestMapping标识的方法的方法名取出来命名成method，最后把当前方法所在的类，也就是Controller标识的这个类的对象命名成controller。我们现在有了url，controller，method。其实就已经拿到了url和method的映射关系了，现在将其封装保存到handerList集合中。这样做的好处是，当前端发来请求的时候，我们可以取出请求的url，通过url在handerList中找到对应的调用的方法名，实现调用的映射。
先设计一个hander,用来封装url，controller，method:
package com.linghu.springmvc.handler;
import java.lang.reflect.Method;
/**
* @author linghu
* @date 2023/9/12 9:23
*/
public class LingHandler {
private String url;
private Object controller;
private Method method;
public LingHandler() {
}
public LingHandler(String url, Object controller, Method method) {
this.url = url;
this.controller = controller;
this.method = method;
}
@Override
public String toString() {
return "LingHandler{" +
"url='" + url + '\'' +
", controller=" + controller +
", method=" + method +
'}';
}
public String getUrl() {
return url;
}
public void setUrl(String url) {
this.url = url;
}
public Object getController() {
return controller;
}
public void setController(Object controller) {
this.controller = controller;
}
public Method getMethod() {
return method;
}
public void setMethod(Method method) {
this.method = method;
}
}
private void initHandlerMapping(){
if (lingWebApplicationContext.ioc.isEmpty()){
return;
}
for (Map.Entry<String,Object> entry :lingWebApplicationContext.ioc.entrySet()) {
Class<?> clazz = entry.getValue().getClass();
if (clazz.isAnnotationPresent(Controller.class)){
Method[] declaredMethods = clazz.getDeclaredMethods();
for (Method method :declaredMethods) {
if (method.isAnnotationPresent(RequestMapping.class)){
RequestMapping requestMappingAnnotation =
method.getAnnotation(RequestMapping.class);
String url = requestMappingAnnotation.value();
LingHandler lingHandler = new LingHandler(url,entry.getValue(),method);
handlerList.add(lingHandler);
}
}
}
}
}
initHandlerMapping()会将容器中的对象，也就是之前 我们通过类路径反射创建的对象进行遍历，遍历过程中筛选出被Controller注解标识过的类，将类里的方法再全部进行遍历，遍历过程中将被RequestMapping注解标识的方法选出来，将这些方法的方法名命名成method，注解RequestMapping的value值取出来命名成url，将当前类命名成controller，最后将url，controller，method放到LingHandler对象中，在将LingHandler对象放到handerList集合中。
完成分发请求
前端发送一个请求过来，无论是get，post请求都要经过我的servlet，这个时候可以取出请求request信息里的uri，这样我就得到了前端想要请求的Controller层的具体方法，其实拿到这个方法我们就可以利用反射进行调用了。所以完成分发请求的还是我们的servlet，也就是文章一开篇就说的前端控制器，核心控制器，它就是我们的整个大脑核心，负责接收请求，完成请求分发，分发到具体要执行的Controller层的方法去。
前端过来的请求，我们可以让它统一都走post请求。
LingDispatcherServlet.java:
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doPost(req, resp);
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
System.out.println("LingDispatcherServlet doPost");
executeDispatch(req, resp);
}
executeDispatch(req, resp)便是携带着前端request请求的具体执行分发请求的方法。
public void executeDispatch(HttpServletRequest request,
HttpServletResponse response){
LingHandler lingHandler = getLingHandler(request);
try {
if (lingHandler==null){
response.getWriter().print("<h1>404</h1>");
}else {
lingHandler.getMethod().invoke(lingHandler.getController(),request,response);
}
} catch (Exception e) {
e.printStackTrace();
}
}
lingHandler.getMethod().invoke(lingHandler.getController(),request,response);便是反射调用，是完成分发的核心。在这里lingHandler.getMethod()本身就是Method类型的对象，所以可以进行调用。getLingHandler(request)的具体过程如下：
public LingHandler getLingHandler(HttpServletRequest request){
String requestURI = request.getRequestURI();
for (LingHandler lingHandler :handlerList) {
if (requestURI.equals(lingHandler.getUrl())){
return lingHandler;
}
}
return null;
}
getLingHandler完成的便是查看handlerList集合中有没有前端请求的方法url，有的话就直接把handler对象返回，handler对象里保存着前端请求url和调用后端方法名的映射关系，通过映射关系我们可以查到具体要调用的方法是谁。
Service注解和AutoWired注解
这两个注解的实现其实和Controller注解差不多的流程三板斧。先通过元注解定义好这两个注解，在扫描全类路径的时候，去判断有没有Service注解，有的话就获取文件下的所有接口名，对接口名字首字母变小写，然后拼接得到新的beanName，最后通过反射创建对象，将beanName和对象加入到ioc中。
} else if (clazz.isAnnotationPresent(Service.class)) {
Service serviceAnnotation = clazz.getAnnotation(Service.class);
String beanName = serviceAnnotation.value();
if ("".equals(beanName)){
Class<?>[] interfaces = clazz.getInterfaces();
for (Class<?> anInterface :interfaces) {
String beanName2=anInterface.getSimpleName().substring(0,1).toLowerCase()+
anInterface.getSimpleName().substring(1);
ioc.put(beanName2,clazz.newInstance());
}
}else {
ioc.put(beanName,clazz.newInstance());
}
}
设计Controller注解的时候，我们是直接获取的 类名，在这里设计Service注解的时候我们获取的是接口名字，是因为接口内部装满了所有实现类，而我们的Service注解又是写在这些实现类上面 的，我们通过获取接口，就有机会遍历到这些实现类，如果不通过获取接口，直接获取实现类代价要大点。
AutoWired注解的作用是将dao层和业务层对象注入到ioc中，方便业务层或者控制层调用dao层和业务层。扫描什么的其实不难，就是全文扫描带AutoWired注解的属性，将其加入到容器中。加入的这个过程放在一个函数executeAutoWired()中。
public void executeAutoWired(){
if (ioc.isEmpty()){
throw new RuntimeException("容器中没有可以装配的bean");
}
for (Map.Entry<String,Object> entry :ioc.entrySet()) {
String key = entry.getKey();
Object bean = entry.getValue();
Field[] declaredFields = bean.getClass().getDeclaredFields();
for (Field declaredField :declaredFields) {
if (declaredField.isAnnotationPresent(AutoWired.class)){
AutoWired autoWiredAnnotation =
declaredField.getAnnotation(AutoWired.class);
String beanName = autoWiredAnnotation.value();
if ("".equals(beanName)){
Class<?> type = declaredField.getType();
beanName= type.getSimpleName().substring(0,1).toLowerCase()+
type.getSimpleName().substring(1);
}
declaredField.setAccessible(true);
try {
if (ioc.get(beanName)==null){
throw new RuntimeException("容器中没有注入该bean");
}
declaredField.set(bean,ioc.get(beanName));
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}
}
}
}
RequestParam注解
前端在发送请求的时候，会携带一些参数过来，这个时候后端要接收请求的时候处理好参数字段的对应关系。我们可以用requestparam注解标识前端对应过来的参数字段。文章来源：https://www.toymoban.com/news/detail-712419.html
@Target(ElementType.PARAMETER)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface RequestParam {
String value() default "";
}
public void executeDispatch(HttpServletRequest request,
HttpServletResponse response){
LingHandler lingHandler = getLingHandler(request);
try {
if (lingHandler==null){
response.getWriter().print("<h1>404</h1>");
}else {
// lingHandler.getMethod().invoke(lingHandler.getController(),request,response);
Class<?>[] parameterTypes =
lingHandler.getMethod().getParameterTypes();
Object [] params = new Object[parameterTypes.length];
for (int i=0;i< parameterTypes.length;i++){
Class<?> parameterType=parameterTypes[i];
if ("HttpServletRequest".equals(parameterType.getSimpleName())){
params[i]=request;
} else if ("HttpServletResponse".equals(parameterType.getSimpleName())) {
params[i]=response;
}
}
Map<String,String[]> parameterMap =
request.getParameterMap();
for (Map.Entry<String,String[]> entry :parameterMap.entrySet()) {
String name = entry.getKey();
String value = entry.getValue()[0];
System.out.println("请求的参数："+name+"----"+value);
int indexRequestParamIndex=
getIndexRequestParamIndex(lingHandler.getMethod(),name);
if (indexRequestParamIndex!=-1){
params[indexRequestParamIndex]=value;
}else {
}
}
lingHandler.getMethod().invoke(lingHandler.getController(),params);
}
} catch (Exception e) {
e.printStackTrace();
}
}
public int getIndexRequestParamIndex(Method method,String name){
Parameter[] parameters = method.getParameters();
for (int i=0;i<parameters.length;i++){
Parameter parameter=parameters[i];
boolean annotationPresent =
parameter.isAnnotationPresent(RequestParam.class);
if (annotationPresent){
RequestParam requestParamAnnotation =
parameter.getAnnotation(RequestParam.class);
String value = requestParamAnnotation.value();
if (name.equals(value)){
return i;
}
}
}
return -1;
}
完整代码
《实现SpringMVC底层机制》文章来源地址https://www.toymoban.com/news/detail-712419.html
到了这里，关于手动开发-实现SpringMVC底层机制--小试牛刀的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！
