Spring_AOP_Proxy AOP动态代理的实现 .

最新推荐文章于 2024-07-08 16:53:33 发布
最新推荐文章于 2024-07-08 16:53:33 发布
阅读量403 收藏
点赞数
分类专栏： Spring 文章标签： aop spring

Spring_AOP_Proxy AOP动态代理的实现 ：

动态代理指的是通过一个代理对象来创建需要的业务对象，然后在这个代理对象中统一进行各种需求的处理。
1.写一个实现相应的InvocationHandler 接口
2.创建要代理的对象

3.创建一个方法生成对象,这个方法的参数是要代理的对象，getInstance 所返回的对象就是代理对象

3.1 创建LogProxy对象

3.2设置这个代理对象

3.3 通过Proxy的方法创建代理对象，

第一个参数是要代理对象的classLoader第二个参数是要代理对象实现的所有接口，

第三个参数是实现类InvocationHander 的对象此时的result就是一个代理的对象，代理的是object

具体实现过程：

在 Spring_AOP_Proxy AOP静态代理的实现 的基础上，修改log包名为proxy，并创建LogProxy代理类并实现接口InvocationHandler：

[java] view plain copy print ?
  1. package com.spring.proxy;  
  2.   
  3. import java.lang.reflect.Method;  
  4.   
  5. import org.springframework.cglib.proxy.InvocationHandler;  
  6. import org.springframework.cglib.proxy.Proxy;  
  7.   
  8. import com.spring.model.LogInfo;  
  9.   
  10. /** 
  11.  * 1.写一个类实现InvocationHandler 接口 
  12.  *  
  13.  * @author sunlight 
  14.  * 
  15.  */  
  16. public class LogProxy implements InvocationHandler {  
  17.   
  18.     // 2.创建一个代理对象   
  19.     private Object target;  
  20.   
  21.     // 3.创建一个方法生成对象,这个方法的参数是要代理的对象，getInstance 所返回的对象就是代理对象   
  22.     public static Object getInstance(Object object) {  
  23.   
  24.         // 3.1 创建LogProxy对象   
  25.         LogProxy proxy = new LogProxy();  
  26.   
  27.         // 3.2设置这个代理对象   
  28.         proxy.target = object;  
  29.   
  30.         // 3.3 通过Proxy的方法创建代理对象，第一个参数是要代理对象的classLoader   
  31.         // 第二个参数是要代理对象实现的所有接口，第三个参数是实现类InvocationHander 的对象   
  32.         // 此时的result就是一个代理的对象，代理的是object   
  33.         Object result = Proxy.newProxyInstance(object.getClass()  
  34.                 .getClassLoader(), object.getClass().getInterfaces(), proxy);  
  35.         return result;  
  36.     }  
  37.   
  38.     /** 
  39.      * 当有了代理对象之后，不管这个代理对象执行什么方法，都会调用以下的invoke方法 
  40.      */  
  41.     @Override  
  42.     public Object invoke(Object proxy, Method method, Object[] args)  
  43.             throws Throwable {  
  44.   
  45.         if (method.getName().equals("add") || method.getName().equals("delete")  
  46.                 || method.getName().equals("update")) {  
  47.             Logger.info("进行了相应的操作——通过方法名称（方法执行前）");  
  48.         }  
  49.   
  50.         Object obj = method.invoke(target, args);  
  51.           
  52.         if(method.isAnnotationPresent(LogInfo.class)){  
  53.             LogInfo li=method.getAnnotation(LogInfo.class);  
  54.             Logger.info(li.value()+"（方法执行后）");  
  55.         }  
  56.           
  57.         return obj;  
  58.     }  
  59.   
  60. }  
package com.spring.proxy;

import java.lang.reflect.Method;

import org.springframework.cglib.proxy.InvocationHandler;
import org.springframework.cglib.proxy.Proxy;

import com.spring.model.LogInfo;

/**
 * 1.写一个类实现InvocationHandler 接口
 * 
 * @author sunlight
 *
 */
public class LogProxy implements InvocationHandler {

	// 2.创建一个代理对象
	private Object target;

	// 3.创建一个方法生成对象,这个方法的参数是要代理的对象，getInstance 所返回的对象就是代理对象
	public static Object getInstance(Object object) {

		// 3.1 创建LogProxy对象
		LogProxy proxy = new LogProxy();

		// 3.2设置这个代理对象
		proxy.target = object;

		// 3.3 通过Proxy的方法创建代理对象，第一个参数是要代理对象的classLoader
		// 第二个参数是要代理对象实现的所有接口，第三个参数是实现类InvocationHander 的对象
		// 此时的result就是一个代理的对象，代理的是object
		Object result = Proxy.newProxyInstance(object.getClass()
				.getClassLoader(), object.getClass().getInterfaces(), proxy);
		return result;
	}

