中文一区一区三区免费 ,中文字幕日韩专区,久久一二三四

Fri, 17 Nov 2006 08:55:00 GMT

观察�?Observer)模式
用途：定义对象之间的一对多依赖关系�Q�因此，当一个对象的状态发生改变时�Q�其所有依赖项都会得到通知�Q��ƈ自动更新�?br /> 它是 OO 设计模式的皇后。该模式被�h们广泛应用（特别是在 GUI 应用�E�序中）�Q��ƈ构成�?MVC 架构的关键部分。它处理复杂的问题，而在解决�q�类问题斚w��表现得相对较好。但是，从实现需要的努力和代码理解的角度来说�Q�它�q�是带来了一些难以解决的��N��?br /> 不��Q�观察�?Observer)模式要求您先侵入�pȝ��中现有的�c�，然后才能支持该模�?—�?臛_��?Java 语言中是�q�样�?br /> 而方面可以降低像观察�?Observer)模式�q�种侵入性模式的负担�Q��得模式参与者更灉|��Q�因��Z��需要包含模式代码。而且�Q�模式本�w�可以变成抽象的基本斚w��Q�允许开发�h员通过导入和应用它来实现重用，不必每次都要重新考虑模式�?br /> 下面通过一个例子来说明�Q?br /> 假设如下的情况：
AccountManager 对象能够观察 Account�Q�这��P��在帐��L��态改变时�Q�它们可以向销售�h员发送一��电子邮件�?br /> 代码如下�Q?

public class Account {

    private int state;
     private String name;

    public String getName() {
        return name;
    }
    public Account(String name) {
        super();
        this.name = name;
    }
    public int getState() {
        return state;
    }

    public void setState(int state) {
        this.state = state;
    }
     @Override
    public String toString() {
        return name;
    }
}

public class AccountManager {

    public void sendEmail(Account account) {
         System.out.println("send Email:" + account);
    }
}

来看一下java代码是如何实现观察者模式的

Java 语言的观察�?/b>
虽然实现的差异很明显�Q�但在它们之间还是有一些相��g��处。不论如何实现观察者，代码中都必须回答以下 4 个问题：
   1. 哪个对象是主体，哪个对象是观察者？
   2. 什么时候主体应当向它的观察者发送通知�Q?br />   3. 当接收到通知�Ӟ��观察者应该做什么？
   4. 观察关系应当在什么时候开始，什么时候终止？

角色定义
    首先从标记器接口来分配角色开始。Observer 接口只定义了一个方法：update()�Q�它对应着 Subject 发送通知时执行的操作�?Subject 承担着更多的职责。它的标记器接口定义了两个方法，一个用来跟�t�观察者，另一个用来通知事�g的那些观察者�?

public interface Observer {

    public void update(Subject subject);
}

public interface Subject {
    public void addObserver(Observer o);
    public void removeObserver(Observer o);
    public void notifyObservers();
}

一旦定义了�q�些角色�Q�就可以把它们应用到�pȝ��中对应的角色上�?br />
应用观察者角�?/b>

public class AccountManager implements Observer {

   public void update(Subject subject) {
        sendEmail((Account) subject);
    }
}

跟踪和通知观察�?/b>
一旦这��工作完成，��可以�{�U�d��Subject。在�q�里�Q�要�?Account�q�行修改�Q?

private Set observers = new HashSet();
public void addObserver(Observer o) {
    observers.add(o);
}
public void removeObserver(Observer o) {
    observers.remove(o);
}
public void notifyObservers() {
    for (Observer o : observers) {
      o.update(this);
    }
}

触发事�g
    现在已经把类调整到它们在模式中的角色上了。但是，�q�需要回�q�头来，在对应的事�g发生时触发通知�?br />
    Account
    public void setState(int state) {
        if (this.state != state) {
            this.state = state;
            notifyObservers();
        }
    }

启动观察关系

public class ObserverClient {

    public static void main(String[] args) {
        AccountManager manager = new AccountManager();
        AccountManager manager2 = new AccountManager();
        Account account = new Account("Account1");
        account.addObserver(manager);
        account.addObserver(manager2);
        account.setState(1);
    }
}

AspectJ 观察�?/b>

定义抽象�c�L��实现观察�?/b>

//采用java5的泛型来定义观察对象和主�?br />public abstract class AbstractSubjectObserver {

       //不允许空item
    protected static void iaxIfNull(Object item, String name) {
        if (null == item) {
            throw new IllegalArgumentException("null " + name);
        }
    }
       //用于保存所有的��M��和观察者之间的对象关系
    private final HashMap> fObservers = new HashMap>();

    protected AbstractSubjectObserver() {

    }

    public synchronized void addObserver(Sub subject, Obv observer) {
        iaxIfNull(subject, "subject");
        iaxIfNull(observer, "observer");
        getObservers(subject).add(observer);
    }

    public synchronized void removeObserver(
            Sub subject,
            Obv observer) {
        iaxIfNull(subject, "subject");
        iaxIfNull(observer, "observer");
        getObservers(subject).remove(observer);
    }

    public synchronized ArrayList getObservers(Sub subject) {
        iaxIfNull(subject, "subject");
        ArrayList result = fObservers.get(subject);
        if (null == result) {
            result = new ArrayList();
            fObservers.put(subject, result);
        }
        return result;
    }
    //��M��状态改变，更新所有的观察者对�?br />    protected void subjectChanged(Sub subject) {
        iaxIfNull(subject, "subject");
        ArrayList list = getObservers(subject);
        if (!list.isEmpty()) {
            updateObservers(subject, Collections.unmodifiableList(list));
        }
    }

   //更新所有观察者操作，调用具体的updateObserver
    protected synchronized void updateObservers(
            Subject subject,
            List observers) {
        iaxIfNull(subject, "subject");
        iaxIfNull(observers, "observers");
        for (Observer observer : observers) {
            updateObserver(subject, observer);
        }
    }
     //需要子�c�d��玎ͼ�具体的更新操�?br />    protected abstract void updateObserver(Subject subject, Observer observer);

}

