Spring之AOP

一，前言

​ 在上一篇博客中总结了关于IOC和DI的知识点，而对于Spring来说还有另一个核心机制就是AOP。

​ AOP:，Aspect-OrientedProgramming，面向切面编程。

​ AOP是一种面向切面的编程思想，那么何为切面。

​ 举例，现在有一张用户表，现要对其中某一个用户进行信息更新。通常的做法是先查询出该用户，然后更新最后再保存到数据库，但这种编程方式并不完善，如果在信息更新之前要添加其他的业务逻辑处理呢。比如日志通知，开启事务等，而AOP便可以很好的处理，在更新用户之前进行日志打印，事务开启。这一点就是切点，而日志和事务相对于该方法来说就是切面，因此切面也可以理解为一个执行过程。

AOP实现者

AspectJ

​ AspectJ是语言级的AOP实现，2001发布，扩展了Java语言，定义了AOP语法，能够在编译期通过提供横切代码的织入，所以它有一个专门的编译器用来生成遵守Java字节码规范的class文件

SpringAOP

​ SpringAOP使用纯Java实现，在运行期通过代理的方式向目标类织入增强代码,目标类.

​ 对于AOP的概念就总结这些，下面说说它的实现原理-动态代理。

• JDK代理
• cglib

二，JDK代理

​ 先来说说JDK代理的实现，该方式是实现InvocationHandler接口重写invoke方法来完成。请看如下代码，定义实现InvocationHandler的实现类。

public class JDKProxy implements InvocationHandler {
    // 目标方法
    private Object target;

    public JDKProxy(Object target){
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("动态代理前。。。");
        System.out.println("method:" + method);
        System.out.println("method名称:" + method.getName());
        // 调用真实的业务主体
        Object invoke = method.invoke(this.target, args);
        System.out.println("动态代理之后。。。");
        return invoke;
    }
}

​ 编写客户端，创建代理类。

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

        IUserService service = new UserServiceImpl();
        // 1，通过类加载器获取目标对象
        ClassLoader classLoader = service.getClass().getClassLoader();
        // 2，目标对象的父类接口
        Class<?>[] interfaces = service.getClass().getInterfaces();
        // 3，创建动态代理类
        JDKProxy handler = new JDKProxy(service);
        IUserService userService =(IUserService) Proxy.newProxyInstance(classLoader, interfaces, handler);
        // 调用方法
        userService.addUser();
    }
}

​ 运行结果为：

分析：

​ 通过代理类去调用方法，明显看出在方法执行前后，都可以进行其他代码的编写。通过这个案例是否可以更贴切的体会到切面的思想，也就是将我们要执行的方法传递给代理类，让代理类去帮我们实现，同时这个代理类再做点“小手脚”。在方法前后添油加醋，来达到更好的效果。

​ 原理分析：

​ 在创建代理类时，调用了newProxyInstance方法，那就先来看看该方法的实现。

 public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)
        throws IllegalArgumentException
    {
    // 判断对象是否为空
        Objects.requireNonNull(h);

        final Class<?>[] intfs = interfaces.clone();
        final SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
        }

        /*
         * 查找或生成指定的代理类
         */
        Class<?> cl = getProxyClass0(loader, intfs);

        /*
         * Invoke its constructor with the designated invocation handler.
         */
        try {
            if (sm != null) {
                checkNewProxyPermission(Reflection.getCallerClass(), cl);
            }
	// 调用构造方法创建代理类
            final Constructor<?> cons = cl.getConstructor(constructorParams);
            final InvocationHandler ih = h;
            if (!Modifier.isPublic(cl.getModifiers())) {
                AccessController.doPrivileged(new PrivilegedAction<Void>() {
                    public Void run() {
                        cons.setAccessible(true);
                        return null;
                    }
                });
            }
            return cons.newInstance(new Object[]{h});
        } catch (IllegalAccessException|InstantiationException e) {
            throw new InternalError(e.toString(), e);
        } catch (InvocationTargetException e) {
            Throwable t = e.getCause();
            if (t instanceof RuntimeException) {
                throw (RuntimeException) t;
            } else {
                throw new InternalError(t.toString(), t);
            }
        } catch (NoSuchMethodException e) {
            throw new InternalError(e.toString(), e);
        }
    }

​ 1，源码很多但是不需要都看，其中有一行代码Class<?> cl = getProxyClass0(loader, intfs);，表示生成二进制字节码，并且在缓存中去获取数据（反射）。

private static Class<?> getProxyClass0(ClassLoader loader,
                                           Class<?>... interfaces) {
        if (interfaces.length > 65535) {
            throw new IllegalArgumentException("interface limit exceeded");
        }

        // If the proxy class defined by the given loader implementing
        // the given interfaces exists, this will simply return the cached copy;
        // otherwise, it will create the proxy class via the ProxyClassFactory
        return proxyClassCache.get(loader, interfaces);
    }

