学习aop，我们需要先学习一些专业术语
1.target：目标类，需要被代理的类。例如：UserService
2.Joinpoint(连接点):所谓连接点是指那些可能被拦截到的方法。例如：所有的方法
3.PointCut 切入点：已经被增强的连接点。例如：addUser()
4.advice 通知/增强，增强代码。例如：after、before
5. Weaving(织入):是指把增强advice应用到目标对象target来创建新的代理对象proxy的过程.
6.proxy 代理类
7. Aspect(切面): 是切入点pointcut和通知advice的结合
一个线是一个特殊的面。
一个切入点和一个通知，组成成一个特殊的面。
在连接点和切入点在现实的生活中，有一个特别形象的比喻，就好比我们去公共厕所，公共厕所一共有5个便池，但是有3个便池被使用了，那么用aop的术语来说，就是有5个连接点，3个切入点，切入点都是被增强的，连接点是所有的。
下面说一下jdk的动态代理，首先，我们需要找到我们的目标类，然后我们需要找到我们的切入点，找到我们的通知。
下面看代码
public interface UserService {
public void addUser();
public void updateUser();
public void deleteUser();
}
public class UserServiceImpl implements UserService {
@Override
public void addUser() {
System.out.println("a_proxy.a_jdk addUser");
}
@Override
public void updateUser() {
System.out.println("a_proxy.a_jdk updateUser");
}
@Override
public void deleteUser() {
System.out.println("a_proxy.a_jdk deleteUser");
}
}
public class MyAspect {
public void before(){
System.out.println("鸡首");
}
public void after(){
System.out.println("牛后");
}
}
public class MyBeanFactory {
public static UserService createService(){
//1 目标类
final UserService userService = new UserServiceImpl();
//2切面类
final MyAspect myAspect = new MyAspect();
/* 3 代理类：将目标类（切入点）和 切面类（通知） 结合 --> 切面
* Proxy.newProxyInstance
* 参数1：loader ，类加载器，动态代理类 运行时创建，任何类都需要类加载器将其加载到内存。
* 一般情况：当前类.class.getClassLoader();
* 目标类实例.getClass().get...
* 参数2：Class[] interfaces 代理类需要实现的所有接口
* 方式1：目标类实例.getClass().getInterfaces() ;注意：只能获得自己接口，不能获得父元素接口
* 方式2：new Class[]{UserService.class}
* 例如：jdbc 驱动 --> DriverManager 获得接口 Connection
* 参数3：InvocationHandler 处理类，接口，必须进行实现类，一般采用匿名内部
* 提供 invoke 方法，代理类的每一个方法执行时，都将调用一次invoke
* 参数31：Object proxy ：代理对象
* 参数32：Method method : 代理对象当前执行的方法的描述对象（反射）
* 执行方法名：method.getName()
* 执行方法：method.invoke(对象，实际参数)
* 参数33：Object[] args :方法实际参数
*
*/
UserService proxService = (UserService)Proxy.newProxyInstance(
MyBeanFactory.class.getClassLoader(),
userService.getClass().getInterfaces(),
new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
if("addUser"==method.getName()){
//前执行
myAspect.before();
//执行目标类的方法
Object obj = method.invoke(userService, args);
//后执行
myAspect.after();
return obj;
}else{
return method.invoke(userService, args);
}
}
});
return proxService;
}
}
public class TestJDK {
@Test
public void demo01(){
UserService userService = MyBeanFactory.createService();
userService.addUser();
userService.updateUser();
userService.deleteUser();
}
}
运行结果，
鸡首
a_proxy.a_jdk addUser
牛后
a_proxy.a_jdk updateUser
a_proxy.a_jdk deleteUser
我在我的代理类中，根据method的方法名称，进行判断，如果方法名称是addUser，那么我执行增强，也就是加入通知。
说完了jdk的动态代理，下面我们说一下使用cglib的动态代理
首先，我们在使用spring的时候，spring的core帮我们整合的了cglib的核心jar，我们在使用cglib的时候，cglib不是像jdk的动态代理，他实现代理类，不需要借口，其次，他的代理类本质上时候被代理的子类，通过继承的方式，来实现增强。下面我们看一下代码。
public class MyBeanFactory {
public static UserServiceImpl createService(){
//1 目标类
final UserServiceImpl userService = new UserServiceImpl();
//2切面类
final MyAspect myAspect = new MyAspect();
// 3.代理类 ，采用cglib，底层创建目标类的子类
//3.1 核心类
Enhancer enhancer = new Enhancer();
//3.2 确定父类
enhancer.setSuperclass(userService.getClass());
/* 3.3 设置回调函数 , MethodInterceptor接口 等效 jdk InvocationHandler接口
* intercept() 等效 jdk invoke()
* 参数1、参数2、参数3：以invoke一样
* 参数4：methodProxy 方法的代理
*
*
*/
enhancer.setCallback(new MethodInterceptor(){
@Override
public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
//前增强
myAspect.before();
//执行目标类的方法
Object obj = method.invoke(userService, args);
// * 执行代理类的父类 ，执行目标类 （目标类和代理类 父子关系）
methodProxy.invokeSuper(proxy, args);
//后增强
myAspect.after();
return obj;
}
});
//3.4 创建代理
UserServiceImpl proxService = (UserServiceImpl) enhancer.create();
return proxService;
}
}
只要把上面的接口删掉，就可以，剩余的代码完全相同，下面我来说一下，使用cglib主要是对enhancer的核心类进行操作，enhancer的中文意思是增强的意思，我们首先创建一个enhance对象。然后对enhancer对象进行封装。
使用AspectJ进行动态代理
public class MyAspect {
public void myBefore(JoinPoint joinPoint){
System.out.println("前置通知 ： " + joinPoint.getSignature().getName());
}
public void myAfterReturning(JoinPoint joinPoint,Object ret){
System.out.println("后置通知 ： " + joinPoint.getSignature().getName() + " , -->" + ret);
}
public Object myAround(ProceedingJoinPoint joinPoint) throws Throwable{
System.out.println("前");
//手动执行目标方法
Object obj = joinPoint.proceed();
System.out.println("后");
return obj;
}
public void myAfterThrowing(JoinPoint joinPoint,Throwable e){
System.out.println("抛出异常通知 ： " + e.getMessage());
}
public void myAfter(JoinPoint joinPoint){
System.out.println("最终通知");
}
}
public interface UserService {
public void addUser();
public String updateUser();
public void deleteUser();
}
public class UserServiceImpl implements UserService {
@Override
public void addUser() {
System.out.println("d_aspect.a_xml addUser");
}
@Override
public String updateUser() {
System.out.println("d_aspect.a_xml updateUser");
int i = 1/ 0;
return "阳志就是屌";
}
@Override
public void deleteUser() {
System.out.println("d_aspect.a_xml deleteUser");
}
}
<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">
<!-- 1 创建目标类 -->
<bean id="userServiceId" class="com.itheima.d_aspect.a_xml.UserServiceImpl"></bean>
<!-- 2 创建切面类（通知） -->
<bean id="myAspectId" class="com.itheima.d_aspect.a_xml.MyAspect"></bean>
<!-- 3 aop编程
<aop:aspect> 将切面类 声明“切面”，从而获得通知（方法）
ref 切面类引用
<aop:pointcut> 声明一个切入点，所有的通知都可以使用。
expression 切入点表达式
id 名称，用于其它通知引用
-->
<aop:config>
<aop:aspect ref="myAspectId">
<aop:pointcut expression="execution(* com.itheima.d_aspect.a_xml.UserServiceImpl.*(..))" id="myPointCut"/>
<!-- 3.1 前置通知
<aop:before method="" pointcut="" pointcut-ref=""/>
method : 通知，及方法名
pointcut :切入点表达式，此表达式只能当前通知使用。
pointcut-ref ： 切入点引用，可以与其他通知共享切入点。
通知方法格式：public void myBefore(JoinPoint joinPoint){
参数1：org.aspectj.lang.JoinPoint 用于描述连接点（目标方法），获得目标方法名等
例如：
<aop:before method="myBefore" pointcut-ref="myPointCut"/>
-->
<!-- 3.2后置通知 ,目标方法后执行，获得返回值
<aop:after-returning method="" pointcut-ref="" returning=""/>
returning 通知方法第二个参数的名称
通知方法格式：public void myAfterReturning(JoinPoint joinPoint,Object ret){
参数1：连接点描述
参数2：类型Object，参数名 returning="ret" 配置的
例如：
<aop:after-returning method="myAfterReturning" pointcut-ref="myPointCut" returning="ret" />
-->
<!-- 3.3 环绕通知
<aop:around method="" pointcut-ref=""/>
通知方法格式：public Object myAround(ProceedingJoinPoint joinPoint) throws Throwable{
返回值类型：Object
方法名：任意
参数：org.aspectj.lang.ProceedingJoinPoint
抛出异常
执行目标方法：Object obj = joinPoint.proceed();
例如：
<aop:around method="myAround" pointcut-ref="myPointCut"/>
-->
<!-- 3.4 抛出异常
<aop:after-throwing method="" pointcut-ref="" throwing=""/>
throwing ：通知方法的第二个参数名称
通知方法格式：public void myAfterThrowing(JoinPoint joinPoint,Throwable e){
参数1：连接点描述对象
参数2：获得异常信息，类型Throwable ，参数名由throwing="e" 配置
例如：
<aop:after-throwing method="myAfterThrowing" pointcut-ref="myPointCut" throwing="e"/>
-->
<!-- 3.5 最终通知 -->
<aop:after method="myAfter" pointcut-ref="myPointCut"/>
</aop:aspect>
</aop:config>
</beans>
相关推荐
主要对Spring AOP的相关概念和简单的静态代理、动态代理以及常见的几种AOP配置方式做总结学习。主要包括：1. AOP的常见概念 2. 静态代理 3. jdk动态代理 4. Aspectj and Aspectjweaver 5. **aop-config** 6. CGLIB ...
3、如果目标对象没有实现了接口，必须采用CGLIB库，spring会自动在JDK动态代理和CGLIB之间转换 如何强制使用CGLIB实现AOP？ * 添加CGLIB库，SPRING_HOME/cglib/*.jar * 在spring配置文件中加入<aop:aspectj-...
如果一个类实现了一个或多个接口，那么Spring就会使用默认的JDK动态代理，如果没有实现任何接口，就会使用cglib来代理。当然我们也可以手动改变这些设置。这也是比较容易掉坑的部分，如果设置错了代理方式，那么在...
动态代理是实现AOP的基础，它通过JDK动态代理或CGLIB代理生成被代理对象的子类。通知是织入到目标对象连接点上的一段程序，例如@Before、@After等。 切点定义了通知应该在哪些连接点上触发。而切面则是通知和切点的...
Spring常见知识点 - 什么是Spring Framework? - Spring的优缺点 - Spring的优点 - Spring的缺点 ... - AspectJ AOP 和 Spring AOP的区别? - cglib动态代理和jdk动态代理的区别? Spring常见知识
spring2.5学习PPT 传智博客 01_全面阐释Spring及其各项功能 02_搭建与测试Spring的开发环境 03_编码剖析Spring管理Bean的原理 ... 32.Struts+Spring+JPA集成 33.使用Spring集成Struts2 34.所有源码
jdk和cglib实现的AOP实际上会在内存生成动态代理对象，还有什么其他办法实现AOP？经提示答出AspectJ以及实现原理 Spring中的对象的作用域 Singleton对象引用Prototype会发生什么 项目中怎样使用微服务？ 两个服务...
1. 定义一个MyClass类（或接口），包括math()、english()和physics()方法，可以简单模拟输出：上数学课/英语课/物理...请选择使用JDK动态代理、CGLIB代理、ProxyFactoryBean或者AspectJ中的某一种方式来实现增强处理。
1.10 基于JDK动态代理和CGLIB动态代理的实现Spring注解管理事务（@Trasactional）到底有什么区别。 1.11 在spring中获取代理对象代理的目标对象工具类 1.12 如何为spring代理类设置属性值 1.13 我对SpringDAO层支持...
AOP（Aspect Orient Programming），也就是面向方面编程，作为面向对象编程的一种补充，专门用于...而动态代理则在运行时借助于 JDK 动态代理、CGLIB 等在内存中“临时”生成 AOP 动态代理类，因此也被称为运行时增强。
6.4.2. Spring AOP中使用@AspectJ还是XML？ 6.5. 混合切面类型 6.6. 代理机制 6.7. 编程方式创建@AspectJ代理 6.8. 在Spring应用中使用AspectJ 6.8.1. 在Spring中使用AspectJ来为domain object进行依赖注入 ...
使用AspectJ的Spring Boot Source Weaving（编译时）示例 这是一个使用AspectJ进行Spring Boot源编织（编译时）的示例。 源编织 当所有源代码（包括注释类，方面类和目标类）都可用时，AspectJ源编织是编译时编织。 ...
7.5.3. 基于JDK和CGLIB的代理 7.5.4. 对接口进行代理 7.5.5. 对类进行代理 7.5.6. 使用“全局”advisor 7.6. 简化代理定义 7.7. 使用ProxyFactory通过编程创建AOP代理 7.8. 操作被通知对象 7.9. 使用“自动代理...
7.5.3. 基于JDK和CGLIB的代理 7.5.4. 对接口进行代理 7.5.5. 对类进行代理 7.5.6. 使用“全局”通知器 7.6. 简化代理定义 7.7. 使用ProxyFactory通过编程创建AOP代理 7.8. 操作被通知对象 7.9. 使用“自动...
7.5.3. 基于JDK和CGLIB的代理 7.5.4. 对接口进行代理 7.5.5. 对类进行代理 7.5.6. 使用“全局”advisor 7.6. 简化代理定义 7.7. 使用ProxyFactory通过编程创建AOP代理 7.8. 操作被通知对象 7.9. 使用“自动...
7.5.3. 基于JDK和CGLIB的代理 7.5.4. 对接口进行代理 7.5.5. 对类进行代理 7.5.6. 使用“全局”通知器 7.6. 简化代理定义 7.7. 使用ProxyFactory通过编程创建AOP代理 7.8. 操作被通知对象 7.9. 使用“自动...
10.5.2 Hibernate+Spring JDBC混合框架的事务管理 10.6 特殊方法成漏网之鱼 10.6.1 哪些方法不能实施Spring AOP事务 10.6.2 事务增强遗漏实例 10.7 数据连接泄漏 10.7.1 底层连接资源的访问问题 10.7.2 Spring JDBC...
10.5.2 Hibernate+Spring JDBC混合框架的事务管理 10.6 特殊方法成漏网之鱼 10.6.1 哪些方法不能实施Spring AOP事务 10.6.2 事务增强遗漏实例 10.7 数据连接泄漏 10.7.1 底层连接资源的访问问题 10.7.2 Spring JDBC...
修改默认代理方法:<aop:aspectj-autoproxy proxy-target-class="true"/> 增强种类 前置通知 后置通知 异常通知 最终通知 环绕通知 注意:使用注解的方式,最终通知和后置通知顺序换了,建议使用环绕通知...