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

@RestController
public class TestController {
    @RequestMapping("/home")
    String home() {
        return "Hello World!";
    }
}

package com.test.test.model;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    public Integer Id;
    public String UserName;
    public String PassWord;
    public String Name;
}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class TestController {
    @Autowired
    private TestService testService;

    @GetMapping("id")
    User getId(){
        return testService.getId();
    }

}

public interface TestService {
    public User getId();
}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class TestServiceImpl implements TestService {
    @Autowired
    private TestMapper testMapper;
    @Override
    public User getId() {
        return testMapper.getId();
    }
}

@Mapper
@Repository
public interface TestMapper {
    @Select("select * from user where id=1")
    public User getId();
}

@SpringBootApplication
@ServletComponentScan("com.zhengxl.filterdemo.filter")
public class TestApplication {

    public static void main(String[] args) {
        SpringApplication.run(TestApplication.class, args);
    }

}

import jakarta.servlet.*;
import jakarta.servlet.annotation.WebFilter;
import jakarta.servlet.http.HttpServletRequest;
import org.springframework.stereotype.Component;

import java.io.IOException;

@Component
@WebFilter(urlPatterns = "/*") // 监听所有路径
public class TokenFilter implements Filter {
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        HttpServletRequest httpRequest = (HttpServletRequest) servletRequest;
        String path = httpRequest.getServletPath(); // 获取请求的路径

        // 根据请求的路径执行不同的验证逻辑
        switch (path) {
            case "/id":
                // 验证token
                String tokenValue = httpRequest.getHeader("token");
                if (isValidToken(tokenValue)) {
                    filterChain.doFilter(servletRequest, servletResponse);
                } else {
                    sendInvalidResponse(servletResponse, "Invalid token");
                }
                break;
            case "/ab":
                // 验证req-name
                String reqNameValue = httpRequest.getHeader("req-name");
                if ("abcdef".equals(reqNameValue)) {
                    filterChain.doFilter(servletRequest, servletResponse);
                } else {
                    sendInvalidResponse(servletResponse, "Invalid req-name value");
                }
                break;
            default:
                // 对于其他路径，直接继续过滤链
                filterChain.doFilter(servletRequest, servletResponse);
                break;
        }
    }

    // 验证token的有效性
    private boolean isValidToken(String token) {
        // 这里仅为示例，实际应用中应替换为实际的token验证逻辑
        return token != null && token.equals("validToken");
    }

    // 发送无效响应
    private void sendInvalidResponse(ServletResponse servletResponse, String message) throws IOException {
        servletResponse.setContentType("text/plain");
        servletResponse.setCharacterEncoding("UTF-8");
        servletResponse.getWriter().write(message);
    }
}

@Component
public class TestInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 一个简单的安全校验，要求请求头中必须包含 req-name : yihuihui
        String header = request.getHeader("req-name");
        if ("yihuihui".equals(header)) {
            return true;
        }

        System.out.println("请求头错误: {"+header+"}");
        return false;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("执行完毕!");
        response.setHeader("res", "postHandler");
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("回收");
    }
}

@Configuration
public class TestConfig implements WebMvcConfigurer {
    @Autowired
    TestInterceptor testInterceptor;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(testInterceptor)
                .addPathPatterns("/**")//指定该类拦截的url
                .excludePathPatterns("/static/**");//过滤静态资源
    }
}

@Configuration
public void addCorsMappings(CorsRegistry registry) {
    registry.addMapping("/**")
            .allowCredentials(true)
            //放行特定的域
            .allowedOrigins("https://example.com", "https://another-example.com")
            .allowedMethods(new String[]{"GET","POST","PUT","DELETE"})
            .allowedHeaders("*")
            .exposedHeaders("*");
}

@Component
public class EmailUtils {

    @Autowired
    private JavaMailSender javaMailSender;
    @Value("${spring.mail.username}")
    private String from;

    /**
     * 
     * @param to 邮件接收人
     * @param subject 邮件主题
     * @param text 邮件正文
     */
    public void sendMail(String to,String subject,String text){

        SimpleMailMessage message=new SimpleMailMessage();
        message.setFrom(from);
        message.setTo(to);
        message.setSubject(subject);
        message.setText(text);
        message.setSentDate(new Date());

        javaMailSender.send(message);

    }
}

@SpringBootApplication
@EnableScheduling//开启定时任务管理
public class TestApplication {
    public static void main(String[] args) {
        SpringApplication.run(TestApplication.class, args);
    }
}

@Component
public class TaskUtils {
    public static int i=0;
    @Scheduled(cron = "0/5 * * * * ? ")
    public void execute(){
        i+=5;
        System.out.println("时间:"+i+"秒");
    }
}

@Scheduled(cron = "0 0 * * * *", zone = "America/New_York") // 指定时区为纽约
public void executeHourlyInNY() {
}

@Scheduled(fixedRate = 5000)
public void taskWithFixedRate() {
    System.out.println("每5秒执行一次：" + new Date());
}

@Scheduled(fixedRateString = "${fixed.rate.in.milliseconds}") // 从配置文件中读取固定频率时间
public void executeWithFixedRateString() {
}

@Scheduled(fixedDelay = 5000)
public void taskWithFixedDelay() {
    System.out.println("任务完成后5秒再执行：" + new Date());
}

@Scheduled(fixedDelayString = "${fixed.delay.in.milliseconds}") // 从配置文件中读取固定延迟时间
public void executeWithFixedDelayString() {
}

@Scheduled(fixedRate = 5000, initialDelay = 10000)
public void taskWithInitialDelay() {
    System.out.println("首次延迟10秒后，每5秒执行一次：" + new Date());
}

@Scheduled(fixedRate = 5000, initialDelayString = "${initial.delay.in.milliseconds}") // 从配置文件中读取初始延迟时间
public void executeWithInitialDelayString() {
}

public String py2(){
    try {
        // 创建一个ProcessBuilder实例，指定要运行的Python脚本的路径
        ProcessBuilder processBuilder = new ProcessBuilder("python","D:/demo/python/gitvideo/getURL.py");
        // ProcessBuilder processBuilder = new ProcessBuilder("python","D:/demo/python/gitvideo/getURL.py","argparse的参数");
        // 启动进程
        Process process = processBuilder.start();

        // 以GBK编码读取进程的输出流，GBK编码通常用于中文Windows环境
        BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream(), "GBK"));
        String line;
        // 逐行读取输出流中的内容，并打印到控制台
        while ((line = reader.readLine()) != null) {
            System.out.println(line);
        }
        // 打印一个标记，表明脚本的输出已经读取完毕
        System.out.println(1233);

        // 等待进程结束，并获取退出码
        int exitCode = process.waitFor();
        if (exitCode != 0) {
            // 如果退出码不为0，表示脚本执行中发生了错误
            return "Error executing script";
        }

        // 返回最后一行脚本的输出，这可能不是你想要的，通常我们会在循环中处理每一行输出
        return line;
    } catch (IOException | InterruptedException e) {
        // 捕获并打印异常信息
        e.printStackTrace();
        return "Error: " + e.getMessage();
    }
}

//用法
    @RequestMapping("/home")
    String home() {
        return "Hello World!";
    }