设计模式之代理模式

静态代理：

/**
 * @author yuyang
 * @DATE 2019/1/7 0007-9:39
 */
public interface ISinger {
    void sing();
}

/**
 * @author yuyang
 * @DATE 2019/1/7 0007-9:39
目标对象实现某一接口
 */
public class Sing implements ISinger {
    @Override
    public void sing() {
        System.out.println("我要唱歌了！！！~~~~");
    }
}

/**
 * @author yuyang
 * @DATE 2019/1/7 0007-9:40
　　静态代理和目标品类实现同一个接口
 */
public class Proxy implements ISinger {
    ISinger iSinger;

    public Proxy(ISinger iSinger) {
        this.iSinger = iSinger;
    }

    @Override
    public void sing() {
        System.out.println("上台————————");
        iSinger.sing();
        System.out.println("谢幕—————————");
    }
}

/**
 * @author yuyang
 * @DATE 2019/1/7 0007-9:41
 */
public class Test {
    public static void main(String[] args) {
        ISinger iSinger=new Sing();
        Proxy proxy=new Proxy(iSinger);
        proxy.sing();
    }
}

动态代理：

 跟静态代理的前提一样，依然是对Singer对象进行扩展

1 public interface ISinger {
2 void sing();
3 }
4
5 /**
6 * 目标对象实现了某一接口
7 */
8 public class Singer implements ISinger{
9 public void sing(){
10 System.out.println("唱一首歌");
11 }
12 }

这回直接上测试，由于java底层封装了实现细节（之后会详细讲），所以代码非常简单，格式也基本上固定。

调用Proxy类的静态方法newProxyInstance即可，该方法会返回代理类对象

static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces,InvocationHandler h )

接收的三个参数依次为:

• ClassLoader loader：指定当前目标对象使用类加载器，写法固定
• Class<?>[] interfaces：目标对象实现的接口的类型，写法固定
• InvocationHandler h：事件处理接口，需传入一个实现类，一般直接使用匿名内部类

测试代码

1 public class Test{
2 public static void main(String[] args) {
3        Singer target = new Singer();
4 ISinger proxy = (ISinger) Proxy.newProxyInstance(
5 target.getClass().getClassLoader(),
6 target.getClass().getInterfaces(),
7 new InvocationHandler() {
8 @Override
9 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
10 System.out.println("向观众问好");
11 //执行目标对象方法
12 Object returnValue = method.invoke(target, args);
13 System.out.println("谢谢大家");
14 return returnValue;
15 }
16 });
17             proxy.sing();
18 }
19 }

总结：以上代码只有标黄的部分是需要自己写出，其余部分全都是固定代码。由于java封装了newProxyInstance这个方法的实现细节，所以使用起来才能这么方便，具体的底层原理将会在下一小节说明。

缺点：可以看出静态代理和JDK代理有一个共同的缺点，就是目标对象必须实现一个或多个接口，加入没有，则可以使用Cglib代理。