java设计模式：观察者模式

参考博客：Java观察者模式(Observer)
SpringBoot事件监听机制及观察者模式/发布订阅模式

1.使用场景

聊天室程序的创建。服务器创建好后，A,B,C三个客户端连上来公开聊天。A向服务器发送数据，服务器端聊天数据改变。我们希望将这些聊天数据分别发给他在线的客户。也就是说，每个客户端需要更新服务器端得数据。
网站上，很多人订阅了”java主题”的新闻。当有这个主题新闻时，就会将这些新闻发给所有订阅的人。
大家一起玩CS游戏时，服务器需要将每个人的方位变化发给所有的客户
  上面这些场景，我们都可以使用观察者模式来处理。我们可以把多个订阅者、客户称之为观察者； 需要同步给多个订阅者的数据封装到对象中，称之为目标.
Uml类图

1.1 核心角色

抽象被观察者角色：
  也就是一个抽象主题，它把所有对观察者对象的引用保存在一个集合中，每个主题都可以有任意数量的观察者。抽象主题提供一个接口，可以增加和删除观察者角色。一般用一个抽象类和接口来实现。
抽象观察者角色：
  为所有的具体观察者定义一个接口，在得到主题通知时更新自己。
具体被观察者角色：
  也就是一个具体的主题，在集体主题的内部状态改变时，所有登记过的观察者发出通知。
具体观察者角色：
  实现抽象观察者角色所需要的更新接口，一边使本身的状态与制图的状态相协调。

2.手动实现观察者模式

(1)定义抽象被观察者角色

package com.dpb.observer;

import java.util.ArrayList;
import java.util.List;
/**
 * 观察者模式：目标对象模板
 * @author dengp
 *
 */
public interface Subject<T> {
	// 存储订阅者
	List<Observer> list = new ArrayList<>();
	// 注册订阅者
	public void registerObserver(T obs);
	// 移除订阅者
	public void removeObserver(T obs);
	//通知所有的观察者更新状态
	public void notifyAllObservers();
}

(2)定义抽象观察者角色

/**
 * 观察者模式:定义观察者 
 * @author dengp
 *
 */
public interface Observer {
	void  update(Subject subject);
}

(3)定义具体被观察者角色

/**
 * 观察者模式:目标对象(主体对象 topic)
 * @author dengp
 *
 */
public class ConcreteSubject implements Subject<Observer> {
	
	
	private int state;

	public int getState() {
		return state;
	}

	public void setState(int state) {
		this.state = state;
		//主题对象(目标对象)值发生了变化，请通知所有的观察者
		this.notifyAllObservers();
	}

	@Override
	public void notifyAllObservers() {
		for (Observer obs : list) {
			// 更新每一个观察者中的信息
			obs.update(this);
		}
	}

	@Override
	public void registerObserver(Observer obs) {
		// TODO Auto-generated method stub
		list.add(obs);
	}


	@Override
	public void removeObserver(Observer obs) {
		// TODO Auto-generated method stub
		list.remove(obs);
	}
}

(4)定义具体观察者角色

package com.dpb.observer;

/**
 * 观察者模式：观察者 实现
 * @author dengp
 *
 */
public class ObserverA implements Observer {
	
	//myState需要跟目标对象的state值保持一致！
	private int myState;   
	
	/**
	 * 更新为和目标对象的值一致
	 */
	@Override
	public void update(Subject subject) {
		myState = ((ConcreteSubject)subject).getState();
	}

	public int getMyState() {
		return myState;
	}
	public void setMyState(int myState) {
		this.myState = myState;
	}
}

测试

package com.dpb.observer;

public class Client {
	public static void main(String[] args) {
		//目标对象
		ConcreteSubject subject = new ConcreteSubject();
		
		//创建多个观察者
		ObserverA  obs1 = new ObserverA();
		ObserverA  obs2 = new ObserverA();
		ObserverA  obs3 = new ObserverA();
		
		//将这三个观察者添加到subject对象的观察者队伍中
		subject.registerObserver(obs1);
		subject.registerObserver(obs2);
		subject.registerObserver(obs3);
		
		
		//改变subject的状态
		subject.setState(3000);
		System.out.println("########################");
		//我们看看，观察者的状态是不是也发生了变化
		System.out.println(obs1.getMyState());
		System.out.println(obs2.getMyState());
		System.out.println(obs3.getMyState());
		
		//改变subject的状态
		subject.setState(30);
		System.out.println("########################");
		//我们看看，观察者的状态是不是也发生了变化
		System.out.println(obs1.getMyState());
		System.out.println(obs2.getMyState());
		System.out.println(obs3.getMyState());
		
		//改变subject的状态
		subject.setState(99);
		System.out.println("########################");
		//我们看看，观察者的状态是不是也发生了变化
		System.out.println(obs1.getMyState());
		System.out.println(obs2.getMyState());
		System.out.println(obs3.getMyState());
	}
}

3.Java内置观察者模式实现

