2. 程式人生 > >觀察者模式實際應用：監聽線程，意外退出線程後自動重啟

觀察者模式實際應用：監聽線程，意外退出線程後自動重啟

阿新 • • 發佈：2017-06-21
lee text 實時 之間 最終 ren tap instance and

摘要: 　觀察者模式，定義對象之間的一種一對多的依賴關系，當對象的狀態發生改變時，所有依賴於它的對象都得到通知並且被自動更新。觀察者模式在JDK中有現成的實現，java.util.Obserable。

　　首先說下需求：通過ftp上傳約定格式的文件到服務器指定目錄下，應用程序能實時監控該目錄下文件變化，如果上傳的文件格式符合要求，將將按照每一行讀取解析再寫入到數據庫，解析完之後再將文件改名。（這個是原先已經實現了的功能，請看我的一篇文章java利用WatchService實時監控某個目錄下的文件變化並按行解析（註：附源代碼））

但項目上線一段時間後，發現再利用FileZilla登陸上傳文件，文件不能被解析，而重啟tomcat之後再上傳，又能解析，於是判定是監控指定目錄的那個線程掛掉了，導致上傳後的文件不能被檢測到，故也不能被解析。之後查看日誌也最終驗證了我推斷。

　　所以關鍵的問題就是：如何監聽線程，當意外退出線程後進行自動重啟，這也是本文所要利用觀察者模式實現的。

下面請看實現過程（尤其見紅色註解部分）：

　　1、web.xml監聽器配置文件監控監聽器，初始化創建一個監控指定目錄的線程　　

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee 
    http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">

    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:root-context.xml</param-value>
    </context-param>

    <filter>
        <filter-name>CharacterEncodingFilter</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>UTF-8</param-value>
        </init-param>
        <init-param>
            <param-name>forceEncoding</param-name>
            <param-value>true</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>CharacterEncodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

    <filter>
        <filter-name>sitemesh</filter-name>
        <filter-class>com.opensymphony.sitemesh.webapp.SiteMeshFilter</filter-class>
    </filter>

    <filter-mapping>
        <filter-name>sitemesh</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

    <servlet>
        <servlet-name>appServlet</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:servlet-context.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>

    <servlet-mapping>
        <servlet-name>appServlet</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
    
    <!-- 配置spring監聽器 -->
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
    <!-- 配置監控文件變化監聽器 -->
    <
 
listener>
        <listener-class>com.zealer.ad.listener.ThreadStartUpListenser</listener-class>
    </listener>
    <listener>
        <listener-class>com.zealer.ad.listener.SessionLifecycleListener</listener-class>
    </listener>
    
    
    <jsp-config>
      <taglib>
       <taglib-uri>/tag</taglib-uri>
       <taglib-location>/WEB-INF/tag/tag.tld</taglib-location>
      </taglib>
    </jsp-config>

    <welcome-file-list>
        <welcome-file>index.jsp</welcome-file>
    </welcome-file-list>
    
    <session-config>
        <session-timeout>45</session-timeout>
    </session-config>
</web-app>

　　2、編寫一個觀察者實現類，用於監聽“監控指定目錄線程”，當“監控指定目錄線程”掛掉後，自動重啟該線程

    package com.zealer.ad.listener;
        
    import java.util.Observable;
    import java.util.Observer;
  
    import org.apache.commons.logging.Log;
    import org.apache.commons.logging.LogFactory;
    
    import com.zealer.ad.task.WatchFilePathTask;
    public class ObserverListener implements Observer{
        private Log log = LogFactory.getLog(ObserverListener.class);
        
        @Override
        public void update(Observable o, Object arg) 
        {
            log.info("WatchFilePathTask掛掉");
            WatchFilePathTask run = new WatchFilePathTask();
            run.addObserver(this);
            new Thread(run).start();
            log.info("WatchFilePathTask重啟");
        }
    }

