02_代理模式

静态代理

一、代理类

package com.study.proxy

/**
 * 代理类
 */
interface StarCompany {
    /**
     * 唱歌
     */
    fun singingMusic(str: String)
}

package com.study.proxy

/**
 * 代理类
 */
class StarCompanyProxy(private val starCompany: StarCompany = LiuDeHua()) : StarCompany {


    override fun singingMusic(str: String) {
        starCompany.singingMusic(str)
    }

}

二、被代理类

package com.study.proxy

/**
 * 被代理类
 */
class LiuDeHua : StarCompany {

    override fun singingMusic(str: String) {
        println("我是刘德华")
        println("刘德华唱::$str")
    }

}

package com.study.proxy
/**
 * 被代理类
 */
class ZhangXueYou : StarCompany {
    override fun singingMusic(str: String) {
        println("我是张学友")
        println("张学友唱::$str")
    }

}

三、主程序调用

package com.study.proxy

/**
 * 代理模式(静态代理)：
 * 代理类与被代理类实现统一接口或抽象类
 * 为什么要实现同一接口呢？
 * 因为代理类需要知道被代理类能干啥以及不能干啥，否则代理要是代理了被代理类不能处理的事务怎么办。
 *
 * 代理类可以代理某一类事务或行为，被代理类是针对某一类事务或行为具体实现
 *
 * 优点：代理类可以帮被代理类优化一些数据之后，再将优化后的数据交给被代理类处理。
 * 可以达到一些AOP的效果,例如想统计下每个被代理对象处理某个事务所需时间之类的事情，
 * 可以直接在代理类中处理
 * 缺点：待归集
 */
fun main(args: Array<String>) {
    var starCompanyProxy1 = StarCompanyProxy()
    starCompanyProxy1.singingMusic("中国话")

    var startCompanyProxy2 = StarCompanyProxy(ZhangXueYou())
    startCompanyProxy2.singingMusic("东方红")
}

四、运行结果

动态代理

一、InvocationHandler的实现类

package com.study.proxy.dynamic;

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

/**
 * 动态代理的核心类
 */
public class DefineInvocationHandler implements InvocationHandler {

    private StarCompany starCompany;

    public DefineInvocationHandler(StarCompany starCompany) {
        this.starCompany = starCompany;
    }

    public void before() {
        System.out.println("方法执行前...");
    }

    public void after() {
        System.out.println("方法执行后...");
    }

    /**
     * 只有当前代理类执行相应方法时，这个invoke方法才会被调用
     *
     * @param proxy  当前代理类对象
     * @param method 要执行的方法
     * @param args   要执行方法的参数
     * @return 方法返回值，没有返回值时返回null
     * @throws Throwable
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        before();
        Object returnObj = method.invoke(starCompany, args);
        after();
        return returnObj;
    }
}

二、主程序调用

package com.study.proxy.dynamic;

import java.lang.reflect.Proxy;

/**
 * 利用Proxy类来实现动态代理
 */
public class MainClient {
    public static void main(String[] args) {
        //被代理类
        LiuDeHua liuDeHua = new LiuDeHua();
        //将生成在内存中的动态代理类写入到磁盘中，
//        System.getProperties().put("jdk.proxy.ProxyGenerator.saveGeneratedFiles", "true"); //jdk11 新版本jdk使用这个
        //jdk8 老版本使用这个，无法确定是就搜索文件ProxyGenerator看看其在哪个包下面来确定
        System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
        StarCompany proxyInstance = (StarCompany) Proxy.newProxyInstance(liuDeHua.getClass().getClassLoader(),
                liuDeHua.getClass().getInterfaces(), new DefineInvocationHandler(liuDeHua));

        proxyInstance.singingMusic("东方红");
    }
}

三、生成在内存中的代理类

// 是通过编译器生成的
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package com.sun.proxy;

import com.study.proxy.dynamic.StarCompany;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;

public final class $Proxy0 extends Proxy implements StarCompany {
    private static Method m1;
    private static Method m2;
    private static Method m3;
    private static Method m0;

    public $Proxy0(InvocationHandler var1) throws  {
        super(var1);
    }

    public final boolean equals(Object var1) throws  {
        try {
            return (Boolean)super.h.invoke(this, m1, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final String toString() throws  {
        try {
            return (String)super.h.invoke(this, m2, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final void singingMusic(String var1) throws  {
        try {
        	//将当前代理对象传递给invoke方法，h就是用户创建的InvocationHandler实现类的对象
            super.h.invoke(this, m3, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final int hashCode() throws  {
        try {
            return (Integer)super.h.invoke(this, m0, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            //用户要执行的方法
            m3 = Class.forName("com.study.proxy.dynamic.StarCompany").getMethod("singingMusic", Class.forName("java.lang.String"));
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}