设计模式2：java中的代理模式

1.静态代理

1.1抽象接口

/**
 * 抽象接口
 */
public interface IUserDao {

    void save();
}

1.2 目标对象

/**
 * 接口实现
 * 目标对象
 */
public class UserDao implements IUserDao {
    public void save() {
        System.out.println("----已经保存数据!----");
    }
}

1.3 代理对象

/**
 * 代理对象,静态代理
 */
public class UserDaoProxy implements IUserDao{
    //接收保存目标对象
    private IUserDao target;
    public UserDaoProxy(IUserDao target){
        this.target=target;
    }

    public void save() {
        System.out.println("开始事务...");
        target.save();//执行目标对象的方法
        System.out.println("提交事务...");
    }
}

1.4静态代理总结

优点：可以做到在不修改目标对象的功能前提下,对目标功能扩展。
缺点:因为代理对象需要与目标对象实现一样的接口,所以会有很多代理类,类太多；
同时,一旦接口增加方法,目标对象与代理对象都要维护。
静态代理类的生成方式：由程序员创建或由特定工具自动生成源代码，再对其编译。
静态代理类生成时间：在程序运行前，代理类的.class 文件就已经存在了。

2.动态代理第一种方式：使用jdk实现动态代理（利用反射和字节码技术来生成代理的方式）（Proxy InvocationHandler两个对象）

2.1 抽象接口

2.2 目标对象

2.3代理对象

public class ProxyTest{
    public static void main(String[] args) {    
        final Target target = new Target();      
       
        //动态创建代理对象（参数是类加载器，实现了哪些接口，执行哪些方法）  
        TargetInterface proxy = (TargetInterface) Proxy.newProxyInstance(
                target.getClass().getClassLoader(), 
                target.getClass().getInterfaces(), 
                new InvocationHandler() {
                    @Override
                    /*
                    第一步：代理对象proxy想要调用带有args参数的method中的方法
                     * proxy:是代理对象
                     * method:代表的是目标方法的字节码对象
                     * args:代表是调用目标方法时参数
                     */
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        //反射知识点（第二步：调用目标对象的参数为args的方法）
                        Object invoke = method.invoke(target, args);//目标对象的相应方法
                        //第三步：方法执行完毕，返回值给代理对象
                        return invoke;
                    }
                }
            );
        
        proxy.method1();//调用invoke方法 ---Method：目标对象的method1方法  args：null  返回值null
        String method2 = proxy.method2();//调用invoke方法  ---Method:目标对象的method2方法  args:null  返回值method2
        int method3 = proxy.method3(100);调用invoke方法  -----Method:目标对象的method3方法 args:Object[]{100}  返回值是100
        System.out.println(method2);
        System.out.println(method3);
            }    
}

3.动态代理第二种方式：cglib代理（适用目标对象没有实现任何接口的情况，使用继承的方式）

Enhancer：来指定要代理的目标对象，实际处理代理逻辑的对象，最终通过调用create（）方法得到代理对象、对这个对象所有的非final方法的调用都会转发给MethodInterceptor

MethodInterceptor：动态代理对象的方法调用都会转发到intercept方法进行增强

3.1 目标对象

/**
 * 目标对象,没有实现任何接口
 */
public class UserDao {
    public void save() {
        System.out.println("----已经保存数据!----");
    }
}

3.2 生成代理对象

/**
 * Cglib子类代理工厂
 * 对UserDao在内存中动态构建一个子类对象
 */
public class ProxyFactory implements MethodInterceptor{
    //1.维护目标对象
    private Object target;
    public ProxyFactory(Object target) {
        this.target = target;
    }

    //2.给目标对象创建一个代理对象
    public Object getProxyInstance(){
        //1.工具类
        Enhancer en = new Enhancer();
        //2.设置父类（设置目标对象作为父类）
        en.setSuperclass(target.getClass());
        //3.设置回调函数
        en.setCallback(this);
        //4.创建子类(代理对象)
        return en.create();
    }

    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("开始事务...");
        //执行目标对象的方法
        Object returnValue = method.invoke(target, args);
        System.out.println("提交事务...");
        return returnValue;
    }
}

动态代理总结：

1、JDK动态代理只能基于接口进行代理（因为它已经继承了proxy了，java不支持多继承）
2、CGLIB通过继承的方式进行代理、无论目标对象有没实现接口都可以代理，但是无法处理final的情况（final修饰的方法不能被重写）