代理模式

一、解决何种问题？

　　将 “主要业务”和“次要业务”做解耦合处理

二、“主要业务”和“次要业务”的区分

　　“主要业务”：要实现的关键性任务

　　“次要业务”：起到辅助功能，辅助“主要业务”顺利实现，在项目中，“次要业务”往往大量重复出现。因此大量重复编写“次要业务”往往会影响开发效率

三、以使用JDBC操作数据库为例，来划分“主要业务”和“次要业务”

　　1、加载数据库驱动（次要业务）

　　2、建立连接（次要业务）

　　3、执行sql语句（主要业务）

　　4、遍历结果集（次要业务）

　　5、关闭资源（次要业务）

四、JDK动态代理

　　1、组成

　　　　· 接口：声明需要被监听的行为

　　　　· 代理实现类（实现InvocationHandler接口）：将“次要业务”和"主要业务"绑定执行

　　　　· 代理目标对象：执行“主要业务”

　　2、特点：

　　　　· 代理对象，不需要实现接口；

　　　　· 代理对象的生成，是利用JDK  API， 动态的在内存中构建代理对象(需要我们指定创建 代理对象/目标对象 实现的接口的类型；

　　　　· 动态代理， JDK代理， 接口代理；  

　　　　· 代理对象不需要实现接口，但是目标对象一定要实现接口；否则不能用动态代理！

　　3、代码示例

　　　　· 创建Interface

package com.kkb.jdk.proxy;

/**
 * 声明需要被监听的方法：findByShopId、findByUserId
 */
public interface IOrderDao {
    Object findByShopId(int shopId);
    Object findByUserId(int userId);
}

 　　　　· 创建实现类

package com.kkb.jdk.proxy;

public class OrderDao implements IOrderDao{
    @Override
    public Object findByShopId(int shopId) {
        System.out.println("执行根据 shopId 查询订单的 sql 语句");
        return null;
    }

    @Override
    public Object findByUserId(int userId) {
        System.out.println("执行根据 userId 查询订单的 sql 语句");
        return null;
    }
}

　　　　· 创建代理实现类

package com.kkb.jdk.proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

/**
 * 代理实现类（实现InvocationHandler接口）：用于“主要业务”和“次要业务”绑定执行
 */
public class Agent implements InvocationHandler {

    private Object target;

    public Agent(Object target){
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] params) throws Throwable {
        Object returnValue  = null;
        prePrimaryService();//执行次要业务
        returnValue  = method.invoke(target,params);//执行主要业务（method：需要执行的目标对象的方法，target：目标对象 params：目标对象的方法所需要的参数）
        afterPrimaryService();//执行次要业务
        return returnValue ;
    }

    /**
     * 执行在主要业务之前的次要业务
     */
    private void prePrimaryService(){
        System.out.println("加载数据库驱动");
        System.out.println("建立连接");
    }

    /**
     * 执行在主要业务之后的次要业务
     */
    private void afterPrimaryService(){
        System.out.println("遍历结果集");
        System.out.println("关闭资源");
    }
}

　　　　· 创建代理类工厂

package com.kkb.jdk.proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;

/**
 * 代理实现类的工厂
 */
public class ProxyFactory {
    public static Object getInstance(IOrderDao orderDao){
        //将目标对象传给代理实现类
        InvocationHandler handler = new Agent(orderDao);
        //ClassLoader loader: 代理对象的字节码文件的地址
        //Class<?>[] interfaces: 需要监听的接口
        //InvocationHandler h :代理实现类
        return Proxy.newProxyInstance(orderDao.getClass().getClassLoader(),orderDao.getClass().getInterfaces(),handler);

    }
}

　　　　· 创建测试类

package com.kkb.jdk.proxy;

public class Client {
    public static void main(String[] args) {
        //代理目标对象
        IOrderDao orderDao = new OrderDao();
        //代理对象
        IOrderDao proxy = (IOrderDao)ProxyFactory.getInstance(orderDao);

        proxy.findByShopId(0);
        System.out.println("
----------------------------");
        proxy.findByUserId(0);
    }
}

　　　　· 打印测试结果

加载数据库驱动
建立连接
执行根据 shopId 查询订单的 sql 语句
遍历结果集
关闭资源

----------------------------
加载数据库驱动
建立连接
执行根据 userId 查询订单的 sql 语句
遍历结果集
关闭资源

 五、Cglib动态代理

　　1、组成

　　　　· 代理实现类（实现MethodInterceptor接口）：将“次要业务”和"主要业务"绑定执行

　　　　· 代理目标对象：执行“主要业务”

　　2、特点

　　　　· Cglib代理，也叫做子类代理。在内存中构建一个子类对象从而实现对目标对象功能的扩展；

　　　　· 目标对象不需要实现接口；

　　　　· 需要引入需要引入cglib – jar文件；

　　　　· 代理的类不能为final， 否则报错。目标对象的方法如果为final/static, 那么就不会被拦截；

　　3、代码实例

　　　　· 代理类

package com.kkb.cglib.proxy;

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import sun.management.MethodInfo;
import sun.reflect.MethodAccessor;

import java.lang.reflect.Method;

/**
 * Cglib 代理实现类，实现MethodInterceptor接口
 */
public class CglibAgent implements MethodInterceptor {
    //代理目标对象
    private Object target;

    public CglibAgent(Object target) {
        this.target = target;
    }

    //给目标对象创建代理对象
    public  Object getProxyInstance(){
        //工具类
        Enhancer enhancer = new Enhancer();
        //设置父类
        enhancer.setSuperclass(target.getClass());
        //设置回调函数
        enhancer.setCallback(this);
        //创建子类
        return enhancer.create();
    }

    @Override
    public Object intercept(Object o, Method method, Object[] params, MethodProxy methodProxy) throws Throwable {
        prePrimaryService();//执行次要业务
        //执行主要业务（method：需要执行的目标对象的方法，target：目标对象 params：目标对象的方法所需要的参数）
        Object returnValue = method.invoke(target,params);
        afterPrimaryService();//执行次要业务
        return returnValue;//目标对象方法的返回值
    }

    /**
     * 执行在主要业务之前的次要业务
     */
    private void prePrimaryService(){
        System.out.println("加载数据库驱动");
        System.out.println("建立连接");
    }

    /**
     * 执行在主要业务之后的次要业务
     */
    private void afterPrimaryService(){
        System.out.println("遍历结果集");
        System.out.println("关闭资源");
    }
}

　　　　· 创建测试类

package com.kkb.cglib.proxy;

import com.kkb.jdk.proxy.ProxyFactory;

public class Client {
    public static void main(String[] args) {
        //代理目标对象
        IOrderDao orderDao = new OrderDao();
        //代理
        IOrderDao proxy = (IOrderDao) new CglibAgent(orderDao).getProxyInstance();

        proxy.findByShopId(0);
        System.out.println("
----------------------------");
        proxy.findByUserId(0);
    }
}

　　　　·打印测试结果

加载数据库驱动
建立连接
执行根据 shopId 查询订单的 sql 语句
遍历结果集
关闭资源

----------------------------
加载数据库驱动
建立连接
执行根据 userId 查询订单的 sql 语句
遍历结果集
关闭资源

六、总结

　　在Spring的AOP编程中，如果加入容器的目标对象有实现接口，用JDK代理；如果目标对象没有实现接口，用Cglib代理；