1、异常处理

1.1 全局异常

  1. @Slf4j
  2. @ControllerAdvice
  3. public class GlobalExceptionHandler {
  5.     @ExceptionHandler(value = Exception.class)
  6.     @ResponseBody
  7.     public String XXXExceptionHandler(Exception e) {
  8.         log.info(e.toString());
  9.         return "123";
  10.     }
  11. }

1.2 自定义异常

  1. // 异常直接抛给 tomcat, 如果后续处理异常，则显示错误页面
  2. throw new CustomExceptionHandler("错误");
  4. @NoArgsConstructor
  5. @ResponseStatus(value = HttpStatus.FORBIDDEN,reason = "拒绝访问")  // 403
  6. public class CustomExceptionHandler extends RuntimeException{
  8.     public  CustomExceptionHandler(String message){
  9.         super(message);
  10.     }
  11. }
  1. @Order(value = Ordered.HIGHEST_PRECEDENCE) // 最高级别，处理所有异常（其他任何异常配置失效）
  2. @Component
  3. public class CustomerHandlerException implements HandlerExceptionResolver {
  5.     @Override
  6.     public ModelAndView resolveException(HttpServletRequest httpServletRequest,
  7.                                          HttpServletResponse httpServletResponse,
  8.                                          Object handler, Exception e) {
  9.         try {
  10.             httpServletResponse.sendError(555,"wuwuwu异常"); // 抛给 tomcat
  11.         } catch (IOException ioException) {
  12.             ioException.printStackTrace();
  13.         }
  14.         return new ModelAndView();
  15.     }
  16. }

2、 异步请求

启动类： @EnableAsync 

  1. @GetMapping("/callable")
  2. private Callable<Object> getCallable(){
  3.     log.info(Thread.currentThread().getName() + " 进入 getCallable 方法");
  4.     Callable<Object> callable = new Callable<Object>() {
  5.         @Override
  6.         public Object call() throws Exception {
  7.             log.info(Thread.currentThread().getName() + " 进入 call 方法");
  8.             Object say = sayHello();
  9.             log.info(Thread.currentThread().getName() + " 从 Service 方法返回");
  10.             return say;
  11.         }
  12.     };
  13.     log.info(Thread.currentThread().getName() + " 从 getCallable 方法返回");
  14.     return callable;
  15. }
  17. @GetMapping("/webAsyncTask")
  18. private WebAsyncTask<Object> getWebAsyncTask(){
  19.     log.info(Thread.currentThread().getName() + " 进入 getWebAsyncTask 方法");
  20.     // 3s 没返回，则认为超时
  21.     WebAsyncTask<Object> webAsyncTask = new WebAsyncTask<>(3000, new Callable<Object>() {
  22.         @Override
  23.         public Object call() throws Exception {
  24.             log.info(Thread.currentThread().getName() + " 进入call方法");
  25.             Object say = sayHello();
  26.             log.info(Thread.currentThread().getName() + " 从 Service 方法返回");
  27.             return say;
  28.         }
  29.     });
  30.     log.info(Thread.currentThread().getName() + " 从 Service 方法返回");
  31.     webAsyncTask.onCompletion(new Runnable() {
  32.         @Override
  33.         public void run() {
  34.             log.info(Thread.currentThread().getName() + " 执行完毕");
  35.         }
  36.     });
  37.     webAsyncTask.onTimeout(new Callable<Object>() {
  38.         @Override
  39.         public Object call() throws Exception {
  40.             log.info(Thread.currentThread().getName() + " onTimeout");
  41.             // 超时的时候，直接抛异常，让外层统一处理超时异常
  42.             throw new TimeoutException("调用超时");
  43.         }
  44.     });
  45.     return webAsyncTask;
  46. }
  48. @GetMapping("/deferredResult")
  49. private DeferredResult<Object> getDeferredResult(){
  50.     log.info(Thread.currentThread().getName() + " 进入 getDeferredResult 方法");
  51.     DeferredResult<Object> deferredResult = new DeferredResult<>(3000L);
  52.     // 调用长时间执行任务
  53.     execute(deferredResult);
  54.     // 当长时间任务中使用deferred.setResult("world");这个方法时，会从长时间任务中返回，继续controller里面的流程
  55.     log.info(Thread.currentThread().getName() + "从 execute 方法返回");
  56.     // 超时的回调方法
  57.     deferredResult.onTimeout(new Runnable(){
  58.         @Override
  59.         public void run() {
  60.             log.info(Thread.currentThread().getName() + " onTimeout");
  61.             // 返回超时信息
  62.             deferredResult.setErrorResult("time out!");
  63.         }
  64.     });
  65.     // 处理完成的回调方法，无论是超时还是处理成功，都会进入这个回调方法
  66.     deferredResult.onCompletion(new Runnable(){
  67.         @Override
  68.         public void run() {
  69.             log.info(Thread.currentThread().getName() + " onCompletion");
  70.         }
  71.     });
  72.     return deferredResult;
  73. }
  75. @Async
  76. public void execute(DeferredResult<Object> deferredResult) {
  77.     log.info(Thread.currentThread().getName() + "进入 execute 方法");
  78.     try {
  79.         // 模拟长时间任务调用，睡眠 2s
  80.         TimeUnit.SECONDS.sleep(5);
  81.         // 2s 后给 Deferred 发送成功消息，告诉 Deferred ，我这边已经处理完了，可以返回给客户端了
  82.         deferredResult.setResult("world");
  83.     } catch (InterruptedException e) {
  84.         e.printStackTrace();
  85.     }
  86. }
  88. private Object sayHello() {
  89.     try {
  90.         TimeUnit.SECONDS.sleep(4);
  91.     } catch (InterruptedException e) {
  92.         e.printStackTrace();
  93.     }
  94.     Map<String,Object> map = new HashMap<>();
  95.     map.put("a",1);
  96.     map.put("b",2);
  97.     return map;
  98. }

