通过发布订阅模式实现数据的异步处理，比如异步处理邮件发送
新建SpringBoot项目
项目结构
.
├── pom.xml
└── src
└── main
├── java
│ └── com
│ └── example
│ └── demo
│ ├── Application.java
│ ├── config
│ │ └── TaskPoolConfig.java
│ ├── controller
│ │ └── IndexController.java
│ ├── entity
│ │ └── EmailDto.java
│ ├── event
│ │ └── SendEmailEvent.java
│ ├── listener
│ │ └── SendEmailListener.java
│ └── service
│ ├── SendEmailService.java
│ └── impl
│ └── SendEmailServiceImpl.java
└── resources
├── application.yml
├── static
└── templates
实现代码
pom.xml
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
|
<? xml version = "1.0" encoding = "UTF-8" ?>
< project xmlns = "http://maven.apache.org/POM/4.0.0" xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd" >
< modelVersion >4.0.0</ modelVersion >
< parent >
< groupId >org.springframework.boot</ groupId >
< artifactId >spring-boot-starter-parent</ artifactId >
< version >2.7.7</ version >
< relativePath /> <!-- lookup parent from repository -->
</ parent >
< groupId >com.example</ groupId >
< artifactId >demo</ artifactId >
< version >0.0.1-SNAPSHOT</ version >
< name >demo</ name >
< description >Demo project for Spring Boot</ description >
< properties >
< java.version >1.8</ java.version >
</ properties >
< dependencies >
< dependency >
< groupId >org.springframework.boot</ groupId >
< artifactId >spring-boot-starter-web</ artifactId >
</ dependency >
< dependency >
< groupId >org.springframework.boot</ groupId >
< artifactId >spring-boot-devtools</ artifactId >
< scope >runtime</ scope >
< optional >true</ optional >
</ dependency >
< dependency >
< groupId >org.projectlombok</ groupId >
< artifactId >lombok</ artifactId >
< optional >true</ optional >
</ dependency >
< dependency >
< groupId >org.springframework.boot</ groupId >
< artifactId >spring-boot-starter-test</ artifactId >
< scope >test</ scope >
</ dependency >
</ dependencies >
< build >
< plugins >
< plugin >
< groupId >org.springframework.boot</ groupId >
< artifactId >spring-boot-maven-plugin</ artifactId >
< configuration >
< excludes >
< exclude >
< groupId >org.projectlombok</ groupId >
< artifactId >lombok</ artifactId >
</ exclude >
</ excludes >
</ configuration >
</ plugin >
</ plugins >
</ build >
</ project >
|
Application.java
|
1
2
3
4
5
6
7
8
9
10
11
12
|
package com.example.demo;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application. class , args);
}
}
|
TaskPoolConfig.java
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
|
package com.example.demo.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import java.util.concurrent.Executor;
/**
* 线程池参数配置
**/
@EnableAsync
@Configuration
public class TaskPoolConfig {
/**
* 自定义线程池
**/
@Bean
public Executor taskExecutor() {
//返回可用处理器的Java虚拟机的数量 12
int i = Runtime.getRuntime().availableProcessors();
System.out.println( "系统最大线程数 ： " + i);
ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
//核心线程池大小
executor.setCorePoolSize( 16 );
//最大线程数
executor.setMaxPoolSize( 20 );
//配置队列容量，默认值为Integer.MAX_VALUE
executor.setQueueCapacity( 99999 );
//活跃时间
executor.setKeepAliveSeconds( 60 );
//线程名字前缀
executor.setThreadNamePrefix( "asyncServiceExecutor -" );
//设置此执行程序应该在关闭时阻止的最大秒数，以便在容器的其余部分继续关闭之前等待剩余的任务完成他们的执行
executor.setAwaitTerminationSeconds( 60 );
//等待所有的任务结束后再关闭线程池
executor.setWaitForTasksToCompleteOnShutdown( true );
return executor;
}
}
|
EmailDto.java
|
1
2
3
4
5
6
7
8
9
10
|
package com.example.demo.entity;
import lombok.Data;
@Data
public class EmailDto {
private String email;
private String subject;
private String content;
}
|
SendEmailEvent.java
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
package com.example.demo.event;
import com.example.demo.entity.EmailDto;
import org.springframework.context.ApplicationEvent;
/**
* 自定义事件
*/
public class SendEmailEvent extends ApplicationEvent {
private EmailDto emailDto;
public SendEmailEvent(EmailDto emailDto) {
super (emailDto);
this .emailDto = emailDto;
}
public EmailDto getEmailDto() {
return this .emailDto;
}
}
|
SendEmailListener.java
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
package com.example.demo.listener;
import com.example.demo.entity.EmailDto;
import com.example.demo.event.SendEmailEvent;
import com.example.demo.service.SendEmailService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationListener;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;
/**
* 事件监听器
*/
@Component
public class SendEmailListener implements ApplicationListener<SendEmailEvent> {
@Autowired
private SendEmailService sendEmailService;
@Async
@Override
public void onApplicationEvent(SendEmailEvent event) {
EmailDto emailDto = event.getEmailDto();
this .sendEmailService.sendEmail(emailDto);
}
}
|
SendEmailService.java
|
1
2
3
4
5
6
7
|
package com.example.demo.service;
import com.example.demo.entity.EmailDto;
public interface SendEmailService {
void sendEmail(EmailDto emailDto);
}
|
SendEmailServiceImpl.java
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
package com.example.demo.service.impl;
import com.example.demo.entity.EmailDto;
import com.example.demo.service.SendEmailService;
import org.springframework.stereotype.Service;
@Service
public class SendEmailServiceImpl implements SendEmailService {
@Override
public void sendEmail(EmailDto emailDto) {
try {
// 模拟耗时3秒
Thread.sleep( 3 * 1000 );
} catch (Exception e) {
System.out.println( "Email发送异常" );
}
System.out.println( "Email发送成功 " + emailDto);
}
}
|
IndexController.java
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
|
package com.example.demo.controller;
import com.example.demo.entity.EmailDto;
import com.example.demo.event.SendEmailEvent;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class IndexController {
@Autowired
private ApplicationEventPublisher publisher;
@GetMapping ( "/sendEmail" )
public String sendEmail() {
EmailDto emailDto = new EmailDto();
emailDto.setEmail( "tom@qq.com" );
emailDto.setSubject( "邮件标题" );
emailDto.setContent( "邮件内容" );
// 发布事件
publisher.publishEvent( new SendEmailEvent(emailDto));
return "success" ;
}
}
|
到此这篇关于详解SpringBoot实现ApplicationEvent事件的监听与发布的文章就介绍到这了,更多相关SpringBoot ApplicationEvent事件监听发布内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！
原文链接：https://blog.csdn.net/mouday/article/details/129380700
查看更多关于详解SpringBoot实现ApplicationEvent事件的监听与发布的详细内容...
声明：本文来自网络，不代表【好得很程序员自学网】立场，转载请注明出处：http://www.haodehen.cn/did188980