View Javadoc

1   /*
2    * Licensed to the Apache Software Foundation (ASF) under one or more
3    * contributor license agreements.  See the NOTICE file distributed with
4    * this work for additional information regarding copyright ownership.
5    * The ASF licenses this file to You under the Apache License, Version 2.0
6    * (the "License"); you may not use this file except in compliance with
7    * the License.  You may obtain a copy of the License at
8    *
9    *      http://www.apache.org/licenses/LICENSE-2.0
10   *
11   * Unless required by applicable law or agreed to in writing, software
12   * distributed under the License is distributed on an "AS IS" BASIS,
13   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14   * See the License for the specific language governing permissions and
15   * limitations under the License.
16   */
17  
18  package org.apache.commons.proxy.factory.cglib;
19  
20  import net.sf.cglib.proxy.Callback;
21  import net.sf.cglib.proxy.CallbackFilter;
22  import net.sf.cglib.proxy.Dispatcher;
23  import net.sf.cglib.proxy.Enhancer;
24  import net.sf.cglib.proxy.MethodProxy;
25  import net.sf.cglib.proxy.NoOp;
26  import org.apache.commons.proxy.Interceptor;
27  import org.apache.commons.proxy.Invocation;
28  import org.apache.commons.proxy.Invoker;
29  import org.apache.commons.proxy.ObjectProvider;
30  import org.apache.commons.proxy.factory.util.AbstractSubclassingProxyFactory;
31  
32  import java.lang.reflect.Method;
33  import java.lang.reflect.Modifier;
34  
35  /**
36   * A <a href="http://cglib.sourceforge.net/">CGLIB</a>-based {@link org.apache.commons.proxy.ProxyFactory}
37   * implementation.
38   * <p/>
39   * <p/>
40   * <b>Dependencies</b>: <ul> <li>CGLIB version 2.0.2 or greater</li> </ul> </p>
41   *
42   * @author James Carman
43   * @since 1.0
44   */
45  public class CglibProxyFactory extends AbstractSubclassingProxyFactory
46  {
47  //----------------------------------------------------------------------------------------------------------------------
48  // Fields
49  //----------------------------------------------------------------------------------------------------------------------
50  
51      private static CallbackFilter callbackFilter = new PublicCallbackFilter();
52  
53  //----------------------------------------------------------------------------------------------------------------------
54  // ProxyFactory Implementation
55  //----------------------------------------------------------------------------------------------------------------------
56  
57      public Object createDelegatorProxy( ClassLoader classLoader, ObjectProvider targetProvider,
58                                          Class[] proxyClasses )
59      {
60          final Enhancer enhancer = new Enhancer();
61          enhancer.setClassLoader( classLoader );
62          enhancer.setInterfaces( toInterfaces( proxyClasses ) );
63          enhancer.setSuperclass( getSuperclass( proxyClasses ) );
64          enhancer.setCallbackFilter( callbackFilter );
65          enhancer.setCallbacks( new Callback[]{ new ObjectProviderDispatcher( targetProvider ), NoOp.INSTANCE } );
66          return enhancer.create();
67      }
68  
69      public Object createInterceptorProxy( ClassLoader classLoader, Object target, Interceptor interceptor,
70                                            Class[] proxyClasses )
71      {
72          final Enhancer enhancer = new Enhancer();
73          enhancer.setClassLoader( classLoader );
74          enhancer.setInterfaces( toInterfaces( proxyClasses ) );
75          enhancer.setSuperclass( getSuperclass( proxyClasses ) );
76          enhancer.setCallbackFilter( callbackFilter );
77          enhancer.setCallbacks( new Callback[]{ new InterceptorBridge( target, interceptor ), NoOp.INSTANCE } );
78          return enhancer.create();
79      }
80  
81      public Object createInvokerProxy( ClassLoader classLoader, Invoker invoker,
82                                        Class[] proxyClasses )
83      {
84          final Enhancer enhancer = new Enhancer();
85          enhancer.setClassLoader( classLoader );
86          enhancer.setInterfaces( toInterfaces( proxyClasses ) );
87          enhancer.setSuperclass( getSuperclass( proxyClasses ) );
88          enhancer.setCallbackFilter( callbackFilter );
89          enhancer.setCallbacks( new Callback[]{ new InvokerBridge( invoker ), NoOp.INSTANCE } );
90          return enhancer.create();
91      }
92  
93  //----------------------------------------------------------------------------------------------------------------------
94  // Inner Classes
95  //----------------------------------------------------------------------------------------------------------------------
96  
97      private static class PublicCallbackFilter implements CallbackFilter
98      {
99          public int accept( Method method )
100         {
101             return Modifier.isPublic( method.getModifiers() ) ? 0 : 1;
102         }
103     }
104 
105     private class InvokerBridge implements net.sf.cglib.proxy.InvocationHandler
106     {
107         private final Invoker original;
108 
109         public InvokerBridge( Invoker original )
110         {
111             this.original = original;
112         }
113 
114         public Object invoke( Object object, Method method, Object[] objects ) throws Throwable
115         {
116             return original.invoke( object, method, objects );
117         }
118     }
119 
120     private class InterceptorBridge implements net.sf.cglib.proxy.MethodInterceptor
121     {
122         private final Interceptor inner;
123         private final Object target;
124 
125         public InterceptorBridge( Object target, Interceptor inner )
126         {
127             this.inner = inner;
128             this.target = target;
129         }
130 
131         public Object intercept( Object object, Method method, Object[] args, MethodProxy methodProxy ) throws Throwable
132         {
133             return inner.intercept( new MethodProxyInvocation( target, method, args, methodProxy ) );
134         }
135     }
136 
137     private class MethodProxyInvocation implements Invocation
138     {
139         private final MethodProxy methodProxy;
140         private final Method method;
141         private final Object[] args;
142         private final Object target;
143 
144         public MethodProxyInvocation( Object target, Method method, Object[] args, MethodProxy methodProxy )
145         {
146             this.target = target;
147             this.method = method;
148             this.methodProxy = methodProxy;
149             this.args = args;
150         }
151 
152         public Method getMethod()
153         {
154             return method;
155         }
156 
157         public Object[] getArguments()
158         {
159             return args;
160         }
161 
162         public Object proceed() throws Throwable
163         {
164             return methodProxy.invoke( target, args );
165         }
166 
167         public Object getProxy()
168         {
169             return target;
170         }
171     }
172 
173     private class ObjectProviderDispatcher implements Dispatcher
174     {
175         private final ObjectProvider delegateProvider;
176 
177         public ObjectProviderDispatcher( ObjectProvider delegateProvider )
178         {
179             this.delegateProvider = delegateProvider;
180         }
181 
182         public Object loadObject()
183         {
184             return delegateProvider.getObject();
185         }
186     }
187 }
188