Srping知识点2---AOP（1）

AOP：（面向 切面 编程）
（官方）：通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。是OOP的延续，可以对业务逻辑的各个部分进行隔离，降低耦合度，提高可重用性。
（个人）一种对目标类的功能方法进行增强，但是不用修改原来代码的技术。
AOP动态代理技术：
1、JDK代理：基于接口的动态代理技术

//目标接口
public interface TargetInterface {

    public  void save();
}

//目标接口实现类
public class TargetImpl implements TargetInterface {
    public void save() {
        System.out.println("save running.....");
    }
}

//增强类
public class Advice {
    public  void before(){
        System.out.println("前置增强...");
    }
    public  void afterReturning()
    {
        System.out.println("后置增强....");
    }
}

//测试类
public class ProxyTest {
    public static void main(final String[] args) {

//        创建目标对象
        final TargetImpl target=new TargetImpl();

//        获得增强对象
        Advice advice=new Advice();

//        Proxy的返回值就是动态生成的代理对象
       TargetInterface proxy= ( TargetInterface) Proxy.newProxyInstance(
//                   目标对象类加载器
               target.getClass().getClassLoader(),
//                目标对象相同的接口字节码对象数组
               target.getClass().getInterfaces(),



//                调用代理对象的任何方法，实质执行的都是invoke方法

                  new InvocationHandler() {

//                    proxy 代理对象
//                   method 当前执行的目标方法的
//                    args  传递的参数
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

//                        前置增强
                        advice.before();

//                        执行目标方法
                       //invoke和上面的invoke不一样，此处invoke 为反射的invoke方法。
//                        参数两个：执行目标，实际参数
                        Object invoke = method.invoke(target, args);//invoke和上面的invoke不一样，此处invoke 为反射的invoke方法,参数两个：执行目标
//                        后置增强
                        advice.afterReturning();
                        return invoke;
                    }
                }
        );



//        调用代理对象
        proxy.save();
    }
}

2、cglib代理：基于父类的动态代理技术

//目标接口实现类
public class TargetImpl  {
    public void save() {
        System.out.println("save running.....");
    }
}

//增强类
public class Advice {
    public  void before(){
        System.out.println("前置增强...");
    }
    public  void afterReturning()
    {
        System.out.println("后置增强....");
    }
}

//测试类
public class ProxyTest {
    public static void main(final String[] args) {

//        创建目标对象
        final TargetImpl target=new TargetImpl();

//        获得增强对象
        Advice advice=new Advice();


//        返回值 就是动态生成的代理对象 基于cglib
//        1、创建增强器
        Enhancer enhancer=new Enhancer();

//        2、设置父类（目标）
        enhancer.setSuperclass(TargetImpl.class);

//        3、设置回调
        enhancer.setCallback(new MethodInterceptor() {

//            methodProxy:方法的对象 （不用管）
//                    proxy 代理对象
//                   method 当前执行的目标方法的
//                    args  传递的参数
            @Override
            public Object intercept(Object proxy, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
//                执行前置
                advice.before();
                Object invoke = method.invoke(target, args);//执行目标
//                执行后置
                advice.afterReturning();

                return invoke;
            }
        });

//        4、创建代理对象
        TargetImpl proxy = (TargetImpl) enhancer.create();

        proxy.save();

    }
}

JDK和cglib的区别：接口