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);
}
}

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

一个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());
}
}
}