	/**
	 * 当有了代理对象之后，不管这个代理对象执行什么方法，都会调用以下的invoke方法
	 */
	@Override
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {

		if (method.getName().equals("add") || method.getName().equals("delete")
				|| method.getName().equals("update")) {
			Logger.info("进行了相应的操作——通过方法名称（方法执行前）");
		}

		Object obj = method.invoke(target, args);
		
		if(method.isAnnotationPresent(LogInfo.class)){
			LogInfo li=method.getAnnotation(LogInfo.class);
			Logger.info(li.value()+"（方法执行后）");
		}
		
		return obj;
	}

}

修改配置文件，添加LogProxy的注入：

[html] view plain copy print ?
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <beans xmlns="http://www.springframework.org/schema/beans"  
  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"  
  4.     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd  
  5.         http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd">  
  6.       
  7.     <!-- 打开Spring的Annotation的支持 -->  
  8.     <context:annotation-config />  
  9.     <!-- 设定Spring去哪些包中找Annotation -->  
  10.     <context:component-scan base-package="com.spring" />  
  11.       
  12.     <bean id="userDynamicDao" class="com.spring.proxy.LogProxy" factory-method="getInstance">  
  13.         <constructor-arg ref="userDao"/>  
  14.     </bean>  
  15.       
  16. </beans>  
<?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"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd">
	
	<!-- 打开Spring的Annotation的支持 -->
	<context:annotation-config />
	<!-- 设定Spring去哪些包中找Annotation -->
	<context:component-scan base-package="com.spring" />
	
	<bean id="userDynamicDao" class="com.spring.proxy.LogProxy" factory-method="getInstance">
		<constructor-arg ref="userDao"/>
	</bean>
	
</beans>

修改UserService注入userDynamicDao：

[java] view plain copy print ?
  1. package com.spring.service;  
  2.   
  3. import javax.annotation.Resource;  
  4.   
  5. import org.springframework.stereotype.Component;  
  6. import org.springframework.stereotype.Service;  
  7.   
  8. import com.spring.dao.IUserDao;  
  9. import com.spring.model.User;  
  10.   
  11. //@Component(value="userService")   
  12. @Service("userService")     //业务层一般用@Service注入   
  13. public class UserService implements IUserService {  
  14.     private IUserDao userDao;  
  15.       
  16.     public IUserDao getUserDao() {  
  17.         return userDao;  
  18.     }  
  19.       
  20.     //默认通过名称注入，在JSR330中提供了@Inject来注入   
  21.     //@Resource(name="userProxyDao")    //此处用代理类注入   
  22.     @Resource(name="userDynamicDao")  
  23.     public void setUserDao(IUserDao userDao) {  
  24.         this.userDao = userDao;  
  25.     }  
  26.   
  27.     @Override  
  28.     public void add(User user) {  
  29.         userDao.add(user);  
  30.     }  
  31.   
  32.     @Override  
  33.     public void delete(int id) {  
  34.         userDao.delete(id);  
  35.     }  
  36.   
  37.     @Override  
  38.     public User load(int id) {  
  39.         return userDao.load(id);  
  40.     }  
  41.   
  42. }  
package com.spring.service;

import javax.annotation.Resource;

import org.springframework.stereotype.Component;
import org.springframework.stereotype.Service;

import com.spring.dao.IUserDao;
import com.spring.model.User;

//@Component(value="userService")
@Service("userService")		//业务层一般用@Service注入
public class UserService implements IUserService {
	private IUserDao userDao;
	
	public IUserDao getUserDao() {
		return userDao;
	}
	
	//默认通过名称注入，在JSR330中提供了@Inject来注入
	//@Resource(name="userProxyDao")	//此处用代理类注入
	@Resource(name="userDynamicDao")
	public void setUserDao(IUserDao userDao) {
		this.userDao = userDao;
	}

	@Override
	public void add(User user) {
		userDao.add(user);
	}

	@Override
	public void delete(int id) {
		userDao.delete(id);
	}

	@Override
	public User load(int id) {
		return userDao.load(id);
	}

}



编写简单的注解 LogInfo：

[java] view plain copy print ?
  1. package com.spring.model;  
  2.   
  3. import java.lang.annotation.Retention;  
  4. import java.lang.annotation.RetentionPolicy;  
  5.   
  6. @Retention(RetentionPolicy.RUNTIME)  
  7. public @interface LogInfo {  
  8.     public String value() default "";  
  9. }  
package com.spring.model;

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;

@Retention(RetentionPolicy.RUNTIME)
public @interface LogInfo {
	public String value() default "";
}