3、发送邮件

Pom

  1. <dependency>
  2.   <groupId>org.springframework.boot</groupId>
  3.   <artifactId>spring-boot-starter-mail</artifactId>
  4. </dependency>

yaml

  1. spring:
  2. #  126邮箱SMTP服务器地址:smtp.126.com,端口号:465或者994
  3. #  2163邮箱SMTP服务器地址:smtp.163.com,端口号:465或者994
  4. #  yeah邮箱SMTP服务器地址:smtp.yeah.net,端口号:465或者994
  5. #  qq邮箱SMTP服务器地址：smtp.qq.com,端口号465或587*
  6.   mail:
  7.     default-encoding: UTF-8
  8.     host: smtp.qq.com
  9.     username: 953598751@qq.com
  10.     password: xxx
  11.     port: 587
  12.     properties:
  13.       mail:
  14.         stmp:
  15.           socketFactoryClass: javax.net.ssl.SSLSocketFactory
  16.         #表示开启 DEBUG 模式，这样，邮件发送过程的日志会在控制台打印出来，方便排查错误
  17.         debug: true

Test

  1. @Autowired
  2. private JavaMailSender javaMailSender;
  3. private final ClassPathResource classPathResource = new ClassPathResource("static/test.jpg");
  5. @Test
  6. public void sendString(){
  7.     // 构建一个邮件对象
  8.     SimpleMailMessage message = new SimpleMailMessage();
  9.     // 设置邮件主题
  10.     message.setSubject("这是一封测试邮件");
  11.     // 设置邮件发送者，这个跟 application.yml中设置的要一致
  12.     message.setFrom("953598751@qq.com");
  13.     // 设置邮件接收者，可以有多个接收者，中间用逗号隔开，以下类似
  14.     message.setTo("1349587649@qq.com");
  15.     // 设置邮件抄送人，可以有多个抄送人。
  16.     // 将邮件同时送给收信人以外的人，用户所写的邮件抄送一份给别人,对方可以看见该用户的E-mail发送给了谁。
  17.     // message.setCc("idu8972@dingtalk.com");
  18.     // 设置隐秘抄送人，可以有多个。
  19.     // 将邮件同时送给收信人以外的人，用户所写的邮件抄送一份给别人,但是对方不能查看到这封邮件同时还发送给了哪些人。
  20.     // message.setBcc("idu8972@dingtalk.com");
  21.     // 设置邮件发送日期
  22.     message.setSentDate(new Date());
  23.     // 设置邮件的正文
  24.     message.setText("这是测试邮件的正文");
  25.     // 发送邮件
  26.     javaMailSender.send(message);
  27. }
  29. /**
  30.  * 发送带附件的邮件
  31.  */
  32. @Test
  33. public void sendAttachFileMail() throws MessagingException, IOException {
  34.     MimeMessage mimeMessage = javaMailSender.createMimeMessage();
  35.     // true表示构建一个可以带附件的邮件对象
  36.     MimeMessageHelper helper = new MimeMessageHelper(mimeMessage,true);
  37.     helper.setSubject("这是一封测试邮件");
  38.     helper.setFrom("953598751@qq.com");
  39.     helper.setTo("1349587649@qq.com");
  40.     helper.setSentDate(new Date());
  41.     helper.setText("这是测试邮件的正文");
  42.     // 第一个参数是自定义的名称，后缀需要加上，第二个参数是文件的位置
  43.     helper.addAttachment("报表.pdf",classPathResource.getFile());
  44.     javaMailSender.send(mimeMessage);
  45. }
  46. /**
  47.  * 正文中带图片的邮件
  48.  */
  49. @Test
  50. public void sendImgResMail() throws MessagingException, IOException {
  51.     MimeMessage mimeMessage = javaMailSender.createMimeMessage();
  52.     MimeMessageHelper helper = new MimeMessageHelper(mimeMessage, true);
  53.     helper.setSubject("这是一封测试邮件");
  54.     helper.setFrom("953598751@qq.com");
  55.     helper.setTo("1349587649@qq.com");
  56.     helper.setSentDate(new Date());
  57.     // src='cid:p01' 占位符写法 ，第二个参数true表示这是一个html文本
  58.     helper.setText("<H1>hello 大家好，这是一封测试邮件，这封邮件包含两种图片，分别如下</H1>" +
  59.                    "<H3>第一张图片：</H3><img src='cid:img01'/>",true);
  60.     // 第一个参数指的是 html 中占位符的名字，第二个参数就是文件的位置
  61.     helper.addInline("img01",new FileSystemResource(classPathResource.getFile()));
  62.     helper.addAttachment("test.jpg",classPathResource.getFile());
  63.     javaMailSender.send(mimeMessage);
  64. }

