Что
Шаблон наблюдатель - это шаблон проектирования в котором объект, называемый субъектом, хранит список наблюдаемых объектов, называемых наблюдателями, и следит за изменениями в их состояниях, обычно вызывая один из их методов. Подробнее.
Перехват событий(или коллбеки) - простой способ реализации шаблона наблюдения когда субъект сообщает наблюдателям, что произошло то или иное событие.
Почему
Перехват событий может быть использован в событийно-управляемым программировании(event-driven programming), в котором поток программы разбит на различные события. Такие как действия пользователя, вывод данных, сообщения из потоков\программ. Подробнее
Как
Мы используем особенность Rust под названием трейты(trains), чтобы определить ожидаемое поведение интерфейса событий. Трейты будут состоять из обработчика событий, который, в свою очередь, по заголовку событий будет определять что это за событие.
Использование трейтов делает наш обработчик событий универсальным(они могут быть любого типа). Все, что надо будет сделать - реализовать трейт на каждое событие.
Для примера, я реализовал событийно-управляемый Логгер(Logger), который записывает события TCP подключений.
Ниже трейт который реализует интерфейс событий для TCP подключений:
| C | 1
2
3
4
5
6
7
8
9
| #[allow(unused_variables)]
pub trait Events {
fn on_connect(&self, host: &str, port: i32) {}
fn on_error(&self, err: &str) {}
fn on_read(&self, resp: &[u8]) {}
fn on_shutdown(&self) {}
fn on_pre_read(&self) {}
fn on_post_read(&self) {}
} |
|
| C | 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
| struct Logger;
impl Events for Logger {
fn on_connect(&self, host: &str, port: i32) {
println!("Connected to {} on port {}", host, port);
}
fn on_error(&self, err: &str) {
println!("error: {}", err);
}
fn on_read(&self, resp: &[u8]) {
print!("{}", str::from_utf8(resp).unwrap());
}
fn on_shutdown(&self) {
println!("Connection closed.");
}
fn on_pre_read(&self) {
println!("Receiving content:\n");
}
fn on_post_read(&self) {
println!("\nFinished receiving content.")
}
} |
|
Далее, у нас есть структура HttpClient, в имплементации которой выполняются сетевые tcp вызовы и уведомляют наблюдателей, о том что событие произошло.
| C | 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
61
62
63
64
65
66
67
| struct HttpClient {
host: String,
port: i32,
hooks: Vec<Box<Events>>,
}
impl HttpClient {
pub fn new(host: &str, port: i32) -> Self {
Self {
host: host.to_owned(),
port: port,
hooks: Vec::new(),
}
}
pub fn add_events_hook<E: Events + 'static>(&mut self, hook: E) {
self.hooks.push(Box::new(hook));
}
pub fn get(&self, endpoint: &str) {
let cmd = format!("GET {} HTTP/1.1\r\nHost: {}\r\n\r\n", endpoint, self.host).into_bytes();
let mut socket = self.connect().unwrap();
socket.write(cmd.as_slice()).unwrap();
socket.flush().unwrap();
for hook in &self.hooks {
hook.on_pre_read();
}
loop {
let mut buf = vec![0; 512usize];
let cnt = socket.read(&mut buf[..]).unwrap();
buf.truncate(cnt);
if !buf.is_empty() {
for hook in &self.hooks {
hook.on_read(buf.as_slice());
}
} else {
for hook in &self.hooks {
hook.on_post_read();
}
break;
}
}
for hook in &self.hooks {
hook.on_shutdown();
}
}
pub fn connect(&self) -> io::Result<TcpStream>{
let addr = format!("{}:{}", self.host, self.port);
match TcpStream::connect(addr) {
Ok(stream) => {
for hook in &self.hooks {
hook.on_connect(&self.host, self.port);
}
Ok(stream)
},
Err(error) => {
for hook in &self.hooks {
hook.on_error(error.description());
}
Err(error)
},
}
}
} |
|
Соберем все вместе в функции main, которая:- инициализирует HttpClient
- регистрирует Логгер как обработчик событий для HttpCliemt
- Выполняет сетевые вызовы используя HttpClient. Результат вызовов попадают в события структуры Logger
| C | 1
2
3
4
5
| fn main() {
let mut http_stream = HttpClient::new("httpbin.org", 80);
http_stream.add_events_hook(Logger);
http_stream.get("/ip");
} |
|
| Bash | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
| Connected to httpbin.org on port 80
Receiving content:
HTTP/1.1 200 OK
Connection: keep-alive
Server: meinheld/0.6.1
Date: Fri, 03 Nov 2017 09:16:40 GMT
Content-Type: application/json
Access-Control-Allow-Origin: *
Access-Control-Allow-Credentials: true
X-Powered-By: Flask
X-Processed-Time: 0.000749111175537
Content-Length: 33
Via: 1.1 vegur
{
"origin": "212.22.171.150"
}
Finished receiving content.
Connection closed. |
|
Сноски
Событийно-управляемый подход довольно часто используется в Rust. Вот список наиболее интересных на мой взгляд проектов:
Ссылки- https://en.wikipedia.org/wiki/Observer_pattern
- https://en.wikipedia.org/wiki/... rogramming
- https://doc.rust-lang.org/book... raits.html
- https://doc.rust-lang.org/book... raits.html
- https://doc.rust-lang.org/std/... tream.html
- https://github.com/seanmonstar/reqwest/issues/155
Оригинал
|
