Spring&AOP&JDK和Cglib动态代理&AspectJ进行AOP开发(XML方式)

AOP概述

AOP(面向切面编程)解决 OOP(面向对象编程) 中遇到的一些问题.是OOP的延续和扩展
AOP最早由 AOP联盟 的组织提出的,制定了一套规范Spring将AOP思想引入到框架中,必须遵守AOP联盟的规范.

AOP两种底层实现方式

代理机制:
Spring的AOP的底层用到两种代理机制：
        JDK的动态代理    :针对实现了接口的类产生代理.
        Cglib的动态代理    :针对没有实现接口的类产生代理. 应用的是底层的字节码增强的技术 生成当前类的子类对象.

JDK动态代理增强一个类中方法

public class MyProxyUtils {
    public static UserDao getUserDao(final UserDao dao){
        //使用Proxy类生成代理对象
        UserDao proxy = (UserDao) Proxy.newProxyInstance(dao.getClass().getClassLoader(), dao.getClass().getInterfaces(), new InvocationHandler() {

            //代理对象方法一执行,invoke方法就会执行一次
            @Override//proxy参数不要用表示当前代理的对象,method代理的方法,args参数
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                if("save".equals(method.getName())){
                    System.out.println("记录日志");
                    //开启事务
                    Object invoke = method.invoke(dao, args);
                    //提交事务,在这里也可以抓住异常回滚事务

                    //让dao类的seve方法或者update方法正常执行下去
                    return invoke;
                }else{
                    Object invoke = method.invoke(dao, args);
                    return invoke;
                }
            }
        });
        //返回代理对象
        return proxy;
   }
}

[装饰者模式AOP具体实现][2]

Cglib的动态代理

public class MyCglibProxy implements MethodInterceptor{

    private CustomerDao customerDao;

    public MyCglibProxy(CustomerDao customerDao){
        this.customerDao = customerDao;
    }
    
    // 生成代理的方法:
    public CustomerDao createProxy(){
        // 创建Cglib的核心类:
        Enhancer enhancer = new Enhancer();
        // 设置父类:
        enhancer.setSuperclass(CustomerDao.class);
        // 设置回调:
        enhancer.setCallback(this);
        // 生成代理：
        CustomerDao customerDaoProxy = (CustomerDao) enhancer.create();
        return customerDaoProxy;
    }

    @Override
    public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        if("delete".equals(method.getName())){
            Object obj = methodProxy.invokeSuper(proxy, args);
            System.out.println("日志记录================");
            return obj;
        }
        
        return methodProxy.invokeSuper(proxy, args);
    }
}

Spring的基于AspectJ的AOP开发

 - Joinpoint(连接点) :所谓连接点是指那些被拦截到的点。在spring中,这些点指的是方法,因为spring只支持方法类型的连接点.
 - Pointcut(切入点) :所谓切入点是指我们要对哪些Joinpoint进行拦截的定义.
 - Advice(通知/增强) :所谓通知是指拦截到Joinpoint之后所要做的事情就是通知.通知分为前置通知,后置通知,异常通知,最终通知,环绕通知(切面要完成的功能)
 - Introduction(引介) :引介是一种特殊的通知在不修改类代码的前提下, Introduction可以在运行期为类动态地添加一些方法或Field.
 - Target(目标对象):代理的目标对象
 - Weaving(织入):是指把增强应用到目标对象来创建新的代理对象的过程.
    spring采用动态代理织入，而AspectJ采用编译期织入和类装在期织入
 - Proxy（代理）:一个类被AOP织入增强后，就产生一个结果代理类
 - Aspect(切面): 是切入点和通知（引介）的结合

需要的jar包:
spring的传统AOP的开发的包
 - spring-aop-4.2.4.RELEASE.jar
 - com.springsource.org.aopalliance-1.0.0.jar

aspectJ的开发包:
 - com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar
 - spring-aspects-4.2.4.RELEASE.jar

引入Spring的配置文件的约束

