Spring中的AOP以及切入点表达式和各种通知

package com.cj.study.spring.aop;
public interface PersonService {
    public String savePerson();
    public void updatePerson();
    public void deletePerson();
}

package com.cj.study.spring.aop;
public class PersonServiceImpl implements PersonService {
    @Override
    public String savePerson() {
        System.out.println("添加");
        return "保存成功！";
    }
    @Override
    public void updatePerson() {
        System.out.println("修改");
    }
    @Override
    public void deletePerson() {
        System.out.println("删除");
    }
}

package com.cj.study.spring.aop;
//切面类
public class MyTransaction {
    //切面里的通知方法
    public void beginTransaction(){
        System.out.println("开启事务 ");
    }
    //切面里的通知方法
    public void commit(){
        System.out.println("提交事务");
    }
}

package com.cj.study.spring.aop;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class AopTest {
    @Test
    public void test(){
        ApplicationContext context = new ClassPathXmlApplicationContext("com/cj/study/spring/aop/applicationContext.xml");
        PersonService proxyPersonService = (PersonService) context.getBean("personService");
        String returnValue = proxyPersonService.savePerson();
        System.out.println(returnValue);
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       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-2.5.xsd
           http://www.springframework.org/schema/aop
           http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">
    <bean class="com.cj.study.spring.aop.PersonServiceImpl" id="personService"></bean>
    <bean class="com.cj.study.spring.aop.MyTransaction" id="myTransaction"></bean>
    <aop:config>
        <aop:pointcut expression="execution(* com.cj.study.spring.aop.*.*(..))" id="perform"/>
        <aop:aspect ref="myTransaction">
            <aop:before method="beginTransaction" pointcut-ref="perform"/>
        </aop:aspect>
        <aop:aspect ref="myTransaction">
            <aop:after method="commit" pointcut-ref="perform"/>
        </aop:aspect>
    </aop:config>
</beans>

execution（public * *（..））  所有的公共方法
execution（* set*（..））  以set开头的任意方法
execution（* com.ci.service.AccountService.*（..）） com.cj.service.AccountService类中的所有的方法
execution（* com.cj.service.*.*（..））  com.cj.service包中的所有的类的所有的方法
execution（* com.cj.service..*.*（..）） com.cj.service包及子包中所有的类的所有的方法
execution(* com.cj.spring.aop..*.*(String,?,Integer))  com.cj.spring.aop包及子包中所有的类的有三个参数
                                                            且第一个参数为String,第二个参数为任意类型，
                                                            第三个参数为Integer类型的方法

通知：
   1、前置通知
      1、在目标方法执行之前执行
      2、无论目标方法是否抛出异常，都执行，因为在执行前置通知的时候，目标方法还没有执行，还没有遇到异常
   2、后置通知
      1、在目标方法执行之后执行
      2、当目标方法遇到异常，后置通知将不再执行
      3、后置通知可以接受目标方法的返回值，但是必须注意：
               后置通知的参数的名称和配置文件中returning="var"的值是一致的
   3、最终通知：
      1、在目标方法执行之后执行
      2、无论目标方法是否抛出异常，都执行，因为相当于finally
   4、异常通知
      1、接受目标方法抛出的异常信息
      2、步骤
           在异常通知方法中有一个参数Throwable  ex
           在配置文件中
              <after-throwing method="throwingMethod" pointcut-ref="perform" throwing="ex"></after-throwing>
   5、环绕通知
       1、如果不在环绕通知中调用ProceedingJoinPoint的proceed，目标方法不会执行
       2、环绕通知可以控制目标方法的执行

springAOP的具体加载步骤：
   1、当spring容器启动的时候，加载了spring的配置文件
   2、为配置文件中所有的bean创建对象
   3、spring容器在创建对象的时候它会解析aop:config的配置
            解析切入点表达式，用切入点表达式和纳入spring容器中的bean做匹配
            如果匹配成功，则会为该bean创建代理对象，代理对象的方法=目标方法+通知
            如果匹配不成功，则为该bean创建正常的对象
            其实就是你通过表达式告诉Spring哪些bean需要它帮你生成代理对象而不是生成原有的正常对象
      理解这一点相当重要！
   4、在客户端利用context.getBean获取对象时，如果该对象有代理对象则返回代理对象，如果没有代理对象，则返回目标对象
注意：如果目标类实现了接口，spring容器会采用jdk的动态代理产生代理对象，产生的代理类和目标类实现了相同的接口；如果目标类没实现接口，spring容器会采用cglib的方式产生代理对象，产生的代理类是目标类的子类