Java进阶知识22 Spring execution 切入点表达式

1、概述

切入点(execution )：可以对指定的方法进行拦截，从而给指定的类生成代理对象。（拦截谁，就是在谁那里切入指定的程序/方法）

格式：

execution(modifiers-pattern? ret-type-pattern declaring-type-pattern? name-pattern(param-pattern) throws-pattern?)

参数解析：

modifiers-pattern?：指定方法的修饰符，支持通配符，该部分可以省略。（public/private/protected）
ret-type-pattern：指定方法的返回值类型，支持通配符，可以使用 * 来匹配所有的返回值类型。
declaring-type-pattern?：指定方法所属的类，支持通配符，该部分可以省略。（要切入的类：class）
name-pattern：指定要匹配的方法名，支持通配符，可以使用"*"通配符来匹配所有方法。（要切入的方法）
param-pattern：指定方法声明中的形参列表，支持两个通配符，即"*"和".."，其中“*”代表一个任意类型的参数，而“..”代表零个或多个任意类型的参数。例如，() 匹配一个不接受任何参数的方法，而(..) 匹配一个接受任意数量参数的方法，(*)匹配了一个接受一个任何类型的参数的方法，(*,String)匹配了一个接受两个参数的方法，其中第一个参数是任意类型，第二个参数必须是String类型。（要切入的方法的参数列表）
throws-pattern：指定方法声明抛出的异常，支持通配符，该部分可以省略。

切入点语法常用的几种：

 <!-- 切入点表达式语法： -->

 <!-- 【1、拦截所有public方法】 -->

 <aop:pointcut expression="execution(public * *(..))" id="pt"/> 
 4

 <!-- 【2、拦截所有save开头的方法】 -->

 <aop:pointcut expression="execution(* save*(..))" id="pt"/> 
 7

 <!-- 【3、拦截指定类的指定方法, 拦截时候一定要定位到方法】 -->

 <aop:pointcut expression="execution(* com.shore.dao.impl.UserDao.save(..))" id="pt"/>

 <!-- 【4、拦截指定类的所有方法】 -->

 <aop:pointcut expression="execution(* com.shore.dao.impl.UserDao.*(..))" id="pt"/>
 

 <!-- 【5、拦截指定包，以及其自包下所有类的所有方法】 -->

 <aop:pointcut expression="execution(* com..*.*(..))" id="pt"/>
 

 <!-- 【6、多条件】 -->

 <!-- 或：||   or -->

 <aop:pointcut expression="execution(* com.shore.dao.impl.UserDao.save(..)) || execution(* com.shore.dao.impl.MessageDao.save(..))" id="pt" />
 <aop:pointcut expression="execution(* com.shore.dao.impl.UserDao.save(..)) or execution(* com.shore.dao.impl.MessageDao.save(..))" id="pt" />
 

 <!-- 且：&amp;&amp;   and -->  <!-- 语法虽然没错，但，没意义 -->

 <aop:pointcut expression="execution(* com.shore.dao.impl.UserDao.save(..)) &amp;&amp; execution(* com.shore.dao.impl.MessageDao.save(..))" id="pt" />

 <aop:pointcut expression="execution(* com.shore.dao.impl.UserDao.save(..)) and execution(* com.shore.dao.impl.MessageDao.save(..))" id="pt" />
 

 <!-- 【7、取非值：not  ！  不拦截指定的规则，拦截除此之外的所有类的方法】 -->

 <aop:pointcut expression="!execution(* com.shore.dao.impl.UserDao.save(..))" id="pt"/>
 <!-- 注意not前必须有空格 -->

 <aop:pointcut expression=" not execution(* com.shore.dao.impl.UserDao.save(..))" id="pt"/>

2、实例

用到的jar包：

Java进阶知识22 Spring execution 切入点表达式-LMLPHP 　　　　

相关代码：

 //接口

 public interface IUserDao {

     public void save();

 }

 //接口实现类

 public class UserDao implements IUserDao {

     @Override

     public void save() { //3、执行业务方法

         System.out.println("3、保存用户成功！");

     }

 }

MessageDao 类（此类，没有实现任何接口）

 public class MessageDao {

     public void save() { //3、执行业务方法

         System.out.println("3、保存信息成功！");

     }

 }

Aop 类

 package com.shore.aop;

 import org.aspectj.lang.ProceedingJoinPoint;

 /**

  * @author DSHORE/2019-11-7

  *

  */

 public class Aop {

     //around：环绕； ProceedingJoinPoint：必须添加(执行)

     @SuppressWarnings("unused")

     private void around(ProceedingJoinPoint pjp) throws Throwable {

         System.out.println("2、环绕前....");

         pjp.proceed();  // 执行目标方法（业务代码）

         System.out.println("5、环绕后....");

     }

     public void begin() {

         System.out.println("1、开启事务......");

     }

     public void commit() {

         System.out.println("6、提交事务......");

     }

     public void afterReturning() {

         System.out.println("4、afterReturning()，返回消息");

     }

     //有异常，执行这个第四步；没有异常，则执行上面的第四步

     public void afterThrowing(){

         System.out.println("4、afterThrowing()，返回异常消息");

     }

 }

