关于装饰模式和动态代理模式

装饰模式和动态代理模式乍一看差不多，都是动态的增加行为，其实有各自的区别。

一、首先我们看一下装饰设计模式，其基本思想如下：

1、编写一个类，实现与被装饰类相同的接口。目的使他们有相同的行为

2、定义一个实例变量，引用被装饰对象。目的和原来的老对象进行交接

3、定义构造方法，把被装饰对象注入进来。

4、对于不需要改写的方法，调用被装饰对象的。

5、对于要改写的方法，改写即可。

废话不多说，举一个例子，模拟实现一个数据库连接池，在这里，我想重写close方法，以实现调用close方法之后不是关闭连接，而是归还连接。

首先，继承java.sql.Connection接口，写一个类MyConnection：

package pool;

import java.sql.Array;
import java.sql.Blob;
import java.sql.CallableStatement;
import java.sql.Clob;
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.NClob;
import java.sql.PreparedStatement;
import java.sql.SQLClientInfoException;
import java.sql.SQLException;
import java.sql.SQLWarning;
import java.sql.SQLXML;
import java.sql.Savepoint;
import java.sql.Statement;
import java.sql.Struct;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.concurrent.Executor;

//1、编写一个类，实现与被装饰类(com.mysql.jdbc.Connection)相同的接口。目的使他们有相同的行为
//2、定义一个实例变量，引用被装饰对象。目的和原来的老对象进行交接
//3、定义构造方法，把被装饰对象注入进来。
//4、对于不需要改写的方法，调用被装饰对象的。
//5、对于要改写的方法，改写即可。

public class MyConnection implements Connection {
    
    private Connection conn;
    private List<Connection> pool;
    
    public MyConnection(Connection conn, List<Connection> pool){
        this.conn = conn;
        this.pool = pool;
    }

    //把conn还回池中
    @Override
    public void close() throws SQLException {
        pool.add(conn);
    }
    
    //静态代理
    @Override
    public <T> T unwrap(Class<T> iface) throws SQLException {
        return conn.unwrap(iface);
    }

    @Override
    public boolean isWrapperFor(Class<?> iface) throws SQLException {
        return conn.isWrapperFor(iface);
    }

除了重写的close方法进行改写，其余的都调用被装饰对象的，即conn.

接下来，继承标准的数据源，写一个MyDataSource，这里只演示重写getConnection()方法。

package pool;

import java.awt.Menu;
import java.io.PrintWriter;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.SQLFeatureNotSupportedException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.logging.Logger;

import javax.sql.DataSource;

import day02.JDBCUtil;

//继承标准的数据源
public class MyDataSource implements DataSource {
    
    //存放链接对象的池
    private static List<Connection> pool = 
            Collections.synchronizedList(new ArrayList<Connection>());
    //最开始初始化一些链接到池中
    static{
        for (int i = 0; i < 10; i++) {
            Connection conn = JDBCUtil.getConnection();
            pool.add(conn);
        }
    }
    
    @Override
    public Connection getConnection() throws SQLException {
        if(pool.size() > 0){
            Connection connection =  pool.remove(0);
            //使用装饰模式
            MyConnection myConnection = new MyConnection(connection, pool);
            return myConnection;

        }else{
            throw new RuntimeException("服务器忙");
        }
    }

 可以通过以下代码进行验证：

@Test
    public void test1() throws SQLException{
        MyDataSource ds = new MyDataSource();
        //保存
        Connection conn = ds.getConnection();
        System.out.println(conn.getClass().getName()); //输出MyConnection
        //-----------
        conn.close();//需要重新写一下close方法，不让它关闭而是归还连接
        
        //删除
        Connection conn1 = ds.getConnection();
        //-----------
        conn1.close();
    }

二、对于动态代理模式，是AOP技术实现的关键，实现它有两种方式：

基于接口的动态代理：

前提：被代理对象的类，实现了至少一个接口

基于子类的动态代理：

借助第三方-CGLIB。

这里我们采用基于接口的动态代理进行演示刚才的例子：

不用写MyConnection了，只需要写MyDataSource:

package pool;

import java.awt.Menu;
import java.io.PrintWriter;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.SQLFeatureNotSupportedException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.logging.Logger;

import javax.sql.DataSource;

import day02.JDBCUtil;

//继承标准的数据源
public class MyDataSource implements DataSource {
    
    //存放链接对象的池
    private static List<Connection> pool = 
            Collections.synchronizedList(new ArrayList<Connection>());
    //最开始初始化一些链接到池中
    static{
        for (int i = 0; i < 10; i++) {
            Connection conn = JDBCUtil.getConnection();
            pool.add(conn);
        }
    }
    
    @Override
    public Connection getConnection() throws SQLException {
        if(pool.size() > 0){
            final Connection connection =  pool.remove(0);//使用动态代理模式
            Connection proxyConnection = (Connection) Proxy.newProxyInstance(
                    connection.getClass().getClassLoader(), 
                    new Class[]{Connection.class},
                    new InvocationHandler() {
                        
                        @Override
                        public Object invoke(Object proxy, Method method, Object[] args)
                                throws Throwable {
                            if("close".equals(method.getName())){
                                //用户调用close方法，返回池中
                                pool.add(connection);
                            }else{
                                //其他方法，调用原来对象的对应方法
                                method.invoke(connection, args);
                            }
                            return null;
                        }
                    });
            return proxyConnection;
        }else{
            throw new RuntimeException("服务器忙");
        }
    }
    

然后进行验证：

@Test
    public void test1() throws SQLException{
        MyDataSource ds = new MyDataSource();
        //保存
        Connection conn = ds.getConnection();
        System.out.println(conn.getClass().getName());//com.sun.proxy.$Proxy4
        //-----------
        conn.close();//需要重新写一下close方法，不让它关闭而是归还连接
        
        //删除
        Connection conn1 = ds.getConnection();
        //-----------
        conn1.close();
    }

对装饰器模式来说，装饰者（decorator）和被装饰者（decoratee）都实现同一个 接口。对代理模式来说，代理类（proxy class）和真实处理的类（real class）都实现同一个接口。此外，不论我们使用哪一个模式，都可以很容易地在真实对象的方法前面或者后面加上自定义的方法。

然而，实际上，在装饰器模式和代理模式之间还是有很多差别的。装饰器模式关注于在一个对象上动态的添加方法，然而代理模式关注于控制对对象的访问。换句话 说，用代理模式，代理类（proxy class）可以对它的客户隐藏一个对象的具体信息。因此，当使用代理模式的时候，我们常常在一个代理类中创建一个对象的实例。并且，当我们使用装饰器模 式的时候，我们通常的做法是将原始对象作为一个参数传给装饰者的构造器。

我们可以用另外一句话来总结这些差别：使用代理模式，代理和真实对象之间的的关系通常在编译时就已经确定了，而装饰者能够在运行时递归地被构造。