AOP面向切面编程，JDK的动态代理方式

1. AOP概念

1.1 什么是AOP

• 在软件行业中，AOP可以理解为面向切面编程，它是一种通过预编译和运行期动态代理实现程序功能的统一的一种技术。AOP，其实是OOP的延续。利用AOP可以使得业务逻辑代码各部分之间的耦合度降低，提高程序的可重用性，同时，提高效率。
• AOP使用纯Java实现，不需要专门的编译过程和类加载器，在运行期通过代理方式向目标类织入增强代码。
• AspectJ是一个基于Java语言的AOP框架，Spring2.0开始，Spring AOP引入对Aspect的支持，AspectJ扩展了Java语言，提供了一个专门的编译器，在编译时提供横向代码的织入。

1.2 AOP 实现原理

• aop底层将采用代理机制进行实现
• 接口+实现类：spring采用jdk的动态代理Proxy。
• 实现类：spring 采用clib字节码增强的代理方式。

1.3 AOP术语

• target：目标类，需要被代理的类。例如：UserService
• Joinpoint(连接点):所谓连接点是指那些可能被拦截到的方法。例如：所有的方法
• PointCut 切入点：已经被增强的连接点。例如：addUser()
• advice 通知/增强，增强代码。例如：after、before
• Weaving(织入):是指把增强advice应用到目标对象target来创建新的代理对象proxy的过程.
• proxy 代理类
• Aspect(切面): 是切入点pointcut和通知advice的结合 一个线是一个特殊的面。 一个切入点和一个通知，组成成一个特殊的面。

2. 手工方式实现

2.1 JDK动态代理

• JDK动态代理 对“装饰者”设计模式 简化。使用前提：必须有接口
  
  • 目标类：接口 + 实现类
  • 切面类：用于存通知 MyAspect
  • 工厂类：编写工厂生成代理
  • 测试

---

需求：需要在一个方法前执行一段代码，方法后执行一段代码。

编写接口UserService

public interface UserService {
    public int addUser();
    public void updateUser();
    public void deleteUser();
}

编写接口实现类UserServiceImpl

package com.friendcom.aop.jdk.self;

public class UserServiceImpl implements UserService{

    public int addUser() {
        // TODO Auto-generated method stub
        System.out.println("add user");
        return 120;
    }

    public void updateUser() {
        // TODO Auto-generated method stub
        System.out.println("update user");

    }

    public void deleteUser() {
        // TODO Auto-generated method stub
        System.out.println("delete user");

    }

}

编写通知类（所谓的切面类）

package com.friendcom.aop.jdk.self;
/**
 * 切面类
 * @author LiWeiKang
 *
 */
public class MyAspect {
    public void before(){
        System.out.println("before");
    }
    public void after(){
        System.out.println("after");
    }
}

编写创建代理类的工厂

package com.friendcom.aop.jdk.self;

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

/**
 * sping工厂的作用就是把目标类和切面类整合起来！
 * 因此 要有目标类和切面类的引用
 * @author LiWeiKang
 *
 *
 * 3 代理类：将目标类（切入点）和 切面类（通知） 结合 --> 切面
 *  Proxy.newProxyInstance
 *      参数1：loader ，类加载器，动态代理类 运行时创建，任何类都需要类加载器将其加载到内存。
 *          一般情况：当前类.class.getClassLoader();
 *                  目标类实例.getClass().get...
 *      参数2：Class[] interfaces 代理类需要实现的所有接口
 *          方式1：目标类实例.getClass().getInterfaces()  ;注意：只能获得自己接口，不能获得父元素接口
 *          方式2：new Class[]{UserService.class}   
 *          例如：jdbc 驱动  --> DriverManager  获得接口 Connection
 *      参数3：InvocationHandler  处理类，接口，必须进行实现类，一般采用匿名内部
 *          提供 invoke 方法，代理类的每一个方法执行时，都将调用一次invoke
 *              参数31：Object proxy ：代理对象
 *              参数32：Method method : 代理对象当前执行的方法的描述对象（反射）
 *                  执行方法名：method.getName()
 *                  执行方法：method.invoke(对象，实际参数)
 *              参数33：Object[] args :方法实际参数
 * 
 */

public class SpringFactory {
    public static UserService getProxy(){//jdk的动态代理
         final UserService service=new UserServiceImpl();//目标类
         final MyAspect aspect=new MyAspect();//切面类
         UserService proxService =(UserService)Proxy.newProxyInstance(SpringFactory.class.getClassLoader(), service.getClass().getInterfaces(), new InvocationHandler() {

            public Object invoke(Object proxy, Method method, Object[] args)
                    throws Throwable {
                // TODO Auto-generated method stub

                System.out.println("1:"+method.getName());
                aspect.before();
                int obj = (Integer)method.invoke(service, args);
                System.out.println(obj);
                aspect.after();
                return obj;
            }
        });
         return proxService;
    }
}

编写测试类

package com.friendcom.aop.jdk.self;

public class Test {
    public static void main(String[] args) {
        UserService service = SpringFactory.getProxy();
        service.addUser();
    }
}

运行代码结果

1:addUser
before
add user
120
after