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")@Aspectpublic 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);