设计模式就该这么学：以微信订阅号来讲观察者模式(第三篇)

//1、人民日报接口
   public interface PeoplesDaily
   {
       //添加订阅者
       void RegisterObserver(Observer observer);
       //取消订阅
       void RemoveObserver(Observer observer);
       //发送人民日报
       void notifyObservers();
   }
 
   //2、订阅者接口
   public interface Observer
   {
       //有新的人民日报了就会被执行通知
       void update();
   }
 
   //3、人民日报
   public class PeopleNewsPaper implements PeoplesDaily
   {
       private List<Observer> subList = new List<Observer>();
       public void RegisterObserver(Observer observer)
       {
           subList.Add(observer);
       }
 
       public void RemoveObserver(Observer observer)
       {
           if (subList.IndexOf(observer) >= 0)
           {
               subList.Remove(observer);
           }
       }
 
       //推送人民日报消息了~~
       public void notifyObservers()
       {
           for (Observer sub : subList)
           {
               sub.update();
           }
       }      
   }
 
  //4、订阅者
   public class subHuman implements Observer
   {
       //订阅者的名字
       private string name;
 
       public subHuman(string f_name)
       {
           name = f_name;
       }
       //通知订阅者有新人民日报推送消息了
       public void update()
       {
           system.out.println(p_name + "!! 有新的人民日报消息了，请查收！");
       }
        
   }

   //5、测试开始订阅，和调用了
  public static void Main(string[] args)
        {
            PeopleNewsPaper paper = new PeopleNewsPaper();
            subHuman zhsangsai = new subHuman("张赛");
            subHuman liyong = new subHuman("李勇");
            subHuman liujin = new subHuman("刘晶");
            //张赛订阅人民日报
            paper.RegisterObserver(zhsangsai);
            //李勇订阅人民日报
            paper.RegisterObserver(liyong);
            //刘晶订阅人民日报
            paper.RegisterObserver(liujin);
            //有新人民日报推送消息了
            paper.notifyObservers();
            system.out.println("---------------发完人民日报了------------------");
 
            //张赛不想订了，取消人民日报
            paper.RemoveObserver(zhsangsai);
            //又有新人民日报了  就没有张赛的人民日报 了
            paper.notifyObservers();
        }

package java.util;

public class Observable {
    private boolean changed = false;
    private Vector obs;


    public Observable() {
        obs = new Vector<>();
    }
    
   //添加一个观察者
    public synchronized void addObserver(Observer o) {
        if (o == null)
            throw new NullPointerException();
        if (!obs.contains(o)) {
            obs.addElement(o);
        }
    }

   //删除一个观察者
    public synchronized void deleteObserver(Observer o) {
        obs.removeElement(o);
    }

    public void notifyObservers() {
        notifyObservers(null);
    }

   //通知所有的观察者
    public void notifyObservers(Object arg) {

        Object[] arrLocal;

        synchronized (this) {
          
            if (!changed)
                return;
            arrLocal = obs.toArray();
            clearChanged();
        }

        //调用Observer类通知所有的观察者
        for (int i = arrLocal.length-1; i>=0; i--)
            ((Observer)arrLocal[i]).update(this, arg);
    }
    
    public synchronized void deleteObservers() {
        obs.removeAllElements();
    }

    protected synchronized void setChanged() {
        changed = true;
    }

    protected synchronized void clearChanged() {
        changed = false;
    }

    //省略......
}

@Component
public class ThreadStartUpListenser implements ServletContextListener
{
    //监控文件新增线程
    private static WatchFilePathTask r = new WatchFilePathTask();

    private Log log = LogFactory.getLog(ThreadStartUpListenser.class);

    @Override
    public void contextDestroyed(ServletContextEvent paramServletContextEvent)
    {
        // r.interrupt();

    }

    @Override
    public void contextInitialized(ServletContextEvent paramServletContextEvent)
    {
        //将监控文件类添加为一个观察者，并启动一个线程
        ObserverListener listen = new ObserverListener();
        r.addObserver(listen);
        new Thread(r).start();
        // r.start();
        log.info("ImportUserFromFileTask is started!");
    }

}
     

//继承java内置观察者模式实现的Observable 类
public class WatchFilePathTask extends Observable implements Runnable
{
    private Log log = LogFactory.getLog(WatchFilePathTask.class);

    private static final String FILE_PATH = ConfigUtils.getInstance()
            .getValue("userfile_path");

    private WatchService watchService;

    /**
     * 此方法一经调用，立马可以通知观察者，在本例中是监听线程 
     */
    public void doBusiness()
    {
        if (true)
        {
            super.setChanged();
        }
        notifyObservers();
    }

    @Override
    public void run()
    {
        try
        {
            //这里省略监控新增文件的方法
        }catch (Exception e)
        {
            e.printStackTrace();
            
            doBusiness();// 在抛出异常时调用，通知观察者，让其重启线程
        }
    }
}

//实现java内置观察者模式实现的Observer接口，并且注册主题WatchFilePathTask,以便线程挂掉的时候，再重启这个线程
public class ObserverListener implements Observer
{
    private Log log = LogFactory.getLog(ObserverListener.class);
     
    /**
     * @param o 
     * @param arg 
     */
    public void update(Observable o, Object arg)
    {
        log.info("WatchFilePathTask挂掉");
        WatchFilePathTask run = new WatchFilePathTask();
        run.addObserver(this);
        new Thread(run).start();
        log.info("WatchFilePathTask重启");
    }
}