​ 2，在return中又调用了get()，这个方法是在WeakCache缓存中，也就是说在创建代理类时，先从缓存中获取目标对象的属性。

​ 3，再看下一行final Constructor<?> cons = cl.getConstructor(constructorParams);。

private Constructor<T> getConstructor0(Class<?>[] parameterTypes,
                                        int which) throws NoSuchMethodException
    {
        Constructor<T>[] constructors = privateGetDeclaredConstructors((which == Member.PUBLIC));
        for (Constructor<T> constructor : constructors) {
            if (arrayContentsEq(parameterTypes,
                                constructor.getParameterTypes())) {
                return getReflectionFactory().copyConstructor(constructor);
            }
        }
        throw new NoSuchMethodException(getName() + ".<init>" + argumentTypesToString(parameterTypes));
    }

​ 4，调用构造器创出代理对象，通过代理对象执行目标方法。

三，CgLib

​ 1，原理:动态给目标对象创建子类，子类中复写了父类中的方法，在子类的基础之上进行拦截。

​ 2，解决了jdk实现动态代理必须要有接口问题。

​ 3，也是给目对象中的所有方法添加了增强，要通过硬编码的方式解决。

​ 4，目标的不能用final修饰。

public class CglibProxy implements MethodInterceptor {
    /**
     * obj:创建子类的代理对象
     * method:业务逻辑的方法
     * objects:可变参数
     * methodProxy:代理方法
     */
    @Override
    public Object intercept(Object obj, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("方法拦截前。。。");
        Object invokeSuper = methodProxy.invokeSuper(obj, objects);
        System.out.println("方法拦截后。。。");
        return invokeSuper;
    }
}

public class CglibClient {
    public static void main(String[] args) {
        // 1，实例化目标对象
        UserServiceImpl service = new UserServiceImpl();
        // 2，创建目标对象的子类
        Enhancer enhancer = new Enhancer();
        // 3，设置目标对象
        enhancer.setSuperclass(service.getClass());
        // 4，设置Handler
        enhancer.setCallback(new CglibProxy());
        // 5，返回子类对象
        UserServiceImpl user = (UserServiceImpl) enhancer.create();
        user.addUser();
    }
}

​ 关于Cglib的实现这里就不再总结了，但大致思路就是继承父类，然后重写父类方法，在子类的基础上对方法进行拦截。

四，Aspectj

​ 1)注解

​ a)@Asepctj:用该注解修饰的类就代表一个切面

​ b)@Pointcut:表达式

​ execution(public * com.cglib.service.*.*(..))

​ c)@Before:前置通知

​ d)@After:后置通知

​ e)@Around:环绕通知

​ ProceedingJoinPoint

​ f)@AfterThrowing:抛出异常通知

​ g)@AfterReturning:后置通知，但是出现异常不执行

​ 定义一个切面类：

@Aspect    //Aspect修饰的类就代表一个切面
public class AspectJDemo {
	
	@Pointcut(value="execution(* add(..))")
	public void p1() {}
	
	@Pointcut(value="execution(* update(..))")
	public void p2() {}
	
	@Before(value="p1() || p2()")
	public void begin() {
		tr.beign();
	}
	
	@After(value="p1() || p2()")
	public void after() {
		tr.commit();
	}
	
	@Around(value="p1() || p2()")
	public void round(ProceedingJoinPoint point ) {
		System.out.println("开始环绕");
		try {
			//调用目标对象
			Object proceed = point.proceed();
			System.out.println("round:"+proceed);
			
		} catch (Throwable e) {
			e.printStackTrace();
		}  
		System.out.println("结束环绕");
	}
	
	@AfterThrowing(value="p1() || p2()")
	public void afterThrow() {
		System.out.println("出现异常");
	}
	
	@AfterReturning(value="p1() || p2()")
	public void returning() {
		System.out.println("出现异常的时候不执行");
	}
}

public void testAdd() {
		//1,目标对象
		UserServiceImpl serviceImpl = new UserServiceImpl();
		//2,切面
		AspectJDemo aspect = new AspectJDemo(tr);
		//3,创建代理类
		AspectJProxyFactory factory = new AspectJProxyFactory();
		factory.setTarget(serviceImpl);   //设置目标对象
		factory.addAspect(aspect);		  //设置切面
		
		IUserService userService = (IUserService)factory.getProxy();
		//4,调用方法
		userService.add();
}

五，总结

​ 关于Spring两个核心概念IOC和AOP就总结完了，总结的并不深入。而对于Spring的AOP两种实现方式，也要在工作中适当的选择。

​ 以上内容如有不适之处，欢迎留言指正。

感谢阅读！