第15讲 --使用JDK中的Proxy技术实现AOP功能

 

 

当目标类实现了接口,我们可以使用jdk的Proxy来生成代理对象。

下面我们使用jdk的aop技术为 PersionServiceBean (它本身实现了一个接口)  来产生一个代理对象

 

主要业务:当user对象不为空的时候我们才调用业务方法,否则什么也不做

 

步骤:

 

(1) 建立接口类  PersionSevice

 

package cn.com.xinli.service;


public interface PersionSevice
{
	public void save(String name);
	public void update(String name, Integer personid);
	public String getPersonName(Integer personid);
	
}

 

 

(2)建立实现类 PersionServiceBean

 

package cn.com.xinli.service.impl;

import org.apache.log4j.Logger;
import org.springframework.stereotype.Service;

import cn.com.xinli.service.PersionSevice;
@Service										   
public class PersionServiceBean implements PersionSevice 
{
	Logger log=Logger.getLogger(PersionServiceBean.class);
	
private String user = null;
	
	public String getUser() {
		return user;
	}

	public PersionServiceBean(){}
	
	public PersionServiceBean(String user){
		this.user = user;
	}

	public String getPersonName(Integer personid) {
		System.out.println("我是getPersonName()方法");
		return "xxx";
	}

	public void save(String name) {
		System.out.println("我是save()方法");
	}

	public void update(String name, Integer personid) {
		System.out.println("我是update()方法");
	}

}	

 

 

(3). 建立代理工厂,必须实现 InvocationHandler 接口

 

package cn.com.xinli.aop;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

import cn.com.xinli.service.impl.PersionServiceBean;



public class JDKProxyFactory implements InvocationHandler{
	private Object targetObject;
	
	public Object createProxyIntance(Object targetObject){
		this.targetObject = targetObject;
		return Proxy.newProxyInstance(this.targetObject.getClass().getClassLoader(), 
				this.targetObject.getClass().getInterfaces(), this);
	}

	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {//环绕通知
		PersionServiceBean bean = (PersionServiceBean) this.targetObject;
		Object result = null; 
		if(bean.getUser()!=null){
			//..... advice()-->前置通知
			try {
				result = method.invoke(targetObject, args);
				// afteradvice() -->后置通知
			} catch (RuntimeException e) {
				//exceptionadvice()--> 例外通知
			}finally{
				//finallyadvice(); -->最终通知
			}
		}
		return result;
	}

}

 

 

(4)  测试

 

	JDKProxyFactory factory = new JDKProxyFactory();
			PersionSevice service = (PersionSevice) factory.createProxyIntance(new PersionServiceBean("hxl"));
			service.save("ss");

 

(5) 结果 当传入字符传 "huxl" 的时候 打印出 我是save()方法, 当不传字符的时候什么也没有打印.

 

 

总结:

a. 使用jdk的 Proxy类实现代理 体现了面向接口编程,它必须要求需要代理的对象实现了接口,代理工厂实现了 InvocationHandler ,否存我们就要使用另外一种技术 CGLIB实现AOP功能

 

 

b.代码解释

