com.mycomm.itool.listener.T.MyTListener Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of ITools Show documentation
ITools
The newest version!
/*
 * Copyright 2018 jw362j.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.mycomm.itool.listener.T;

import com.mycomm.itool.logs.TheLogger;
import java.util.LinkedList;
import java.util.List;
import java.util.Timer;
import java.util.TimerTask;

/**
 *
 * 
 */
public class MyTListener implements TListener {

    private final List> initializers;
    private final List> cleaners;
    private final List> scanners;
    private final long default_period = 1000 * 15;
    protected TheLogger logger;
    private boolean onetimeFlag = true;
    private T parameter;
    private final MyLifeCycle myLifeCycle;
    private Timer triger;

    public MyTListener(MyLifeCycle lifeCycle) {
        initializers = new LinkedList>();
        cleaners = new LinkedList>();
        scanners = new LinkedList>();
        myLifeCycle = lifeCycle;
    }

    public void TCreated(T t) {
        parameter = t;
        logger = myLifeCycle.loadLogger();
        if (logger == null) {
            logger = new TheLogger() {
                public void info(String msg) {
                    System.out.println(msg);
                }

                public void debug(String msg) {
                    System.out.println(msg);
                }

                public void error(String msg) {
                    System.err.println(msg);
                }
            };
        }
        myLifeCycle.LoadInitializers(initializers);
        logger.debug("initializers:" + initializers);

        if (initializers != null && initializers.size() > 0) {
            logger.debug("initializers length:" + initializers.size());
            for (TInitializer initializer : initializers) {
                if (initializer == null) {
                    logger.debug("initializer is null!");
                    continue;
                }
                logger.debug("invoking initializer:" + initializer);
                try {
                    initializer.onInit(t);
                } catch (Exception e) {
                    logger.error("Error happen when invoking initializer:" + initializer + ",error is:" + e.getMessage());
                }
                logger.debug("invoking initializer:" + initializer + " done!");
            }
        }

        //open scanner
        myLifeCycle.LoadScanner(scanners);
        logger.debug("scanners:" + scanners);
        if (onetimeFlag && scanners != null && scanners.size() > 0) {
            onetimeFlag = false;
            logger.debug("scanners size:" + scanners.size());
            triger = new Timer();
            long period = myLifeCycle.getScannerPeriod();
            period = period <= 0 ? default_period : period;
            triger.schedule(new RemindTask(), 1000 * 3, period);
        }
    }

    class RemindTask extends TimerTask implements ScannerExecuter{

        @Override
        public void run() {
            runScaners();
        }

        public List> getScanners() {
           return scanners;
        }

        public void runScaners() {
            
            if (getScanners() == null) {
                return;
            }
            for (TScanner scanner : getScanners()) {
                if (scanner == null) {
                    continue;
                }
                logger.info("run scanner:" + scanner);
                try {
                    scanner.onScan(parameter);
                } catch (Exception e) {
                    logger.error("error happen when invoking scanner:" + scanner + ",error is:" + e.getMessage());
                }
                logger.info("run scanner:" + scanner + " done!");
            }
        }
    }

    public void TDestroyed(T t) {
        cleaners.add(new TCleaner() {
            public void onClean(T t) {
                if (triger == null) {
                    return;
                }
                triger.cancel();
                triger = null;
            }
        });
        myLifeCycle.LoadCleaners(cleaners);
        logger.debug("cleaners:" + cleaners);
        if (cleaners != null && cleaners.size() > 0) {
            logger.debug("cleaners length:" + cleaners.size());
            for (TCleaner cleaner : cleaners) {
                if (cleaner == null) {
                    logger.debug("cleaner is null!");
                    continue;
                }
                logger.debug("invoking cleaner:" + cleaner);
                try {
                    cleaner.onClean(t);
                } catch (Exception e) {
                    logger.error("Error happen when invoking cleaner:" + cleaner + ",error is:" + e.getMessage());
                }
                logger.debug("invoking cleaner:" + cleaner + " done!");
            }
        }

        initializers.clear();
        cleaners.clear();
        scanners.clear();
    }

}