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" />
<!-- 且：&& and --> <!-- 语法虽然没错，但，没意义 -->
<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(..)) 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包：
相关代码：
//接口
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 &&】 -->
<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" />
运行结果图：
解析：
从上面的项目截图以及相关代码，可以看出：只有三个public 方法，Aop类中的不算，因为他是切面类。故，上面红框中的结果，大家不难理解。没有红框的两处代码，是对IUserDao类进行拦截，输出两遍，是因为测试类，调用它两遍。
2、拦截所有save开头的方法
<!-- 【2、拦截所有save开头的方法】 --> <!-- 第一个*是返回类型，两个..表示可以是两个或者是多个参数 -->
<aop:pointcut expression="execution(* save(..))" id="pt" />
运行结果图：
解析省略（看结果图中的红色文字）
3、拦截指定类的指定方法， 拦截时候一定要 定位到方法
<!-- 【3、拦截指定类的指定方法, 拦截时候一定要定位到方法】 --> <!-- 第一个*是返回类型，两个..表示可以是两个或者是多个参数 -->
<aop:pointcut expression="execution(* com.shore.dao.impl.UserDao.save(..))" id="pt" />
运行结果图：
解析：
从上面的代码和结果图，可以看出，这里只对UserDao类中的save方法进行拦截。虽然MessageDao类中的save方法也运行了，但是，没有开启事务，也没提交事务，故不会生效。
4、拦截指定类的所有方法
<!-- 【4、拦截指定类的所有方法】 --> <!-- 第一个*是返回值类型，第二个*是方法名；两个..表示可以是两个或者是多个参数 -->
<aop:pointcut expression="execution(* com.shore.dao.impl.UserDao.*(..))" id="pt" />
运行结果图：
解析省略（和上面第3点一样，UserDao类中，有多少个方法，就执行多少个，结果类似）
5、拦截指定包，以及其自包下所有类的所有方法
<!-- 【5、拦截指定包，以及其自包下所有类的所有方法】 -->
<aop:pointcut expression="execution(* com..*.*(..))" id="pt" /><!-- 这几个*分别是 返回类型、com包下的所有类、指定类下的所有方法 -->
<aop:pointcut expression="execution(* com..UserDao.*(..))" id="pt" />
运行结果图：
解析省略（和上面的测试结果类似）
6、多条件
<!-- 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 &&】 -->
<aop:pointcut expression="execution(* com.shore.dao.impl.UserDao.save(..)) and execution(* com.shore.dao.impl.MessageDao.save(..))" id="pt" />
运行结果图：
解析省略（看结果图中的红色文字）
7、否定： ! not(注意：not前后都需要空格)
<!-- 【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" />
运行结果图：
解析省略（看结果图中的红色文字）
本文总结： 经测试结果显示，做修饰符（public/private/protected）和否定（！ not）测试时，连接口类都一起拦截。除这两种以外，只要是指定了包名、类名、方法名的 等等，都不会再去拦截接口类。
|
原创作者：DSHORE 作者主页：http://www.cnblogs.com/dshore123/ 原文出自：https://www.cnblogs.com/dshore123/p/11823849.html 欢迎转载，转载务必说明出处。（如果本文对您有帮助，可以点击一下右下角的 推荐，或评论，谢谢！） |