代理模式

代理模式

1、代理模式

1.1、应用场景

当程序涉及修改数据库中数据操作时，此时的一般操作流程是：
- 1、开启事务
- 2、修改操作
- 3、提交事务或者回滚事务

随着时间的推移，代码中开启事务、提交事务及回滚事务的代码将变得冗余。记录日志在程序中也是推荐使用，那么记录日志也将变得冗余，同时设计具体业务操作的时候，往往还得考虑事务、日志等方面的操作，不能专注于业务操作。

为了解决代码冗余以及业务对象专注于业务操作，产生了代理模式。

1.2、组成部分

代理模式有以下5部分组成：
- 1、target(目标对象/业务对象)
- 2、proxy(代理对象)
- 2、function(功能对象/事务对象、日志对象)
- 3、interceptor(拦截器对象)
- 4、client(客户端)

2、静态代理模式

通过代理类去完成目标类的目标方面，并且在该目标的类特定的代理类中附加上额外的功能

静态代理模式代码实例：

目标类接口

/**
* @ClassName: PersonDao
* @Description: PersonDao接口
* @author Yue Chang 
* @date 2017年3月23日 上午10:42:46 
* @since 1.0
*/
public interface PersonDao {
    public void deletePerson();
    public void updatePerson();
}

目标类实现类

/**
* @ClassName: PersonDaoImpl
* @Description: PersonDao接口实现类
* @author Yue Chang 
* @date 2017年3月23日 上午10:42:05 
* @since 1.0
*/
public class PersonDaoImpl implements PersonDao {

    @Override
    public void deletePerson() {
        System.out.println("delete Person !~");
    }

    @Override
    public void updatePerson() {
        System.out.println("update Person !~");
    }
}

事务类

/**
* @ClassName: Transaction
* @Description: 事务类
* @author Yue Chang 
* @date 2017年3月23日 上午10:45:19 
* @since 1.0
*/
public class Transaction {

    public void beginTransaction(){
        System.out.println("begin transaction !~");
    }

    public void commit(){
        System.out.println("transaction commit !~");
    }

    public void rollback(){
        System.out.println("transaction rollback !~");
    }
}

拦截器类

/**
* @ClassName: MyHandler
* @Description: 拦截器类
* @author Yue Chang 
* @date 2017年3月23日 上午11:54:30 
* @since 1.0
*/
public class MyHandler implements PersonDao {

    private Transaction transaction;
    private PersonDao personDaoTarget;

    /**
     * @param transaction
     * @param personDao
     */
    public MyHandler(Transaction transaction, PersonDao personDao) {
        super();
        this.transaction = transaction;
        this.personDaoTarget = personDao;
    }

    @Override
    public void deletePerson() {
        try {
            // 开启事务
            transaction.beginTransaction();
            // 目标类对象调用目标方法
            personDaoTarget.deletePerson();
            // 提交事务
            transaction.commit();
        } catch (Exception e) {
            // 回滚事务
            transaction.rollback();
        }
    }

    @Override
    public void updatePerson() {
        try {
            // 开启事务
            transaction.beginTransaction();
            // 目标类对象调用目标方法
            personDaoTarget.updatePerson();
            // 提交事务
            transaction.commit();
        } catch (Exception e) {
            // 回滚事务
            transaction.rollback();
        }
    }

    public Transaction getTransaction() {
        return transaction;
    }

    public void setTransaction(Transaction transaction) {
        this.transaction = transaction;
    }

    public PersonDao getPersonDaoTarget() {
        return personDaoTarget;
    }

    public void setPersonDaoTarget(PersonDao personDaoTarget) {
        this.personDaoTarget = personDaoTarget;
    }
}

客户端对象

/**
* @ClassName: StaticProxyTest
* @Description: 静态代理模式测试类
* @author Yue Chang 
* @date 2017年3月23日 下午12:01:49 
* @since 1.0
*/
public class StaticProxyTest {

    @Test
    public void testStaticProxy(){

        PersonDao personDao = new PersonDaoImpl();
        Transaction transaction = new Transaction();
        MyHandler myHandler = new MyHandler(transaction, personDao);

        myHandler.deletePerson();
        System.out.println();
        myHandler.updatePerson();
    }
}

