一.实现复合模式
        复合模式能够把集合中的对象组合在一起，并且以某种方式与整个组交互，这种交互式类似于同组中的单个成员进行交互。
package  com.aspectj;

 import  java.util.Enumeration;
 import  java.util.Vector;
 import  java.util.WeakHashMap;

 public   abstract  aspect CompositePattern  {
    public interface Component{}
    
    protected interface Composite extends Component{}
    
    protected interface Leaf extends Component{}
    
    private WeakHashMap perComponentChildren = new WeakHashMap();
    
    private Vector getChildren(Component s) {
        Vector children = (Vector) perComponentChildren.get(s);
        if (children == null) {
            children = new Vector();
            perComponentChildren.put(s, children);
        }
        return children;
    }
    
    public void addChild(Composite composite , Component component) {
        getChildren(composite).add(component);
    }
    
    public void removeChild(Composite composite , Component component) {
        getChildren(composite).remove(component);
    }
    
    public Enumeration getAllChildren(Component c) {
        return getChildren(c).elements();
    }
    
    public interface Visitor {
        public void doOperation(Component c);
    }
    
    public void recurseOperation(Component c , Visitor v) {
        for (Enumeration enums = getAllChildren(c) ; enums.hasMoreElements();) {
            Component child = (Component) enums.nextElement();
            v.doOperation(child);
        }
    }
    
    public interface FunctionVisitor {
        public Object doFunction(Component c);
    }
    
    public Enumeration recurseFunction(Component c , FunctionVisitor fv) {
        Vector results = new Vector();
        for (Enumeration enums = getAllChildren(c) ; enums.hasMoreElements();){
            Component child = (Component) enums.nextElement();
            results.add(fv.doFunction(child));
        }
        return results.elements();
    }
}

package  com.aspectj;

 import  java.io.PrintStream;

 public  aspect GraphicComposite  extends  CompositePattern  {
    declare parents:Window implements Composite;
    declare parents:Line implements Leaf;
    declare parents:Rectangle implements Leaf;

    public void Component.draw(PrintStream s) {
        s.println("Drawing:" + this);
    }
    
    public void Composite.draw(final PrintStream s) {
        s.println("Composite:" + this);
        GraphicComposite.aspectOf().recurseOperation(this , new Visitor(){
            public void doOperation(Component c){
                c.draw(s);
            }
        });
    }
    
    public void Leaf.draw(PrintStream s) {
        s.println("Drawing Leaf: " + this);
    }
}

二.实现享元模式
        享元模式提供了一些机制，利用这些机制通过在合适的地方共享对象，可以把细粒度的对象纳入到OO设计中，而不会带来资源和性能损失。重型对象潜在地通过许多享元对象来封装要引用的实际数据。

package  com.aspectj;

 import  java.util.Hashtable;

 public   abstract  aspect FlyweightPattern 
 {
   private Hashtable flyweightPool = new Hashtable();

   public interface Flyweight
   {
   }; 
   
   protected abstract pointcut flyweightCreation(Object key);
   
   Object around(Object key) : flyweightCreation(key) && !within(com.oreilly.aspectjcookbook.oopatterns.FlyweightPattern+)
   {
      return this.checkFlyweight(key);
   }
   
   /** *//**
    * Applies the flyweight checking policy.
    * 
    * @param key
    *           The key that determines whether a new flyweight should be
    *           created or not
    * @return The new object that could be a flyweight or a new instance.
    */
   public synchronized Flyweight checkFlyweight(Object key)
   {
      if (flyweightPool.containsKey(key))
      {
        return (Flyweight) flyweightPool.get(key);
      }
      else
      {
        Flyweight flyweight = createNewFlyweight(key);
        flyweightPool.put(key, flyweight);
        return flyweight;
      }
   }
   
   protected abstract Flyweight createNewFlyweight(Object key);
}

        FlyweightPattern抽象方面包含一个享元池集合。这个集合会记住已经创建的重型对象，因此，在可用时，可以把享元设置成现有的重型对象。
        由于抽象方面不知道如何创建不同的具有享元对象，所以它定义了一个抽象方法createNewFlyweight(...)。
同时还包含flyweightCreation(Object)抽象切入点，它用于捕获何时创建被指定为享元的对象。这个切入点使用关联的around()通知，允许FlyweightPattern重写享元对象的创建，使用checkFlyweight(...)方法通过检查是否可以利用现有的重型对象来设计模式的规则，从而根据需要创建新的重型对象。
package  com.aspectj;

 public  aspect PrintableCharacterFlyweight  extends  FlyweightPattern 
 {
   declare parents : PrintableCharacter implements Flyweight;

   protected pointcut flyweightCreation(Object key) : call(public com.oreilly.aspectjcookbook.PrintableCharacter.new(Character)) && args(key);
   
   protected Flyweight createNewFlyweight(Object key)
   {
      return new PrintableCharacter((Character) key);
   }
}

三.实现适配器模式
        适配器模式提供一种方式，把从一个类发送的消息更改成为真正的目标类所期待的消息，使消息适合于两个粘连在一起。
package  com.aspectj;

 public  aspect PrinterScreenAdapter 
 {
  declare parents : Screen implements Printer;

  public void Screen.print(String s)
  {
    outputToScreen(s);
  }
}

四.实现桥接模式
        桥接模式把类与一种特定实现的底层特征分离开，使得可以应用不同的实现，而不会影响类的客户。
package  com.aspectj;

 public   class  Window
 {
   public void drawText(String text)
   {
      
   }
   
   public void drawRect()
   {
      
   }
}

