Java设计模式（六）合成模式 享元模式

（十一）合成模式 Composite

合成模式是一组对象的组合，这些对象能够是容器对象，也能够是单对象。组对象同意包括单对象，也能够包括其它组对象，要为组合对象和单对象定义共同的行为。合成模式的意义是 保证client调用单对象与组合对象的一致性。

class TreeNode{
	private String name;
	private TreeNode parent;
	private Vector<TreeNode> children = new Vector<TreeNode>();
	public TreeNode(String name){
		this.name = name;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public TreeNode getParent() {
		return parent;
	}
	public void setParent(TreeNode parent) {
		this.parent = parent;
	}
	public void setChildren(Vector<TreeNode> children) {
		this.children = children;
	}
	//加入孩子节点
	public void add(TreeNode node){
		children.add(node);
	}
	//删除孩子节点
	public void remove(TreeNode node){
		children.remove(node);
	}
	//取得孩子节点
	public Enumeration<TreeNode> getChildren(){
		return children.elements();
	}
}
public class Composite {
	TreeNode root = null;
	public Composite(String name){
		root = new TreeNode(name);
	}
	public static void main(String[] args){
		Composite com = new Composite("A");
		TreeNode nodeb = new TreeNode("B");
		TreeNode nodec = new TreeNode("C");
		nodeb.add(nodec);
		com.root.add(nodeb);
	}
}

(十二) 享元模式 Flyweight

享元模式的主要目的是实现对象的共享，当系统中存在大量对象的时候降低内存开销。通常与工厂模式一同使用。

一个client请求时候。工厂检查当前对象池是否存在可用的对象，有就返回已经存在的对象。没有就创建一个新对象。数据库连接池就是最典型的运用享元模式的样例。

public class ConnectionPool implements IConnectionPool{
	private DBbean dbBean;	//连接池配置属性
	private boolean isActive = false;	//连接池活动状态
	private int contActive = 0;		//记录创建的总连接数
	private List<Connection> freeConnection = new Vector<Connection>();
	private List<Connection> activeConnection = new Vector<>();
	private static ThreadLocal<Connection> threadLocal = new ThreadLocal<>();
	public ConnectionPool(DBbean dbBean){
		super();
		this.dbBean = dbBean;
		init();
		cheackPool();
	}
	public void init(){
		try {
			Class.forName(dbBean.getDriverName());
			for(int i = 0;i < dbBean.getInitConnections();i++){
				Connection conn;
				conn = newConnection();
				if(conn != null){
					freeConnection.add(conn);
					contActive++;
				}
			}
			isActive = true;
		} catch (ClassNotFoundException | SQLException e) {
			e.printStackTrace();
		}
	}
	//获得当前连接数
	public Connection getCurrentConnection(){
		Connection conn = threadLocal.get();
		if(!isValid(conn)){
			conn = getConnection();
		}
		return conn;
	}
	// 获得连接  
    public synchronized Connection getConnection() {  
        Connection conn = null;  
        try {  
            // 推断是否超过最大连接数限制  
            if(contActive < this.dbBean.getMaxActiveConnections()){  
                if (freeConnection.size() > 0) {  
                    conn = freeConnection.get(0);  
                    if (conn != null) {  
                        threadLocal.set(conn);  
                    }  
                    freeConnection.remove(0);  
                } else {  
                    conn = newConnection();  
                }  
            }else{  
                // 继续获得连接,直到从新获得连接  
                wait(this.dbBean.getConnTimeOut());  
                conn = getConnection();  
            }  
            if (isValid(conn)) {  
                activeConnection.add(conn);  
                contActive ++;  
            }  
        } catch (SQLException e) {  
            e.printStackTrace();  
        } catch (ClassNotFoundException e) {  
            e.printStackTrace();  
        } catch (InterruptedException e) {  
            e.printStackTrace();  
        }  
        return conn;  
    }
    // 获得新连接  
    private synchronized Connection newConnection()  
            throws ClassNotFoundException, SQLException {  
        Connection conn = null;  
        if (dbBean != null) {  
            Class.forName(dbBean.getDriverName());  
            conn = DriverManager.getConnection(dbBean.getUrl(),  
                    dbBean.getUserName(), dbBean.getPassword());  
        }  
        return conn;  
    }  
    // 释放连接  
    public synchronized void releaseConn(Connection conn) throws SQLException {  
        if (isValid(conn)&& !(freeConnection.size() > dbBean.getMaxConnections())) {  
            freeConnection.add(conn);  
            activeConnection.remove(conn);  
            contActive --;  
            threadLocal.remove();  
            // 唤醒全部正待等待的线程，去抢连接  
            notifyAll();  
        }  
    }  
    // 推断连接是否可用  
    private boolean isValid(Connection conn) {
    	try {  
    		if (conn == null || conn.isClosed()) {  
    			return false;  
    		}  
    	} catch (SQLException e) {  
    		e.printStackTrace();  
    	}  
    	return true;  
    }
    // 销毁连接池  
    public synchronized void destroy() {  
        for (Connection conn : freeConnection) {  
            try {  
                if (isValid(conn)) {  
                    conn.close();  
                }  
            } catch (SQLException e) {  
                e.printStackTrace();  
            }  
        }  
        for (Connection conn : activeConnection) {  
            try {  
                if (isValid(conn)) {  
                    conn.close();  
                }  
            } catch (SQLException e) {  
                e.printStackTrace();  
            }  
        }  
        isActive = false;  
        contActive = 0;  
    }  
    // 连接池状态  
    @Override  
    public boolean isActive() {  
        return isActive;  
    }  
    // 定时检查连接池情况  
    @Override  
    public void cheackPool() {  
        if(dbBean.isCheakPool()){  
            new Timer().schedule(new TimerTask() {  
            @Override  
            public void run() {  
            // 1.对线程里面的连接状态  
            // 2.连接池最小 最大连接数  
            // 3.其它状态进行检查。由于这里还须要写几个线程管理的类，临时就不加入了  
            System.out.println("空线池连接数："+freeConnection.size());  
            System.out.println("活动连接数：："+activeConnection.size());  
            System.out.println("总的连接数："+contActive);  
                }  
            },dbBean.getLazyCheck(),dbBean.getPeriodCheck());  
        }  
    }  
}