From 699d2df521ee26e343c53505a2ac1d546ba1965e Mon Sep 17 00:00:00 2001 From: antelder Date: Sat, 28 Mar 2009 09:46:58 +0000 Subject: Create M2 relese branch git-svn-id: http://svn.us.apache.org/repos/asf/tuscany@759448 13f79535-47bb-0310-9956-ffa450edef68 --- .../apache/tuscany/sca/stripes/TuscanyHelper.java | 298 +++++++++++++++++++++ .../tuscany/sca/stripes/TuscanyInterceptor.java | 73 +++++ .../sca/stripes/TuscanyInterceptorSupport.java | 57 ++++ 3 files changed, 428 insertions(+) create mode 100644 branches/sca-java-2.0-M2/modules/stripes/src/main/java/org/apache/tuscany/sca/stripes/TuscanyHelper.java create mode 100644 branches/sca-java-2.0-M2/modules/stripes/src/main/java/org/apache/tuscany/sca/stripes/TuscanyInterceptor.java create mode 100644 branches/sca-java-2.0-M2/modules/stripes/src/main/java/org/apache/tuscany/sca/stripes/TuscanyInterceptorSupport.java (limited to 'branches/sca-java-2.0-M2/modules/stripes/src/main/java/org') diff --git a/branches/sca-java-2.0-M2/modules/stripes/src/main/java/org/apache/tuscany/sca/stripes/TuscanyHelper.java b/branches/sca-java-2.0-M2/modules/stripes/src/main/java/org/apache/tuscany/sca/stripes/TuscanyHelper.java new file mode 100644 index 0000000000..f4d7f48dae --- /dev/null +++ b/branches/sca-java-2.0-M2/modules/stripes/src/main/java/org/apache/tuscany/sca/stripes/TuscanyHelper.java @@ -0,0 +1,298 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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.sca.stripes; + +import java.lang.reflect.Field; +import java.lang.reflect.Method; +import java.util.Collection; +import java.util.Iterator; +import java.util.Map; +import java.util.concurrent.ConcurrentHashMap; + +import javax.servlet.ServletContext; + +import net.sourceforge.stripes.action.ActionBeanContext; +import net.sourceforge.stripes.controller.StripesFilter; +import net.sourceforge.stripes.exception.StripesRuntimeException; +import net.sourceforge.stripes.util.Log; +import net.sourceforge.stripes.util.ReflectUtil; + +import org.apache.tuscany.sca.implementation.web.runtime.utils.ContextHelper; +import org.oasisopen.sca.annotation.Reference; + +/** + *

Static helper class that is used to lookup SCA references and inject them into objects + * (often ActionBeans). Is capable of injecting references through setter methods (property access) + * and also through direct field access if the security policy allows it. Methods and fields + * must be annotated using the SCA {@code @Reference} annotation.

+ * + *

