Spring框架学习笔记2---AOP

最新推荐文章于 2022-05-10 17:36:47 发布
最新推荐文章于 2022-05-10 17:36:47 发布
阅读量297 收藏
点赞数
文章标签： Spring学习笔记 AOP 面向切面编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40145104/article/details/102815383
版权

目录

1、AOP介绍

1.1、什么是Aop

1.2、AOP的的实现原理

1.3、AOP术语【掌握】

2、手动方式

2.1、JDK动态代理

2.1.1、目标类 

2.1.2、切面类：用于存储通知MyAspect

2.1.3、工厂类：编写工厂生成代理

2.1.4、测试类：

2.1.5、测试结果

2.1.6、jdk动态代理现象（设置断点查看）

2.2、CGLIB字节码增强

2.2.1、目标类（不需要实现接口，直接写类就行）

2.2.2、切面类

2.2.3、工厂类

2.2.4、测试类

2.2.5、测试结果

2.2.6、cglib字节码增强现象

3、AOP联盟通知类型

4、spring编写代理：半自动

4.1、目标类

4.2、切面类

4.3、配置文件

4.4、测试类

4.5、测试结果

5、spring的AOP编程：全自动【掌握】

5.1、目标类

5.2、切面类

5.3、配置文件

5.4、测试类

5.5、测试结果

6、aspect

 

1、AOP介绍

1.1、什么是Aop

  • AOP：是Aspect Oriented Programming的缩写，意思是面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP（面向对象编程）的延续，是软件开发中的一个热点，也是spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而是的业务逻辑各个部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。
  • AOP采取横向抽取机制，取代了传统纵向继承体系重复性代码
  • 经典的应用：性能监视、事务管理、安全检查、缓存、日志等
  • Spring AOP使用纯Java实现，不需要专门的编译过程和类加载器，在运行期通过代理方式向目标类织入增强代码
  • AspectJ是一个基于Java语言的AOP框架，spring2.0开始，Spring AOP引入对Aspect的支持，AspectJ扩展了Java语言，提供了专门的编译器，在编译时提供横向代码的织入

1.2、AOP的的实现原理

  • aop底层将采用代理机制进行实现
  • 接口 + 实现类：spring采用的是jdk的动态代理Proxy
  • 实现类：spring采用cglib字节码增强

1.3、AOP术语【掌握】

  • target：目标类，需要被代理的类
  • Jointpoint（连接点）：是指那些可能被拦截的方法。例如目标类的所有方法
  • PointCut（切入点）：已经被增强的连接点。（切入点是连接点的子集）
  • advice：通知 / 增强，增强的代码，例如
  • weaving（织入）：是指把增强advice应用到目标对象target来创建新的代理对象proxy的过程
  • proxy（代理类）：
  • Aspect（切面）：是切入点pointcut和通知advice· 的结合（一个线是一个特殊的面，即一个切入点和一个通知能组成一个特殊的面）

2、手动方式

2.1、JDK动态代理

  • JDK动态代理是对"装饰者"设计模式的简化。使用前提：必须有接口
  • jdk动态代理：
Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces,InvocationHandler h)

三个参数：

  • 参数1：loader，类加载器，动态代理类运行时创建，任何类都需要类加载器将其加载到内存

            方式1：当前类.Class().getClassLoader()

            方式2：目标类实例.getClass().getClassLoader()

  • 参数2 : interfaces，代理类需要实现的所有接口

            方式1：目标类实例.getClass().getInterfaces()

            方式2：new Class[]{目标类.Class}

  • 参数3 ： InvocationHandler 处理类，接口，必须进行实现，一般情况下，采用匿名内部类的方式。该接口中提供invoke方法，代理类的每一个方法执行的时，都将调用一次invoke方法，也有三个参数：

                    参数1：Object proxy：代理对象

                    参数2：Method method ：代理对象当前执行的方法的描述（反射）

                                     执行方法名：method.getName()

                                     执行方法：method.invoke(对象 实际参数)

                    参数3：Object[] args：方法实际参数

2.1.1、目标类 

//接口
public interface UserService {
	public void addUser();
	public void updateUser();
	public void deleteUser();
}
//实现类
public class UserServiceImpl implements UserService {
	@Override
	public void addUser() {
		// TODO 自动生成的方法存根
		System.out.println("add a user");
	}
	@Override
	public void updateUser() {
		// TODO 自动生成的方法存根
		System.out.println("upadte user");
	}
	@Override
	public void deleteUser() {
		// TODO 自动生成的方法存根
		System.out.println("delete a user");
	}
}

 