Spring 配置文件（beans.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"

     xmlns:tx="http://www.springframework.org/schema/tx"

     xsi:schemaLocation="

        http://www.springframework.org/schema/beans

        http://www.springframework.org/schema/beans/spring-beans.xsd

        http://www.springframework.org/schema/tx

        http://www.springframework.org/schema/tx/spring-tx.xsd

        http://www.springframework.org/schema/aop

        http://www.springframework.org/schema/aop/spring-aop.xsd">

     <!-- dao类 -->

     <bean id="userDao" class="com.shore.dao.impl.UserDao"></bean>

     <bean id="messageDao" class="com.shore.dao.impl.MessageDao"></bean>

     <!-- 注入切面类 -->

     <bean id="aop" class="com.shore.aop.Aop"></bean>

     <aop:config>

         <!-- 配置切入点 -->

         <!-- 切入点表达式语法： -->

         <!-- 【1、拦截所有public方法】 -->  <!-- 【第一个*是返回类型，第二个*是方法名 -->

         <!-- <aop:pointcut expression="execution(public * *(..))" id="pt" /> -->

         <!-- 【2、拦截所有save开头的方法】 -->

         <!-- <aop:pointcut expression="execution(* save(..))" id="pt" /> -->

         <!-- 【3、拦截指定类的指定方法, 拦截时候一定要定位到方法】 -->

         <!-- <aop:pointcut expression="execution(* com.shore.dao.impl.UserDao.save(..))" id="pt" /> -->

         <!-- 【4、拦截指定类的所有方法】 -->

         <!-- <aop:pointcut expression="execution(* com.shore.dao.impl.UserDao.*(..))" id="pt" /> -->

         <!-- 【5、拦截指定包，以及其自包下所有类的所有方法】 -->

         <!-- <aop:pointcut expression="execution(* com..*.*(..))" id="pt" /> -->

         <!-- <aop:pointcut expression="execution(* com..UserDao.*(..))" id="pt" /> -->

         <!-- 6、多条件 -->

         <!-- 【（1）或：or   ||】 -->

         <!-- <aop:pointcut expression="execution(* com.shore.dao.impl.UserDao.save(..)) or execution(* com.shore.dao.impl.MessageDao.save(..))" id="pt" /> -->

         <!-- 【（2）与：and   &amp;&amp;】 -->

         <aop:pointcut expression="execution(* com.shore.dao.impl.UserDao.save(..)) and execution(* com.shore.dao.impl.MessageDao.save(..))" id="pt" />

         <!-- 【7、否定:!  not(not前后都需要空格)】 -->

         <!-- <aop:pointcut expression="!execution(* com.shore.dao.impl.UserDao.*(..))" id="pt" /> -->

         <aop:pointcut expression=" not execution(* com.shore.dao.impl.UserDao.*(..))" id="pt" />

         <!-- 配置切面(切入点形成的类，切入点就是重复的代码/方法) -->

         <aop:aspect ref="aop">

             <!-- 1、开启事务。。。。。。 -->

             <aop:before method="begin" pointcut-ref="pt" />

             <!-- 6、提交事务 -->

             <aop:after method="commit" pointcut-ref="pt" />

             <!-- 环绕2/5 -->

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

             <!-- 4、afterReturning -->

             <aop:after-returning method="afterReturning"

                 pointcut-ref="pt" />

             <!-- 4、异常（程序出现异常，执行这个第四步；没有异常，则执行上面的第四步） -->

             <aop:after-throwing method="afterThrowing"

                 pointcut-ref="pt" />

         </aop:aspect>

     </aop:config>

 </beans>

测试类

 package com.shore.test;

 import org.junit.Test;

 import org.springframework.context.ApplicationContext;

 import org.springframework.context.support.ClassPathXmlApplicationContext;

 import com.shore.dao.IUserDao;

 import com.shore.dao.impl.MessageDao;

 /**

  * @author DSHORE/2019-11-7

  *

  */

 public class MyTest {

     @Test

     public void testUserDao() {

         ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");

         IUserDao userDao = (IUserDao) context.getBean("userDao");

         //$Proxy4 ：class com.sun.proxy.$Proxy4

         System.out.println("这个相当于动态代理$Proxy4："+userDao);//返回值：com.shore.dao.impl.UserDao@73aecc3a

         userDao.save();

         System.out.println("=============== 分割线 ===============");

         MessageDao messageDao = (MessageDao) context.getBean("messageDao");

         System.out.println("这个相当于Cglib子类代理："+messageDao);//返回值：com.shore.dao.impl.MessageDao@15412e75

         messageDao.save();

     }

 }

上方实例，切入点出代码，详细解析：

1、拦截所有public方法

 <!-- 【1、拦截所有public方法】 -->  <!-- 第一个*是返回值类型，第二个*是方法名；两个..表示可以是两个或者是多个参数 -->

 <aop:pointcut expression="execution(public * *(..))" id="pt" />

运行结果图：