AOP应用

AOP操作（准备）：

　　1：Spring框架一般基于AspectJ实现AOP操作

　　　　AspectJ不是Spring的组成部分，是一个独立的AOP框架，一般把AspectJ与Spring框架一起使用，进行AOP相关操作

　　2：基于AspectJ实现AOP操作（两种方式）

　　　　1）基于xml配置文件方式实现

　　　　2）使用注解方式实现（一般使用此方法）

　　3：在项目工程里面增加AOP相关依赖包，

1　　com.springsource.net.sf.cglib-2.2.0

2　　com.springsource.org.aopalliance-1.0.0

3　　com.springsource.org.aspectj.weaver-1.7.2.RELEASE

　　4：切入点表达式

切入点表达式作用：知道对哪个类里面的哪个方法进行增强

语法结构：

execution([权限修饰符][返回类型][类全路径].[方法名称]（[参数列表]）)　　*表示所有

例子：对com.UserDao类里面的add方法进行增强

execution（* com.UserDao.add(int a))

 

AOP操作（基于注解实现AspectJ）：

　　1：创建类，在类里面定义方法

　　2：创建增强类（编写增强方法）

　　3：进行通知的配置：

　　　　（1）在spring配置文件中开启注解扫描

 

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       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">

<!--    开启注解扫描哦-->
    <context:component-scan base-package="AOP.annotation"></context:component-scan>

 

 

 

　　　　（2）使用注解创建User和UserProxy对象

　　　　（3）在增强类上面增加一个注解@Aspect

 

package AOP.annotation;

import org.springframework.stereotype.Component;

//被增强的类
@Component
public class User {
    public void add() {
        System.out.println("add......");
    }
}

 

package AOP.annotation;

import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;

//增强类
@Component
@Aspect //生成代理对象
public class UserProxy {
    //前置通知
    public void before() {
        System.out.println("before.....");
    }
}

 

　　　　（4）在spring配置文件中开启生成代理对象　　

　　　　

<!--    开启Aspect生成代理对象-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

 

 

 

 　　4：配置不同类型的通知

　　　　在增强类的里面，在作为通知方法上面添加通知类型注解，使用切入点表达式配置

　　　　

package AOP.annotation;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

//增强类
@Component
@Aspect //生成代理对象
public class UserProxy {
    //前置通知
    //Before注解表示作为前置通知
    @Before(value = "execution(* AOP.annotation.User.add())")
    public void before() {
        System.out.println("before.....");
    }

    @After(value = "execution(* AOP.annotation.User.add())")
    public void after() {
        System.out.println("after.....");
    }

    @AfterReturning(value = "execution(* AOP.annotation.User.add())")
    public void afterReturning() {
        System.out.println("afterReturning.....");
    }

    //异常通知
    @AfterThrowing(value = "execution(* AOP.annotation.User.add())")
    public void afterThrowing() {
        System.out.println("afterThrowing.....");
    }

    //环绕通知
    @Around(value = "execution(* AOP.annotation.User.add())")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{
        System.out.println("环绕之前");

//        被增强的方法执行
        proceedingJoinPoint.proceed();

        System.out.println("环绕之后");
    }
}

 

　　

　　5：相同切入点抽取

　　　　

 //相同切入点抽取
    @Pointcut(value = "execution(* AOP.annotation.User.add())")
    public void pointcut() {}


    //前置通知
    //Before注解表示作为前置通知
    @Before(value = "pointcut()")   //value值使用抽取的切入点的类即可
    public void before() {
        System.out.println("before.....");
    }

 

 

 　　6：如果有多个增强类对同一个方法进行增强，可以设置优先级

　　　　　　增强类上面增加@Order（数字类型值）注解，数字越小表示优先级越高

 

　　7：如果使用完全注解开发：

@Configuration

@ComponentScan(basePackages ={"com.Book"})

@EnableAspectJAutoProxy(proxyTargetClass = true)

public void ConfigAop{.........}

 

 

AOP操作（基于xml文件实现）：

　　1：创建增强类和被增强类，创建方法

 

package AOP.xml;

public class Book {

    public void book() {
        System.out.println("buy.......");
    }
}

 

package AOP.xml;

public class BookProxy {

    public void before() {
        System.out.println("before....");
    }
}

 

 

　　2：在xml配置文件中创建两个类的对象

 

<!--创建对象-->
    <bean id="book" class="AOP.xml.Book"></bean>
    <bean id="bookProxy" class="AOP.xml.BookProxy"></bean>

 

 

 

　　3：在配置文件中配置切入点

 

<!--    配置aop增强-->
    <aop:config>
        <!--    切入点-->
            <aop:pointcut id="p" expression="execution(* AOP.xml.BookProxy.before(..))"/>
<!--        配置切面-->
            <aop:aspect ref="bookProxy">
<!--                增强作用在具体方法上-->
                        <aop:before method="before" pointcut-ref="p"/>
            </aop:aspect>
    </aop:config>

</beans>