程序执行结果：

begin transaction !~
delete Person !~
transaction commit !~

begin transaction !~
update Person !~
transaction commit !~

优点：。
1、可以在不改变目标类的基础上，增加额外的功能，耦合度低；
2、让目标类专注于业务开发，无需关注业务之外的功能；
缺点：
1、对于每一个目标类都需要编写一个handler，代码冗余，增加代码维护成本；

3、动态代理

为了解决静态代理模式的代码冗余的缺点，以及继续保持低耦合的优点，也就有了动态代理模式。其中包括cglib动态代理模式和jdk动态代理模式。

3.1 jdk动态代理模式

jdk动态代理模式代码实例：

PersonDao接口

/**
* @ClassName: PersonDao
* @Description: PersonDao接口
* @author Yue Chang 
* @date 2017年3月23日 上午10:42:46 
* @since 1.0
*/
public interface PersonDao {
    public void deletePerson();
    public void updatePerson();
}

PersonDao接口实现类

/**
* @ClassName: PersonDaoImpl
* @Description: PersonDao接口实现类
* @author Yue Chang 
* @date 2017年3月23日 上午10:42:05 
* @since 1.0
*/
public class PersonDaoImpl implements PersonDao {

    @Override
    public void deletePerson() {
        System.out.println("delete Person !~");
    }

    @Override
    public void updatePerson() {
        System.out.println("update Person !~");
    }
}

功能类(事务类）

/**
* @ClassName: Transaction
* @Description: 事务类
* @author Yue Chang 
* @date 2017年3月23日 上午10:45:19 
* @since 1.0
*/
public class Transaction {

    public void beginTransaction(){
        System.out.println("begin transaction !~");
    }

    public void commit(){
        System.out.println("transaction commit !~");
    }

    public void rollback(){
        System.out.println("transaction rollback !~");
    }
}

拦截器

/**
 * @ClassName: MyHandler
 * @Description: 拦截器
 * @author Yue Chang
 * @date 2017年3月23日 上午10:49:05
 * @since 1.0
 */
public class MyHandler implements InvocationHandler {

    private Object target;
    private Transaction transaction;

    /**
     * @param target 目标对象
     * @param tansaction 事务对象
     */
    public MyHandler(Object target, Transaction transaction) {
        super();
        this.target = target;
        this.transaction = transaction;
    }

    // invoke方法
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        try {
            // 开启事务
            transaction.beginTransaction();
            // 调用目标类的目标方法，
            method.invoke(target, args);
            // 提交事务
            transaction.commit();

        } catch (Exception e) {

            // 回滚事务
            transaction.rollback();
        }
        return null;
    }

    // getter/setter方法
}

客户端测试类

/**
* @ClassName: JdkProxyTest
* @Description: jdk动态代理客户端
* @author Yue Chang 
* @date 2017年3月23日 上午10:56:36 
* @since 1.0
*/
public class JdkProxyTest {

    @Test
    public void testJdkProxy(){

        // 目标对象
        PersonDao target = new PersonDaoImpl();
        // 事务对象
        Transaction transaction = new Transaction();
        // 拦截器对象
        MyHandler myIntercepter = new MyHandler(target, transaction);
        // PersonDao代理对象
        PersonDao proxy = (PersonDao) Proxy.newProxyInstance(target.getClass().getClassLoader(),
            target.getClass().getInterfaces(), myIntercepter);

        proxy.deletePerson();
        System.out.println();
        proxy.updatePerson();
    }
}

代码执行结果：

begin transaction !~
delete Person !~
transaction commit !~

begin transaction !~
update Person !~
transaction commit !~

如果想再加入其他功能，比如日志，则需要在MyHandler类中，新增成员变量Logger，修改对应的构造方法，在invoke方法中增加对应操作。同时，如果觉得不需要事务，也同样可以操作MyHandler类来去除事务，这样的操作与目标类没有任何影响，完全松耦合。

3.2 cglib动态代理模式

cglib动态代理模式与jdk动态代理模式类似，cglib动态代理模式代码如下：
PersonDao接口

/**
* @ClassName: PersonDao
* @Description: PersonDao接口
* @author Yue Chang 
* @date 2017年3月23日 上午10:42:46 
* @since 1.0
*/
public interface PersonDao {