定义斚w��Q?/b>
public abstract aspect SubjectObserver extends
        AbstractSubjectObserver {

    //需要横切的代码�Q�表�C�哪些需要触发观察者模�?br />    protected abstract pointcut changing();

    //在状态改变后�Q�触发所有的观察�?br />    after(Sub subject) returning : target(subject) && changing() {
        subjectChanged(subject);
    }
}

无需改动原有的实玎ͼ�看一下客��L��如何启动观察关系
public class ObserverClient {

    public static void main(String[] args) {
        Account account=new Account("Account1");
        Client client=Client.aspectOf();
        client.addObserver(account,new AccountManager());
        client.addObserver(account,new AccountManager());
        account.setState(1);
    }
    static aspect Client extends SubjectObserver {

        protected pointcut changing() : execution(void Account.setState(int));

        protected void updateObserver(Account account, AccountManager manager) {
            manager.sendEmail(account);
        }
    }
}

AspectJ 观察者的分析
   易于理解�Q�从参与者的视角来看�Q�AOP 版本的观察者更��?br />   重用:可以很容易的实现重用

布衣�?/a> 2006-11-17 16:55 发表评论

Thu, 16 Nov 2006 10:56:00 GMT
攉��了几个常用的斚w��Q?br />
NoCallsIntoTestFromOutside    ��止从��品包到测试包的引�?br />
public abstract aspect NoCallsIntoTestFromOutside {
   //引用带有test的包的所有可能操�?br />   pointcut referToTestPackage():
        call(* *..test..*.*(..)) || call(*..test..*.new(..))
        || get(* *..test..*.*) || set(* *..test..*.*)
        || get(*..test..* *) || set(*..test..* *)
        || (staticinitialization(!*..test..*)
           && staticinitialization(*..test..*+))
        || call(* *(*..test..*, ..))
        || call(* *(*, *..test..*, ..))
        || call(* *(*, *, *..test..*))
        || call(* *(.., *..test..*))
        || execution(* *(*..test..*, ..))
        || execution(* *(*, *..test..*, ..))
        || execution(* *(*, *, *..test..*, ..))
        || execution(* *(.., *..test..*))
        ;
   // getcode scary-tests END

   abstract protected pointcut withinTypes();

   pointcut fromWithinNonTest(): within(!*..test..*);

   declare error: withinTypes() && referToTestPackage()
       && fromWithinNonTest(): "production code referring to test code";
}

UtilityClassEnforced     ��止构造实用工��L��

public aspect UtilityClassEnforced {

    declare error :
        //定义非private 的构造器
        execution(!private (@UtilityClass *).new(..))
        //调用new 初始化方�?br />        || call((@UtilityClass *).new(..))
        //执行工具�cȝ��M��Ҏ��
        || execution((@UtilityClass *) *(..))
        : "no instances of utility classes";

}

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
public @interface UtilityClass {

}

NoSystemOut     ��止使用 System.err �?System.out

public abstract aspect NoSystemOut {
    abstract protected pointcut withinTypes�Q?br />    //��d��System.out对象
    declare error: withinTypes() && get(PrintStream System.out) : "no System.out";
     //��d��System.err对象
    declare error: withinTypes() && get(PrintStream System.err) : "no System.err";
    //��d��FileDescriptor.err
    declare error: withinTypes() && get(PrintStream FileDescriptor.err) : "no FileDescriptor.err";
    //��d��FileDescriptor.out
    declare error: withinTypes() && get(PrintStream FileDescriptor.out) : "no FileDescriptor.out";
     //执行Throwable.printStackTrace()�Ҏ��
    declare error: withinTypes() && call(void Throwable.printStackTrace()) : "no System.err";
}

GetterSetter    ��止在除初始化或 getter �Ҏ��以外�q�行字段��d��操作�Q�禁止在初始化或 setter �Ҏ��以外�q�行字段写操�?br />
public abstract aspect GetterSetter {

   abstract protected pointcut withinTypes();
   //所有的sets 非public fields
   pointcut sets() : set(!public * *);
       //所有的gets 非public fields
   pointcut gets() : get(!public * *);
   declare error : withinTypes() && gets() &&
       //在get*�Ҏ��或者构造器以外地方使用
       !(withincode(!void get*()) || withincode(new(..)))
       : "non-public field-get outside constructor or getter method";
   declare error : withinTypes() && sets() &&
       !(withincode(void set*(*)) || withincode(new(..)))
       : "non-public field-set outside constructor or setter method";
}

