代理模式

静态代理

• 接口 person

public interface Person {
    public void study();
    public void keepFit();
}

• 实现类 student 实现person

public class Student implements Person {
    private String name;

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

    @Override
    public void study() {
        System.out.println(name + "最近学习成绩好");
    }

    @Override
    public void keepFit() {
        System.out.println(name + "最近有坚持健身");
    }
}

• 静态代理类 实现person 代理student

public class StaticProxy implements Person {

    Student stu;

    public StaticProxy(Person stu) {
        if (stu.getClass() == Student.class) {
            this.stu = (Student) stu;
        }
    }

	@Override
    public void study() {
        System.out.println("这里可以做点啥.......");
        stu.study();
        System.out.println("这里可以做点啥.......");
    }

    @Override
    public void keepFit() {
        System.out.println("这里可以做点啥.......");
        stu.keepFit();
        System.out.println("这里可以做点啥.......");
    }


    public static void main(String[] args) {

        Person zhangsan = new Student("张三");

        Person stuProxy = new StaticProxy(zhangsan);

        stuProxy.study();

        stuProxy.keepFit();
    }
}

jdk动态代理

public class DynamicProxy {
    public static void main(String[] args) {

        //创建一个实例对象，这个对象是被代理的对象
        Person zhangsan = new Student("张三");

        //创建一个代理对象stuProxy来代理zhangsan，代理对象的每个执行方法都会替换执行Invocation中的invoke方法
        Person stuProxy = (Person) Proxy.newProxyInstance(Person.class.getClassLoader(), new Class<?>[]{Person.class}, new InvocationHandler() {

            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

                System.out.println("这里可以做点啥.......");

                Object result = method.invoke(zhangsan, args);

             // System.out.println(proxy);  将会一直输出  "这里可以做点啥......."

                System.out.println("这里可以做点啥.......");

                return result;
            }
        });

        //代理执行学习方法
        stuProxy.study();
        //再增加执行代理方法只需要在这里调用即可，匿名内部类InvocationHandler不用做修改
        stuProxy.keepFit();
    }
}

//1、相比于静态代理， 动态代理的优势在于可以很方便的对代理类的函数进行统一的处理，而不用修改每个代理类中的方法，即上面的匿名内部类InvocationHandler不用做修改。

//2、invoke方法的第一个参数proxy到底有什么作用？
//如果你的接口中有方法需要返回自身，如果在invoke中没有传入这个参数，将导致实例无法正常返回，
//这时proxy的用途就表现出来了。简单来说，这其实就是链式编程的一种应用实现。

cglib动态代理

/**
 * @Auther: yyn
 * CGLIB创建的动态代理对象比JDK创建的动态代理对象的性能更高，但是CGLIB创建代理对象时所花费的时间却比JDK多得多。
 * 所以对于单例的对象，因为无需频繁创建对象，用CGLIB合适，反之使用JDK方式要更为合适一些。
 * 同时由于CGLib由于是采用动态创建子类的方法，对于final修饰的方法无法进行代理
 *
 */
public class CglibProxy implements MethodInterceptor {

    @Override //继承MethodInterceptor接口重写intercept方法
    public Object intercept(Object object, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        System.out.println("这里可以做点啥......");
        Object result = methodProxy.invokeSuper(object, args);
//        Object result = method.invoke(object, args);  //报错
        System.out.println("这里可以做点啥......");
        return result;
    }

    public Object getInstance(Object target, Class[] args, Object[] argsValue) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(target.getClass());
        enhancer.setCallback(this);
        return enhancer.create(args,argsValue);
    }

    public static void main(String[] args) {
        //创建一个实例对象，这个对象是被代理的对象
        Student zhangsan = new Student("张三");
        CglibProxy cglibProxy = new CglibProxy();
        Student instance = (Student) cglibProxy.getInstance(zhangsan, new Class[]{String.class}, new Object[]{zhangsan.getName()});
        instance.keepFit();
        instance.study();
    }

}

spring aop

springboot整合aop
Spring AOP中使用了两种动态代理：

JDK的动态代理：源码中对应的包装类是JdkDynamicAopProxy，JDK的动态代理必须指定接口，这些接口都是已经被代理对象实现了的；

CGLIB的动态代理：源码中对应的包装类是CglibAopProxy，CGLIB代理不需要指定接口。