`
哈达f
  • 浏览: 120521 次
  • 性别: Icon_minigender_1
  • 来自: 广西
社区版块
存档分类
最新评论

动态代理实现

    博客分类:
  • j2se
 
阅读更多

package com.dhcool.proxy;

import java.lang.reflect.Method;

/**
 * 这个类是用于给动态代理类调用的类,实现这个类就可以让代理类为我们调用
 * */
public interface Advise {
	void beforeMethod(Method method);
	void afterMethod(Method method);
}

 

package com.dhcool.proxy;

import java.lang.reflect.Method;

/**
 * 实现自己的Advise然后实现相应的方法
 * */
public class MyAdvise implements Advise{

	@Override
	public void beforeMethod(Method method) {
		System.out.println("beforeMethod");
		
	}

	@Override
	public void afterMethod(Method method) {
		System.out.println("afterMethod");
		
	}

}

 

package com.dhcool.proxy;

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


/**
 * 这个类继承Proxy动态代理,当我们创建一个MyProxy的时候要给构造方法传递一个我们自己的 调用处理器 InvocationHandler
 * 这个类中还有可以设置目标类(实现接口的类),建议添加的内容Advise
 * 
 * Proxy能够动态的获取一个实现接口的代理类,当我们调用Proxy的Proxy.newProxyInstance(loader, interfaces, h)方法的时候,我们要传递过去的有
 * 1.一个类加载器(反射获得目标对象的类加载器:target.getClass().getClassLoader())
 * 2.具体实现类的接口Class[]数组集合(我们可以通过反射获得,target.getClass.getInterfaces())
 * 3.一个 调用控制器(InvocationHandler)这个类我们必须要自己实现,因为当我们获取了一个实例代理类之后,就可以去调用该类相应的方法,而这个调用过程就在
 * 	实例代理类中是这样实现的:比如我们的target类有一个方法叫add();在实例代理类中也会有一个方法叫做add();并且是Proxy帮我们已经实现好了的,方法的内容是这样的
 * 	InvocationHandler实例对象去调用invoke(Object proxy, Method method, Object[] args),也就是我们初始化的invoke(Object proxy, Method method, Object[] args)
 * 	这个过程中会把Proxy实例代理类,调用具体的方法mehod,调用时的参数Object[] args传递过去。
 * 	
 *了解了以上的过程,我们需要做的就是去实现这个InvocationHandler,实现invoke方法,在invoke方法中就可以是实现我们的target的调用,也就是method.invoke(target,args);
 *这样就一个过程就是动态代理过程。
 * */
public class MyProxy {
	
	private static final long serialVersionUID = 1L;
	
	private InvocationHandler handler = null;
	private Advise advise;
	private Object target;
	
	public MyProxy(){}
	
	protected MyProxy(InvocationHandler h) {
		this.handler = h;
	}

	//设置建议内容
	public void setAdvise(Advise advise){
		this.advise = advise;
	}
	
	//设置目标类
	public void setTarget(Object target){
		this.target = target;
	}
	
	//设置 调用处理器
	public void setInvocationHander(InvocationHandler h ){
		this.handler = h;
	}

	//获取动态代理类,返回的是一个对象Object类型,我们可以根据需要进行转换为相应的类
	private Object getProxy(final Advise advise, final Object target) {
		if(this.target == null){
			return null;
		}
		
		if(this.handler == null){
			
			if(this.advise == null){
				return null;
			}
			
			return Proxy.newProxyInstance(this.target.getClass().getClassLoader(), this.target.getClass().getInterfaces(), new InvocationHandler() {
				@Override
				public Object invoke(Object proxy, Method method, Object[] args)
						throws Throwable {
					advise.beforeMethod(method);
					Object returnValue = method.invoke(target, args);
					advise.afterMethod(method);
					return returnValue;
				}
			});
		}else{
			return Proxy.newProxyInstance(this.target.getClass().getClassLoader(), this.target.getClass().getInterfaces(), this.handler); 
		}		
		
	}
	
	public Object getProxy(){
		return this.getProxy(this.advise, this.target);
	}

}

 

package com.dhcool.proxy;

import java.lang.annotation.Target;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.ArrayList;
import java.util.Collection;


public class ProxyTest {
	
	public static void main(String[] args) {
		
		//final Advise advise = new MyAdvise();
		final Advise advise2 = new MyAdvise2();
		//final Collection<String> target = new ArrayList<String>();
		

		/*MyProxy myProxy1 = new MyProxy(new InvocationHandler() {
			
			@Override
			public Object invoke(Object proxy, Method method, Object[] args)
					throws Throwable {
				advise.beforeMethod(method);
				advise.beforeMethod(method);
				advise.afterMethod(method);
				System.out.println("OK");
				return method.invoke(target, args);				 
			}
		});
		
		myProxy1.setTarget(target);		
		@SuppressWarnings("unchecked")
		Collection<String> c = (Collection<String>)myProxy1.getProxy();
		if(c == null){
			System.out.println("数据不足不能获取代理对象");
			return;
		}
		c.add("123");
		System.out.println(c.size());*/		
		
		
		/*MyProxy myProxy = new MyProxy();		
		myProxy.setAdvise(advise);
		myProxy.setTarget(target);
		
		@SuppressWarnings("unchecked")
		Collection<String> c2 = (Collection<String>)myProxy.getProxy();
		if(c2 == null){
			System.out.println("数据不足不能获取代理对象");
			return;
		}
		c2.add("123");
		System.out.println(c2.size());		*/
		
		
		//创建代理
		MyProxy myProxy2 = new MyProxy();
		//设置代理的附加建议代码
		myProxy2.setAdvise(advise2);
		//设置代理的实现目标接口
		final MyInterfaces interfaces = new InterfaceImp();
		myProxy2.setTarget(interfaces);		
		//获取动态代理类
		MyInterfaces inter = (MyInterfaces)myProxy2.getProxy();
		inter.add();
		
		/*final MyInterfaces interfaces = new InterfaceImp();
		//final Collection interfaces = new ArrayList();
		Class[] clazz = interfaces.getClass().getInterfaces();
		for (Class class1 : clazz) {
			System.out.println(class1.getName());
		}
		
		MyInterfaces a = (MyInterfaces)Proxy.newProxyInstance(interfaces.getClass().getClassLoader(), interfaces.getClass().getInterfaces(), new InvocationHandler() {
			
			@Override
			public Object invoke(Object proxy, Method method, Object[] args)
					throws Throwable {
				advise2.afterMethod(method);
				return method.invoke(interfaces, args);				 
			}
		});
		
		System.out.println(a.delete());*/
	}	
	
}

 

package com.dhcool.proxy;

public interface MyInterfaces {
	
	public void add();
	public int delete();
	public void update();

}
 

 

 

package com.dhcool.proxy;

public class InterfaceImp implements MyInterfaces {

	@Override
	public void add() {
		System.out.println("增加");

	}

	@Override
	public int delete() {
		return 1;
	}

	@Override
	public void update() {
		System.out.println("更新");

	}

}

 

 

分享到:
评论

相关推荐

    ioc框架,通过动态代理实现.

    在学习和应用IOC框架,尤其是通过动态代理实现时,我们需要了解以下知识点: 1. IOC的基本原理和实现机制,包括依赖注入(Dependency Injection)的概念。 2. 如何配置IOC容器,如XML配置或注解配置。 3. 如何使用...

    用Java动态代理实现AOP

    Java动态代理实现AOP Java动态代理是实现Aspect Oriented Programming(AOP)的重要手段。在Java中,动态代理可以通过java.lang.reflect InvocationHandler接口和java.lang.reflect.Proxy类来实现。AOP的主要思想...

    使用JAVA中的动态代理实现数据库连接池

    以下是一个简单的示例,展示如何使用动态代理实现数据库连接池: 1. 定义数据库连接池参数类(如`DBPoolConfig`),存储JDBC驱动类名、URL、用户名和密码等信息,用于初始化连接池。 ```java public class ...

    由浅入深分析mybatis通过动态代理实现拦截器(插件)的原理

    本文将由浅入深地分析 MyBatis 如何通过动态代理实现拦截器的原理。 首先,我们需要了解动态代理的概念。在 Java 中,动态代理是通过 `java.lang.reflect.Proxy` 类和 `java.lang.reflect.InvocationHandler` 接口...

    动态代理实现AOP思想

    以下是一个简单的例子,展示了如何使用Java动态代理实现AOP: ```java import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; interface MyInterface {...

    java 动态代理实现AOP

    ### Java动态代理实现AOP详解 #### 一、引言 随着软件开发复杂度的提升,传统的面向对象编程(OOP)已经难以满足现代软件工程的需求。为了更好地管理跨切面的关注点,如日志记录、性能监控、安全控制等,面向切面...

    Java 代理 代理模式 静态代理与动态代理 常见的动态代理实现 .md

    在Java中,最常用的动态代理实现有两种:JDK Proxy和CGLIB。 - **JDK Proxy**:基于Java反射API实现,仅支持接口的代理。使用JDK Proxy时,需要指定被代理接口的类型,并且代理类必须实现该接口。 - **CGLIB**:...

    JAVA动态代理实现Demo(JDK动态代理和CGLIB动态代理)

    Java提供了两种主要的动态代理实现方式:JDK动态代理和CGLIB动态代理。 **JDK动态代理**: JDK动态代理基于接口实现,也就是说,被代理的对象必须实现至少一个接口。代理机制的核心是`java.lang.reflect.Proxy`类和...

    动态代理实现aop

    ### 动态代理实现AOP #### 概述 面向切面编程(Aspect-Oriented Programming,简称AOP)是一种编程范式,旨在通过将横切关注点与业务逻辑分离来提高系统的模块化程度。本篇文章主要介绍了如何利用Java动态代理技术...

    AOP技术及其在J2EE中动态代理实现

    在J2EE(Java 2 Platform, Enterprise Edition)环境中,AOP的动态代理实现机制是一种常用的技术手段,它利用了Java的反射机制。Java的动态代理可以分为接口型和类型两种。接口型动态代理要求目标对象实现一个接口,...

    Java动态代理实现数据源连接池

    但是,理解如何通过动态代理实现数据源连接池可以帮助我们更好地理解这种机制,并且在某些特定场景下,自定义实现可能会更加灵活。 首先,我们需要了解`InvocationHandler`接口。这个接口只有一个方法`invoke()`,...

    动态代理实现文件.....

    这里我们将深入探讨Java中的两种主要动态代理实现:JDK动态代理和CGLIB动态代理,以及静态代理作为基础概念的介绍。 首先,我们来看静态代理。静态代理是代理模式的一种实现方式,它要求我们为每个目标接口创建一个...

    java动态代理实现数据库连接池

    ### Java动态代理实现数据库连接池 #### 背景与挑战 在开发应用程序时,数据库连接池是一个常用且重要的组成部分。频繁地建立和断开数据库连接不仅效率低下,还可能导致性能瓶颈。为了解决这一问题,引入了数据库...

    用Java动态代理实现委托模式

    下面我们将详细探讨如何使用Java动态代理实现委托模式,以及相关的源码和工具应用。 首先,理解委托模式的基本概念。委托模式通常由三部分组成:委托者(Delegate)、被委托者(Subject)和客户端(Client)。委托...

    动态代理实现AOP机制

    动态代理是实现AOP的一种常见手段,尤其在Java中应用广泛。 动态代理主要分为JDK动态代理和CGLIB动态代理两种方式: 1. **JDK动态代理**: JDK动态代理基于接口实现,它通过`java.lang.reflect.Proxy`类和`java....

    基于JAVA的动态代理实现的AOP的研究.pdf

    以下是如何利用动态代理实现AOP的基本步骤: 1. 创建一个接口,定义横切关注点所涉及的方法。 2. 创建一个实现该接口的类,实现具体的功能逻辑。 3. 实现InvocationHandler接口,覆写invoke方法。在invoke方法中,...

Global site tag (gtag.js) - Google Analytics