operation.java

sp最新短信API(综合网关)

package com.wayout.wayoutsp.operation;

import java.util.*;
import java.net.*;
import java.sql.*;
import com.wayout.wayoutsp.operation.Operation.*;

/**
 * <p>Title: Operation</p>
 * <p>Description:SP业务基类</p>
 * <p>Copyright: Copyright (c) 2002</p>
 * <p>Company: wayout</p>
 * @author wayout
 * @version 1.0
 */

public abstract class Operation
{
//	private Thread _handBusi = null;

    private Object _lockNotify = new Object();

    private Vector _packages = new Vector();

    /*
     * 是否需要数据库支持,缺省为需要
     */
    private boolean _needDBSupport = true;

    /*
     * 数据库连接池
     */
    private Map _databaseConnectionPool = new HashMap();

    /*
     * 数据库参数表
     */
    private Map _databaseCollection = new HashMap();

    protected boolean initDefaultConfig(){
      return true;
    }
    /**
     * 要使用的数据库描述
     * @param DBLocalName 数据库名,在每个业务中一定为唯一值
     * @param DBDriver    数据库的驱动
     * @param DBUrl       数据库的有效地址
     * @param DBUser      数据库的用户名
     * @param DBPass      数据库的密码
     */
    protected final void addDatabase(String DBLocalName,
                        String DBDriver,
                        String DBUrl,
                        String DBUser,
                        String DBPass)
    {
        DatabaseConfig database = new DatabaseConfig();
        database._DBLocalName = DBLocalName;
        database._DBDriver = DBDriver;
        database._DBUrl = DBUrl;
        database._DBUser = DBUser;
        database._DBPass = DBPass;

        _databaseCollection.put(database._DBLocalName,database);
    }

//    private String[] _DBLocalName = new String[0];
//    private String[] _DBDriver = new String[0];
//    private String[] _DBUrl = new String[0];
//    private String[] _DBUser = new String[0];
//    private String[] _DBPass = new String[0];


    private final void startAllDatabaseConnect()
    {
        if(!_needDBSupport)
        {
            return;
        }

        if(_databaseCollection.isEmpty())
        {
            throw new IllegalStateException("Beacuse you choose database support ,you Must init database parameter!");
        }

        Iterator iterator = _databaseCollection.entrySet().iterator();
        while(iterator.hasNext())
        {
            Map.Entry data= (Map.Entry)iterator.next();
            startDBConnect((DatabaseConfig)data.getValue());
        }

    }

    /**
     * 如果你需要数据库的支持请调用此方法
     */
    protected final void setNotNeedDBSupport()
    {
        this._needDBSupport = false;
    }

    private final void startDBConnect(final DatabaseConfig database)
    {

        try
        {
            Class.forName(database._DBDriver).newInstance();
        }
        catch (ClassNotFoundException ex)
        {
            System.err.println("Please check your CLASSPATH and ensure it include <"+database._DBDriver+">" );
            System.exit(-1);
        }
        catch (IllegalAccessException ex)
        {
        }
        catch (InstantiationException ex)
        {
        }

//        System.out.println("Come in startDBConnect()");

        try{
            Connection connection = DriverManager.getConnection(database._DBUrl,
                                                                database._DBUser,
                                                                database._DBPass);
            addToConnectionPool(database,connection);
            if(OperManager.DEBUG)
            {
                System.out.println("this._databaseConnectionPool.size() = "+this._databaseConnectionPool.size());
                System.out.println("<Connect to database status><BGN>Connect to Database success<END>");
                System.out.println(database.toString());
            }
        }
        catch(java.sql.SQLException ex)
        {
            System.err.println("<ERROR><Connection><BGN>connect to database error<END>");
            System.out.println(ex.getMessage());
        }


        Thread dbConnect = new Thread(new Runnable()
        {
            public void run()
            {
//				connect();

                for(;;)
                {
//					System.out.println("Come in maintenance database connection thread");
                    Connection connect = (Connection)getDatabaseConnection(database._DBLocalName);
                    if(null == connect)
                    {
                        System.err.println("<ERROR><DATABASE><BGN> null == connect <END>");
                        connect();

                    }

                    if(isClosed(connect))
                    {
                        System.err.println("<ERROR><DATABASE><BGN> connect is close. <END>");
                        connect();
                    }

                    try {
                        Thread.sleep(10000);
                    }
                    catch (InterruptedException ex) {
                    }
                }
            }

            private void connect()
            {
                try{
                     Connection connection = DriverManager.getConnection(database._DBUrl,
                                                                         database._DBUser,
                                                                         database._DBPass);
                    addToConnectionPool(database,connection);
                    if(OperManager.DEBUG)
                    {
                        System.out.println("_databaseConnectionPool.size() = "+_databaseConnectionPool.size());
                        System.out.println("<Connection><BGN>Connect to Database success<END>");
                        System.out.println(database.toString());
                    }
                }
                catch(java.sql.SQLException ex)
                {
                    System.err.println("<ERROR><DATABASE><BGN>connect to database error<END>");
                    System.out.println(ex.getMessage());
                }
            }

            private boolean isClosed(Connection connect)
            {
                boolean isClosed = false;

//                try {
//                    if(connect.isClosed())
//                    {
//                        return true;
//                    }
//                }
//                catch (SQLException ex)
//				{
//					return true;
//                }

                if(null == connect)
                {
                    return true;
                }

                ResultSet rs = null;
                String query = "select 1 from dual ";
                try
                {
                    synchronized (connect) {
                        Statement stmt = connect.createStatement();
                        rs = stmt.executeQuery(query);
                        stmt.close();
                    }


                }
                catch(SQLException e)
                {
                    System.err.println("<ERROR><DATABASE><BGN>at maintenance database thread isClose() method <END>");
                    System.err.println(e.getMessage());
                    return true;
                }


                return isClosed;
            }
        });
        dbConnect.start();

    }