在java.util包中包含有基本的Observer接口和Observable抽象类.功能上和Subject接口和Observer接口类似.不过在使用上,就方便多了,因为许多功能比如说注册,删除,通知观察者的那些功能已经内置好了.
(1)定义具体被观察者

package com.dpb.observer2;

import java.util.Observable;

/**
 * 目标对象
 * 继承 Observable
 * @author dengp
 *
 */
public class ConcreteSubject extends Observable {
	
	private int state; 
	
	public void set(int s){
		state = s;  //目标对象的状态发生了改变
		setChanged();  //表示目标对象已经做了更改
		notifyObservers(state);  //通知所有的观察者
	}

	public int getState() {
		return state;
	}

	public void setState(int state) {
		this.state = state;
	}
}

观察者只需要继承Observable父类。发送消息的方式执行如下两行代码即可

setChanged();  //表示目标对象已经做了更改
notifyObservers(state);  //通知所有的观察者

(2)定义观察者

package com.dpb.observer2;

import java.util.Observable;
import java.util.Observer;
/**
 * 观察者模式：观察者(消息订阅者)
 * 实现Observer接口
 * @author dengp
 *
 */
public class ObserverA implements Observer {

	private int myState;
	
	@Override
	public void update(Observable o, Object arg) {
		myState = ((ConcreteSubject)o).getState();
	}
	public int getMyState() {
		return myState;
	}
	public void setMyState(int myState) {
		this.myState = myState;
	}
}

观察者也就是订阅者只需要实现Observer接口并重写相关update方法即可，在目标实现中我们发现触发的时候执行的就是观察者的update方法。
测试

package com.dpb.observer2;

public class Client {
	public static void main(String[] args) {
		//创建目标对象Obserable
		ConcreteSubject subject = new ConcreteSubject();
		
		//创建观察者
		ObserverA obs1 = new ObserverA();
		ObserverA obs2 = new ObserverA();
		ObserverA obs3 = new ObserverA();
		
		//将上面三个观察者对象添加到目标对象subject的观察者容器中
		subject.addObserver(obs1);
		subject.addObserver(obs2);
		subject.addObserver(obs3);
		
		//改变subject对象的状态
		subject.set(3000);
		System.out.println("===============状态修改了！");
		//观察者的状态发生了变化
		System.out.println(obs1.getMyState());
		System.out.println(obs2.getMyState());
		System.out.println(obs3.getMyState());

		subject.set(600);
		System.out.println("===============状态修改了！");
		//观察者的状态发生了变化
		System.out.println(obs1.getMyState());
		System.out.println(obs2.getMyState());
		System.out.println(obs3.getMyState());
		
		//移除一个订阅者
		subject.deleteObserver(obs2);
		subject.set(100);
		System.out.println("===============状态修改了！");
		//观察者的状态发生了变化
		System.out.println(obs1.getMyState());
		System.out.println(obs2.getMyState());
		System.out.println(obs3.getMyState());	
	}
}

4.实践（springboot中应用）

在GoF的《设计模式》中，观察者模式的定义：在对象之间定义一个一对多的依赖，当一个对象状态改变的时候，所有依赖的对象都会自动收到通知。如果你觉得比较抽象，接下来这个例子应该会让你有所感觉：

就拿用户注册功能为例吧，假设用户注册成功之后，我们将会发送邮件，优惠券等等操作，很容易就能写出下面的逻辑：

@RestController
@RequestMapping("/user")
public class SimpleUserController {

    @Autowired
    private SimpleEmailService emailService;

    @Autowired
    private SimpleCouponService couponService;

    @Autowired
    private SimpleUserService userService;

    @GetMapping("/register")
    public String register(String username) {
        // 注册
        userService.register(username);
        // 发送邮件
        emailService.sendEmail(username);
        // 发送优惠券
        couponService.addCoupon(username);
        return "注册成功!";
    }
}

这样写会有什么问题呢？

方法调用时，同步阻塞导致响应变慢，需要异步非阻塞的解决方案。

注册接口此时做的事情：注册，发邮件，优惠券，违反单一职责的原则。当然，如果后续没有拓展和修改的需求，这样子倒可以接受。

如果后续注册的需求频繁变更，相应就需要频繁变更register方法，违反了开闭原则。

针对以上的问题，我们想一想解决的方案：

一、异步非阻塞的效果可以新开一个线程执行耗时的发送邮件任务，但频繁地创建和销毁线程比较耗时，并且并发线程数无法控制，创建过多的线程会导致堆栈溢出。

二、使用线程池执行任务解决上述问题。

@Service
@Slf4j
public class SimpleEmailService {
	// 启动一个线程执行耗时操作
    public void sendEmail(String username) {
        Thread thread = new Thread(()->{
            try {
                // 模拟发邮件耗时操作
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            log.info("给用户 [{}] 发送邮件...", username);
        });
        thread.start();
    }
}

@Slf4j
@Service
public class SimpleCouponService {