IUserDao接口添加注解，添加了LogInfo注解的方法可以为其添加日志。
[java] view plain copy print ?
  1. package com.spring.dao;  
  2.   
  3. import com.spring.model.LogInfo;  
  4. import com.spring.model.User;  
  5.   
  6. public interface IUserDao {  
  7.     @LogInfo("添加了用户信息——注解方式")  
  8.     public void add(User user);  
  9.     @LogInfo("删除了用户信息——注解方式")  
  10.     public void delete(int id);  
  11.     public User load(int id);  
  12. }  
package com.spring.dao;

import com.spring.model.LogInfo;
import com.spring.model.User;

public interface IUserDao {
	@LogInfo("添加了用户信息——注解方式")
	public void add(User user);
	@LogInfo("删除了用户信息——注解方式")
	public void delete(int id);
	public User load(int id);
}

以上是动态代理的2中实现：

1.通过方法名称来添加日志；

2.通过注解方式来添加日志；

注意，AOP的动态代理实现，添加日志操作可以在方法执行前，也可以在方法执行后，本例 方法前使用 1 来添加日志，方法后使用 2 来添加日志。

测试结果如下：



huangqiang12
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Aop和动态代理的使用
weixin_44720982的博客
07-08 321
JDK和CjLib动态代理，AOP的使用
AOP动态代理完整过程（超基础，超详细）
woongcha的博客
05-14 1478
AOP 动态代理 租房的时候，房屋中介就是代理（筛选符合自己要求的房子，再供自己选择）。 代理也需要和自己有相同的所有能力（自己有看房的能力，中介也有）。 在程序中，代理是一个对象。这个对象由一个类产生，这个类本身就是动态产生。 这个类本身不会被创建，在程序运行时动态产生。 InvocationHandler提供生成代理类的功能，InvocationHandler不是代理类，是帮助生成动态代理类的一个类。 代码分析 public class MyInvocationHandler imp
SpringAOP动态代理小结
黑猫小长的博客
03-02 903
学习springAOP时，顺便学习了jdk与cglb动态代理，jdk与cglb动态代理最大不同之处就是jdk动态代理是基于接口的，如果有的项目不是基于接口又想实现动态代理，就需要cglb动态代理，这里总结下AOP的动态代理。 springAOP动态代理实现方式 是基于jdk与cglb的，就是选它们一种来实现。这里涉及两个属性proxyTargetClass属性，若为true，则是面向类动态代理，
【啃啊啃 Spring5 源码】细碎三：AOP两种动态代理的区别
大树的学习之路
08-19 897
spring 中 AOP是基于 “动态代理” 实现，其采用了两种方式： java代理：采用java内置的代理API实现 cglib代理：采用第三方API实现 本文主要阐述这两种方式的区别 动态代理和静态代理 静态代理：编译时将增强代码植入class文件，因为是编译期进行的增强，所以代码运行时效率比动态代理高。使用Aspect可以实现静态代理。 动态代理：运行时生成代理类并加载，效...
spring AOP动态代理使用和配置方式（手打）
南北雪树的专栏
04-15 5257
理论的东西，随便看下吧， AOP是OOP的延续，是Aspect Oriented Programming的缩写，意思是面向切面编程。可以通过预编译方式和运行期动态代理实现在不修改源代码的情况下给程序动态统一添加功能的一种技术。AOP实际是GoF设计模式的延续，设计模式孜孜不倦追求的是调用者和被调用者之间的解耦，AOP可以说也是这种目标的一种实现。 我们现在做的一些非业务，如：日志、
spring_AOP.rar_876.aop_java aop_spring_aop
09-14
1. Spring_AOP_DynProxy：这可能包含有关Spring动态代理的资料，Spring使用JDK动态代理或CGLIB来创建代理对象，实现AOP的功能。 2. ch20_aop_annotation：这部分内容可能是关于使用注解来定义和实现切面的教程。 3. ...
spring_aop.rar_spring_aop
09-19
7. **代理（Proxy）**：Spring AOP通过代理来实现对目标对象的拦截。有JDK动态代理和CGLIB代理两种方式，前者基于接口，后者基于子类。 在"spring_aop.rar_spring_aop"这个实例工程中，可能包含了两个部分，"spring...
spring_aop1.rar_spring aop
09-22
5. **代理（Proxy）**：Spring AOP通过动态代理实现切面的功能。有两种类型的代理：JDK动态代理和CGLIB代理。JDK代理用于实现接口的类，而CGLIB代理用于不实现接口的类。 6. **织入（Weaving）**：织入是将切面应用...
spring-aop.rar_aop1270_spring_spring aop
09-23
Spring AOP的核心类包括`org.springframework.aop.framework.ProxyFactoryBean`、`org.springframework.aop.framework.ProxyFactory`、`org.springframework.aop.aspectj.autoproxy.AspectJAutoProxyCreator`等。...
Aop.rar_aop_java aop 例 proxy
09-21
本资源"Aop.rar"包含了一个关于Java AOP的实际应用示例，重点展示了三种主要的代理实现方式：CGLIB、Javassist和Java动态代理。让我们逐一深入了解这三种技术。 1. **CGLIB（Code Generation Library）**： CGLIB...
SpringBoot AOP动态代理的使用
qq_38677458的博客
05-25 254
https://www.jianshu.com/p/4d22ea402d14
AOP（JDK动态代理实现）
baiqi123456的博客
08-13 831
（1）采用JDK动态代理实现AOP必须要使代理类和被代理类实现同一个接口。 （2）代理类实现接口的方式是通过反射在内存中形成，然后在通过类加载器加载到方法区的。所以和我们平时通过implement进行实现的编写方式不一样，但底层原理一样。（3）我们最后调用方法时是调用代理类实现的方法，而代理类中的方法又调用了被代理类的方法。（1）定义一个接口名称为TaergetInterface，里面有一个方法f(int x,int y),该方法用于计算两数之和并输出。 （2）编写一个类实现这个接口，并实现这个方法f(i
动态代理
weixin_47216239的博客
08-19 208
1、Java.lang.reflect.Proxy类可以直接生成一个代理对象 Proxy.newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)生成一个代理对象 参数1:ClassLoader loader 代理对象的类加载器 一般使用被代理对象的类加载器 (表名你要用那个类加载器去加载生成的代理类。) 参数2:Class<?>[] interfaces 代理对象的要实现的接口
接口日志记录
SS__FF的博客
03-07 3492
1.添加配置（保证日志记录信息类能执行） &lt;!-- 接口日志记录 --&gt; &lt;aop:aspectj-autoproxy proxy-target-class="true"/&gt; &lt;bean class="com.epoint.baohan.bizlogic.util.LogAspect" /&gt; 2.注解类loginfo （在自己写的某...
动态代理实现AOP
当一堆用不熄灭的柴火
10-14 2101
今天说和小张哥一起讨论AOP，正好看到了相关的视频，今天就总结一下AOP是如何使用动态代理来实现的。AOP对JAVA程序员来说并不陌生，他是spring的一个核心内容——面向切面编程，先把概念放在这里，因为这一篇博客不会展开讲述AOP是什么，而是讲一讲他的来源——动态代理。我们先来看一个例子：有一个接口：UserManager，还有就是接口的实现类UserManagerImplUserManager
java动态代理对象实现日志的拦截（annotation自定义注解方式）
kevon_sun的专栏
04-02 6195
proxy动态代理的实现类package org.sunjs.proxy.main; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; import org.sunjs.proxy.annotation.LogAnnotatio...
spring AOP的实现原理
weixin_30340775的博客
06-26 187
姓名：陈中娇 班级：软件151 基于代理(Proxy)的AOP实现 首先，这是一种基于代理(Proxy)的实现方式。下面这张图很好地表达了这层关系： 这张图反映了参与到AOP过程中的几个关键组件(以@Before Advice为例)： 调用者Beans - 即调用发起者，它只知道目标方法所在Bean，并不清楚代理以及Advice的存在 目标方法所在Bean - 被调...
5.Spring AOP及动态代理
一介书生
01-27 8340
1. Spring AOP简介 1.1 什么是AOP AOP的全称是Aspect-Oriented Programming，即面向切面编程（也称面向方面编程）。它是面向对象编程（OOP）的一种补充，目前已成为一种比较成熟的编程方式。 在传统的业务处理代码中，通常都会进行事务处理、日志记录等操作。虽然使用OOP可以通过组合或者继承的方式来达到代码的重用，但如果要实现某个功能（如日志记录），同样的代码...
Spring Security的Filter
最新发布
weixin_44263023的博客
07-08 705
如果你需要实现一些 Spring Security 没有提供的特定安全功能，你可以通过实现 javax.servlet.Filter 接口来创建自定义的过滤器，并使用 Spring Security 的 FilterRegistrationBean 或通过 Spring Security 的配置类将其添加到过滤器链中。
spring.aop.proxy-target-class 启动 栈溢出
05-25
如果你在应用程序中启用了 `spring.aop.proxy-target-class`，并且代理的目标类没有实现接口，那么 Spring AOP 将会使用 CGLIB 来创建代理对象。但是，CGLIB 代理可能会导致栈溢出的问题，因为它使用了大量的反射和...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值