　　3、編寫一個ThreadStartUpListenser類，實現ServletContextListener，tomcat啟動時創建後臺線程

package com.zealer.ad.listener;

import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.stereotype.Component;

import com.zealer.ad.task.WatchFilePathTask;

@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!");
    }

}

　　4、創建指定目錄文件變化監控類WatchFilePathTask

package com.zealer.ad.task;

import java.io.File;
import java.io.FileFilter;
import java.nio.file.FileSystems;
import java.nio.file.Path;
import java.nio.file.StandardWatchEventKinds;
import java.nio.file.WatchEvent;
import java.nio.file.WatchKey;
import java.nio.file.WatchService;
import java.util.Observable;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.joda.time.DateTime;

import com.zealer.ad.util.ConfigUtils;
import com.zealer.ad.util.SpringUtils;

/**
 * 指定目錄文件變化監控類
 * @author cancer
 *
 */
public class WatchFilePathTask extends Observable implements Runnable
{
    private Log log = LogFactory.getLog(WatchFilePathTask.class);
    
    private static final String filePath = ConfigUtils.getInstance().getValue("userfile_path");
    
    private WatchService watchService;
    
    // 此方法一經調用，立馬可以通知觀察者，在本例中是監聽線程
    public void doBusiness()
　　{
        if(true)
　　　　 {
            super.setChanged();
        }
　　　　 //通知觀察者，重啟線程
        notifyObservers();
    }
    
    @Override
    public void run()
    {
        try
        {
            //獲取監控服務
            watchService = FileSystems.getDefault().newWatchService();
            log.debug("獲取監控服務"+watchService);
            Path path = FileSystems.getDefault().getPath(filePath);
            log.debug("@@@:Path:"+path);
            
            final String todayFormat = DateTime.now().toString("yyyyMMdd");
            
            File existFiles = new File(filePath);
            
            //啟動時檢查是否有未解析的符合要求的文件
            if(existFiles.isDirectory())
            {
                File[] matchFile = existFiles.listFiles(new FileFilter()
                {
                    
                    @Override
                    public boolean accept(File pathname)
                    {
                        if((todayFormat+".txt").equals(pathname.getName()))
                        {
                            return true;
                        }
                        else
                        {
                            return false;
                        }
                    }
                });
                
                if(null != matchFile)
                {
                    for (File file : matchFile)
                    {
                        //找到符合要求的文件，開始解析
                        ImportUserFromFileTask task = (ImportUserFromFileTask) SpringUtils.getApplicationContext().getBean("importUserFromFileTask");
                        task.setFileName(file.getAbsolutePath());
                        task.start();
                    }
                }
            }
            
            //註冊監控服務，監控新增事件
            WatchKey key = path.register(watchService, StandardWatchEventKinds.ENTRY_CREATE);
            while (true) 
            {  
                key = watchService.take();  
                for (WatchEvent<?> event : key.pollEvents()) { 
                    
                    //獲取目錄下新增的文件名
                    String fileName = event.context().toString();
                    
                    //檢查文件名是否符合要求
                    if((todayFormat+".txt").equals(fileName))
                    {
                        String filePath = path.toFile().getAbsolutePath()+File.separator+fileName;
                        log.info("import filePath:"+filePath);
                        
                        //啟動線程導入用戶數據
                        ImportUserFromFileTask task = (ImportUserFromFileTask) SpringUtils.getApplicationContext().getBean("importUserFromFileTask");//new ImportUserFromFileTask(filePath);
                        task.setFileName(filePath);
                        task.start();
                        log.debug("啟動線程導入用戶數據"+task);
                    }
                } 
                key.reset();  
            }  
        } 
　　　　　catch (Exception e)
        {
            e.printStackTrace();
            System.out.println("已經到這裏來了");
            doBusiness();//在拋出異常時調用，通知觀察者，讓其重啟線程
        }
    }
}

　　5、創建解析用戶文件及導入數據庫線程，由WatchFilePathTask啟動

