android中关于观察者模式的demo

最新推荐文章于 2021-06-07 15:57:50 发布
最新推荐文章于 2021-06-07 15:57:50 发布
阅读量304 收藏
点赞数
分类专栏： 移动开发 Android开发 文章标签： android开发 java设计模式 观察者模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014471160/article/details/71577344
版权
自己写的一个android中关于观察者模式的demo。关于观察者的定义，可以看另外一篇文章：Java设计模式之观察者模式

下面先来看看代码的结构图：

结构的大体说明：包manager和包managerimpl用来管理观察者，包manager中是抽象的观察者，包managerimpl中是具体的观察者。
包listener和包notify 用来管理被观察者（也成为目标），包listener中是抽象的被观察者，提供注册和删除观察者对象的接口，包notify中是具体的被观察者，当它的状态发送改变时，向它的各个观察者发出通知。
包common中的类起全局的作用，用来管理所有的观察者。
与上面的包的路径平行的是包fragment和MainActivity，TestService，TestPrint等类，这些类是实现观察者接口的对象，具体分为4种类型：Activity，Fragment，Service和普通的类（TestPrint.java）。因为Android中入口程序是在Activity中，所以普通类TestPrint.java还要另外提供一个方法addListener()来使自己实现观察着的接口，并且将这个方法放在MainActivity中调用。

代码如下，

包listener中：两个类中共有6个方法，模拟收到了6中不同的消息，然后通知观察者。这里为了简单，通知的内容都是基本数据类型，具体情况中可以使用JavaBean实现。

public interface RecvMsgOne {

	public void notifyRecvMsgHaHa(String haha);
	
	public void notifyRecvMsgXiXi(String xixi);
	
}

public interface RecvMsgTwo {

	public void notifyRecvName(String str);
	
	public void notifyRecvAge(int num);
	
	public void notifyRecvSex(boolean bool);
	
	public void notifyRecvAddress(String address);
}

包notify中：
//一个最基本的空的interface，用来管理具体的被观察者 
public interface BaseListener {

}

public interface OnRecvMsgHaHa extends BaseListener{

	public void onRecvHaHa(String haha);
}

public interface OnRecvMsgXiXi extends BaseListener{

	public void onRecvXiXi(String xixi);
}

public interface OnRecvMsgName extends BaseListener{

	public void onRecvName(String name);
}

....还有其他的具体的被观察者，格式同上面。
包manager中： 
public interface ManagerOne{

	public void addListenerOne(RecvMsgOne listener);
	
	public void removeListenerOne(RecvMsgOne listener);
	
}

public interface ManagerTwo {

	public void addListenerTwo(RecvMsgTwo listener);
	
	public void removeListenerTwo(RecvMsgTwo listener);
}

包managerimpl中：
//实现了抽象的观察者ManagerOne，并且观察两个目标 
public class ManagerImplOne implements ManagerOne, OnRecvMsgHaHa, OnRecvMsgXiXi{

	public ManagerImplOne(){
		SendMsgActivity.addListener(this);
	}
	
	
	private List<RecvMsgOne> recvMsgOneList = new CopyOnWriteArrayList<RecvMsgOne>();
	@Override
	public void addListenerOne(RecvMsgOne listener) {
		synchronized (recvMsgOneList) {
			if (!recvMsgOneList.contains(listener)) {
				recvMsgOneList.add(listener);
			}
		}
		
	}

	@Override
	public void removeListenerOne(RecvMsgOne listener) {
		synchronized (recvMsgOneList) {
			if(recvMsgOneList.contains(listener)){
				recvMsgOneList.remove(listener);
			}
		}
		
	}

	@Override
	public void onRecvXiXi(String xixi) {
		synchronized(recvMsgOneList){
			for(RecvMsgOne l : recvMsgOneList){
				l.notifyRecvMsgXiXi(xixi);
			}
		}
		
	}

	@Override
	public void onRecvHaHa(String haha) {
		synchronized(recvMsgOneList){
			for(RecvMsgOne l : recvMsgOneList){
				l.notifyRecvMsgHaHa(haha);
			}
		}
	}

}

//实现了抽象的观察者ManagerTwo，并且观察四个目标 

