一.后端（包装servlet）

        使用BaseServlet进行请求的初步处理（利用继承进行执行这个）

                在BaseServlet中  处理请求的类型找到对象的方法，并使用注解找到参数名，执行参数自动注入。

package com.csdn.controller;

import com.csdn.annotation.ParamName;
import com.csdn.annotation.RequestMethod;
import com.csdn.common.Message;
import com.csdn.util.ResponseUtil;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;

import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.BufferedReader;
import java.io.IOException;
import java.lang.reflect.Method;
import java.lang.reflect.Parameter;


public class BaseServlet extends HttpServlet {

    @Override
    protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        System.out.println("进入service");


        /*request里的请求体里面储存着json格式的数据，其中存在一个键为method，*/
        ObjectMapper mapper = new ObjectMapper();
        JsonNode jsonNode = mapper.readTree(request.getReader());

        System.out.println("jsonNode:"+jsonNode);


        JsonNode methodNameNode = jsonNode.get("method");

        if (methodNameNode == null || !methodNameNode.isTextual()|| methodNameNode.asText().trim().isEmpty()) {
            throw new ServletException("没有指定方法名");
        }
        String methodName = methodNameNode.asText();
        System.out.println("方法名字："+methodName);


        try {
            // 通过反射获取当前类的所有方法
            Method[] methods = this.getClass().getDeclaredMethods();
            for (Method method : methods) {
                // 检查方法是否被@RequestMethod注解标记
                if (method.isAnnotationPresent(RequestMethod.class)) {
                    RequestMethod requestMethod = method.getAnnotation(RequestMethod.class);
                    // 检查注解的值是否与请求中的方法名匹配
                    if (requestMethod.value().equals(methodName)) {

                        //得到参数
                        Object[] params = getParameters(method, jsonNode);
                        method.setAccessible(true);
                        // 调用找到的方法 并 自动注入参数
                        //result是一个java对象
                        Object result = method.invoke(this, params);
                        if (result != null) {
                            // 将返回值（java对象）转换为json格式
                            String message = mapper.writeValueAsString(result);
                            System.out.println(message);
                            response.getWriter().write(message);
                        } else {
                            response.getWriter().write("{}");
                            System.out.println("result 为空!  程序错误\n\n\n");
                        }
                        return;
                    }
                }
            }
        } catch (Exception e) {
            System.out.println("，没有找到对应方法");
            e.printStackTrace();
        }

    }

    // 参数注入（得到参数）
    private static Object[] getParameters(Method method, JsonNode jsonNode) {
        Class<?>[] paramTypes = method.getParameterTypes();
        Parameter[] parameters = method.getParameters();
        Object[] params = new Object[paramTypes.length];

        for (int i = 0; i < paramTypes.length; i++) {
            Parameter parameter = parameters[i];
            // 检查参数上是否有ParamName注解
            if (parameter.isAnnotationPresent(ParamName.class)) {
                ParamName paramNameAnnotation = parameter.getAnnotation(ParamName.class);
                String paramName = paramNameAnnotation.value();
                JsonNode paramValueNode = jsonNode.get(paramName);
                if (paramValueNode != null) {
                    // 根据实际类型转换参数值
                    params[i] = convertJsonNodeToJavaType(paramValueNode, paramTypes[i]);
                }
            } else {
                // 如果没有ParamName注解，使用默认逻辑处理
                System.out.println( "!!!\n\n\n没有ParamName注解\n\n\n");
            }
        }
        return params;
    }

    private static Object convertJsonNodeToJavaType(JsonNode node, Class<?> type) {
        ObjectMapper mapper = new ObjectMapper();
        try {
            // 尝试将JsonNode转换为Java对象
            return mapper.treeToValue(node, type);
        } catch (JsonProcessingException e) {
            // 处理转换失败的情况
            System.err.println("Failed to convert JSON node to Java type: " + type);
            return null; // 或者根据需要返回其他值
        }
    }





}

在controller类中（参数中使用注解，并在baseServlet中进行参数自动注入）

 

二.前端与后端交互的信息类

 这里响应对象，转化为json对象进行传输，并在前端并处理后端结果。

三.前端发送请求并响应后端结果

// 进行发送请求
axios.post('/csdn_war/user',sendMail).then(response => {
    if(response.data.state === 100){
        alert("邮箱未注册请重试！");
    }else if(response.data.state === 110){
        console.log("发送验证码成功！");
        sendVerifyCode2(sendButton2);
    }else{
        alert("后端出现错误！");
    }
})