代理模式

最新推荐文章于 2024-09-05 23:35:50 发布

smartfirstme

最新推荐文章于 2024-09-05 23:35:50 发布

阅读量110

点赞数

CC 4.0 BY-SA版权

分类专栏： java模式文章标签： AOP Spring 编程

本文链接：https://blog.youkuaiyun.com/smartfirstme/article/details/83533832

java模式专栏收录该内容

0 篇文章

订阅专栏

本文介绍了Java动态代理的实现方式及其与AOP的关系。通过具体示例展示了如何使用动态代理来实现对象的代理，并进一步讲解了如何通过动态代理机制实现简单的AOP拦截功能。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

 动态代理实例 
     定义一个接口  
package agentMoudle;

public interface SaleInterface {
     void sale();
}

实现接口

package agentMoudle;

public class WineSale implements SaleInterface{

	public void sale() {
		// TODO Auto-generated method stub
		 System.out.println("我是酒的总供应商");
	}     
}

实现接口2

package agentMoudle;

public class SmokeSale  implements SaleInterface{

	public void sale() {
		// TODO Auto-generated method stub
           System.out.print("我是烟的总供应商");		
	}

}

代理类

package agentMoudle;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
   //该动态代理类需要实现  invocationHandle
public class Agent implements InvocationHandler {
    public Object proxy_obj;
    public Agent(){}
    public Agent(Object obj){
    	this.proxy_obj=obj;
    }
      //根据参数来返回代理对象
    public static Object factory(Object obj){
    	Class cl=obj.getClass();
    	//创建代理类的 newProxyInstance  方法
       return Proxy.newProxyInstance(cl.getClassLoader(),cl.getInterfaces(), new Agent(obj));
    }
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		// TODO Auto-generated method stub
		//利用发射生成真正的的对象(即烟酒总供应商)
		return method.invoke(proxy_obj, args);
	}
     
}

通过代理类调用真是对象的类

package agentMoudle;

public class Invocation {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
        Agent agent=new Agent();
        //只需调用代理类中factory 方法  在方法中传入不同的参数  即可操作真实的对象
        SaleInterface si= (SaleInterface) agent.factory(new SmokeSale());
	    //根据si调用的方法  来动态 管理 代理类的 的invoke方法  
        si.sale();
	}
}

以下是转自他人博客的内容

而是实现了java的InvocationHandler接口,这样就把代理主题角色和我们的业务代码分离开来,使代理对象能通用于其他接口.
其实InvocationHandler接口就是一种拦截机制,当系统中有了代理对象以后,对原对象(真实主题)方法的调用,都会转由InvocationHandler接口来处理,并把方法信息以参数的形式传递给invoke方法,这样,我们就可以在invoke方法中拦截原对象的调用,并通过反射机制来动态调用原对象的方法.这好象也是spring aop编程的基础吧

接着,用代理模式实现一个超级简单的aop拦截机制
这个例子可以拦截我们指定的函数,并在拦截前后根据需要进行处理

Java代码

/**
*切面接口,通过实现这个接口,我们可以对指定函数在调用前后进行处理
*/
public interface AopInterface {
public void before(Object obj);//调用的处理
public void end(Object obj);//调用后的处理
}

/**
*切面接口,通过实现这个接口,我们可以对指定函数在调用前后进行处理
*/
public interface AopInterface {
   public void before(Object obj);//调用的处理
   public void end(Object obj);//调用后的处理
}

这个是实现了AopInterface 接口,在这里我们实现了我们的处理逻辑

Java代码

public class AopInterfaceImp implements AopInterface{
public void before(Object obj) {
System.out.println("调用前拦截");
}
public void end(Object obj) {
System.out.println("调用调用后处理");
}
}

public class AopInterfaceImp implements AopInterface{

    public void before(Object obj) {
        System.out.println("调用前拦截");
    }

    public void end(Object obj) {
        System.out.println("调用调用后处理");
    }

}

接着是代理类

Java代码

