openwebbeans-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From strub...@apache.org
Subject svn commit: r1728163 [1/2] - in /openwebbeans/branches/cdi-2.0: ./ webbeans-doc/src/docbkx/userguide/ webbeans-ee/src/main/java/org/apache/webbeans/ee/event/ webbeans-impl/src/main/java/org/apache/webbeans/component/ webbeans-impl/src/main/java/org/apa...
Date Tue, 02 Feb 2016 17:48:15 GMT
Author: struberg
Date: Tue Feb  2 17:48:14 2016
New Revision: 1728163

URL: http://svn.apache.org/viewvc?rev=1728163&view=rev
Log:
Merged from trunk
properly set enabled flag for interceptors [from revision 1680659]
collapse statements [from revision 1680660]
remove unused method parameters [from revision 1680662]
remove unused method and field [from revision 1680664]
remove unused variable [from revision 1680666]
avoid NPE if cc.getbean is null [from revision 1680825]
remove redundant public qualifier from interface [from revision 1681040]
remove wrong JavaDoc [from revision 1681041]
remove unused 'withAnnotaions'

This was initially intended for CDI Extension support but turned out
not to be needed. [from revision 1681042]
OWB-1065 fix Incorrect matching of parameterized events

txs to Harald Wellmann for the catch and ideas for the unit test. [from revision 1681043]
OWB-1066 fix endless loop in GenericsUtil [from revision 1681576]
OWB-989 mark utility class ct as private [from revision 1681617]
OWB-798 do event binding check only if no observer could be found.

saves a lot of performance for most events [from revision 1681618]
OWB-798 improve performance of various event type checks [from revision 1681620]
OWB-1053 cache raw event types [from revision 1681630]
OWB-1075 improve annotation check performance [from revision 1681638]
OWB-1044 only fire @Destroyed and @Initialized if there are any observers for them. [from revision 1681646]
OWB-1044 improve lifecycle event caching even further

We cache RequestScoped even more agressively as this gets used
even for resource requests [from revision 1681652]
OWB-1051 move cache request scope proxies by default

* RequestScopedBeanInterceptorHandler got moved from owb-web to owb-core and enabled by default
* Also enable caches for @SessionScoped beans [from revision 1681656]
fix spi pom by making not mandatory ee specs optional [from revision 1681657]
OWB-851 improve registration of EE beans [from revision 1681659]
OWB-1061 mark ApplicationContext as already destroyed

We cannot immediately kill out the whole ApplicationContext and not even set it to inactive
as it is needed for delivering @BeforeShutdown events. [from revision 1681661]
OWB-1048 remove OpenWebBeansWebPlugin

Not needed anymore, we don't use the sessionId as it gets permanently rewritten anyway [from revision 1681663]
OWB-1048 remove now unused Tomcat ContainerListener

we do not use the sessionId anymore to track things as 
it got changed way too often to be of any use. [from revision 1681665]
OWB-812 extract commonly used "WebBeansContext" param name [from revision 1681689]
OWB-812 extract common nullcheck paramete [from revision 1681692]
OWB-821 extract common string [from revision 1681693]
OWB-821 make utility classes final [from revision 1681726]
OWB-1076 remove sample sources from binary distribution

They are already contained in the source distribution anyway [from revision 1681935]
OWB-933 adding test to verify all works now [from revision 1681961]
OWB-989 remove unecessary nullcheck [from revision 1681964]
OWB-989 remove redundant array creation [from revision 1681967]
OWB-989 using entrySet is faster [from revision 1681970]
OWB-989 remove TODOs as those cases should never happen. [from revision 1681971]
OWB-989 fix potential nullpointer [from revision 1681973]
OWB-989 avoid possible NPE [from revision 1681977]
OWB-989 remove redundant null checks [from revision 1681978]
OWB-989 don't throw NPEs [from revision 1681984]
OWB-1056 add missing dependencies [from revision 1682241]
OWB-1077 create install script for OWB on tomcat7 [from revision 1682245]
OWB-1077 also add an install script for tomcat6 integration of OWB [from revision 1682246]
OWB-1077 fix script documentation for tomat6 [from revision 1682249]
OWB-1077 rework distribution pom

Now you can also build a 'local' distribution zip with -Pbuild-dist [from revision 1682297]
OWB-1077 chmod to 0777 by default to have shell scripts executable [from revision 1682321]
OWB-1077 add a windows installer as well [from revision 1682328]
OWB-989 remove unused variable [from revision 1682371]
OWB-989 fix potential NPE and dead code [from revision 1682375]
OWB-989 avoid empty if blocks [from revision 1682377]
OWB-989 remove unecessary cast [from revision 1682379]
OWB-989 fix potential NPEs [from revision 1682380]
fix modifier ordering

to make sonar happy... [from revision 1682626]
OWB-1077 add install script for OWB + MyFaces on Tomcat7 & 8 [from revision 1682645]
add ASM license and notice to our distribution packages [from revision 1682655]
OWB-654 fix manual lookup of beans with generic types

Txs to Daniel Cunha (soro) for the patch! [from revision 1682658]
OWB-654 fix manual lookup of beans with generic types

Missed to add a few classes from the patch.
Txs to Daniel Cunha (soro) for the patch! [from revision 1682689]
OWB-1080 support for other JVM versions in our proxies

The new configuration affects which bytecode we generate in our proxy classes
* By default we now generate Java6 bytecode instead of Java5
* A new config org.apache.webbeans.generator.javaVersion=auto supports automatically
  detecting the current JVM java.version and use this
* Switch from CALC_MAX to real FRAME calculateion for our generated bytecode
* org.apache.webbeans.generator.javaVersion=1.8 etc can be used to specify a java version [from revision 1682898]
OWB-1055 fold back Begin and End listeners into one single Listener

It turned out not to be needed. [from revision 1682905]
OWB-1079 upgrade to xbean-4.3 which contains a shaded ASM-5.0.4 [from revision 1682910]
add release notes for OWB-1.6.0 [from revision 1682911]
OWB-1082 set serializable BeanManager wrapper into ServletContext and similar 'external' usages [from revision 1684722]
upgrade samples to latest available MyFaces version [from revision 1685115]
OWB-1083 avoid HttpSession creation during context destroyal

Txs to Adam Cornett for the report and partly fix! [from revision 1685118]
OWB-1081 check Reception.IF_EXISTS in case of an inactive context [from revision 1685641]
release preparation for owb-1.6.1 [from revision 1685698]
OWB-1084 tracking session to get the right (from owb point of view) session instance for destroy event [from revision 1688063]
OWB-935 add unit test 

A standard bean observing CDI Extension event which should not get triggered.
Extension events can only get observed in Extensions [from revision 1694733]
add description about how to debug the ITs [from revision 1694734]
add release notes for OWB-1.6.2 [from revision 1694735]
OWB-1093 WebApp beans scanning broken with maven and jetty [from revision 1704602]
OWB-1094 Move bean scanning excludes to openwebbeans.properties [from revision 1704889]
OWB-1094 renamed config name [from revision 1704908]
OWB-1094 possible NPE [from revision 1705018]
OWB-1096 Enable > CDI1.0 unit tests [from revision 1710680]
OWB-1095 fixed InjectionResolver cache handling on startup [from revision 1710767]
OWB-1098 improve getRootCause logic

txs to Tobias Stoeckmann for the patch! [from revision 1713935]
adding whitelist to BlacklistClassResolver [from revision 1716862]
fixing copy/paste from tomee [from revision 1716863]
useless method [from revision 1716866]
checkstyle sorry to have forgotten you my love [from revision 1716930]
improve documentation of our Conversation configuration [from revision 1719452]
improve conversation timeout documentation [from revision 1719453]
OWB-1034 improve BeanCacheKey performance

we actually don't need such a good qualifier hash as all gets compared
later anyways. So we now only look at the annotationTypes hash
and be good. 
I also enabled a special handling for qualifiers which are known 
to have no parameters. [from revision 1719457]
OWB-1104 add tomcat bootstrap.jar to scan-excludes [from revision 1723351]
OWB-1102 fix generic assignability check for ProcessInjectionPoint event

txs to Antonin Stefanutti for the bug report and providing a draft for a unit test! [from revision 1723685]
OWB-1108 destroy all SPI servicec which implement the Closeable interface [from revision 1723999]
OWB-1103 improve the DefaultApplicationBoundaryService to max return the Application CL as outermost CL. [from revision 1724000]
OWB-1103 add JavaDoc and make it easier to subclass [from revision 1724539]
OWB-1054 move all shutdown caches cleanup calls to the BeanManager [from revision 1724542]
OWB-1110 implement allowProxying logic

User can now define that classes are proxyable - even if they have final methods

* comma separated class list in java sytem prop -Djavax.enterprise.inject.allowProxying.classes=...
* or an environment key with the name JAVAX_ENTERPRISE_INJECT_ALLOWPROXYING_CLASSES=...
* or via beans.xml:
  <beans>
    <allowProxying>
      <class>Class1</class>
      <class>some.OtherClass</class>
    </allowProxying>
  </beans> [from revision 1724876]
OWB-1111 proper ections in case of errors 

* SystemExceptions will blow up as they indicate a systematic setup problem
* AFTER_SUCCESS gets skipped, on Rollback or IllegalState
* for all other phases (AFTER_COMPLETION, BEFORE_COMLETION, AFTER_FAILURE) 
  the event will get delivered immediate [from revision 1726303]
OWB-1111 also deliver the AFTER_SUCCESS if there is no active transaction [from revision 1726366]
OWB-1107 introduce bean-discovery-mode="scoped"

with this bean-discovery-mode we will create AnnotatedTypes and fire PAT for all scanned classes
but only pick up AnnotatedTypes as Bean<T> IF they are:
* have an explicit CDI scope annotation, or
* are an Interceptor or a Decorator, or
* are a JavaEE bean, or
* have a StereoType

This commit also removes a duplicate scanning which erronously got introduced accidently [from revision 1727788]
OWB-1107 adding <scopedBeansOnly/> backward compat option

adding a scopedBeansOnly tag to your beans.xml will make OWB only pick up scoped beans.
This is a backward compat option for bean-discovery-mode="scoped" [from revision 1727792]

