长达100分钟的阿里二三面，惊险刺激！乔戈里又和学弟要来了面经！

// 动态代理，总共有四个类

// 1. 接口
package AOP.Proxy;

public interface Person {
    void play();
    void dance();

}

// 2. 实现类，也就是要被代理的类
package AOP.Proxy;

public class Universities implements  Person {
    @Override
    public void play() {
        System.out.println("I like play computer");

    }

    @Override
    public void dance() {
        System.out.println("I like dance");
    }
}




// 3. 实现 InnocationHandler 接口，完成代理的任务
package AOP.Proxy;

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

public class Dynamic implements InvocationHandler {
    // 整容的人是谁，我得知道
    private Object obj;
    public Dynamic(Object obj){
        this.obj = obj;
    }
  // 整容的过程
    public Object myDynamic(){
        return Proxy.newProxyInstance(this.obj.getClass().getClassLoader(),this.obj.getClass().getInterfaces(),this);
    }
    // 整容的地方交代清楚
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("开始为" + method.getName() + "方法进行代理");
        Object result = method.invoke(obj,args);
        System.out.println("结束" + method.getName() + "方法的代理");
        return result;
    }
}


// 4. 测试类
// 这里我采用了两种方法测试，一种是直接在 test 类中写出整容的过程
// 另外一种是直接调用我在 Dynamic 已经包装好整容过程的方法，建议使用这种
// 因为这样代码就少了，下面 cglib 就是采用方法二哈
package AOP.Proxy;

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

public class test {
    public static void main(String[] args) {
        // 相当于做生意的过程，比如我去医院整容，首先我要确保我有钱(也就是有接口)
        Universities person = new Universities();
        // 其次，我得去医院找到相应的医生，也就是把我想代理的对象，即我本人，告知给医生
        // 医生肯定得有能整容的技术，那就是得继承 InvocationHandler
        InvocationHandler dynamic_person = new Dynamic(person);
        // 进行交易的过程，一手交钱一手交换，医生拿到钱，会返回一个有钱的处理好的美女，也就是代理完成了
        // 这里必须强调代理返回的是 接口对象，也就是医生只会对有钱人进行代理，没钱的代理就失败了
        // 如果最开始我没钱，我就去找医生了，那在这一步交易的过程就会出错，因为医生只会处理有钱人，并且返回有钱人的代理好的对象
        // 有钱人得到代理后的对象，就可以为所欲为了
        Person pp = (Person) Proxy.newProxyInstance(person.getClass().getClassLoader(),person.getClass().getInterfaces(),dynamic_person);
        
        pp.dance();
        System.out.println("-----------");
        
        
        Person pp2 = (Person) new Dynamic(person).myDynamic();
        pp2.dance();



    }
}

// cglib 实现
//1. 导包，在pom.xml 导包
    <dependency>
            <groupId>cglib</groupId>
            <artifactId>cglib-nodep</artifactId>
            <version>3.2.0</version>
        </dependency>

        <dependency>
            <groupId>cglib</groupId>
            <artifactId>cglib</artifactId>
            <version>3.2.0</version>
        </dependency>
        
// 2. 需要被代理的类
package AOP.Cglib;

public class SomeService {
    public String doFirst() {
        System.out.println("执行doFirst()方法");
        return "abc";
    }

    public void doSecond() {
        System.out.println("doSecond()方法");
    }
}

// 3. 进行代理过程
package AOP.Cglib;

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 CglibFactory implements MethodInterceptor {

    private Object object;

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

    public Object myCglibCreator() {
        Enhancer enhancer = new Enhancer();
        //将目标类设置为父类，cglib动态代理增强的原理就是子类增强父类,cglib不能增强目标类为final的类
        //因为final类不能有子类
        enhancer.setSuperclass(this.object.getClass());
        //设置回调接口,这里的MethodInterceptor实现类回调接口，而我们又实现了MethodInterceptor,其实
        //这里的回调接口就是本类对象,调用的方法其实就是intercept()方法
        enhancer.setCallback(this);
        //create()方法用于创建cglib动态代理对象
        return enhancer.create();
    }

    //回调接口的方法
    //回调接口的方法执行的条件是：代理对象执行目标方法时会调用回调接口的方法
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {

        Object result = methodProxy.invokeSuper(o, objects);

        //这里实现将返回值字符串变为大写的逻辑
        if(result != null) {
            result = ((String) result).toUpperCase();
        }
        return result;
    }
}

// 4. 测试
package AOP.Cglib;

public class Test {
    public static void main(String[] args) {
        SomeService target = new SomeService();

        SomeService proxy = (SomeService) new CglibFactory(target).myCglibCreator();

        String result = proxy.doFirst();
        System.out.println(result);
        proxy.doSecond();
    }
}