    ExecutorService executorService = Executors.newSingleThreadExecutor();
	// 线程池执行任务，减少资源消耗
    public void addCoupon(String username) {
        executorService.execute(() -> {
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            log.info("给用户 [{}] 发放优惠券", username);
        });
    }
}

这里用户注册事件对【发送短信和优惠券】其实是一对多的关系，可以使用观察者模式进行解耦：

/**
 * 主题接口
 * @author Summerday
 */
public interface Subject {

    void registerObserver(Observer observer);
    void removeObserver(Observer observer);
    void notifyObservers(String message);
}

/**
 * 观察者接口
 * @author Summerday
 */
public interface Observer {

    void update(String message);
}

@Component
@Slf4j
public class EmailObserver implements Observer {

    @Override
    public void update(String message) {
        log.info("向[{}]发送邮件", message);
    }
}
@Component
@Slf4j
public class CouponObserver implements Observer {

    @Override
    public void update(String message) {
        log.info("向[{}]发送优惠券",message);
    }
}

@Component
public class UserRegisterSubject implements Subject {

    @Autowired
    List<Observer> observers;

    @Override
    public void registerObserver(Observer observer) {
        observers.add(observer);
    }

    @Override
    public void removeObserver(Observer observer) {
        observers.remove(observer);
    }

    @Override
    public void notifyObservers(String username) {
        for (Observer observer : observers) {
            observer.update(username);
        }
    }
}


@RestController
@RequestMapping("/")
public class UserController {

    @Autowired
    UserRegisterSubject subject;

    @Autowired
    private SimpleUserService userService;


    @GetMapping("/reg")
    public String reg(String username) {
        userService.register(username);
        subject.notifyObservers(username);
        return "success";
    }
}

发布订阅模式是什么?
观察者模式和发布订阅模式是有一点点区别的，区别有以下几点：

前者：观察者订阅主题，主题也维护观察者的记录，而后者：发布者和订阅者不需要彼此了解，而是在消息队列或代理的帮助下通信，实现松耦合。
前者主要以同步方式实现，即某个事件发生时，由Subject调用所有Observers的对应方法，后者则主要使用消息队列异步实现。

尽管两者存在差异，但是他们其实在概念上相似，网上说法很多，不需要过于纠结，重点在于我们需要他们为什么出现，解决了什么问题。
Spring事件监听机制概述
SpringBoot中事件监听机制则通过发布-订阅实现，主要包括以下三部分：

事件 ApplicationEvent，继承JDK的EventObject，可自定义事件。
事件发布者 ApplicationEventPublisher，负责事件发布。
事件监听者 ApplicationListener，继承JDK的EventListener，负责监听指定的事件。
我们通过SpringBoot的方式，能够很容易实现事件监听，接下来我们改造一下上面的案例：

SpringBoot事件监听
(1)定义注册事件

public class UserRegisterEvent extends ApplicationEvent {
    
    private String username;

    public UserRegisterEvent(Object source) {
        super(source);
    }

    public UserRegisterEvent(Object source, String username) {
        super(source);
        this.username = username;
    }

    public String getUsername() {
        return username;
    }
}

(2)两种方式监听器，使用注解的方式和实现类的方式，同时可以使用异步操作
例1：注解，没使用异步

/**
 * 注解方式 @EventListener
 * @author Summerday
 */
@Service
@Slf4j
public class CouponService {
    /**
     * 监听用户注册事件,执行发放优惠券逻辑
     */
    @EventListener
    public void addCoupon(UserRegisterEvent event) {
        log.info("给用户[{}]发放优惠券", event.getUsername());
    }
}

例2：实现使用异步

/**
 * 实现ApplicationListener<Event>的方式
 * @author Summerday
 */
@Service
@Slf4j
public class EmailService implements ApplicationListener<UserRegisterEvent> {
    /**
     * 监听用户注册事件, 异步发送执行发送邮件逻辑
     */
    @Override
    @Async
    public void onApplicationEvent(UserRegisterEvent event) {
        log.info("给用户[{}]发送邮件", event.getUsername());
    }
}

(3) 注册事件发布者

@Service
@Slf4j
public class UserService implements ApplicationEventPublisherAware {

    // 注入事件发布者
    private ApplicationEventPublisher applicationEventPublisher;

    @Override
    public void setApplicationEventPublisher(ApplicationEventPublisher applicationEventPublisher) {
        this.applicationEventPublisher = applicationEventPublisher;
    }

    /**
     * 发布事件
     */
    public void register(String username) {
        log.info("执行用户[{}]的注册逻辑", username);
        applicationEventPublisher.publishEvent(new UserRegisterEvent(this, username));
    }
}

(5)定义接口

@RestController
@RequestMapping("/event")
public class UserEventController {

    @Autowired
    private UserService userService;

    @GetMapping("/register")
    public String register(String username){
        userService.register(username);
        return "恭喜注册成功!";
    }
}

(6)启动类

@EnableAsync // 开启异步
@SpringBootApplication
public class SpringBootEventListenerApplication {

    public static void main(String[] args) {

        SpringApplication.run(SpringBootEventListenerApplication.class, args);
    }

}

中的代码样例已经全部上传至Gitee：https://gitee.com/tqbx/springboot-samples-learn