4、跨域

  1. @Configuration
  2. @EnableWebMvc  // 使用 swagger 不能有该注解
  3. public class WebConfig extends WebMvcConfigurerAdapter {
  4.     @Override
  5.     public void addCorsMappings(CorsRegistry registry) {
  6.         registry.addMapping("/**")
  7.             .allowedOrigins("*")
  8.             .allowedMethods("GET","POST")
  9.             .allowCredentials(false).maxAge(3600);
  10.     }
  11. }
  14. @Configuration
  15. class CorsConfig implements WebMvcConfigurer {
  16.     @Override
  17.     public void addCorsMappings(CorsRegistry registry) {
  18.         //添加映射路径
  19.         registry.addMapping("/**")
  20.                 //是否发送Cookie
  21.                 .allowCredentials(true)
  22.                 //设置放行哪些原始域   SpringBoot2.4.4下低版本使用.allowedOrigins("*")
  23.                 .allowedOriginPatterns("*")
  24.                 //放行哪些请求方式
  25.                 .allowedMethods("GET", "POST")
  26.                 //.allowedMethods("*") //或者放行全部
  27.                 //放行哪些原始请求头部信息
  28.                 .allowedHeaders("*")
  29.                 //暴露哪些原始请求头部信息
  30.                 .exposedHeaders("*");
  31.     }
  32.     /** swagger 访问 **/
  33.     @Override
  34.     public void addResourceHandlers(ResourceHandlerRegistry registry) {
  35.         registry.addResourceHandler("/static/**").addResourceLocations("classpath:/static/");
  36.         registry.addResourceHandler("/swagger-ui.html").addResourceLocations("classpath:/META-INF/resources/");
  37.         registry.addResourceHandler("/webjars/**").addResourceLocations("classpath:/META-INF/resources/webjars/");
  38.         WebMvcConfigurer.super.addResourceHandlers(registry);
  39.     }
  40. }
  43. public class MyCorsFilter extends CorsFilter {
  44.     public MyCorsFilter() {
  45.         super(configurationSource());
  46.     }
  47.     private static UrlBasedCorsConfigurationSource configurationSource() {
  48.         CorsConfiguration config = new CorsConfiguration();
  49.         config.setAllowCredentials(true);
  50.         config.addAllowedOrigin("http://domain1.com");
  51.         config.addAllowedHeader("*");
  52.         config.addAllowedMethod("GET","POST");
  53.         UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
  54.         source.registerCorsConfiguration("/**", config);
  55.         return source;
  56.     }
  57. }
  59. // 注解形式
  60. @CrossOrigin(origins = "*",maxAge = 3600)

