java delegate模式_java的delegate实现

一贯用c#用习惯了,这下回来用java编码,少了委托,还有丢丢不习惯.

于是尝试在java中来实现一个.也应该不完全算委托,主要是为了完成类似的事情.

c#中的委托:

class A:

// 定义一个委托的样式

public delegate void ADelegate(paramList);

// 实例一个委托

public ADelegate OnSomethingHappend;

// 当事件发生的时候 调用所有的委托

OnSomethingHappend?.invoke(parmList);

class B:

// 增加一个委托 local fun的传入参数要和class a中定义的委托的参数保持一直

AInstace.OnSomethingHappend += new ADelegate(local fun);

java:

java 就没有delegate 这个字段了,所以要实现,得靠自己.不过也不是很复杂就是了.

首先定义一个interface

// 观察者

public interface IConnectEventObserver

{

// 接受到一个包

public void OnRecvANetworkPacket(ConnectPacket packet);

}

然后定义一个虚类,在里面定义通知对象

// 通知者

public abstract class ConnectEventINotifier {

protected ArrayList observerList = new ArrayList();

/**

* 新增一个observer

* @param observer 添加的观察者

* @return 是否添加成功/新添加

*/

public boolean AddObserver(IConnectEventObserver observer){

if(observer == null)

{

throw new NullPointerException();

}

if( observerList.indexOf(observer)>= 0){

// 重复添加观察者

return false;

}

observerList.add(observer);

return true;

}

/**

* 删除一个observerList

* @param observer

* @return 是否删除成功,如果失败,代表这个观察者并没有注册

*/

public boolean RemoveObserver(IConnectEventObserver observer){

if(observer == null){

throw new NullPointerException();

}

int observerIndex = observerList.indexOf(observer);

if( observerIndex>= 0){

observerList.remove(observerIndex);

return true;

}

return false;

}

/**

* 通知所有观察者

* @param packet

* @return

*/

protected boolean NotifyAllObserver(ConnectPacket packet){

for(IConnectEventObserver observer : observerList) {

observer.OnRecvANetworkPacket(packet);

}

return true;

}

}

接着,发送通知的类extends ConnectEventINotifier ,然后在需要通知的时候 调用NotifyAllObserver.

要接受通知的类 就实现接口IConnectEventObserver 然后调用上面要发送通知的实例的AddObserver 注册自己就好

  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