Added:
    openwebbeans/branches/cdi-2.0/webbeans-impl/src/test/java/org/apache/webbeans/test/events/injectiontarget/ProcessInjectionPointTest.java
      - copied unchanged from r1723685, openwebbeans/trunk/webbeans-impl/src/test/java/org/apache/webbeans/test/events/injectiontarget/ProcessInjectionPointTest.java
    openwebbeans/branches/cdi-2.0/webbeans-impl/src/test/java/org/apache/webbeans/test/performance/BeanResolvingPerformanceTest.java
      - copied unchanged from r1719457, openwebbeans/trunk/webbeans-impl/src/test/java/org/apache/webbeans/test/performance/BeanResolvingPerformanceTest.java
    openwebbeans/branches/cdi-2.0/webbeans-impl/src/test/java/org/apache/webbeans/test/proxy/unproxyable/
      - copied from r1724876, openwebbeans/trunk/webbeans-impl/src/test/java/org/apache/webbeans/test/proxy/unproxyable/
    openwebbeans/branches/cdi-2.0/webbeans-impl/src/test/resources/org/apache/webbeans/test/xml/allowproxying/
      - copied from r1724876, openwebbeans/trunk/webbeans-impl/src/test/resources/org/apache/webbeans/test/xml/allowproxying/
    openwebbeans/branches/cdi-2.0/webbeans-impl/src/test/resources/org/apache/webbeans/test/xml/strict/cdi11_discovery_scoped.xml
      - copied unchanged from r1727792, openwebbeans/trunk/webbeans-impl/src/test/resources/org/apache/webbeans/test/xml/strict/cdi11_discovery_scoped.xml
    openwebbeans/branches/cdi-2.0/webbeans-impl/src/test/resources/org/apache/webbeans/test/xml/strict/cdi11_discovery_scopedBeansOnly.xml
      - copied unchanged from r1727792, openwebbeans/trunk/webbeans-impl/src/test/resources/org/apache/webbeans/test/xml/strict/cdi11_discovery_scopedBeansOnly.xml
    openwebbeans/branches/cdi-2.0/webbeans-spi/src/main/java/org/apache/webbeans/spi/BdaScannerService.java
      - copied unchanged from r1727788, openwebbeans/trunk/webbeans-spi/src/main/java/org/apache/webbeans/spi/BdaScannerService.java
    openwebbeans/branches/cdi-2.0/webbeans-tck/src/test/java/
      - copied from r1727788, openwebbeans/trunk/webbeans-tck/src/test/java/
Modified:
    openwebbeans/branches/cdi-2.0/   (props changed)
    openwebbeans/branches/cdi-2.0/webbeans-doc/src/docbkx/userguide/chapter1.xml
    openwebbeans/branches/cdi-2.0/webbeans-ee/src/main/java/org/apache/webbeans/ee/event/TransactionalEventNotifier.java
    openwebbeans/branches/cdi-2.0/webbeans-impl/src/main/java/org/apache/webbeans/component/AbstractOwbBean.java
    openwebbeans/branches/cdi-2.0/webbeans-impl/src/main/java/org/apache/webbeans/component/creation/BeanAttributesBuilder.java
    openwebbeans/branches/cdi-2.0/webbeans-impl/src/main/java/org/apache/webbeans/config/BeansDeployer.java
    openwebbeans/branches/cdi-2.0/webbeans-impl/src/main/java/org/apache/webbeans/config/DeploymentValidationService.java
    openwebbeans/branches/cdi-2.0/webbeans-impl/src/main/java/org/apache/webbeans/config/OpenWebBeansConfiguration.java
    openwebbeans/branches/cdi-2.0/webbeans-impl/src/main/java/org/apache/webbeans/config/PropertyLoader.java
    openwebbeans/branches/cdi-2.0/webbeans-impl/src/main/java/org/apache/webbeans/config/WebBeansContext.java
    openwebbeans/branches/cdi-2.0/webbeans-impl/src/main/java/org/apache/webbeans/container/BeanCacheKey.java
    openwebbeans/branches/cdi-2.0/webbeans-impl/src/main/java/org/apache/webbeans/container/BeanManagerImpl.java
    openwebbeans/branches/cdi-2.0/webbeans-impl/src/main/java/org/apache/webbeans/corespi/scanner/AbstractMetaDataDiscovery.java
    openwebbeans/branches/cdi-2.0/webbeans-impl/src/main/java/org/apache/webbeans/corespi/se/DefaultApplicationBoundaryService.java
    openwebbeans/branches/cdi-2.0/webbeans-impl/src/main/java/org/apache/webbeans/event/NotificationManager.java
    openwebbeans/branches/cdi-2.0/webbeans-impl/src/main/java/org/apache/webbeans/lifecycle/AbstractLifeCycle.java
    openwebbeans/branches/cdi-2.0/webbeans-impl/src/main/java/org/apache/webbeans/util/ClassUtil.java
    openwebbeans/branches/cdi-2.0/webbeans-impl/src/main/java/org/apache/webbeans/util/OwbCustomObjectInputStream.java
    openwebbeans/branches/cdi-2.0/webbeans-impl/src/main/java/org/apache/webbeans/util/SpecializationUtil.java
    openwebbeans/branches/cdi-2.0/webbeans-impl/src/main/java/org/apache/webbeans/util/WebBeansConstants.java
    openwebbeans/branches/cdi-2.0/webbeans-impl/src/main/java/org/apache/webbeans/xml/DefaultBeanArchiveInformation.java
    openwebbeans/branches/cdi-2.0/webbeans-impl/src/main/java/org/apache/webbeans/xml/DefaultBeanArchiveService.java
    openwebbeans/branches/cdi-2.0/webbeans-impl/src/main/resources/META-INF/openwebbeans/openwebbeans.properties
    openwebbeans/branches/cdi-2.0/webbeans-impl/src/test/java/org/apache/webbeans/test/annotation/binding/BeanCacheKeyUnitTest.java
    openwebbeans/branches/cdi-2.0/webbeans-impl/src/test/java/org/apache/webbeans/test/xml/BeanArchiveServiceTest.java
    openwebbeans/branches/cdi-2.0/webbeans-jsf/src/main/resources/META-INF/openwebbeans/openwebbeans.properties
    openwebbeans/branches/cdi-2.0/webbeans-jsf12/src/main/resources/META-INF/openwebbeans/openwebbeans.properties
    openwebbeans/branches/cdi-2.0/webbeans-spi/src/main/java/org/apache/webbeans/spi/ApplicationBoundaryService.java
    openwebbeans/branches/cdi-2.0/webbeans-spi/src/main/java/org/apache/webbeans/spi/BeanArchiveService.java
    openwebbeans/branches/cdi-2.0/webbeans-spi/src/main/java/org/apache/webbeans/spi/ScannerService.java

Propchange: openwebbeans/branches/cdi-2.0/
------------------------------------------------------------------------------
--- svn:mergeinfo (original)
+++ svn:mergeinfo Tue Feb  2 17:48:14 2016
@@ -1,2 +1,2 @@
 /openwebbeans/branches/owb_1.2.x:1640945,1641609,1641684
-/openwebbeans/trunk:1681165-1697479
+/openwebbeans/trunk:1681165-1697479,1704602,1704889,1704908,1705018,1710680,1710767,1713935,1716862-1716863,1716866,1716930,1719452-1719453,1719457,1723351,1723685,1723999-1724000,1724539,1724542,1724876,1726303,1726366,1727788,1727792

Modified: openwebbeans/branches/cdi-2.0/webbeans-doc/src/docbkx/userguide/chapter1.xml
URL: http://svn.apache.org/viewvc/openwebbeans/branches/cdi-2.0/webbeans-doc/src/docbkx/userguide/chapter1.xml?rev=1728163&r1=1728162&r2=1728163&view=diff
==============================================================================
--- openwebbeans/branches/cdi-2.0/webbeans-doc/src/docbkx/userguide/chapter1.xml (original)
+++ openwebbeans/branches/cdi-2.0/webbeans-doc/src/docbkx/userguide/chapter1.xml Tue Feb  2 17:48:14 2016
@@ -203,8 +203,8 @@ org.apache.webbeans.spi.JNDIService=org.
     				</listitem>
     				
     				<listitem>
-    					<para><emphasis>org.apache.webbeans.conversation.Conversation.periodicDelay:</emphasis>  Conversation removing thread periodic delay. Unused
-    					conversations are removed by the container periodically.</para>
+    					<para><emphasis>org.apache.webbeans.conversation.Conversation.timeoutInterval:</emphasis>  Conversation removing thread periodic delay. Unused
+    					conversations are removed by the container if they are not touched for this amount of time.</para>
     				</listitem>
     				
     				<listitem>

Modified: openwebbeans/branches/cdi-2.0/webbeans-ee/src/main/java/org/apache/webbeans/ee/event/TransactionalEventNotifier.java
URL: http://svn.apache.org/viewvc/openwebbeans/branches/cdi-2.0/webbeans-ee/src/main/java/org/apache/webbeans/ee/event/TransactionalEventNotifier.java?rev=1728163&r1=1728162&r2=1728163&view=diff
==============================================================================
--- openwebbeans/branches/cdi-2.0/webbeans-ee/src/main/java/org/apache/webbeans/ee/event/TransactionalEventNotifier.java (original)
+++ openwebbeans/branches/cdi-2.0/webbeans-ee/src/main/java/org/apache/webbeans/ee/event/TransactionalEventNotifier.java Tue Feb  2 17:48:14 2016
@@ -21,8 +21,10 @@ package org.apache.webbeans.ee.event;
 import javax.enterprise.event.TransactionPhase;
 import javax.enterprise.inject.spi.EventMetadata;
 import javax.enterprise.inject.spi.ObserverMethod;
+import javax.transaction.RollbackException;
 import javax.transaction.Status;
 import javax.transaction.Synchronization;
+import javax.transaction.SystemException;
 import javax.transaction.Transaction;
 
 import org.apache.webbeans.config.OWBLogConst;
@@ -46,6 +48,22 @@ public final class TransactionalEventNot
 
     /**
      * This will get called by the EJB integration code
+     *
+     * Since registration of the event can blow up if the tx is not active we have a matrix of assumed behaviour
+     *
+     * There are 3 different error cases when registering a TX Synchronization:
+     * RollbackException - Thrown to indicate that the transaction has been marked for rollback only.
+     * IllegalStateException - Thrown if the transaction in the target object is in the prepared state or the transaction is inactive.
+     * SystemException - Thrown if the transaction manager encounters an unexpected error condition.
+     *
+     * In case of the SystemException we simply let it blow up. This is usually the case if there
+     * is some setup problem.
+     *
+     * In case of a RollbackException or IllegalStateException we will perform different actions based on the
+     * desired TransactionPhase:
+     * For AFTER_COMPLETION, BEFORE_COMPLETION and AFTER_FAILURE we will deliver the event immediately.
+     * For AFTER_SUCCESS we copmletely skip the event. It will not get invoked at all because the transaction
+     * will not succeed.
      */
     public static void registerTransactionSynchronization(TransactionPhase phase, ObserverMethod<? super Object> observer, Object event, EventMetadata metadata) throws Exception
     {
@@ -61,19 +79,27 @@ public final class TransactionalEventNot
         {
             if (phase.equals(TransactionPhase.AFTER_COMPLETION))
             {
-                transaction.registerSynchronization(new AfterCompletion(observer, event, metadata));
+                registerEvent(transaction, new AfterCompletion(observer, event, metadata), true);
             }
             else if (phase.equals(TransactionPhase.AFTER_SUCCESS))
             {
-                transaction.registerSynchronization(new AfterCompletionSuccess(observer, event, metadata));
+                if (transaction.getStatus() == Status.STATUS_NO_TRANSACTION)
+                {
+                    // the AFTER_SUCCESS observers only get invoked if the TX succeeds or if there is no transaction
+                    new AfterCompletionSuccess(observer, event, metadata).notifyObserver();
+                }
+                else
+                {
+                    registerEvent(transaction, new AfterCompletionSuccess(observer, event, metadata), false);
+                }
             }
             else if (phase.equals(TransactionPhase.AFTER_FAILURE))
             {
-                transaction.registerSynchronization(new AfterCompletionFailure(observer, event, metadata));
+                registerEvent(transaction, new AfterCompletionFailure(observer, event, metadata), true);
             }
             else if (phase.equals(TransactionPhase.BEFORE_COMPLETION))
             {
-                transaction.registerSynchronization(new BeforeCompletion(observer, event, metadata));
+                registerEvent(transaction, new BeforeCompletion(observer, event, metadata), true);
             }
             else
             {
@@ -92,7 +118,30 @@ public final class TransactionalEventNot
             }
         }
     }