package com.zealer.ad.task;

import com.zealer.ad.entity.AutoPutUser;
import com.zealer.ad.entity.Bmsuser;
import com.zealer.ad.service.AutoPutUserService;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import org.joda.time.DateTime;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStreamReader;

import java.util.Date;

import javax.annotation.Resource;


/**
 * 解析用戶文件及入庫線程,由WatchFilePathTask啟動
 * @author cancer
 *
 */
public class ImportUserFromFileTask extends Thread {
    private Log log = LogFactory.getLog(ImportUserFromFileTask.class);
    private String fileName;
    @Resource(name = "autoPutUserService")
    private AutoPutUserService autoPutUserService;

    @Override
    public void run() {
        File file = new File(fileName);

        if (file.exists() && file.isFile()) {
            log.debug("：@@@準備開始休眠10秒鐘：" + file);

            //休眠十分鐘，防止文件過大還沒完全拷貝到指定目錄下，這裏的線程就開始讀取文件
            try {
                sleep(10000);
            } catch (InterruptedException e1) {
                e1.printStackTrace();
            }

            InputStreamReader read;

            try {
                read = new InputStreamReader(new FileInputStream(file), "UTF-8");

                BufferedReader bufferedReader = new BufferedReader(read);
                String lineTxt = null;
                int count = 0;
                Boolean f = false;

                while ((lineTxt = bufferedReader.readLine()) != null) {
                    if ((null == lineTxt) || "".equals(lineTxt)) {
                        continue;
                    }

                    if (lineTxt.startsWith("‘")) {
                        lineTxt = lineTxt.substring(1, lineTxt.length());
                    }

                    //解析分隔符為‘, ‘
                    String[] lines = lineTxt.split("‘, ‘");
                    int length = lines.length;

                    if (length < 2) {
                        continue;
                    }

                    Bmsuser bmsuser = new Bmsuser();
                    bmsuser.setName(lines[0]);if (!"".equals(lines[1])) {
                        bmsuser.setCity(lines[1]);
                    }
　　　　　　　　　　　　//根據唯一索引已經存在的數據則不插入
                    f = autoPutUserService.insertIgnore(bmsuser);

                    if (f) {
                        count++;
                    }
                }

                //匯總數據
                AutoPutUser autoPutUser = new AutoPutUser();
                autoPutUser.setTotalCount(autoPutUserService.getUserCount());
                autoPutUser.setCount(count);
                autoPutUser.setCountDate(new Date(System.currentTimeMillis()));

                String today = DateTime.now().toString("yyyy-MM-dd");
                Integer oldCount = autoPutUserService.getOldCount(today);

                //如果今天導入過了就更新否則插入
                if (!oldCount.equals(0)) {
                    autoPutUserService.updateUserData(autoPutUser, today,
                        oldCount);
                } else {
                    autoPutUserService.gatherUserData(autoPutUser);
                }

                //註意：要關閉流
                read.close();
            } catch (Exception e) {
                log.error(e.getMessage(), e);
            }

            File newFile = new File(file.getPath() +
                    System.currentTimeMillis() + ".complate");
            file.renameTo(newFile);
        } else {
            log.error(fileName + " file is not exists");
        }
    }

    public String getFileName() {
        return fileName;
    }

    public void setFileName(String fileName) {
        this.fileName = fileName;
    }

    public AutoPutUserService getAutoPutUserService() {
        return autoPutUserService;
    }

    public void setAutoPutUserService(AutoPutUserService autoPutUserService) {
        this.autoPutUserService = autoPutUserService;
    }
}

附帶：

1、sql腳本

CREATE TABLE `bmsuser` (
  `id` int(255) unsigned NOT NULL AUTO_INCREMENT,
  `name` varchar(32) DEFAULT NULL ,
  `city` varchar(32) DEFAULT NULL COMMENT ,
  PRIMARY KEY (`bmsid`),
  UNIQUE KEY `bbLoginName` (`bbLoginName`)
) ENGINE=InnoDB  DEFAULT CHARSET=utf8;

