spring aop知识点整理

梦里梦外; 2021-11-01 21:52 365阅读 0赞

**Aspect（切面）**： Aspect 声明类似于 Java 中的类声明，在 Aspect 中会包含着一些 Pointcut 以及相应的 Advice。  
**Joint point（连接点）**：表示在程序中明确定义的点，典型的包括方法调用，对类成员的访问以及异常处理程序块的执行等等，它自身还可以嵌套其它 joint point。  
**Pointcut（切点）**：表示一组 joint point，这些 joint point 或是通过逻辑关系组合起来，或是通过通配、正则表达式等方式集中起来，它定义了相应的 Advice 将要发生的地方。  
**Advice（增强）**：Advice 定义了在 Pointcut 里面定义的程序点具体要做的操作，它通过 before、after 和 around 来区别是在每个 joint point 之前、之后还是代替执行的代码。（共有五种：before，after （无论是否发生异常，都进行执行的通知），around ，afterRunning，afterThrowing）  
**Target（目标对象）**：织入 Advice 的目标对象.。  
**Weaving（织入）**：将 Aspect 和其他对象连接起来, 并创建 Adviced object 的过程。  
举例  
需要增强的类

package aop;
     import org.springframework.stereotype.Component;
     @Component("knight")
     public class BraveKnight {
         public void saying(String str,User user) throws Exception{ 
             System.out.println("我是骑士..（切点方法）");
             //throw new Exception();
         }
     }

切面类

package aop;
     
     import java.util.Arrays;
     /**
      * 注解方式声明aop
      * 1.用@Aspect注解将类声明为切面(如果用@Component("")注解注释为一个bean对象，那么就要在spring配置文件中开启注解扫描，<context:component-scan base-package="com.cjh.aop2"/>
      *      否则要在spring配置文件中声明一个bean对象)
      * 2.在切面需要实现相应方法的前面加上相应的注释，也就是通知类型。
      * 3.此处有环绕通知，环绕通知方法一定要有ProceedingJoinPoint类型的参数传入，然后执行对应的proceed()方法，环绕才能实现。
      */
     @Component("annotationTest")
     @Aspect
     public class AnnotationTest {
         //定义切点
         @Pointcut("execution(* *.saying(..))")
         public void sayings(){}
         /**
          * 前置通知(注解中的sayings()方法，其实就是上面定义pointcut切点注解所修饰的方法名，那只是个代理对象,不需要写具体方法，
          * 相当于xml声明切面的id名，如下，相当于id="embark",用于供其他通知类型引用)
          * <aop:config>
             <aop:aspect ref="mistrel">
                 
                 <aop:pointcut expression="execution(* *.saying(..))" id="embark"/>
                 
                 <aop:before method="beforSay" pointcut-ref="embark"/>
                 
                 <aop:after method="afterSay" pointcut-ref="embark"/>
             </aop:aspect>
            </aop:config>
          */
         @Before("sayings()")
         public void sayHello(){
             System.out.println("注解类型前置通知");
         }
         //后置通知
         @After("sayings()")
         public void sayGoodbey(){
             System.out.println("注解类型后置通知");
         }
         //环绕通知。注意要有ProceedingJoinPoint参数传入。
         @Around("sayings()")
         public void sayAround(ProceedingJoinPoint joinPoint) throws Throwable{
             System.out.println("注解类型环绕通知..环绕前");
             Object[] args = joinPoint.getArgs();
             Signature signature = joinPoint.getSignature();
             MethodSignature methodSignature = (MethodSignature) signature;
             //2.最关键的一步:通过这获取到方法的所有参数名称的字符串数组
             String[] parameterNames = methodSignature.getParameterNames();
             System.out.println("parameterNames"+Arrays.toString(parameterNames));
             joinPoint.proceed();//执行方法
             System.out.println("注解类型环绕通知..环绕后");
         }
     }

测试类

package aop;
    
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    /**
     * 
     * @author Caijh
     * email:codecjh@163.com
     * 2017年7月11日 下午6:27:06
     */
    public class Test {
        public static void main(String[] args) throws Exception {
            ApplicationContext ac = new ClassPathXmlApplicationContext("spring.xml");
            BraveKnight br = (BraveKnight) ac.getBean("knight");
            User user = new User();
            user.setAge(24);
            br.saying("zhangfei",user);
        }
    }