-    
+
+    private static void registerEvent(Transaction transaction, AbstractSynchronization synchronization, boolean immediateOnError)
+        throws SystemException
+    {
+        try
+        {
+            transaction.registerSynchronization(synchronization);
+        }
+        catch (RollbackException re)
+        {
+            if (immediateOnError)
+            {
+                synchronization.notifyObserver();
+            }
+        }
+        catch (IllegalStateException ise)
+        {
+            if (immediateOnError)
+            {
+                synchronization.notifyObserver();
+            }
+        }
+    }
+
     private static class AbstractSynchronization<T> implements Synchronization
     {
 

Modified: openwebbeans/branches/cdi-2.0/webbeans-impl/src/main/java/org/apache/webbeans/component/AbstractOwbBean.java
URL: http://svn.apache.org/viewvc/openwebbeans/branches/cdi-2.0/webbeans-impl/src/main/java/org/apache/webbeans/component/AbstractOwbBean.java?rev=1728163&r1=1728162&r2=1728163&view=diff
==============================================================================
--- openwebbeans/branches/cdi-2.0/webbeans-impl/src/main/java/org/apache/webbeans/component/AbstractOwbBean.java (original)
+++ openwebbeans/branches/cdi-2.0/webbeans-impl/src/main/java/org/apache/webbeans/component/AbstractOwbBean.java Tue Feb  2 17:48:14 2016
@@ -152,14 +152,12 @@ public abstract class AbstractOwbBean<T>
 
     private Throwable getRootException(Throwable throwable)
     {
-        if(throwable.getCause() == null || throwable.getCause() == throwable)
+        Throwable current = throwable;
+        while (current.getCause() != null && current.getCause() != current)
         {
-            return throwable;
-        }
-        else
-        {
-            return getRootException(throwable.getCause());
+            current = current.getCause();
         }
+        return current;
     }
 
     /*

Modified: openwebbeans/branches/cdi-2.0/webbeans-impl/src/main/java/org/apache/webbeans/component/creation/BeanAttributesBuilder.java
URL: http://svn.apache.org/viewvc/openwebbeans/branches/cdi-2.0/webbeans-impl/src/main/java/org/apache/webbeans/component/creation/BeanAttributesBuilder.java?rev=1728163&r1=1728162&r2=1728163&view=diff
==============================================================================
--- openwebbeans/branches/cdi-2.0/webbeans-impl/src/main/java/org/apache/webbeans/component/creation/BeanAttributesBuilder.java (original)
+++ openwebbeans/branches/cdi-2.0/webbeans-impl/src/main/java/org/apache/webbeans/component/creation/BeanAttributesBuilder.java Tue Feb  2 17:48:14 2016
@@ -27,6 +27,7 @@ import java.util.Iterator;
 import java.util.List;
 import java.util.Set;
 
+import javax.decorator.Decorator;
 import javax.enterprise.context.Dependent;
 import javax.enterprise.context.NormalScope;
 import javax.enterprise.inject.Alternative;
@@ -43,6 +44,7 @@ import javax.enterprise.inject.spi.Annot
 import javax.enterprise.util.Nonbinding;
 import javax.inject.Named;
 import javax.inject.Scope;
+import javax.interceptor.Interceptor;
 
 import org.apache.webbeans.annotation.AnnotationManager;
 import org.apache.webbeans.annotation.AnyLiteral;
@@ -106,9 +108,17 @@ public abstract class BeanAttributesBuil
 
     public BeanAttributesImpl<T> build()
     {
-        defineTypes();
+        // we need to check the stereotypes first because we might need it to determine the scope
         defineStereotypes();
+
         defineScope();
+        if (scope == null)
+        {
+            // this indicates that we shall not use this AnnotatedType to create Beans from it.
+            return null;
+        }
+
+        defineTypes();
         defineName();
         defineQualifiers();
         defineNullable();
@@ -281,10 +291,10 @@ public abstract class BeanAttributesBuil
 
     protected void defineScope(String errorMessage)
     {
-        defineScope(null, errorMessage);
+        defineScope(null, false, errorMessage);
     }
 
-    protected void defineScope(Class<?> declaringClass, String errorMessage)
+    protected void defineScope(Class<?> declaringClass, boolean onlyScopedBeans, String errorMessage)
     {
         Annotation[] annotations = AnnotationUtil.asArray(annotated.getAnnotations());
         boolean found = false;
@@ -364,24 +374,20 @@ public abstract class BeanAttributesBuil
 
         if (!found && declaringClass != null && !hasDeclaredNonInheritedScope(declaringClass))
         {
-            defineScope(declaringClass.getSuperclass(), errorMessage);
+            defineScope(declaringClass.getSuperclass(), onlyScopedBeans, errorMessage);
         }
         else if (!found)
         {
-            defineDefaultScope(errorMessage);
+            defineDefaultScope(errorMessage, onlyScopedBeans);
         }
     }
 
-    private void defineDefaultScope(String exceptionMessage)
+    private void defineDefaultScope(String exceptionMessage, boolean onlyScopedBeans)
     {
         if (scope == null)
         {
             Set<Class<? extends Annotation>> stereos = stereotypes;
-            if (stereos.size() == 0)
-            {
-                scope = Dependent.class;
-            }
-            else
+            if (stereos != null && stereos.size() >  0)
             {
                 Annotation defined = null;
                 Set<Class<? extends Annotation>> anns = stereotypes;
@@ -426,6 +432,17 @@ public abstract class BeanAttributesBuil
                     scope = Dependent.class;
                 }
             }
+            if (scope == null &&
+                    (!onlyScopedBeans ||
+                    annotated.getAnnotation(Interceptor.class) != null ||
+                    annotated.getAnnotation(Decorator.class) != null))
+            {
+                // only add a 'default' Dependent scope
+                // * if it's not in a bean-discovery-mode='scoped' module, or
+                // * if it's a Decorator or Interceptor
+                scope = Dependent.class;
+            }
+
         }
     }
 
@@ -558,9 +575,14 @@ public abstract class BeanAttributesBuil
         
         public <T> BeanAttributesBuilder<T, AnnotatedType<T>> newBeanAttibutes(AnnotatedType<T> annotatedType)
         {
-            return new AnnotatedTypeBeanAttributesBuilder<T>(webBeansContext, annotatedType);
+            return newBeanAttibutes(annotatedType, false);
         }
         
+        public <T> BeanAttributesBuilder<T, AnnotatedType<T>> newBeanAttibutes(AnnotatedType<T> annotatedType, boolean onlyScopedBeans)
+        {
+            return new AnnotatedTypeBeanAttributesBuilder<T>(webBeansContext, annotatedType, onlyScopedBeans);
+        }
+
         public <T> BeanAttributesBuilder<T, AnnotatedField<T>> newBeanAttibutes(AnnotatedField<T> annotatedField)
         {
             return new AnnotatedFieldBeanAttributesBuilder<T>(webBeansContext, annotatedField);
@@ -574,16 +596,19 @@ public abstract class BeanAttributesBuil
 
     private static class AnnotatedTypeBeanAttributesBuilder<C> extends BeanAttributesBuilder<C, AnnotatedType<C>>
     {
+        private final boolean onlyScopedBeans;
 
-        public AnnotatedTypeBeanAttributesBuilder(WebBeansContext webBeansContext, AnnotatedType<C> annotated)
+        public AnnotatedTypeBeanAttributesBuilder(WebBeansContext webBeansContext, AnnotatedType<C> annotated, boolean onlyScopedBeans)
         {
             super(webBeansContext, annotated);
+            this.onlyScopedBeans = onlyScopedBeans;
         }
 
         @Override
         protected void defineScope()
         {
-            defineScope(getAnnotated().getJavaClass(), WebBeansLoggerFacade.getTokenString(OWBLogConst.TEXT_MB_IMPL) + getAnnotated().getJavaClass().getName() +
+            defineScope(getAnnotated().getJavaClass(), onlyScopedBeans,
+                    WebBeansLoggerFacade.getTokenString(OWBLogConst.TEXT_MB_IMPL) + getAnnotated().getJavaClass().getName() +
                     WebBeansLoggerFacade.getTokenString(OWBLogConst.TEXT_SAME_SCOPE));
         }
 

Modified: openwebbeans/branches/cdi-2.0/webbeans-impl/src/main/java/org/apache/webbeans/config/BeansDeployer.java
URL: http://svn.apache.org/viewvc/openwebbeans/branches/cdi-2.0/webbeans-impl/src/main/java/org/apache/webbeans/config/BeansDeployer.java?rev=1728163&r1=1728162&r2=1728163&view=diff
==============================================================================
--- openwebbeans/branches/cdi-2.0/webbeans-impl/src/main/java/org/apache/webbeans/config/BeansDeployer.java (original)
+++ openwebbeans/branches/cdi-2.0/webbeans-impl/src/main/java/org/apache/webbeans/config/BeansDeployer.java Tue Feb  2 17:48:14 2016
@@ -70,6 +70,7 @@ import org.apache.webbeans.portable.even
 import org.apache.webbeans.portable.events.discovery.BeforeBeanDiscoveryImpl;
 import org.apache.webbeans.portable.events.generics.GProcessAnnotatedType;
 import org.apache.webbeans.portable.events.generics.GProcessManagedBean;
+import org.apache.webbeans.spi.BdaScannerService;
 import org.apache.webbeans.spi.BeanArchiveService;
 import org.apache.webbeans.spi.JNDIService;
 import org.apache.webbeans.spi.ScannerService;
@@ -82,6 +83,7 @@ import org.apache.webbeans.util.Injectio
 import org.apache.webbeans.util.SpecializationUtil;
 import org.apache.webbeans.util.WebBeansConstants;
 import org.apache.webbeans.util.WebBeansUtil;
+import org.apache.webbeans.xml.DefaultBeanArchiveInformation;
 
 import javax.enterprise.inject.AmbiguousResolutionException;
 import javax.enterprise.inject.Model;
@@ -121,6 +123,8 @@ import java.util.logging.Level;
 import java.util.logging.Logger;
 
 import static java.util.Arrays.asList;
+import static org.apache.webbeans.spi.BeanArchiveService.BeanDiscoveryMode;
+import static org.apache.webbeans.spi.BeanArchiveService.BeanArchiveInformation;
 
 /**
  * Deploys the all beans that are defined in the {@link org.apache.webbeans.spi.ScannerService} at
@@ -165,6 +169,12 @@ public class BeansDeployer
     private final Map<String, Boolean> packageVetoCache = new HashMap<String, Boolean>();
 
     /**
+     * This BdaInfo is used for all manually added annotated types or in case
+     * a non-Bda-aware ScannerService got configured.
+     */
+    private final DefaultBeanArchiveInformation defaultBeanArchiveInformation;
+
+    /**
      * Creates a new deployer with given xml configurator.
      * 
      * @param webBeansContext
@@ -179,6 +189,9 @@ public class BeansDeployer
 
         String usage = this.webBeansContext.getOpenWebBeansConfiguration().getProperty(OpenWebBeansConfiguration.USE_EJB_DISCOVERY);
         discoverEjb = Boolean.parseBoolean(usage);
+
+        defaultBeanArchiveInformation = new DefaultBeanArchiveInformation();
+        defaultBeanArchiveInformation.setBeanDiscoveryMode(BeanDiscoveryMode.ALL);
     }
 
     /**
@@ -224,44 +237,58 @@ public class BeansDeployer
                 //Configure Default Beans
                 configureDefaultBeans();
 
-                List<AnnotatedType<?>> annotatedTypes = annotatedTypesFromClassPath(scanner);
+                Map<BeanArchiveInformation, List<AnnotatedType<?>>> annotatedTypesPerBda = annotatedTypesFromClassPath(scanner);
 
-                //Deploy additional Annotated Types
-                addAdditionalAnnotatedTypes(webBeansContext.getBeanManagerImpl().getAdditionalAnnotatedTypes(), annotatedTypes);
+                List<AnnotatedType<?>> globalBdaAnnotatedTypes = annotatedTypesPerBda.get(defaultBeanArchiveInformation);
 
-                registerAlternativesDecoratorsAndInterceptorsWithPriority(annotatedTypes);
+                // Deploy additional Annotated Types which got added via BeforeBeanDiscovery#addAnnotatedType
+                addAdditionalAnnotatedTypes(webBeansContext.getBeanManagerImpl().getAdditionalAnnotatedTypes(), globalBdaAnnotatedTypes);
 
-                addAdditionalAnnotatedTypes(fireAfterTypeDiscoveryEvent(), annotatedTypes);
+                registerAlternativesDecoratorsAndInterceptorsWithPriority(globalBdaAnnotatedTypes);
+
+                addAdditionalAnnotatedTypes(fireAfterTypeDiscoveryEvent(), globalBdaAnnotatedTypes);
+
+                // Also configures deployments, interceptors, decorators.
+                deployFromXML(scanner);
 
                 SpecializationUtil specializationUtil = new SpecializationUtil(webBeansContext);
+                specializationUtil.removeDisabledTypes(annotatedTypesPerBda, null, true);
 
-                specializationUtil.removeDisabledTypes(annotatedTypes, null, true);
+                final Map<BeanArchiveInformation, Map<AnnotatedType<?>, ExtendedBeanAttributes<?>>> beanAttributesPerBda
+                    = getBeanAttributes(annotatedTypesPerBda);
 
-                final Map<AnnotatedType<?>, AnnotatedTypeData<?>> annotatedTypePreProcessing = getBeanAttributes(annotatedTypes);
-                annotatedTypes.clear(); // shouldn't be used anymore, view is now annotatedTypePreProcessing
+                // shouldn't be used anymore, view is now beanAttributes
+                annotatedTypesPerBda.clear();
 
-                //Deploy bean from XML. Also configures deployments, interceptors, decorators.
-                deployFromXML(scanner, annotatedTypePreProcessing);
 
                 //Checking stereotype conditions
                 checkStereoTypes(scanner);
 
                 // Handle Specialization
                 specializationUtil.removeDisabledTypes(
-                        annotatedTypePreProcessing.keySet(),
+                        annotatedTypesPerBda,
                         new SpecializationUtil.BeanAttributesProvider()
                         {
                             @Override
                             public <T> BeanAttributes get(final AnnotatedType<T> at)
                             {
-                                final AnnotatedTypeData<?> data = annotatedTypePreProcessing.get(at);
+                                ExtendedBeanAttributes<?> data = null;
+                                for (Map<AnnotatedType<?>, ExtendedBeanAttributes<?>> beanAttributes : beanAttributesPerBda.values())
+                                {
+                                    data = beanAttributes.get(at);
+                                    if (data != null)
+                                    {
+                                        break;
+                                    }
+
+                                }
                                 return data == null ? null : data.beanAttributes;
                             }
                         },
                         false);
 
                 // create beans from the discovered AnnotatedTypes
-                deployFromAnnotatedTypes(annotatedTypePreProcessing);
+                deployFromBeanAttributes(beanAttributesPerBda);
 
                 //X TODO configure specialized producer beans.
                 webBeansContext.getWebBeansUtil().configureProducerMethodSpecializations();
@@ -320,37 +347,56 @@ public class BeansDeployer
         }
     }
 
-    private Map<AnnotatedType<?>, AnnotatedTypeData<?>> getBeanAttributes(final List<AnnotatedType<?>> annotatedTypes)
+    private Map<BeanArchiveInformation, Map<AnnotatedType<?>, ExtendedBeanAttributes<?>>> getBeanAttributes(
+                                final Map<BeanArchiveInformation, List<AnnotatedType<?>>> annotatedTypesPerBda)
     {
-        final Map<AnnotatedType<?>, AnnotatedTypeData<?>> result = new IdentityHashMap<AnnotatedType<?>, AnnotatedTypeData<?>>(annotatedTypes.size());
-        final Iterator<AnnotatedType<?>> iterator = annotatedTypes.iterator();
-        while (iterator.hasNext())
-        {
-            final AnnotatedType<?> at = iterator.next();
-            final Class beanClass = at.getJavaClass();
-            final boolean isEjb = discoverEjb && EJBWebBeansConfigurator.isSessionBean(beanClass, webBeansContext);
-            try
+        final Map<BeanArchiveInformation, Map<AnnotatedType<?>, ExtendedBeanAttributes<?>>> beanAttributesPerBda
+            = new HashMap<BeanArchiveInformation, Map<AnnotatedType<?>, ExtendedBeanAttributes<?>>>();
+
+        for (Map.Entry<BeanArchiveInformation, List<AnnotatedType<?>>> atEntry : annotatedTypesPerBda.entrySet())
+        {
+            BeanArchiveInformation bdaInfo = atEntry.getKey();
+            List<AnnotatedType<?>> annotatedTypes = atEntry.getValue();
+
+            boolean onlyScopedBeans = BeanDiscoveryMode.SCOPED.equals(bdaInfo.getBeanDiscoveryMode());
+
+            final Map<AnnotatedType<?>, ExtendedBeanAttributes<?>> bdaBeanAttributes = new IdentityHashMap<AnnotatedType<?>, ExtendedBeanAttributes<?>>(annotatedTypes.size());
+            final Iterator<AnnotatedType<?>> iterator = annotatedTypes.iterator();
+            while (iterator.hasNext())
             {
-                if(isEjb || (ClassUtil.isConcrete(beanClass) || WebBeansUtil.isDecorator(at)) && isValidManagedBean(at))
+                final AnnotatedType<?> at = iterator.next();
+                final Class beanClass = at.getJavaClass();
+                final boolean isEjb = discoverEjb && EJBWebBeansConfigurator.isSessionBean(beanClass, webBeansContext);
+                try
                 {
-                    final BeanAttributesImpl tBeanAttributes = BeanAttributesBuilder.forContext(webBeansContext).newBeanAttibutes(at).build();
-                    final BeanAttributes<?> beanAttributes = webBeansContext.getWebBeansUtil().fireProcessBeanAttributes(at, at.getJavaClass(), tBeanAttributes);
-                    if (beanAttributes != null)
+                    if (isEjb || (ClassUtil.isConcrete(beanClass) || WebBeansUtil.isDecorator(at)) && isValidManagedBean(at))
                     {
-                        result.put(at, new AnnotatedTypeData(beanAttributes, isEjb));
+                        final BeanAttributesImpl tBeanAttributes = BeanAttributesBuilder.forContext(webBeansContext).newBeanAttibutes(at, onlyScopedBeans).build();
+                        if (tBeanAttributes != null)
+                        {
+                            final BeanAttributes<?> beanAttributes = webBeansContext.getWebBeansUtil().fireProcessBeanAttributes(at, at.getJavaClass(), tBeanAttributes);
+                            if (beanAttributes != null)
+                            {
+                                bdaBeanAttributes.put(at, new ExtendedBeanAttributes(beanAttributes, isEjb));
+                            }
+                        }
+                    }
+                    else
+                    {
+                        iterator.remove();
                     }
                 }
-                else
+                catch (final NoClassDefFoundError ncdfe)
                 {
-                    iterator.remove();
+                    logger.info("Skipping deployment of Class " + beanClass + "due to a NoClassDefFoundError: " + ncdfe.getMessage());
                 }
             }
-            catch (final NoClassDefFoundError ncdfe)
-            {
-                logger.info("Skipping deployment of Class " + beanClass + "due to a NoClassDefFoundError: " + ncdfe.getMessage());
-            }
+
+            beanAttributesPerBda.put(bdaInfo, bdaBeanAttributes);
         }
-        return result;
+
+
+        return beanAttributesPerBda;
     }
 
     private void validateDisposeParameters()
@@ -487,7 +533,6 @@ public class BeansDeployer
                 {
                     final Class<?> javaClass = annotatedType.getJavaClass();
                     interceptorsManager.addPriorityClazzInterceptor(javaClass, priority);
-                    // interceptorsManager.addEnabledInterceptorClass(javaClass);
                 }
             }
             if (annotatedType.getAnnotation(javax.decorator.Decorator.class) != null)
@@ -497,7 +542,6 @@ public class BeansDeployer
                 {
                     final Class<?> javaClass = annotatedType.getJavaClass();
                     decoratorsManager.addPriorityClazzDecorator(javaClass, priority);
-                    // decoratorsManager.addEnabledDecorator(javaClass);
                 }
             }
         }
@@ -880,13 +924,44 @@ public class BeansDeployer
     /**
      * Create AnnotatedTypes from the ClassPath via the ScannerService
      */
-    private List<AnnotatedType<?>> annotatedTypesFromClassPath(ScannerService scanner)
+    private Map<BeanArchiveInformation, List<AnnotatedType<?>>> annotatedTypesFromClassPath(ScannerService scanner)
     {
         logger.fine("Creating AnnotatedTypes from class files has started.");
 
-        // Start from the class
-        Set<Class<?>> classIndex = scanner.getBeanClasses();
+        Map<BeanArchiveInformation, List<AnnotatedType<?>>> annotatedTypesPerBda
+            = new HashMap<BeanArchiveInformation, List<AnnotatedType<?>>>();
+
+        if (scanner instanceof BdaScannerService)
+        {
+            Map<BeanArchiveInformation, Set<Class<?>>> beanClassesPerBda = ((BdaScannerService) scanner).getBeanClassesPerBda();
+
+            for (Map.Entry<BeanArchiveInformation, Set<Class<?>>> bdaEntry : beanClassesPerBda.entrySet())
+            {
+                BeanArchiveInformation bdaInfo = bdaEntry.getKey();
+                List<AnnotatedType<?>> annotatedTypes = annotatedTypesFromBdaClassPath(bdaEntry.getValue());
+                annotatedTypesPerBda.put(bdaEntry.getKey(), annotatedTypes);
+            }
+
+            // also add the rest of the class es to the default bda
+            // we also need this initialised in case annotatedTypes get added manually at a later step
+            annotatedTypesPerBda.put(defaultBeanArchiveInformation, annotatedTypesFromBdaClassPath(scanner.getBeanClasses()));
+        }
+        else
+        {
+            // this path is only for backward compat to older ScannerService implementations
+
+            Set<Class<?>> classIndex = scanner.getBeanClasses();
+            List<AnnotatedType<?>> annotatedTypes = annotatedTypesFromBdaClassPath(classIndex);
+
+            annotatedTypesPerBda.put(defaultBeanArchiveInformation, annotatedTypes);
+        }
+
+
+        return annotatedTypesPerBda;
+    }
 
+    private List<AnnotatedType<?>> annotatedTypesFromBdaClassPath(Set<Class<?>> classIndex)
+    {
         List<AnnotatedType<?>> annotatedTypes = new ArrayList<AnnotatedType<?>>();
 
         //Iterating over each class
@@ -1055,30 +1130,34 @@ public class BeansDeployer
     /**
      * Discovers and deploys classes from class path.
      * 
-     * @param annotatedTypes the AnnotatedTypes which got discovered so far and are not vetoed
+     * @param beanAttributesPerBda the AnnotatedTypes which got discovered so far and are not vetoed
      * @throws ClassNotFoundException if class not found
      */
-    protected void deployFromAnnotatedTypes(Map<AnnotatedType<?>, AnnotatedTypeData<?>> annotatedTypes)
+    protected void deployFromBeanAttributes( Map<BeanArchiveInformation, Map<AnnotatedType<?>, ExtendedBeanAttributes<?>>> beanAttributesPerBda)
     {
         logger.fine("Deploying configurations from class files has started.");
 
-        // Start from the class
-        for(Map.Entry<AnnotatedType<?>, AnnotatedTypeData<?>> annotatedType : annotatedTypes.entrySet())
+        for (Map<AnnotatedType<?>, ExtendedBeanAttributes<?>> beanAttributesMap : beanAttributesPerBda.values())
         {
-            try
-            {
-                deploySingleAnnotatedType(annotatedType.getKey(), annotatedType.getValue(), annotatedTypes);
-            }
-            catch (NoClassDefFoundError ncdfe)
+
+            // Start from the class
+            for (Map.Entry<AnnotatedType<?>, ExtendedBeanAttributes<?>> annotatedType : beanAttributesMap.entrySet())
             {
-                logger.info("Skipping deployment of Class " + annotatedType.getKey().getJavaClass() + "due to a NoClassDefFoundError: " + ncdfe.getMessage());
-            }
+                try
+                {
+                    deploySingleAnnotatedType(annotatedType.getKey(), annotatedType.getValue(), beanAttributesMap);
+                }
+                catch (NoClassDefFoundError ncdfe)
+                {
+                    logger.info("Skipping deployment of Class " + annotatedType.getKey().getJavaClass() + "due to a NoClassDefFoundError: " + ncdfe.getMessage());
+                }
 
-            // if the implClass already gets processed as part of the
-            // standard BDA scanning, then we don't need to 'additionally'
-            // deploy it anymore.
-            webBeansContext.getBeanManagerImpl().removeAdditionalAnnotatedType(annotatedType.getKey());
+                // if the implClass already gets processed as part of the
+                // standard BDA scanning, then we don't need to 'additionally'
+                // deploy it anymore.
+                webBeansContext.getBeanManagerImpl().removeAdditionalAnnotatedType(annotatedType.getKey());
 
+            }
         }
 
         logger.fine("Deploying configurations from class files has ended.");
@@ -1092,7 +1171,7 @@ public class BeansDeployer
      * 
      * @param annotatedTypeData the AnnotatedType representing the bean to be deployed with their already computed data
      */
-    private void deploySingleAnnotatedType(AnnotatedType annotatedType, AnnotatedTypeData annotatedTypeData, Map<AnnotatedType<?>, AnnotatedTypeData<?>> annotatedTypes)
+    private void deploySingleAnnotatedType(AnnotatedType annotatedType, ExtendedBeanAttributes annotatedTypeData, Map<AnnotatedType<?>, ExtendedBeanAttributes<?>> annotatedTypes)
     {
 
         Class beanClass = annotatedType.getJavaClass();
@@ -1160,7 +1239,8 @@ public class BeansDeployer
      *
      * @throws WebBeansDeploymentException if a problem occurs
      */
-    protected void deployFromXML(ScannerService scanner, Map<AnnotatedType<?>, AnnotatedTypeData<?>> preProcessing) throws WebBeansDeploymentException
+    protected void deployFromXML(ScannerService scanner)
+        throws WebBeansDeploymentException
     {
         logger.fine("Deploying configurations from XML files has started.");
 
@@ -1173,19 +1253,23 @@ public class BeansDeployer
 
             logger.fine("OpenWebBeans BeansDeployer configuring: " + url.toExternalForm());
 
-            BeanArchiveService.BeanArchiveInformation beanArchiveInformation = beanArchiveService.getBeanArchiveInformation(url);
+            BeanArchiveInformation beanArchiveInformation = beanArchiveService.getBeanArchiveInformation(url);
 
             configureDecorators(url, beanArchiveInformation.getDecorators());
             configureInterceptors(url, beanArchiveInformation.getInterceptors());
-            configureAlternatives(url, beanArchiveInformation.getAlternativeClasses(), false, preProcessing);
-            configureAlternatives(url, beanArchiveInformation.getAlternativeStereotypes(), true, preProcessing);
+            configureAlternatives(url, beanArchiveInformation.getAlternativeClasses(), false);
+            configureAlternatives(url, beanArchiveInformation.getAlternativeStereotypes(), true);
+            configureAllowProxying(url, beanArchiveInformation.getAllowProxyingClasses());
         }
 
         logger.fine("Deploying configurations from XML has ended successfully.");
     }
 
-    private void configureAlternatives(URL bdaLocation, List<String> alternatives, boolean isStereotype, Map<AnnotatedType<?>, AnnotatedTypeData<?>> preProcessing)
+    private void configureAlternatives(URL bdaLocation, List<String> alternatives, boolean isStereotype)
     {
+        AlternativesManager manager = webBeansContext.getAlternativesManager();
+        AnnotatedElementFactory annotatedElementFactory = webBeansContext.getAnnotatedElementFactory();
+
         // the alternatives in this beans.xml
         // this gets used to detect multiple definitions of the
         // same alternative in one beans.xml file.
@@ -1208,7 +1292,6 @@ public class BeansDeployer
             }
             else
             {
-                AlternativesManager manager = webBeansContext.getAlternativesManager();
                 if (isStereotype)
                 {
                     manager.addXmlStereoTypeAlternative(clazz);
@@ -1222,17 +1305,17 @@ public class BeansDeployer
                     }
                     else
                     {
-                        AnnotatedType annotatedType = webBeansContext.getAnnotatedElementFactory().getAnnotatedType(clazz);
+                        AnnotatedType annotatedType = annotatedElementFactory.getAnnotatedType(clazz);
                         if (annotatedType != null)
                         {
-                            AnnotatedTypeData data = preProcessing.get(annotatedType);
-                            if (data != null && data.beanAttributes.isAlternative())
+                            if (annotatedType.getAnnotation(Alternative.class) != null)
                             {
                                 manager.addXmlClazzAlternative(clazz);
+                                break;
                             }
                             else
                             {
-                                throw new WebBeansDeploymentException("Given alternative class : " + clazz.getName() + " is not decorated wih @Alternative" );
+                                throw new WebBeansDeploymentException("Given alternative class : " + clazz.getName() + " is not decorated wih @Alternative");
                             }
                         }
                     }
@@ -1345,6 +1428,15 @@ public class BeansDeployer
         }
     }
 
+    private void configureAllowProxying(URL url, List<String> allowProxyingClasses)
+    {
+        OpenWebBeansConfiguration owbConfiguration = webBeansContext.getOpenWebBeansConfiguration();
+        for (String allowProxyingClass : allowProxyingClasses)
+        {
+            owbConfiguration.addConfigListValue(OpenWebBeansConfiguration.ALLOW_PROXYING_PARAM, allowProxyingClass);
+        }
+    }
+
 
     /**
      * Gets error message for XML parsing of the current XML file.
@@ -1440,7 +1532,7 @@ public class BeansDeployer
      * Defines and configures managed bean.
      * @param <T> type info
      */
-    protected <T> void defineManagedBean(AnnotatedType<T> annotatedType, BeanAttributes<T> attributes, Map<AnnotatedType<?>, AnnotatedTypeData<?>> annotatedTypes)
+    protected <T> void defineManagedBean(AnnotatedType<T> annotatedType, BeanAttributes<T> attributes, Map<AnnotatedType<?>, ExtendedBeanAttributes<?>> annotatedTypes)
     {   
         //Fires ProcessInjectionTarget event for Java EE components instances
         //That supports injections but not managed beans
@@ -1625,12 +1717,12 @@ public class BeansDeployer
         webBeansContext.getWebBeansUtil().setInjectionTargetBeanEnableFlag(bean);
     }
 
-    private static class AnnotatedTypeData<T>
+    private static class ExtendedBeanAttributes<T>
     {
         private final BeanAttributes<T> beanAttributes;
         private final boolean isEjb;
 
-        public AnnotatedTypeData(final BeanAttributes<T> beanAttributes, final boolean isEjb)
+        public ExtendedBeanAttributes(final BeanAttributes<T> beanAttributes, final boolean isEjb)
         {
             this.beanAttributes = beanAttributes;
             this.isEjb = isEjb;

Modified: openwebbeans/branches/cdi-2.0/webbeans-impl/src/main/java/org/apache/webbeans/config/DeploymentValidationService.java
URL: http://svn.apache.org/viewvc/openwebbeans/branches/cdi-2.0/webbeans-impl/src/main/java/org/apache/webbeans/config/DeploymentValidationService.java?rev=1728163&r1=1728162&r2=1728163&view=diff
==============================================================================
--- openwebbeans/branches/cdi-2.0/webbeans-impl/src/main/java/org/apache/webbeans/config/DeploymentValidationService.java (original)
+++ openwebbeans/branches/cdi-2.0/webbeans-impl/src/main/java/org/apache/webbeans/config/DeploymentValidationService.java Tue Feb  2 17:48:14 2016
@@ -25,6 +25,7 @@ import java.lang.reflect.Constructor;
 import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
 import java.util.Set;
+import java.util.logging.Logger;
 
 import javax.enterprise.inject.Disposes;
 import javax.enterprise.inject.TransientReference;
@@ -42,14 +43,23 @@ import org.apache.webbeans.component.Pro
 import org.apache.webbeans.exception.WebBeansDeploymentException;
 import org.apache.webbeans.exception.helper.ViolationMessageBuilder;
 import org.apache.webbeans.intercept.InterceptorResolutionService.BeanInterceptorInfo;
+import org.apache.webbeans.logger.WebBeansLoggerFacade;
 import org.apache.webbeans.portable.InjectionTargetImpl;
 import org.apache.webbeans.util.SecurityUtil;
 
 public class DeploymentValidationService
 {
+    /**Logger instance*/
+    private static final Logger logger = WebBeansLoggerFacade.getLogger(DeploymentValidationService.class);
 
     private WebBeansContext webBeansContext;
 
+    /**
+     * Classes which are allowed to be proxies despite having a non-private, non-static final method
+     */
+    private Set<String> allowProxyingClasses = null;
+
+
     public DeploymentValidationService(WebBeansContext webBeansContext)
     {
         this.webBeansContext = webBeansContext;
@@ -62,13 +72,19 @@ public class DeploymentValidationService
      */
     public UnproxyableResolutionException validateProxyable(OwbBean<?> bean)
     {
+        if (allowProxyingClasses == null)
+        {
+            allowProxyingClasses = webBeansContext.getOpenWebBeansConfiguration().getConfigListValues(OpenWebBeansConfiguration.ALLOW_PROXYING_PARAM);
+        }
+
         // Unproxyable test for NormalScoped beans
         if (webBeansContext.getBeanManagerImpl().isNormalScope(bean.getScope()))
         {
             ViolationMessageBuilder violationMessage = ViolationMessageBuilder.newViolation();
 
             Class<?> beanClass = bean.getReturnType();
-            
+
+
             if(!beanClass.isInterface() && beanClass != Object.class)
             {
                 if(beanClass.isPrimitive())
@@ -91,7 +107,16 @@ public class DeploymentValidationService
                     String finalMethodName = hasNonPrivateFinalMethod(beanClass);
                     if (finalMethodName != null)
                     {
-                        violationMessage.addLine(beanClass.getName(), " has final method "+ finalMethodName + " CDI doesn't allow to proxy that.");
+                        if (allowProxyingClasses.contains(beanClass.getName()))
+                        {
+                            logger.info(beanClass.getName() +  " has final method " + finalMethodName + ". CDI doesn't allow to proxy that." +
+                                " Continuing because the class is explicitly configured to be treated as proxyable." +
+                                " Final methods shall not get invoked on this proxy!");
+                        }
+                        else
+                        {
+                            violationMessage.addLine(beanClass.getName(), " has final method " + finalMethodName + " CDI doesn't allow to proxy that.");
+                        }
                     }
 
 

Modified: openwebbeans/branches/cdi-2.0/webbeans-impl/src/main/java/org/apache/webbeans/config/OpenWebBeansConfiguration.java
URL: http://svn.apache.org/viewvc/openwebbeans/branches/cdi-2.0/webbeans-impl/src/main/java/org/apache/webbeans/config/OpenWebBeansConfiguration.java?rev=1728163&r1=1728162&r2=1728163&view=diff
==============================================================================
--- openwebbeans/branches/cdi-2.0/webbeans-impl/src/main/java/org/apache/webbeans/config/OpenWebBeansConfiguration.java (original)
+++ openwebbeans/branches/cdi-2.0/webbeans-impl/src/main/java/org/apache/webbeans/config/OpenWebBeansConfiguration.java Tue Feb  2 17:48:14 2016
@@ -18,14 +18,19 @@
  */
 package org.apache.webbeans.config;
 
+import java.io.IOException;
 import java.security.AccessController;
 import java.security.PrivilegedAction;
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
+import java.util.HashMap;
 import java.util.HashSet;
+import java.util.List;
 import java.util.Map;
 import java.util.Properties;
 import java.util.Set;
+import java.util.logging.Level;
 import java.util.logging.Logger;
 
 import org.apache.webbeans.exception.WebBeansConfigurationException;
@@ -33,7 +38,7 @@ import org.apache.webbeans.logger.WebBea
 
 /**
  * Defines configuration for OpenWebBeans.
- *
+ * 
  * The algorithm is easy:
  * <ul>
  * <li>Load all properties you can find with the name (META-INF/openwebbeans/openwebbeans.properties),</li>
@@ -49,13 +54,22 @@ public class OpenWebBeansConfiguration
     /**Logger instance*/
     private static final Logger logger = WebBeansLoggerFacade.getLogger(OpenWebBeansConfiguration.class);
 
-    /**Conversation periodic delay in ms.*/
+    /**
+     * Conversation periodic delay in ms. This is not used by OWB out of the box.
+     * Some Containers might implement it though.
+     */
     public static final String CONVERSATION_PERIODIC_DELAY = "org.apache.webbeans.conversation.Conversation.periodicDelay";
-
+    
     /**Timeout interval in ms*/
     public static final String CONVERSATION_TIMEOUT_INTERVAL = "org.apache.webbeans.conversation.Conversation.timeoutInterval";
 
     /**
+     * Environment property which comma separated list of classes which
+     * should NOT fail with UnproxyableResolutionException
+     */
+    public static final String ALLOW_PROXYING_PARAM = "javax.enterprise.inject.allowProxying.classes";
+
+    /**
      * Lifycycle methods like {@link javax.annotation.PostConstruct} and
      * {@link javax.annotation.PreDestroy} must not define a checked Exception
      * regarding to the spec. But this is often unnecessary restrictive so we
@@ -65,34 +79,34 @@ public class OpenWebBeansConfiguration
 
     /**Use EJB Discovery or not*/
     public static final String USE_EJB_DISCOVERY = "org.apache.webbeans.spi.deployer.useEjbMetaDataDiscoveryService";
-
+    
     /**Container lifecycle*/
     public static final String CONTAINER_LIFECYCLE = "org.apache.webbeans.spi.ContainerLifecycle";
-
+    
     /**JNDI Service SPI*/
-    public static final String JNDI_SERVICE = "org.apache.webbeans.spi.JNDIService";
-
+    public static final String JNDI_SERVICE = "org.apache.webbeans.spi.JNDIService";    
+    
     /**Scanner Service*/
     public static final String SCANNER_SERVICE = "org.apache.webbeans.spi.ScannerService";
 
     /**Contexts Service*/
     public static final String CONTEXTS_SERVICE = "org.apache.webbeans.spi.ContextsService";
-
+    
     /**Conversation Service*/
     public static final String CONVERSATION_SERVICE = "org.apache.webbeans.spi.ConversationService";
-
+    
     /**Resource Injection Service*/
     public static final String RESOURCE_INJECTION_SERVICE = "org.apache.webbeans.spi.ResourceInjectionService";
-
+    
     /**Security Service*/
     public static final String SECURITY_SERVICE = "org.apache.webbeans.spi.SecurityService";
-
+    
     /**Validator Service*/
     public static final String VALIDATOR_SERVICE = "org.apache.webbeans.spi.ValidatorService";
-
+    
     /**Transaction Service*/
     public static final String TRANSACTION_SERVICE = "org.apache.webbeans.spi.TransactionService";
-
+    
     /**Application is core JSP*/
     public static final String APPLICATION_IS_JSP = "org.apache.webbeans.application.jsp";
 
@@ -162,6 +176,23 @@ public class OpenWebBeansConfiguration
     private Set<String> ignoredInterfaces;
 
     /**
+     * All configured lists per key.
+     *
+     * For a single key the following configuration sources will get parsed:
+     * <ul>
+     *     <li>all {@link #DEFAULT_CONFIG_PROPERTIES_NAME} files</li>
+     *     <li>{@code System.getProperties()}</li>
+     *     <li>{@code System.env()}</li>
+     * </ul>
+     *
+     * All the found values will get split by comma (',') and all trimmed values
+     * will get stored in a Set.
+     *
+     */
+    private Map<String, Set<String>> configuredLists = new HashMap<String, Set<String>>();
+
+
+    /**
      * you can configure this externally as well.
      *
      * @param properties
@@ -183,6 +214,7 @@ public class OpenWebBeansConfiguration
     }
 
 
+
     /**
      * (re)read the configuration from the resources in the classpath.
      * @see #DEFAULT_CONFIG_PROPERTIES_NAME
@@ -204,6 +236,27 @@ public class OpenWebBeansConfiguration
 
     }
 
+    /**
+     * Take the given commaSeparatedVals and spit them by ',' and trim them.
+     * @return all trimmed values or an empty list
+     */
+    public List<String> splitValues(String commaSeparatedVals)
+    {
+        ArrayList<String> values = new ArrayList<String>();
+        if (commaSeparatedVals != null)
+        {
+            for (String value : commaSeparatedVals.split(","))
+            {
+                value = value.trim();
+                if (!value.isEmpty())
+                {
+                    values.add(value);
+                }
+            }
+        }
+        return values;
+    }
+
     private void overrideWithGlobalSettings(Properties configProperties)
     {
         logger.fine("Overriding properties from System and Env properties");
@@ -257,7 +310,7 @@ public class OpenWebBeansConfiguration
     {
         return configProperties.getProperty(key);
     }
-
+    
     /**
      * Gets property value.
      * @param key
@@ -268,8 +321,8 @@ public class OpenWebBeansConfiguration
     {
         return configProperties.getProperty(key, defaultValue);
     }
-
-
+    
+    
     /**
      * Sets given property.
      * @param key property name
@@ -279,7 +332,7 @@ public class OpenWebBeansConfiguration
     {
         configProperties.put(key, value);
     }
-
+    
 
     /**
      * Gets jsp property.
@@ -288,10 +341,10 @@ public class OpenWebBeansConfiguration
     public boolean isJspApplication()
     {
         String value = getProperty(APPLICATION_IS_JSP);
-
+        
         return Boolean.valueOf(value);
     }
-
+    
     /**
      * Gets conversation supports property.
      * @return true if supports
@@ -299,7 +352,7 @@ public class OpenWebBeansConfiguration
     public boolean supportsConversation()
     {
         String value = getProperty(APPLICATION_SUPPORTS_CONVERSATION);
-
+        
         return Boolean.valueOf(value);
     }
 
@@ -320,6 +373,68 @@ public class OpenWebBeansConfiguration
         return ignoredInterfaces;
     }
 
+    /**
+     * Scan all openwebbeans.properties files + system properties +
+     * syste.env for the given key.
+     * If the key is comma separated then use the separate tokens.
+     * All the values get put into a big set.
+     */
+    public synchronized Set<String> getConfigListValues(String keyName)
+    {
+        Set<String> allValues = configuredLists.get(keyName);
+        if (allValues != null)
+        {
+            return allValues;
+        }
+
+        allValues = new HashSet<String>();
+        try
+        {
+            List<Properties> properties = PropertyLoader.loadAllProperties(DEFAULT_CONFIG_PROPERTIES_NAME);
+            if (properties != null)
+            {
+                for (Properties property : properties)
+                {
+                    String values = (String) property.get(keyName);
+                    allValues.addAll(splitValues(values));
+                }
+            }
+        }
+        catch (IOException e)
+        {
+            logger.log(Level.SEVERE, "Error while loading the propertyFile " + DEFAULT_CONFIG_PROPERTIES_NAME, e);
+            return Collections.EMPTY_SET;
+        }
+
+        // search for the key in the properties
+        String value = System.getProperty(keyName);
+        allValues.addAll(splitValues(value));
+
+        // search for the key in the environment
+        String envKeyName = keyName.toUpperCase().replace(".", "_");
+        value = System.getenv(envKeyName);
+        allValues.addAll(splitValues(value));
+
+        configuredLists.put(keyName, allValues);
+
+        return allValues;
+    }
+
+    /**
+     * Add a configuration value to the Set of configured values registered
+     * under the keyName.
+     *
+     * Calling this method ensures that all the configured values are first
+     * read from the environment and configuration properties.
+     *
+     * @see #getConfigListValues(String) get's called internally to insure the list is initialised
+     */
+    public synchronized void addConfigListValue(String keyName, String value)
+    {
+        Set<String> configListValues = getConfigListValues(keyName);
+        configListValues.add(value);
+    }
+
     public boolean supportsInterceptionOnProducers()
     {
         return "true".equals(getProperty(PRODUCER_INTERCEPTION_SUPPORT, "true"));

Modified: openwebbeans/branches/cdi-2.0/webbeans-impl/src/main/java/org/apache/webbeans/config/PropertyLoader.java
URL: http://svn.apache.org/viewvc/openwebbeans/branches/cdi-2.0/webbeans-impl/src/main/java/org/apache/webbeans/config/PropertyLoader.java?rev=1728163&r1=1728162&r2=1728163&view=diff
==============================================================================
--- openwebbeans/branches/cdi-2.0/webbeans-impl/src/main/java/org/apache/webbeans/config/PropertyLoader.java (original)
+++ openwebbeans/branches/cdi-2.0/webbeans-impl/src/main/java/org/apache/webbeans/config/PropertyLoader.java Tue Feb  2 17:48:14 2016
@@ -95,7 +95,7 @@ public final class PropertyLoader
         }
     }
 
-    private static List<Properties> loadAllProperties(String propertyFileName)
+    public static List<Properties> loadAllProperties(String propertyFileName)
             throws IOException
     {
         ClassLoader cl = WebBeansUtil.getCurrentClassLoader();

Modified: openwebbeans/branches/cdi-2.0/webbeans-impl/src/main/java/org/apache/webbeans/config/WebBeansContext.java
URL: http://svn.apache.org/viewvc/openwebbeans/branches/cdi-2.0/webbeans-impl/src/main/java/org/apache/webbeans/config/WebBeansContext.java?rev=1728163&r1=1728162&r2=1728163&view=diff
==============================================================================
--- openwebbeans/branches/cdi-2.0/webbeans-impl/src/main/java/org/apache/webbeans/config/WebBeansContext.java (original)
+++ openwebbeans/branches/cdi-2.0/webbeans-impl/src/main/java/org/apache/webbeans/config/WebBeansContext.java Tue Feb  2 17:48:14 2016
@@ -18,12 +18,17 @@
  */
 package org.apache.webbeans.config;
 
+import java.io.Closeable;
+import java.io.IOException;
 import java.lang.reflect.Constructor;
 import java.lang.reflect.InvocationTargetException;
+import java.util.Collection;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Properties;
+import java.util.logging.Level;
+import java.util.logging.Logger;
 
 import org.apache.webbeans.annotation.AnnotationManager;
 import org.apache.webbeans.container.BeanManagerImpl;
@@ -38,6 +43,7 @@ import org.apache.webbeans.inject.impl.I
 import org.apache.webbeans.intercept.InterceptorResolutionService;
 import org.apache.webbeans.intercept.InterceptorUtil;
 import org.apache.webbeans.intercept.InterceptorsManager;
+import org.apache.webbeans.logger.WebBeansLoggerFacade;
 import org.apache.webbeans.plugins.PluginLoader;
 import org.apache.webbeans.portable.AnnotatedElementFactory;
 import org.apache.webbeans.portable.events.ExtensionLoader;
@@ -64,6 +70,8 @@ import org.apache.webbeans.util.WebBeans
  */
 public class WebBeansContext
 {
+    private static final Logger logger = WebBeansLoggerFacade.getLogger(WebBeansContext.class);
+
     private final Map<Class<?>, Object> managerMap = new HashMap<Class<?>, Object>();
 
     private final Map<Class<?>, Object> serviceMap = new HashMap<Class<?>, Object>();
@@ -446,9 +454,35 @@ public class WebBeansContext
         }
     }
 
+    /**
+     * Clear and destroy the whole WebBeansContext.
+     * This will also properly destroy all SPI services
+     */
     public void clear()
     {
+        destroyServices(managerMap.values());
+        destroyServices(serviceMap.values());
+
         managerMap.clear();
+        serviceMap.clear();
+    }
+
+    private void destroyServices(Collection<Object> services)
+    {
+        for (Object spiService : services)
+        {
+            if (spiService instanceof Closeable)
+            {
+                try
+                {
+                    ((Closeable) spiService).close();
+                }
+                catch (IOException e)
+                {
+                    logger.log(Level.SEVERE, "Error while destroying SPI service " + spiService.getClass().getName(), e);
+                }
+            }
+        }
     }
 
     public LoaderService getLoaderService()

Modified: openwebbeans/branches/cdi-2.0/webbeans-impl/src/main/java/org/apache/webbeans/container/BeanCacheKey.java
URL: http://svn.apache.org/viewvc/openwebbeans/branches/cdi-2.0/webbeans-impl/src/main/java/org/apache/webbeans/container/BeanCacheKey.java?rev=1728163&r1=1728162&r2=1728163&view=diff
==============================================================================
--- openwebbeans/branches/cdi-2.0/webbeans-impl/src/main/java/org/apache/webbeans/container/BeanCacheKey.java (original)
+++ openwebbeans/branches/cdi-2.0/webbeans-impl/src/main/java/org/apache/webbeans/container/BeanCacheKey.java Tue Feb  2 17:48:14 2016
@@ -18,6 +18,7 @@
  */
 package org.apache.webbeans.container;
 
+import org.apache.webbeans.annotation.EmptyAnnotationLiteral;
 import org.apache.webbeans.util.AnnotationUtil;
 
 import javax.enterprise.util.Nonbinding;
@@ -177,96 +178,16 @@ public final class BeanCacheKey
     }
 
     /**
-     * Calculate the hashCode() of a qualifier, which ignores {@link Nonbinding} members.
+     * Calculate the hashCode() of a qualifier.
+     * We do not do any in-depth hashCode down to member hashes
+     * but only use the hashcode of the AnnotationType itself.
+     * This is WAY faster and spreads well enough in practice.
+     * We can do this as we do not need to return a perfectly unique
+     * result anyway.
      */
     private int getQualifierHashCode(Annotation a)
     {
-        Class annotationClass = getAnnotationClass(a.getClass());
-
-        if (annotationClass == null)
-        {
-            return getTypeHashCode(a.getClass());
-        }
-
-        // the hashCode of an Annotation is calculated solely via the hashCodes
-        // of it's members. If there are no members, it is 0.
-        // thus we first need to get the annotation-class hashCode
-        int hashCode = getTypeHashCode(annotationClass);
-
-        // and now add the hashCode of all it's Nonbinding members
-        // the following algorithm is defined by the Annotation class definition
-        // see the JavaDoc for Annotation!
-        // we only change it so far that we skip evaluating @Nonbinding members
-        final Method[] members = annotationClass.getDeclaredMethods();
-
-        for (Method member : members)
-        {
-            if (member.isAnnotationPresent(Nonbinding.class))
-            {
-                // ignore the non binding
-                continue;
-            }
-
-            // Member value
-            final Object object = callMethod(a, member);
-            final int value;
-            if(object.getClass().isArray())
-            {
-                Class<?> type = object.getClass().getComponentType();
-                if(type.isPrimitive())
-                {
-                    if(Long.TYPE == type)
-                    {
-                        value = Arrays.hashCode((long[]) object);
-                    }
-                    else if(Integer.TYPE == type)
-                    {
-                        value = Arrays.hashCode((int[])object);
-                    }
-                    else if(Short.TYPE == type)
-                    {
-                        value = Arrays.hashCode((short[])object);
-                    }
-                    else if(Double.TYPE == type)
-                    {
-                        value = Arrays.hashCode((double[])object);
-                    }
-                    else if(Float.TYPE == type)
-                    {
-                        value = Arrays.hashCode((float[])object);
-                    }
-                    else if(Boolean.TYPE == type)
-                    {
-                        value = Arrays.hashCode((boolean[])object);
-                    }
-                    else if(Byte.TYPE == type)
-                    {
-                        value = Arrays.hashCode((byte[])object);
-                    }
-                    else if(Character.TYPE == type)
-                    {
-                        value = Arrays.hashCode((char[])object);
-                    }
-                    else
-                    {
-                        value = 0;
-                    }
-                }
-                else
-                {
-                    value = Arrays.hashCode((Object[])object);
-                }
-            }
-            else
-            {
-                value = object.hashCode();
-            }
-
-            hashCode = 29 * hashCode + value;
-            hashCode = 29 * hashCode + member.getName().hashCode();
-        }
-
-        return hashCode;
+        return a.annotationType().hashCode();
     }
 
     /**
@@ -277,17 +198,6 @@ public final class BeanCacheKey
         return ANNOTATION_COMPARATOR.compare(qualifier1, qualifier2) == 0;
     }
 
-    private static Class getAnnotationClass(Class a)
-    {
-        for (Class i : a.getInterfaces())
-        {
-            if (i.isAnnotation())
-            {
-                return i;
-            }
-        }
-        return null;
-    }
 
     /**
      * Helper method for calculating the hashCode of an annotation.
@@ -338,6 +248,13 @@ public final class BeanCacheKey
             {
                 return temp;
             }
+            if (annotation1 instanceof EmptyAnnotationLiteral || annotation2 instanceof EmptyAnnotationLiteral)
+            {
+                // if any of those 2 annotations are known to have no members
+                // then we can immediately return as we know the 2 annotations mean the same
+                return 0;
+            }
+
             final Method[] member1 = type1.getDeclaredMethods();
             final Method[] member2 = type2.getDeclaredMethods();
 

Modified: openwebbeans/branches/cdi-2.0/webbeans-impl/src/main/java/org/apache/webbeans/container/BeanManagerImpl.java
URL: http://svn.apache.org/viewvc/openwebbeans/branches/cdi-2.0/webbeans-impl/src/main/java/org/apache/webbeans/container/BeanManagerImpl.java?rev=1728163&r1=1728162&r2=1728163&view=diff
==============================================================================
--- openwebbeans/branches/cdi-2.0/webbeans-impl/src/main/java/org/apache/webbeans/container/BeanManagerImpl.java (original)
+++ openwebbeans/branches/cdi-2.0/webbeans-impl/src/main/java/org/apache/webbeans/container/BeanManagerImpl.java Tue Feb  2 17:48:14 2016
@@ -1413,6 +1413,12 @@ public class BeanManagerImpl implements
         passivationBeans.clear();
         webBeansContext.getInterceptorsManager().clear();
         webBeansContext.getDecoratorsManager().clear();
+        webBeansContext.getAnnotatedElementFactory().clear();
+
+        injectionResolver.clearCaches();
+
+        // finally destroy all SPI services
+        webBeansContext.clear();
     }
 
     public void clearCacheProxies()

Modified: openwebbeans/branches/cdi-2.0/webbeans-impl/src/main/java/org/apache/webbeans/corespi/scanner/AbstractMetaDataDiscovery.java
URL: http://svn.apache.org/viewvc/openwebbeans/branches/cdi-2.0/webbeans-impl/src/main/java/org/apache/webbeans/corespi/scanner/AbstractMetaDataDiscovery.java?rev=1728163&r1=1728162&r2=1728163&view=diff
==============================================================================
--- openwebbeans/branches/cdi-2.0/webbeans-impl/src/main/java/org/apache/webbeans/corespi/scanner/AbstractMetaDataDiscovery.java (original)
+++ openwebbeans/branches/cdi-2.0/webbeans-impl/src/main/java/org/apache/webbeans/corespi/scanner/AbstractMetaDataDiscovery.java Tue Feb  2 17:48:14 2016
@@ -27,9 +27,9 @@ import org.apache.webbeans.corespi.scann
 import org.apache.webbeans.exception.WebBeansDeploymentException;
 import org.apache.webbeans.logger.WebBeansLoggerFacade;
 import org.apache.webbeans.spi.BDABeansXmlScanner;
+import org.apache.webbeans.spi.BdaScannerService;
 import org.apache.webbeans.spi.BeanArchiveService;
 import org.apache.webbeans.spi.BeanArchiveService.BeanDiscoveryMode;
-import org.apache.webbeans.spi.ScannerService;
 import org.apache.webbeans.util.ClassUtil;
 import org.apache.webbeans.util.UrlSet;
 import org.apache.webbeans.util.WebBeansUtil;
@@ -39,12 +39,12 @@ import org.apache.xbean.finder.ClassLoad
 import java.io.IOException;
 import java.lang.annotation.Annotation;
 import java.net.URL;
-import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Enumeration;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Iterator;
+import java.util.List;
 import java.util.Map;
 import java.util.Set;
 import java.util.logging.Level;
@@ -52,7 +52,7 @@ import java.util.logging.Logger;
 
 
 
-public abstract class AbstractMetaDataDiscovery implements ScannerService
+public abstract class AbstractMetaDataDiscovery implements BdaScannerService
 {
     protected static final Logger logger = WebBeansLoggerFacade.getLogger(AbstractMetaDataDiscovery.class);
 
@@ -78,6 +78,12 @@ public abstract class AbstractMetaDataDi
      */
     private final Map<String, URL> beanDeploymentUrls = new HashMap<String, URL>();
 
+    /**
+     * for having proper scan mode 'SCOPED' support we need to know which bean class
+     * has which beans.xml.
+     */
+    private Map<BeanArchiveService.BeanArchiveInformation, Set<Class<?>>> beanClassesPerBda;
+
     protected String[] scanningExcludes;
 
     protected ClassLoader loader;
@@ -113,6 +119,7 @@ public abstract class AbstractMetaDataDi
 
     /**
      * @return list of beans.xml locations or implicit bean archives
+     * @deprecated just here for backward compat reasons
      */
     protected Iterable<URL> getBeanArchiveUrls()
     {
@@ -315,21 +322,10 @@ public abstract class AbstractMetaDataDi
     {
         if (scanningExcludes == null)
         {
-            String scanningExcludesProperty =
-                    WebBeansContext.currentInstance().getOpenWebBeansConfiguration().getProperty(OpenWebBeansConfiguration.SCAN_EXCLUSION_PATHS);
-            ArrayList<String> scanningExcludesList = new ArrayList<String>();
-            if (scanningExcludesProperty != null)
-            {
-                for (String scanningExclude : scanningExcludesProperty.split(","))
-                {
-                    scanningExclude = scanningExclude.trim();
-                    if (!scanningExclude.isEmpty())
-                    {
-                        scanningExcludesList.add(scanningExclude);
-                    }
-                }
-            }
-            scanningExcludes = scanningExcludesList.toArray(new String[scanningExcludesList.size()]);
+            OpenWebBeansConfiguration owbConfiguration = WebBeansContext.currentInstance().getOpenWebBeansConfiguration();
+            String scanningExcludesProperty = owbConfiguration.getProperty(OpenWebBeansConfiguration.SCAN_EXCLUSION_PATHS);
+            List<String> excludes = owbConfiguration.splitValues(scanningExcludesProperty);
+            scanningExcludes = excludes.toArray(new String[excludes.size()]);
         }
     }
 
@@ -352,59 +348,74 @@ public abstract class AbstractMetaDataDi
             beanArchiveService = webBeansContext.getBeanArchiveService();
         }
 
+        // just to trigger the creation
         beanArchiveService.getBeanArchiveInformation(beanArchiveUrl);
     }
 
-    /* (non-Javadoc)
-     * @see org.apache.webbeans.corespi.ScannerService#getBeanClasses()
+
+    /**
+     * This method only gets called if the initialisation is done already.
+     * It will collect all the classes from all the BDAs it can find.
      */
-    @Override
-    public Set<Class<?>> getBeanClasses()
+    public Map<BeanArchiveService.BeanArchiveInformation, Set<Class<?>>> getBeanClassesPerBda()
     {
-        final Set<Class<?>> classSet = new HashSet<Class<?>>();
-        for (CdiArchive.FoundClasses foundClasses : archive.classesByUrl().values())
+        if (beanClassesPerBda == null)
         {
-            boolean scanModeAnnotated = BeanDiscoveryMode.ANNOTATED.equals(foundClasses.getBeanArchiveInfo().getBeanDiscoveryMode());
-            for(String className : foundClasses.getClassNames())
+            beanClassesPerBda = new HashMap<BeanArchiveService.BeanArchiveInformation, Set<Class<?>>>();
+
+            for (CdiArchive.FoundClasses foundClasses : archive.classesByUrl().values())
             {
-                try
+                Set<Class<?>> classSet = new HashSet<Class<?>>();
+                boolean scanModeAnnotated = BeanDiscoveryMode.ANNOTATED.equals(foundClasses.getBeanArchiveInfo().getBeanDiscoveryMode());
+                for (String className : foundClasses.getClassNames())
                 {
-                    if (scanModeAnnotated)
+                    try
                     {
-                        // in this case we need to find out whether we should keep this class in the Archive
-                        AnnotationFinder.ClassInfo classInfo = finder.getClassInfo(className);
-                        if (classInfo == null || !isBeanAnnotatedClass(classInfo))
+                        if (scanModeAnnotated)
                         {
-                            continue;
+                            // in this case we need to find out whether we should keep this class in the Archive
+                            AnnotationFinder.ClassInfo classInfo = finder.getClassInfo(className);
+                            if (classInfo == null || !isBeanAnnotatedClass(classInfo))
+                            {
+                                continue;
+                            }
                         }
-                    }
 
-                    Class<?> clazz = ClassUtil.getClassFromName(className);
-                    if (clazz != null)
-                    {
-
-                        // try to provoke a NoClassDefFoundError exception which is thrown
-                        // if some dependencies of the class are missing
-                        clazz.getDeclaredFields();
-                        clazz.getDeclaredMethods();
-
-                        // we can add this class cause it has been loaded completely
-                        classSet.add(clazz);
+                        Class<?> clazz = ClassUtil.getClassFromName(className);
+                        if (clazz != null)
+                        {
+                            // try to provoke a NoClassDefFoundError exception which is thrown
+                            // if some dependencies of the class are missing
+                            clazz.getDeclaredFields();
 
+                            // we can add this class cause it has been loaded completely
+                            classSet.add(clazz);
+                        }
                     }
-                }
-                catch (NoClassDefFoundError e)
-                {
-                    if (logger.isLoggable(Level.WARNING))
+                    catch (NoClassDefFoundError e)
                     {
-                        logger.log(Level.WARNING, OWBLogConst.WARN_0018, new Object[] { className, e.toString() });
+                        if (logger.isLoggable(Level.WARNING))
+                        {
+                            logger.log(Level.WARNING, OWBLogConst.WARN_0018, new Object[]{className, e.toString()});
+                        }
                     }
                 }
+
+                beanClassesPerBda.put(foundClasses.getBeanArchiveInfo(), classSet);
             }
 
         }
+        return beanClassesPerBda;
+    }
 
-        return classSet;
+    /* (non-Javadoc)
+     * @see org.apache.webbeans.corespi.ScannerService#getBeanClasses()
+     */
+    @Override
+    public Set<Class<?>> getBeanClasses()
+    {
+        // do nothing, getBeanClasses() should not get invoked anymore
+        return Collections.EMPTY_SET;
     }
 
     /**



Mime
View raw message