NoNullParameters           在公共方法传递空参数时抛出异�?br />
public abstract aspect NoNullParameters {
   abstract protected pointcut withinTypes();

   pointcut publicParameters() :
       //执行public 构造器或者public �Ҏ��
       (execution(public new(*,..)) || execution(public * *(*,..)))
       //除了执行非Object的参�?如原�c�d��Q�int,long
       && !(execution(* *(!Object+)) || execution(*.new(!Object+)));
   //如果参数为null,则抛��Z��外 �?
   before() : withinTypes() && publicParameters() {
       Object[] args = thisJoinPoint.getArgs();
       for (int i = 0; i < args.length; i++) {
           if (null == args[i]) {
               JoinPoint.StaticPart sp = thisJoinPointStaticPart;
               String name = AJReflect.getParameterName(sp, i);
               throw new IllegalArgumentException("null " + name);
           }
       }
   }
}

布衣�?/a> 2006-11-16 18:56 发表评论

Sat, 21 Oct 2006 12:50:00 GMT
   默认的情况下�Q�Aspect�c�d��有一个实例存在于虚拟��Z��Q�也��是作�ؓ单例存在的，对于每个对象来说�Q�方面是�׃�n的。一般这��L��斚w��Q�不能用来保存相应对象的状态�?br />   对于AspectJ 来说�Q�Aspect斚w��c�，包括以下的实例化方式�?br />
每虚拟机(默认�Q�，只有一个实例，其生命周期从虚拟机启动开始，一直到虚拟机停止�?/span>
每对象，对于每一个对象都有一个方面实例，其生命周期跟随相兌��的对象�?/span>
每控制流�Q�对于每个controlFlow点，都会创徏相应的方面实例，可以参考事务管理（对于事务�Q�每个原子操作，都是一个控制流�Q�方面的生命周期�Q�从控制��开始，一直到控制��结束）�?/span>
1)   每虚拟机兌��
默认斚w��Q�它的状态是�׃�n的�?/span>
2)每对�?/span>兌��
通常�Q�重用基��斚w��需要保持每个对象的状态，也就是对象的数据。对于每个对象都会创��Z��个方面实例�?/span>

对于每对象关联可以指定两�U�类型：
perthis()-与当前所匚w��的连接点的执行对象，所兌��
pertarget()—与当前所匚w��的连接点的目标执行对象，所兌��
3)�?span lang="EN-US">控制��关�?/span>
可以指定两种�c�d��的每控制��对象关联：
percflow()�B-对于�?/span>percflow()指定�?/span>pointcut所匚w��的连接点�Q�关联每一个独立的斚w��实例和控制流执行�?/span>
percflowbelow()�Q�对于在prcflowbelow ()指定�?/span>pointcut所匚w��的连接点�Q�关联每一个独立的斚w��实例和控制流下的执行�?/span>

下面来看一个实例：来区别不同点�Q?/span>
声明必要的测试类

public class TestBean {

    private String name;

    public TestBean(String name) {
        this.name = name;
    }

    public void method1() {
    }

    public void method2() {
    }

    @Override
    public String toString() {
        return name;
    }

}
��试�c�：
public class LogAspectTest {

    @Test
    public void testAssociation() {
        TestBean bean1 = new TestBean("bean1");
        TestBean bean2 = new TestBean("bean2");
        bean1.method1();
        bean1.method2();
        bean2.method1();
        bean2.method2();
    }
}

斚w��c�：
public aspect LogAspect {

    private static Log log = LogFactory.getLog(LogAspect.class);

    public LogAspect() {
        log.info("create LogAspect instance");
    }

    pointcut logMethod(TestBean bean)
        :execution(* TestBean.method*(..))&&this(bean)&&!within(LogAspect+);

    before(TestBean bean):logMethod( bean){
        log.info("JoinPoint: "
                 + thisJoinPointStaticPart
                 + "\n\taspect: "
                 + this
                 + "\n\tobject: "
                 + bean);

    }
}

默认的输��Zؓ�Q?br />2006-10-21 20:42:02,275 [demo.chap4.log.LogAspect] - create LogAspect instance
2006-10-21 20:42:02,275 [demo.chap4.log.LogAspect] - JoinPoint: execution(void demo.chap4.log.TestBean.method1())
    aspect: demo.chap4.log.LogAspect@15601ea
    object: bean1
2006-10-21 20:42:02,275 [demo.chap4.log.LogAspect] - JoinPoint: execution(void demo.chap4.log.TestBean.method2())
    aspect: demo.chap4.log.LogAspect@15601ea
    object: bean1
2006-10-21 20:42:02,275 [demo.chap4.log.LogAspect] - JoinPoint: execution(void demo.chap4.log.TestBean.method1())
    aspect: demo.chap4.log.LogAspect@15601ea
    object: bean2
2006-10-21 20:42:02,275 [demo.chap4.log.LogAspect] - JoinPoint: execution(void demo.chap4.log.TestBean.method2())
    aspect: demo.chap4.log.LogAspect@15601ea
    object: bean2
可以看到只是实例化了一��?/p>
现在更改相应的aspect�Q?br />
public aspect LogAspect perthis(logMethod(TestBean)){

    ....

    }
}
只是增加�?/span>perthis(logMethod(TestBean))
输出�Ӟ��可以看到创徏了两个实�?br />
2006-10-21 20:45:21,306 [demo.chap4.log.LogAspect] - create LogAspect instance
2006-10-21 20:45:21,306 [demo.chap4.log.LogAspect] - JoinPoint: execution(void demo.chap4.log.TestBean.method1())
    aspect: demo.chap4.log.LogAspect@197d257
    object: bean1