package  com.aspectj;

 public  aspect XWindowBridge perthis(captureAllBridgedCalls())
 {
      private XWindow imp = new XWindow();
      
      public pointcut captureDrawText(String text) : execution(public void Window.drawText(String)) && args(text);
      
      public pointcut captureDrawRect() : execution(public void Window.drawRect());
      
      public pointcut captureAllBridgedCalls() : captureDrawText(String) || captureDrawRect();
      
      void around(String text) : captureDrawText(text)
      {
         imp.drawText(text);
      }
      
      void around() : captureDrawRect()
      {
         imp.drawLine();
         imp.drawLine();
         imp.drawLine();
         imp.drawLine();
      }
}


        XWindowBridge方面捕获需要导向XWindow类上特定调用的Window类上的所有方法。例如，Window类上的drawRect()方法会在XWindow类上产生4个调用，但是通过使用桥接模式，Window类不必将这些调用硬编码进它的行为中。
        通过使用prethis(...)方面实例化策略，将会为通过captureAllBridgedCalls()切入点指定的每个新的桥接Window对象创建一个新方面。这意味着每个Window对象都有它自己的XWindow实现对象的副本。

五.实现装饰模式
        装饰模式扩展了类方法的行为，同时维持其现有的公共接口，而无需类知道或关心扩展。
package  com.aspectj;

 public   abstract  aspect DecoratorPattern 
 {
   public interface DecoratedComponent
   {
   };
   
   private boolean DecoratedComponent.decorated = false;
   
   public void DecoratedComponent.setDecorated(boolean decorated)
   {
      this.decorated = decorated;
   }
   
   public boolean DecoratedComponent.isDecorated()
   {
      return this.decorated;
   }
}

package  com.aspectj;

 public  aspect TextDisplayDecorator  extends  DecoratorPattern 
 {
  declare parents : TextDisplay implements DecoratedComponent;

  public pointcut selectDecorators(Object object) : call(public void TextDisplay.display(String))
    && target(object);
  
  before(Object object) : selectDecorators(object) && if(((DecoratedComponent)object).isDecorated())
  {
     System.out.print("<Decoration>");
  }
  
  after(Object object) : selectDecorators(object) && if(((DecoratedComponent)object).isDecorated())
  {
     System.out.print("</Decoration>");
  }
}

package  com.aspectj;

 public   class  TextDisplay
 {
    public void display(String text)
    {
        System.out.print(text);
    }
}

六.实现代理模式
        代理模式允许开发人员提供代理对象来代替实际的对象，以防需要委托或控制对真实对象的访问。
package  com.aspectj;

 import  org.aspectj.lang.JoinPoint;

 public   abstract  aspect ProxyPattern 
 {

    protected interface Subject
    {
    }

    protected abstract pointcut requestTriggered();

    private pointcut accessByCaller(Object caller) : requestTriggered() && this(caller);
    
    private pointcut accessByUnknown() : requestTriggered() && !accessByCaller(Object);

    Object around(Object caller, Subject subject) : accessByCaller(caller)
        && target(subject)
    {
        if (reject(caller, subject, thisJoinPoint))
        {
            return rejectRequest(caller, subject, thisJoinPoint);
        }
        else if (delegate(caller, subject, thisJoinPoint))
        {
            return delegateRequest(caller, subject, thisJoinPoint);
        }

        return proceed(caller, subject);
    }
    
    Object around(Subject subject) : accessByUnknown()
    && target(subject)
    {
       // Without a caller then reject does not really make sense
       // as there is no way of deciding to reject or not
       if (delegate(null, subject, thisJoinPoint))
        {
            return delegateRequest(null, subject, thisJoinPoint);
        }

        return proceed(subject);
    }

    protected abstract boolean reject(
        Object caller,
        Subject subject,
        JoinPoint joinPoint);

    protected abstract boolean delegate(
        Object caller,
        Subject subject,
        JoinPoint joinPoint);

    protected abstract Object rejectRequest(
        Object caller,
        Subject subject,
        JoinPoint joinPoint);

    protected abstract Object delegateRequest(
        Object caller,
        Subject subject,
        JoinPoint joinPoint);
}

        代理模式的抽象方面定义封装了Subject()的角色，它应用于需要定义代理逻辑的对象。对于可能应用代理的两种情况(委托和保护)中的任何一个情况，都存在一条定义的路径。通过它来检查和委托或者拒绝对主题的调用，这取决于继承子方面中包含的逻辑。
        代理模式的这个方面实现的最重要的优点是：目标应用程序的原始类不必知道将在代理情况下涉及它们。这是绝对关键的，因为这可以保护应用程序中的对象集合的安全，并其他代理敏感的考虑事项不会影响原始类的设计目标。
package  com.aspectj;

 import  org.aspectj.lang.JoinPoint;

 public  aspect DelegationProxy  extends  ProxyPattern 
 {
    declare parents : RealSubject implements Subject;

    protected pointcut requestTriggered() : call(* RealSubject.write(..));

    protected boolean reject(
        Object caller,
        Subject subject,
        JoinPoint joinPoint)
    {

        return false;

    }

    protected boolean delegate(
        Object caller,
        Subject subject,
        JoinPoint joinPoint)
    {
        return true;
    }

    protected Object rejectRequest(
        Object caller,
        Subject subject,
        JoinPoint joinPoint)
    {
        return null;
    }

    protected Object delegateRequest(
        Object caller,
        Subject subject,
        JoinPoint joinPoint)
    {
        Object[] args = joinPoint.getArgs();
        if (args != null)
        {
            AnotherRealSubject.write((String) args[0]);
        }
        else
        {
            AnotherRealSubject.write("");
        }
        return null;
    }
}