Spring入门学习（三）AOP

一、Spring AOP简介

AOP是面向切面编程，一种比较成熟的编程方式。是（面向对象编程）OOP的一种补充。

    由于在传统中，通常会进行事务处理、日志记录等操作。虽然使用OOP可以通过组合或者继承的方式来达到代码的重用，但是如果要实现某个功能，同样的代码仍然会分散到各个方法中。这样，如果想要关闭某个功能或者对其进行修改，就必须要修改所有相关方法，这样不但增加了开发人员的工作量，而且提高了代码的出错率。

    为了解决这一问题，AOP思想随之产生.AOP采用横向抽取机制，将分散在各个方法中的重复代码提取出来，然后再程序编译或者运行时，再将这些提取出来的代码应用到需要执行的地方。

目前最流行的AOP框架有两个，分别Apring AOP和AspectJ。

AOP使用纯Java代码实现，不需要专门的编译过程和类加载器，在运行期间通过代理方式向目标类织入增强的代码。

AspectJ是一个基于Java语言的AOP框架，它扩展了JAVA语言，提供了一个专门的编译器，在编译时提供横向代码的织入。

二、AOP专业术语（主要包括Aspect、Joinpoint、Pointcut、Advice、Target Object、Proxy和Weaving）

AOP术语

Aspect（切面）	切面通常是指封装的用于横向插入系统功能的类。 该类要被Spring容器识别为切面，需要在配置文件中通过<bean>元素指定
Joinpoint（连接点）	在程序执行过程中的某个阶段点，它实际上是对象的一个操作，例如方法的调用和异常的抛出。
Pointcut（切入点）	指切面与程序流程的交叉点，即那些要处理的连接点。 通常在程序中，切入点指的是类或者方法名，如某个通知要应用到所有以add开头的方法中，那么所有满足这一规则的方法都是切面。
Advice（通知/增强处理）	AOP框架在特定的切入点执行的增强处理，即在定义好的切入点处所要执行的程序代码。它是切面的具体实现。
Target Object（目标对象）	是指所有被通知的对象，也被称为增强对象。 如果AOP框架采用的是动态的AOP实现，那么该对象就是一个被代理对象。
Proxy（代理）	将通知应用到目标对象之后，被动态创建的对象。
Weaving（织入）	将切面代码插入到目标对象上，从而生成代理对象的过程。

三、动态代理

• JDK动态代理

    JDK动态代理通过java.lang.reflect.Proxy类来实现的，可以调用Proxy类的newProxyInstance()方法来创建代理对象。

     对于使用业务接口的类，Spring默认会使用JDK动态代理来实现AOP。

     具体步骤如下：

         1.创建一个web项目，在lib下导入Spring框架所需的JAR包，并发布到路径下。

         2.在src目录下，创建一个com.example.jdk包，在该包下创建接口类UserDao，并在该接口中编写添加和删除方法。

package com.example.jdk;

public interface UserDao {
	public void addUser();
	public void deleteUser();
}

         3.在com.example.jdk包中，创建UserDao接口实现类UserImplement，分别实现接口中的方法，并在每个方法中添加一条输出语句。

package com.example.jdk;

//目标类
public class UserDaoImplement implements UserDao{
	public void addUser() {
		System.out.println("add a user");
	}


	public void deleteUser() {
		System.out.println("delete a user");
	}
}

         4.在src目录下创建一个com.example.aspect包，并在它的下面创建切面类MyAspect，在该类中定义一个模拟权限检查的方法和一个模拟记录日志的方法，这两个方法就表示切面中的通知。

package com.example.aspect;

//切面类：可以存在多个通知Advice(即增强的方法)
public class MyAspect {
	public void check_Permissions() {
		System.out.println("模拟检查权限...");
	}
	
	public void log() {
		System.out.println("模拟记录日志...");
	}
}

          5.在com.example.jdk包下，创建代理类JdkProxy，该类需要实现InvocationHandler接口，并编写代理方法。

在代理方法中，需要通过Proxy类实现动态代理。

           JdkProxy类实现了InvocationHandler接口，并实现了接口中的invoke()方法，所有动态代理类所调用的方法都会交给该方法处理。

在创建的代理方法createProxy()中，使用了Proxy类的NewProxyInstance()方法来创建代理对象。

NewProxyInstance()方法：第一个参数是当前类的加载器

                                           第二个参数是被代理对象实现的所有接口

                                           第三个参数是代理类JdkProxy本身

