diff options
Diffstat (limited to 'sca-java-1.x/tags/java-stable-20060304/sca/core/src/main/java/org/apache/tuscany/core/invocation/jdk')
3 files changed, 291 insertions, 0 deletions
diff --git a/sca-java-1.x/tags/java-stable-20060304/sca/core/src/main/java/org/apache/tuscany/core/invocation/jdk/JDKInvocationHandler.java b/sca-java-1.x/tags/java-stable-20060304/sca/core/src/main/java/org/apache/tuscany/core/invocation/jdk/JDKInvocationHandler.java new file mode 100644 index 0000000000..2f27698d6b --- /dev/null +++ b/sca-java-1.x/tags/java-stable-20060304/sca/core/src/main/java/org/apache/tuscany/core/invocation/jdk/JDKInvocationHandler.java @@ -0,0 +1,143 @@ +/** + * + * Copyright 2005 The Apache Software Foundation or its licensors, as applicable. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.tuscany.core.invocation.jdk; + +import java.lang.reflect.InvocationHandler; +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; +import java.util.HashMap; +import java.util.Map; + +import org.apache.tuscany.core.context.TargetException; +import org.apache.tuscany.core.invocation.Interceptor; +import org.apache.tuscany.core.invocation.InvocationConfiguration; +import org.apache.tuscany.core.invocation.TargetInvoker; +import org.apache.tuscany.core.message.Message; +import org.apache.tuscany.core.message.MessageFactory; + +/** + * Receives a request from a JDK proxy and dispatches it to a target invoker or source interceptor stack + * + * @version $Rev$ $Date$ + */ +public class JDKInvocationHandler implements InvocationHandler { + + private MessageFactory messageFactory; + + /* + * an association of an operation to configuration holder. The holder contains the master invocation configuration + * and a locale clone of the master TargetInvoker. TargetInvokers will be cloned by the handler and placed in the + * holder if they are cacheable. This allows optimizations such as avoiding target resolution when a source refers + * to a target of greater scope since the target reference can be maintained by the invoker. When a target invoker + * is not cacheable, the master associated with the invocation configuration will be used. + */ + private Map<Method, ConfigHolder> configuration; + + // ---------------------------------- + // Constructors + // ---------------------------------- + + public JDKInvocationHandler(MessageFactory messageFactory, Map<Method, InvocationConfiguration> configuration) { + assert (configuration != null) : "Configuration not specified"; + this.configuration = new HashMap(configuration.size()); + for (Map.Entry<Method, InvocationConfiguration> entry : configuration.entrySet()) { + this.configuration.put(entry.getKey(), new ConfigHolder(entry.getValue())); + } + // this.configuration = configuration; + this.messageFactory = messageFactory; + } + + // ---------------------------------- + // Methods + // ---------------------------------- + + /** + * Dispatches a client request made on a proxy + */ + public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { + Interceptor headInterceptor = null; + ConfigHolder holder = configuration.get(method); + if (holder == null) { + TargetException e = new TargetException("Operation not configured"); + e.setIdentifier(method.getName()); + throw e; + } + InvocationConfiguration config = holder.config; + if (config != null) { + headInterceptor = config.getSourceInterceptor(); + } + + TargetInvoker invoker = null; + + if (holder.cachedInvoker == null) { + if(config.getTargetInvoker() == null){ + TargetException e= new TargetException("No target invoker configured for operation"); + e.setIdentifier(config.getMethod().getName()); + throw e; + } + if (config.getTargetInvoker().isCacheable()) { + // clone and store the invoker locally + holder.cachedInvoker = (TargetInvoker) config.getTargetInvoker().clone(); + invoker = holder.cachedInvoker; + } else { + invoker = config.getTargetInvoker(); + } + } else { + invoker = config.getTargetInvoker(); + } + if (headInterceptor == null) { + try { + // short-circuit the dispatch and invoke the target directly + if (config.getTargetInvoker() == null) { + throw new AssertionError("No target invoker [" + method.getName() + "]"); + } + return config.getTargetInvoker().invokeTarget(args); + } catch (InvocationTargetException e) { + // the cause was thrown by the target so throw it + throw e.getCause(); + } + } else { + Message msg = messageFactory.createMessage(); + msg.setTargetInvoker(invoker);// config.getTargetInvoker()); + msg.setBody(args); + // dispatch the invocation down the chain and get the response + Message resp = headInterceptor.invoke(msg); + + Object body = resp.getBody(); + if (body instanceof Throwable) { + throw (Throwable) body; + } + return body; + } + } + + /** + * A holder used to associate an invocation configuration with a local copy of a target invoker that was previously + * cloned from the configuration master + */ + private class ConfigHolder { + + public ConfigHolder(InvocationConfiguration config) { + this.config = config; + } + + InvocationConfiguration config; + + TargetInvoker cachedInvoker; + } + +}
\ No newline at end of file diff --git a/sca-java-1.x/tags/java-stable-20060304/sca/core/src/main/java/org/apache/tuscany/core/invocation/jdk/JDKProxyFactory.java b/sca-java-1.x/tags/java-stable-20060304/sca/core/src/main/java/org/apache/tuscany/core/invocation/jdk/JDKProxyFactory.java new file mode 100644 index 0000000000..75137ffa36 --- /dev/null +++ b/sca-java-1.x/tags/java-stable-20060304/sca/core/src/main/java/org/apache/tuscany/core/invocation/jdk/JDKProxyFactory.java @@ -0,0 +1,96 @@ +/** + * + * Copyright 2005 The Apache Software Foundation or its licensors, as applicable. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.tuscany.core.invocation.jdk; + +import java.lang.reflect.InvocationHandler; +import java.lang.reflect.Method; +import java.lang.reflect.Proxy; +import java.util.Map; + +import org.apache.tuscany.core.invocation.InvocationConfiguration; +import org.apache.tuscany.core.invocation.MethodHashMap; +import org.apache.tuscany.core.invocation.ProxyConfiguration; +import org.apache.tuscany.core.invocation.spi.ProxyFactory; +import org.apache.tuscany.core.invocation.spi.ProxyInitializationException; + +/** + * Creates proxies for handling invocations using JDK dynamic proxies + * + * @version $Rev$ $Date$ + */ +public class JDKProxyFactory implements ProxyFactory { + + private static final int UNINITIALIZED = 0; + + private static final int INITIALIZED = 1; + + private static final int ERROR = -1; + + private int state = UNINITIALIZED; + + private Class[] businessInterfaceArray; + + private Map<Method, InvocationConfiguration> methodToInvocationConfig; + + private ProxyConfiguration configuration; + + public void initialize() throws ProxyInitializationException { + if (state != UNINITIALIZED) { + throw new IllegalStateException("Proxy factory in wrong state [" + state + "]"); + } + Map<Method, InvocationConfiguration> invocationConfigs = configuration.getInvocationConfigurations(); + methodToInvocationConfig = new MethodHashMap(invocationConfigs.size()); + for (Map.Entry entry : invocationConfigs.entrySet()) { + Method method = (Method) entry.getKey(); + methodToInvocationConfig.put(method, (InvocationConfiguration) entry.getValue()); + } + state = INITIALIZED; + } + + public Object createProxy() { + if (state != INITIALIZED) { + throw new IllegalStateException("Proxy factory not INITIALIZED [" + state + "]"); + } + InvocationHandler handler = new JDKInvocationHandler(configuration.getMessageFactory(), methodToInvocationConfig); + return Proxy.newProxyInstance(configuration.getProxyClassLoader(), businessInterfaceArray, handler); + } + + public ProxyConfiguration getProxyConfiguration() { + return configuration; + } + + public void setProxyConfiguration(ProxyConfiguration config) { + configuration = config; + } + + public void setBusinessInterface(Class interfaze) { + businessInterfaceArray = new Class[] { interfaze }; + } + + public Class getBusinessInterface() { + return businessInterfaceArray[0]; + } + + public void addInterface(Class claz) { + throw new UnsupportedOperationException("Additional proxy interfaces not yet supported"); + } + + public Class[] getImplementatedInterfaces() { + return businessInterfaceArray; + } + +} diff --git a/sca-java-1.x/tags/java-stable-20060304/sca/core/src/main/java/org/apache/tuscany/core/invocation/jdk/JDKProxyFactoryFactory.java b/sca-java-1.x/tags/java-stable-20060304/sca/core/src/main/java/org/apache/tuscany/core/invocation/jdk/JDKProxyFactoryFactory.java new file mode 100644 index 0000000000..81458e4178 --- /dev/null +++ b/sca-java-1.x/tags/java-stable-20060304/sca/core/src/main/java/org/apache/tuscany/core/invocation/jdk/JDKProxyFactoryFactory.java @@ -0,0 +1,52 @@ +/** + * + * Copyright 2005 The Apache Software Foundation or its licensors, as applicable. + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ +package org.apache.tuscany.core.invocation.jdk; + +import java.lang.reflect.InvocationHandler; +import java.lang.reflect.Proxy; + +import org.apache.tuscany.core.invocation.spi.ProxyFactory; +import org.apache.tuscany.core.invocation.spi.ProxyFactoryFactory; + +/** + * Creates JDK Dynamic Proxy-based proxy factories + * + * @version $Rev$ $Date$ + */ +public class JDKProxyFactoryFactory implements ProxyFactoryFactory { + + public JDKProxyFactoryFactory() { + } + + public ProxyFactory createProxyFactory() { + return new JDKProxyFactory(); + } + + public boolean isProxy(Object object) { + if (object == null) { + return false; + } else { + return Proxy.isProxyClass(object.getClass()); + } + } + + public InvocationHandler getHandler(Object proxy) { + if (proxy == null) { + return null; + } else { + return Proxy.getInvocationHandler(proxy); + } + } + +} |