2.1.2、切面类：用于存储通知MyAspect

public class MyAspect {
	public void before() {
		System.out.println("before-method");
	}
	public void after() {
		System.out.println("after-method");
	}
}

 

2.1.3、工厂类：编写工厂生成代理

public class MyBeanFactory {
	public static UserService createUserService() {
		//1、目标类
		final UserService userService = new UserServiceImpl();
		//2、切面类
		final MyAspect myAspect = new MyAspect();
		/*3、代理类：将目标类（切入点）和切面类（通知）结合--->切面
		 * Proxy.newProxyInstance
		 *      参数1：loader，类加载器，动态代理类运行时创建，任何类都需要类加载器将其加载到内存
		 *      	一般情况下：当前类.class.getClassLoader()
		 *      			  目标类实例.getClass().getClassLoader()
		 *      参数2：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 {
						/*
						 * Object proxy:代理对象
						 * Method method：代理对象当前执行的方法描述
						 * Object[] args：方法实际参数
						 */
						//将目标类和切面类结合
						//前方法执行 
						System.out.println("**************************");
						myAspect.before();
						//执行目标类的方法
						String str = method.getName();
						System.out.println("当前执行的方法名是：" + str);
						Object obj = method.invoke(userService, args);
						//后方法执行
						myAspect.after();
						return null;
					}
				});
		return proxService;//返回代理对象
	}
}

 

2.1.4、测试类：

public class TestJDK {
	@Test
	public void demo01() {
		UserService userService = MyBeanFactory.createUserService();
		userService.addUser();
		userService.updateUser();
		userService.deleteUser();
	}
}

 

2.1.5、测试结果

2.1.6、jdk动态代理现象（设置断点查看）

2.2、CGLIB字节码增强

  • 没有接口，只能有实现类
  • 采用字节码增强框架，cglib，在运行时创建目标类的子类（继承），从而对目标类进行增强
  • 导入jar包

               方式1：核心：hibernate-distribution-3.6.10.Final\lib\bytecode\cglib-2.2.jar

                            依赖：struts-2.3.15.3\apps\struts2-blank\WEB-INF\lib\asm.3.3.jar

               方式2：spring-core.jar已经整合了以上两个内容

2.2.1、目标类（不需要实现接口，直接写类就行）

public class UserServiceImpl {
	public void addUser() {
		System.out.println("add a user");
	}
	public void updateUser() {
		System.out.println("update a user");
	}
	public void deleteUser() {
		System.out.println("delete a user");
	}
}

 

2.2.2、切面类

public class MyAspect {
	public void before() {
		System.out.println("before-method");
	}
	public void after() {
		System.out.println("after-method");
	}
}

 

2.2.3、工厂类

public class MyBeanFactory {
	public static UserServiceImpl createUserService(){
		//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接口
		enhancer.setCallback(new MethodInterceptor() {
		@Override
		public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
			/*
			 * intercept()等效于jdk中的 invoke()方法
			 * 参数1:代理对象
			 * 参数2:代理对象当前执行的方法描述（反射）
			 * 参数3：方法实际参数
			 * 参数4：方法的代理，
			 */
			System.out.println("****************************");
			//前方法
			myAspect.before();
			//执行目标类的方法
			Object obj = method.invoke(userService, args);
			//执行代理类的父类，执行目标类（目标类和代理类就是父子关系）
			methodProxy.invokeSuper(proxy, args);
			//后方法
			myAspect.after();
			return obj;
			}
			
		});
		//3.4 创建代理
		UserServiceImpl proxyService = (UserServiceImpl)enhancer.create();
		return proxyService;
	}
}

 

2.2.4、测试类

public class TestCglib {
	@Test
	public void demo() {
		UserServiceImpl userService = MyBeanFactory.createUserService();
		userService.addUser();
		userService.updateUser();
		userService.deleteUser();
	}
}

 

2.2.5、测试结果

2.2.6、cglib字节码增强现象

3、AOP联盟通知类型

  • AOP联盟为通知Advice定义了org.aopalliance.aop.Advice
  • Spring按照通知Advice在目标类方法的连接点位置，可以分为5类

1、前置通知 org.springframework.aop.MethodBeforeAdvice

  • 在目标方法执行前实施增强

2、后置通知 org.springframework.aop.AfterReturningAdvice

  • 在目标方法执行后实施增强