incoke()方法：目标类方法执行的前后会分别执行切面类中的check_permissions()方法和log()方法。

package com.example.jdk;

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

import com.example.aspect.MyAspect;

public class JdkProxy implements InvocationHandler{

	//创建目标类接口
	private UserDao userDao;
	//创建代理方法
	public Object createProxy(UserDao userDao) {
		this.userDao=userDao;
		//类加载器
		ClassLoader classLoader=JdkProxy.class.getClassLoader();
		//被代理对象实现的所有接口
		Class[] classes=userDao.getClass().getInterfaces();
		//使用代理类，进行增强，返回的是代理后的对象
		return Proxy.newProxyInstance(classLoader, classes, this);
	}
	
	/**
	 * 所有动态代理类的方法进行调用，都会交出invole()方法去处理
	 * proxy被代理的对象
	 * method将要被执行的方法信息（反射）
	 * args执行方法时需要的参数
	 */
	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		//声明切面
		MyAspect myAspect=new MyAspect();
		//前增强
		myAspect.check_Permissions();
		//在目标类上调用方法，并传入参数
		Object object=method.invoke(userDao, args);
		//后增强
		myAspect.log();
		return object;
	}
	
}

          6.在com.example.jdk中，创建测试类JdkText。在该类的main()方法在创建代理对象和目标对象，然后从代理对象中获得对目标对象userDao增强后的对象，最后调用该对象中的添加和删除方法。

package com.example.jdk;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class JdkTest {

	public static void main(String[] args) {
		//创建代理对象
		JdkProxy jdkProxy=new JdkProxy();
		//创建目标对象
		UserDao userDao=new UserDaoImplement();
		//从代理对象中获取增强后的目标对象
		UserDao userDao1=(UserDao)jdkProxy.createProxy(userDao);
		//执行方法
		userDao1.addUser();
		userDao1.deleteUser();
	}

}

     7.测试结果

• CGLIB代理

    JDK动态代理的使用非常简单，但是存在一定的局限性(使用动态代理的对象必须实现一个或者多个接口)。

     如果要对没有实现接口的类进行代理，就可以使用CGLIB代理：一个高性能开源的代码生成包，它采用非常底层的字节码技术，对指定的目标类生成一个子类，并对子类进行增强。

     具体步骤如下：

         1.在src下，创建一个com.example.cglib包，在包中创建一个目标类UserDao，UserDao不需要实现任何接口，只需要定义一个添加和删除用户的方法。

package com.example.cglib;

public class UserDao {
	public void addUser() {
		System.out.println("add a user");
	}

	public void deleteUser() {
		System.out.println("delete a user");
	}
}

        2.在com.example.cglib包中，创建代理类CglibProxy，该代理类需要实现MethodInterceptor接口，并实现接口中的intercept()方法。

intercept()方法会在程序执行目标方法时被调用，方法运行时将会执行切面类中的增强方法。

package com.example.cglib;

import java.lang.reflect.Method;

import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

import com.example.aspect.MyAspect;

//代理类
public class CglibProxy implements MethodInterceptor{
	
	//代理方法
	public Object createProxy(Object target) {
		//创建一个动态类对象
		Enhancer enhancer=new Enhancer();
		//确定需要增强的类，设置其父类
		enhancer.setSuperclass(target.getClass());
		//添加回调函数
		enhancer.setCallback(this);
		//返回创建的代理类
		return enhancer.create();
	}
	
	/**
	 * proxy CGLIB根据指定父类生成的代理对象
	 * method 拦截方法
	 * args 拦截方法参数数组
	 * methodProxy 方法的代理对象，用于执行父类的方法
	 */
	@Override
	public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
		//创建切面类对象
		MyAspect myAspect = new MyAspect();
		//前增强
		myAspect.check_Permissions();
		//目标方法执行
		Object object=methodProxy.invokeSuper(proxy, args);
		//后增强
		myAspect.log();
		return object;
	}
	
}

       3.在com.example.cglib包中，创建测试类CglibTest。

package com.example.cglib;


public class CglibTest {

	public static void main(String[] args) {
		//创建代理对象
	    CglibProxy cglibProxy=new CglibProxy();
		//创建目标对象
		UserDao userDao=new UserDao();
		UserDao userDao1=(UserDao)cglibProxy.createProxy(userDao);
		//执行方法
		userDao1.addUser();
		userDao1.deleteUser();
	}

}
 

      4.测试结果