配置文件

<?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/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd
            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd">
        
        <context:component-scan base-package="aop"/>
        
        <aop:aspectj-autoproxy/>
    </beans>

**@Pointcut**注解详解：  
execution(modifiers-pattern? ret-type-pattern declaring-type-pattern? name-pattern(param-pattern)throws-pattern?)  
括号中各个pattern分别表示：

修饰符匹配（modifier-pattern?）  
返回值匹配（ret-type-pattern）可以为*表示任何返回值,全路径的类名等  
类路径匹配（declaring-type-pattern?）  
方法名匹配（name-pattern）可以指定方法名 或者 代表所有, set 代表以set开头的所有方法  
参数匹配（(param-pattern)）可以指定具体的参数类型，多个参数间用“,”隔开，各个参数也可以用“*”来表示匹配任意类型的参数，如(String)表示匹配一个String参数的方法；(\*,String) 表示匹配有两个参数的方法，第一个参数可以是任意类型，而第二个参数是String类型；可以用(…)表示零个或多个任意参数  
异常类型匹配（throws-pattern?）  
其中后面跟着“?”的是可选项

1）execution(* *(..))  
    //表示匹配所有方法  
    2）execution(public * com. savage.service.UserService.*(..))  
    //表示匹配com.savage.server.UserService中所有的公有方法  
    3）execution(* com.savage.server..*.*(..))  
    //表示匹配com.savage.server包及其子包下的所有方法

拓展一些没用的  
**Spring AOP采用的是动态代理，在运行期间对业务方法进行增强，所以不会生成新类，对于动态代理技术，Spring AOP提供了对JDK动态代理的支持以及CGLib的支持。  
JDK动态代理只能为接口创建动态代理实例，而不能对类创建动态代理。需要获得被目标类的接口信息（应用Java的反射技术），生成一个实现了代理接口的动态代理类（字节码），再通过反射机制获得动态代理类的构造函数，利用构造函数生成动态代理类的实例对象，在调用具体方法前调用invokeHandler方法来处理。  
采用Cglib动态代理可以对没有实现接口的类产生代理，实际上是生成了目标类的子类来增强**

重载与重写  
重载：方法名相同, 参数列表不同的方法之间构成重载; 参数列表不同又包括**参数数量, 参数类型, 参数顺序**的不同.重载的判断只有这两条, 与方法的修饰符, 返回值类型都无关，修饰符返回值类型不同也叫重载  
重写：　1. 三同一大: 返回值类型, 方法名, 参数列表必须与父类相同(返回值类型在java1.5中允许协变返回类型, 就是重写之后的方法的返回值可以是重写之前方法的子类); 一大是指访问权限大于等于父类的访问权限  
　　　　2. 子类方法只能抛出比父类方法更小的异常或者不抛出异常  
　　　　3. 被重写的方法不能有final,private, static修饰符. 因为final不允许被子类继承; 而private方法隐含是final类型, 且只能在类中被访问, 子类是无权访问的. 子类中只能定义一个与父类完全相同的方法, 而不能称之为重写;

**spring事务实现原理：动态代理**  
对于纯JDBC操作数据库，想要用到事务，可以按照以下步骤进行：

1获取连接 Connection con = DriverManager.getConnection()  
2开启事务con.setAutoCommit(true/false);  
3执行CRUD  
4提交事务/回滚事务 con.commit() / con.rollback();  
5关闭连接 conn.close();

使用Spring的事务管理功能后，我们可以不再写步骤 2 和 4 的代码，而是由Spirng 自动完成。 那么Spring是如何在我们书写的 CRUD 之前和之后开启事务和关闭事务的呢？解决这个问题，也就可以从整体上理解Spring的事务管理实现原理了。下面简单地介绍下，注解方式为例子  
配置文件开启注解驱动，在相关的类和方法上通过注解@Transactional标识。  
spring 在启动的时候会去解析生成相关的bean，这时候会查看拥有相关注解的类和方法，并且为这些类和方法生成代理，并根据@Transaction的相关参数进行相关配置注入，这样就在代理中为我们把相关的事务处理掉了（开启正常提交事务，异常回滚事务）。