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

// Observer.ts 观察者接口
export interface Observer {
  // 可观察对象变更回调
  update(product: string, price: number): void;
  userUUID: string;
  email: string;
  subscriptionType: SubscriptionType;
  discountThreshold?: number; // 仅对 DISCOUNT_TO 类型有效
}

// 订阅类型枚举
export class SubscriptionType {
  private constructor(public readonly model: string) {}

  static readonly IN_STOCK = new SubscriptionType("IN_STOCK");
  static readonly DISCOUNT = new SubscriptionType("DISCOUNT");
  static readonly DISCOUNT_TO = new SubscriptionType("DISCOUNT_TO");

  getDescription(): string {
    switch (this.model) {
      case "IN_STOCK":
        return "来货通知";
      case "DISCOUNT":
        return "降价通知";
      case "DISCOUNT_TO":
        return "降价到预期通知";
      default:
        return "未知订阅";
    }
  }
}

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

// UserObserver.ts 实现具体的观察者，处理不同类型的通知
import {logger} from "../util/Logger"
import { Observer, SubscriptionType } from "./Observer";

export class UserObserver implements Observer {
  constructor(
    public userUUID: string,
    public email: string,
    public subscriptionType: SubscriptionType,
    public discountThreshold?: number // 仅对 DISCOUNT_TO 类型有效
  ) {}

  update(product: string, price: number): void {
    switch (this.subscriptionType) {
      case SubscriptionType.IN_STOCK:
        this.sendEmailNotification(`${product} 来货了!`);
        break;
      case SubscriptionType.DISCOUNT:
        this.sendEmailNotification(`${product} 现在已经降价至 $${price}!`);
        break;
      case SubscriptionType.DISCOUNT_TO:
        this.sendEmailNotification(
          `${product} 现在已经降价至 $${price}, 满足您期待的降价 $${
            this.discountThreshold ?? 0
          }% !`
        );
        break;
    }
  }