Methods and fields may be public, protected, package-access or private. If they are not + * public an attempt is made to call {@link Method#setAccessible(boolean)} in order to make + * them accessible from this class. If the attempt fails, an exception will be thrown.

+ * + *

Method names can take any form. For example {@code setSomeBean(Bean b)} or + * {@code someBean(bean b)}. In both cases, if a specific Reference name is not supplied, + * the default name of {@code someBean} will be used.

+ * + *

The value of the {@code @Reference} annotation should be the reference on the + * SCA component with an {@code } componentType. + * + *

The first time that any of the injection methods in this class is called with a specific type + * of object, the object's class is examined for annotated fields and methods. The discovered + * fields and methods are then cached for future usage.

+ * + * Created for Tuscany from the Stripes SpringHelper written by Dan Hayes and Tim Fennell + */ +public class TuscanyHelper { + private static final Log log = Log.getInstance(TuscanyHelper.class); + + /** Lazily filled in map of Class to methods annotated with Reference. */ + private static Map, Collection> methodMap = + new ConcurrentHashMap, Collection>(); + + /** Lazily filled in map of Class to fields annotated with Reference. */ + private static Map, Collection> fieldMap = + new ConcurrentHashMap, Collection>(); + + /** + * Injects SCA References using the ComponentContext that is + * derived from the ServletContext, which is in turn looked up using the + * ActionBeanContext. + * + * @param bean the object into which to inject SCA reference + * @param context the ActionBeanContext represented by the current request + */ + public static void injectBeans(Object bean, ActionBeanContext context) { + injectBeans(bean, StripesFilter.getConfiguration().getServletContext()); + } + + /** + * Looks for all methods and fields annotated with {@code @Reference} and attempts + * to lookup and inject a managed bean into the field/property. If any annotated + * element cannot be injected an exception is thrown. + * + * @param bean the bean into which to inject SCA reference + * @param ctx the SCA ComponentContext + */ + public static void injectBeans(Object bean, ServletContext ctx) { + // First inject any values using annotated methods + for (Method m : getMethods(bean.getClass())) { + try { + Reference scaReference = m.getAnnotation(Reference.class); + boolean nameSupplied = !"".equals(scaReference.name()); + String name = nameSupplied ? scaReference.name() : methodToPropertyName(m); + Class beanType = m.getParameterTypes()[0]; + Object managedBean = findReference(ctx, name, beanType, !nameSupplied); + m.invoke(bean, managedBean); + } + catch (Exception e) { + throw new StripesRuntimeException("Exception while trying to lookup and inject " + + "an SCA Reference into a bean of type " + bean.getClass().getSimpleName() + + " using method " + m.toString(), e); + } + } + + // And then inject any properties that are annotated + for (Field f : getFields(bean.getClass())) { + try { + Reference scaReference = f.getAnnotation(Reference.class); + boolean nameSupplied = !"".equals(scaReference.name()); + String name = nameSupplied ? scaReference.name() : f.getName(); + Object managedBean = findReference(ctx, name, f.getType(), !nameSupplied); + f.set(bean, managedBean); + } + catch (Exception e) { + throw new StripesRuntimeException("Exception while trying to lookup and inject " + + "an SCA Referenceinto a bean of type " + bean.getClass().getSimpleName() + + " using field access on field " + f.toString(), e); + } + } + } + + /** + * Fetches the methods on a class that are annotated with Reference. The first time it + * is called for a particular class it will introspect the class and cache the results. + * All non-overridden methods are examined, including protected and private methods. + * If a method is not public an attempt it made to make it accessible - if it fails + * it is removed from the collection and an error is logged. + * + * @param clazz the class on which to look for Reference annotated methods + * @return the collection of methods with the annotation + */ + protected static Collection getMethods(Class clazz) { + Collection methods = methodMap.get(clazz); + if (methods == null) { + methods = ReflectUtil.getMethods(clazz); + Iterator iterator = methods.iterator(); + + while (iterator.hasNext()) { + Method method = iterator.next(); + if (!method.isAnnotationPresent(Reference.class)) { + iterator.remove(); + } + else { + // If the method isn't public, try to make it accessible + if (!method.isAccessible()) { + try { + method.setAccessible(true); + } + catch (SecurityException se) { + throw new StripesRuntimeException( + "Method " + clazz.getName() + "." + method.getName() + "is marked " + + "with @Reference and is not public. An attempt to call " + + "setAccessible(true) resulted in a SecurityException. Please " + + "either make the method public or modify your JVM security " + + "policy to allow Stripes to setAccessible(true).", se); + } + } + + // Ensure the method has only the one parameter + if (method.getParameterTypes().length != 1) { + throw new StripesRuntimeException( + "A method marked with @Reference must have exactly one parameter: " + + "the bean to be injected. Method [" + method.toGenericString() + "] has " + + method.getParameterTypes().length + " parameters." + ); + } + } + } + + methodMap.put(clazz, methods); + } + + return methods; + } + + /** + * Fetches the fields on a class that are annotated with Refernece. The first time it + * is called for a particular class it will introspect the class and cache the results. + * All non-overridden fields are examined, including protected and private fields. + * If a field is not public an attempt it made to make it accessible - if it fails + * it is removed from the collection and an error is logged. + * + * @param clazz the class on which to look for Reference annotated fields + * @return the collection of methods with the annotation + */ + protected static Collection getFields(Class clazz) { + Collection fields = fieldMap.get(clazz); + if (fields == null) { + fields = ReflectUtil.getFields(clazz); + Iterator iterator = fields.iterator(); + + while (iterator.hasNext()) { + Field field = iterator.next(); + if (!field.isAnnotationPresent(Reference.class)) { + iterator.remove(); + } + else if (!field.isAccessible()) { + // If the field isn't public, try to make it accessible + try { + field.setAccessible(true); + } + catch (SecurityException se) { + throw new StripesRuntimeException( + "Field " + clazz.getName() + "." + field.getName() + "is marked " + + "with @Reference and is not public. An attempt to call " + + "setAccessible(true) resulted in a SecurityException. Please " + + "either make the field public, annotate a public setter instead " + + "or modify your JVM security policy to allow Stripes to " + + "setAccessible(true).", se); + } + } + } + + fieldMap.put(clazz, fields); + } + + return fields; + } + + /** + * Looks up an SCA Reference from a ComponentContext. First looks for a bean + * with name specified. If no such bean exists, looks for a bean by type. If there is + * only one bean of the appropriate type, it is returned. If zero or more than one bean + * of the correct type exists, an exception is thrown. + * + * @param ctx the SCA ComponentContext + * @param name the name of the reference to look for + * @param type the type of bean to look for + * @param allowFindByType true to indicate that finding a bean by type is acceptable + * if find by name fails. + * @exception RuntimeException various subclasses of RuntimeException are thrown if it + * is not possible to find a unique matching bean in the ComponentContext given + * the constraints supplied. + */ + protected static Object findReference(ServletContext ctx, + String name, + Class type, + boolean allowFindByType) { + // First try to lookup using the name provided + Object bean = ContextHelper.getReference(name, type, ctx); + if (bean == null) { + throw new StripesRuntimeException("no reference defined:" + name); + } + + log.debug("Found sca reference with name [", name, "] and type [", + bean.getClass().getName(), "]"); + return bean; + +// TODO: Support get by type (sca autowire?) + +// // If we got here then we didn't find a bean yet, try by type +// String[] beanNames = ctx.getBeanNamesForType(type); +// if (beanNames.length == 0) { +// throw new StripesRuntimeException( +// "Unable to find SpringBean with name [" + name + "] or type [" + +// type.getName() + "] in the Spring application context."); +// } +// else if (beanNames.length > 1) { +// throw new StripesRuntimeException( +// "Unable to find SpringBean with name [" + name + "] or unique bean with type [" + +// type.getName() + "] in the Spring application context. Found " + beanNames.length + +// "beans of matching type."); +// } +// else { +// log.warn("Found unique SpringBean with type [" + type.getName() + "]. Matching on ", +// "type is a little risky so watch out!"); +// return ctx.getBean(beanNames[0], type); +// } + } + + /** + * A slightly unusual, and somewhat "loose" conversion of a method name to a property + * name. Assumes that the name is in fact a mutator for a property and will do the + * usual {@code setFoo} to {@code foo} conversion if the method follows the normal + * syntax, otherwise will just return the method name. + * + * @param m the method to determine the property name of + * @return a String property name + */ + protected static String methodToPropertyName(Method m) { + String name = m.getName(); + if (name.startsWith("set") && name.length() > 3) { + String ret = name.substring(3,4).toLowerCase(); + if (name.length() > 4) ret += name.substring(4); + return ret; + } + else { + return name; + } + } +} diff --git a/branches/sca-java-2.0-M2/modules/stripes/src/main/java/org/apache/tuscany/sca/stripes/TuscanyInterceptor.java b/branches/sca-java-2.0-M2/modules/stripes/src/main/java/org/apache/tuscany/sca/stripes/TuscanyInterceptor.java new file mode 100644 index 0000000000..1381266c9e --- /dev/null +++ b/branches/sca-java-2.0-M2/modules/stripes/src/main/java/org/apache/tuscany/sca/stripes/TuscanyInterceptor.java @@ -0,0 +1,73 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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.sca.stripes; + +import net.sourceforge.stripes.action.Resolution; +import net.sourceforge.stripes.controller.ExecutionContext; +import net.sourceforge.stripes.controller.Interceptor; +import net.sourceforge.stripes.controller.Intercepts; +import net.sourceforge.stripes.controller.LifecycleStage; +import net.sourceforge.stripes.util.Log; + + +/** + *

An {@link Interceptor} that uses the implementation.web ComponentContext to inject reference + * proxies into newly created ActionBeans immediately following ActionBeanResolution. For more + * information on how the injection is performed see {@link TuscanyHelper#injectBeans(Object, + * net.sourceforge.stripes.action.ActionBeanContext)}.

+ * + *

To configure the TuscanyInterceptor for use you will need to add the following to your + * web.xml (assuming no other interceptors are yet configured):

+ * + * 
+ * <init-param>
+ *     <param-name>Interceptor.Classes</param-name>
+ *     <param-value>
+ *         org.apache.tuscany.sca.stripes.TuscanyInterceptor,
+ *         net.sourceforge.stripes.controller.BeforeAfterMethodInterceptor
+ *     </param-value>
+ * </init-param>
+ *
+ * + *

If one or more interceptors are already configured in your web.xml simply separate the + * fully qualified names of the interceptors with commas (additional whitespace is ok).

+ * + * Created for Tuscany from the Stripes SpringInterceptor written by Tim Fennell + */ +@Intercepts(LifecycleStage.ActionBeanResolution) +public class TuscanyInterceptor implements Interceptor { + private static final Log log = Log.getInstance(TuscanyInterceptor.class); + + /** + * Allows ActionBean resolution to proceed and then once the ActionBean has been + * located invokes the {@link TuscanyHelper} to perform SCA reference injection. + * + * @param context the current execution context + * @return the Resolution produced by calling context.proceed() + * @throws Exception if the Tuscany injection process produced unrecoverable errors + */ + public Resolution intercept(ExecutionContext context) throws Exception { + Resolution resolution = context.proceed(); + log.debug("Running Tuscany dependency injection for instance of ", + context.getActionBean().getClass().getSimpleName()); + TuscanyHelper.injectBeans(context.getActionBean(), context.getActionBeanContext()); + return resolution; + } +} diff --git a/branches/sca-java-2.0-M2/modules/stripes/src/main/java/org/apache/tuscany/sca/stripes/TuscanyInterceptorSupport.java b/branches/sca-java-2.0-M2/modules/stripes/src/main/java/org/apache/tuscany/sca/stripes/TuscanyInterceptorSupport.java new file mode 100644 index 0000000000..4c73f28a08 --- /dev/null +++ b/branches/sca-java-2.0-M2/modules/stripes/src/main/java/org/apache/tuscany/sca/stripes/TuscanyInterceptorSupport.java @@ -0,0 +1,57 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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.sca.stripes; + +import net.sourceforge.stripes.config.ConfigurableComponent; +import net.sourceforge.stripes.config.Configuration; +import net.sourceforge.stripes.controller.Interceptor; + +import javax.servlet.ServletContext; + +/** + *

Base class for developing Interceptors with dependencies on SCA component references. Not + * to be confused with {@link TuscanyInterceptor} which injects SCA reference proxies into + * ActionBeans. For example, you may wish to subclass this class in order to write an + * interceptor with access to Tuscany ???.

+ * + * TODO: does Tuscany really need this? + * + *

Since Interceptors are long-lived objects that are instantiated at application startup + * time, and not per-request, the Tuscany wiring takes place in the init() method and happens + * only once when the interceptor is first created and initialized.

+ * + * Created for Tuscany from the Stripes SpringInterceptorSupport written by Tim Fennell + */ +public abstract class TuscanyInterceptorSupport implements Interceptor, ConfigurableComponent { + + /** + * Fetches the ServletContext and invokes TuscanyHelper.injectBeans() to auto-wire any + * Tuscany dependencies prior to being placed into service. + * + * @param configuration the Stripes Configuration + * @throws Exception if there are problems with the Tuscany configuration/wiring + */ + public void init(Configuration configuration) throws Exception { + ServletContext ctx = configuration.getBootstrapPropertyResolver() + .getFilterConfig().getServletContext(); + + TuscanyHelper.injectBeans(this, ctx); + } +} -- cgit v1.2.3