5、获取文件

  1. // 获取 classpath 路径下的文件
  2. ClassPathResource classPathResource = new ClassPathResource("static/index.html");
  3. File file = classPathResource.getFile();
  4. System.out.println(file.getName());
  6. // 获取项目路径下的文件
  7. FileSystemResource fileSystemResource = new FileSystemResource("pom.xml");
  8. File file1 = fileSystemResource.getFile();
  9. FileReader fileReader = new FileReader(file1);
  10. char[] chars = new char[100];
  11. if(fileReader.read(chars)!=-1){
  12.     System.out.println(String.valueOf(chars));
  13. }

6、远程调试

  • 启动命令： java -agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=8000 -jar web.jar

-agentlib:jdwp=transport=dt_socket,server=y,address=8000

以 Socket 方式监听 8000 端口，程序启动阻塞（suspend 的默认值为y）直到被连接。

-agentlib:jdwp=transport=dt_socket,server=y,address=localhost:8000,timeout=5000

以 Socket 方式监听 8000 端口，当程序启动后5秒无调试者连接的话终止，程序启动阻塞（suspend的默认值为y）直到被连接。

-agentlib:jdwp=transport=dt_shmem,server=y,suspend=n

选择可用的共享内存连接地址并使用 stdout 打印，程序启动不阻塞。

-agentlib:jdwp=transport=dt_socket,address=myhost:8000

以 socket 方式连接到 myhost:8000上的调试程序，在连接成功前启动阻塞。

-agentlib:jdwp=transport=dt_socket,server=y,address=8000,onthrow=java.io.IOException,launch=/usr/local/bin/debugstub

以 Socket 方式监听 8000 端口，程序启动阻塞（suspend的默认值为y）直到被连接。当抛出 IOException 时中断调试，转而执行 usr/local/bin/debugstub程序。

  • 参数说明 | transport | 指定运行的被调试应用和调试者之间的通信协议，它由几个可选值： | | —- | —- | | | dt_socket
    ：主要的方式，采用 socket 方式连接 | | server | 当前应用作为调试服务端还是客户端，默认为 n
    。
    如果你想将当前应用作为被调试应用，设置该值为 y
    ；如果你想将当前应用作为客户端，作为调试的发起者，设置该值为 n | | suspend | 当前应用启动后，是否阻塞应用直到被连接，默认值为 y
    。
    在大部分的应用场景，这个值为 n
    ，即不需要应用阻塞等待连接。
    一个可能为 y
    的应用场景是，你的程序在启动时出现了一个故障，为了调试，必须等到调试方连接上来后程序再启动 | | address | 暴露的调试连接端口，默认值为 8000 | | onthrow | 当程序抛出设定异常时，中断调试 | | onuncaught | 当程序抛出未捕获异常时，是否中断调试，默认值为 n | | launch | 当调试中断时，执行的程序。 | | timeout | 该参数限定为 java -agentlib:jdwp=…
    可用，单位为毫秒ms。
    当 suspend = y 时，该值表示等待连接的超时；当 suspend = n 时，该值表示连接后的使用超时。 |
  • IDEA 调试

Edit Configurations > 添加一个 Remote JVM Debug > 配置 Host 和 Port > 启动该配置