目前整个开发社区对AOP(Aspect Oriented Programing)推崇备至,也涌现出大量支持AOP的优秀Framework,--Spring, JAC, Jboss AOP 等等。AOP似乎一时之间成了潮流。Java初学者不禁要发出感慨,OOP还没有学通呢,又来AOP。本文不是要在理论上具体阐述何为AOP, 为何要进行AOP . 要详细了解学习AOP可以到它老家http://aosd.net去瞧瞧。这里只是意图通过一个简单的例子向初学者展示一下如何来进行AOP.   为了简单起见,例子没有没有使用任何第三方的AOP Framework, 而是利用Java语言本身自带的动态代理功能来实现AOP.   让我们先回到AOP本身,AOP主要应用于日志记录,性能统计,安全控制,事务处理等方面。它的主要意图就要将日志记录,性能统计,安全控制等等代码从商业逻辑代码中清楚的划分出来,我们可以把这些行为一个一个单独看作系统所要解决的问题,就是所谓的面向问题的编程(不知将AOP译作面向问题的编程是否欠妥)。通过对这些行为的分离,我们希望可以将它们独立地配置到商业方法中,而要改变这些行为也不需要影响到商业方法代码。   假设系统由一系列的BusinessObject所完成业务逻辑功能,系统要求在每一次业务逻辑处理时要做日志记录。这里我们略去具体的业务逻辑代码。 Java代码 public interface BusinessInterface {  public void processBusiness(); } public class BusinessObject implements BusinessInterface {  private Logger logger = Logger.getLogger(this.getClass().getName());  public void processBusiness(){   try {    logger.info("start to processing...");    //business logic here.    System.out.println(“here is business logic”);    logger.info("end processing...");   } catch (Exception e){    logger.info("exception happends...");    //exception handling   }  } } public interface BusinessInterface {  public void processBusiness(); } public class BusinessObject implements BusinessInterface {  private Logger logger = Logger.getLogger(this.getClass().getName());  public void processBusiness(){   try {    logger.info("start to processing...");    //business logic here.    System.out.println(“here is business logic”);    logger.info("end processing...");   } catch (Exception e){    logger.info("exception happends...");    //exception handling   }  } }   这里处理商业逻辑的代码和日志记录代码混合在一起,这给日后的维护带来一定的困难,并且也会造成大量的代码重复。完全相同的log代码将出现在系统的每一个BusinessObject中。   按照AOP的思想,我们应该把日志记录代码分离出来。要将这些代码分离就涉及到一个问题,我们必须知道商业逻辑代码何时被调用,这样我们好插入日志记录代码。一般来说要截获一个方法,我们可以采用回调方法或者动态代理。动态代理一般要更加灵活一些,目前多数的AOP Framework也大都采用了动态代理来实现。这里我们也采用动态代理作为例子。   JDK1.2以后提供了动态代理的支持,程序员通过实现java.lang.reflect.InvocationHandler接口提供一个执行处理器,然后通过java.lang.reflect.Proxy得到一个代理对象,通过这个代理对象来执行商业方法,在商业方法被调用的同时,执行处理器会被自动调用。   有了JDK的这种支持,我们所要做的仅仅是提供一个日志处理器。 Java代码 public class LogHandler implements InvocationHandler {  private Logger logger = Logger.getLogger(this.getClass().getName());   private Object delegate;   public LogHandler(Object delegate){    this.delegate = delegate;   }  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {   Object o = null;   try {    logger.info("method stats..." + method);    o = method.invoke(delegate,args);    logger.info("method ends..." + method);   } catch (Exception e){    logger.info("Exception happends...");    //excetpion handling.   }   return o;  } }   现在我们可以把BusinessObject里面的所有日志处理代码全部去掉了。 public class BusinessObject implements BusinessInterface {  private Logger logger = Logger.getLogger(this.getClass().getName());  public void processBusiness(){   //business processing   System.out.println(“here is business logic”);  } } public class LogHandler implements InvocationHandler {  private Logger logger = Logger.getLogger(this.getClass().getName());   private Object delegate;   public LogHandler(Object delegate){    this.delegate = delegate;   }  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {   Object o = null;   try {    logger.info("method stats..." + method);    o = method.invoke(delegate,args);    logger.info("method ends..." + method);   } catch (Exception e){    logger.info("Exception happends...");    //excetpion handling.   }   return o;  } }   现在我们可以把BusinessObject里面的所有日志处理代码全部去掉了。 public class BusinessObject implements BusinessInterface {  private Logger logger = Logger.getLogger(this.getClass().getName());  public void processBusiness(){   //business processing   System.out.println(“here is business logic”);  } }   客户端调用商业方法的代码如下: Java代码 BusinessInterface businessImp = new BusinessObject(); InvocationHandler handler = new LogHandler(businessImp); BusinessInterface proxy = (BusinessInterface) Proxy.newProxyInstance(  businessImp.getClass().getClassLoader(),  businessImp.getClass().getInterfaces(),  handler); proxy.processBusiness(); BusinessInterface businessImp = new BusinessObject(); InvocationHandler handler = new LogHandler(businessImp); BusinessInterface proxy = (BusinessInterface) Proxy.newProxyInstance(  businessImp.getClass().getClassLoader(),  businessImp.getClass().getInterfaces(),  handler); proxy.processBusiness();   程序输出如下: INFO: method stats... here is business logic INFO: method ends...   至此我们的第一次小尝试算是完成了。可以看到,采用AOP之后,日志记录和业务逻辑代码完全分开了,以后要改变日志记录的话只需要修改日志记录处理器就行了,而业务对象本身(BusinessObject)无需做任何修改。并且这个日志记录不会造成重复代码了,所有的商业处理对象都可以重用这个日志处理器。   当然在实际应用中,这个例子就显得太粗糙了。由于JDK的动态代理并没有直接支持一次注册多个InvocationHandler,那么我们对业务处理方法既要日志记录又要性能统计时,就需要自己做一些变通了。一般我们可以自己定义一个Handler接口,然后维护一个队列存放所有Handler, 当InvocationHandler被触发的时候我们依次调用自己的Handler。所幸的是目前几乎所有的AOP Framework都对这方面提供了很好的支持.这里推荐大家使用Spring。
Java中,委托(Delegate)是一种设计模式,它允许一个对象将某个任务委托给其他对象来完成。委托模式通过定义一个接口来描述任务,然后在另一个类中实现该接口并完成具体的任务。 在Java中,委托可以通过接口和匿名内部类来实现。首先,定义一个接口来描述任务的方法。然后,在另一个类中创建一个接口的实现类,并在该类中实现具体的任务逻辑。最后,将该实现类的实例传递给需要完成任务的对象,从而实现委托。 下面是一个简单的示例代码: ```java // 定义任务接口 interface Task { void execute(); } // 实现任务接口的类 class TaskImpl implements Task { @Override public void execute() { System.out.println("执行具体的任务逻辑"); } } // 需要完成任务的类 class TaskExecutor { private Task task; public void setTask(Task task) { this.task = task; } public void executeTask() { if (task != null) { task.execute(); } } } // 使用委托完成任务 public class DelegateExample { public static void main(String[] args) { TaskExecutor executor = new TaskExecutor(); Task task = new TaskImpl(); executor.setTask(task); executor.executeTask(); } } ``` 在上面的示例中,`Task`接口定义了一个`execute()`方法,`TaskImpl`类实现了该接口并实现了具体的任务逻辑。`TaskExecutor`类是需要完成任务的类,它通过`setTask()`方法将任务委托给其他对象,并通过`executeTask()`方法执行任务。 通过委托模式,我们可以将任务的实现与任务的执行解耦,使得代码更加灵活和可维护。

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值