从静态代理到SpringAop

静态代理

• 接口 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();
    }
}

动态代理

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的用途就表现出来了。简单来说，这其实就是最近非常火的链式编程的一种应用实现。

spring aop

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

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

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