7、静态资源服务

  1. @Configuration
  2. class CorsConfig implements WebMvcConfigurer {
  4.     @Override
  5.     public void addResourceHandlers(ResourceHandlerRegistry registry) {
  6.         registry.addResourceHandler("/img/**").addResourceLocations("file:D:/app_3d/fpt/");
  7.         registry.addResourceHandler("/static/**").addResourceLocations("classpath:/static/");
  8.         registry.addResourceHandler("/swagger-ui.html").addResourceLocations("classpath:/META-INF/resources/");
  9.         registry.addResourceHandler("/webjars/**").addResourceLocations("classpath:/META-INF/resources/webjars/");
  10.         WebMvcConfigurer.super.addResourceHandlers(registry);
  11.     }
  12. }

8、Mybatis plus LocalTime

  1. @JsonFormat(shape=JsonFormat.Shape.STRING, pattern="yyyy-MM-dd HH:mm:ss")
  2. @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
  3. private LocalDateTime updateTime;
  5. @Bean(name = "mapperObject")
  6. public ObjectMapper getObjectMapper() {
  7.     JavaTimeModule javaTimeModule = new JavaTimeModule();
  8.     javaTimeModule.addSerializer(LocalDateTime.class, new LocalDateTimeSerializer(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
  9.     javaTimeModule.addSerializer(LocalDate.class, new LocalDateSerializer(DateTimeFormatter.ofPattern("yyyy-MM-dd")));
  10.     javaTimeModule.addSerializer(LocalTime.class, new LocalTimeSerializer(DateTimeFormatter.ofPattern("HH:mm:ss")));
  11.     return new ObjectMapper().registerModule(javaTimeModule);
  12. }

9、AOP

  1. <!--        <dependency>-->
  2. <!--            <groupId>org.aspectj</groupId>-->
  3. <!--            <artifactId>aspectjweaver</artifactId>-->
  4. <!--            <version>1.8.13</version>-->
  5. <!--        </dependency>-->
  7. <dependency>
  8.   <groupId>org.springframework.boot</groupId>
  9.   <artifactId>spring-boot-starter-aop</artifactId>
  10. </dependency>
  1. @Component
  2. public class User {
  3.     public void add(String str){
  4.         System.out.println("add..........." + str);
  5.     }
  6. }
  9. @Component
  10. @Aspect
  11. @Order(1) // 设置增强顺序
  12. public class UserProxy1 {
  13.     /**
  14.      * 前置通知
  15.      */
  16.     @Before(value =  "execution(* com.cug.aop.User.add(..))")
  17.     public void before(){
  18.         System.out.println("UserProxy1 before...........");
  19.     }
  20. }
  23. /**
  24.  * @Description 创建不同的方法，代表不同的通知类型
  25.  */
  26. @Aspect
  27. @Component
  28. @Order(2)  // 设置增强顺序
  29. public class UserProxy {
  31.     /**
  32.      * 相同切入点抽取
  33.      */
  34.     @Pointcut(value = "execution(* com.cug.aop.User.add(..))")
  35.     public void pointDemo(){}
  37.     /**
  38.      * 前置通知
  39.      */
  40.     @Before(value =  "pointDemo()")
  41.     public void before(JoinPoint joinPoint){
  42.         System.out.println(Arrays.toString(joinPoint.getArgs()));
  43.         // 2
  44.         System.out.println("before...........");
  45.     }
  47.     @After(value = "execution(* com.cug.aop.User.add(..))")
  48.     public void after(){
  49.         // 4
  50.         System.out.println("after..........");
  51.     }
  53.     @AfterReturning(value = "execution(* com.cug.aop.User.add(..))")
  54.     public void afterReturning(){
  55.         // 3   增强的方法之后
  56.         System.out.println("AfterReturning..........");
  57.     }
  59.     @AfterThrowing(value = "execution(* com.cug.aop.User.add(..))")
  60.     public void afterThrowing(){
  61.         System.out.println("AfterThrowing..........");
  62.     }
  64.     @Around(value = "execution(* com.cug.aop.User.add(..))")
  65.     public Object around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
  66.         // 1
  67.         System.out.println("Around before..........");
  68.         // 被增强的方法执行
  69.         proceedingJoinPoint.proceed();
  70.         // 5
  71.         System.out.println("Around after..........");
  72.         return "around";
  73.     }
  74. }
  77. @SpringBootTest
  78. class ApoApplicationTests {
  79.     @Autowired
  80.     private User user;
  81.     @Test
  82.     void contextLoads() {
  83.         user.add("111");
  84.     }
  85. }