public class JDKProxy implements InvocationHandler {
	private Object targetObject;//代理的目标对象
	public Object createProxyInstance(Object targetObject){
		this.targetObject = targetObject;
/*
* 第一个参数设置代码使用的类装载器,一般采用跟目标类相同的类装载器
* 第二个参数设置代理类实现的接口
* 第三个参数设置回调对象,当代理对象的方法被调用时,会委派给该参数指定对象的invoke方法
*/
		return Proxy.newProxyInstance(this.targetObject.getClass().getClassLoader(),
				this.targetObject.getClass().getInterfaces(), this);
	}
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		return method.invoke(this.targetObject, args);//把方法调用委派给目标对象
	}
}
当目标类实现了接口,我们可以使用jdk的Proxy来生成代理对象。

 

 

 

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
### 回答1: 以下是 JDK 动态代理实现 AOP 的步骤: 1. 创建一个接口,定义需要进行 AOP 的方法。 2. 创建一个代理类,实现 InvocationHandler 接口,并重写 invoke 方法。 3. 在 invoke 方法,根据需要进行 AOP 增强处理,例如在方法前后添加日志、事务等等。 4. 使用 Proxy 类的 newProxyInstance 方法创建代理对象。 5. 将代理对象转换为接口类型,并调用接口方法,代理类的 invoke 方法会被调用,从而实现 AOP 增强处理。 下面是一个简单的例子,演示如何使用 JDK 动态代理实现 AOP: ```java // 定义接口 public interface UserService { void addUser(String name); } // 实现接口 public class UserServiceImpl implements UserService { public void addUser(String name) { System.out.println("添加用户:" + name); } } // 代理类 public class UserServiceProxy implements InvocationHandler { private Object target; public UserServiceProxy(Object target) { this.target = target; } public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { System.out.println("开始事务"); Object result = method.invoke(target, args); System.out.println("提交事务"); return result; } } // 使用代理类 public class Main { public static void main(String[] args) { UserService userService = new UserServiceImpl(); UserService proxy = (UserService) Proxy.newProxyInstance(userService.getClass().getClassLoader(), userService.getClass().getInterfaces(), new UserServiceProxy(userService)); proxy.addUser("张三"); } } ``` 运行结果: ``` 开始事务 添加用户:张三 提交事务 ``` ### 回答2: JDK动态代理是一种实现AOP(面向切面编程)的方式。AOP主要是通过在程序运行期间动态地将额外的逻辑注入到目标对象的方法,从而实现横切关注点的分离和复用。JDK动态代理是Java语言提供的一种代理方式,基于接口实现动态代理,以下是其实现AOP的步骤: 1. 定义切面类:切面是横切关注点的实现,一般包括需解决的问题和实现逻辑。切面类通常实现了InvocationHandler接口。 2. 创建目标对象:创建需要被代理的目标对象,并且实现了接口。 3. 获取代理对象:通过ProxynewProxyInstance()方法获取代理对象。该方法接收三个参数,分别是目标对象的ClassLoader、目标对象的所有接口以及切面对象。 4. 调用代理对象方法:通过代理对象调用方法时,会自动触发InvocationHandler的invoke()方法。 5. 在invoke()方法实现逻辑:在invoke()方法,我们可以根据需要进行一些额外的逻辑操作,如在目标方法之前或之后进行一些其他操作。 通过以上步骤,JDK动态代理可以在运行时为目标对象的方法添加额外的逻辑实现,达到AOP的目的。这种方式的优点是实现简单,无需引入额外的依赖库,且支持接口代理;但缺点是只能通过接口进行代理,无法对类进行直接代理。 ### 回答3: JDK动态代理是一种实现面向切面编程(AOP)的方式之一。以下是JDK动态代理实现AOP的步骤: 1. 定义切面类:首先,我们需要定义一个切面类,该类包含了我们要在目标对象的方法之前或之后执行的代码。切面类需要实现InvocationHandler接口。 2. 创建目标对象:接下来,我们需要创建一个目标对象,即我们要在其方法上实施切面的对象。 3. 创建代理对象:使用Proxy类的静态newProxyInstance方法创建一个代理对象。该方法接受三个参数:ClassLoader对象、目标对象的接口数组以及InvocationHandler对象。ClassLoader负责加载代理对象,目标对象的接口数组指定了代理对象需要实现的接口,InvocationHandler对象执行切面逻辑。 4. 调用方法:通过代理对象调用目标对象的方法,代理对象会在方法执行前后执行切面逻辑。 5. 前置通知:在切面类的invoke方法,我们可以通过method.invoke(target, args)调用目标对象的方法,同时可以在此之前执行我们定义的前置通知。 6. 后置通知:在切面类的invoke方法,我们同样可以通过method.invoke(target, args)调用目标对象的方法,同时可以在此之后执行我们定义的后置通知。 总结:JDK动态代理实现AOP的步骤包括定义切面类、创建目标对象、创建代理对象,调用方法以及前置和后置通知的执行。使用代理对象调用目标对象的方法时,会自动执行所定义的切面逻辑,从而实现AOP的效果。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值