public class PeoxyObject implements InvocationHandler {
private AopInterface aop;//定义了切入时调用的方法
private Object proxy_obj;
private String methodName;//指定要切入的方法名
PeoxyObject(){}
public Object factory(Object obj){
proxy_obj = obj;
Class cls = obj.getClass();
return Proxy.newProxyInstance(cls.getClassLoader(), cls.getInterfaces(),this);
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
if(this.aop == null)throw new NullPointerException("aop is null");
if(method == null)throw new NullPointerException("method is null");
Object o;
//如果指定了要拦截方法名,并且调用的方法和指定的方法名相同,则进行拦截处理
//否则当正常方法处理
if(methodName != null && method.toString().indexOf(methodName) != -1){
aop.before(proxy_obj);//指定方法调用前的处理
o = method.invoke(proxy_obj, args);
aop.end(proxy_obj);//指定方法调用后的处理
}else{
//没有指定的方法,以正常方法调用
o = method.invoke(proxy_obj, args);
}
return o;
}
public AopInterface getAop() {
return aop;
}
public void setAop(AopInterface aop) {
this.aop = aop;
}
public String getMethodName() {
return methodName;
}
public void setMethodName(String methodName) {
this.methodName = methodName;
}
}

public class PeoxyObject implements InvocationHandler {
    private AopInterface aop;//定义了切入时调用的方法
    private Object proxy_obj;
    private String methodName;//指定要切入的方法名

    PeoxyObject(){}

    public Object factory(Object obj){
        proxy_obj = obj;
        Class cls = obj.getClass();
        return Proxy.newProxyInstance(cls.getClassLoader(), cls.getInterfaces(),this);
    }

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        if(this.aop == null)throw new NullPointerException("aop is null");
        if(method == null)throw new NullPointerException("method is null");

        Object o;
//如果指定了要拦截方法名,并且调用的方法和指定的方法名相同,则进行拦截处理
//否则当正常方法处理
        if(methodName != null && method.toString().indexOf(methodName) != -1){
            aop.before(proxy_obj);//指定方法调用前的处理
            o = method.invoke(proxy_obj, args);
            aop.end(proxy_obj);//指定方法调用后的处理
        }else{
            //没有指定的方法,以正常方法调用
            o = method.invoke(proxy_obj, args);
        }
        return o;
    }

    public AopInterface getAop() {
        return aop;
    }

    public void setAop(AopInterface aop) {
        this.aop = aop;
    }

    public String getMethodName() {
        return methodName;
    }

    public void setMethodName(String methodName) {
        this.methodName = methodName;
    }
}

这里定义一个用来测试用的类

Java代码

public interface SubInterface {
public void add(String value1,String value2);
public void acc(String value1);
}
public class ImpObject implements SubInterface{
public void add(String value1,String value2) {
System.out.println("ImpObject add(String value1,String value2)");
}
public void acc(String value1){
System.out.println("ImpObject acc(String value1)");
}
}

public interface SubInterface {
    public void add(String value1,String value2);
    public void acc(String value1);
}

public class ImpObject implements SubInterface{

    public void add(String value1,String value2) {
        System.out.println("ImpObject add(String value1,String value2)");
    }

    public void acc(String value1){
        System.out.println("ImpObject acc(String value1)");
    }

}

这里是测试代码

Java代码

public static void main(String agr[]){
PeoxyObject po = new PeoxyObject();
po.setAop(new AopInterfaceImp());//我们实现的拦截处理对象
po.setMethodName("acc");//指定要拦截的函数
SubInterface si = (SubInterface)po.factory(new ImpObject());
//因为add方法不是我们指定的拦截函数,AopInterfaceImp是不会被执行
si.add("tt","dd");
//acc是我们指定的拦截方法,所以调用acc的前后会先执行AopInterfaceImp
//对象的两个方法
si.acc("tt");
}

   public static void main(String agr[]){
        PeoxyObject po = new PeoxyObject();

        po.setAop(new AopInterfaceImp());//我们实现的拦截处理对象
         po.setMethodName("acc");//指定要拦截的函数
        
         SubInterface si = (SubInterface)po.factory(new ImpObject());
      //因为add方法不是我们指定的拦截函数,AopInterfaceImp是不会被执行
         si.add("tt","dd");   

      //acc是我们指定的拦截方法,所以调用acc的前后会先执行AopInterfaceImp
       //对象的两个方法
         si.acc("tt");
    }

通过上面可以看出,拦截机制是代理模式的重要使用方式之一,
除了拦截,代理模式还常用于资源加载,当我们要加载的资源很大时,我们可以让真实主题角色在后台加载资源,让代理主题角色负责处理前台的等待提示信息.
还有就是授权机制,通过代理能拦截真实主题的能力,来控制真实主题的访问权限