静态代理与动态代理

概念：

代理模式--是一种设计模式，分为静态代理和动态代理
类似于装饰模式，都是在不改变原来类增强原来类的功能
静态代理：继承父类，重写父类方法，在父类方法前后做操作
静态代理的缺点：对于类过多的情况下，会生成过多的代理

静态代理测试：

package staticproxy;

public class Bird {
    public void fly(){
        System.out.println("i am fly");
    }
}

package staticproxy;
//代理模式--是一种设计模式，分为静态代理和动态代理
//类似于装饰模式，都是在不改变原来类增强原来类的功能
//静态代理：继承父类，重写父类方法，在父类方法前后做操作
//静态代理的缺点：对于类过多的情况下，会生成过多的代理
public class BirdProxy extends Bird {
    @Override
    public void fly() {
        System.out.println("i am sing");
        super.fly();
        System.out.println("i am dance");
    }
}

动态代理测试：

package dynamicProxy;

public interface Fly {
    void fly();
    void eat();
}

package dynamicProxy;

public class Bird implements Fly {
    public void fly() {
        System.out.println("bird can fly");
    }

    public void eat() {
        System.out.println("bird can eat");
    }
}

package dynamicProxy;

public class Pig implements Fly {
    public void fly() {
        System.out.println("pig can fly");
    }
    public void eat() {
        System.out.println("bird can eat");
    }
}

package dynamicProxy;

import java.lang.reflect.Proxy;

//动态代理：动态生成代理类
public class DynamicProxyDemo {
    public static void main(String[] args) {
        //生成代理实例
        //获取类加载器
        ClassLoader classLoader = Fly.class.getClassLoader();
        //被代理类的接口
        Class[] interfaces = {Fly.class};
        //代理处理类
        ProxyHandler proxyHandler = new ProxyHandler(new Pig());
        //生成真正的代理类
        Fly pigProxy = (Fly) Proxy.newProxyInstance(classLoader, interfaces, proxyHandler);
        //当调用被代理类的方法时，会自动进入invoke方法
        pigProxy.fly();
        pigProxy.eat();
        /*ProxyHandler proxyHandler2 = new ProxyHandler(new Bird());
        //生成真正的代理类
        Fly birdProxy = (Fly) Proxy.newProxyInstance(classLoader, interfaces, proxyHandler2);
        //当调用被代理类的方法时，会自动进入invoke方法
        birdProxy.fly();*/

    }
}

package dynamicProxy;

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

/**
 * InvocationHandler:调用处理器
 * 在其中实现代理逻辑
 */
public class ProxyHandler implements InvocationHandler {
    //运用构造方法传参
    //private Object proxy;
    //被代理类(接口)
    private Fly proxied;

    public ProxyHandler(Fly proxied) {
        this.proxied = proxied;
    }

    //当调用被代理类的方法时，会自动进入invoke方法
    //如：被代理类是Bird，方法时fly
    //proxy:表示代理类--pig
    //Method：被调用的方法--fly
    //args：表示方法参数---空
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("i can sing");
        //反射--传值
        method.invoke(this.proxied,args);
        System.out.println("i can dance");
        return null;
    }
}