public class ManagerImplTwo implements ManagerTwo, OnRecvMsgName, OnRecvMsgAge,
        OnRecvMsgSex, OnRecvMsgAddress {

    public ManagerImplTwo(){
        SendMsgActivity.addListener(this);
    }
    
    private List<RecvMsgTwo> recvMsgTwoList = new CopyOnWriteArrayList<RecvMsgTwo>();

    @Override
    public void addListenerTwo(RecvMsgTwo listener) {
        synchronized (recvMsgTwoList) {
            if (!recvMsgTwoList.contains(listener)) {
                recvMsgTwoList.add(listener);
            }
        }
    }

    @Override
    public void removeListenerTwo(RecvMsgTwo listener) {
        synchronized (recvMsgTwoList) {
            if (recvMsgTwoList.contains(listener)) {
                recvMsgTwoList.remove(listener);
            }
        }
    }

    @Override
    public void onRecvAddress(String address) {
        synchronized (recvMsgTwoList) {
            for (RecvMsgTwo l : recvMsgTwoList) {
                l.notifyRecvAddress(address);
            }
        }
    }

    @Override
    public void onRecvSex(boolean sex) {
        synchronized (recvMsgTwoList) {
            for (RecvMsgTwo l : recvMsgTwoList) {
                l.notifyRecvSex(sex);
            }
        }
    }

    @Override
    public void onRecvAge(int age) {
        synchronized(recvMsgTwoList){
            for (RecvMsgTwo l : recvMsgTwoList) {
                l.notifyRecvAge(age);
            }
        }
    }

    @Override
    public void onRecvName(String name) {
        synchronized(recvMsgTwoList){
            for (RecvMsgTwo l : recvMsgTwoList) {
                l.notifyRecvName(name);
            }
        }
    }

}

还有一个很重要的包:common
//用来管理所有的观察者 

public class GlobalManager {

	private static ManagerOne managerOne;
	private static ManagerTwo managerTwo;
	
	public static ManagerOne getManagerOne(){
		if(null == managerOne){
			managerOne = new ManagerImplOne();
		}
		 
		return managerOne;
	}
	
	public static ManagerTwo getManagerTwo(){
		if(null == managerTwo){
			managerTwo = new ManagerImplTwo();
		}
		
		return managerTwo;
	}
}


上面就是大体的观察者和被观察者，其次就是实现观察者接口的对象，具体分为4种类型：Activity，Fragment，Service和普通的类（TestPrint.java）。大体的功能已经在上面说过了。因为除了实现观察者外，他们都没有其他的逻辑，所以这里就不列出代码了。下面是模拟接收到消息并通知观察者的SendMsgActivity： 

public class SendMsgActivity extends Activity{

	private Button btnSend;
	private EditText edit;
	
	private String msgType;
	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setTitle("模拟收到消息的界面");
		setContentView(R.layout.activity_sendmsg);
		
		btnSend = (Button) findViewById(R.id.sendAct_send);
		edit = (EditText) findViewById(R.id.sendAct_edit);
		
		btnSend.setOnClickListener(new OnClickListener() {
			
			@Override
			public void onClick(View v) {
				sendMsg();
			}
		});
	}
	
	protected void sendMsg() {
		msgType = edit.getText().toString().trim();
		int type = Integer.valueOf(msgType);
		
		switch (type) {
		case 1:
			for(OnRecvMsgHaHa l : onRecvMsgHaHaList){
				l.onRecvHaHa("Hahahaha...");
			}
			break;
		case 2:
			for(OnRecvMsgXiXi l : onRecvMsgXiXiList){
				l.onRecvXiXi("Xixixixi...");
			}
			break;
		case 3:
			for(OnRecvMsgName l : onRecvMsgNameList){
				l.onRecvName("XiaoMing");
			}
			break;
		case 4:
			for(OnRecvMsgSex l : onRecvMsgSexList){
				l.onRecvSex(true);
			}
			break;
		case 5:
			for(OnRecvMsgAge l : onRecvMsgAgeList){
				l.onRecvAge(24);
			}
			break;
		case 6:
			for(OnRecvMsgAddress l : onRecvMsgAddressList){
				l.onRecvAddress("杭州市西湖区");
			}
			break;

		default:
			break;
		}
		
	}





	/*** 通过下面的list给所有注册的观察者发送消息    ***/
	private static List<OnRecvMsgAddress> onRecvMsgAddressList = new CopyOnWriteArrayList<OnRecvMsgAddress>();
	private static List<OnRecvMsgAge> onRecvMsgAgeList = new CopyOnWriteArrayList<OnRecvMsgAge>();
	private static List<OnRecvMsgHaHa> onRecvMsgHaHaList = new CopyOnWriteArrayList<OnRecvMsgHaHa>();
	private static List<OnRecvMsgXiXi> onRecvMsgXiXiList = new CopyOnWriteArrayList<OnRecvMsgXiXi>();
	private static List<OnRecvMsgSex> onRecvMsgSexList = new CopyOnWriteArrayList<OnRecvMsgSex>();
	private static List<OnRecvMsgName> onRecvMsgNameList = new CopyOnWriteArrayList<OnRecvMsgName>();
		
	public static void addListener(BaseListener listener){
		if(listener instanceof OnRecvMsgAddress){
			onRecvMsgAddressList.add((OnRecvMsgAddress)listener);
		}
		
		if(listener instanceof OnRecvMsgAge){
			onRecvMsgAgeList.add((OnRecvMsgAge)listener);
		}
		if(listener instanceof OnRecvMsgHaHa){
			onRecvMsgHaHaList.add((OnRecvMsgHaHa)listener);
		}
		if(listener instanceof OnRecvMsgXiXi){
			onRecvMsgXiXiList.add((OnRecvMsgXiXi)listener);
		}
		if(listener instanceof OnRecvMsgSex){
			onRecvMsgSexList.add((OnRecvMsgSex)listener);
		}
		if(listener instanceof OnRecvMsgName){
			onRecvMsgNameList.add((OnRecvMsgName)listener);
		}
	}
	
	/**
	 * 会移除所有的观察者，在程序退出时调用是一种好的编码习惯
	 * @param listener
	 */
	public static void removeListener(BaseListener listener){
		if(listener instanceof OnRecvMsgAddress){
			onRecvMsgAddressList.remove((OnRecvMsgAddress)listener);
		}
		
		if(listener instanceof OnRecvMsgAge){
			onRecvMsgAgeList.remove((OnRecvMsgAge)listener);
		}
		if(listener instanceof OnRecvMsgHaHa){
			onRecvMsgHaHaList.remove((OnRecvMsgHaHa)listener);
		}
		if(listener instanceof OnRecvMsgXiXi){
			onRecvMsgXiXiList.remove((OnRecvMsgXiXi)listener);
		}
		if(listener instanceof OnRecvMsgSex){
			onRecvMsgSexList.remove((OnRecvMsgSex)listener);
		}
		if(listener instanceof OnRecvMsgName){
			onRecvMsgNameList.remove((OnRecvMsgName)listener);
		}
	}
}