2、文件格式，命名為yyyyMMdd.txt

‘張三‘, ‘深圳‘

觀察者模式實際應用：監聽線程，意外退出線程後自動重啟

相關推薦

觀察者模式實際應用：監聽線程，意外退出線程後自動重啟

lee text 實時 之間 最終 ren tap instance and 摘要: 　觀察者模式，定義對象之間的一種一對多的依賴關系，當對象的狀態發生改變時，所有依賴於它的對象都得到通知並且被自動更新。觀察者模式在JDK中有現成的實現，java.util.Obsera

觀察者模式的應用：模擬MVC架構的實現

mvc架構是安卓的經典架構模式，它是觀察者模式的一個典型應用場景。今天我就用java程式來簡單模擬mvc架構的實現。 首先，簡單說下什麼是mvc架構。 mvc架構由model，view和controller三者組成，基於職責分離的原則，三者分別承擔不同的職責

觀察者模式實際應用場景-----Spring事件機制

以下虛擬碼是一個儲存訂單的功能，並會發送簡訊訊息： /** * Author heling on 2019/1/9 */ @Service public class OrderServiceImpl implements OrderService { @Override pub

觀察者模式的應用：Winform窗體之間傳值

觀察者模式的應用：Winform窗體傳值 觀察者模式的概念： 定義了物件之間的一對多依賴，這樣一來，當一個物件改變狀態時，它的所有依賴者都會收到通知並更新。 今天我們就學著用一下這個觀察者模式，先想象下這個場景：當一個窗體(主窗體)內的值發生變化時，另外幾個窗體內的值也會發生相應的變化。這個最簡單的實現方

PropertyChangeSupport 觀察者模式的應用

AD 發生 list 負責 get urn chan prope 屬性 PropertyChangeSupport 類實現的監聽器功能 ，它是java jdk自帶的一個類，用於監聽某個對象屬性的改變來觸發相應信息，具體看代碼介紹 import java.beans.Pro

(C#)設計模式 之 觀察者模式 (經典應用:貓叫,燒開水)

/* * 題目： * 貓叫了，所有老鼠開始逃跑，主人被驚醒，請用OO的思想描繪此過程 * 1，老鼠跟主人是被動的 * 2，要考慮聯動性與擴充套件性 */ using System; using System.Collections.Generic; using Syste

觀察者模式( Observer Pattern )： MVC的進一步泛化

參考書籍： 《Design Patterns: Elements of Reusable Object-Oriented Software》 在商業專案中第一次讀到觀察者模式的程式碼是一個非同

Linux下Tomcat服務監聽，關閉後自動重啟

本教程用來解決，linux下tomcat服務，因為各種原因異常關閉後，實現自動重啟服務，保證服務可用 還用到一個自啟動指令碼 #!/bin/sh # func:自動監控tomcat指令碼並且執行

Win10開機提示：你的電腦將在一分鐘後自動重啟

解決方法 啟動win10安全模式：按電源鍵開機，等系統載入時（有個圈圈在轉時），長按電源鍵強制關機，反覆操作兩次，第三次開機時進入高階啟動，然後點選高階選項=>啟動設定=>重啟=>

重學 Java 設計模式：實戰觀察者模式「模擬類似小客車指標搖號過程，監聽訊息通知使用者中籤場景」

![](https://img-blog.csdnimg.cn/20200630231649444.png) 作者：小傅哥 部落格：[https://bugstack.cn](https://bugstack.cn) - `原創系列專題文章` >沉澱、分享、成長，讓自己和他人都能有所收穫！

觀察者模式下es6的實現（自定義可監聽事件）

定義 觀察者模式：又叫釋出訂閱模式，多個觀察者可以實時監聽一個主題物件，而javascript中最常用的實現方式是事件觸發機制。 es6實現： 要知道需要有什麼東西，類和建構函式是es6中基本的物件結構 class BaseEvent { 　　constructor() {} } 首先類中要能儲

觀察者模式和事件監聽模式的區別

監聽機制 其他 不包含 機制 監聽 多態 場景 觀察者模式 特定 事件監聽模式更像是觀察者模式的進階。 觀察者模式中，‘主題’會在特定邏輯下通知所有‘觀察者’。如果這個通知不包含任何信息，那麽這種實現就是通常的觀察者模式。 如果‘主題’通知‘觀察者’的過程帶有一些<其

觀察者模式的程式例項C++ 以及觀察者模式與事件監聽的區別

一、什麼是觀察者模式      Observer模式也叫觀察者模式，它的作用是當一個物件的狀態發生變化時，可以自己主動通知其它關聯物件，自己主動重新整理物件狀態。 舉個樣例，使用者介面能夠作為一個觀察者，業務資料是被觀察者，使用者介面觀察業務資料的變化，發現數據變化後，

Spring中的觀察者模式-事件監聽

      在編碼過程中，我們經常會遇到完成一個操作需要多個步驟完成的情況。我們可能會把多個步驟寫到一個方法裡，假如這個操作需要新增步驟，那麼勢必要修改已有的方法，這違反了開閉原則。      我們可以使用spring的事件機制來簡單地實現這種功能

Unity如何實現網路通訊（三）：觀察者模式以及在網路模組的應用

    首先我們來說一下什麼叫觀察者模式。觀察者模式，顧名思義，就是觀察，那麼就會有觀察者和被觀察者，比如在軍隊中，所有的軍人要聽長官的指示，軍人就是觀察者，長官就是被觀察者，長官一聲號令：“向左轉！”，長官所有的監聽者就會執行向左轉的方法，那麼這就是一個觀察者模式的流程

JS實現監聽模式和觀察者模式

[b]引子：[/b]最近看阮一峰先生的[url=http://www.ruanyifeng.com/blog/2012/12/asynchronous＿javascript.html]這篇[/url]文章，文章涉及到觀察模式，監聽模式相關的設計模式的內容，正好，我最近也用sw

設計模式實戰應用之二：觀察者模式

        觀察者模式的定義        觀察者模式是應用最普遍的設計模式之一。著名的 MVC 模式就是觀察者模式的應用之一；高效能網路應用框架 MINA 中的事件處理器也是觀察者模式的應用之一，一旦有 I/O 事件，所有註冊的 IoHandler 物件會被通知到，我們

Unity中設計模式應用（二）：結合中介者模式的觀察者模式

一.觀察者模式簡介 觀察者模式（又被稱為釋出-訂閱（Publish/Subscribe）模式，屬於行為模式的一種，它定義了一種一對多的依賴關係，讓多個觀察者物件同時監聽某一個主題物件。當這個主題物件的狀態發生變化時，會通知所有此狀態的觀察者，這些觀察者會執行相

SpringBoot事件監聽機制及觀察者模式/釋出訂閱模式

[toc] ## 本篇要點 - 介紹觀察者模式和釋出訂閱模式的區別。 - SpringBoot快速入門事件監聽。 ## 什麼是觀察者模式？ 觀察者模式是經典行為型設計模式之一。 在GoF的《設計模式》中，觀察者模式的定義：**在物件之間定義一個一對多的依賴，當一個物件狀態改變的時候，所有依賴的物件都會自

觀察者模式，無需多執行緒完成資料監聽

大家好，我們今天來了解一個新的設計模式——觀察者模式。 觀察者模式的思路很簡單，它被廣泛地用在各種資料監控上。很多時候我們希望監聽某個資料的變化，希望一旦獲悉它的變化之後立即採取一些舉措。按照常規的操作，我們需要開啟額外的執行緒來進行監聽。但是開啟執行緒一則非常麻煩，二則需要帶來額外的開銷，我們今天介紹的觀察