  private sendEmailNotification(message: string): void {
    logger.info(`发送邮件 ${this.email}: ${message}`);
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13

// Observable.ts 定义一个可观察对象接口，包括订阅、取消订阅和通知方法
import { Observer } from "../Observer";

export interface Observable {
  // 订阅
  subscribe(observer: Observer): void;

  // 取消订阅
  unsubscribe(observer: Observer): void;

  // 通知
  notifyObservers(): void;
}

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
68
69

// ProductObservable.ts  实现具体的可观察对象（商品通知器）
import { Observable } from "./Observable";
import { Observer, SubscriptionType } from "../Observer";
import { logger } from "../../util/Logger";

export class ProductObservable implements Observable {
  private publishers: Observer[] = [];
  private currentPrice: number = 0.0;
  private originalPrice: number = 100.0; // 原始价格，用于比较

  constructor(private product: string) {
    logger.info(
      `创建可观察对象（商品：${product}），价格 $${this.originalPrice}`
    );
  }

  subscribe(publisher: Observer): void {
    this.publishers.push(publisher);
    logger.info(
      `用户UUID： ${publisher.userUUID} ，成功订阅商品 ${
        this.product
      } ，订阅类型 ${publisher.subscriptionType.getDescription()}.`
    );
  }

  unsubscribe(publisher: Observer): void {
    this.publishers = this.publishers.filter(
      (obs) => obs.userUUID !== publisher.userUUID
    );
    logger.info(
      `用户UUID： ${publisher.userUUID} ，取消订阅商品 ${this.product} `
    );
  }

  notifyObservers(): void {
    for (const publisher of this.publishers) {
      switch (publisher.subscriptionType) {
        case SubscriptionType.IN_STOCK:
          publisher.update(this.product, this.currentPrice);
          break;
        case SubscriptionType.DISCOUNT:
          if (this.currentPrice < this.originalPrice) {
            publisher.update(this.product, this.currentPrice);
          }
          break;
        case SubscriptionType.DISCOUNT_TO:
          if (this.currentPrice <= (publisher.discountThreshold ?? 0)) {
            publisher.update(this.product, this.currentPrice);
          }
          break;
      }
    }
  }
  
  productRestocked(): void {
    logger.info(`商品 ${this.product} 采购成功`);
    this.notifyObservers();
  }

  productDiscounted(newPrice: number): void {
    this.currentPrice = newPrice;
    if (newPrice === this.originalPrice) {
      logger.info(`商品 ${this.product} 恢复原价`);
    } else {
      logger.info(`商品 ${this.product} 降价至: $${this.currentPrice}`);
    }
    this.notifyObservers();
  }
}

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

// main.ts
import { ProductObservable } from "./observable/ProductObservable";
import { UserObserver } from "./UserObserver";
import { SubscriptionType } from "./Observer";
import { logger } from "../util/Logger";

export const TestObserver = () => {
  // 创建可观察对象（商品通知器）
  const su7Notifier = new ProductObservable("小米SU7");

  // 创建观察者（用户）
  const user1 = new UserObserver(
    "UUID-1111",
    "user1@thatcoder.cn",
    SubscriptionType.IN_STOCK
  );
  const user2 = new UserObserver(
    "UUID-2222",
    "user2@thatcoder.cn",
    SubscriptionType.DISCOUNT
  );
  const user3 = new UserObserver(
    "UUID-3333",
    "user3@thatcoder.cn",
    SubscriptionType.DISCOUNT_TO,
    50
  );

  // 用户1订阅iPhone 15有货通知
  su7Notifier.subscribe(user1);
  // 用户2订阅iPhone 15降价通知
  su7Notifier.subscribe(user2);
  // 用户3订阅iPhone 15降价到50%通知
  su7Notifier.subscribe(user3);

  // 商品到货，通知相关用户
  su7Notifier.productRestocked();

  // 商品降价，通知相关用户
  su7Notifier.productDiscounted(60.0);

  // 商品恢复原价
  su7Notifier.productDiscounted(100.0);

  // 商品降价到50%，通知相关用户
  su7Notifier.productDiscounted(45.0);

  // 用户1取消iPhone 15的订阅
  su7Notifier.unsubscribe(user1);

  // 商品到货，通知剩余的用户
  su7Notifier.productRestocked();
};

1
2
3
4
5
6
7
8
9
10

import org.springframework.context.ApplicationListener
import org.springframework.context.event.ContextRefreshedEvent  
import org.springframework.stereotype.Component  
  
@Component  
class StartupListener : ApplicationListener<ContextRefreshedEvent> {  
    override fun onApplicationEvent(event: ContextRefreshedEvent) {  
        println("应用刷新成功!")  
    }  
}

1

data class OrderPlacedEvent(val orderId: String, val userEmail: String)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

import org.springframework.context.event.TransactionalEventListener
import org.springframework.stereotype.Component

@Component
class OrderPlacedEventListener {

    @TransactionalEventListener
    @Async
    fun handleOrderPlacedEvent(event: OrderPlacedEvent) {
        // 发送订单确认邮件
        val orderId = event.orderId
        val userEmail = event.userEmail
        println("发送 $orderId 信息到用户邮箱 $userEmail")
        // 实际发送邮件的逻辑...
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

import org.springframework.context.ApplicationEventPublisher
import org.springframework.stereotype.Service
import org.springframework.transaction.annotation.Transactional

@Service
class OrderService(private val eventPublisher: ApplicationEventPublisher) {

    @Transactional
    fun save(order: Order) {
        // 处理下单逻辑...
        // 发布事件
        eventPublisher.publishEvent(OrderPlacedEvent(orderId, userEmail))
    }
}

1
2
3
4
5
6
7
8

interface Handler : Comparable<Handler> {
    var index: Int  // 责任链顺序

    fun setNext(handler: Handler): Handler  // 下一个
    fun handleRequest(request: Request)  // 处理方法，处理同一种入参

    override fun compareTo(other: Handler): Int = this.index - other.index
}

1
2
3
4
5
6
7
8
9
10
11
12
13

// 基础处理者，提供处理链传递逻辑，并实现index
abstract class BaseHandler(override var index: Int) : Handler {
    private var nextHandler: Handler? = null

    override fun setNext(handler: Handler): Handler {
        nextHandler = handler
        return handler
    }

    override fun handleRequest(request: Request) {
        nextHandler?.handleRequest(request)
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

// 具体处理者1：处理认证逻辑
class AuthenticationHandler(index: Int) : BaseHandler(index) {
    override fun handleRequest(request: Request) {
        if ("ROLE_ADMIN" == request?.role) {
            super.handleRequest(request)
        } else {
            response.WriteError("认证失败")
        }
    }
}

// 具体处理者2：处理日志记录逻辑
class LoggingHandler(index: Int) : BaseHandler(index) {
    override fun handleRequest(request: Request) {
        Logger.info("登录：${request.username}")
        super.handleRequest(request)
    }
}

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

// 链的管理者：负责组装和管理责任链
class ChainManager {
    private val handlers: MutableList<Handler> = mutableListOf()
    // 添加处理器到链中，指定顺序
    fun addHandler(handler: Handler): ChainManager {
        handlers.add(handler)
        return this
    }
    // 从链中移除处理器
    fun removeHandler(handler: Handler): ChainManager {
        handlers.remove(handler)
        return this
    }
    // 构建责任链
    fun buildChain(): Handler? {
        if (handlers.isEmpty()) {
            throw IllegalArgumentException("空链")
        }
        // 根据index字段排序
        handlers.sort()
        // 链接处理器
        for (i in 0 until handlers.size - 1) {
            handlers[i].setNext(handlers[i + 1])
        }
        return handlers.firstOrNull()
    }
}

1
2
3
4
5
6
7
8
9

// 链的创建者：工厂类，用于创建责任链
object ChainCreator {
    fun createDefaultChain(): Handler? {
        val manager = ChainManager()
        manager.addHandler(LoggingHandler(2))  // 指定顺序
               .addHandler(AuthenticationHandler(1))
        return manager.buildChain()
    }
}

1
2
3
4
5
6
7
8
9
10
11

@Configuration
class WebConfig : WebMvcConfigurer {

    override fun addInterceptors(registry: InterceptorRegistry) {
        // 创建责任链
        val chain = ChainCreator.createDefaultChain()
        
        // 注册责任链的第一个处理者
        registry.addInterceptor(chain)
    }
}