AspectJ实现设计模式(五)—迭代子模式

原创 2003年07月22日 08:00:00

本文介绍使用AspectJ实现设计模式之迭代子模式,文章以一个购买商品的例子实现AspectJ版本的内禀迭代子。

由于迭代子模式应用广泛,文章在此不再赘述模式的具体内容了,我使用具体的例子说明如何使用AspectJ来完成模式所述的功能。此例子参考了<<Java与模式>>书中关于迭代子模式的示例。

<?xml:namespace prefix = v ns = "urn:schemas-microsoft-com:vml" /><?xml:namespace prefix = o ns = "urn:schemas-microsoft-com:office:office" />

                                          1 ——例子系统UML

例子系统首先定义一个抽象的购物筐类Purchase,以便给出所有的具体购物筐的行为和需要实现的方法。购物筐PurchaseOfCopA和PurchaseOfCopB继承自Purchase,它们分别创建一个前向迭代ForwardIterator和一个后向迭代子BackawrdIterator用于元素的遍历。系统包含一个抽象方面IteratorAspect,它使用Inter-type声明了Purchase类的方法createIterator用来创建迭代子以及适配器类PurchaseIterator,它实现接口java.util.Iterator,同时还定义了一个抽象的pointcut iterator供子方面使用。子方面ForwardIteratorAspectBackwardIteratorAspect分别定义各自的iterator pointcut捕捉对应的Purchase子类的createIterator方法调用并提供Advice around实现createIterator方法返回对应类别的迭代子。最重要的是这两个子方面中的内部类ForwardIteratorBackwardIterator,它们实现了前向迭代和后向迭代的逻辑。

 

抽象类Purchase.java

import java.util.*;

public abstract class Purchase {

  private Collection elements=new ArrayList();

  public void append(Object obj){//添家元素

    elements.add(obj);

  }

  public void remove(Object obj){//删除元素

    elements.remove(obj);

  }

  public Object currentItem(int index){//当前元素

    return ((ArrayList)elements).get(index);

  }

  public int count(){//元素总数

    return elements.size();

  }

}

 

具体类PurchaseOfCopAPurchaseOfCopB

public class PurchaseOfCopA {}

public class PurchaseOfCopB{}

 

适配器类PurchaseIterator.java

public class PurchaseIterator {}

 

抽象方面IteratorAspect.java

import java.util.Iterator;

public abstract aspect IteratorAspect {

  public Iterator Purchase.createIterator(){ return null; }

  abstract pointcut iterator(Purchase purchase);

  //PurchaseIterator实现Iterator,作为适配器类,供子方面使用

  declare parents : PurchaseIterator implements Iterator;

  int PurchaseIterator.current=0;

  Purchase PurchaseIterator.purchase;

 

  //Iterator接口方法的缺省实现

  public boolean PurchaseIterator.hasNext(){ return false;}

  public Object PurchaseIterator.next(){ return null;}

  public void PurchaseIterator.remove(){}

  public void PurchaseIterator.append(Object obj){}

}

 

具体方面ForwardIteratorAspect.java

import java.util.Iterator;

public aspect ForwardIteratorAspect extends IteratorAspect{

  declare parents : PurchaseOfCopA extends Purchase;

  pointcut iterator(Purchase purchase) : target(purchase)

      && call(Iterator createIterator())

      && if(purchase instanceof PurchaseOfCopA); //捕捉前向迭代子的创建方法调用

 

  Iterator around(Purchase purchase) : iterator(purchase){//创建方法执行逻辑,构造前向迭代器

    return new ForwardIterator(purchase);

  }

 

  private static class ForwardIterator extends PurchaseIterator{//前向迭代子内部类

    public ForwardIterator(Purchase purchase){

      super();

      this.purchase=purchase;

      current=0; //当前游标为第一个元素

    }

    public boolean hasNext(){

      return (current<=purchase.count()-1);

    }

    public Object next(){

      if(!hasNext()){

        throw new ArrayIndexOutOfBoundsException("Iterator out of Bounds");

      }

      return purchase.currentItem(current++);

    }

  }

}

 

具体方面BackwardIteratorAspect.java

import java.util.Iterator;

public aspect BackwardIteratorAspect extends IteratorAspect{

  declare parents : PurchaseOfCopB extends Purchase;

  pointcut iterator(Purchase purchase) : target(purchase)

      && call(Iterator createIterator())

      && if(purchase instanceof PurchaseOfCopB);//捕捉后向迭代子的创建方法调用

  Iterator around(Purchase purchase) : iterator(purchase){//创建方法执行逻辑,构造后向迭代器

    return new BackwardIterator(purchase);

  }

 

  private static class BackardIterator extends PurchaseIterator{//后向迭代子内部类

    public BackwardIterator(Purchase purchase){

      super();

      this.purchase=purchase;

      current=purchase.count()-1;//当前游标为最后元素

    }

    public boolean hasNext(){

      return (current>=0);

    }

    public Object next(){

      if (!hasNext()) {

              throw new ArrayIndexOutOfBoundsException("Iterator out of Bounds");

      } else {

          return purchase.currentItem(current--);

      }

    }

  }

}

 

示例代码Demo.java

public class Demo {