2006-10-21 20:45:21,306 [demo.chap4.log.LogAspect] - JoinPoint: execution(void demo.chap4.log.TestBean.method2())
    aspect: demo.chap4.log.LogAspect@197d257
    object: bean1
2006-10-21 20:45:21,306 [demo.chap4.log.LogAspect] - create LogAspect instance
2006-10-21 20:45:21,306 [demo.chap4.log.LogAspect] - JoinPoint: execution(void demo.chap4.log.TestBean.method1())
    aspect: demo.chap4.log.LogAspect@7259da
    object: bean2
2006-10-21 20:45:21,306 [demo.chap4.log.LogAspect] - JoinPoint: execution(void demo.chap4.log.TestBean.method2())
    aspect: demo.chap4.log.LogAspect@7259da
    object: bean2
�l�箋更改aspect�Q�把perthis改�ؓpercflow
输出改�ؓ�Q?br />
2006-10-21 20:46:58,009 [demo.chap4.log.LogAspect] - create LogAspect instance
2006-10-21 20:46:58,009 [demo.chap4.log.LogAspect] - JoinPoint: execution(void demo.chap4.log.TestBean.method1())
    aspect: demo.chap4.log.LogAspect@eee36c
    object: bean1
2006-10-21 20:46:58,009 [demo.chap4.log.LogAspect] - create LogAspect instance
2006-10-21 20:46:58,009 [demo.chap4.log.LogAspect] - JoinPoint: execution(void demo.chap4.log.TestBean.method2())
    aspect: demo.chap4.log.LogAspect@194df86
    object: bean1
2006-10-21 20:46:58,009 [demo.chap4.log.LogAspect] - create LogAspect instance
2006-10-21 20:46:58,009 [demo.chap4.log.LogAspect] - JoinPoint: execution(void demo.chap4.log.TestBean.method1())
    aspect: demo.chap4.log.LogAspect@defa1a
    object: bean2
2006-10-21 20:46:58,009 [demo.chap4.log.LogAspect] - create LogAspect instance
2006-10-21 20:46:58,009 [demo.chap4.log.LogAspect] - JoinPoint: execution(void demo.chap4.log.TestBean.method2())
    aspect: demo.chap4.log.LogAspect@f5da06
    object: bean2

每个�Ҏ��都创建相应的实例�?br />

布衣�?/a> 2006-10-21 20:50 发表评论

关于AspectJ 中的pointcut 语法

