Author: pete.muir(a)jboss.org Date: 2009-11-07 16:50:44 -0500 (Sat, 07 Nov 2009) New Revision: 4753 Added: core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/AbstractFacade.java core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/AbstractFacadeBean.java core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/BeanManagerBean.java core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/CallableMethodHandler.java core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/EventBean.java core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/FacadeBeanResolvableTransformer.java core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/InstanceBean.java core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/InstanceImpl.java core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/ee/ core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/ee/AbstractEEBean.java core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/ee/AbstractEECallable.java Removed: core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/ManagerBean.java core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/facade/ core/trunk/impl/src/main/java/org/jboss/weld/bean/ee/ Modified: core/trunk/impl/src/main/java/org/jboss/weld/bean/AbstractBean.java core/trunk/impl/src/main/java/org/jboss/weld/bean/AbstractClassBean.java core/trunk/impl/src/main/java/org/jboss/weld/bean/AbstractProducerBean.java core/trunk/impl/src/main/java/org/jboss/weld/bean/DisposalMethod.java core/trunk/impl/src/main/java/org/jboss/weld/bean/ManagedBean.java core/trunk/impl/src/main/java/org/jboss/weld/bean/ProducerMethod.java core/trunk/impl/src/main/java/org/jboss/weld/bean/RIBean.java core/trunk/impl/src/main/java/org/jboss/weld/bean/SessionBean.java core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/AbstractBuiltInBean.java core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/ExtensionBean.java core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/ee/DefaultValidatorBean.java core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/ee/DefaultValidatorFactoryBean.java core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/ee/EEResourceProducerField.java core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/ee/PersistenceContextProducerField.java core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/ee/PrincipalBean.java core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/ee/UserTransactionBean.java core/trunk/impl/src/main/java/org/jboss/weld/bean/proxy/ClientProxyProvider.java core/trunk/impl/src/main/java/org/jboss/weld/bean/proxy/DecoratorProxyMethodHandler.java core/trunk/impl/src/main/java/org/jboss/weld/bootstrap/AbstractBeanDeployer.java core/trunk/impl/src/main/java/org/jboss/weld/bootstrap/BeanDeployment.java core/trunk/impl/src/main/java/org/jboss/weld/bootstrap/WeldBootstrap.java core/trunk/impl/src/main/java/org/jboss/weld/bootstrap/events/AfterBeanDiscoveryImpl.java core/trunk/impl/src/main/java/org/jboss/weld/conversation/AbstractConversationManager.java core/trunk/impl/src/main/java/org/jboss/weld/event/EventImpl.java core/trunk/impl/src/main/java/org/jboss/weld/injection/ConstructorInjectionPoint.java core/trunk/impl/src/main/java/org/jboss/weld/injection/FieldInjectionPoint.java core/trunk/impl/src/main/java/org/jboss/weld/injection/MethodInjectionPoint.java core/trunk/impl/src/main/java/org/jboss/weld/injection/ParameterInjectionPoint.java core/trunk/impl/src/main/java/org/jboss/weld/injection/WeldInjectionPoint.java core/trunk/impl/src/main/java/org/jboss/weld/introspector/ForwardingWeldClass.java core/trunk/impl/src/main/java/org/jboss/weld/introspector/ForwardingWeldConstructor.java core/trunk/impl/src/main/java/org/jboss/weld/introspector/ForwardingWeldMethod.java core/trunk/impl/src/main/java/org/jboss/weld/introspector/ForwardingWeldParameter.java core/trunk/impl/src/main/java/org/jboss/weld/introspector/WeldCallable.java core/trunk/impl/src/main/java/org/jboss/weld/introspector/WeldClass.java core/trunk/impl/src/main/java/org/jboss/weld/introspector/WeldParameter.java core/trunk/impl/src/main/java/org/jboss/weld/introspector/jlr/ConstructorSignatureImpl.java core/trunk/impl/src/main/java/org/jboss/weld/introspector/jlr/MethodSignatureImpl.java core/trunk/impl/src/main/java/org/jboss/weld/introspector/jlr/WeldClassImpl.java core/trunk/impl/src/main/java/org/jboss/weld/introspector/jlr/WeldConstructorImpl.java core/trunk/impl/src/main/java/org/jboss/weld/introspector/jlr/WeldMethodImpl.java core/trunk/impl/src/main/java/org/jboss/weld/introspector/jlr/WeldParameterImpl.java core/trunk/impl/src/main/java/org/jboss/weld/resolution/TypeSafeBeanResolver.java core/trunk/impl/src/main/java/org/jboss/weld/util/Beans.java core/trunk/impl/src/main/java/org/jboss/weld/util/Proxies.java Log: WELD-214, WELD-64, WELD-250, WELD-227, WELD-231 Modified: core/trunk/impl/src/main/java/org/jboss/weld/bean/AbstractBean.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/bean/AbstractBean.java 2009-11-07 21:36:10 UTC (rev 4752) +++ core/trunk/impl/src/main/java/org/jboss/weld/bean/AbstractBean.java 2009-11-07 21:50:44 UTC (rev 4753) @@ -101,8 +101,6 @@ // The Bean manager protected BeanManagerImpl manager; - private boolean _serializable; - private boolean initialized; @@ -143,7 +141,6 @@ log.trace(CREATING_BEAN, getType()); initName(); initScopeType(); - initSerializable(); initProxyable(); checkDelegateInjectionPoints(); } @@ -492,18 +489,6 @@ return primitive; } - public boolean isSerializable() - { - // TODO WTF - why are we not caching the serializability of injection - // points! - return _serializable && checkInjectionPointsAreSerializable(); - } - - protected void initSerializable() - { - _serializable = Reflections.isSerializable(type); - } - @Override public boolean isProxyable() { Modified: core/trunk/impl/src/main/java/org/jboss/weld/bean/AbstractClassBean.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/bean/AbstractClassBean.java 2009-11-07 21:36:10 UTC (rev 4752) +++ core/trunk/impl/src/main/java/org/jboss/weld/bean/AbstractClassBean.java 2009-11-07 21:50:44 UTC (rev 4753) @@ -22,15 +22,12 @@ import static org.jboss.weld.logging.messages.BeanMessage.USING_SCOPE; import java.lang.annotation.Annotation; -import java.lang.reflect.Type; import java.util.ArrayList; import java.util.Collections; import java.util.HashSet; -import java.util.LinkedHashSet; import java.util.List; import java.util.Set; -import javassist.util.proxy.ProxyFactory; import javassist.util.proxy.ProxyObject; import javax.enterprise.context.Dependent; @@ -52,22 +49,23 @@ import org.jboss.weld.BeanManagerImpl; import org.jboss.weld.DefinitionException; import org.jboss.weld.DeploymentException; -import org.jboss.weld.serialization.spi.helpers.SerializableContextualInstance; -import org.jboss.weld.serialization.spi.helpers.SerializableContextual; -import org.jboss.weld.context.SerializableContextualInstanceImpl; -import org.jboss.weld.context.SerializableContextualImpl; -import org.jboss.weld.ejb.EJBApiAbstraction; import org.jboss.weld.bean.proxy.DecoratorProxyMethodHandler; import org.jboss.weld.bootstrap.BeanDeployerEnvironment; +import org.jboss.weld.context.SerializableContextualImpl; +import org.jboss.weld.context.SerializableContextualInstanceImpl; +import org.jboss.weld.ejb.EJBApiAbstraction; import org.jboss.weld.injection.FieldInjectionPoint; import org.jboss.weld.injection.MethodInjectionPoint; import org.jboss.weld.introspector.WeldClass; import org.jboss.weld.introspector.WeldMethod; import org.jboss.weld.metadata.cache.MetaAnnotationStore; +import org.jboss.weld.serialization.spi.helpers.SerializableContextual; +import org.jboss.weld.serialization.spi.helpers.SerializableContextualInstance; import org.jboss.weld.util.Beans; import org.jboss.weld.util.Proxies; import org.jboss.weld.util.Reflections; import org.jboss.weld.util.Strings; +import org.jboss.weld.util.Proxies.TypeInfo; import org.slf4j.cal10n.LocLogger; /** @@ -173,14 +171,7 @@ protected void initProxyClassForDecoratedBean() { - Set<Type> types = new LinkedHashSet<Type>(getTypes()); - types.add(TargetInstanceProxy.class); - ProxyFactory proxyFactory = Proxies.getProxyFactory(types); - - @SuppressWarnings("unchecked") - Class<T> proxyClass = proxyFactory.createClass(); - - this.proxyClassForDecorators = proxyClass; + this.proxyClassForDecorators = Proxies.createProxyClass(TypeInfo.of(getTypes()).add(TargetInstanceProxy.class)); } protected T applyDecorators(T instance, CreationalContext<T> creationalContext, InjectionPoint originalInjectionPoint) Modified: core/trunk/impl/src/main/java/org/jboss/weld/bean/AbstractProducerBean.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/bean/AbstractProducerBean.java 2009-11-07 21:36:10 UTC (rev 4752) +++ core/trunk/impl/src/main/java/org/jboss/weld/bean/AbstractProducerBean.java 2009-11-07 21:50:44 UTC (rev 4753) @@ -21,6 +21,7 @@ import static org.jboss.weld.logging.messages.BeanMessage.USING_DEFAULT_SCOPE; import static org.jboss.weld.logging.messages.BeanMessage.USING_SCOPE; +import java.io.Serializable; import java.lang.annotation.Annotation; import java.lang.reflect.Constructor; import java.lang.reflect.Field; @@ -65,6 +66,7 @@ private static final LocLogger log = loggerFactory().getLogger(BEAN); private Producer<T> producer; + private boolean passivationCapable; /** * Constructor @@ -152,9 +154,28 @@ getDeclaringBean().initialize(environment); super.initialize(environment); checkProducerReturnType(); + initPassivationCapable(); } + private void initPassivationCapable() + { + if (getAnnotatedItem().isFinal() && !Serializable.class.isAssignableFrom(getAnnotatedItem().getJavaClass())) + { + this.passivationCapable = false; + } + else + { + this.passivationCapable = true; + } + } + @Override + public boolean isPassivationCapable() + { + return passivationCapable; + } + + @Override public Set<InjectionPoint> getInjectionPoints() { return getProducer().getInjectionPoints(); @@ -183,7 +204,7 @@ { return; } - if (!Reflections.isSerializable(instance.getClass()) && Beans.isPassivationCapableBean(injectionPoint.getBean())) + if (!Reflections.isSerializable(instance.getClass()) && Beans.isPassivatingScope(injectionPoint.getBean(), manager)) { if (injectionPoint.getMember() instanceof Field) { @@ -238,18 +259,6 @@ } } - @Override - protected void initSerializable() - { - // No-op - } - - @Override - public boolean isSerializable() - { - return true; - } - /** * This operation is *not* threadsafe, and should not be called outside bootstrap * Modified: core/trunk/impl/src/main/java/org/jboss/weld/bean/DisposalMethod.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/bean/DisposalMethod.java 2009-11-07 21:36:10 UTC (rev 4752) +++ core/trunk/impl/src/main/java/org/jboss/weld/bean/DisposalMethod.java 2009-11-07 21:50:44 UTC (rev 4753) @@ -96,7 +96,7 @@ { // At least 1 parameter exists, already checked in constructor this.bindings = new HashSet<Annotation>(); - this.bindings.addAll(disposalMethodInjectionPoint.getWBParameters().get(0).getQualifiers()); + this.bindings.addAll(disposalMethodInjectionPoint.getWeldParameters().get(0).getQualifiers()); initDefaultBindings(); } @@ -144,7 +144,7 @@ } @Override - public boolean isSerializable() + public boolean isPassivationCapable() { // Not relevant return false; @@ -179,7 +179,7 @@ private void checkDisposalMethod() { - if (!disposalMethodInjectionPoint.getWBParameters().get(0).isAnnotationPresent(Disposes.class)) + if (!disposalMethodInjectionPoint.getWeldParameters().get(0).isAnnotationPresent(Disposes.class)) { throw new DefinitionException(disposalMethodInjectionPoint.toString() + " doesn't have @Dispose as first parameter"); } Modified: core/trunk/impl/src/main/java/org/jboss/weld/bean/ManagedBean.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/bean/ManagedBean.java 2009-11-07 21:36:10 UTC (rev 4752) +++ core/trunk/impl/src/main/java/org/jboss/weld/bean/ManagedBean.java 2009-11-07 21:50:44 UTC (rev 4753) @@ -83,6 +83,8 @@ private Set<WeldInjectionPoint<?, ?>> resourceInjectionPoints; private ManagedBean<?> specializedBean; + + private boolean passivationCapable; /** * Creates a simple, annotation defined Web Bean @@ -186,6 +188,7 @@ initPostConstruct(); initPreDestroy(); initEEInjectionPoints(); + initPassivationCapable(); if (isInterceptionCandidate()) { initDirectlyDefinedInterceptors(); @@ -255,6 +258,18 @@ } } + private void initPassivationCapable() + { + this.passivationCapable = Reflections.isSerializable(getAnnotatedItem().getJavaClass()); + // TODO Add in interceptor and decorator checks + } + + @Override + public boolean isPassivationCapable() + { + return passivationCapable; + } + private void initEEInjectionPoints() { this.ejbInjectionPoints = Beans.getEjbInjectionPoints(this, getAnnotatedItem(), getManager()); @@ -296,7 +311,7 @@ DecoratorImpl<?> decoratorBean = (DecoratorImpl<?>) decorator; for (WeldMethod<?, ?> decoratorMethod : decoratorBean.getAnnotatedItem().getWeldMethods()) { - WeldMethod<?, ?> method = getAnnotatedItem().getWBMethod(decoratorMethod.getSignature()); + WeldMethod<?, ?> method = getAnnotatedItem().getWeldMethod(decoratorMethod.getSignature()); if (method != null && !method.isStatic() && !method.isPrivate() && method.isFinal()) { throw new DefinitionException("Decorated bean method " + method + " (decorated by "+ decoratorMethod + ") cannot be declarted final"); Modified: core/trunk/impl/src/main/java/org/jboss/weld/bean/ProducerMethod.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/bean/ProducerMethod.java 2009-11-07 21:36:10 UTC (rev 4752) +++ core/trunk/impl/src/main/java/org/jboss/weld/bean/ProducerMethod.java 2009-11-07 21:50:44 UTC (rev 4753) @@ -133,7 +133,7 @@ */ protected void initProducerMethodInjectableParameters() { - for (WeldParameter<?, ?> parameter : method.getWBParameters()) + for (WeldParameter<?, ?> parameter : method.getWeldParameters()) { addInjectionPoint(ParameterInjectionPoint.of(this, parameter)); } Modified: core/trunk/impl/src/main/java/org/jboss/weld/bean/RIBean.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/bean/RIBean.java 2009-11-07 21:36:10 UTC (rev 4752) +++ core/trunk/impl/src/main/java/org/jboss/weld/bean/RIBean.java 2009-11-07 21:50:44 UTC (rev 4753) @@ -85,6 +85,8 @@ } public abstract boolean isProxyable(); + + public abstract boolean isPassivationCapable(); public boolean isProxyRequired() { Modified: core/trunk/impl/src/main/java/org/jboss/weld/bean/SessionBean.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/bean/SessionBean.java 2009-11-07 21:36:10 UTC (rev 4752) +++ core/trunk/impl/src/main/java/org/jboss/weld/bean/SessionBean.java 2009-11-07 21:50:44 UTC (rev 4753) @@ -24,13 +24,9 @@ import java.util.Collections; import java.util.HashSet; import java.util.LinkedHashMap; -import java.util.LinkedHashSet; import java.util.Map; import java.util.Set; -import javassist.util.proxy.ProxyFactory; -import javassist.util.proxy.ProxyObject; - import javax.decorator.Decorator; import javax.enterprise.context.ApplicationScoped; import javax.enterprise.context.spi.CreationalContext; @@ -49,7 +45,6 @@ import org.jboss.weld.bean.proxy.EnterpriseBeanProxyMethodHandler; import org.jboss.weld.bean.proxy.Marker; import org.jboss.weld.bootstrap.BeanDeployerEnvironment; -import org.jboss.weld.serialization.spi.helpers.SerializableContextual; import org.jboss.weld.ejb.InternalEjbDescriptor; import org.jboss.weld.ejb.api.SessionObjectReference; import org.jboss.weld.ejb.spi.BusinessInterfaceDescriptor; @@ -58,8 +53,10 @@ import org.jboss.weld.introspector.WeldClass; import org.jboss.weld.introspector.WeldMethod; import org.jboss.weld.resources.ClassTransformer; +import org.jboss.weld.serialization.spi.helpers.SerializableContextual; import org.jboss.weld.util.Beans; import org.jboss.weld.util.Proxies; +import org.jboss.weld.util.Proxies.TypeInfo; /** * An enterprise bean representation @@ -169,8 +166,7 @@ { T instance = proxyClass.newInstance(); ctx.push(instance); - ((ProxyObject) instance).setHandler(new EnterpriseBeanProxyMethodHandler<T>(SessionBean.this, ctx)); - return instance; + return Proxies.attachMethodHandler(instance, new EnterpriseBeanProxyMethodHandler<T>(SessionBean.this, ctx)); } catch (InstantiationException e) { @@ -211,15 +207,7 @@ protected void initProxyClass() { - Set<Type> types = new LinkedHashSet<Type>(getTypes()); - types.add(EnterpriseBeanInstance.class); - types.add(Serializable.class); - ProxyFactory proxyFactory = Proxies.getProxyFactory(types); - - @SuppressWarnings("unchecked") - Class<T> proxyClass = proxyFactory.createClass(); - - this.proxyClass = proxyClass; + this.proxyClass = Proxies.createProxyClass(TypeInfo.of(getTypes()).add(EnterpriseBeanInstance.class).add(Serializable.class)); } /** @@ -351,16 +339,10 @@ } @Override - protected void initSerializable() + public boolean isPassivationCapable() { - // No-op + return getEjbDescriptor().isStateful(); } - - @Override - public boolean isSerializable() - { - return true; - } public InternalEjbDescriptor<T> getEjbDescriptor() { Modified: core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/AbstractBuiltInBean.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/AbstractBuiltInBean.java 2009-11-07 21:36:10 UTC (rev 4752) +++ core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/AbstractBuiltInBean.java 2009-11-07 21:50:44 UTC (rev 4753) @@ -112,6 +112,12 @@ } @Override + public boolean isPassivationCapable() + { + return true; + } + + @Override public String getDescription() { return "Built-in bean " + getClass().getSimpleName(); Copied: core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/AbstractFacade.java (from rev 4715, core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/facade/AbstractFacade.java) =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/AbstractFacade.java (rev 0) +++ core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/AbstractFacade.java 2009-11-07 21:50:44 UTC (rev 4753) @@ -0,0 +1,149 @@ +/* + * JBoss, Home of Professional Open Source + * Copyright 2008, Red Hat Middleware LLC, and individual contributors + * by the @authors tag. See the copyright.txt in the distribution for a + * full listing of individual contributors. + * + * 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.jboss.weld.bean.builtin; + +import java.io.Serializable; +import java.lang.annotation.Annotation; +import java.lang.reflect.ParameterizedType; +import java.lang.reflect.Type; +import java.util.Arrays; + +import javax.enterprise.inject.spi.InjectionPoint; + +import org.jboss.weld.BeanManagerImpl; + +/** + * Common implementation for binding-type-based helpers + * + * @author Gavin King + * + * @param <T> + */ +public abstract class AbstractFacade<T, X> +{ + + protected static Type getFacadeType(InjectionPoint injectionPoint) + { + Type genericType = injectionPoint.getType(); + if (genericType instanceof ParameterizedType ) + { + return ((ParameterizedType) genericType).getActualTypeArguments()[0]; + } + else + { + throw new IllegalStateException("Must have concrete type argument " + injectionPoint); + } + } + + private final BeanManagerImpl beanManager; + private final InjectionPoint injectionPoint; + private final Type type; + private final Annotation[] qualifiers; + + protected AbstractFacade(Type type, Annotation[] qualifiers, InjectionPoint injectionPoint, BeanManagerImpl beanManager) + { + this.beanManager = beanManager; + this.injectionPoint = injectionPoint; + this.type = type; + this.qualifiers = qualifiers; + } + + protected BeanManagerImpl getBeanManager() + { + return beanManager.getCurrent(); + } + + protected Annotation[] getQualifiers() + { + return qualifiers; + } + + protected Type getType() + { + return type; + } + + protected InjectionPoint getInjectionPoint() + { + return injectionPoint; + } + + + /** + * Gets a string representation + * + * @return A string representation + */ + @Override + public String toString() + { + return "Abstract facade implmentation"; + } + + @Override + public boolean equals(Object obj) + { + if (obj instanceof AbstractFacade<?, ?>) + { + AbstractFacade<?, ?> that = (AbstractFacade<?, ?>) obj; + return this.getType().equals(that.getType()) && Arrays.equals(this.getQualifiers(), that.getQualifiers()); + } + else + { + return false; + } + } + + @Override + public int hashCode() + { + int hashCode = 17; + hashCode += getType().hashCode() * 5; + hashCode += Arrays.hashCode(getQualifiers()) * 7; + return hashCode; + } + + // Serialization + + protected static class AbstractFacadeSerializationProxy implements Serializable + { + + private static final long serialVersionUID = -9118965837530101152L; + + private final InjectionPoint injectionPoint; + private final BeanManagerImpl beanManager; + + protected AbstractFacadeSerializationProxy(AbstractFacade<?, ?> facade) + { + this.injectionPoint = facade.getInjectionPoint(); + this.beanManager = facade.getBeanManager(); + } + + protected BeanManagerImpl getBeanManager() + { + return beanManager; + } + + protected InjectionPoint getInjectionPoint() + { + return injectionPoint; + } + + } + + +} \ No newline at end of file Property changes on: core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/AbstractFacade.java ___________________________________________________________________ Name: svn:eol-style + native Copied: core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/AbstractFacadeBean.java (from rev 4715, core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/facade/AbstractFacadeBean.java) =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/AbstractFacadeBean.java (rev 0) +++ core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/AbstractFacadeBean.java 2009-11-07 21:50:44 UTC (rev 4753) @@ -0,0 +1,60 @@ +/* + * JBoss, Home of Professional Open Source + * Copyright 2008, Red Hat Middleware LLC, and individual contributors + * by the @authors tag. See the copyright.txt in the distribution for a + * full listing of individual contributors. + * + * 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.jboss.weld.bean.builtin; + +import static org.jboss.weld.logging.Category.BEAN; +import static org.jboss.weld.logging.LoggerFactory.loggerFactory; +import static org.jboss.weld.logging.messages.BeanMessage.DYNAMIC_LOOKUP_OF_BUILT_IN_NOT_ALLOWED; + +import javax.enterprise.context.spi.CreationalContext; +import javax.enterprise.inject.spi.InjectionPoint; + +import org.jboss.weld.BeanManagerImpl; +import org.slf4j.cal10n.LocLogger; + +public abstract class AbstractFacadeBean<T> extends AbstractBuiltInBean<T> +{ + + private static final LocLogger log = loggerFactory().getLogger(BEAN); + + protected AbstractFacadeBean(String idSuffix, BeanManagerImpl manager) + { + super(idSuffix, manager); + } + + public T create(CreationalContext<T> creationalContext) + { + InjectionPoint injectionPoint = this.getManager().getCurrentInjectionPoint(); + if (injectionPoint != null) + { + return newInstance(injectionPoint); + } + else + { + log.warn(DYNAMIC_LOOKUP_OF_BUILT_IN_NOT_ALLOWED, toString()); + return null; + } + } + + public void destroy(T instance, CreationalContext<T> creationalContext) + { + // TODO Auto-generated method stub + } + + protected abstract T newInstance(InjectionPoint injectionPoint); + +} Property changes on: core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/AbstractFacadeBean.java ___________________________________________________________________ Name: svn:mime-type + text/plain Name: svn:eol-style + native Copied: core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/BeanManagerBean.java (from rev 4715, core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/ManagerBean.java) =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/BeanManagerBean.java (rev 0) +++ core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/BeanManagerBean.java 2009-11-07 21:50:44 UTC (rev 4753) @@ -0,0 +1,66 @@ +/* + * JBoss, Home of Professional Open Source + * Copyright 2008, Red Hat Middleware LLC, and individual contributors + * by the @authors tag. See the copyright.txt in the distribution for a + * full listing of individual contributors. + * + * 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.jboss.weld.bean.builtin; + +import java.lang.reflect.Type; +import java.util.Set; + +import javax.enterprise.context.spi.CreationalContext; +import javax.enterprise.inject.spi.BeanManager; + +import org.jboss.weld.BeanManagerImpl; +import org.jboss.weld.util.collections.Arrays2; + +public class BeanManagerBean extends AbstractBuiltInBean<BeanManagerImpl> +{ + + private static final Set<Type> TYPES = Arrays2.<Type>asSet(Object.class, BeanManagerImpl.class, BeanManager.class); + + public BeanManagerBean(BeanManagerImpl manager) + { + super(BeanManager.class.getSimpleName(), manager); + } + + public BeanManagerImpl create(CreationalContext<BeanManagerImpl> creationalContext) + { + return getManager().getCurrent(); + } + + @Override + public Class<BeanManagerImpl> getType() + { + return BeanManagerImpl.class; + } + + public Set<Type> getTypes() + { + return TYPES; + } + + public void destroy(BeanManagerImpl instance, CreationalContext<BeanManagerImpl> creationalContext) + { + // No-op + } + + @Override + public String toString() + { + return "Built-in javax.inject.manager.Manager bean"; + } + + +} \ No newline at end of file Property changes on: core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/BeanManagerBean.java ___________________________________________________________________ Name: svn:mime-type + text/plain Name: svn:eol-style + native Added: core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/CallableMethodHandler.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/CallableMethodHandler.java (rev 0) +++ core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/CallableMethodHandler.java 2009-11-07 21:50:44 UTC (rev 4753) @@ -0,0 +1,62 @@ +package org.jboss.weld.bean.builtin; + +import static org.jboss.weld.logging.Category.BEAN; +import static org.jboss.weld.logging.LoggerFactory.loggerFactory; +import static org.jboss.weld.logging.messages.BeanMessage.CALL_PROXIED_METHOD; + +import java.io.Serializable; +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; +import java.util.concurrent.Callable; + +import javassist.util.proxy.MethodHandler; + +import org.slf4j.cal10n.LocLogger; + +public class CallableMethodHandler implements MethodHandler, Serializable +{ + + private static final long serialVersionUID = -1348302663981663427L; + private static final LocLogger log = loggerFactory().getLogger(BEAN); + + private final Callable<?> callable; + + public CallableMethodHandler(Callable<?> callable) + { + super(); + this.callable = callable; + } + + public Object invoke(Object self, Method proxiedMethod, Method proceed, Object[] args) throws Throwable + { + // Ignore calls to finalize + if ("finalize".equals(proxiedMethod.getName())) + { + return null; + } + Object instance = callable.call(); + if (instance == null) + { + throw new NullPointerException("Unable to obtain instance. Bean: " + callable); + } + try + { + Object returnValue = proxiedMethod.invoke(instance, args); + log.trace(CALL_PROXIED_METHOD, proxiedMethod, instance, args, returnValue == null ? null : returnValue); + return returnValue; + } + catch (InvocationTargetException e) + { + // Unwrap the ITE + if (e.getCause() != null) + { + throw e.getCause(); + } + else + { + throw e; + } + } + } + +} Property changes on: core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/CallableMethodHandler.java ___________________________________________________________________ Name: svn:mime-type + text/plain Name: svn:eol-style + native Copied: core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/EventBean.java (from rev 4715, core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/facade/EventBean.java) =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/EventBean.java (rev 0) +++ core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/EventBean.java 2009-11-07 21:50:44 UTC (rev 4753) @@ -0,0 +1,84 @@ +/* + * JBoss, Home of Professional Open Source + * Copyright 2008, Red Hat Middleware LLC, and individual contributors + * by the @authors tag. See the copyright.txt in the distribution for a + * full listing of individual contributors. + * + * 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.jboss.weld.bean.builtin; + +import java.lang.annotation.Annotation; +import java.lang.reflect.Type; +import java.util.Arrays; +import java.util.HashSet; +import java.util.Set; + +import javax.enterprise.event.Event; +import javax.enterprise.inject.spi.InjectionPoint; +import javax.enterprise.util.TypeLiteral; + +import org.jboss.weld.BeanManagerImpl; +import org.jboss.weld.event.EventImpl; +import org.jboss.weld.literal.AnyLiteral; +import org.jboss.weld.resolution.ResolvableTransformer; +import org.jboss.weld.util.collections.Arrays2; + +public class EventBean extends AbstractFacadeBean<Event<?>> +{ + + private static final Class<Event<?>> TYPE = new TypeLiteral<Event<?>>() {}.getRawType(); + private static final Set<Type> DEFAULT_TYPES = Arrays2.<Type>asSet(TYPE, Object.class); + private static final Annotation ANY = new AnyLiteral(); + private static final Set<Annotation> DEFAULT_BINDINGS = new HashSet<Annotation>(Arrays.asList(ANY)); + public static final ResolvableTransformer TRANSFORMER = new FacadeBeanResolvableTransformer(TYPE); + + public EventBean(BeanManagerImpl manager) + { + super(Event.class.getSimpleName(), manager); + } + + @Override + public Class<Event<?>> getType() + { + return TYPE; + } + + @Override + public Class<?> getBeanClass() + { + return EventImpl.class; + } + + public Set<Type> getTypes() + { + return DEFAULT_TYPES; + } + + @Override + public Set<Annotation> getQualifiers() + { + return DEFAULT_BINDINGS; + } + + @Override + protected Event<?> newInstance(InjectionPoint injectionPoint) + { + return EventImpl.of(injectionPoint, getManager()); + } + + @Override + public String toString() + { + return "Built-in implicit javax.event.Event bean"; + } + +} Property changes on: core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/EventBean.java ___________________________________________________________________ Name: svn:mime-type + text/plain Name: svn:eol-style + native Modified: core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/ExtensionBean.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/ExtensionBean.java 2009-11-07 21:36:10 UTC (rev 4752) +++ core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/ExtensionBean.java 2009-11-07 21:50:44 UTC (rev 4753) @@ -26,11 +26,13 @@ import org.jboss.weld.BeanManagerImpl; import org.jboss.weld.introspector.WeldClass; +import org.jboss.weld.util.Reflections; /** * @author pmuir * */ +// TODO Move out of built in public class ExtensionBean extends AbstractBuiltInBean<Extension> { @@ -38,12 +40,14 @@ private final WeldClass<Extension> clazz; private final Extension instance; + private final boolean passivationCapable; public ExtensionBean(BeanManagerImpl manager, WeldClass<Extension> clazz, Extension instance) { super(new StringBuilder().append(ID_PREFIX).append(BEAN_ID_SEPARATOR).append(clazz.getName()).toString(), manager); this.clazz = clazz; this.instance = instance; + this.passivationCapable = Reflections.isSerializable(clazz.getJavaClass()); } @Override @@ -62,6 +66,12 @@ { return clazz.isProxyable(); } + + @Override + public boolean isPassivationCapable() + { + return passivationCapable; + } public Extension create(CreationalContext<Extension> creationalContext) { Copied: core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/FacadeBeanResolvableTransformer.java (from rev 4715, core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/facade/FacadeBeanResolvableTransformer.java) =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/FacadeBeanResolvableTransformer.java (rev 0) +++ core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/FacadeBeanResolvableTransformer.java 2009-11-07 21:50:44 UTC (rev 4753) @@ -0,0 +1,101 @@ +/* + * JBoss, Home of Professional Open Source + * Copyright 2008, Red Hat Middleware LLC, and individual contributors + * by the @authors tag. See the copyright.txt in the distribution for a + * full listing of individual contributors. + * + * 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.jboss.weld.bean.builtin; + +import java.lang.annotation.Annotation; +import java.lang.reflect.Type; +import java.util.Collections; +import java.util.HashSet; +import java.util.Set; + +import javax.enterprise.inject.Any; + +import org.jboss.weld.literal.AnyLiteral; +import org.jboss.weld.resolution.ForwardingResolvable; +import org.jboss.weld.resolution.Resolvable; +import org.jboss.weld.resolution.ResolvableTransformer; + +/** + * AnnotatedItem transformer which can be used for FacadeBeans + * + * @author Pete Muir + * + */ +public class FacadeBeanResolvableTransformer implements ResolvableTransformer +{ + + private static final Set<Annotation> bindings; + + static + { + bindings = new HashSet<Annotation>(); + bindings.add(new AnyLiteral()); + } + + private final Class<?> clazz; + private final HashSet<Type> types; + + public FacadeBeanResolvableTransformer(Class<?> clazz) + { + this.clazz = clazz; + this.types = new HashSet<Type>(); + types.add(clazz); + } + + public Resolvable transform(final Resolvable resolvable) + { + if (resolvable.isAssignableTo(clazz)) + { + return new ForwardingResolvable() + { + + @Override + protected Resolvable delegate() + { + return resolvable; + } + + @Override + public Set<Annotation> getQualifiers() + { + return Collections.unmodifiableSet(bindings); + } + + @Override + public Set<Type> getTypeClosure() + { + return Collections.unmodifiableSet(types); + } + + @Override + public boolean isAssignableTo(Class<?> c) + { + return c.isAssignableFrom(clazz); + } + + @Override + public boolean isAnnotationPresent(Class<? extends Annotation> annotationType) + { + return Any.class.equals(annotationType); + } + + }; + } + return resolvable; + } + +} Property changes on: core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/FacadeBeanResolvableTransformer.java ___________________________________________________________________ Name: svn:mime-type + text/plain Name: svn:eol-style + native Copied: core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/InstanceBean.java (from rev 4715, core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/facade/InstanceBean.java) =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/InstanceBean.java (rev 0) +++ core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/InstanceBean.java 2009-11-07 21:50:44 UTC (rev 4753) @@ -0,0 +1,87 @@ +/* + * JBoss, Home of Professional Open Source + * Copyright 2008, Red Hat Middleware LLC, and individual contributors + * by the @authors tag. See the copyright.txt in the distribution for a + * full listing of individual contributors. + * + * 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.jboss.weld.bean.builtin; + +import java.lang.annotation.Annotation; +import java.lang.reflect.Type; +import java.util.Arrays; +import java.util.HashSet; +import java.util.Set; + +import javax.enterprise.inject.Any; +import javax.enterprise.inject.Instance; +import javax.enterprise.inject.spi.InjectionPoint; +import javax.enterprise.util.TypeLiteral; +import javax.inject.Provider; + +import org.jboss.weld.BeanManagerImpl; +import org.jboss.weld.literal.AnyLiteral; +import org.jboss.weld.resolution.ResolvableTransformer; +import org.jboss.weld.util.collections.Arrays2; + +public class InstanceBean extends AbstractFacadeBean<Instance<?>> +{ + + private static final Class<Instance<?>> INSTANCE_TYPE = new TypeLiteral<Instance<?>>() {}.getRawType(); + private static final Class<Provider<?>> PROVIDER_TYPE = new TypeLiteral<Provider<?>>() {}.getRawType(); + private static final Set<Type> DEFAULT_TYPES = Arrays2.<Type>asSet(INSTANCE_TYPE, PROVIDER_TYPE, Object.class); + private static final Any ANY = new AnyLiteral(); + private static final Set<Annotation> DEFAULT_BINDINGS = new HashSet<Annotation>(Arrays.asList(ANY)); + public static final ResolvableTransformer INSTANCE_TRANSFORMER = new FacadeBeanResolvableTransformer(INSTANCE_TYPE); + public static final ResolvableTransformer PROVIDER_TRANSFORMER = new FacadeBeanResolvableTransformer(PROVIDER_TYPE); + + public InstanceBean(BeanManagerImpl manager) + { + super(Instance.class.getSimpleName(), manager); + } + + @Override + public Class<Instance<?>> getType() + { + return INSTANCE_TYPE; + } + + @Override + public Class<?> getBeanClass() + { + return InstanceImpl.class; + } + + public Set<Type> getTypes() + { + return DEFAULT_TYPES; + } + + @Override + public Set<Annotation> getQualifiers() + { + return DEFAULT_BINDINGS; + } + + @Override + protected Instance<?> newInstance(InjectionPoint injectionPoint) + { + return InstanceImpl.of(injectionPoint, getManager()); + } + + @Override + public String toString() + { + return "Built-in implicit javax.inject.Instance bean"; + } + +} Property changes on: core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/InstanceBean.java ___________________________________________________________________ Name: svn:mime-type + text/plain Name: svn:eol-style + native Copied: core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/InstanceImpl.java (from rev 4715, core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/facade/InstanceImpl.java) =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/InstanceImpl.java (rev 0) +++ core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/InstanceImpl.java 2009-11-07 21:50:44 UTC (rev 4753) @@ -0,0 +1,175 @@ +/* + * JBoss, Home of Professional Open Source + * Copyright 2008, Red Hat Middleware LLC, and individual contributors + * by the @authors tag. See the copyright.txt in the distribution for a + * full listing of individual contributors. + * + * 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.jboss.weld.bean.builtin; + +import static org.jboss.weld.util.Reflections.EMPTY_ANNOTATIONS; + +import java.io.InvalidObjectException; +import java.io.ObjectInputStream; +import java.io.ObjectStreamException; +import java.io.Serializable; +import java.lang.annotation.Annotation; +import java.lang.reflect.Type; +import java.util.ArrayList; +import java.util.Collection; +import java.util.Iterator; +import java.util.Set; + +import javax.enterprise.inject.Instance; +import javax.enterprise.inject.spi.Bean; +import javax.enterprise.inject.spi.InjectionPoint; +import javax.enterprise.util.TypeLiteral; + +import org.jboss.weld.BeanManagerImpl; +import org.jboss.weld.resolution.ResolvableWeldClass; +import org.jboss.weld.util.Beans; +import org.jboss.weld.util.Names; + +/** + * Helper implementation for Instance for getting instances + * + * @author Gavin King + * + * @param <T> + */ +public class InstanceImpl<T> extends AbstractFacade<T, Instance<T>> implements Instance<T>, Serializable +{ + + private static final long serialVersionUID = -376721889693284887L; + + public static <I> Instance<I> of(InjectionPoint injectionPoint, BeanManagerImpl beanManager) + { + return new InstanceImpl<I>(getFacadeType(injectionPoint), injectionPoint.getQualifiers().toArray(EMPTY_ANNOTATIONS), injectionPoint, beanManager); + } + + private InstanceImpl(Type type, Annotation[] qualifiers, InjectionPoint injectionPoint, BeanManagerImpl beanManager) + { + super(type, qualifiers, injectionPoint, beanManager); + } + + public T get() + { + Bean<?> bean = getBeanManager().getBean(ResolvableWeldClass.of(getType(), getQualifiers(), getBeanManager()), getQualifiers()); + // Push in an empty CC to ensure that we don't get the CC of whatever is injecting the bean containing the Instance injection point + try + { + getBeanManager().pushDummyInjectionPoint(); + @SuppressWarnings("unchecked") + T instance = (T) getBeanManager().getReference(bean, getType(), getBeanManager().createCreationalContext(bean)); + return instance; + } + finally + { + getBeanManager().popDummyInjectionPoint(); + } + } + + /** + * Gets a string representation + * + * @return A string representation + */ + @Override + public String toString() + { + return new StringBuilder().append(Names.annotationsToString(getQualifiers())).append(" Instance<").append(getType()).append(">").toString(); + } + + private Set<Bean<?>> getBeans() + { + return getBeanManager().getBeans(getType(), getQualifiers()); + } + + public Iterator<T> iterator() + { + Collection<T> instances = new ArrayList<T>(); + for (Bean<?> bean : getBeans()) + { + Object object = getBeanManager().getReference(bean, getType(), getBeanManager().createCreationalContext(bean)); + + @SuppressWarnings("unchecked") + T instance = (T) object; + + instances.add(instance); + } + return instances.iterator(); + } + + public boolean isAmbiguous() + { + return getBeans().size() > 1; + } + + public boolean isUnsatisfied() + { + return getBeans().size() == 0; + } + + public Instance<T> select(Annotation... qualifiers) + { + return selectInstance(this.getType(), qualifiers); + } + + public <U extends T> Instance<U> select(Class<U> subtype, Annotation... qualifiers) + { + return selectInstance(subtype, qualifiers); + } + + public <U extends T> Instance<U> select(TypeLiteral<U> subtype, Annotation... qualifiers) + { + return selectInstance(subtype.getType(), qualifiers); + } + + private <U extends T> Instance<U> selectInstance(Type subtype, Annotation[] newQualifiers) + { + return new InstanceImpl<U>( + subtype, + Beans.mergeInQualifiers(getQualifiers(), newQualifiers), + getInjectionPoint(), + getBeanManager()); + } + + // Serialization + + private Object writeReplace() throws ObjectStreamException + { + return new SerializationProxy(this); + } + + private void readObject(ObjectInputStream stream) throws InvalidObjectException + { + throw new InvalidObjectException("Proxy required"); + } + + private static class SerializationProxy extends AbstractFacadeSerializationProxy + { + + private static final long serialVersionUID = 9181171328831559650L; + + public SerializationProxy(InstanceImpl<?> instance) + { + super(instance); + } + + private Object readResolve() + { + return InstanceImpl.of(getInjectionPoint(), getBeanManager()); + } + + } + +} Property changes on: core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/InstanceImpl.java ___________________________________________________________________ Name: svn:eol-style + native Deleted: core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/ManagerBean.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/ManagerBean.java 2009-11-07 21:36:10 UTC (rev 4752) +++ core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/ManagerBean.java 2009-11-07 21:50:44 UTC (rev 4753) @@ -1,66 +0,0 @@ -/* - * JBoss, Home of Professional Open Source - * Copyright 2008, Red Hat Middleware LLC, and individual contributors - * by the @authors tag. See the copyright.txt in the distribution for a - * full listing of individual contributors. - * - * 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.jboss.weld.bean.builtin; - -import java.lang.reflect.Type; -import java.util.Set; - -import javax.enterprise.context.spi.CreationalContext; -import javax.enterprise.inject.spi.BeanManager; - -import org.jboss.weld.BeanManagerImpl; -import org.jboss.weld.util.collections.Arrays2; - -public class ManagerBean extends AbstractBuiltInBean<BeanManagerImpl> -{ - - private static final Set<Type> TYPES = Arrays2.<Type>asSet(Object.class, BeanManagerImpl.class, BeanManager.class); - - public ManagerBean(BeanManagerImpl manager) - { - super(BeanManager.class.getSimpleName(), manager); - } - - public BeanManagerImpl create(CreationalContext<BeanManagerImpl> creationalContext) - { - return getManager().getCurrent(); - } - - @Override - public Class<BeanManagerImpl> getType() - { - return BeanManagerImpl.class; - } - - public Set<Type> getTypes() - { - return TYPES; - } - - public void destroy(BeanManagerImpl instance, CreationalContext<BeanManagerImpl> creationalContext) - { - // No-op - } - - @Override - public String toString() - { - return "Built-in javax.inject.manager.Manager bean"; - } - - -} \ No newline at end of file Copied: core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/ee (from rev 4715, core/trunk/impl/src/main/java/org/jboss/weld/bean/ee) Added: core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/ee/AbstractEEBean.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/ee/AbstractEEBean.java (rev 0) +++ core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/ee/AbstractEEBean.java 2009-11-07 21:50:44 UTC (rev 4753) @@ -0,0 +1,67 @@ +package org.jboss.weld.bean.builtin.ee; + +import java.io.Serializable; +import java.lang.reflect.Type; +import java.util.HashSet; +import java.util.Set; +import java.util.concurrent.Callable; + +import javax.enterprise.context.spi.CreationalContext; + +import org.jboss.weld.BeanManagerImpl; +import org.jboss.weld.DefinitionException; +import org.jboss.weld.bean.builtin.AbstractBuiltInBean; +import org.jboss.weld.bean.builtin.CallableMethodHandler; +import org.jboss.weld.util.Proxies; +import org.jboss.weld.util.Proxies.TypeInfo; + +public abstract class AbstractEEBean<T> extends AbstractBuiltInBean<T> +{ + + private final T proxy; + private final Class<T> type; + private final Set<Type> types; + + protected AbstractEEBean(Class<T> type, Callable<T> callable, BeanManagerImpl beanManager) + { + super(type.getSimpleName(), beanManager); + this.type = type; + this.types = new HashSet<Type>(); + this.types.add(Object.class); + this.types.add(type); + try + { + this.proxy = Proxies.<T>createProxy(new CallableMethodHandler(callable), TypeInfo.of(getTypes()).add(Serializable.class)); + } + catch (InstantiationException e) + { + throw new DefinitionException("Could not instantiate client proxy for " + this, e); + } + catch (IllegalAccessException e) + { + throw new DefinitionException("Could not access bean correctly when creating client proxy for " + this, e); + } + } + + public T create(CreationalContext<T> creationalContext) + { + return proxy; + } + + public void destroy(T instance, CreationalContext<T> creationalContext) + { + // no-op + } + + @Override + public Class<T> getType() + { + return type; + } + + public Set<Type> getTypes() + { + return types; + } + +} Property changes on: core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/ee/AbstractEEBean.java ___________________________________________________________________ Name: svn:mime-type + text/plain Name: svn:eol-style + native Added: core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/ee/AbstractEECallable.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/ee/AbstractEECallable.java (rev 0) +++ core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/ee/AbstractEECallable.java 2009-11-07 21:50:44 UTC (rev 4753) @@ -0,0 +1,25 @@ +package org.jboss.weld.bean.builtin.ee; + +import java.io.Serializable; +import java.util.concurrent.Callable; + +import org.jboss.weld.BeanManagerImpl; + +public abstract class AbstractEECallable<V> implements Callable<V>, Serializable +{ + + private static final long serialVersionUID = 2685728358029843185L; + + private final BeanManagerImpl beanManager; + + protected AbstractEECallable(BeanManagerImpl beanManager) + { + this.beanManager = beanManager; + } + + public BeanManagerImpl getBeanManager() + { + return beanManager; + } + +} Property changes on: core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/ee/AbstractEECallable.java ___________________________________________________________________ Name: svn:mime-type + text/plain Name: svn:eol-style + native Modified: core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/ee/DefaultValidatorBean.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/bean/ee/DefaultValidatorBean.java 2009-11-06 12:58:14 UTC (rev 4715) +++ core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/ee/DefaultValidatorBean.java 2009-11-07 21:50:44 UTC (rev 4753) @@ -14,60 +14,54 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.jboss.weld.bean.ee; +package org.jboss.weld.bean.builtin.ee; -import java.lang.reflect.Type; -import java.util.Set; - -import javax.enterprise.context.spi.CreationalContext; import javax.validation.Validator; import org.jboss.weld.BeanManagerImpl; import org.jboss.weld.Container; -import org.jboss.weld.bean.builtin.AbstractBuiltInBean; -import org.jboss.weld.util.collections.Arrays2; import org.jboss.weld.validation.spi.ValidationServices; /** * @author pmuir * */ -public class DefaultValidatorBean extends AbstractBuiltInBean<Validator> +public class DefaultValidatorBean extends AbstractEEBean<Validator> { - - private static final Set<Type> TYPES = Arrays2.<Type>asSet(Object.class, Validator.class); - public DefaultValidatorBean(BeanManagerImpl manager) + private static class ValidatorCallable extends AbstractEECallable<Validator> { - super(Validator.class.getSimpleName(), manager); - } + + private static final long serialVersionUID = 2455850340620002351L; - @Override - public Class<Validator> getType() - { - return Validator.class; - } + public ValidatorCallable(BeanManagerImpl beanManager) + { + super(beanManager); + } - public Set<Type> getTypes() - { - return TYPES; - } - - public Validator create(CreationalContext<Validator> creationalContext) - { - if (getManager().getServices().contains(ValidationServices.class)) + public Validator call() throws Exception { - return Container.instance().deploymentServices().get(ValidationServices.class).getDefaultValidatorFactory().getValidator(); + if (getBeanManager().getServices().contains(ValidationServices.class)) + { + return Container.instance().deploymentServices().get(ValidationServices.class).getDefaultValidatorFactory().getValidator(); + } + else + { + throw new IllegalStateException("ValidationServices not available"); + } } - else + + @Override + public String toString() { - throw new IllegalStateException("ValidationServices not available"); + return "Built-in Validator bean"; } + } - - public void destroy(Validator instance, CreationalContext<Validator> creationalContext) + + public DefaultValidatorBean(BeanManagerImpl manager) { - // No-op + super(Validator.class, new ValidatorCallable(manager), manager); } } Modified: core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/ee/DefaultValidatorFactoryBean.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/bean/ee/DefaultValidatorFactoryBean.java 2009-11-06 12:58:14 UTC (rev 4715) +++ core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/ee/DefaultValidatorFactoryBean.java 2009-11-07 21:50:44 UTC (rev 4753) @@ -14,59 +14,53 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.jboss.weld.bean.ee; +package org.jboss.weld.bean.builtin.ee; -import java.lang.reflect.Type; -import java.util.Set; - -import javax.enterprise.context.spi.CreationalContext; import javax.validation.ValidatorFactory; import org.jboss.weld.BeanManagerImpl; -import org.jboss.weld.bean.builtin.AbstractBuiltInBean; -import org.jboss.weld.util.collections.Arrays2; import org.jboss.weld.validation.spi.ValidationServices; /** * @author pmuir * */ -public class DefaultValidatorFactoryBean extends AbstractBuiltInBean<ValidatorFactory> +public class DefaultValidatorFactoryBean extends AbstractEEBean<ValidatorFactory> { - - private static final Set<Type> TYPES = Arrays2.<Type>asSet(Object.class, ValidatorFactory.class); - public DefaultValidatorFactoryBean(BeanManagerImpl manager) + private static class ValidatorFactoryCallable extends AbstractEECallable<ValidatorFactory> { - super(ValidatorFactory.class.getSimpleName(), manager); - } + + private static final long serialVersionUID = -8511087629930598385L; - @Override - public Class<ValidatorFactory> getType() - { - return ValidatorFactory.class; - } + public ValidatorFactoryCallable(BeanManagerImpl beanManager) + { + super(beanManager); + } - public Set<Type> getTypes() - { - return TYPES; - } - - public ValidatorFactory create(CreationalContext<ValidatorFactory> creationalContext) - { - if (getManager().getServices().contains(ValidationServices.class)) + public ValidatorFactory call() throws Exception { - return getManager().getServices().get(ValidationServices.class).getDefaultValidatorFactory(); + if (getBeanManager().getServices().contains(ValidationServices.class)) + { + return getBeanManager().getServices().get(ValidationServices.class).getDefaultValidatorFactory(); + } + else + { + throw new IllegalStateException("ValidationServices not available"); + } } - else + + @Override + public String toString() { - throw new IllegalStateException("ValidationServices not available"); + return "Built-in ValidatorFactory bean"; } + } - - public void destroy(ValidatorFactory instance, CreationalContext<ValidatorFactory> creationalContext) + + public DefaultValidatorFactoryBean(BeanManagerImpl beanManager) { - // No-op + super(ValidatorFactory.class, new ValidatorFactoryCallable(beanManager), beanManager); } } Modified: core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/ee/EEResourceProducerField.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/bean/ee/EEResourceProducerField.java 2009-11-06 12:58:14 UTC (rev 4715) +++ core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/ee/EEResourceProducerField.java 2009-11-07 21:50:44 UTC (rev 4753) @@ -14,15 +14,26 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.jboss.weld.bean.ee; +package org.jboss.weld.bean.builtin.ee; +import java.io.Serializable; + +import javax.enterprise.context.spi.Contextual; +import javax.enterprise.context.spi.CreationalContext; + import org.jboss.weld.BeanManagerImpl; +import org.jboss.weld.Container; import org.jboss.weld.bean.AbstractClassBean; import org.jboss.weld.bean.ProducerField; +import org.jboss.weld.bean.builtin.CallableMethodHandler; import org.jboss.weld.bootstrap.BeanDeployerEnvironment; import org.jboss.weld.ejb.EJBApiAbstraction; import org.jboss.weld.introspector.WeldField; import org.jboss.weld.persistence.PersistenceApiAbstraction; +import org.jboss.weld.serialization.spi.ContextualStore; +import org.jboss.weld.util.Proxies; +import org.jboss.weld.util.Reflections; +import org.jboss.weld.util.Proxies.TypeInfo; import org.jboss.weld.ws.WSApiAbstraction; /** @@ -32,6 +43,49 @@ public class EEResourceProducerField<X, T> extends ProducerField<X, T> { + + private static class EEResourceCallable<T> extends AbstractEECallable<T> + { + + private static final long serialVersionUID = 6287931036073200963L; + + private final String beanId; + private transient T instance; + + public EEResourceCallable(BeanManagerImpl beanManager, ProducerField<?, T> producerField/*, CreationalContext<T> creationalContext*/) + { + super(beanManager); + this.beanId = producerField.getId(); + } + + public T call() throws Exception + { + if (instance == null) + { + Contextual<T> contextual = Container.instance().deploymentServices().get(ContextualStore.class).<Contextual<T>, T>getContextual(beanId); + if (contextual instanceof EEResourceProducerField<?, ?>) + { + @SuppressWarnings("unchecked") + EEResourceProducerField<?, T> bean = (EEResourceProducerField<?, T>) contextual; + + this.instance = bean.createUnderlying(getBeanManager().createCreationalContext(bean)); + } + else + { + throw new IllegalStateException("Bean is not an EE resource producer field. Bean: " + contextual); + } + } + return instance; + } + + @Override + public String toString() + { + return beanId; + } + + } + /** * Creates an EE resource producer field * @@ -44,10 +98,31 @@ { return new EEResourceProducerField<X, T>(field, declaringBean, manager); } + + private final T proxy; protected EEResourceProducerField(WeldField<T, X> field, AbstractClassBean<X> declaringBean, BeanManagerImpl manager) { super(field, declaringBean, manager); + try + { + if (Reflections.isFinal(field.getJavaClass()) || Serializable.class.isAssignableFrom(field.getJavaClass())) + { + this.proxy = null; + } + else + { + this.proxy = Proxies.<T>createProxy(new CallableMethodHandler(new EEResourceCallable<T>(getManager(), this)), TypeInfo.of(getTypes()).add(Serializable.class)); + } + } + catch (InstantiationException e) + { + throw new RuntimeException("Error creating proxy for resource producer field. Field: " + this, e); + } + catch (IllegalAccessException e) + { + throw new RuntimeException("Error creating proxy for resource field. Field: " + this, e); + } } @Override @@ -70,5 +145,33 @@ throw new IllegalStateException("Tried to create an EEResourceProducerField, but no @Resource, @PersistenceContext, @PersistenceUnit, @WebServiceRef or @EJB is present " + getAnnotatedItem()); } } + + @Override + public T create(CreationalContext<T> creationalContext) + { + if (proxy == null) + { + return createUnderlying(creationalContext); + } + else + { + return proxy; + } + } + + /** + * Access to the underlying producer field + */ + private T createUnderlying(CreationalContext<T> creationalContext) + { + return super.create(creationalContext); + } + + @Override + public boolean isPassivationCapable() + { + return true; + } + } Modified: core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/ee/PersistenceContextProducerField.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/bean/ee/PersistenceContextProducerField.java 2009-11-06 12:58:14 UTC (rev 4715) +++ core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/ee/PersistenceContextProducerField.java 2009-11-07 21:50:44 UTC (rev 4753) @@ -14,7 +14,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.jboss.weld.bean.ee; +package org.jboss.weld.bean.builtin.ee; import javax.persistence.EntityManager; Modified: core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/ee/PrincipalBean.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/bean/ee/PrincipalBean.java 2009-11-06 12:58:14 UTC (rev 4715) +++ core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/ee/PrincipalBean.java 2009-11-07 21:50:44 UTC (rev 4753) @@ -14,59 +14,53 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.jboss.weld.bean.ee; +package org.jboss.weld.bean.builtin.ee; -import java.lang.reflect.Type; import java.security.Principal; -import java.util.Set; -import javax.enterprise.context.spi.CreationalContext; - import org.jboss.weld.BeanManagerImpl; -import org.jboss.weld.bean.builtin.AbstractBuiltInBean; import org.jboss.weld.security.spi.SecurityServices; -import org.jboss.weld.util.collections.Arrays2; /** * @author pmuir - * + * */ -public class PrincipalBean extends AbstractBuiltInBean<Principal> +public class PrincipalBean extends AbstractEEBean<Principal> { - private static final Set<Type> TYPES = Arrays2.<Type>asSet(Object.class, Principal.class); - - public PrincipalBean(BeanManagerImpl manager) + private static class PrincipalCallable extends AbstractEECallable<Principal> { - super(Principal.class.getSimpleName(), manager); - } - @Override - public Class<Principal> getType() - { - return Principal.class; - } + private static final long serialVersionUID = -6603676793378907096L; - public Set<Type> getTypes() - { - return TYPES; - } + public PrincipalCallable(BeanManagerImpl beanManager) + { + super(beanManager); + } - public Principal create(CreationalContext<Principal> creationalContext) - { - if (getManager().getServices().contains(SecurityServices.class)) + public Principal call() throws Exception { - return getManager().getServices().get(SecurityServices.class).getPrincipal(); + if (getBeanManager().getServices().contains(SecurityServices.class)) + { + return getBeanManager().getServices().get(SecurityServices.class).getPrincipal(); + } + else + { + throw new IllegalStateException("SecurityServices not available"); + } } - else + + @Override + public String toString() { - throw new IllegalStateException("SecurityServices not available"); + return "Built-in Principal bean"; } + } - public void destroy(Principal instance, CreationalContext<Principal> creationalContext) + public PrincipalBean(BeanManagerImpl beanManager) { - // No-op + super(Principal.class, new PrincipalCallable(beanManager), beanManager); } } Modified: core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/ee/UserTransactionBean.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/bean/ee/UserTransactionBean.java 2009-11-06 12:58:14 UTC (rev 4715) +++ core/trunk/impl/src/main/java/org/jboss/weld/bean/builtin/ee/UserTransactionBean.java 2009-11-07 21:50:44 UTC (rev 4753) @@ -14,59 +14,53 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.jboss.weld.bean.ee; +package org.jboss.weld.bean.builtin.ee; -import java.lang.reflect.Type; -import java.util.Set; - -import javax.enterprise.context.spi.CreationalContext; import javax.transaction.UserTransaction; import org.jboss.weld.BeanManagerImpl; -import org.jboss.weld.bean.builtin.AbstractBuiltInBean; import org.jboss.weld.transaction.spi.TransactionServices; -import org.jboss.weld.util.collections.Arrays2; /** * @author pmuir * */ -public class UserTransactionBean extends AbstractBuiltInBean<UserTransaction> +public class UserTransactionBean extends AbstractEEBean<UserTransaction> { - - private static final Set<Type> TYPES = Arrays2.<Type>asSet(Object.class, UserTransaction.class); - public UserTransactionBean(BeanManagerImpl manager) + private static class UserTransactionCallable extends AbstractEECallable<UserTransaction> { - super(UserTransaction.class.getSimpleName(), manager); - } + + private static final long serialVersionUID = -6320641773968440920L; - @Override - public Class<UserTransaction> getType() - { - return UserTransaction.class; - } + public UserTransactionCallable(BeanManagerImpl beanManager) + { + super(beanManager); + } - public Set<Type> getTypes() - { - return TYPES; - } - - public UserTransaction create(CreationalContext<UserTransaction> creationalContext) - { - if (getManager().getServices().contains(TransactionServices.class)) + public UserTransaction call() throws Exception { - return getManager().getServices().get(TransactionServices.class).getUserTransaction(); + if (getBeanManager().getServices().contains(TransactionServices.class)) + { + return getBeanManager().getServices().get(TransactionServices.class).getUserTransaction(); + } + else + { + throw new IllegalStateException("TransactionServices not available"); + } } - else + + @Override + public String toString() { - throw new IllegalStateException("TransactionServices not available"); + return "Built-in UserTransaction bean"; } + } - - public void destroy(UserTransaction instance, CreationalContext<UserTransaction> creationalContext) + + public UserTransactionBean(BeanManagerImpl beanManager) { - // No-op + super(UserTransaction.class, new UserTransactionCallable(beanManager), beanManager); } } Modified: core/trunk/impl/src/main/java/org/jboss/weld/bean/proxy/ClientProxyProvider.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/bean/proxy/ClientProxyProvider.java 2009-11-07 21:36:10 UTC (rev 4752) +++ core/trunk/impl/src/main/java/org/jboss/weld/bean/proxy/ClientProxyProvider.java 2009-11-07 21:50:44 UTC (rev 4753) @@ -17,13 +17,8 @@ package org.jboss.weld.bean.proxy; import java.io.Serializable; -import java.lang.reflect.Type; -import java.util.LinkedHashSet; -import java.util.Set; import java.util.concurrent.Callable; -import javassist.util.proxy.ProxyFactory; - import javax.enterprise.inject.spi.Bean; import org.jboss.weld.BeanManagerImpl; @@ -31,6 +26,7 @@ import org.jboss.weld.DefinitionException; import org.jboss.weld.serialization.spi.ContextualStore; import org.jboss.weld.util.Proxies; +import org.jboss.weld.util.Proxies.TypeInfo; import org.jboss.weld.util.collections.ConcurrentCache; /** @@ -74,20 +70,9 @@ */ private static <T> T createClientProxy(Bean<T> bean, BeanManagerImpl manager, String id) throws RuntimeException { - try { - ClientProxyMethodHandler proxyMethodHandler = new ClientProxyMethodHandler(bean, manager, id); - Set<Type> classes = new LinkedHashSet<Type>(bean.getTypes()); - classes.add(Serializable.class); - ProxyFactory proxyFactory = Proxies.getProxyFactory(classes); - proxyFactory.setHandler(proxyMethodHandler); - Class<?> clazz = proxyFactory.createClass(); - - @SuppressWarnings("unchecked") - T instance = (T) clazz.newInstance(); - - return instance; + return Proxies.<T>createProxy(new ClientProxyMethodHandler(bean, manager, id), TypeInfo.of(bean.getTypes()).add(Serializable.class)); } catch (InstantiationException e) { Modified: core/trunk/impl/src/main/java/org/jboss/weld/bean/proxy/DecoratorProxyMethodHandler.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/bean/proxy/DecoratorProxyMethodHandler.java 2009-11-07 21:36:10 UTC (rev 4752) +++ core/trunk/impl/src/main/java/org/jboss/weld/bean/proxy/DecoratorProxyMethodHandler.java 2009-11-07 21:50:44 UTC (rev 4753) @@ -73,19 +73,20 @@ * * @throws Throwable if the method invocation fails. */ + @Override protected Object doInvoke(Object self, Method method, Method proceed, Object[] args) throws Throwable { MethodSignature methodSignature = new MethodSignatureImpl(method); for (SerializableContextualInstance<Decorator<Object>, Object> beanInstance : decoratorInstances) { WeldMethod<?, ?> decoratorMethod; - if (beanInstance.getContextual().get() instanceof DecoratorImpl) + if (beanInstance.getContextual().get() instanceof DecoratorImpl<?>) { - decoratorMethod = ((DecoratorImpl)beanInstance.getContextual().get()).getAnnotatedItem().getWBMethod(methodSignature); + decoratorMethod = ((DecoratorImpl<?>)beanInstance.getContextual().get()).getAnnotatedItem().getWeldMethod(methodSignature); } else if (beanInstance.getContextual().get() instanceof AnnotatedItemProvidingDecoratorWrapper) { - decoratorMethod = ((AnnotatedItemProvidingDecoratorWrapper)beanInstance.getContextual().get()).getAnnotatedItem().getWBMethod(methodSignature); + decoratorMethod = ((AnnotatedItemProvidingDecoratorWrapper)beanInstance.getContextual().get()).getAnnotatedItem().getWeldMethod(methodSignature); } else { Modified: core/trunk/impl/src/main/java/org/jboss/weld/bootstrap/AbstractBeanDeployer.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/bootstrap/AbstractBeanDeployer.java 2009-11-07 21:36:10 UTC (rev 4752) +++ core/trunk/impl/src/main/java/org/jboss/weld/bootstrap/AbstractBeanDeployer.java 2009-11-07 21:50:44 UTC (rev 4753) @@ -46,8 +46,8 @@ import org.jboss.weld.bean.ProducerMethod; import org.jboss.weld.bean.RIBean; import org.jboss.weld.bean.SessionBean; -import org.jboss.weld.bean.ee.EEResourceProducerField; -import org.jboss.weld.bean.ee.PersistenceContextProducerField; +import org.jboss.weld.bean.builtin.ee.EEResourceProducerField; +import org.jboss.weld.bean.builtin.ee.PersistenceContextProducerField; import org.jboss.weld.bootstrap.events.ProcessBeanImpl; import org.jboss.weld.bootstrap.events.ProcessBeanInjectionTarget; import org.jboss.weld.bootstrap.events.ProcessManagedBeanImpl; Modified: core/trunk/impl/src/main/java/org/jboss/weld/bootstrap/BeanDeployment.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/bootstrap/BeanDeployment.java 2009-11-07 21:36:10 UTC (rev 4752) +++ core/trunk/impl/src/main/java/org/jboss/weld/bootstrap/BeanDeployment.java 2009-11-07 21:50:44 UTC (rev 4753) @@ -28,14 +28,14 @@ import org.jboss.weld.BeanManagerImpl; import org.jboss.weld.bean.RIBean; +import org.jboss.weld.bean.builtin.BeanManagerBean; +import org.jboss.weld.bean.builtin.EventBean; import org.jboss.weld.bean.builtin.InjectionPointBean; -import org.jboss.weld.bean.builtin.ManagerBean; -import org.jboss.weld.bean.builtin.facade.EventBean; -import org.jboss.weld.bean.builtin.facade.InstanceBean; -import org.jboss.weld.bean.ee.DefaultValidatorBean; -import org.jboss.weld.bean.ee.DefaultValidatorFactoryBean; -import org.jboss.weld.bean.ee.PrincipalBean; -import org.jboss.weld.bean.ee.UserTransactionBean; +import org.jboss.weld.bean.builtin.InstanceBean; +import org.jboss.weld.bean.builtin.ee.DefaultValidatorBean; +import org.jboss.weld.bean.builtin.ee.DefaultValidatorFactoryBean; +import org.jboss.weld.bean.builtin.ee.PrincipalBean; +import org.jboss.weld.bean.builtin.ee.UserTransactionBean; import org.jboss.weld.bootstrap.api.Environment; import org.jboss.weld.bootstrap.api.ServiceRegistry; import org.jboss.weld.bootstrap.api.helpers.SimpleServiceRegistry; @@ -80,7 +80,7 @@ beanDeployer = new BeanDeployer(beanManager, ejbDescriptors); // Must at the Manager bean straight away, as it can be injected during startup! - beanManager.addBean(new ManagerBean(beanManager)); + beanManager.addBean(new BeanManagerBean(beanManager)); parseBeansXml(); } @@ -150,7 +150,7 @@ } beanDeployer.createBeans().deploy(); } - + public void afterBeanDiscovery(Environment environment) { doAfterBeanDiscovery(beanManager.getBeans()); @@ -158,13 +158,13 @@ doAfterBeanDiscovery(beanManager.getInterceptors()); } - private void doAfterBeanDiscovery(List<? extends Bean> beanList) + private void doAfterBeanDiscovery(List<? extends Bean<?>> beanList) { for (Bean<?> bean : beanList) { - if (bean instanceof RIBean) + if (bean instanceof RIBean<?>) { - ((RIBean) bean).initializeAfterBeanDiscovery(); + ((RIBean<?>) bean).initializeAfterBeanDiscovery(); } } } Modified: core/trunk/impl/src/main/java/org/jboss/weld/bootstrap/WeldBootstrap.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/bootstrap/WeldBootstrap.java 2009-11-07 21:36:10 UTC (rev 4752) +++ core/trunk/impl/src/main/java/org/jboss/weld/bootstrap/WeldBootstrap.java 2009-11-07 21:50:44 UTC (rev 4753) @@ -39,7 +39,7 @@ import org.jboss.weld.ContextualStoreImpl; import org.jboss.weld.Validator; import org.jboss.weld.Container.Status; -import org.jboss.weld.bean.builtin.ManagerBean; +import org.jboss.weld.bean.builtin.BeanManagerBean; import org.jboss.weld.bootstrap.api.Bootstrap; import org.jboss.weld.bootstrap.api.Environment; import org.jboss.weld.bootstrap.api.Lifecycle; @@ -343,7 +343,7 @@ extensionBeanDeployer.deployBeans(); // Add the Deployment BeanManager Bean to the Deployment BeanManager - deploymentManager.addBean(new ManagerBean(deploymentManager)); + deploymentManager.addBean(new BeanManagerBean(deploymentManager)); // Re-Read the deployment structure, this will be the physical structure, and will add in BDAs for any extensions outside a physical BDA beanDeployments = deploymentVisitor.visit(); Modified: core/trunk/impl/src/main/java/org/jboss/weld/bootstrap/events/AfterBeanDiscoveryImpl.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/bootstrap/events/AfterBeanDiscoveryImpl.java 2009-11-07 21:36:10 UTC (rev 4752) +++ core/trunk/impl/src/main/java/org/jboss/weld/bootstrap/events/AfterBeanDiscoveryImpl.java 2009-11-07 21:50:44 UTC (rev 4753) @@ -59,7 +59,7 @@ public void addBean(Bean<?> bean) { BeanManagerImpl beanManager = getOrCreateBeanDeployment(bean.getBeanClass()).getBeanManager(); - if (bean instanceof Interceptor) + if (bean instanceof Interceptor<?>) { beanManager.addInterceptor((Interceptor<?>) bean); } Modified: core/trunk/impl/src/main/java/org/jboss/weld/conversation/AbstractConversationManager.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/conversation/AbstractConversationManager.java 2009-11-07 21:36:10 UTC (rev 4752) +++ core/trunk/impl/src/main/java/org/jboss/weld/conversation/AbstractConversationManager.java 2009-11-07 21:50:44 UTC (rev 4753) @@ -44,7 +44,7 @@ import java.util.concurrent.TimeUnit; import javax.enterprise.context.Conversation; -import javax.enterprise.inject.Any; +import javax.enterprise.inject.Instance; import javax.inject.Inject; import org.jboss.weld.Container; @@ -65,8 +65,8 @@ private static final LocLogger log = loggerFactory().getLogger(CONVERSATION); // The current conversation - @Inject @Any - private ConversationImpl currentConversation; + @Inject + private Instance<ConversationImpl> currentConversation; // The conversation timeout in milliseconds waiting for access to a blocked // conversation @@ -129,7 +129,7 @@ // If all goes well, set the identity of the current conversation to // match the fetched long-running one String oldConversation = currentConversation.toString(); - currentConversation.switchTo(resumedConversationEntry.getConversation()); + currentConversation.get().switchTo(resumedConversationEntry.getConversation()); log.trace(CONVERSATION_SWITCHED, oldConversation, currentConversation); } } @@ -139,10 +139,10 @@ public void cleanupConversation() { log.trace(CLEANING_UP_CONVERSATION, currentConversation); - String cid = currentConversation.getUnderlyingId(); - if (!currentConversation.isTransient()) + String cid = currentConversation.get().getUnderlyingId(); + if (!currentConversation.get().isTransient()) { - Future<?> terminationHandle = scheduleForTermination(cid, currentConversation.getTimeout()); + Future<?> terminationHandle = scheduleForTermination(cid, currentConversation.get().getTimeout()); // When the conversation ends, a long-running conversation needs to // start its self-destruct. We can have the case where the conversation // is a previously known conversation (that had it's termination @@ -157,7 +157,7 @@ } else { - ConversationEntry conversationEntry = ConversationEntry.of(getBeanStore(cid), currentConversation, terminationHandle); + ConversationEntry conversationEntry = ConversationEntry.of(getBeanStore(cid), currentConversation.get(), terminationHandle); longRunningConversations.put(cid, conversationEntry); } log.trace(CONVERSATION_TERMINATION_SCHEDULED, currentConversation); @@ -183,12 +183,12 @@ // Conversation.begin(String), we need to unlock the original conversation // and re-schedule // it for termination - String originalCid = currentConversation.getOriginalId(); + String originalCid = currentConversation.get().getOriginalId(); ConversationEntry longRunningConversation = originalCid == null ? null : longRunningConversations.get(originalCid); if (longRunningConversation != null) { longRunningConversation.unlock(); - longRunningConversation.reScheduleTermination(scheduleForTermination(originalCid, currentConversation.getTimeout())); + longRunningConversation.reScheduleTermination(scheduleForTermination(originalCid, currentConversation.get().getTimeout())); } } Modified: core/trunk/impl/src/main/java/org/jboss/weld/event/EventImpl.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/event/EventImpl.java 2009-11-07 21:36:10 UTC (rev 4752) +++ core/trunk/impl/src/main/java/org/jboss/weld/event/EventImpl.java 2009-11-07 21:50:44 UTC (rev 4753) @@ -16,19 +16,28 @@ */ package org.jboss.weld.event; +import static org.jboss.weld.util.Reflections.EMPTY_ANNOTATIONS; + +import java.io.InvalidObjectException; +import java.io.ObjectInputStream; +import java.io.ObjectStreamException; +import java.io.Serializable; import java.lang.annotation.Annotation; import java.lang.reflect.Type; -import java.util.Arrays; import java.util.HashSet; import java.util.Set; import javax.enterprise.event.Event; +import javax.enterprise.inject.Default; +import javax.enterprise.inject.spi.InjectionPoint; import javax.enterprise.util.TypeLiteral; import org.jboss.weld.BeanManagerImpl; -import org.jboss.weld.bean.builtin.facade.AbstractFacade; +import org.jboss.weld.bean.builtin.AbstractFacade; +import org.jboss.weld.literal.DefaultLiteral; +import org.jboss.weld.util.Beans; +import org.jboss.weld.util.Names; import org.jboss.weld.util.Observers; -import org.jboss.weld.util.Strings; /** * Implementation of the Event interface @@ -38,67 +47,100 @@ * @param <T> The type of event being wrapped * @see javax.enterprise.event.Event */ -public class EventImpl<T> extends AbstractFacade<T, Event<T>> implements Event<T> +public class EventImpl<T> extends AbstractFacade<T, Event<T>> implements Event<T>, Serializable { private static final long serialVersionUID = 656782657242515455L; - private static final Annotation[] EMPTY_BINDINGS = new Annotation[0]; + private static final Default DEFAULT = new DefaultLiteral(); - public static <E> EventImpl<E> of(Type eventType, BeanManagerImpl manager, Set<Annotation> bindings) + public static <E> EventImpl<E> of(InjectionPoint injectionPoint, BeanManagerImpl beanManager) { - return new EventImpl<E>(eventType, manager, bindings); + return new EventImpl<E>(getFacadeType(injectionPoint), getFacadeEventQualifiers(injectionPoint), injectionPoint, beanManager); } + private static Annotation[] getFacadeEventQualifiers(InjectionPoint injectionPoint) + { + if (!injectionPoint.getAnnotated().isAnnotationPresent(Default.class)) + { + Set<Annotation> qualifers = new HashSet<Annotation>(injectionPoint.getQualifiers()); + qualifers.remove(DEFAULT); + return qualifers.toArray(EMPTY_ANNOTATIONS); + } + else + { + return injectionPoint.getQualifiers().toArray(EMPTY_ANNOTATIONS); + } + } + private EventImpl(Type type, Annotation[] qualifiers, InjectionPoint injectionPoint, BeanManagerImpl beanManager) + { + super(type, qualifiers, injectionPoint, beanManager); + } + /** - * Constructor + * Gets a string representation * - * @param eventType The event type - * @param manager The Bean manager - * @param bindings The binding types + * @return A string representation */ - private EventImpl(Type eventType, BeanManagerImpl manager, Set<Annotation> bindings) - { - super(eventType, manager, bindings); - } - @Override public String toString() { - StringBuilder buffer = new StringBuilder(); - buffer.append("Observable Event:\n"); - buffer.append(" Event Type: " + getType().toString() + "\n"); - buffer.append(Strings.collectionToString(" Event Bindings: ", getBindings())); - return buffer.toString(); + return new StringBuilder().append(Names.annotationsToString(getQualifiers())).append(" Event<").append(getType()).append(">").toString(); } public void fire(T event) { - getManager().fireEvent(event, getBindings().toArray(EMPTY_BINDINGS)); + getBeanManager().fireEvent(event, getQualifiers()); } - public Event<T> select(Annotation... bindings) + public Event<T> select(Annotation... qualifiers) { - return selectEvent(this.getType(), bindings); + return selectEvent(this.getType(), qualifiers); } - public <U extends T> Event<U> select(Class<U> subtype, Annotation... bindings) + public <U extends T> Event<U> select(Class<U> subtype, Annotation... qualifiers) { - return selectEvent(subtype, bindings); + return selectEvent(subtype, qualifiers); } - public <U extends T> Event<U> select(TypeLiteral<U> subtype, Annotation... bindings) + public <U extends T> Event<U> select(TypeLiteral<U> subtype, Annotation... qualifiers) { - return selectEvent(subtype.getType(), bindings); + return selectEvent(subtype.getType(), qualifiers); } - public <U extends T> Event<U> selectEvent(Type subtype, Annotation[] bindings) + private <U extends T> Event<U> selectEvent(Type subtype, Annotation[] newQualifiers) { Observers.checkEventObjectType(subtype); - return new EventImpl<U>( - subtype, - this.getManager(), - new HashSet<Annotation>(Arrays.asList(mergeInBindings(bindings)))); - } + return new EventImpl<U>(subtype, Beans.mergeInQualifiers(getQualifiers(), newQualifiers), getInjectionPoint(), getBeanManager()); + } + + // Serialization + + private Object writeReplace() throws ObjectStreamException + { + return new SerializationProxy(this); + } + + private void readObject(ObjectInputStream stream) throws InvalidObjectException + { + throw new InvalidObjectException("Proxy required"); + } + + private static class SerializationProxy extends AbstractFacadeSerializationProxy + { + private static final long serialVersionUID = 9181171328831559650L; + + public SerializationProxy(EventImpl<?> event) + { + super(event); + } + + private Object readResolve() + { + return EventImpl.of(getInjectionPoint(), getBeanManager()); + } + + } + } Modified: core/trunk/impl/src/main/java/org/jboss/weld/injection/ConstructorInjectionPoint.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/injection/ConstructorInjectionPoint.java 2009-11-07 21:36:10 UTC (rev 4752) +++ core/trunk/impl/src/main/java/org/jboss/weld/injection/ConstructorInjectionPoint.java 2009-11-07 21:50:44 UTC (rev 4753) @@ -18,6 +18,10 @@ import static org.jboss.weld.injection.Exceptions.rethrowException; +import java.io.InvalidObjectException; +import java.io.ObjectInputStream; +import java.io.ObjectStreamException; +import java.io.Serializable; import java.lang.annotation.Annotation; import java.lang.reflect.Constructor; import java.lang.reflect.InvocationTargetException; @@ -33,11 +37,13 @@ import javax.enterprise.inject.spi.Bean; import org.jboss.weld.BeanManagerImpl; +import org.jboss.weld.introspector.ConstructorSignature; import org.jboss.weld.introspector.ForwardingWeldConstructor; +import org.jboss.weld.introspector.WeldClass; import org.jboss.weld.introspector.WeldConstructor; import org.jboss.weld.introspector.WeldParameter; -public class ConstructorInjectionPoint<T> extends ForwardingWeldConstructor<T> implements WeldInjectionPoint<T, Constructor<T>> +public class ConstructorInjectionPoint<T> extends ForwardingWeldConstructor<T> implements WeldInjectionPoint<T, Constructor<T>>, Serializable { private static abstract class ForwardingParameterInjectionPointList<T, X> extends AbstractList<ParameterInjectionPoint<T, X>> @@ -98,7 +104,7 @@ { try { - return delegate().newInstance(getParameterValues(getWBParameters(), null, null, manager, creationalContext)); + return delegate().newInstance(getParameterValues(getWeldParameters(), null, null, manager, creationalContext)); } catch (IllegalArgumentException e) { @@ -120,9 +126,9 @@ } @Override - public List<ParameterInjectionPoint<?, T>> getWBParameters() + public List<ParameterInjectionPoint<?, T>> getWeldParameters() { - final List<? extends WeldParameter<?, T>> delegate = super.getWBParameters(); + final List<? extends WeldParameter<?, T>> delegate = super.getWeldParameters(); return new ForwardingParameterInjectionPointList() { @@ -200,5 +206,50 @@ // TODO Auto-generated method stub return false; } + + // Serialization + + private Object writeReplace() throws ObjectStreamException + { + return new SerializationProxy<T>(this); + } + + private void readObject(ObjectInputStream stream) throws InvalidObjectException + { + throw new InvalidObjectException("Proxy required"); + } + + private static class SerializationProxy<T> extends WeldInjectionPointSerializationProxy<T, Constructor<T>> + { + private static final long serialVersionUID = 9181171328831559650L; + + private final ConstructorSignature signature; + + public SerializationProxy(ConstructorInjectionPoint<T> injectionPoint) + { + super(injectionPoint); + this.signature = injectionPoint.getSignature(); + } + + private Object readResolve() + { + return ConstructorInjectionPoint.of(getDeclaringBean(), getWeldConstructor()); + } + + protected WeldConstructor<T> getWeldConstructor() + { + return getWeldClass().getDeclaredWeldConstructor(signature); + } + + @SuppressWarnings("unchecked") + @Override + protected WeldClass<T> getWeldClass() + { + return (WeldClass<T>) super.getWeldClass(); + } + + } + + } Modified: core/trunk/impl/src/main/java/org/jboss/weld/injection/FieldInjectionPoint.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/injection/FieldInjectionPoint.java 2009-11-07 21:36:10 UTC (rev 4752) +++ core/trunk/impl/src/main/java/org/jboss/weld/injection/FieldInjectionPoint.java 2009-11-07 21:50:44 UTC (rev 4753) @@ -18,6 +18,10 @@ import static org.jboss.weld.injection.Exceptions.rethrowException; +import java.io.InvalidObjectException; +import java.io.ObjectInputStream; +import java.io.ObjectStreamException; +import java.io.Serializable; import java.lang.annotation.Annotation; import java.lang.reflect.Field; import java.lang.reflect.Member; @@ -36,15 +40,16 @@ import org.jboss.weld.introspector.ForwardingWeldField; import org.jboss.weld.introspector.WeldField; -public class FieldInjectionPoint<T, X> extends ForwardingWeldField<T, X> implements WeldInjectionPoint<T, Field> +public class FieldInjectionPoint<T, X> extends ForwardingWeldField<T, X> implements WeldInjectionPoint<T, Field>, Serializable { - + private static final Annotation[] EMPTY_ANNOTATION_ARRAY = new Annotation[0]; private final Bean<?> declaringBean; private final WeldField<T, X> field; private final boolean delegate; + public static <T, X> FieldInjectionPoint<T, X> of(Bean<?> declaringBean, WeldField<T, X> field) { return new FieldInjectionPoint<T, X>(declaringBean, field); @@ -131,6 +136,45 @@ { return getJavaMember(); } + + + + // Serialization + + private Object writeReplace() throws ObjectStreamException + { + return new SerializationProxy<T>(this); + } + + private void readObject(ObjectInputStream stream) throws InvalidObjectException + { + throw new InvalidObjectException("Proxy required"); + } + + private static class SerializationProxy<T> extends WeldInjectionPointSerializationProxy<T, Field> + { + + private static final long serialVersionUID = -3491482804822264969L; + + private final String fieldName; + public SerializationProxy(FieldInjectionPoint<T, ?> injectionPoint) + { + super(injectionPoint); + this.fieldName = injectionPoint.getName(); + } + + private Object readResolve() + { + return FieldInjectionPoint.of(getDeclaringBean(), getWeldField()); + } + + protected WeldField<T, ?> getWeldField() + { + return getWeldClass().getDeclaredWeldField(fieldName); + } + + } + } Modified: core/trunk/impl/src/main/java/org/jboss/weld/injection/MethodInjectionPoint.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/injection/MethodInjectionPoint.java 2009-11-07 21:36:10 UTC (rev 4752) +++ core/trunk/impl/src/main/java/org/jboss/weld/injection/MethodInjectionPoint.java 2009-11-07 21:50:44 UTC (rev 4753) @@ -18,6 +18,9 @@ import static org.jboss.weld.injection.Exceptions.rethrowException; +import java.io.InvalidObjectException; +import java.io.ObjectInputStream; +import java.io.ObjectStreamException; import java.lang.annotation.Annotation; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Member; @@ -34,6 +37,7 @@ import org.jboss.weld.BeanManagerImpl; import org.jboss.weld.introspector.ForwardingWeldMethod; +import org.jboss.weld.introspector.MethodSignature; import org.jboss.weld.introspector.WeldMethod; import org.jboss.weld.introspector.WeldParameter; @@ -98,7 +102,7 @@ { try { - return delegate().invoke(declaringInstance, getParameterValues(getWBParameters(), null, null, manager, creationalContext)); + return delegate().invoke(declaringInstance, getParameterValues(getWeldParameters(), null, null, manager, creationalContext)); } catch (IllegalArgumentException e) { @@ -120,7 +124,7 @@ { try { - return invoke(declaringInstance, getParameterValues(getWBParameters(), annotatedParameter, parameter, manager, creationalContext)); + return invoke(declaringInstance, getParameterValues(getWeldParameters(), annotatedParameter, parameter, manager, creationalContext)); } catch (IllegalArgumentException e) { @@ -141,7 +145,7 @@ { try { - return delegate().invokeOnInstance(declaringInstance, getParameterValues(getWBParameters(), null, null, manager, creationalContext)); + return delegate().invokeOnInstance(declaringInstance, getParameterValues(getWeldParameters(), null, null, manager, creationalContext)); } catch (IllegalArgumentException e) { @@ -171,7 +175,7 @@ { try { - return invokeOnInstance(declaringInstance, getParameterValues(getWBParameters(), annotatedParameter, parameter, manager, creationalContext)); + return invokeOnInstance(declaringInstance, getParameterValues(getWeldParameters(), annotatedParameter, parameter, manager, creationalContext)); } catch (IllegalArgumentException e) { @@ -197,9 +201,9 @@ } @Override - public List<ParameterInjectionPoint<?, X>> getWBParameters() + public List<ParameterInjectionPoint<?, X>> getWeldParameters() { - final List<? extends WeldParameter<?, X>> delegate = super.getWBParameters(); + final List<? extends WeldParameter<?, X>> delegate = super.getWeldParameters(); return new ForwardingParameterInjectionPointList() { @@ -292,5 +296,43 @@ { return getJavaMember(); } + + + // Serialization + + private Object writeReplace() throws ObjectStreamException + { + return new SerializationProxy<T>(this); + } + + private void readObject(ObjectInputStream stream) throws InvalidObjectException + { + throw new InvalidObjectException("Proxy required"); + } + + private static class SerializationProxy<T> extends WeldInjectionPointSerializationProxy<T, Method> + { + private static final long serialVersionUID = 9181171328831559650L; + + private final MethodSignature signature; + + public SerializationProxy(MethodInjectionPoint<T, ?> injectionPoint) + { + super(injectionPoint); + this.signature = injectionPoint.getSignature(); + } + + private Object readResolve() + { + return MethodInjectionPoint.of(getDeclaringBean(), getWeldMethod()); + } + + protected WeldMethod<T, ?> getWeldMethod() + { + return getWeldClass().getDeclaredWeldMethod(signature); + } + + } + } Modified: core/trunk/impl/src/main/java/org/jboss/weld/injection/ParameterInjectionPoint.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/injection/ParameterInjectionPoint.java 2009-11-07 21:36:10 UTC (rev 4752) +++ core/trunk/impl/src/main/java/org/jboss/weld/injection/ParameterInjectionPoint.java 2009-11-07 21:50:44 UTC (rev 4753) @@ -16,6 +16,10 @@ */ package org.jboss.weld.injection; +import java.io.InvalidObjectException; +import java.io.ObjectInputStream; +import java.io.ObjectStreamException; +import java.io.Serializable; import java.lang.annotation.Annotation; import java.lang.reflect.Member; import java.lang.reflect.Type; @@ -28,10 +32,14 @@ import javax.enterprise.inject.spi.Decorator; import org.jboss.weld.BeanManagerImpl; +import org.jboss.weld.introspector.ConstructorSignature; import org.jboss.weld.introspector.ForwardingWeldParameter; +import org.jboss.weld.introspector.MethodSignature; +import org.jboss.weld.introspector.WeldConstructor; +import org.jboss.weld.introspector.WeldMethod; import org.jboss.weld.introspector.WeldParameter; -public class ParameterInjectionPoint<T, X> extends ForwardingWeldParameter<T, X> implements WeldInjectionPoint<T, Object> +public class ParameterInjectionPoint<T, X> extends ForwardingWeldParameter<T, X> implements WeldInjectionPoint<T, Object>, Serializable { private static final Annotation[] EMPTY_ANNOTATION_ARRAY = new Annotation[0]; @@ -110,6 +118,97 @@ { return getJavaMember(); } + + // Serialization + + private Object writeReplace() throws ObjectStreamException + { + return new SerializationProxy<T>(this); + } + + private void readObject(ObjectInputStream stream) throws InvalidObjectException + { + throw new InvalidObjectException("Proxy required"); + } + + private static class SerializationProxy<T> extends WeldInjectionPointSerializationProxy<T, Object> + { + + private static final long serialVersionUID = -3491482804822264969L; + + private final int parameterPosition; + private final MethodSignature methodSignature; + private final ConstructorSignature constructorSignature; + public SerializationProxy(ParameterInjectionPoint<T, ?> injectionPoint) + { + super(injectionPoint); + this.parameterPosition = injectionPoint.getPosition(); + if (injectionPoint.delegate().getDeclaringWeldCallable() instanceof WeldMethod<?, ?>) + { + this.methodSignature = ((WeldMethod<?, ?>) injectionPoint.delegate().getDeclaringWeldCallable()).getSignature(); + this.constructorSignature = null; + } + else if (injectionPoint.delegate().getDeclaringWeldCallable() instanceof WeldConstructor<?>) + { + this.methodSignature = null; + this.constructorSignature = ((WeldConstructor<?>) injectionPoint.delegate().getDeclaringWeldCallable()).getSignature(); + } + else + { + throw new IllegalStateException("Cannot handle injection point as neither constructor or method. Injection Point: " + injectionPoint); + } + } + + private Object readResolve() + { + return ParameterInjectionPoint.of(getDeclaringBean(), getWeldParameter()); + } + + protected WeldParameter<T, ?> getWeldParameter() + { + if (methodSignature != null) + { + WeldMethod<?, ?> method = getWeldClass().getDeclaredWeldMethod(methodSignature); + if (method.getParameters().size() > parameterPosition) + { + WeldParameter<?, ?> p = method.getWeldParameters().get(parameterPosition); + + @SuppressWarnings("unchecked") + WeldParameter<T, ?> px = (WeldParameter<T, ?>) p; + + return px; + } + else + { + throw new IllegalStateException("Parameter not in list. Parameter position: " + parameterPosition + "; Parameters: " + method.getParameters()); + } + } + else if (constructorSignature != null) + { + WeldConstructor<?> constructor = getWeldClass().getDeclaredWeldConstructor(constructorSignature); + if (constructor.getParameters().size() > parameterPosition) + { + WeldParameter<?, ?> p = constructor.getWeldParameters().get(parameterPosition); + + @SuppressWarnings("unchecked") + WeldParameter<T, ?> px = (WeldParameter<T, ?>) p; + + return px; + } + else + { + throw new IllegalStateException("Parameter not in list. Parameter position: " + parameterPosition + "; Parameters: " + constructor.getParameters()); + } + } + else + { + throw new IllegalStateException("Cannot read object"); + } + + } + + } + } Modified: core/trunk/impl/src/main/java/org/jboss/weld/injection/WeldInjectionPoint.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/injection/WeldInjectionPoint.java 2009-11-07 21:36:10 UTC (rev 4752) +++ core/trunk/impl/src/main/java/org/jboss/weld/injection/WeldInjectionPoint.java 2009-11-07 21:50:44 UTC (rev 4753) @@ -16,13 +16,46 @@ */ package org.jboss.weld.injection; +import java.io.Serializable; + +import javax.enterprise.inject.spi.Bean; import javax.enterprise.inject.spi.InjectionPoint; +import org.jboss.weld.Container; import org.jboss.weld.introspector.WeldAnnotated; +import org.jboss.weld.introspector.WeldClass; +import org.jboss.weld.resources.ClassTransformer; +import org.jboss.weld.serialization.spi.ContextualStore; public interface WeldInjectionPoint<T, S> extends InjectionPoint, WeldAnnotated<T, S> { + static abstract class WeldInjectionPointSerializationProxy<T, S> implements Serializable + { + + private static final long serialVersionUID = -5488095196637387378L; + + private final String declaringBeanId; + private final Class<?> declaringClass; + + public WeldInjectionPointSerializationProxy(WeldInjectionPoint<T, S> injectionPoint) + { + this.declaringBeanId = Container.instance().deploymentServices().get(ContextualStore.class).putIfAbsent(injectionPoint.getBean()); + this.declaringClass = injectionPoint.getBean().getBeanClass(); + } + + protected Bean<T> getDeclaringBean() + { + return Container.instance().deploymentServices().get(ContextualStore.class).<Bean<T>, T>getContextual(declaringBeanId); + } + + protected WeldClass<?> getWeldClass() + { + return Container.instance().deploymentServices().get(ClassTransformer.class).loadClass(declaringClass); + } + + } + /** * Injects an instance * Modified: core/trunk/impl/src/main/java/org/jboss/weld/introspector/ForwardingWeldClass.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/introspector/ForwardingWeldClass.java 2009-11-07 21:36:10 UTC (rev 4752) +++ core/trunk/impl/src/main/java/org/jboss/weld/introspector/ForwardingWeldClass.java 2009-11-07 21:50:44 UTC (rev 4753) @@ -87,9 +87,9 @@ return delegate().getWeldMethod(method); } - public <M> WeldMethod<M, ?> getWBMethod(MethodSignature signature) + public <M> WeldMethod<M, ?> getWeldMethod(MethodSignature signature) { - return delegate().getWBMethod(signature); + return delegate().getWeldMethod(signature); } public Set<WeldMethod<?, ?>> getWeldMethodsWithAnnotatedParameters(Class<? extends Annotation> annotationType) @@ -144,14 +144,14 @@ return delegate().getDeclaredWeldMethod(method); } - public <F> WeldField<F, ?> getDeclaredWeldField(String fieldName, WeldClass<F> expectedType) + public <F> WeldField<F, ?> getDeclaredWeldField(String fieldName) { - return delegate().getDeclaredWeldField(fieldName, expectedType); + return delegate().getDeclaredWeldField(fieldName); } public <M> WeldMethod<M, ?> getDeclaredWeldMethod(MethodSignature signature, WeldClass<M> expectedReturnType) { - return delegate().getDeclaredWeldMethod(signature, expectedReturnType); + return delegate().getDeclaredWeldMethod(signature); } public WeldConstructor<T> getDeclaredWeldConstructor(ConstructorSignature signature) Modified: core/trunk/impl/src/main/java/org/jboss/weld/introspector/ForwardingWeldConstructor.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/introspector/ForwardingWeldConstructor.java 2009-11-07 21:36:10 UTC (rev 4752) +++ core/trunk/impl/src/main/java/org/jboss/weld/introspector/ForwardingWeldConstructor.java 2009-11-07 21:50:44 UTC (rev 4753) @@ -40,9 +40,9 @@ return delegate().getDeclaringType(); } - public List<? extends WeldParameter<?, T>> getWBParameters() + public List<? extends WeldParameter<?, T>> getWeldParameters() { - return delegate().getWBParameters(); + return delegate().getWeldParameters(); } public T newInstance(Object... parameters) throws IllegalArgumentException, InstantiationException, IllegalAccessException, InvocationTargetException Modified: core/trunk/impl/src/main/java/org/jboss/weld/introspector/ForwardingWeldMethod.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/introspector/ForwardingWeldMethod.java 2009-11-07 21:36:10 UTC (rev 4752) +++ core/trunk/impl/src/main/java/org/jboss/weld/introspector/ForwardingWeldMethod.java 2009-11-07 21:50:44 UTC (rev 4753) @@ -44,9 +44,9 @@ return delegate().getParameterTypesAsArray(); } - public List<? extends WeldParameter<?, X>> getWBParameters() + public List<? extends WeldParameter<?, X>> getWeldParameters() { - return delegate().getWBParameters(); + return delegate().getWeldParameters(); } public String getPropertyName() Modified: core/trunk/impl/src/main/java/org/jboss/weld/introspector/ForwardingWeldParameter.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/introspector/ForwardingWeldParameter.java 2009-11-07 21:36:10 UTC (rev 4752) +++ core/trunk/impl/src/main/java/org/jboss/weld/introspector/ForwardingWeldParameter.java 2009-11-07 21:50:44 UTC (rev 4753) @@ -35,4 +35,9 @@ return delegate().getPosition(); } + public WeldCallable<?, X, ?> getDeclaringWeldCallable() + { + return delegate().getDeclaringWeldCallable(); + } + } Modified: core/trunk/impl/src/main/java/org/jboss/weld/introspector/WeldCallable.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/introspector/WeldCallable.java 2009-11-07 21:36:10 UTC (rev 4752) +++ core/trunk/impl/src/main/java/org/jboss/weld/introspector/WeldCallable.java 2009-11-07 21:50:44 UTC (rev 4753) @@ -35,7 +35,7 @@ * @return A list of parameters. Returns an empty list if no parameters are * present. */ - public List<? extends WeldParameter<?, X>> getWBParameters(); + public List<? extends WeldParameter<?, X>> getWeldParameters(); /** * Gets the list of annotated parameters for a given annotation Modified: core/trunk/impl/src/main/java/org/jboss/weld/introspector/WeldClass.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/introspector/WeldClass.java 2009-11-07 21:36:10 UTC (rev 4752) +++ core/trunk/impl/src/main/java/org/jboss/weld/introspector/WeldClass.java 2009-11-07 21:50:44 UTC (rev 4753) @@ -57,10 +57,9 @@ * * @param <F> the expected type of the field * @param fieldName the field name - * @param expectedType the expected type of the field * @return the field */ - public <F> WeldField<F, ?> getDeclaredWeldField(String fieldName, WeldClass<F> expectedType); + public <F> WeldField<F, ?> getDeclaredWeldField(String fieldName); /** * Gets all fields which are annotated with the given annotation type on this @@ -154,11 +153,9 @@ * * @param <M> the expected return type * @param signature the name of the method - * @param expectedReturnType the expected return type * @return the method, or null if it doesn't exist */ - public <M> WeldMethod<M, ?> getDeclaredWeldMethod(MethodSignature signature, - WeldClass<M> expectedReturnType); + public <M> WeldMethod<M, ?> getDeclaredWeldMethod(MethodSignature signature); /** * Get a method by name @@ -167,7 +164,7 @@ * @param signature the name of the method * @return the method, or null if it doesn't exist */ - public <M> WeldMethod<M, ?> getWBMethod(MethodSignature signature); + public <M> WeldMethod<M, ?> getWeldMethod(MethodSignature signature); // TODO Replace with AnnotatedMethod variant @Deprecated Modified: core/trunk/impl/src/main/java/org/jboss/weld/introspector/WeldParameter.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/introspector/WeldParameter.java 2009-11-07 21:36:10 UTC (rev 4752) +++ core/trunk/impl/src/main/java/org/jboss/weld/introspector/WeldParameter.java 2009-11-07 21:50:44 UTC (rev 4753) @@ -27,5 +27,7 @@ */ public interface WeldParameter<T, X> extends WeldAnnotated<T, Object>, AnnotatedParameter<X> { + + public WeldCallable<?, X, ?> getDeclaringWeldCallable(); } Modified: core/trunk/impl/src/main/java/org/jboss/weld/introspector/jlr/ConstructorSignatureImpl.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/introspector/jlr/ConstructorSignatureImpl.java 2009-11-07 21:36:10 UTC (rev 4752) +++ core/trunk/impl/src/main/java/org/jboss/weld/introspector/jlr/ConstructorSignatureImpl.java 2009-11-07 21:50:44 UTC (rev 4753) @@ -31,10 +31,10 @@ public ConstructorSignatureImpl(WeldConstructor<?> method) { - this.parameterTypes = new String[method.getWBParameters().size()]; - for (int i = 0; i < method.getWBParameters().size(); i++) + this.parameterTypes = new String[method.getWeldParameters().size()]; + for (int i = 0; i < method.getWeldParameters().size(); i++) { - parameterTypes[i] = method.getWBParameters().get(i).getJavaClass().getName(); + parameterTypes[i] = method.getWeldParameters().get(i).getJavaClass().getName(); } } @@ -56,7 +56,7 @@ @Override public int hashCode() { - return getParameterTypes().hashCode(); + return Arrays.hashCode(parameterTypes); } public String[] getParameterTypes() Modified: core/trunk/impl/src/main/java/org/jboss/weld/introspector/jlr/MethodSignatureImpl.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/introspector/jlr/MethodSignatureImpl.java 2009-11-07 21:36:10 UTC (rev 4752) +++ core/trunk/impl/src/main/java/org/jboss/weld/introspector/jlr/MethodSignatureImpl.java 2009-11-07 21:50:44 UTC (rev 4753) @@ -34,10 +34,10 @@ public MethodSignatureImpl(WeldMethod<?, ?> method) { this.methodName = method.getName(); - this.parameterTypes = new String[method.getWBParameters().size()]; - for (int i = 0; i < method.getWBParameters().size(); i++) + this.parameterTypes = new String[method.getWeldParameters().size()]; + for (int i = 0; i < method.getWeldParameters().size(); i++) { - parameterTypes[i] = method.getWBParameters().get(i).getJavaClass().getName(); + parameterTypes[i] = method.getWeldParameters().get(i).getJavaClass().getName(); } } @@ -70,8 +70,8 @@ public int hashCode() { int hashCode = 17; - hashCode += getMethodName().hashCode() * 5; - hashCode += Arrays.hashCode(getParameterTypes()) * 7; + hashCode += methodName.hashCode() * 5; + hashCode += Arrays.hashCode(parameterTypes) * 7; return hashCode; } Modified: core/trunk/impl/src/main/java/org/jboss/weld/introspector/jlr/WeldClassImpl.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/introspector/jlr/WeldClassImpl.java 2009-11-07 21:36:10 UTC (rev 4752) +++ core/trunk/impl/src/main/java/org/jboss/weld/introspector/jlr/WeldClassImpl.java 2009-11-07 21:50:44 UTC (rev 4753) @@ -484,8 +484,8 @@ { return Collections.unmodifiableSet(declaredFields); } - - public <F> WeldField<F, ?> getDeclaredWeldField(String fieldName, WeldClass<F> expectedType) + + public <F> WeldField<F, ?> getDeclaredWeldField(String fieldName) { return (WeldField<F, ?>) declaredFieldsByName.get(fieldName); } @@ -661,17 +661,17 @@ } @SuppressWarnings("unchecked") - public <M> WeldMethod<M, ?> getDeclaredWeldMethod(MethodSignature signature, WeldClass<M> expectedReturnType) + public <M> WeldMethod<M, ?> getDeclaredWeldMethod(MethodSignature signature) { return (WeldMethod<M, ?>) declaredMethodsBySignature.get(signature); } @SuppressWarnings("unchecked") - public <M> WeldMethod<M, ?> getWBMethod(MethodSignature signature) + public <M> WeldMethod<M, ?> getWeldMethod(MethodSignature signature) { return (WeldMethod<M, ?>) methodsBySignature.get(signature); } - + /** * Gets a string representation of the class * Modified: core/trunk/impl/src/main/java/org/jboss/weld/introspector/jlr/WeldConstructorImpl.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/introspector/jlr/WeldConstructorImpl.java 2009-11-07 21:36:10 UTC (rev 4752) +++ core/trunk/impl/src/main/java/org/jboss/weld/introspector/jlr/WeldConstructorImpl.java 2009-11-07 21:50:44 UTC (rev 4753) @@ -206,9 +206,9 @@ * * @return A list of annotated parameter abstractions * - * @see org.jboss.weld.introspector.WeldConstructor#getWBParameters() + * @see org.jboss.weld.introspector.WeldConstructor#getWeldParameters() */ - public List<WeldParameter<?, T>> getWBParameters() + public List<WeldParameter<?, T>> getWeldParameters() { return Collections.unmodifiableList(parameters); } @@ -259,7 +259,7 @@ if (super.equals(other) && other instanceof WeldConstructor) { WeldConstructor<?> that = (WeldConstructor<?>) other; - return this.getDeclaringType().equals(that.getDeclaringType()) && this.getWBParameters().equals(that.getWBParameters()); + return this.getDeclaringType().equals(that.getDeclaringType()) && this.getWeldParameters().equals(that.getWeldParameters()); } return false; } Modified: core/trunk/impl/src/main/java/org/jboss/weld/introspector/jlr/WeldMethodImpl.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/introspector/jlr/WeldMethodImpl.java 2009-11-07 21:36:10 UTC (rev 4752) +++ core/trunk/impl/src/main/java/org/jboss/weld/introspector/jlr/WeldMethodImpl.java 2009-11-07 21:50:44 UTC (rev 4753) @@ -181,7 +181,7 @@ return method; } - public List<WeldParameter<?, X>> getWBParameters() + public List<WeldParameter<?, X>> getWeldParameters() { return Collections.unmodifiableList(parameters); } @@ -202,7 +202,7 @@ if (other instanceof WeldMethod) { WeldMethod<?, ?> that = (WeldMethod<?, ?>) other; - return this.getDeclaringType().equals(that.getDeclaringType()) && this.getName().equals(that.getName()) && this.getWBParameters().equals(that.getWBParameters()); + return this.getDeclaringType().equals(that.getDeclaringType()) && this.getName().equals(that.getName()) && this.getWeldParameters().equals(that.getWeldParameters()); } else { Modified: core/trunk/impl/src/main/java/org/jboss/weld/introspector/jlr/WeldParameterImpl.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/introspector/jlr/WeldParameterImpl.java 2009-11-07 21:36:10 UTC (rev 4752) +++ core/trunk/impl/src/main/java/org/jboss/weld/introspector/jlr/WeldParameterImpl.java 2009-11-07 21:50:44 UTC (rev 4753) @@ -151,6 +151,11 @@ { return declaringMember; } + + public WeldCallable<?, X, ?> getDeclaringWeldCallable() + { + return declaringMember; + } public int getPosition() { Modified: core/trunk/impl/src/main/java/org/jboss/weld/resolution/TypeSafeBeanResolver.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/resolution/TypeSafeBeanResolver.java 2009-11-07 21:36:10 UTC (rev 4752) +++ core/trunk/impl/src/main/java/org/jboss/weld/resolution/TypeSafeBeanResolver.java 2009-11-07 21:50:44 UTC (rev 4753) @@ -24,8 +24,8 @@ import javax.enterprise.inject.spi.Bean; import org.jboss.weld.BeanManagerImpl; -import org.jboss.weld.bean.builtin.facade.EventBean; -import org.jboss.weld.bean.builtin.facade.InstanceBean; +import org.jboss.weld.bean.builtin.EventBean; +import org.jboss.weld.bean.builtin.InstanceBean; import org.jboss.weld.util.Beans; import org.jboss.weld.util.Reflections; import org.jboss.weld.util.collections.ConcurrentCache; Modified: core/trunk/impl/src/main/java/org/jboss/weld/util/Beans.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/util/Beans.java 2009-11-07 21:36:10 UTC (rev 4752) +++ core/trunk/impl/src/main/java/org/jboss/weld/util/Beans.java 2009-11-07 21:50:44 UTC (rev 4753) @@ -29,6 +29,7 @@ import java.lang.annotation.Annotation; import java.lang.reflect.Type; import java.util.ArrayList; +import java.util.Arrays; import java.util.Collection; import java.util.Collections; import java.util.HashMap; @@ -53,8 +54,8 @@ import org.jboss.interceptor.model.InterceptionType; import org.jboss.interceptor.model.InterceptionTypeRegistry; import org.jboss.weld.BeanManagerImpl; +import org.jboss.weld.Container; import org.jboss.weld.DefinitionException; -import org.jboss.weld.bean.AbstractProducerBean; import org.jboss.weld.bean.RIBean; import org.jboss.weld.bean.SessionBean; import org.jboss.weld.bean.DecoratorImpl; @@ -124,14 +125,10 @@ */ public static boolean isPassivationCapableBean(Bean<?> bean) { - if (bean instanceof SessionBean<?>) + if (bean instanceof RIBean<?>) { - return ((SessionBean<?>) bean).getEjbDescriptor().isStateful(); + return ((RIBean<?>) bean).isPassivationCapable(); } - else if (bean instanceof AbstractProducerBean<?, ?, ?>) - { - return Reflections.isSerializable(((AbstractProducerBean<?, ?, ?>) bean).getType()); - } else { return Reflections.isSerializable(bean.getBeanClass()); @@ -394,7 +391,7 @@ public static Set<ParameterInjectionPoint<?, ?>> getParameterInjectionPoints(Bean<?> declaringBean, WeldConstructor<?> constructor) { Set<ParameterInjectionPoint<?,?>> injectionPoints = new HashSet<ParameterInjectionPoint<?,?>>(); - for (WeldParameter<?, ?> parameter : constructor.getWBParameters()) + for (WeldParameter<?, ?> parameter : constructor.getWeldParameters()) { injectionPoints.add(ParameterInjectionPoint.of(declaringBean, parameter)); } @@ -404,7 +401,7 @@ public static Set<ParameterInjectionPoint<?, ?>> getParameterInjectionPoints(Bean<?> declaringBean, MethodInjectionPoint<?, ?> method) { Set<ParameterInjectionPoint<?,?>> injectionPoints = new HashSet<ParameterInjectionPoint<?,?>>(); - for (WeldParameter<?, ?> parameter : method.getWBParameters()) + for (WeldParameter<?, ?> parameter : method.getWeldParameters()) { injectionPoints.add(ParameterInjectionPoint.of(declaringBean, parameter)); } @@ -418,7 +415,7 @@ { for (MethodInjectionPoint<?, ?> method : i) { - for (WeldParameter<?, ?> parameter : method.getWBParameters()) + for (WeldParameter<?, ?> parameter : method.getWeldParameters()) { injectionPoints.add(ParameterInjectionPoint.of(declaringBean, parameter)); } @@ -751,6 +748,27 @@ { return annotatedItem.isAnnotationPresent(Decorator.class); } + + public static Annotation[] mergeInQualifiers(Annotation[] qualifiers, Annotation[] newQualifiers) + { + Set<Annotation> result = new HashSet<Annotation>(); + result.addAll(Arrays.asList(qualifiers)); + Set<Annotation> checkedNewQualifiers = new HashSet<Annotation>(); + for (Annotation qualifier : newQualifiers) + { + if (!Container.instance().deploymentServices().get(MetaAnnotationStore.class).getBindingTypeModel(qualifier.annotationType()).isValid()) + { + throw new IllegalArgumentException("Annotation is not a qualifier. Qualifier: " + qualifier); + } + if (checkedNewQualifiers.contains(qualifier)) + { + throw new IllegalArgumentException("Qualifier is already present. Qualifier: " + qualifier + "; All qualifiers: " + Arrays.asList(newQualifiers)); + } + checkedNewQualifiers.add(qualifier); + } + result.addAll(checkedNewQualifiers); + return result.toArray(Reflections.EMPTY_ANNOTATIONS); + } public static InjectionPoint getDelegateInjectionPoint(javax.enterprise.inject.spi.Decorator<?> decorator) { Modified: core/trunk/impl/src/main/java/org/jboss/weld/util/Proxies.java =================================================================== --- core/trunk/impl/src/main/java/org/jboss/weld/util/Proxies.java 2009-11-07 21:36:10 UTC (rev 4752) +++ core/trunk/impl/src/main/java/org/jboss/weld/util/Proxies.java 2009-11-07 21:50:44 UTC (rev 4753) @@ -24,7 +24,9 @@ import java.util.LinkedHashSet; import java.util.Set; +import javassist.util.proxy.MethodHandler; import javassist.util.proxy.ProxyFactory; +import javassist.util.proxy.ProxyObject; /** * Utilties for working with Javassist proxies @@ -35,7 +37,7 @@ */ public class Proxies { - + public static class TypeInfo { @@ -87,9 +89,9 @@ return proxyFactory; } - private void add(Type type) + public TypeInfo add(Type type) { - if (type instanceof Class) + if (type instanceof Class<?>) { Class<?> clazz = (Class<?>) type; if (clazz.isInterface()) @@ -109,41 +111,49 @@ { throw new IllegalArgumentException("Cannot proxy non-Class Type " + type); } + return this; } - public static TypeInfo ofTypes(Set<? extends Type> types) + public static TypeInfo of(Set<? extends Type> types) { - TypeInfo typeInfo = new TypeInfo(); + TypeInfo typeInfo = create(); for (Type type : types) { typeInfo.add(type); } return typeInfo; } - - public static TypeInfo ofClasses(Set<Class<?>> classes) + + public static TypeInfo create() { - TypeInfo typeInfo = new TypeInfo(); - for (Class<?> type : classes) - { - typeInfo.add(type); - } - return typeInfo; + return new TypeInfo(); } } - - /** - * Get the proxy factory for the given set of types - * - * @param types The types to create the proxy factory for - * @param classes Additional interfaces the proxy should implement - * @return the proxy factory - */ - public static ProxyFactory getProxyFactory(Set<Type> types) + + public static <T> T createProxy(MethodHandler methodHandler, TypeInfo typeInfo) throws IllegalAccessException, InstantiationException { - return TypeInfo.ofTypes(types).createProxyFactory(); + return Proxies.<T>createProxyClass(methodHandler, typeInfo).newInstance(); } + + public static <T> Class<T> createProxyClass(TypeInfo typeInfo) + { + return createProxyClass(null, typeInfo); + } + + public static <T> Class<T> createProxyClass(MethodHandler methodHandler, TypeInfo typeInfo) + { + ProxyFactory proxyFactory = typeInfo.createProxyFactory(); + if (methodHandler != null) + { + proxyFactory.setHandler(methodHandler); + } + + @SuppressWarnings("unchecked") + Class<T> clazz = proxyFactory.createClass(); + + return clazz; + } /** * Indicates if a class is proxyable @@ -153,14 +163,14 @@ */ public static boolean isTypeProxyable(Type type) { - if (type instanceof Class) + if (type instanceof Class<?>) { return isClassProxyable((Class<?>) type); } else if (type instanceof ParameterizedType) { Type rawType = ((ParameterizedType) type).getRawType(); - if (rawType instanceof Class) + if (rawType instanceof Class<?>) { return isClassProxyable((Class<?>) rawType); } @@ -237,6 +247,20 @@ { return instance.getClass().getName().indexOf("_$$_javassist_") > 0; } + + public static <T> T attachMethodHandler(T instance, MethodHandler methodHandler) + { + if (instance instanceof ProxyObject) + { + ((ProxyObject) instance).setHandler(methodHandler); + return instance; + } + else + { + throw new IllegalArgumentException("Instance not a proxy. Instance: " + instance); + } + + } }