Java设计模式之代理模式详解

//接口(抽象角色)
public interface Singer{
	// 歌星要会唱歌
	void sing();
}

//具体角色，男歌手
public class MaleSinger implements Singer{
    private String name;
    public MaleSinger(String name) {
        this.name = name;
    }
    @Override
    public void sing() {
        System.out.println(this.name+"男歌手在唱歌");
    }
}

//代理角色
public class Agent implements Singer{
    private MaleSinger singer; //代理角色要有一个被代理角色
    public Agent(MaleSinger singer) {
        this.singer = singer;
    }
    @Override
    public void sing() {
        System.out.println("协商出场费，做会场工作");
        //一定是被代理角色歌手去唱歌
        singer.sing();
        System.out.println("会场收拾，结算费用");
    }
}

//客户
public class Client {
    public static void main(String[] args) {
        MaleSinger singer=new MaleSinger("周杰伦");
        Agent agent=new Agent(singer);
        agent.sing();//通过代理来运行唱歌
    }
}

//歌手接口
public interface Singer2 {
    void sing();
    void dance();
}

//男歌手实现类
public class MaleSinger2 implements Singer2 {
    private String name;

    public MaleSinger2(String name) {
        this.name = name;
    }

    @Override
    public void sing() {
        System.out.println(this.name+"在唱歌");
    }

    @Override
    public void dance() {
        System.out.println(this.name+"在跳舞");
    }
}

import com.hj.Agent2;
import com.hj.MaleSinger2;
import com.hj.Singer2;

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

public class Client2 {
    public static void main(String[] args) {
        System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles","true");//设置用于输出jdk动态代理产生的类
        //简单例子，把所有东西放到一段来解释
        System.out.println("实例1------------------------------------------------");
        MaleSinger2 maleSinger = new MaleSinger2("周杰伦");
        //新建代理实例
        //newProxyInstance(ClassLoader loader, 类加载器，不懂的可以去看https://blog.csdn.net/Doraemon_Nobita/article/details/115702012?spm=1001.2014.3001.5501
        //Class<?>[] interfaces, 实现的接口，注意是个数组
        //InvocationHandler h 处理函数)
        Singer2 agent = (Singer2) Proxy.newProxyInstance(Client2.class.getClassLoader(),
                new Class[]{Singer2.class}, new InvocationHandler() {//匿名内部类的方式实现InvocationHandler接口，对这个看不懂的可以参考https://blog.csdn.net/Doraemon_Nobita/article/details/115506705?spm=1001.2014.3001.5501
                    @Override
                    // 这个invoke就是我们调用agent.sing()后调用的方法
                    // invoke(Object proxy, 代理对象
                    // Method method, method是方法，即我们要调用的方法（是唱歌还是跳舞，在调用的时候会是sing()还是dance()）
                    // Object[] args 参数列表,可能你需要传参)
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        System.out.println("协商出场费，做会场工作");
                        //关于invoke的讲解，详情可以参考：https://blog.csdn.net/Doraemon_Nobita/article/details/115702012?spm=1001.2014.3001.5501 调用指定的方法的那部分。
                        //invoke方法的参数，一个是Object类型，也就是调用该方法的对象，
                        //第二个参数是一个可变参数类型，也就是给这个方法的传参,外层的这个已经给我们封装成args了，直接用就是了
                        Object invoke = method.invoke(maleSinger,args);//通过反射获取到的method名我们再invoke激活一下，传入要调用该方法的对象。这里用maleSinger
                        System.out.println("会场收拾，结算费用");
                        return invoke;
                    }
                });
        agent.sing();//可以调用到maleSinger的sing()
        agent.dance();//调用到maleSinger的dance()
        System.out.println("实例2------------------------------------------------");
        //这个简单例子不行啊，我还每次必须写死这里是maleSinger，以后想换别的还得改这里。动态代理岂是如此不便之物。
        //所以我们直接实现一下InvocationHandler接口，取名为Agent2
        MaleSinger2 JayZ=new MaleSinger2("周杰伦");
        MaleSinger2 JJ =new MaleSinger2("林俊杰");
        Singer2 agentJJ=(Singer2) Proxy.newProxyInstance(Client2.class.getClassLoader(),
                new Class[]{Singer2.class}, new Agent2(JJ));
        Singer2 agentJayZ=(Singer2) Proxy.newProxyInstance(Client2.class.getClassLoader(),
                new Class[]{Singer2.class}, new Agent2(JayZ));
        //可以看到现在代理人创建就十分方便了
        agentJJ.dance();
        agentJJ.sing();
        agentJayZ.sing();
        agentJayZ.dance();
    }
}

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

public class Agent2 implements InvocationHandler {
    private Object object;//想代理谁都可以，随便啊

    public Agent2(Object object) {
        this.object = object;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("协商出场费，做会场工作");
        //一定是歌手去唱歌
        Object invoke = method.invoke(object,args);
        System.out.println("会场收拾，结算费用");
        return invoke;
    }
}

<dependencies>
    <dependency>
        <groupId>cglib</groupId>
        <artifactId>cglib</artifactId>
        <version>3.3.0</version>
    </dependency>
</dependencies>

public class CglibMaleSinger {
    public CglibMaleSinger(String name) {
        this.name = name;
    }

    private String name;

    public CglibMaleSinger() {//注意这里一定要有无参构造器，不然之后会报错Superclass has no null constructors but no arguments were given
    }

    public void sing(){
        System.out.println(this.name+"要去唱歌了");
    }
    public void dance(){
        System.out.println(this.name+"要去跳舞了");
    }
}

import com.hj.CglibMaleSinger;
import net.sf.cglib.core.DebuggingClassWriter;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

public class CglibClient {
    public static void main(String[] args) {
        System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY,"./class");//用于输出生成的代理class文件,"./class"表示存储在class文件夹中
        CglibMaleSinger JayZ=new CglibMaleSinger("周杰伦");
        Enhancer enhancer = new Enhancer();//定义一个增强器enhancer
        enhancer.setSuperclass(CglibMaleSinger.class);//设置其超类，我们要代理哪个类就传哪个类
        //MethodInterceptor是拦截器，就是把我的方法拦截住然后再去增强
        enhancer.setCallback(new MethodInterceptor() {//设置方法拦截器
            // o 是指被增强的对象，指自己
            // method是拦截后的方法，把父类的方法拦截，增强后写在了子类里
            // objs 参数
            // methodProxy 父类的方法（拦截前的方法对象）
            @Override
            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                System.out.println("谈出场费");
                method.invoke(JayZ,objects);
                System.out.println("出场费谈完了");
                return null;
            }
        });
        CglibMaleSinger cglibMaleSinger = (CglibMaleSinger)enhancer.create();
        cglibMaleSinger.sing();
        cglibMaleSinger.dance();
    }
}