  public static void main(String [] args)throws Exception{

    Purchase purchaseA=new PurchaseOfCopA();

Purchase purchaseB=new PurchaseOfCopB();

    purchaseA.append("Dish Washer");

    purchaseA.append("Hair Dresser");

purchaseA.append("Microwave");

System.out.println(Creating forward iterator for purchase A);

    printItems(purchaseA);

    purchaseB.append("Hair Dresser");

    purchaseB.append("Diskman");

    purchaseB.append("Digital Camera");

    purchaseB.append("PC");

purchaseB.append("Dish Washer");

System.out.println(Creating backward iterator for purchase B);

    printItems(purchaseB);

  }

  private static void printItems(Purchase purchase){//格式化输出元素

    int index=1;

    if(isBackforward(purchase)){

      index=purchase.count();

    }

    Iterator it=purchase.createIterator();

    while(it.hasNext()){

      System.out.println("Item :No "+index+":"+it.next().toString());

      if(isBackforward(purchase)){

        index--;

      }

      else{

        index++;

      }

    }

  }

  private static boolean isBackforward(Purchase purchase){//是后向迭代吗?

    if(purchase instanceof PurchaseOfCopB){

      return true;

    }

    return false;

  }

}

 

输出结果如下

Creating forward iterator for purchase A

Item No.1 : Dish Washer

Item No.2 : Hair Dresser

Item No.3 : Microwave

Creating backward iterator for purchase B

Item No.5 : Dish Washer

Item No.4 : PC

Item No.3 : Digital Camera

Item No.2 : Discman

Item No.1 : Hair Dresser

 

    至此,我已经使用AspectJ实现了一个使用内禀迭代子的例子,有兴趣的读者可以尝试实现使用外禀迭代子的相同例子。另因为下个月本人要参加重要的考试,所以本系列的其余文章可能会推出的慢一点,还请各位读者见谅。同时由于许多读者不知道AspectJ语法,所以我将会在另一系列中详细介绍AspectJ的语法、配置和使用范例,希望能提高大家对AspectJ以及AOP面向方面编程的兴趣。

声明

本文由starchu1981保留版权,如果需要转贴请写明作者和出处。

设计模式 行为模式之迭代子模式

1 基础知识 1.1 标准定义 迭代子模式标准定义:提供一种方法顺序访问一个聚合对象 中各个元素,而又不需暴露该对象的内部表示。 1.2 分析和说明 迭代子模式 称迭代器模式,属于对象行为型模...
  • qq_33336787
  • qq_33336787
  • 2016年08月16日 17:24
  • 224

Java设计模式之迭代子模式

本文继续介绍23种设计模式系列之观察者模式。定义在软件构建过程中,集合对象内部结构常常变化各异,但对于这些集合对象,我们希望在不暴露其内部结构的同时,可以让外部客户代码透明地访问其中包含的元素;同时这...
  • jason0539
  • jason0539
  • 2015年04月17日 07:26
  • 6638

设计模式之迭代子模式(Iterator)

迭代子模式(Iterator) 顾名思义,迭代器模式就是顺序访问聚集中的对象,一般来说,集合中非常常见,如果对集合类比较熟悉的话,理解本模式会十分轻松。这句话包含两层意思:一是需要遍历的对象,即聚...
  • m_xiaoer
  • m_xiaoer
  • 2017年06月14日 19:44
  • 151

C++设计模式之迭代器模式

前言 又到年底了,时间真的过的好快啊。最近也非常感伤,总是怀念大学的日子,做梦的时候也常常梦到。梦到大学在电脑前傻傻的敲着键盘,写着代码,对付着数据结构与算法的作业;建立一个链表,遍历链表,打印链表...
  • liujiayu2
  • liujiayu2
  • 2015年04月16日 16:29
  • 483

设计模式之迭代子模式

1类图 2python示例 ''' Created on 2017-2-10 @author: admin ''' from _overlapped import NULL from abc...
  • hxpjava1
  • hxpjava1
  • 2017年02月10日 09:57
  • 297

设计模式_迭代子模式(19)

什么是迭代子模式 迭代子模式的例子迭代子模式的优缺点 迭代子模式的使用场景闲言碎语 什么是迭代子模式 迭代子模式的例子 迭代子模式的优缺点 迭代子模式的使用场景 闲言碎语...
  • qq_15996553
  • qq_15996553
  • 2017年10月16日 17:21
  • 50

设计模式-15-迭代子模式

迭代子模式:所谓迭代器模式就是提供一种方法顺序访问一个聚合对象中的各个元素,而不是暴露其内部的表示。...
  • caoxuekun
  • caoxuekun
  • 2017年07月28日 15:25
  • 47

java设计模式,迭代子模式

package com.dasenlin.itrator; /** * 迭代子模式 * 迭代器模式就是顺序访问聚集中的对象,一般来说,集合中非常常见,如果对集合类比较熟悉的话,理解本模式会十分轻松...
  • rentian1
  • rentian1
  • 2016年10月14日 17:06
  • 139

设计模式16-迭代子模式

简介顺序访问聚集中的对象实现两个接口public interface Collection { public Iterator iterator(); /*取得集合元素*/ ...
  • qq_23370223
  • qq_23370223
  • 2017年10月10日 16:01
  • 30

JAVA设计模式——迭代子模式

迭代子模式,又叫游标(Cursor)模式,是一种行为型设计模式。其思想是:利用迭代子顺序地访问一个聚集中的元素而不必暴露聚集的内部表象(internal representation)。 几...
  • mrkohaku
  • mrkohaku
  • 2018年01月25日 15:53
  • 15
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:AspectJ实现设计模式(五)—迭代子模式
举报原因:
原因补充:

(最多只允许输入30个字)