3、环绕通知 org.aopalliance.intercept.MethodInterceptor

  • 在目标方法执行前后实施增强（必须手动执行目标方法）
//环绕通知
try{
    //前置方法：可以阻止目标方法的执行
    //执行目标方法
    //后置通知：可以获得目标方法的返回值
}catch{
    //抛出异常通知
}

4、异常抛出通知 org.springframework.aop.ThrowsAdvice

  • 在方法抛出异常后实施增强（方法可以为前置、后置、环绕以及目标）

5、引介通知 org.springframework.aop.IntroductionInterceptor

  • 在目标类中添加一些新的方法和属性

4、spring编写代理：半自动

  • 让spring创建代理对象，从spring容器中手动的获取代理对象
  • 导入jar包

       核心：4+1（core、context、beans、expression）+logging

       AOP：AOP联盟（规范）、spring aop（实现）

AOP联盟：

六个jar包：

4.1、目标类

public interface UserService {
	public void addUser();
	public void updateUser();
	public void deleteUser();
}
public class UserServiceImpl implements UserService {
	@Override
	public void addUser() {
		System.out.println("add a user");
	}
	@Override
	public void updateUser() {
		System.out.println("update a user");
	}
	@Override
	public void deleteUser() {
		System.out.println("delete a user");
	}
}

 

4.2、切面类

/*
 * 切面类中确定通知，需要实现不同的接口，接口就是规范，从而就确定的方法的名称
 * 采用的是“环绕通知”：需要实现MethodInterceptor接口
 * 环绕通知 必须手动的执行目标方法
 */
public class MyAspect implements MethodInterceptor{

	@Override
	public Object invoke(MethodInvocation mi) throws Throwable {
		// TODO 自动生成的方法存根
		System.out.println("前");
		//手动执行目标方法:相当于通知spring执行目标方法
		Object obj = mi.proceed();
		System.out.println("后");
		return obj;
	}

}

 

4.3、配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    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.xsd">
	<!-- 创建目标类 -->
	<bean id = "userServiceId" class = "test_b_factory_bean.UserServiceImpl"></bean>
	<!-- 创建切面类 -->
	<bean id = "myAspectId" class = "test_b_factory_bean.MyAspect"></bean>
	<!-- 创建代理类
		*使用bean FactoryBean，底层调用getObject() 返回特殊bean
		*ProxyFactoryBean用于创建代理工厂bean，生成特殊的代理对象
		*再在该bean中配置
			*interfaces:确定接口们，通过<array>可以设置多个值，只有一个值的时候 使用value,值就是接口的全限定名
			*target:确定目标类
			*interceptorNames:通知切面类的名称,采用String[] 设置一个值采用的是value，设置多个值采用<array>
			*optimize:强制使用cglib
		底层机制：如果目标类有接口，采用jdk动态代理
				如果没有接口，采用cglib
				如果声明是optimize = true，无论是否有接口，都采用cglib
	 -->
	<bean id = "proxyUserServiceId" class = "org.springframework.aop.framework.ProxyFactoryBean">
		<property name = "interfaces" value = "test_b_factory_bean.UserService"></property>
		<property name = "target" ref = "userServiceId"></property>
		<property name = "interceptorNames" value = "myAspectId"></property>
		<property name = "optimize" value = "true"></property>
	</bean>	
</beans>

 

4.4、测试类

public class TestFactoryBean {
	@Test
	public void demo() {
		String xmlPath = "test_b_factory_bean/applicationContext.xml";
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext(xmlPath);
		//在这里获得代理类
		UserService userService = applicationContext.getBean("proxyUserServiceId",UserService.class);
		userService.addUser();
		userService.updateUser();
		userService.deleteUser();
	}
}

 

4.5、测试结果

5、spring的AOP编程：全自动【掌握】

  • 从spring容器中获得目标类，如果配置了AOP，Spring将自动的生成代理
  • 要确定目标类，aspectj切入点表达式，
  • 导入jar包

5.1、目标类

public interface UserService {
	public void addUser();
	public void updateUser();
	public void deleteUser();
}
public class UserServiceImpl implements UserService {
	@Override
	public void addUser() {
		System.out.println("add a user");
	}
	@Override
	public void updateUser() {
		System.out.println("update a user");	
	}
	@Override
	public void deleteUser() {
		System.out.println("delete a user");	
	}
}

 

5.2、切面类