下面是整个demo运行后的效果图：

输入的数字1--6代表上面的6中消息类型，输入数字，点击发送按钮后，目标会通知各自的观察者。






具体的代码可以在这里下载：https://github.com/215836017/ObservableDemo.git
同时欢迎大佬给予宝贵的建议和意见。


冯可乐同学
关注
专栏目录
Android开发模式之观察者模式
weixin_43858011的博客
10-25 2799
定义对象一种一对多的依赖关系，使得当一个对象改变状态的时候，所有依赖它的对象都会得到通知并自动更新。观察者模式是一种使用频率非常高的设计模式，最常用的地方就是订阅-发布系统。
Android设计模式--观察者模式DEMO
12-05
Android设计模式--观察者模式DEMO 观察者模式是一个使用频率非常高的模式，他最常用的地方是GUI系统和订阅-发布系统。 该模式的最重要的作用就是解耦，使观察者和被观察者之间依赖尽可能小，甚至好无依赖。
Android观察者模式的简单实现demo
weixin_30892889的博客
09-28 117
观察者模式就是：当一个对象的状态发送改变时，所有依赖于它的对象都能得到通知并被自动更新。 下面介绍一种简单的使用方法，（下面有demo链接）先看一下project的目录构成： ObserverListener是观察者接口，SubjectListener是被观察者接口，ObserverManager是观察者的管理类。 1 /** 2 * Created by Administrat...
android 观察者模式
longfei_2010的博客
10-21 260
1:观察者模式: 1:使用场景:一般使用在自定义控件的事件点击监听上面(或者封装方法进行回调) 2:写观察者模式步骤: (1):声明一个接口 (2):接口里面封装一个抽象方法 (3):需要封装一个方法,方法的参数就是抽象类(用来设置监听) (4):声明抽象类 (5):调用抽象方法 1:抽象类与接口的区别: (1):默认的方法实现
android 观察者模式的简单demo,一个简单的demo彻底搞懂观察者模式
weixin_32297123的博客
06-07 259
介绍观察者模式也被称为发布-订阅(Publish/Subscribe)模式，它属于行为型模式的一种。观察者模式定义了一种一对多的依赖关系，一个主题对象可被多个观察者对象同时监听。当这个主题对象状态变化时，会通知所有观察者对象并作出相应处理逻辑。UML观察者模式UML观察者模式定义了四种角色：抽象主题、具体主题、抽象观察者、具体观察者。抽象主题(Subject)：该角色是一个抽象类或接口，定义了增加...
[android]观察者模式demo
04-20
原文请看http://blog.csdn.net/cc_want/article/details/51201118
android观察者模式Demo
01-05
在这个"android观察者模式Demo"中，我们看到的是如何在Android应用程序中应用观察者模式，特别是通过一个Activity作为观察者来实现实时的数据更新。 首先，我们要理解观察者模式的基本概念。观察者模式包含两个主要...
观察者模式for android demo
09-30
在这个“观察者模式for android demo”中，我们将深入探讨如何在Android环境中应用该模式。 观察者模式的核心概念是发布-订阅（Publish-Subscribe）模型，其中被观察的对象称为主题（Subject），而对主题变化感兴趣...
Android观察者模式简单实现Demo
02-17
Android观察者模式简单实现Demo,同步博文http://blog.csdn.net/qq_28690547/article/details/50661603
观察者模式DEMO
萧若寒
10-09 150
观察者模式 Java深入到一定程度,就不可避免的碰到设计模式(design pattern)这一概念,了解设计模式,将使自己对java中的接口或抽象类应用有更深的理解.设计模式在java的中型系统中应用广泛,遵循一定的编程模式,才能使自己的代码便于理解,易于交流,Observer(观察者)模式是比较常用的一个模式,尤其在界面设计中应用广泛,而本站所关注的是Java在电子商务系统中应用,因此想...
android之观察者模式理解demo
09-16
为了理解观察者模式，本人利用生活中的一个小需求，编写了一个小例子，加强记忆，主要模拟了消费者想购买一辆自行车，并且希望时时知道某自行车店的自行车价格变化，当降价的时候，会收到降价通知，并且购买的一个应用场景，还利用简单的回调接口实现安卓UI界面的显示，希望也可以帮到你们！ 有问题可以随时联系！
Android_观察者模式简单Demo
ytjd926的专栏
08-09 7488
总体流程： a. 实例化被观察者（单例） b. 被观察者添加观察者 c. 数据变化后，被观察者调用其notifyWatcher（）方法，此方法内容是通知所有观察者数据改变。 d. 观察者接收到数据改变信息后的处理。 实例代码如下： 被观察者接口 public interface Watched { //在其接口中定义一个用来增加观察者的方法 public void add(Wat
android 观察者模式的简单demo,简单的观察者模式-demo
weixin_30478151的博客
06-07 117
const EventEmitter = (function () {const emitters = [];const ONCE_SYMBOL = '$$EMITTER_ONCE';class $EventEmitter{constructor(isInit) {emitters.push(this);this.listenrs = {};if (isInit) {return Object.a...
Android 观察者模式
Venus 的博客
11-25 1576
待续······
Android 观察者模式
yshr1991的博客
05-31 735
观察者模式：观察者和被观察者 1.观察者接收到消息后，即进行update更新操作，对接收到的信息进行处理。    一个类如果实现观察者的接口，则只需要实现一个update（）方法，注意还需要在此类中添加一个被观察者（.addObserver(this);）this指实现了观察者接口的对象 观察者模式有什么优点呢： 观察者和被观察者之间是抽象耦合的，不管是增加观察者还是被观察者都非
Android的设计模式-观察者模式
四月葡萄的博客
11-22 493
前言Android的设计模式系列文章介绍，欢迎关注，持续更新中：1.定义定义对象间的一种一个对多的依赖关系，当一个对象的状态发送改变时，所以依赖于它的对象都得到通知并被自动更新。2.介绍 观察者属于行为型模式。 观察者模式又被称作发布/订阅模式。 观察者模式主要用来解耦，将被观察者和观察者解耦，让他们之间没有没有依赖或者依赖关系很小。 3.UML类图角色说明： Subject（抽象主题）：又叫抽象被
springboot 观察者模式 demo
最新发布
08-18
好的！下面是一个简单的 Spring Boot 观察者模式的示例代码： 首先，我们需要定义一个被观察的主题类（Subject），可以是一个普通的 Java 类： ```java import java.util.ArrayList; import java.util.List; public class Subject { private List<Observer> observers = new ArrayList<>(); public void attach(Observer observer) { observers.add(observer); } public void detach(Observer observer) { observers.remove(observer); } public void notifyObservers(String message) { for (Observer observer : observers) { observer.update(message); } } } ``` 然后，定义观察者接口（Observer）： ```java public interface Observer { void update(String message); } ``` 接下来，我们可以创建一些具体的观察者类来实现 Observer 接口： ```java public class ConcreteObserver implements Observer { @Override public void update(String message) { System.out.println("Received message: " + message); // 实现具体的观察者逻辑 } } ``` 最后，在 Spring Boot 应用中使用观察者模式： ```java import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; @SpringBootApplication public class ObserverPatternDemoApplication { public static void main(String[] args) { SpringApplication.run(ObserverPatternDemoApplication.class, args); // 创建被观察的主题对象 Subject subject = new Subject(); // 创建观察者对象 Observer observer1 = new ConcreteObserver(); Observer observer2 = new ConcreteObserver(); // 注册观察者 subject.attach(observer1); subject.attach(observer2); // 发送通知 subject.notifyObservers("Hello, observers!"); } } ``` 这个示例中，我们创建了一个被观察的主题对象（Subject），并注册了两个观察者对象（ConcreteObserver）。当主题对象调用 `notifyObservers` 方法时，观察者对象会接收到通知，并执行相应的逻辑。 希望这个示例能帮助到你！如果有任何问题，请随时提问。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值