This is an automated email from the ASF dual-hosted git repository.
jlmonteiro pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/openwebbeans.git
The following commit(s) were added to refs/heads/master by this push:
new 2428122 OWB-1392 Use a different service to avoid breaking users by
adding a new method. It also allows a clear separation of concerns
2428122 is described below
commit 24281227289cd7477e9a384fe6e7ea98126162f2
Author: Jean-Louis Monteiro <[email protected]>
AuthorDate: Wed Oct 6 16:28:17 2021 +0200
OWB-1392 Use a different service to avoid breaking users by adding a new
method.
It also allows a clear separation of concerns
---
.../webbeans/proxy/AbstractProxyFactory.java | 16 +++++++++++---
.../webbeans/service/ClassLoaderProxyService.java | 5 +++--
.../service/ClassLoaderProxyServiceTest.java | 16 --------------
.../apache/webbeans/spi/DefiningClassService.java | 8 -------
...Service.java => InstantiatingClassService.java} | 25 ++++------------------
5 files changed, 20 insertions(+), 50 deletions(-)
diff --git
a/webbeans-impl/src/main/java/org/apache/webbeans/proxy/AbstractProxyFactory.java
b/webbeans-impl/src/main/java/org/apache/webbeans/proxy/AbstractProxyFactory.java
index 040226d..34f3ee9 100644
---
a/webbeans-impl/src/main/java/org/apache/webbeans/proxy/AbstractProxyFactory.java
+++
b/webbeans-impl/src/main/java/org/apache/webbeans/proxy/AbstractProxyFactory.java
@@ -36,6 +36,7 @@ import org.apache.webbeans.exception.ProxyGenerationException;
import org.apache.webbeans.exception.WebBeansException;
import org.apache.webbeans.hash.XxHash64;
import org.apache.webbeans.spi.DefiningClassService;
+import org.apache.webbeans.spi.InstantiatingClassService;
import org.apache.xbean.asm9.ClassReader;
import org.apache.xbean.asm9.ClassWriter;
import org.apache.xbean.asm9.MethodVisitor;
@@ -62,6 +63,7 @@ public abstract class AbstractProxyFactory
protected final Unsafe unsafe;
private final DefiningClassService definingService;
+ private final InstantiatingClassService instantiatingService;
private final boolean useStaticNames;
private final boolean useXXhash64;
@@ -84,11 +86,19 @@ public abstract class AbstractProxyFactory
this.webBeansContext = webBeansContext;
javaVersion = determineDefaultJavaVersion();
definingService =
webBeansContext.getService(DefiningClassService.class);
+
+ // if defining service implements both, we don't need to lookup the
second service
+ instantiatingService = (definingService instanceof
InstantiatingClassService)
+ ? (InstantiatingClassService) definingService
+ :
webBeansContext.getService(InstantiatingClassService.class);
+
useStaticNames =
Boolean.parseBoolean(webBeansContext.getOpenWebBeansConfiguration()
.getProperty("org.apache.webbeans.proxy.useStaticNames"));
useXXhash64 =
Boolean.parseBoolean(webBeansContext.getOpenWebBeansConfiguration()
.getProperty("org.apache.webbeans.proxy.staticNames.useXxHash64"));
- unsafe = definingService == null ? new Unsafe() : null;
+
+ // we have fallbacks bellow to try Unsafe anyways if we can't do
otherwise
+ unsafe = definingService == null || instantiatingService == null ? new
Unsafe() : null;
}
private int determineDefaultJavaVersion()
@@ -338,9 +348,9 @@ public abstract class AbstractProxyFactory
protected <T> T newInstance(final Class<? extends T> proxyClass)
{
- if (definingService != null)
+ if (instantiatingService != null)
{
- return definingService.newInstance(proxyClass);
+ return instantiatingService.newInstance(proxyClass);
}
return unsafe.unsafeNewInstance(proxyClass);
}
diff --git
a/webbeans-impl/src/main/java/org/apache/webbeans/service/ClassLoaderProxyService.java
b/webbeans-impl/src/main/java/org/apache/webbeans/service/ClassLoaderProxyService.java
index 632da45..9aeb00d 100644
---
a/webbeans-impl/src/main/java/org/apache/webbeans/service/ClassLoaderProxyService.java
+++
b/webbeans-impl/src/main/java/org/apache/webbeans/service/ClassLoaderProxyService.java
@@ -28,8 +28,9 @@ import org.apache.webbeans.config.WebBeansContext;
import org.apache.webbeans.exception.WebBeansException;
import org.apache.webbeans.logger.WebBeansLoggerFacade;
import org.apache.webbeans.spi.DefiningClassService;
+import org.apache.webbeans.spi.InstantiatingClassService;
-public class ClassLoaderProxyService implements DefiningClassService
+public class ClassLoaderProxyService implements DefiningClassService,
InstantiatingClassService
{
private final ProxiesClassLoader loader;
@@ -124,7 +125,7 @@ public class ClassLoaderProxyService implements
DefiningClassService
}
// strict load only impl, it changes LoadFirst by not creating a
classloader at all (nice in graalvm) -@Experimental
- public static class LoadOnly implements DefiningClassService
+ public static class LoadOnly implements DefiningClassService,
InstantiatingClassService
{
@Override
public ClassLoader getProxyClassLoader(final Class<?> forClass)
diff --git
a/webbeans-impl/src/test/java/org/apache/webbeans/service/ClassLoaderProxyServiceTest.java
b/webbeans-impl/src/test/java/org/apache/webbeans/service/ClassLoaderProxyServiceTest.java
index be6fcd3..0b4f5f4 100644
---
a/webbeans-impl/src/test/java/org/apache/webbeans/service/ClassLoaderProxyServiceTest.java
+++
b/webbeans-impl/src/test/java/org/apache/webbeans/service/ClassLoaderProxyServiceTest.java
@@ -44,29 +44,13 @@ public class ClassLoaderProxyServiceTest
final ClassLoader proxyLoader =
context.getService(DefiningClassService.class).getProxyClassLoader(proxyClass);
assertEquals(proxyLoader, proxyClass.getClassLoader());
proxyClass.getMethod("ok", String.class); // this line would fail if
not here, no assert needed
-
- // when using ClassLoaderProxyService, we don't use Unsafe to allocate
the instance
- // the regular reflection method newInstance is called and therefore
the constructor gets called
- // final Bean<MyBean> bean =
- // final MyBean beanInstance = factory.createProxyInstance(proxyClass,
factory.getInstanceProvider(proxyLoader, bean));
- // assertTrue(beanInstance.isConstructorInvoked);
}
public static class MyBean
{
- private final boolean constructorInvoked;
-
- public MyBean() {
- this.constructorInvoked = true;
- }
-
public String ok(final String value)
{
return ">" + value + "<";
}
-
- public boolean isConstructorInvoked() {
- return constructorInvoked;
- }
}
}
diff --git
a/webbeans-spi/src/main/java/org/apache/webbeans/spi/DefiningClassService.java
b/webbeans-spi/src/main/java/org/apache/webbeans/spi/DefiningClassService.java
index 3312b01..3bda2cd 100644
---
a/webbeans-spi/src/main/java/org/apache/webbeans/spi/DefiningClassService.java
+++
b/webbeans-spi/src/main/java/org/apache/webbeans/spi/DefiningClassService.java
@@ -40,12 +40,4 @@ public interface DefiningClassService
* @return the proxy class
*/
<T> Class<T> defineAndLoad(String name, byte[] bytecode, Class<T>
proxiedClass);
-
- /**
- * Create a new instance for a given proxy class.
- * @param proxyClass the proxy class
- * @param <T> type of the class to proxy
- * @return the proxy instance
- */
- <T> T newInstance(final Class<? extends T> proxyClass); // maybe a default
method would make sense here
}
diff --git
a/webbeans-spi/src/main/java/org/apache/webbeans/spi/DefiningClassService.java
b/webbeans-spi/src/main/java/org/apache/webbeans/spi/InstantiatingClassService.java
similarity index 54%
copy from
webbeans-spi/src/main/java/org/apache/webbeans/spi/DefiningClassService.java
copy to
webbeans-spi/src/main/java/org/apache/webbeans/spi/InstantiatingClassService.java
index 3312b01..383da5d 100644
---
a/webbeans-spi/src/main/java/org/apache/webbeans/spi/DefiningClassService.java
+++
b/webbeans-spi/src/main/java/org/apache/webbeans/spi/InstantiatingClassService.java
@@ -19,33 +19,16 @@
package org.apache.webbeans.spi;
/**
- * SPI interface to implement the proxy defining logic.
- * It enables to switch from unsafe to classloader logic for instance for java
>= 9.
+ * SPI interface to define the logic to allocate/instantiate proxy instances.
+ * We used to do that using Unsafe.allocateInstance, but better to give the
choice
*/
-public interface DefiningClassService
+public interface InstantiatingClassService
{
/**
- * Returns the classloader to use to define the given class.
- * @param forClass the proxied class
- * @return the classloader to use to define the class
- */
- ClassLoader getProxyClassLoader(Class<?> forClass);
-
- /**
- * Register the proxy class from its bytecode.
- * @param name the proxy name
- * @param bytecode the bytecode to "define"
- * @param proxiedClass the original class
- * @param <T> type of the class to proxy
- * @return the proxy class
- */
- <T> Class<T> defineAndLoad(String name, byte[] bytecode, Class<T>
proxiedClass);
-
- /**
* Create a new instance for a given proxy class.
* @param proxyClass the proxy class
* @param <T> type of the class to proxy
* @return the proxy instance
*/
- <T> T newInstance(final Class<? extends T> proxyClass); // maybe a default
method would make sense here
+ <T> T newInstance(final Class<? extends T> proxyClass);
}