Tue, 17 Oct 2006 12:00:00 GMT
    �q�两天忙着看AspectJ in Action ��Z��补一下AOP知识。看了Spring 2.0的规范，其中AOP部分已经基本融合了AspectJ�Q�看来有必要看一看AspectJ了�?br />   看了很多AOP的文章了�Q�AOP�q�两�q�发展的很慢�Q�没有什么新意，现在到处都是SOA�Q�SCA了，不过研究了一下，觉得�q�是很有帮助的。尤其是增加�pȝ��的契�U�性和模块的独立性来��_��很有帮助�?br />   当然�Q�学东西�Q�基��很重要。下面就说说AspectJ中的基本语法�Q�有兴趣的可以看看AspectJ in Action�?br />   先来说说pointcut�Q�从字面的意思说的是切面的意思。也��是横切的时候，会有哪些执行点会被识别。只有先识别了，才能执行相应的Advice�?br />   基本的定义如下：

   public pointcut accountOperations:call(* Account.*(..))

   1.通配�W�和pointcut 操作�W?br />
   * 表示��M��数量的字�W�，除了(.)
    .. 表示��M��数量的字�W�包括�Q何数量的(.)
       + 描述指定�c�d��的�Q何子�c�L��者子接口
    �?/span>java一��P��提供了一元和二元的条件表达操作符�?br />    一元操作符�Q?/span>!
      二元操作�W�：||�?/span>&&
      优先权同java

      2.�{�֐�语法

�c�d��{�֐�样式

主要的例�?
Account                              �c�d��Account
    *Account                             使用Account名称�l�束的类型，�?/span>SavingsAccount�?/span>CheckingAccount
    java.*.Date                         �c�d��Date在�Q何直接的java子包中，�?/span>java.util.Date�?/span>java.sql.Date
java..*                                 ��M��?/span>java包或者所有子包中的类型，�?/span>java.awt�?/span>java.util或�?/span>java.awt.event �?/span>java.util.logging
    javax..*Model+                   所�?/span>javax包或者子包中�?/span>Model�l�尾的类型和其所有子�c�，�?/span>TableModel,TreeModel�?br /> �Q?/span>vector                             所有除�?/span>Vector的类�?br /> Vector|| Hashtable              Vector或�?/span>Hashtable�c�d��
java.util.RandomAccess+    实现RandomAccess�?/span>List的所有子�c?/span>
   && java.util.List+

   �Ҏ��和构造器�{�֐�模式

public void Collection.clear()�Q?br /> 在Collection中同��L��名的clear�Ҏ��

public void Account.debit(float) throws InsufficientBalanceException�Q?br /> Account中同��L��名的debit�Ҏ��

public void Account.set*(*)
Account中以set开��_��q�且只有一个参数类型的�Ҏ��

public void Account.*()
Account中所有的没有参数的public void �Ҏ��

public * Account.*()
Account中所有没有参数的public �Ҏ��

public * Account.*(..)
Account中所有的public �Ҏ��

* Account.*(..)
Account中的所有方法，包括private�Ҏ��

!public * Account.*(..)
所有的非public �Ҏ��

   * Account+.*(..)
   所有的�Ҏ��Q�包括子�cȝ��Ҏ��

   * java.io.Reader.read(..)
   所有的read�Ҏ��

   * java.io.Reader.read(char[],..)
   所有以read(char[])开始的�Ҏ��Q�包括read(char[])和read(char[],int,int)

   * javax..*.add*Listener(EventListener+)
   命名以add开始，以Listener�l�尾的方法，参数中�ؓEventListener或子�c?br />
   * *.*(..) throws RemoteException
   抛出RemoteException的所有方�?/span>

   构造器�Q�同上面
   public Account.new()
   没有参数的构造器�Ҏ��

    属性签名模�?/b>
    同方法一��P��属性也查不�?br />    * Account.*
    所有的Account属�?br />
    !public static * banking..*.*
    所有的非public static 属性，在banking的包或者子包中

    3.主要的pointcuts�c�d��

    分类pointcuts
    遵��@特定的语法用于捕��h��一个种�cȝ��可��用连接点�?br />    主要的种�c�：
�Ҏ��执行�Q�execution(MethodSignature)
�Ҏ��调用�Q�call(MethodSignature)
构造器执行�Q�execution(ConstructorSignature)
构造器调用�Q�call(ConstructorSignature)
�c�d��始化�Q�staticinitialization(TypeSignature)
属性读操作�Q�get(FieldSignature)
属性写操作�Q�set(FieldSignature)
例外处理执行�Q�handler(TypeSignature)
对象初始化：initialization(ConstructorSignature)
对象预先初始化：preinitialization(ConstructorSignature)
Advice执行�Q�adviceexecution()
   ��Z��控制��的pointcuts
   主要包括两种�c�d��的控制流�Q?br />   cflow(Pointcut)�Q�捕��h��有的�q�接点在指定的方法执行中�Q�包括执行方法本�w��?br />   cflowbelow(Pointcut)�Q�捕��h��有的�q�接点在指定的方法执行中�Q�除了执行方法本�w��?br />
   如以下的例子�Q?br />   cflow(call(* Account.debit(..))
   所有的debit�Ҏ��中的�q�接点，包括debit�Ҏ��本��n
   cflowbelow(call(* Account.debit(..))
   所有debit�Ҏ��中的�q�接点，除了debit�Ҏ��本��n
   cflow(transactedOperations())
   所有由transactedOperations捕获的连接点
   cflowbelow(execution(Account.new(..))
   所有在Account 构造器中执行的�q�接�?br />
   ��Z��词汇�l�构的连接点
   源代码片断。，如within()和withincode()
   within �Q�捕获在指定�c�L��者方面中的程序体中的所有连接点�Q�包括内部类�?br />   Withincode�Q�用于捕获在构造器或者方法中的所有连接点�Q�包括在其中的本地类

   执行对象�q�接�?/b>
   匚w��this,和target对象�Q�作为方法被调用的对象�?br />   this(Account)�Q�所有Account的实例的执行点，匚w��所有的�q�接点，如方法调用，属性设�|�，当前的执行对象�ؓAccount�Q�或者其子类�?br />   target(Account)�Q�匹配所有的�q�接点，目标对象为Account或其子类�?br />
   必须执行相应的类型，不能使用*,或�?.通配�W�。当前静态方法，不能被匹配�?br />
   在within()和this()中的区别�Q?br />   一个是�E�序体，而另一个�ؓ对象执行�?br />
   参数pointcuts
   用于捕获参数�c�d��的连接点�?br />   args(String,..,int)
   args(RemoteException)

   条�g��pointcuts
   if(System.currentTimeMillis()>triggerTime)

   基本的语法就�q�些�Q�不�q�AspectJ5 已经增加了不��语法，主要关于Annotation 的，不过�q�部分还没有仔细研究�Q�以后再讲解吧。希望能有所帮助



布衣�?/a> 2006-10-17 20:00 发表评论

spring aop 2.0 �~�程(�?

Sun, 17 Sep 2006 03:13:00 GMT

前面�q�是讲了许多的概念，下面以一个例子来说明�Q?br />一个很好理解的aop 例子�Q�也��是日志服务�?br />先从aop�W�一�U�方式来实现�Q�也��是xml配置方式
先创建基本的日志�c�：
public class Logger {

    private static Log log = LogFactory.getLog(Logger.class);

    public void entry(String message) {
        log.info(message);
    }
}
�q�里只是��单的一个方法，当然实际情况可能不同�?br />�׃��xml配置需要一个方面的实现bean
所以创��Z��个简单的bean �Q?br />public class LogBean {

    private Logger logger = new Logger();

    public Object aroundLogCalls(ProceedingJoinPoint joinPoint) throws Throwable {
        logger.entry("before invoke method:"
                     + joinPoint.getSignature().getName());
        Object object = joinPoint.proceed();
        logger.entry("after invoke method:"
                     + joinPoint.getSignature().getName());
        return object;
    }
}
�q�里采取��单的around advice�Q�其他类型的advice 基本上都差不�?br />
当然有了�q�两个核心的日志�c�，需要一个测试类�Q�用于测试�?br />public class TestBean {

    public void method1() {
        System.out.println("in method1");
    }

    public void method2() {
        System.out.println("in method2");
    }
}
�q�就是需要测试的�c�M��Q�需要记录日志的�Ҏ��只有两个�Q�这里用System.out.println�Q�只是想昄��Ҏ��的调用顺序�?br />

然后关键的在于xml的配�|�了

xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aophttp://www.springframework.org/schema/aop/spring-aop.xsd">



                expression="execution(public * *(..)) and !execution(* org.spring.test.aop.log.Logger.*(..))"/>





现在写一个测试类�Q?br />
public class LogXmlTest extends RootTest {

    @Override
    protected String getBeanXml() {
        return "org/spring/test/aop/log/bean.xml";
    }

    public void testLog() {
        TestBean bean = (TestBean) ctx.getBean("testBean");
        bean.method1();
        bean.method2();
    }

}

public abstract class RootTest extends TestCase {

    protected ApplicationContext ctx;

    protected Log log = LogFactory.getLog(getClass());

    protected RootTest() {
        ctx = new ClassPathXmlApplicationContext(getBeanXml());
    }

    protected abstract String getBeanXml();

}

打印的消息如下：
2006-09-17 11:08:28,203 INFO [org.spring.test.aop.log.Logger] - before invoke method:method1
in method1
2006-09-17 11:08:28,203 INFO [org.spring.test.aop.log.Logger] - after invoke method:method1
2006-09-17 11:08:28,218 INFO [org.spring.test.aop.log.Logger] - before invoke method:method2
in method2
2006-09-17 11:08:28,218 INFO [org.spring.test.aop.log.Logger] - after invoke method:method2

�W�二�U�实现方式，采用注释方式�Q?br />
Logger �c�M��?br />创徏一个LogAspect�c?br />@Aspect
public class LogAspect {

    private Logger logger = new Logger();

    @Pointcut("execution(public * *(..))")
    public void publicMethods() {

    }

    @Pointcut("execution(* org.spring.test.aop.log.Logger.*(..))")
    public void logObjectCalls() {

    }

    @Pointcut("publicMethods()&&!logObjectCalls()")
    public void loggableCalls() {

    }

    @Around("loggableCalls()")
    public Object aroundLogCalls(ProceedingJoinPoint joinPoint) throws Throwable {
        logger.entry("before invoke method:"
                     + joinPoint.getSignature().getName());
        Object object = joinPoint.proceed();
        logger.entry("after invoke method:"
                     + joinPoint.getSignature().getName());
        return object;
    }
}

配置文�g��q��单多�?br />
xmlns:aop=" xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop

��试�c�：
跟上面的差不�?br />把xml文�g换掉��p��

打印的方式差不多

个�h�q�是比较喜欢�W�二�U�实现�?/p>

布衣�?/a> 2006-09-17 11:13 发表评论

spring aop�~�程(�?

Fri, 15 Sep 2006 11:31:00 GMT

前面主要介绍了如何通过xml实现aop�~�程�Q�下面主要介�l�如何通过@AspectJ来实现�?br />��Z��使@AspectJ 支持生效,
需要做以下步骤�Q?br />�?/span>xml中设�|?/span>

或�?br />在xml中加�?br />

声明 aspect



package org.xyz;

import org.aspectj.lang.annotation.Aspect;

@Aspect

public class NotVeryUsefulAspect {

}

声明 pointcut

@Pointcut("execution(* transfer(..))")

public void transfer() {}

声明 advice

Before advice:

@Before("com.xyz.myapp.SystemArchitecture.dataAccessOperation()")

public void doAccessCheck() {

    // ...

}

After returning advice:

@AfterReturning("com.xyz.myapp.SystemArchitecture.dataAccessOperation()")

public void doAccessCheck() {

    // ...

}

或�?/span>

@AfterReturning(
pointcut="com.xyz.myapp.SystemArchitecture.dataAccessOperation()",
returning="retVal")

public void doAccessCheck(Object retVal) {

    // ...

}

After throwing advice�Q?o:p>

@AfterThrowing("SystemArchitecture.dataAccessOperation()")

public void doRecoveryActions() {

    // ...

}

或�?/span>

@AfterThrowing(

    pointcut=" SystemArchitecture.dataAccessOperation()",

    throwing="ex")

public void doRecoveryActions(DataAccessException ex) {

    // ...

}

After (finally) advice�Q?o:p>

@After("com.xyz.myapp.SystemArchitecture.dataAccessOperation()")

public void doReleaseLock() {

    // ...

}

Around advice�Q?o:p>

@Around("com.xyz.myapp.SystemArchitecture.businessService()")

public Object doBasicProfiling( ProceedingJoinPoint pjp) throws Throwable {

    // start stopwatch

    Object retVal = pjp.proceed();

    // stop stopwatch

    return retVal;

}

Advice parameters�Q?o:p>

@Before("com.xyz.myapp.SystemArchitecture.dataAccessOperation() &&" + "args(account,..)" )

public void validateAccount(Account account) {

// ...

}

声明参数名称�Q?/span>

@Before(

   value="com.xyz.lib.Pointcuts.anyPublicMethod() && " +

         "@annotation(auditable)",

argNames="auditable" )

public void audit(Auditable auditable) {

AuditCode code = auditable.value();

// ...

}

Advice 排序�Q?o:p>

一般以声明的方法次序�ؓ先后

不同�?/span> Advice �Q�通过实现 Ordered 接口�Q�来排序

Introductions

用于引入新的接口

@Aspect

public class UsageTracking {

@DeclareParents(value="com.xzy.myapp.service.*+",

                  defaultImpl=DefaultUsageTracked.class)

public static UsageTracked mixin;

@Before("com.xyz.myapp.SystemArchitecture.businessService() &&" +

          "this(usageTracked)")

public void recordUsage(UsageTracked usageTracked) {

    usageTracked.incrementUseCount();

}

}

布衣�?/a> 2006-09-15 19:31 发表评论

spring 2.0 aop�~�程(一)

Fri, 15 Sep 2006 01:41:00 GMT
在spring2.0中，aop发生了很大的变化�Q?br />主要分�ؓ两大斚w��
1.支持��单的aop xml配置
2.支持@AspectJ的注�?br />
先来看一看第一�U�情况：
��x��一个aspect�Q�在xml中的��x��如下�Q?br />

    ...

...

��x��pointcut

        expression="execution(* com.xyz.myapp.service.*.*(..))"/>

��x��advice
Before advice�Q?/span>

      pointcut-ref="dataAccessOperation"
      method="doAccessCheck"/>
After returning advice:


      pointcut-ref="dataAccessOperation"
      method="doAccessCheck"/>

    ...

或者带有返回参�?/span>


      pointcut-ref="dataAccessOperation"
     returning="retVal"
      method="doAccessCheck"/>

    ...


After throwing advice�Q?/span>


      pointcut-ref="dataAccessOperation"
      method="doRecoveryActions"/>

    ...

或者带有throwing


      pointcut-ref="dataAccessOperation"
      throwing="dataAccessEx"
      method="doRecoveryActions"/>

    ...

After (finally) advice�Q?/span>


      pointcut-ref="dataAccessOperation"
      method="doReleaseLock"/>

    ...

Around advice�Q?/span>


      pointcut-ref="businessService"
      method="doBasicProfiling"/>

    ...

Advice parameters�Q?/span>
pointcut="Pointcuts.anyPublicMethod() and @annotation(auditable)"
method="audit"
  arg-names="auditable"/>

对于引入接口�Q?a name="_Toc144432334">Introductions�Q�：

      types-matching="com.xzy.myapp.service.*+",
      implement-interface="UsageTracked"
      default-impl=" service.tracking.DefaultUsageTracked"/>

    pointcut="com.xyz.myapp.SystemArchitecture.businessService()
              and this(usageTracked)"
    method="recordUsage"/>

布衣�?/a> 2006-09-15 09:41 发表评论

使用aop创徏松散耦合�Q�分析日志程序）

Sat, 09 Sep 2006 00:32:00 GMT
        日志�Q�是每个�pȝ��都不可缺��的。但是，又不是必要的业务需求�?br />        但用于日志记录的代码和主要用于其它职责的代码�~�绕在一赗��根据所解决的问题的复杂�E�度和作用域的不同，所引�v的�؜乱可大可��。更改一个应用程序的日志记录�{�略可能涉及数百�ơ编�?�?即��可行�Q�这是个令�h头疼的�Q务�?br />         考虑一下以下代码：
清单 1. 日志调用手工插入到每个方法中
public void doGet(JspImplicitObjects theObjects) throws ServletException { logger.entry("doGet(...)"); JspTestController controller = new JspTestController(); controller.handleRequest(theObjects); logger.exit("doGet"); }
        可能在不同的�Ҏ��中都存在�q�样的代码。这��造成代码的无限扩张，同时修改也变得非常困难�?br />       使用aop后，更改的代码�ؓ�Q?br />清单 2. 自动应用于每个方法的记录日志调用
public aspect AutoLog{ pointcut publicMethods() : execution(public * org.apache.cactus..*(..)); pointcut logObjectCalls() : execution(* Logger.*(..)); pointcut loggableCalls() : publicMethods() && ! logObjectCalls(); before() : loggableCalls(){ Logger.entry(thisJoinPoint.getSignature().toString()); } after() : loggableCalls(){ Logger.exit(thisJoinPoint.getSignature().toString()); } }
所有的日志�l�护都集中于AutoLog斚w��?br />
Pointcut �?join point
要理�?Pointcut�Q�必需知道 join point 是什么。join point 表示在程序执行中明确定义的点。AspectJ 中典型的 join point 包括�Ҏ��调用、对�c�L��员的讉K��以及异常处理�E�序块的执行。join point 可以包含其它 join point。例如，一个方法调用可能在它返回之前引起其它方法调用。那么，Pointcut ��是一�U�语�a�构造，�q�种构造根据已定义的标准挑选一�l?join point。示例中的第一�?Pointcut �U�Cؓ publicMethods �Q�选择 org.apache.cactus 包中的所有公用（public�Q�方法的执行�?execution 是一个原始的 Pointcut�Q�就�?int 是一�U�原始的 Java �c�d��Q�。它选择与其括号中定义的�Ҏ��说明匚w��的�Q何方法的执行。方法说明允许包含通配�W�；�C�Z��中的一个方法说明包含了几个通配�W�。第二个名�ؓ logObjectCalls �?Pointcut 选择�?Logger �c�M��的所有方法的执行。第三个 Pointcut loggableCalls �Q�通过使用 && ! 合�ƈ了前两个 Pointcut�Q�这意味着它选择了除 Logger �c�M��的公用方法以外， org.apache.cactus 中所有的公用�Ҏ��。（记录 log �Ҏ��导致无限递归。）
Advice
既然 Aspect 已经定义了它应该记录的点�Q�它使用 Advice 来完成实际的日志记录。Advice 是在 join point 之前、之后或周围执行的代码。相对于 Pointcut 来定�?Advice�Q�说�c�M��于“在惌��记录的每个方法调用之后运行这些代码”这��L��话。因�?Advice 如下�Q?/p>
before() : loggableCalls(){ Logger.entry(thisJoinPoint.getSignature().toString()); }

Advice 使用 Logger �c�，其入口和出口�Ҏ��c�M��于下列代码：
public static void entry(String message){ System.out.println("entering method " + message); }

在示例中�Q�传递到记录器的 String 是从 thisJoinPoint �z��的，�q�是一个特�D�的反射对象�Q�它允许讉K�� join point 执行所处的�q�行时上下文。在 Cactus 实际使用�?Aspect 中，Advice 使用�q�种对象来检索传递到每个记录的方法调用中的方法参数。当日志记录 Aspect 应用于代码时�Q�方法调用的�l�果如下�Q?

清单 3. AutoLog Aspect 的输�?/b>
entering method: void test.Logging.main(String[]) entering method: void test.Logging.foo() exiting method: void test.Logging.foo() exiting method: void test.Logging.main(String[])

布衣�?/a> 2006-09-09 08:32 发表评论

理解AOP

Wed, 06 Sep 2006 12:05:00 GMT
         AOP�q�个概念提出来很久了�Q�可对它��L��一知半解。这几天好好补了一下其中的知识�Q�终于有所�H�破�?br />         ��单的来说,AOP��是面向斚w��Q�aspect)�~�程。具体的概念是这��L��Q?br />         面向 Aspect 的编�E�（AOP�Q�是一�U�新的编�E�技术，它允许程序员�?横切关系�Q�crosscutting concerns�Q?/i>�Q�跨��典型职责界限的行�ؓ�Q�例如日志记录）�q�行模块化。AOP 引进�?Aspect�Q?/i>它将影响多个�cȝ��行�ؓ��装��C��个可重用模块中�?br />         �?a name="IDA0ESCC">什么是横切�Q?/font>
        横切是面向方面编�E�的专有名词。它指的是在一个给定的�~�程模型中穿��既定的职责部分�Q�比如日志记录和性能优化�Q�的操作。在横切的世界里�Q�横切有两种�c�d��Q�动态横切和静态横切�?br />        动态横�?/strong>
       动态横�?/i> 是通过切入�?/i> �?�q�接�?/i> 在一�?斚w�� 中创��为的�q�程�Q�连接点可以在执行时横向地应用于现有对象。动态横切通常用于帮助向对象层�ơ中的各�U�方法添加日志记录或�w�䆾认证。下面让我们��q��旉��了解一下动态横切中的一些实际概念：
斚w��Q�aspect�Q?/b>�c�M��?Java �~�程语言中的�c�R��方面定义切入点和通知�Q�advice�Q�，�q�由诸如 AspectJ �q�样的方面编译器来编译，以便��横切（包括动态的和静态的�Q�织入（interweave�Q�现有的对象中�?

一�?�q�接点（join point�Q?/b> 是程序执行中一个精��执行点�Q�比如类中的一个方法。例如，对象 Foo 中的�Ҏ�� bar() ��可以是一个连接点�?�q�接�?/i>是个抽象的概念；不用��d��定义一个连接点�?

一�?切入点（pointcut�Q?/b> 本质上一个用于捕捉连接点的结构。例如，可以定义一个切入点来捕捉对对象 Foo 中的�Ҏ�� bar() 的所有调用。和�q�接点相反，切入炚w��要在斚w��中定义�?

通知�Q�advice�Q?/b> 是切入点的可执行代码。一个经常定义的通知是添加日志记录功能，其中切入�Ҏ��捉对对象 Foo 中的 bar() 的每个调用，然后该通知动态地插入一些日志记录功能，比如捕捉 bar() 的参数�?
       �q�些概念是动态横切的核心�Q�虽然正如我们即��看到的�Q�它们�ƈ不全都是静态横切所必需的�?br />
       静态横�?/strong>
     静态横�?/i> 和动态横切的区别在于它不修改一个给定对象的执行行�ؓ。相反，它允讔R��过引入附加的方法字�D�和属性来修改对象�?�l�构。此外，静态横切可以把扩展和实现附加到对象的基本结构中�?
    虽然现在�q�无法谈及静态横切的普遍使用——它看�v来是 AOP 的一个相�Ҏ��被探索（��管非常��h��吸引力）的特性——然而这一技术蕴含的潜力是巨大的。��用静态横切，架构师和设计者能用一�U�真正面向对象的�Ҏ��有效地徏立复杂系�l�的模型。静态横切允许您不用创徏很深的层�ơ结构，以一�U�本质上更优雅、更逼真于现实结构的方式�Q�插入跨��整个系�l�的公共行�ؓ�?/p>


布衣�?/a> 2006-09-06 20:05 发表评论

中文一区一区三区免费 ,中文字幕日韩专区,久久一二三四

1) 每虚拟机兌���

2)每对�?/span>兌���

3)�?span lang="EN-US">控制���关�?/span>

关于AspectJ 中的pointcut 语法

spring aop 2.0 �~�程(�?

spring aop�~�程(�?

spring 2.0 aop�~�程(一)

使用aop创徏松散耦合�Q�分析日志程序）

理解AOP

1) 每虚拟机兌��

2)每对�?/span>兌��

3)�?span lang="EN-US">控制��关�?/span>