public class MyAspect implements MethodInterceptor{
	@Override
	public Object invoke(MethodInvocation mi) throws Throwable {
		// TODO 自动生成的方法存根
		System.out.println("************************");
		System.out.println("前");
		Object obj = mi.proceed();
		System.out.println("后");
		return obj;
	}
}

 

5.3、配置文件

<?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" 
    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 = "test_c_spring_aop.UserServiceImpl"></bean>
    <!-- 2、切面类 -->
    <bean id = "myAspectId" class = "test_c_spring_aop.MyAspect"></bean>
    <!-- 3、aop 
    3.1 导入命名空间
    3.2 使用<aop:config>进行配置
    	proxy-target-class = "true"：声明式使用cglib代理
    	有接口是jdk动态代理，没有接口cglib代理
    	<aop:pointcut>：切入点，从目标对象获得具体方法
    	<aop:advisor>：特殊的切面，只有一个通知和一个切入点
    		advice-ref : 通知引用（通知在切面类中）
    		pointcut-ref ：切入点引用
    3.3 切入点表达式
    	execution(* test_c_spring_aop.  *.  *     (...))
    	选择方法     返回值任意  包                         类名任意  方法名任意 参数任意
    -->
    <aop:config proxy-target-class = "true">
    	<aop:pointcut expression="execution(* test_c_spring_aop.*.*(..))" id="myPointCut"/>
    	<aop:advisor advice-ref="myAspectId" pointcut-ref="myPointCut"/>
    </aop:config>
</beans>

 

5.4、测试类

public class TestSpringAop {
	@Test
	public void demo() {
		String xmlPath = "test_c_spring_aop/applicationContext.xml";
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext(xmlPath);
		UserService userService = (UserService) applicationContext.getBean("userServiceId");
		userService.addUser();
		userService.updateUser();
		userService.deleteUser();
	}
}

 

5.5、测试结果

 

