静态代理、Proxy动态代理

静态代理

静态代理需要弄明白代理类与被代理类含义，比如明星需要开演唱会,那么明星可能需要会说先找我的经纪人。那么这个经纪人就是代理类,明星开演唱会就是被代理类。不知道我举例是否对不对,如果不对还望大佬们指点。

/**
 * 创建一个唱歌的工厂接口
 */
interface SingFactory {
    void concert();
}

/**
 * 被代理类
 * 明星开演唱会
 */
class StartSing implements SingFactory {
    @Override
    public void concert() {
        System.out.println("明星xxx在xxx地点xxx时间开演唱会了");
    }
}

/**
 * 代理类
 * 经纪人谈明星开演唱会之前要干嘛
 * 之后要干嘛
 */
class BrokerNegSing implements SingFactory {

    protected SingFactory singFactory;

    //创建构造方法将明星开演唱会传递
    public BrokerNegSing(SingFactory singFactory) {
        this.singFactory = singFactory;
    }

    @Override
    public void concert() {
        System.out.println("经纪人在明星开演唱会前xxx");
        //需要让明星开演唱会,那么需要调用明星的演唱会方法
        singFactory.concert();
        System.out.println("经纪人在明星开演唱会完成后xxx");
    }
}


/**
 * 静态代理测试
 */
public class StaticProxyTest {
    public static void main(String[] args) {
        //创建被代理类
        SingFactory singFactory = new StartSing();
        //创建代理类调用被代理类和自己的方法
        SingFactory borderFactory = new BrokerNegSing(singFactory);
        borderFactory.concert();
    }
}

Proxy动态代理

静态代理需要知道代理类的情况下进行被代理类的创建和方法的调用,那么动态代理,就是需要动态的创建被代理类并调用代理类的方法。

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

public class ProxyTest {

    public static void main(String[] args) {
        SingFactory singFactory = new StartSing();
        SingFactory singFactory1 = (SingFactory) ProxyFactory.getProxyInstance(singFactory);//返回不能是SingFactory,因为是代理类跟被代理类不一样
        singFactory1.concert();
    }

}

interface SingFactory {
    void concert();
}

class StartSing implements SingFactory {
    @Override
    public void concert() {
        System.out.println("xxx明星xxx在xxx地点xxx时间开演唱会了");
    }
}

/**
 * 根据被代理类创建代理类
 */
class ProxyFactory {
    public static Object getProxyInstance(Object object) {
        MyInvocationHandler invocationHandler = new MyInvocationHandler();
        invocationHandler.setObject(object);
        return Proxy.newProxyInstance(object.getClass().getClassLoader(), object.getClass().getInterfaces(), invocationHandler);
    }
}

/**
 * 需要使用被代理类的对象进行赋值
 */
class MyInvocationHandler implements InvocationHandler {

    private Object object;

    public void setObject(Object object) {
        this.object = object;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        SingUtil singUtil = new SingUtil();
        singUtil.method1();
        Object returnValue = method.invoke(object, args);
        singUtil.method2();
        return returnValue;
    }
}

class SingUtil {
    public void method1() {
        System.out.println("经纪人在明星开演唱会前xxx");
    }

    public void method2() {
        System.out.println("经纪人在明星开演唱会完成后xxx");
    }
}