腾讯傻白甜？游说集团和旋转门了解一下？

https://www.bilibili.com/video/BV1ui4y137d3

package com.example.proxydemo.dynamicproxy;

import com.example.proxydemo.subject.Subject;
import com.example.proxydemo.subject.SubjectImpl;

import java.lang.reflect.Proxy;

public class DynamicProxyTest {

    public static void main(String[] args) {
        //1.创建目标对象
        SubjectImpl realSubject = new SubjectImpl();

        //2.创建调用处理器对象
        ProxyHandler proxyHandler = new ProxyHandler(realSubject);

        //3.动态生成代理对象
        Subject proxySubject =
                (Subject) Proxy.newProxyInstance(
                SubjectImpl.class.getClassLoader(),
                SubjectImpl.class.getInterfaces(), proxyHandler
        );

        //4.客户端通过代理对象调用方法
        //本次调用将自动被代理处理器的invoke方法接收
        proxySubject.request();

        proxySubject.response();

        System.out.println(proxySubject.getClass().getName());
    }
}

package com.example.proxydemo.dynamicproxy;

import com.example.proxydemo.subject.Subject;

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

/**
 * 代理类的调用处理器
 * @author ukyoZq
 */
public class ProxyHandler implements InvocationHandler {

    private Subject subject;

    public ProxyHandler(Subject subject){
        this.subject = subject;
    }

    /**
     * 此函数在代理对象调用任何一个方法时都会被调用
     * @param proxy
     * @param method
     * @param args
     * @return
     * @throws Throwable
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println(proxy.getClass().getName());
        //定义预处理的工作,当然你也可以根据method的不同进行不同的预处理工作
        System.out.println("====before====");
        Object result = method.invoke(subject, args);
        System.out.println("====after====");
        return result;
    }
}

package com.example.proxydemo.multiple;

public interface Cook {
    void doWork();
}

package com.example.proxydemo.multiple;

public class CookImpl implements Cook{
    @Override
    public void doWork() {
        System.out.println("Cook for myself");
    }
}

package com.example.proxydemo.multiple;

public interface Driver {
    void doWork();
}

package com.example.proxydemo.multiple;

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

/**
 * https://www.icourse163.org/learn/ECNU-1206500807?tid=1206823217
 * @author ukyoZq
 * @date 2020/4/18
 */
public class MultipleInterfacesProxyTest {

    public static void main(String[] args) throws Exception {
        Cook cook = new CookImpl();
        //创建指定类的类加载器
        ClassLoader c1 = MultipleInterfacesProxyTest.class.getClassLoader();
        ProxyHandler handler = new ProxyHandler(cook);

        //生成代理类型 这里的声明顺序是有关系的
        Class<?> proxyClass = Proxy.getProxyClass(c1, new Class<?>[]{Cook.class, Driver.class});

        //生成代理对象
        Object proxy = proxyClass.getConstructor(new Class[]{InvocationHandler.class})
                .newInstance(new Object[]{handler});
        System.out.println(Proxy.isProxyClass(proxyClass));

        Proxy p = (Proxy) proxy;
        System.out.println(Proxy.getInvocationHandler(proxy).getClass().getName());
        System.out.println("proxy类型:"+proxyClass.getName());

        //代理对象都继承于java.lang.reflect.Proxy,但是获取父类确实Object而不是Proxy
        Class father = proxyClass.getSuperclass();
        System.out.println("proxy的父类类型:"+father.getName());

        Class[] cs = proxy.getClass().getInterfaces();

        for(Class c:cs){
            System.out.println("proxy的父接口类型:"+c.getName());
        }
        System.out.println("============================");

        Method[] ms = proxy.getClass().getMethods();
        for (Method m:ms){
            System.out.println("调用方法"+m.getName()+":参数为"+ Arrays.deepToString(m.getParameters()));
        }
        System.out.println("=============================");

        Cook c = (Cook)proxy;
        c.doWork();

        Driver d = (Driver)proxy;
        d.doWork();
    }
}

package com.example.proxydemo.multiple;

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

/**
 * 代理类的调用处理器
 */
public class ProxyHandler implements InvocationHandler {

    private Cook cook;

    public ProxyHandler(Cook cook){
        this.cook = cook;
    }

    //此函数在代理对象调用任何一个方法时都会被调用
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("proxy类型:"+proxy.getClass().getName());
        System.out.println("调用方法:"+method+":参数为:"+Arrays.deepToString(args));
        Object result = method.invoke(cook, args);
        return result;
    }
}

package com.example.proxydemo.staticproxy;

import com.example.proxydemo.subject.Subject;

/**
 * 静态代理对象
 * @author ukyoZq
 */
public class StaticProxy implements Subject {
    //实际目标对象
    private Subject subject;

    public StaticProxy(Subject subject){
        this.subject = subject;
    }

    @Override
    public void request() {
        System.out.println("PreProcess");
        subject.request();
        System.out.println("PostProcess");
    }

    @Override
    public void response() {

    }
}

package com.example.proxydemo.staticproxy;

import com.example.proxydemo.subject.SubjectImpl;

public class StaticProxyTest {

    public static void main(String[] args) {
        //创建实际对象
        SubjectImpl subject = new SubjectImpl();
        //把实际对象封装到代理对象中
        StaticProxy p = new StaticProxy(subject);
        p.request();

    }
}

package com.example.proxydemo.subject;

/**
 * 被代理对象
 * @author ukyoZq
 */
public interface Subject {

    void request();

    void response();

}

package com.example.proxydemo.subject;

public class SubjectImpl implements Subject{
    @Override
    public void request() {
        System.out.println("SubjectImpl request()");
    }

    @Override
    public void response() {
        System.out.println("SubjectImpl response()");
    }
}