SSM之SpringAOP 切面表达式

学习目标

• spring AOP
• 事务
• spring事务管理
• Spring和Mybatis整合

动态代理JDK proxy

• 动态代理，必须要有一个接口
• 动态代理的三个参数
  代理类，与被代理类 地位是一样的（相同的ClassLoader，相同的接口）所以，有相同的接口，相同的类加载器
• invoke方法
  参2 表示要增强哪个方法
  Object returnValue = method.invoke(laoZong,args);

AOP术语

1、 目标类target：就是我们需要增强的那个类 LaoZong.class
2、 代理类proxy：就是自定义的代理的对象 $Proxy0.class
3、 连接点joinPoint：程序执行的某个特定位置，Spring仅支持方法的连接点
eat(),sleep(),run()
4、 切入点pointCut：就是在目标类中实际增强的方法
eat()
5、 织入weave：就是将代理类中需要增强的方法放入到目标类中去执行的过程
将原方法与其他类的方法一起调用
6、 引介Introduction：引介是一种特殊的增强，它为类添加一些属性和方法(课程不使用)
7、 通知advice：将代理对象中的方法应用到目标类的过程中产生的结果。
8、 切面aspect：所有的切入点和代理对象的方法组成在一起 构成了切面

Spring AOP的准备

pom.xml

  <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.9.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.7.2</version>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.2.9.RELEASE</version>
        </dependency>

    </dependencies>

IUser

//1 必须要有一个接口
public interface IUser {
    
    
    void work();
}

UserImpl

//2 类与接口是实现关系
public class UserImpl implements IUser {
    
    
    //连接点
    //切点
    @Override
    public void work() {
    
    
        System.out.println("我加班我快乐");
    }
}

Advice

public class Advice {
    
    
    public void writeLog(){
    
    
        System.out.println("写一个开发备忘录");
    }
}

Spring AOP的xml配置

applicationContext.xml

<?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"
       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">


<!--    创建UserImpl对象 目标类 -->
    <bean id="userImpl" class="com.wzx.service.impl.UserImpl"/>
<!--    创建Advice对象-->
    <bean id="advice" class="com.wzx.service.Advice"/>
<!--    配置他们的增强关系 生成一个代理类-->
    <aop:config >
        <aop:pointcut id="work" expression="execution(public void com.wzx.service.impl.UserImpl.work())"/>
        <!-- 我想在work方法执行 之后调用一下writeLog-->
        <aop:aspect ref="advice">
             <aop:after method="writeLog"  pointcut-ref="work"/>
        </aop:aspect>
    </aop:config>
</beans>

UserImplTest

public class UserImplTest {
    
    

    @Autowired
    IUser iUser;
    @Test
    public void work() {
    
    
        System.out.println(iUser);
        iUser.work();;
    }
}

AOP切面编程-切面表达式

• 切面表达式
  excution([修饰符] 返回值类型 包.类.方法（参数列表）)；
• 切面表达式的作用
  符合表达式的方法，会被增强
  使用* 表示任意的内容
  使用…可以表示包与子包下面的类
  使用…可以写在方法（…）中，表示任意参数

<!--    配置他们的增强关系 生成一个代理类-->
    <aop:config >
        <aop:pointcut id="work" expression="execution(* com.wzx.service..*.*(..))"/>
        <!-- 我想在work方法执行 之后调用一下writeLog-->
        <aop:aspect ref="advice">
            <aop:after method="writeLog"  pointcut-ref="work"/>
        </aop:aspect>
    </aop:config>

增强方式

• 有哪些？
  实质是增强的四个可选调用位置
  每个位置都有对应的名称
  arround环绕
  

简化

joinPoint.proceed();//切到原来的目标方法，进行执行

Advice

public class Advice {
    
    
    public void writeLog(){
    
    
        System.out.println("写一个开发备忘录");
    }
    public void before(){
    
    
        System.out.println("before-------");
    }
    public void after(){
    
    
        System.out.println("after-------");
    }
    public void afterReturn(){
    
    
        System.out.println("afterReturn-------");
    }
    public void afterThrow(){
    
    
        System.out.println("afterThrow-------");
    }
}

applicationContext.xml

 <!--    配置他们的增强关系 生成一个代理类-->
    <aop:config >
        <aop:pointcut id="all" expression="execution( * com.wzx.service..*.*(..))"/>
        <!-- 我想在work方法执行 之后调用一下writeLog-->
        <aop:aspect ref="advice">
            <!-- try-->
            <aop:before method="before"  pointcut-ref="all"/>
            <!-- 有可能程序正常运行-->
            <aop:after-returning method="afterReturn"  pointcut-ref="all"/>
            <!-- catch-->
            <aop:after-throwing method="afterThrow"  pointcut-ref="all"/>
            <!-- finally-->
            <aop:after method="after"  pointcut-ref="all"/>

        </aop:aspect>
    </aop:config>

环绕通知

Advice

public void arround(ProceedingJoinPoint point ){
    
    //参目标类中的任意方法
        try{
    
    
            //执行before
            before();
            System.out.println("arround-------");
            point.proceed();//对应你调用的UserImpl中的任意方法
            //执行正常返回
            afterReturn();
        }catch (Throwable e){
    
    
            //补救方法
            afterThrow();
        }finally {
    
    
            //释放资源的方法
            after();
        }
    }

applicationContext.xml

<!--    配置他们的增强关系 生成一个代理类-->
    <aop:config >
        <aop:pointcut id="all" expression="execution( * com.wzx.service..*.*(..))"/>
        <!-- 我想在work方法执行 之后调用一下writeLog-->
        <aop:aspect ref="advice">

            <aop:around method="arround"  pointcut-ref="all"/>

        </aop:aspect>
    </aop:config>

注解

• spring注解配置：一个xml开启注解自动代理
• 注解
  切面@Aspect+四个注解 @Before @AfterReturning @AfterThrowing@After
  切面@Aspect+@Arround

Advice

@Component
@Aspect
public class Advice {
    
    
    public void writeLog(){
    
    
        System.out.println("写一个开发备忘录");
    }
    //try{  }
   // @Before("execution( * com.wzx.service..*.*(..))")
    public void before(){
    
    
        System.out.println("before-------");
    }
    //@AfterReturning("execution( * com.wzx.service..*.*(..))")
    public void afterReturn(){
    
    
        System.out.println("afterReturn-------");
    }
   //catch(exception e){ }
   // @AfterThrowing("execution( * com.wzx.service..*.*(..))")
    public void afterThrow(){
    
    
        System.out.println("afterThrow-------");
    }
    //finally
   // @After("execution( * com.wzx.service..*.*(..))")
    public void after(){
    
    
        System.out.println("after-------");
    }

    @Around("execution( * com.wzx.service..*.*(..))")
    public void arround(ProceedingJoinPoint point ){
    
    //参目标类中的任意方法
        try{
    
    
            //执行before
            before();
            System.out.println("arround-------");
            point.proceed();
            //执行正常返回
            afterReturn();
        }catch (Throwable e){
    
    
            //补救方法
            afterThrow();
        }finally {
    
    
            //释放资源的方法
            after();
        }
    }
}

applicationContext.xml

<?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:context="http://www.springframework.org/schema/context"
       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/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="com.wzx.service"/>

    <!--开启自动AOP代理-->
    <aop:aspectj-autoproxy/>

</beans>