    private final void addToConnectionPool(DatabaseConfig database,Connection connection)
    {
        synchronized (_databaseConnectionPool)
        {
            if(_databaseConnectionPool.containsKey(database._DBLocalName))
            {
                Connection connectLocal = (Connection)_databaseConnectionPool.get(database._DBLocalName);
                if(null != connectLocal)
                {
                    try
                    {
                        connectLocal.close();
                    }
                    catch (SQLException ex)
                    {
                    }
                }
                _databaseConnectionPool.remove(database._DBLocalName);
            }
            _databaseConnectionPool.put(database._DBLocalName,connection);
        }
    }

    /**
     *  根据数据库名得到数据库连接
     * @param DBLocalName 数据库名
     * @return 与数据库名相对应的数据库连接
     */
    public final Connection getDatabaseConnection(String DBLocalName)
    {
        Connection connection = null;
        synchronized (_databaseConnectionPool)
        {
//			for(int i = 0; i<3; i++)
//			{
//				if(_databaseConnectionPool.size() == 0)
//				{
//					try {
//						Thread.sleep(5000);
//					}
//					catch (InterruptedException ex) {
//					}
//
//				}
                connection = (Connection)_databaseConnectionPool.get(DBLocalName);
//				if(null == connection)
//				{
//					try {
//						Thread.sleep(3000);
//					}
//					catch (InterruptedException ex) {
//					}
//
//				}
//			}

        }
        return connection;
    }


    public final static void register(Operation oper)
    {
        OperManager.getInstance().register(oper);
    };

    /**
     * 启动所有服务
     */
    protected final void startAllKindServer()
    {
        addAllDatabase();
        startAllDatabaseConnect();
        initDefaultConfig();
        startHandBusiThread();

        register(this);
    }

    /*
     * <Warning><BNG>Only can invoke once.<END>
     */
    private final void startHandBusiThread()
    {
        Runnable run = new Runnable()
        {
            public void run()
            {
                for(;;)
                {
                    while(_packages.isEmpty())
                    {
                        synchronized (_lockNotify)
                        {
                            try {
                                _lockNotify.wait();
                            }
                            catch (InterruptedException ex)
                            {
                            }
                        }
                    }

                    int packsize = _packages.size() ;
                    for (int i=0; i<packsize; i++)
                    {
                        handBusi(_packages.get(0));
                        _packages.removeElementAt(0);
                    }


//                    Object[] arrLocal;
//
//                    arrLocal = _packages.toArray();
//
//                    for(int i = 0; i< arrLocal.length; i++)
//                    {
//                        handBusi(arrLocal[i]);
//                        _packages.removeElementAt(0);
//                    }
                }

            }
        };
       Thread handBusiThread = new Thread(run);
       handBusiThread.start();
    }

    /**
     * 提供给Operation调用
     * @param obj 传入的包
     * @return 是否属于自己的业务范围
     */
    public final boolean addPackage(Object obj)
    {
        if(!isOwnBusi(obj))
        {
            return false;
        }

        synchronized (_lockNotify)
        {
            _packages.addElement(obj);
            _lockNotify.notifyAll();
        }
        return true;
    }

    /**
      * 判断是否是自己业务
      * @param obj 要读入的包
      * @return 是否是自己业务
      */
    protected abstract boolean isOwnBusi(Object obj);

    /**
     * 做业务处理
     * @param obj 要读入的包
     */
    protected abstract void handBusi(Object obj);

    /**
     * 如果你想有数据库支持,请override此方法.
     */
    protected void addAllDatabase()
    {
        setNotNeedDBSupport();
    }

    /* <Warning><BGN>私有内部类<END>
     * 用户所指向的数据库
     */
    private class DatabaseConfig
    {
        public String _DBLocalName = null;
        public String _DBDriver = null;
        public String _DBUrl = null;
        public String _DBUser = null;
        public String _DBPass = null;

        public String toString()
        {
            StringBuffer buffer = new StringBuffer();
            buffer.append("############################################\n");
            buffer.append("#DBdriver = "+ _DBDriver+"\n");
            buffer.append("#DBUrl ="+ _DBUrl+"\n");
            buffer.append("#DBUser ="+ _DBUser+"\n");
            buffer.append("#DBPass ="+ _DBPass+"\n");
            buffer.append("############################################\n");
            return buffer.toString();
       }
    }


}