精华内容
下载资源
问答
  • 观察者模式是广播机制,消息订阅和推送的核心设计。开发中常见的场景: 1.手机中消息推送 2.后台群发信息观察者模式例子(自己实现) 首先是定义观察者接口并使用三个子类实现/** * 观察者接口 * * @author ...

    什么叫观察者模式:
    观察者模式是广播机制,消息订阅和推送的核心设计。

    开发中常见的场景:
    1.手机中消息推送
    2.后台群发信息

    观察者模式例子(自己实现)
    首先是定义观察者接口并使用三个子类实现

    /**
     * 观察者接口
     * 
     * @author liuxg
     * @date 2016年5月27日 下午10:15:30
     */
    public interface IObserver {
    
        public void process();
    
    }
    
    class Observer1 implements IObserver {
    
        @Override
        public void process() {
    
            System.out.println("Observer1执行动作");
    
        }
    
    }
    class Observer2 implements IObserver {
    
        @Override
        public void process() {
    
            System.out.println("Observer2执行动作");
    
        }
    
    }
    class Observer3 implements IObserver {
    
        @Override
        public void process() {
    
            System.out.println("Observer3执行动作");
    
        }
    
    }

    再定义主题,观察者若想获得消息,必须先注册

    /**
     * 
     * @author liuxg
     * @date 2016年5月27日 下午10:12:18
     */
    public class Subject {
    
        List<IObserver> list = new ArrayList<IObserver>();
    
    
        /***
         * 注册观察者
         * @param observer
         */
        public void registerObserver(IObserver observer){
            list.add(observer);
        }
    
    
        /**
         * 广播消息
         */
        public void send(){ 
            for (IObserver observer : list) {
                observer.process();
            }
        }
    
    }

    客户端这样子,我们这样子使用

    public class Client01 {
    
        public static void main(String[] args) {
            IObserver observer1 = new Observer1();
            IObserver observer2 = new Observer2();
            IObserver observer3 = new Observer3();
    
            Subject subject = new Subject();
            subject.registerObserver(observer1);
            subject.registerObserver(observer2);
            subject.registerObserver(observer3);
    
            subject.send();
    
        }
    
    }

    接下来我们利用jdk的api来实现观察者模式
    观察者模式例子(jdk api)

    /**
     * 实现观察者
     * @author liuxg
     * @date 2016年5月28日 下午7:11:43
     */
    public class MyObserver implements Observer {
    
        @Override
        public void update(Observable o, Object arg) {
            int state = ((ConcreteSubject)o).getState();
    
            System.out.println("state = " + state);
    
    
        }
    
    }

    接下来我们来实现主题信息

    
    /**
     * 继承jdk的Observable来实现主题信息
     * @author liuxg
     * @date 2016年5月28日 下午7:10:52
     */
    public class ConcreteSubject extends Observable{
    
        private int state ;
    
        public void set(int state) { //状态切换,广播信息
            this.state = state;
    
            setChanged();
            notifyObservers();
    
        }
    
        public int getState() {
            return state;
        }
    
        public void setState(int state) {
            this.state = state;
        }
    }
    

    客户端测试,可以这样子

    public class Client02 {
    
        public static void main(String[] args) {
            ConcreteSubject obj = new ConcreteSubject();
    
            MyObserver observer = new MyObserver();
            obj.addObserver(observer);
    
            obj.set(123);
    
        }
    
    }
    
    展开全文
  • Android广播机制

    千次阅读 2015-01-22 11:46:00
    Android广播机制指的是,在一个应用程序运行的时候可以自定义一个消息类型,让相应的接收器去处理这个消息或者是系统消息,比如来电话了、来短信了、手机没电了等等系统发送的消息。系统发送的消息也可以通过广播的...

    什么叫广播?

    Android广播机制指的是,在一个应用程序运行的时候可以自定义一个消息类型,让相应的接收器去处理这个消息或者是系统消息,比如来电话了、来短信了、手机没电了等等系统发送的消息。系统发送的消息也可以通过广播的方式通知给应用程序,这样子就避免了新开一个Thread去监听系统或其他应用发送过来的消息的状态。

    Android广播的分类:

    1、 普通广播:也叫标准广播,这种广播可以依次传递给各个处理器去处理。

    2、 有序广播:这种广播在处理器端的处理顺序是按照处理器的不同优先级来区分的,高优先级的处理器会优先截获这个消息,并且可以将这个消息删除。

    3、 粘性消息(Sticky 广播):粘性消息在发送后就一直存在于系统的消息容器里面,等待对应的处理器去处理,如果暂时没有处理器处理这个消息则一直在消息容器里面处于等待状态。

    注意:普通广播(标准广播)和粘性消息不能被截获,而有序广播是可以被截获的

    处理器的注册:

    1、 在代码中用函数代码动态的方式注册。动态注册的处理器必须用代码动态的销毁,每次用来处理消息的就一个实例对象

    2、 在配置文件里面静态注册,静态注册有个特点,那就是一旦注册就会一直存在于系统里面,无论应用是否关闭或开关机。(简直就是一个流氓软件病毒啊~)。静态注册每次有处理消息就由系统new一个处理器处理,并销毁

    下面具体看看Android广播消息的发送、注册、处理过程:

    ① 自定义处理器类: 

    public class MyBroadcastReceiver4 extends BroadcastReceiver {
            public MyBroadcastReceiver4() {
                System.out.println("创建了一个由registerReceiver()注册的广播接收器");
            }
            
            @Override
            public void onReceive(Context context, Intent intent) {
                String action = intent.getAction();
                System.out.println("MyBroadcastReceiver4收到了一个" + action + "消息");
                if (isOrderedBroadcast()) {
                    System.out.println("这是一个有序广播,已经被拦截了。");
                    this.abortBroadcast();
                } else {
                    System.out.println("这不是一个有序广播");
                }
                Bundle bundle = intent.getExtras();
                if (bundle != null) {
                    System.out.println("该消息携带的数据如下:");
                    // 获得bundle的一个key的集合
                    Set set = bundle.keySet();
                    // 获得上述集合的迭代器
                    Iterator iterator = set.iterator();
                    // 用迭代器遍历集合
                    while (iterator.hasNext()) {
                        // 取得集合中的一个内容
                        String str = (String) iterator.next();
                        // 取得Bundle中的内容
                        System.out.println(str + "--->" + bundle.get(str));
                    }
                } else {
                    System.out.println("该消息没有携带数据");
                }
                Toast toast = Toast.makeText(context, "MyBroadcastReceiver4收到了一个" + action + "消息", Toast.LENGTH_LONG);
                toast.show();
               //将这个消息截获(从消息容器移除)这样其他处理器就没法接收到这个消息
                this.abortBroadcast();
            }
        }

    ② 发送广播消息

    ⑴、 发送普通广播:

    // 发送一个普通消息

    Intent intent = new Intent(); 

     intent.setAction("asdfasdf");

    Android_09_10Activity.this.sendBroadcast(intent);

    ⑵、 发送有序广播:

    // 发送一个有序消息

    Intent intent = new Intent();

    intent.setAction("asdfasdf");

    Android_09_10Activity.this.sendOrderedBroadcast(intent,

    null);

    ⑶、 发送粘性广播:

    // 发送一个粘性消息

    Intent intent = new Intent();

    intent.setAction("qwerqwer");  Android_09_10Activity.this.sendStickyBroadcast(intent);

    ③ 注册广播接收器

    ⑴动态注册:

    // 注册一个广播接收器

    IntentFilter intentFilter = new IntentFilter("asdfasdf");

    intentFilter.setPriority(0);

    Android_09_10Activity.this.registerReceiver(mbr2,

    intentFilter);

    ⑵静态注册:

     

    <receiver android:name=".MyBroadcastReceiver4" >
                <intent-filter android:priority="1000" >
                    <action android:name="android.intent.action.WALLPAPER_CHANGED"/>
                    <action android:name="android.provider.Telephony.SMS_RECEIVED"/>
                    <action android:name="android.intent.action.PHONE_STATE"/>
                    <action android:name="android.intent.action.PACKAGE_REMOVED"/>
                    //这一句比较特殊,是上面那个广播消息特有的
                    <data android:scheme="package"/>
                    <category android:name="android.intent.category.DEFAULT"/>
                </intent-filter>
    </receiver>

    想发送粘性消息的时候必须在配置文件里面获取权限:

     

    <uses-permission android:name="android.permission.BROADCAST_STICKY" />

    想用自定义处理器对系统广播进行处理的话也必须在注册文件里面申明获取权限,比如:

    <uses-permission android:name="android.permission.RECEIVE_SMS" />

    <uses-permission android:name="android.permission.READ_PHONE_STATE" />

    下面是一个完整的demo

    MainActivity.java

     

    package demo.xzy.qh.com.broadcastdemo;
    
    import android.app.Activity;
    import android.content.Intent;
    import android.content.IntentFilter;
    import android.os.Bundle;
    
    public class MainActivity extends Activity {
        private MyBroadcastReceiver myBroadcastReceiver;
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            myBroadcastReceiver = new MyBroadcastReceiver();
            String action = "com.xzy.demo.broadcast";
            //注册广播接收器
            IntentFilter intentFilter = new IntentFilter();
            intentFilter.addAction(action);
            this.registerReceiver(myBroadcastReceiver, intentFilter);
            //发送广播
            sendBroadcast(action);
        }
    
        /**
         * @param action
         */
        private void sendBroadcast(String action) {
            Intent intent = new Intent();
            intent.setAction(action);
            intent.putExtra("name", "xzy");
            sendBroadcast(intent);
        }
    
        @Override
        protected void onDestroy() {
            //反注册广播接收器
            unregisterReceiver(myBroadcastReceiver);
            super.onDestroy();
        }
    }
    


    自定义广播接收器

     

     

    package demo.xzy.qh.com.broadcastdemo;
    
    import android.content.BroadcastReceiver;
    import android.content.Context;
    import android.content.Intent;
    import android.os.Bundle;
    import android.util.Log;
    
    import java.util.Iterator;
    import java.util.Set;
    
    /**
     * Function:自定义广播接收器
     * Created by xuzhuyun on 2017/6/23.
     */
    
    public class MyBroadcastReceiver extends BroadcastReceiver {
        private static final String TAG = "MyBroadcastReceiver";
    
        @Override
        public void onReceive(Context context, Intent intent) {
            String action = intent.getAction();
            if (action != null) {
                if (action.equals("com.xzy.demo.broadcast")) {
                    Log.i(TAG, "onReceive,action is:" + action);
                    Bundle bundle = intent.getExtras();
                    if (bundle != null) {
                        Set set = bundle.keySet();
                        Iterator iterator = set.iterator();
                        while (iterator.hasNext()) {
                            String str = (String) iterator.next();
                            Log.i(TAG, "传递的参数为:" + str + "-->" + bundle.get(str));
                        }
                    } else {
                        Log.i(TAG, "bundle为空");
                    }
                }
            } else {
                Log.i(TAG, "onReceive: action is null");
            }
        }
    }
    

    另外,这一篇关于广播的文章,也总结的很详细https://www.jianshu.com/p/ced5f62b7d25

     

    粘性消息 (Sticky 广播)的用法可以看这一篇文章

    https://blog.csdn.net/u011506413/article/details/54095148

     

     

     

     

     

    展开全文
  • 广播机制实现

    千次阅读 2014-05-08 15:38:29
    广播机制实现  有时需要将数据广播给大家,这时需要应用广播机制原理。所谓Android广播与现实中广播有点相似,就是把消息传给所有人。如果自己需要这个广播消息的话,就接受处理。否则就不理睬。但是怎样才...
      广播机制实现
    


        有时需要将数据广播给大家,这时需要应用广播机制原理。所谓Android广播与现实中广播有点相似,就是把消息传给所有人。如果自己需要这个广播消息的话,就接受处理。否则就不理睬。但是怎样才知道自己需不需要呢?为了实现这个,Android引入“动作”。如果广播者和接受者持有同样的动作的话,那么接受者将接受这个广播,并处理这个广播消息,这就是广播实现原理。


    1、如何发送广播的?

    1. Intent intent=new Intent("com.music.activities.seekBar");//这里定义动作;  
    2. sendBroadcast(intent);//发送广播  


    2、接着就是定义广播处理。

    1. private class SeekBarBroadcastReceiver extends BroadcastReceiver {  
    2.   
    3.         @Override  
    4.         public void onReceive(Context context, Intent intent) {  
    5.               
    6.               
    7.         }  
    8.   
    9.     }  

    这里onReceive是处理广播消息的。


    3、可能一个应用有N多个广播,根本不知道要处理哪个广播?这个需要引用广播注册,广播注册作用是使接受者和广播者持有相同相同动作,这样接受者就知道接受和处理哪个广播。
    广播注册有两种办法:
    1)在配置文件注册(AndroidManifest.xml)

    1. <receiver android:name=".SeekBarBroadcastReceiver ">   
    2.             <intent-filter android:priority="20">   
    3.                 <action android:name="com.music.activities.seekBar"/>   
    4.             </intent-filter>   
    5.         </receiver>  

    2)另一个注册办法是在程序中注册

    1. SeekBarBroadcastReceiver receiver = new SeekBarBroadcastReceiver();  
    2.         IntentFilter filter = new IntentFilter("com.music.activities.seekBar");  
    3.         this.registerReceiver(receiver, filter);  
    这种办法解除注册过程是这样的,

    1. this.unregisterReceiver(receiver);  

    4、这样就完成广播所有实现过程。


    1. <pre></pre>  
    2. <pre></pre>  
    3. <pre></pre>  
    4. <pre></pre>  
    5. <pre></pre>  
    6. <pre></pre>  
    7. <pre></pre> 

    展开全文
  • spring事件广播机制

    千次阅读 2018-04-13 14:26:13
    打个比方,当我们和其他公司进行业务接口对接时,我们这边...这个时候我们就可以使用事件广播来做这个操作看过spring源码的大神都知道,当我们初始化容器的过程中,我们会有initApplicationEventMulticaster()---...

    打个比方,当我们和其他公司进行业务接口对接时,我们这边需要保存或者修改某些数据,但是保存和修改这些数据对整个流程没有太大的影响,这个时候我们应该怎么做呢?是的,我们要考虑异步去保存或者修改数据,但怎么去异步保存数据呢?这个时候我们就可以使用事件广播来做这个操作

    看过spring源码的大神都知道,当我们初始化容器的过程中,我们会有initApplicationEventMulticaster()--->此方法在org.springframework.context.support.AbstractApplicationContext.refresh()中,默认情况使用的事件广播是SimpleApplicationEventMulticaster这个类,这个类中有Executor接口,感觉是不是很熟悉?提示一下,线程池。如果还不熟悉的请自行百度,我们需要手动去设置这个线程池,该怎么配置呢?请看

    <!--异步事件处理
    AbstractApplicationContext 初始化应用事件传播时,会从beanFactory中获取是否存在广播器,
        如果不存在则用SimpleApplicationEventMulticaster
        如果想自定义此广播器,则id='applicationEventMulticaster'-->
    <bean id="applicationEventMulticaster" class="org.springframework.context.event.SimpleApplicationEventMulticaster">
        <property name="taskExecutor" ref="coreTaskExecutor"/>
    </bean>
    
    <bean id="coreTaskExecutor" class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor">
        <property name="corePoolSize" value="10"/>
        <property name="maxPoolSize" value="20"/>
        <property name="queueCapacity" value="25"/>
        <property name="threadNamePrefix" value="coreTaskExecutor"/>
    </bean>

    在applicationContext.xml中配置,如果使用的springboot,可以使用

    @ImportResource("classpath:applicationContext.xml")

    来导入xml文件

    配置好了之后,我们可以定义我们自己的事件和监听器了

    创建事件类,需要继承ApplicationEvent

    public class TestEvent extends ApplicationEvent {
    
       public TestEvent(Object source) {
          super(source);
       }
    }

    Object对象就是我们需要传递的参数

    接着,定义我们的监听,需要实现ApplicationListener这个接口

    public class TestListener implements ApplicationListener {
       @Override
       public void onApplicationEvent(ApplicationEvent event) {
          if(!(event instanceof TestEvent)){
             return;
          }
          event.getSource();//获取传递的参数,即:和TestEvent中的source一样的
          //再次处理业务逻辑    TODO    
       }
    }

    我们主要是在监听器中处理业务逻辑

    是不是想到了个问题,参数怎么传递过来的呢?别着急,我们慢慢来

    参数当然是从我们正常处理业务逻辑代码中传递过来的了,监听器中的代码只是处理分支的情况,正常情况,我们一般都是在service的实现类中进行事件广播并传递参数,此类必须实现ApplicationContextAware这个接口

    public class TestServiceImpl implements ApplicationContextAware{
       ApplicationContext applicationContext;
    
       @Override
       public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
          this.applicationContext = applicationContext;
       }
    
       public void test(){
          String datas = "";//传递参数也可以是maplist、实体对象等
           applicationContext.publishEvent(new TestEvent(datas));
       }
    }

    那么在监听器中就可以接收到datas数据了,然后就可以愉快的进行代码编写了




    努力成就非凡,请不要在最该奋斗的年纪选择安逸



    展开全文
  • 详解Android广播机制

    千次阅读 2018-05-09 10:42:28
    谨以文章记录学习历程,如有错误还请...为了便于进行系统级别的消息通知,Android引入了一套类似的广播机制,然而比上述情景要灵活得多。此文将对Android广播机制的方方面面做出详尽的介绍。 Android广播机...
  • Java事件机制

    千次阅读 2009-11-12 15:12:00
    所有的事件类必须继承Java事件基类,即java.util.EventObject;EventObject(Object source)是EventObject唯一的构造方法,这意味着所有事件必须在实例化时就指定事件源;EventObject类提供了getSource
  • Android广播机制——广播的发送

    万次阅读 2017-01-19 16:44:04
    基于Android 7.0源码,分析Android广播机制的发送过程。 按照广播的类型,可以分为普通广播、有序广播和sticky广播。
  • 安卓开发22:广播机制

    千次阅读 2013-07-15 10:31:39
    安卓的广播机制: 说明:广播广播,其实就是一个地方将信息传播出去,只要有广播接收器的地方都能同时接收到信息。安卓的广播机制一般可以针对应用内的广播,也可以针对跨应用广播。例如电池的事件,电池快没电的...
  • Android广播机制分析

    千次阅读 2016-04-26 13:27:14
    Android广播机制分析 1.1. 广播简介  Android 广播与生活中的广播概念不同,它是指系统中产生事件后的通知。Android 广播不关心接收者是否收到处理或者如何处理广播,可以说是一种单向的通知。  Android 通过 ...
  • Android 系统广播机制

    千次阅读 2014-07-05 11:19:51
     参考Android应用程序注册广播接收器(registerReceiver)的过程分析http://blog.csdn.net/luoshengyang/article/details/6737352和《Android系统源代码情景分析》,作者罗升阳。   0、总图:
  • Java事件机制整理

    2013-01-07 17:02:54
    之前很少做Java开发,对于Java事件的处理机制一直理解的不是很到位,最近正好工作压力不太大,便花了一点时间研究了一下。现在对Java事件的处理机制简单做下整理,方便日后查阅。  Java事件机制中有以下四个关键...
  • //发送广播 button1.setOnClickListener(new View.OnClickListener(){ @Override public void onClick(View v) { Intent it = new Intent(); it.setAction(BROADCAST_ACTION_NORMAL); it.putExtra("name",...
  • 当我们收到一条信息,可能我们的应用需要处理一些数据,可能我们开机,我们的应用也需要处理一些数据,这里都用到了广播机制,这里简单的实现了一个自定义广播,看实例:MyBroadcastReceiver.javapackage com.examp
  • Android10.0 BroadcastCast广播机制原理

    千次阅读 2020-01-05 19:40:07
    原文地址:...基于Android10.0,分析广播机制的原理 一、概述 广播(BroadcastCast)用于进程/线程间的通信,广播有发送广播和接收广播两部分组成,其中广播接收者BroadcastR...
  • 利用Java反射机制控制Nfc开关

    千次阅读 2017-03-20 18:04:23
    利用Java反射机制控制Nfc开关

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 59,287
精华内容 23,714
热门标签
关键字:

java广播机制

java 订阅