切面编程（二）

一、动态织入切面代码

　　AOP的核心在于“业务代码”与“切面代码”的分离，这样设计的好处是

　　（1）切面代码写一次即可

　　（2）开发者只需关注业务代码的实现，无需重复编写功能重复的切面代码

　　（3）运行时，执行业务代码时候动态织入切面代码

　　如何实现分离，在本节和下节（切面编程（三））中将详细介绍几种方式

二、代理工厂实现AOP

　　spring+jdk动态代理实现AOP详细样例实现

　　 步骤1.编写切面代码，并将切面加入IOC容器

package com.jyk.spring.aop;

import org.springframework.stereotype.Component;

@Component //加入IOC容器
public class UserAop {
    
    public void begin()
    {
        System.out.println("开启事务");
    }
    
    public void commit()
    {
        System.out.println("结束事务");
    }
}

　　步骤2.编写业务接口和实现类，并将实现类加入IOC容器

package com.jyk.spring.aop;

public interface UserInterface {

    public void add();
    
    public void delete();
}

package com.jyk.spring.aop;

import javax.annotation.Resource;
import org.springframework.stereotype.Component;

@Component
public class UserImpl implements UserInterface{

    @Resource
    private UserAop ua;
    
    @Override
    public void add() {
        System.out.println("核心业务1");
    }

    @Override
    public void delete() {
        System.out.println("核心业务2");
    }
}

　　步骤3.编写代理工厂

package com.jyk.spring.aop;

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

import org.springframework.stereotype.Component;

import com.jyk.spring.proxy.ProxyFactory;

public class UserProxyFactory {

    static Object target;
    static UserAop aop;
    
    //生成代理对象的方法
    public static Object getProxyInstance(Object mTarget,UserAop mUserAop)
    {
        
        target = mTarget;
        aop = mUserAop;
        
        return Proxy.newProxyInstance(
                target.getClass().getClassLoader(), 
                target.getClass().getInterfaces(),
                new InvocationHandler() {
                    
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args)
                            throws Throwable {
                        aop.begin();
                        Object returnObject = method.invoke(target, args);
                        aop.commit();
                        return returnObject;
                    }
                });
    }
}

　　步骤4.在spring配置文件中开启bean扫描，将配置加入IOC的容器的bean加入到容器中管理，同时将代理对象配置成bean。

　　　　　<!-- 开启注解扫描 -->            
        <context:component-scan base-package="com.jyk.spring.aop"></context:component-scan>
                
        <!-- 调用工厂方法，返回UserDao代理后的对象 -->
        <bean id="userImplProxy" class="com.jyk.spring.aop.UserProxyFactory" factory-method="getProxyInstance">
            <constructor-arg index="0" ref="userImpl"></constructor-arg>
            <constructor-arg index="1" ref="userAop"></constructor-arg>
        </bean>

　　步骤5.启动测试，截图可见动态代理方式有效的对业务方法实现了拦截

三、注解实现AOP

　   spring提供了丰富的注解实现aop的功能，通过配置注解，即可实现切面及切入点，一定程度上节省了开发的工作量，提高了效率。

　　步骤1.引入aop相关jar包，核心jar包主要有spring-aop-x.x.x.RELEASE.jar，aopalliance.jar，aspectjweaver.jar和aspectjrt.jar，也可直接引入spring的核心jar包。

　　步骤2.在spring的配置文件中引入aop名称空间，并对业务实现类所在的包开启切面扫描注解。　　　

<?xml version="1.0" encoding="UTF-8"?>
<!-- 名称空间 -->
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd
        ">
                
        <!-- 开启aop注解方式 -->
        <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
        
        <!-- 开启注解扫描 -->            
        <context:component-scan base-package="com.jyk.spring.aop1"></context:component-scan>

</beans>

　　步骤3.相关注解解释及使用

　　@Aspect 指定一个类为切面类
　　@Pointcut("execution(* com.jyk.spring.aop1.*.*(..))") 指定切入点表达式

　　@Before("pointCut_()") 前置通知: 目标方法之前执行
　　@After("pointCut_()") 后置通知：目标方法之后执行（始终执行）
　　@AfterReturning("pointCut_()") 返回后通知： 执行方法结束前执行(异常不执行)
　　@AfterThrowing("pointCut_()") 异常通知: 出现异常时候执行
　　@Around("pointCut_()") 环绕通知： 环绕目标方法执行

　　步骤4.编写切面类并编写切入点　package com.jyk.spring.aop1;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

@Component
@Aspect //指定当前类为切面类
public class UserAop {
    
    //指定切入点表达式，即拦截哪些方法
　　//com.jyk.spring.aop1.*.*(..))即表示拦截该包下所有类的所有方法

    @Pointcut("execution(* com.jyk.spring.aop1.*.*(..))")
    public void testPT()
    {
        
    }
    
    //前置通知，执行目标方法前执行
    @Before("testPT()")
    public void begin()
    {
        System.out.println("开启事务");
    }
    
    //后置通知，执行目标方法后执行
    @After("testPT()")
    public void commit()
    {
        System.out.println("结束事务");
    }
    
    //返回后通知，目标方法调用结束后执行,出现异常不执行
    @AfterReturning("testPT()")
    public void afterRunning()
    {
        System.out.println("目标方法调用结束后执行");
    }
    
    //异常通知，目标方法调用发生异常时执行
    @AfterThrowing("testPT()")
    public void throwException()
    {
        System.out.println("执行目标方法出现了异常");
    }
    
    //环绕通知，环绕目标方法执行
    @Around("testPT()")
    public void arround(ProceedingJoinPoint pj)throws Throwable
    {
        System.out.println("环绕前");
        //执行目标方法
        pj.proceed();
        System.out.println("环绕后");
    }
}

　　步骤5.编写业务接口和具体实现，并将实现类加入到spring的IOC容器

package com.jyk.spring.aop1;

public interface UserInterface {

    public void add();
    
    public void delete();
}

package com.jyk.spring.aop1;

import javax.annotation.Resource;

import org.springframework.stereotype.Component;

@Component
public class UserImpl implements UserInterface{
    
    @Override
    public void add() {
        System.out.println("核心业务1");
    }

    @Override
    public void delete() {
        System.out.println("核心业务2");
    }
}

　　步骤6.验证切入点执行顺序，和执行结果

ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
    
    //目标对象有实现接口,Spring会默认使用JDK代理
    @Test
    public void testJDK()
    {
        UserInterface ui = (UserInterface) ac.getBean("userImpl");
        System.out.println(ui.getClass());
        ui.add();
        ui.delete();
    }

　　由执行结果可知，Around前拦截先于Before前拦截，Around后拦截先于After后拦截，AfterReturning先于Around后拦截，慢于After后拦截。

　　其中，AfterThrowing只有在目标对象的目标方法出现异常时候才执行。

　　注：目标对象有实现接口,Spring会默认使用JDK代理，目标对象没有实现接口，Spring会默认使用cglib代理。