观察者模式
1.定义
观察者模式又叫做发布-订阅(Publish/Subscribe)模式。定义了一种一对多的依赖关系,让多个观察者对象同时监听某一个主题对象。这个主题对象在状态发生变化时,会通知所有观察者对象,使它们能够自动更新自己。
2.实现
使用JDK工具包实现
具体主题或具体通知者
package com.design.pattern.observer.jdk;
import java.util.Observable;
/**
* Created by Administrator on 2021/4/14.
* 具体主题或具体通知者
*/
public class ConcreteSubject extends Observable {
public void changeState(){
//改变状态
this.setChanged();
//通知所有观察者
this.notifyObservers();
}
}
具体观察者
package com.design.pattern.observer.jdk;
import lombok.Data;
import lombok.NonNull;
import lombok.RequiredArgsConstructor;
import java.util.Observable;
import java.util.Observer;
/**
* Created by Administrator on 2021/4/14.
* 具体观察者
*/
@RequiredArgsConstructor
@Data
public class ConcreteObserver implements Observer {
@NonNull
private String name;
@Override
public void update(Observable o, Object arg) {
System.out.println(String .format("观察者%s收到了更新",name));
}
}
测试
import org.junit.Test;
import com.design.pattern.observer.jdk.ConcreteSubject;
import com.design.pattern.observer.jdk.ConcreteObserver;
/**
* Created by Administrator on 2021/4/14.
*/
public class ObserverTest {
@Test
public void testJDK(){
//创建具体主题或具体通知者
ConcreteSubject observable = new ConcreteSubject();
//添加张三观察者
observable.addObserver(new ConcreteObserver("张三"));
//添加李四观察者
observable.addObserver(new ConcreteObserver("李四"));
//具体主题或具体通知者改变状态
observable.changeState();
}
}
结果
观察者李四收到了更新
观察者张三收到了更新
自定义实现
主题或抽象通知者
package com.design.pattern.observer.custom;
import java.util.List;
import java.util.Vector;
/**
* Created by Administrator on 2021/4/14.
* 主题或抽象通知者
*/
public abstract class CustomSubject {
private List<CustomObserver> customObservers = new Vector<>();
//增加观察者
public synchronized void attach(CustomObserver customObserver){
if (customObserver == null)
throw new NullPointerException();
if (!customObservers.contains(customObserver)) {
customObservers.add(customObserver);
}
}
//移除观察者
public synchronized void detach(CustomObserver customObserver){
customObservers.remove(customObserver);
}
//通知
public void notifyObeservers(){
for (int i = 0; i < customObservers.size(); i++) {
CustomObserver customObserver = customObservers.get(i);
customObserver.update();
}
}
}
抽象观察者
package com.design.pattern.observer.custom;
/**
* Created by Administrator on 2021/4/14.
* 抽象观察者
*/
public abstract class CustomObserver {
public abstract void update();
}
具体的主题或通知者
package com.design.pattern.observer.custom;
/**
* Created by Administrator on 2021/4/14.
* 具体的主题或通知者
*/
public class ConcreteCustomSubject extends CustomSubject {
}
具体的观察者
package com.design.pattern.observer.custom;
import lombok.NonNull;
import lombok.RequiredArgsConstructor;
/**
* Created by Administrator on 2021/4/14.
* 具体的观察者
*/
@RequiredArgsConstructor
public class ConcreteCustomObeserver extends CustomObserver {
@NonNull
private String name;
@NonNull
private CustomSubject customSubject;
@Override
public void update() {
System.out.println(String.format("观察者%s收到了通知",name));
}
}
测试
@Test
public void testCustom(){
//创建具体主题或具体通知者
ConcreteCustomSubject concreteCustomSubject = new ConcreteCustomSubject();
//添加张三观察者
concreteCustomSubject.attach(new ConcreteCustomObeserver("张三",concreteCustomSubject));
//添加李四观察者
concreteCustomSubject.attach(new ConcreteCustomObeserver("李四",concreteCustomSubject));
//具体主题或具体通知者通知所有观察者
concreteCustomSubject.notifyObeservers();
}
事件委托
1.定义
委托就是一种引用方法的类型。 一旦为委托分配了方法, 委托将与该方法具有完全相同的行为。 委托方法的使用可以像其他任何方法一样, 具有参数和返回值。 委托可以看作是对函数的抽象, 是函数的 ‘类 ’, 委托的实例将代表一个具体的函数。——出处《大话设计模式》
一个委托可以搭载多个方法, 所有方法被依次唤起。 更重要的是, 它可以使得委托对 象所搭载的方法井不需要属于同一个类。
在java中没有事件委托的概念,可以自己实现
2.实现
事件对象
package com.design.pattern.observer.event;
import lombok.Getter;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Arrays;
/**
* Created by Administrator on 2021/4/14.
* 事件对象,要执行方法的对象需重写hashCode和equals方法
*/
@Getter
public class Event {
//要执行方法的对象
private Object object;
//要执行的方法名称
private String methodName;
//要执行方法的参数
private Object[] params;
//要执行方法的参数类型
private Class[] paramTypes;
public Event(Object object,String methodName,Object...args){
this.params=args;
convertParamsToParamTypes(this.params);
setObject(object);
setMethodName(methodName);
}
private void setMethodName(String methodName) {
if(methodName==null||methodName.trim().length()==0){
throw new IllegalArgumentException("methodName must be not null or empty string");
}
try {
Method method=object.getClass().getMethod(methodName, this.getParamTypes());
} catch (NoSuchMethodException e) {
try {
Method method = object.getClass().getDeclaredMethod(methodName, this.getParamTypes());
} catch (NoSuchMethodException e1) {
throw new RuntimeException(String.format("对象%s没有该参数类型%s的方法%s,e:%s",object.toString(),Arrays.toString(paramTypes),methodName,e));
}
throw new RuntimeException(String.format("对象%s参数类型为%s的%s方法不可访问,e:%s",object.toString(),Arrays.toString(paramTypes),methodName,e));
}
this.methodName=methodName.trim();
}
private void setObject(Object object) {
if(object==null){
throw new IllegalArgumentException("object must be not null");
}
this.object=object;
}
//根据参数数组生成参数类型数组
private void convertParamsToParamTypes(Object[] params){
if(params!=null) {
this.paramTypes = new Class[params.length];
for (int i = 0; i < params.length; i++) {
this.paramTypes[i] = params[i].getClass();
}
}
}
//执行该 对象的该方法
public void invoke(){
try {
Method method=object.getClass().getMethod(this.getMethodName(), this.getParamTypes());
method.invoke(this.getObject(), this.getParams());
} catch (NoSuchMethodException e) {
System.out.println(String.format("对象%s没有该参数类型%s的方法%s,e:%s",object.toString(),Arrays.toString(paramTypes),methodName,e));
} catch (IllegalAccessException e) {
System.out.println(String.format("对象%s参数类型为%s的%s方法不可访问,e:%s",object.toString(),Arrays.toString(paramTypes),methodName,e));
} catch (InvocationTargetException e) {
System.out.println(String.format("对象%s参数类型为%s的%s方法执行错误,e:%s",object.toString(),Arrays.toString(paramTypes),methodName,e));
}
}
@Override
public boolean equals(Object obj){
if(obj==null){
return false;
}
if(this==obj){
return true;
}
if(!(obj instanceof Event)){
return false;
}
Event objEvent = (Event) obj;
if(!objEvent.getObject().equals(object)){
return false;
}
if(!objEvent.getMethodName().equals(methodName)){
return false;
}
Class[] objParamTypes = objEvent.getParamTypes();
Object[] objParams = objEvent.getParams();
return areParametersEqual(objParamTypes, objParams);
}
private boolean areParametersEqual(Class[] objParamTypes, Object[] objParams) {
if(paramTypes==null){
if(objParamTypes!=null) {
return false;
}
return true;
}
if(objParamTypes ==null|| paramTypes.length!=objParamTypes.length){
return false;
}
for (int i = 0; i < paramTypes.length; i++) {
if(!paramTypes[i].getName().equals(objParamTypes[i].getName())){
return false;
}
}
//类型是根据传递的方法参数自动创建的,所以空和参数个数都是一致的,不需再判断
for (int i = 0; i < params.length; i++) {
if(!params[i].equals(objParams[i])){
return false;
}
}
return true;
}
@Override
public int hashCode(){
int h = object.hashCode() + methodName.hashCode();
if(params!=null&¶ms.length>0){
for (int i = 0; i < params.length; i++) {
if(params[i]!=null){
h += params[i].hashCode();
}
}
}
return h;
}
}
事件处理对象
package com.design.pattern.observer.event;
import java.util.*;
/**
* Created by Administrator on 2021/4/14.
* 事件处理对象
*/
public class EventHandle {
List<Event> events = new Vector<>();
//添加某个对象要执行的事件
public synchronized void addEvent(Event event){
if(!events.contains(event)) {
events.add(event);
}
}
public synchronized void removeEvent(Event event){
events.remove(event);
}
public void notifyEvents(){
if(events!=null){
for (int i = 0; i < events.size(); i++) {
events.get(i).invoke();
}
}
}
}
抽象主题或通知
package com.design.pattern.observer.event;
/**
* Created by Administrator on 2021/4/15.
* 抽象主题或通知
*/
public abstract class AbstractSubject {
private EventHandle eventHandle=new EventHandle();
public void attatch(Object obj,String methodName,Object...args){
eventHandle.addEvent(new Event(obj,methodName,args));
}
public void detach(Object obj,String methodName,Object...args){
eventHandle.removeEvent(new Event(obj,methodName,args));
}
public void notifyObservers(){
eventHandle.notifyEvents();
}
}
具体主题或通知
package com.design.pattern.observer.event;
import lombok.NonNull;
import lombok.RequiredArgsConstructor;
/**
* Created by Administrator on 2021/4/15.
* 具体主题或者具体通知类
*/
@RequiredArgsConstructor
public class SubjectOne extends AbstractSubject {
@NonNull
private String name;
}
观察者1
package com.design.pattern.observer.event;
import lombok.*;
/**
* Created by Administrator on 2021/4/15.
* 具体观察者1,重写hashCode和equals方法
*/
@RequiredArgsConstructor
@EqualsAndHashCode
@ToString
public class ObserverOne {
@NonNull
private String name;
public void oneUpdate(){
System.out.println("通知到观察者"+name+",观察者"+name+"的oneUpdate方法执行了");
}
}
观察者2
package com.design.pattern.observer.event;
import lombok.EqualsAndHashCode;
import lombok.NonNull;
import lombok.RequiredArgsConstructor;
import lombok.ToString;
/**
* Created by Administrator on 2021/4/15.
* 具体观察者2,重写hashCode和equals方法
*/
@RequiredArgsConstructor
@EqualsAndHashCode
@ToString
public class ObserverTwo {
@NonNull
private String name;
public void twoUpdate(String str){
System.out.println("通知到观察者"+name+",观察者"+name+"的twoUpdate方法执行了,接收到的参数为:"+str);
}
}
测试
@Test
public void testEventDelegation(){
//创建具体主题或具体通知者
SubjectOne subject = new SubjectOne("通知者1");
//添加观察者张三
ObserverOne objOne = new ObserverOne("张三");
subject.attatch(objOne,"oneUpdate");
subject.attatch(objOne,"oneUpdate");
subject.attatch(new ObserverOne("张三"),"oneUpdate");
//添加观察者李四
ObserverTwo objTwo = new ObserverTwo("李四");
subject.attatch(objTwo,"twoUpdate","你好");
//具体主题或具体通知者通知所有观察者
subject.notifyObservers();
subject.detach(new ObserverOne("张三"),"oneUpdate");
//subject.detach(new ObserverTwo("李四"),"twoUpdate");
subject.notifyObservers();
}
通知到观察者张三,观察者张三的oneUpdate方法执行了
通知到观察者李四,观察者李四的twoUpdate方法执行了,接收到的参数为:你好
通知到观察者李四,观察者李四的twoUpdate方法执行了,接收到的参数为:你好