Spring 动态代理分析&AOP的XML的方式&注解方式

Spring的AOP开发

AOP：面向切面编程。AOP出现是OOP（面向对象）的延伸，是OOP的扩展。解决OOP中的一些问题。
AOP取代传统的纵向继承体系，采用横向抽取机制。（解耦）

AOP底层实现原理：
aop底层实现就是利用了动态代理。
利用了动态代理的两种机制：JDK动态代理、CGlib动态代理。
两种代理区别：JDK动态代理，基于接口实现，代理目标必须实现至少一个接口。
代码示例：

public static Object getProxy(final Class clazz){
        Object o = Proxy.newProxyInstance(clazz.getClassLoader(), clazz.getInterfaces(), new InvocationHandler() {      
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {         
                Object o = null;
                try {
                    System.out.println("开启事务");

                    o = method.invoke(clazz.newInstance(), args);

                    System.out.println("提交事务");
                } catch (Exception e) {
                    System.out.println("回滚事务");
                }
                return o;
            }
        }); 

CGlib动态代理，基于子类实现 ，类不能是final类。
代码示例：

public static Object createProxy(final Class clazz) {

                //1、创建一个工具类
                Enhancer enhancer = new Enhancer();
                //2、设置父类
                enhancer.setSuperclass(clazz);
                //3、设置回调函数（方法增强）
                enhancer.setCallback(new MethodInterceptor() {

                    @Override
                    //参数1：代理对象本身的引用
                    //参数2：父类中的方法
                    //参数3：方法中的参数
                    //参数4：子类中的方法
                    public Object intercept(Object arg0, Method m, Object[] arg2, MethodProxy mp) throws Throwable {
                        try {
                            System.out.println("开启事务");
                            m.invoke(clazz.newInstance(), arg2);//调用真实对象中的方法
                            System.out.println("提交事务");
                        } catch (Exception e) {
                            e.printStackTrace();
                            System.out.println("回滚事务");
                        }

                        return null;
                    }
                });
                //4、创建代理对象
                Object proxy = enhancer.create();
                return proxy;
    }

两种代理采用第三方的代理机制，对没有实现接口的类产生代理，使用的是字节码的增强技术，其实就是产生这个类的子类。（生成的代理类地址为null，可用debug查看）

---

AOP开发中的术语：

切入点表达式的语法规则：

AspectJ中提供了切入点的表达式，用来指定哪些包下的哪些类需要被增强。
表达式基于execution函数完成的，execution(“切入点表达式”)。
表达式语法:
[方法的访问修饰符] 方法的返回值 包名.类名.方法名(参数)
1 public void com.itheima.spring.service.CustomerService.save(..)
2 * com.itheima.spring.service.*Service.save(..)
3 * com.itheima.spring.service..(..)
4 * com.itheima.spring.service.CustomerService+.*(..)
5 * com...(..)
6 * ...*(..)

AspectJ中的通知类型：

前置通知 ：在目标方法执行之前执行。

<aop:before>

后置通知 ：在目标方法执行之后执行。

 <aop:after-returning>

环绕通知 ：在目标方法执行之前和之后执行。阻止目标方法的执行。

<aop:around>

异常抛出通知 ：在目标方法执行出现异常的时候执行。

 <aop:after-throwing>

最终通知 ：无论目标方法是否出现异常，最终通知总是会被执行。

 <aop:after>

常用标签：

<aop:config>
作用：
用于声明开始aop的配置

<aop:aspect>
作用：
用于配置切面。
属性：
id：给切面提供一个唯一标识。
ref：引用配置好的通知类bean的id。

<aop:pointcut>
作用：
用于配置切入点表达式
属性：
expression：用于定义切入点表达式。
id：用于给切入点表达式提供一个唯一标识。

**AOP注解和XML配置使用方式：

配置xml开启扫描：

<!-- 开启包扫描 -->
    <context:component-scan base-package="指定要扫描的包的范围"/>
    <!-- 开户aop注解 -->
    <aop:aspectj-autoproxy/>

AOP常用注解：

@Aspect ：定义切面类
@Before :前置通知
@AfterReturning:后置通知
@Around :环绕通知
@AfterThrowing:异常抛出通知
@After :最终通知
@Pointcut :定义切入点

使用方法：

@Component("myAspect")
@Aspect
public class MyAspect {
    @Before("execution(* * com..service.*.*(..))")
    public void before(){
        System.out.println("前置增强执行了。。。");
    }
}

切入点的使用：

@Pointcut("execution(* com..service.*.*(..))")
    public void pointcut1() {
    }

    // 前置增强
    @Before("pointcut1()")
    public void mybefore() {
        System.out.println("前置方法");
    }
    // 后置增强
    @AfterReturning("pointcut1()")
    public void myreturning() {
        System.out.println("后置方法");
    }

AOP纯注解配置方式：
编写一个配置类来取代XML文件：

@Configuration //表示当前类是配置类
@ComponentScan("指定要扫描的包的范围") //开启包扫描器
@EnableAspectJAutoProxy  //开启aop注解扫描
public class SpringConfiguration {
}

//获取容器的方法
ApplicationContext ac = 
            new AnnotationConfigApplicationContext(SpringConfiguration.class);