<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" xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
    
</beans>

代码和配置:
1.编写目标类
创建接口和类:

public interface OrderDao {
    public void save();
    public void update();
    public void delete();
    public void find();
}

public class OrderDaoImpl implements OrderDao {

    @Override
    public void save() {
        System.out.println("保存订单...");
    }

    @Override
    public void update() {
        System.out.println("修改订单...");
    }

    @Override
    public void delete() {
        System.out.println("删除订单...");
    }

    @Override
    public void find() {
        System.out.println("查询订单...");
    }

}

2.目标类的配置

    <!-- 目标类================ -->
    <bean id="orderDao" class="cn.itcast.spring.demo3.OrderDaoImpl">
    
    </bean>

3.配置切面类

    <aop:config>
        <aop:aspect ref="切面类的id">
                <!--<aop:around>前置通知-->
                <aop:around method="切面类的方法(增强方法)" pointcut="表达式切入点" />
        </aop:aspect>
    </aop:config>

通知类型
 - 前置通知
    在目标类的方法执行之前执行。

配置文件信息：

<aop:after method="before" pointcut="切入点表达式"/>

    应用：可以对方法的参数来做校验
 - 最终通知
    在目标类的方法执行之后执行，如果程序出现了异常，最终通知也会执行。

    在配置文件中编写具体的配置：

<aop:after method="after" pointcut="切入点表达式"/>

    应用：例如像释放资源
 - 后置通知
    方法正常执行后的通知。        

    在配置文件中编写具体的配置：

<aop:after-returning method="afterReturning" pointcut="切入点表达式"/>

    应用：可以修改方法的返回值
 - 异常抛出通知
    在抛出异常后通知

    在配置文件中编写具体的配置：

<aop:after-throwing method="afterThorwing" pointcut="切入点表达式"/>    

    应用：包装异常的信息
 - 环绕通知
    方法的执行前后执行。

    在配置文件中编写具体的配置：

<aop:around method="around" pointcut="切入点表达式"/>

    要注意：目标的方法默认不执行，需要使用ProceedingJoinPoint对来让目标对象的方法执行。
切入点表达式
execution(表达式)
表达式:
[方法访问修饰符] 方法返回值 包名.类名.方法名(方法的参数),*通配符

public * cn.itcast.spring.dao.*.*(..)
 - * cn.itcast.spring.dao.*.*(..)
 - * cn.itcast.spring.dao.UserDao+.*(..)
 - * cn.itcast.spring.dao..*.*(..)

编写一个切面类

public class MyAspectXml {
    // 前置增强
    public void before(){
        System.out.println("前置增强===========");
    }
}

另一种AOP配置方式

<!-- 配置切面类 -->
    <bean id="myAspectXml" class="cn.itcast.spring.demo3.MyAspectXml"></bean>
    
<!-- 进行aop的配置 -->
    <aop:config>
        <!-- 配置切入点表达式:哪些类的哪些方法需要进行增强 -->
        <aop:pointcut expression="execution(* cn.itcast.spring.demo3.*Dao.save(..))" id="pointcut1"/>
        <aop:pointcut expression="execution(* cn.itcast.spring.demo3.*Dao.delete(..))" id="pointcut2"/>
        <aop:pointcut expression="execution(* cn.itcast.spring.demo3.*Dao.update(..))" id="pointcut3"/>
        <aop:pointcut expression="execution(* cn.itcast.spring.demo3.*Dao.find(..))" id="pointcut4"/>
        <!-- 配置切面 -->
        <aop:aspect ref="myAspectXml">
            <aop:before method="before" pointcut-ref="pointcut1"/>
            <aop:after-returning method="afterReturing" pointcut-ref="pointcut2"/>
            <aop:around method="around" pointcut-ref="pointcut3"/>
            <aop:after-throwing method="afterThrowing" pointcut-ref="pointcut4"/>
            <aop:after method="after" pointcut-ref="pointcut4"/>
        </aop:aspect>
    </aop:config>