    public void deletePerson();
    public void updatePerson();
}

PersonDao接口实现类

/**
* @ClassName: PersonDaoImpl
* @Description: PersonDao接口实现类
* @author Yue Chang 
* @date 2017年3月23日 上午10:42:05 
* @since 1.0
*/
public class PersonDaoImpl implements PersonDao {

    @Override
    public void deletePerson() {
        System.out.println("delete Person !~");
    }

    @Override
    public void updatePerson() {
        System.out.println("update Person !~");
    }
}

事务类

/**
* @ClassName: Transaction
* @Description: 事务类
* @author Yue Chang 
* @date 2017年3月23日 上午10:45:19 
* @since 1.0
*/
public class Transaction {

    public void beginTransaction(){
        System.out.println("begin transaction !~");
    }

    public void commit(){
        System.out.println("transaction commit !~");
    }

    public void rollback(){
        System.out.println("transaction rollback !~");
    }
}

cglib代理类拦截器

/**
 * @ClassName: MyInterceptor
 * @Description: cglib代理类拦截器
 * @author Yue Chang
 * @date 2017年3月23日 下午12:19:35
 * @since 1.0
 */
public class MyInterceptor implements MethodInterceptor {

    private Object target;
    private Transaction transaction;

    /**
     * @param target
     * @param transaction
     */
    public MyInterceptor(Object target, Transaction transaction) {
        super();
        this.target = target;
        this.transaction = transaction;
    }

    /**
     * @category 创建代理对象，可以在客户端完成
     * @since cglib proxy
     * @author Yue Chang 
     * @date 2017年3月31日 上午11:41:50 
     * @return
     */
    public Object createProxy(){
        Enhancer enhancer = new Enhancer();
        enhancer.setCallback(this);
        enhancer.setSuperclass(target.getClass());
        return enhancer.create();
    }

    @Override
    public Object intercept(Object arg0, Method method, Object[] args, 
        MethodProxy arg3) throws Throwable {

        try {
            transaction.beginTransaction();
            method.invoke(target, args);
            transaction.commit();
        } catch (Exception e) {
            e.printStackTrace();
            transaction.rollback();
        }
        return null;
    }

    // getter/setter方法
}

客户端

/**
* @ClassName: CglibProxyTest
* @Description: cglib代理模式测试类
* @author Yue Chang 
* @date 2017年3月25日 下午3:48:01 
* @since 1.0
*/
public class CglibProxyTest {

    @Test
    public void testCglibProxy(){

        PersonDao target = new PersonDaoImpl();
        Transaction transaction = new Transaction();
        MyInterceptor myInterceptor = new MyInterceptor(target, transaction);
        PersonDao proxy = (PersonDao) myInterceptor.createProxy();

        proxy.deletePerson();
        System.out.println();
        proxy.updatePerson();
    }
}

程序运行结果：

begin transaction !~
delete Person !~
transaction commit !~

begin transaction !~
update Person !~
transaction commit !~

3.3 jdk动态代理模式和cglib动态代理模式的区别

均在invoke方法中，对于复杂的逻辑处理比较困难。其中，具体方法由对应method参数决定。

jdk动态代理模式中，是通过Proxy.newProxyInstance来创建代理对象；
cglib动态代理模式中，是通过Enhancer对象来创建代理对象；

jdk动态代理模式中，代理类与目标类实现了相同的接口；
cglib动态代理模式中，代理类是目标类的子类；

这一点区别其实也可以从创建代理对象中发现，jdk的获得目标类以及目标类的所有接口

Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), myIntercepter);

cglib 将目标类设置为代理对象的超类

Enhancer enhancer = new Enhancer();
        enhancer.setCallback(this);
        enhancer.setSuperclass(target.getClass());
        return enhancer.create();

4、拓展

可以申明一个Interceptor类，里面定义interceptor方法，将所有需要附加的功能类都实现Interceptor接口，将需要的操作在interceptor方法中实现，然后在动态代理模式中定义List interceptorList成员变量，初始化时传入interceptorList，在invoke方法中迭代此List，并执行Interceptor对象的interceptor方法，这样可以执行附加多个功能，并且不频繁改动拦截器类。