SpringSnow0403
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
SpringAOP学习笔记
01-27
AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性...
Spring学习笔记-cqupt
最新发布
03-19
在本篇 Spring 学习笔记中，我们将探讨 Spring 的入门、优点、组成以及重要的IOC理论。 1. **Spring 简介** Spring 是一个开源的、免费的 Java 框架，它的目标是减少企业级开发的复杂性。它集成了许多现有的技术，...
SpringFramework之ProxyFactory
choubayan4320的博客
07-13 229
Spring版本是5.0.4.release. ProxyFactory在Springaop中占有举足轻重的地位，用来间接创建代理，如下List-1所示，我们给ServiceImpl创建代理。 List-1 public interface IService { ...
Spring基于注解开发的注解使用之AOP（部分源代码分析）
qqzhengwei的专栏
01-27 264
AOP底层实现动态代理 1、导入spring-aop包依赖 <!--aopV1--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-aop</artifactId> <scope>test</scope> </dependency> <!--ao
Spring Aop - 使用ProxyFactoryBean实现Aop原理-第八篇
阿健小站
05-11 769
概述 使用ProxyFactoryBean来演示如何生成一个代理对象，并执行aop的过程，ProxyFactoryBean即前文交待的FactoryBean的子类，这里可以再回忆下FactoryBean与BeanFactory的区别，具体文章：https://blog.csdn.net/y510662669/article/details/105664281 ProxyFactoryBean见文知意，即用来生成代理的工厂bean。生成的bean是一个代理bean。 类结构 ProxyConfig
可视化与代码说明jdk动态代理与cglib动态代理--InvocationHandler--MethodInterceptor
老专家的博客
10-31 2076
动态代理是为了实现Aop编程，代理的是类对象 【jdk动态代理】被代理的类需要实现接口，针对接口的代理，通过生成一个实现了接口的动态类实现代理 ServiceImpl是被代理类，实现接口ServiceInterface JDKProxy是代理处理方法类，实现接口InvocationHandler 通过JDKProxy.bind()得到jdk【动态】生成代理类ServiceProxy 当你调用Se...
Spring interceptor
寒塘鹤影
11-18 2012
1 Spring的通知类型 现在让我们看看Spring AOP是如何处理通知的。 1.1. 通知的生命周期 Spring的通知可以跨越多个被通知对象共享，或者每个被通知对象有自己的通知。这分别对应 per-class或per-instance 通知。 Per-class通知使用最为广泛。它适合于通用的通知，如事务adisor。它们不依赖被代理 的对象的状态，也不添加新的状态。它们仅仅作用于
马士兵老师spring框架学习笔记
02-28
马士兵老师是知名的Java教育专家，他的Spring框架学习笔记深入浅出，对于初学者和进阶者来说都是一份宝贵的资源。这份笔记涵盖了Spring的核心概念、配置、AOP（面向切面编程）、DI（依赖注入）等关键知识点。 1. **...
Spring Boot核心技术-笔记
12-05
以上仅是Spring Boot众多特性和功能的一部分，实际的笔记可能还会涵盖更多细节，如AOP（面向切面编程）、WebSocket支持、缓存管理、邮件服务、任务调度等。这些知识对于理解和实践Spring Boot开发至关重要。通过深入...
java笔记 Java-Web笔记 J2EE三大框架笔记
10-19
Spring框架是目前最流行的Java企业级应用框架，提供依赖注入（DI）和面向切面编程（AOP），简化了组件的装配和管理。Struts是MVC（Model-View-Controller）架构的实现，负责控制应用程序流程，处理用户请求。...
SpringAOP的实现（三）
A2460865183的博客
02-29 160
Spring中的org.springframework.aop.framework.ProxyFactoryBean是创建AOP的最基本的方式之一。 IUserService接口 package com.qfedu.aop03; import java.util.List; /** * Created by HuangCong on 2020/2/26. */ public inter...
基于spring security及spring aop的权限控制
silyvin
06-15 3508
首先，获取spring security的当前用户： http://blog.csdn.net/tomcat_2014/article/details/50725723 .Java代码中使用 [java] view plain copy UserDetails userDetails = (UserDetails) Securit
spring方法拦截器 MethodInterceptor
tao_wei162的博客
01-03 939
使用到spring方法拦截器 MethodInterceptor实现权限控制，MethodInterceptor可以使用通配符，并且是基于注解的。 简单例子代码如下： 1、定义需要拦截的类 Java代码 收藏代码 public class LoginAction{ //没有权限限制 @Requ...
JDK动态代理与CGLIB动态代理
weixin_43529092的博客
04-02 3045
设计模式之代理模式 下面假设一个常见的场景，假如你有一个法国的朋友叫Aice，有一天你想要购买一瓶法国香奈儿的香水，这种香水只在法国销售。你找到你的朋友Alice，请求她帮忙购买一瓶香奈儿的香水，你的朋友Alice于是乎就找到香奈儿的销售店购买了一瓶法国香奈儿的香水，并将香水交给了你。 在上面这个例子当中，你想要购买法国香水，但是无法直接向香奈儿供应商购买，只能通过中间人(Alice)购买，这就是我们生活中比较常见的代理模式。我们假设有一天，你突然想要一瓶法国红酒，但是由于Alice本身并不具备购买红
动态代理
guen12345的博客
12-16 96
动态代理 动态代理和静态代理角色是一样的 动态代理的代理类是自动生成的，不是直接写好的（相当于一个万能对象） 动态代理分类两类：基于接口和基于类 基于接口：jdk原生（invocationHandler） 基于类：cglib java字节码：javasist jdk原生 jdk提供了invocationHandler接口和Proxyl类 动态生成代理类 //动态生成代理对象 public class Handel implements InvocationHandler { //被代理的接口
17.Java核心——方法
qq_45938466的博客
11-14 122
Java核心——方法 知识大纲 方法的概述 方法的格式 方法的定义 方法的调用（含调用图解） 定义方法的注意事项 小案例 方法的概述 方法的格式 方法的定义 方法的调用 package edu.hunau.cxb19.MathDemo; /** * @author yf * @create 2020-11-14 下午 04:57 */ /* 方法的定义格式： 修饰符 返回值的类型 方法名 (参数类型 参数名1，参数类型 参数名2...){ 方法体语句；
Spring方法拦截器MethodInterceptor
热门推荐
淡淡的倔强的博客
05-12 3万+
前言实现MethodInterceptor 接口，在调用目标对象的方法时，就可以实现在调用方法之前、调用方法过程中、调用方法之后对其进行控制。MethodInterceptor 接口可以实现MethodBeforeAdvice接口、AfterReturningAdvice接口、ThrowsAdvice接口这三个接口能够所能够实现的功能，但是应该谨慎使用MethodInterceptor 接口，很可能
Java Cglib 动态代理intercept的参数含义
yytree123的博客
05-10 1202
如何使用CGLIB创建动态代理，网上已经有很多资料，这里就不再赘述。 直接说结论。 当我们使用自定义类 private static class MethodInterceptorImpl implements MethodInterceptor { private Object target; public MethodInterceptorImpl(Object object){ this.target= object; } @Overrid

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值