利用spring自己实现观察者模式

利用spring，自己实现的一个观察者模式，写着玩玩，目的是为了加深理解，下次用Spring自带的玩一玩。

 

首先我们定义一个侦听类接口

package com.hyenas.common.listener;

import java.util.Map;

public interface Observer {
    
    public boolean isAsyn();

    public void excute(Map<String, Object> params);
}

抽象侦听类

package com.hyenas.common.listener;

public abstract class AbstractObserver implements Observer {

    private boolean asyn = false;

    public void setAsyn(boolean asyn) {
        this.asyn = asyn;
    }

    @Override
    public boolean isAsyn() {
        return asyn;
    }

}

事件管理类

package com.hyenas.common.listener;

import java.util.List;
import java.util.Map;

public class EventManager {

    private Map<String, List<Observer>> events;

    public void setEvents(Map<String, List<Observer>> events) {
        this.events = events;
    }

    public void dispather(String eventName, Map<String, Object> params) {
        if (events == null || events.isEmpty()) {
            return;
        }

        List<Observer> observers = events.get(eventName);
        for (Observer observer : observers) {
            if (observer.isAsyn()) {
                EventManagerThead eventManagerThead = new EventManagerThead(
                        observer, params);
                Thread t = new Thread(eventManagerThead);
                t.start();
            } else {
                observer.excute(params);
            }
        }
    }

    class EventManagerThead implements Runnable {

        private Observer observer;
        private Map<String, Object> params;

        public EventManagerThead(Observer observer, Map<String, Object> params) {
            super();
            this.observer = observer;
            this.params = params;
        }

        @Override
        public void run() {
            observer.excute(params);
        }

    }
}

然后我们定义一个侦听者的实现类

package com.hyenas.common.listener;

import java.util.Map;
import java.util.Map.Entry;

public class ObserverTest extends AbstractObserver {

    @Override
    public void excute(Map<String, Object> params) {
        
        System.out.println("execute ObserverTest");
        
        for (Entry<String, Object> entry : params.entrySet()) {
            System.out.println(entry.getKey() + "->" + entry.getValue());
        }
        
        System.out.println("thread name ObserverTest:"
                + Thread.currentThread().getName());
    }

}

Spring 配置文件  : listener.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
       http://www.springframework.org/schema/tx
       http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">

  <bean id="eventManager" class="com.hyenas.common.listener.EventManager">
    <property name="events">
        <map>
            <entry key="observerTest">
                <list>
                   <ref bean="observerTest"/>
                </list>
            </entry>
    </map> 
    </property>
  </bean>
  
  <bean id="observerTest" class="com.hyenas.common.listener.ObserverTest">
      <property name="asyn" value="true"></property>
  </bean>
  
  
</beans>

好了，我们来测试一下：

package com.hyenas.common.listener;

import java.util.HashMap;
import java.util.Map;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {
    public static void main(String[] args) {

        ClassPathXmlApplicationContext ctx = null;

        try {
            
            String[] locations = { "listener.xml" };
            ctx = new ClassPathXmlApplicationContext(locations);

            EventManager eventManager = (EventManager) ctx
                    .getBean("eventManager");

            System.out.println("thread name main:"
                    + Thread.currentThread().getName());

            Map<String, Object> map = new HashMap<String, Object>();
            map.put("paramKey", "paramValue");

            eventManager.dispather("observerTest", map);
        } finally {
            if (ctx != null) {
                ctx.close();
            }
        }

    }
}

运行结果：

thread name main:main
execute ObserverTest
paramKey->paramValue
thread name ObserverTest:Thread-0

 

里面的多线程操作可以换成线程池，spring 有一个类ThreadPoolTaskExecutor大家可以试一试