KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > nanocontainer > aop > dynaop > DynaopAspectsManager


1 /*****************************************************************************
2  * Copyright (c) PicoContainer Organization. All rights reserved. *
3  * ------------------------------------------------------------------------- *
4  * The software in this package is published under the terms of the BSD *
5  * style license a copy of which has been included with this distribution in *
6  * the LICENSE.txt file. *
7  * *
8  * Idea by Rachel Davies, Original code by various *
9  *****************************************************************************/

10 package org.nanocontainer.aop.dynaop;
11
12 import dynaop.Aspects;
13 import dynaop.Interceptor;
14 import dynaop.InterceptorFactory;
15 import dynaop.ProxyFactory;
16 import dynaop.util.Classes;
17 import org.aopalliance.intercept.MethodInterceptor;
18 import org.nanocontainer.aop.AspectsManager;
19 import org.nanocontainer.aop.ClassPointcut;
20 import org.nanocontainer.aop.ComponentPointcut;
21 import org.nanocontainer.aop.MethodPointcut;
22 import org.nanocontainer.aop.PointcutsFactory;
23 import org.picocontainer.PicoContainer;
24
25 import java.lang.reflect.Method JavaDoc;
26
27 /**
28  * An <code>AspectsManager</code> implemented using dynaop.
29  *
30  * @author Stephen Molitor
31  * @version $Revision: 3144 $
32  */

33 public class DynaopAspectsManager implements AspectsManager {
34
35     private final Aspects containerAspects;
36     private final PointcutsFactory pointcutsFactory;
37     private final ContainerLoader containerLoader = new ContainerLoader();
38     private final PicoContainer container = PicoContainerProxy.create(containerLoader);
39     private final ComponentAspectsCollection componentAspects = new ComponentAspectsCollection();
40
41     /**
42      * Creates a new <code>DynaopAspectsManager</code> that will used the
43      * given <code>dynaop.Aspects</code> object and pointcuts factory. This
44      * constructor might be useful if the <code>containerAspects</code> object
45      * contains aspects already configured via dynaop's API, perhaps using
46      * dynaop's BeanShell configuration mechanism.
47      *
48      * @param containerAspects the <code>dyanop.Aspects</code> object used to
49      * contain the aspects.
50      * @param pointcutsFactory the pointcuts factory.
51      */

52     public DynaopAspectsManager(Aspects containerAspects, PointcutsFactory pointcutsFactory) {
53         this.containerAspects = containerAspects;
54         this.pointcutsFactory = pointcutsFactory;
55     }
56
57     /**
58      * Creates a new <code>DynaopAspectsManager</code> that will used the
59      * given <code>dynaop.Aspects</code> object. This constructor might be
60      * useful if the <code>containerAspects</code> object contains aspects
61      * already configured via dynaop's API, perhaps using dynaop's BeanShell
62      * configuration mechanism.
63      *
64      * @param containerAspects the <code>dyanop.Aspects</code> object used to
65      * contain the aspects.
66      */

67     public DynaopAspectsManager(Aspects containerAspects) {
68         this(containerAspects, new DynaopPointcutsFactory());
69     }
70
71     /**
72      * Creates a new <code>DynaopAspectsManager</code> that will use the given
73      * pointcuts factory.
74      *
75      * @param pointcutsFactory the pointcuts factory.
76      */

77     public DynaopAspectsManager(PointcutsFactory pointcutsFactory) {
78         this(new Aspects(), pointcutsFactory);
79     }
80
81     /**
82      * Creates a new <code>DynaopAspectsManager</code>.
83      */

84     public DynaopAspectsManager() {
85         this(new Aspects());
86     }
87
88     public void registerInterceptor(ClassPointcut classPointcut, MethodPointcut methodPointcut,
89                                     Object JavaDoc interceptorComponentKey) {
90         containerAspects.interceptor(getClassPointcut(classPointcut), getMethodPointcut(methodPointcut),
91                 createInterceptorFactory(interceptorComponentKey));
92     }
93
94     public void registerInterceptor(ClassPointcut classPointcut, MethodPointcut methodPointcut,
95                                     MethodInterceptor interceptor) {
96         containerAspects.interceptor(getClassPointcut(classPointcut), getMethodPointcut(methodPointcut),
97                 createInterceptor(interceptor));
98     }
99
100     public void registerInterceptor(ComponentPointcut componentPointcut, MethodPointcut methodPointcut,
101                                     Object JavaDoc interceptorComponentKey) {
102         componentAspects.add(new InterceptorComponentAspect(componentPointcut, getMethodPointcut(methodPointcut),
103                 createInterceptorFactory(interceptorComponentKey)));
104     }
105
106     public void registerInterceptor(ComponentPointcut componentPointcut, MethodPointcut methodPointcut,
107                                     MethodInterceptor interceptor) {
108         componentAspects.add(new InterceptorComponentAspect(componentPointcut, getMethodPointcut(methodPointcut),
109                 createInterceptor(interceptor)));
110     }
111
112     public void registerMixin(ClassPointcut classPointcut, Class JavaDoc mixinClass) {
113         registerMixin(classPointcut, Classes.getAllInterfaces(mixinClass), mixinClass);
114     }
115
116     public void registerMixin(ClassPointcut classPointcut, Class JavaDoc[] interfaces, Class JavaDoc mixinClass) {
117         containerAspects.mixin(getClassPointcut(classPointcut), interfaces, new ContainerSuppliedMixinFactory(container, mixinClass));
118     }
119
120     public void registerMixin(ComponentPointcut componentPointcut, Class JavaDoc mixinClass) {
121         registerMixin(componentPointcut, Classes.getAllInterfaces(mixinClass), mixinClass);
122     }
123
124     public void registerMixin(ComponentPointcut componentPointcut, Class JavaDoc[] interfaces, Class JavaDoc mixinClass) {
125         componentAspects.add(new MixinComponentAspect(componentPointcut, interfaces, new ContainerSuppliedMixinFactory(container, mixinClass)));
126     }
127
128     public void registerInterfaces(ClassPointcut classPointcut, Class JavaDoc[] interfaces) {
129         containerAspects.interfaces(getClassPointcut(classPointcut), interfaces);
130     }
131
132     public void registerInterfaces(ComponentPointcut componentPointcut, Class JavaDoc[] interfaces) {
133         componentAspects.add(new InterfacesComponentAspect(componentPointcut, interfaces));
134     }
135
136     public PointcutsFactory getPointcutsFactory() {
137         return pointcutsFactory;
138     }
139
140     public Object JavaDoc applyAspects(Object JavaDoc componentKey, Object JavaDoc component, PicoContainer container) {
141         containerLoader.setContainer(container);
142         Aspects aspects = componentAspects.registerAspects(componentKey, containerAspects);
143         return ProxyFactory.getInstance(aspects).wrap(component);
144     }
145
146     private dynaop.ClassPointcut getClassPointcut(final ClassPointcut classPointcut) {
147         if (classPointcut instanceof dynaop.ClassPointcut) {
148             return (dynaop.ClassPointcut) classPointcut;
149         }
150         return new dynaop.ClassPointcut() {
151             public boolean picks(Class JavaDoc clazz) {
152                 return classPointcut.picks(clazz);
153             }
154         };
155     }
156
157     private dynaop.MethodPointcut getMethodPointcut(final MethodPointcut methodPointcut) {
158         if (methodPointcut instanceof dynaop.MethodPointcut) {
159             return (dynaop.MethodPointcut) methodPointcut;
160         }
161         return new dynaop.MethodPointcut() {
162             public boolean picks(Method JavaDoc method) {
163                 return methodPointcut.picks(method);
164             }
165         };
166     }
167
168     private Interceptor createInterceptor(MethodInterceptor methodInterceptor) {
169         return new MethodInterceptorAdapter(methodInterceptor);
170     }
171
172     private InterceptorFactory createInterceptorFactory(Object JavaDoc interceptorComponent) {
173         return new ContainerSuppliedInterceptorFactory(container, interceptorComponent);
174     }
175
176 }
Popular Tags