Prepare for the removal of the securitymanager in moxy. (#1320)
Signed-off-by: Tomas Kraus <tomas.kraus@oracle.com>
diff --git a/foundation/org.eclipse.persistence.core/src/main/java/org/eclipse/persistence/internal/security/PrivilegedAccessHelper.java b/foundation/org.eclipse.persistence.core/src/main/java/org/eclipse/persistence/internal/security/PrivilegedAccessHelper.java
index e7dc532..4b893d2 100644
--- a/foundation/org.eclipse.persistence.core/src/main/java/org/eclipse/persistence/internal/security/PrivilegedAccessHelper.java
+++ b/foundation/org.eclipse.persistence.core/src/main/java/org/eclipse/persistence/internal/security/PrivilegedAccessHelper.java
@@ -27,6 +27,9 @@
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.security.AccessController;
+import java.security.PrivilegedAction;
+import java.security.PrivilegedActionException;
+import java.security.PrivilegedExceptionAction;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
@@ -96,6 +99,102 @@
/**
* INTERNAL
+ * A task that returns a result and shall not throw an exception.
+ * Implementors define a single {@code call()} method with no arguments.
+ *
+ * @param <T> the result type of method call
+ */
+ @FunctionalInterface
+ public interface PrivilegedCallable<T> {
+ T call();
+ }
+
+ /**
+ * INTERNAL
+ * A task that returns a result and may throw an exception.
+ * Implementors define a single {@code call()} method with no arguments.
+ *
+ * @param <T> the result type of method call
+ */
+ @FunctionalInterface
+ public interface PrivilegedExceptionCallable<T> {
+ T call() throws Exception;
+ }
+
+ /**
+ * INTERNAL
+ * Specific {@code Exception} supplier for {@link PrivilegedExceptionCallable}.
+ *
+ * @param <E> specific {@link Exception} type
+ */
+ @FunctionalInterface
+ public interface CallableExceptionSupplier<E extends Exception> {
+ E get(Exception e);
+ }
+
+ /**
+ * INTERNAL
+ * Executes provided {@link PrivilegedCallable} task using {@link AccessController#doPrivileged(PrivilegedAction)}
+ * when privileged access is enabled.
+ *
+ * @param <T> {@link PrivilegedCallable} return type
+ * @param task task to execute
+ */
+ @SuppressWarnings("removal")
+ public static <T> T callDoPrivileged(PrivilegedCallable<T> task) {
+ if (shouldUsePrivilegedAccess()) {
+ return AccessController.doPrivileged((PrivilegedAction<T>) task::call);
+ } else {
+ return task.call();
+ }
+ }
+
+ /**
+ * INTERNAL
+ * Executes provided {@link PrivilegedExceptionCallable} task using {@link AccessController#doPrivileged(PrivilegedExceptionAction)}
+ * when privileged access is enabled.
+ *
+ * @param <T> {@link PrivilegedExceptionCallable} return type
+ * @param task task to execute
+ */
+ @SuppressWarnings("removal")
+ public static <T> T callDoPrivilegedWithException(PrivilegedExceptionCallable<T> task) throws Exception {
+ if (shouldUsePrivilegedAccess()) {
+ try {
+ return AccessController.doPrivileged((PrivilegedExceptionAction<T>) task::call);
+ // AccessController.doPrivileged wraps Exception instances with PrivilegedActionException. Let's unwrap them
+ // to provide the same exception output as original callable without AccessController.doPrivileged
+ } catch (PrivilegedActionException pae) {
+ throw pae.getException();
+ }
+ } else {
+ return task.call();
+ }
+ }
+
+ /**
+ * INTERNAL
+ * Executes provided {@link PrivilegedExceptionCallable} task using {@link AccessController#doPrivileged(PrivilegedExceptionAction)}
+ * when privileged access is enabled.
+ * If {@link Exception} is thrown from task, it will be processed by provided {@link CallableExceptionSupplier}.
+ *
+ * @param <T> {@link PrivilegedExceptionCallable} return type
+ * @param <E> specific {@link Exception} type
+ * @param task task to execute
+ * @param exception specific {@link Exception} supplier
+ */
+ @SuppressWarnings("removal")
+ public static <T,E extends Exception> T callDoPrivilegedWithException(
+ PrivilegedExceptionCallable<T> task, CallableExceptionSupplier<E> exception) throws E {
+ try {
+ return callDoPrivilegedWithException(task);
+ } catch (Exception e) {
+ throw exception.get(e);
+ }
+ }
+
+ /**
+ * INTERNAL
* It will be used to set default value of property "eclipselink.security.usedoprivileged"
* if not passed as system property. This is used by GlassfishPlatform.
*/
diff --git a/jpa/org.eclipse.persistence.jpars.server/src/main/java/org/eclipse/persistence/jpa/rs/util/PreLoginMappingAdapter.java b/jpa/org.eclipse.persistence.jpars.server/src/main/java/org/eclipse/persistence/jpa/rs/util/PreLoginMappingAdapter.java
index 164bde1..af34ff8 100644
--- a/jpa/org.eclipse.persistence.jpars.server/src/main/java/org/eclipse/persistence/jpa/rs/util/PreLoginMappingAdapter.java
+++ b/jpa/org.eclipse.persistence.jpars.server/src/main/java/org/eclipse/persistence/jpa/rs/util/PreLoginMappingAdapter.java
@@ -19,6 +19,8 @@
import java.util.Map;
import java.util.Vector;
+import jakarta.xml.bind.annotation.adapters.XmlAdapter;
+
import org.eclipse.persistence.descriptors.ClassDescriptor;
import org.eclipse.persistence.descriptors.InheritancePolicy;
import org.eclipse.persistence.internal.descriptors.InstantiationPolicy;
@@ -31,7 +33,6 @@
import org.eclipse.persistence.internal.jpa.rs.weaving.PersistenceWeavedRest;
import org.eclipse.persistence.internal.jpa.rs.weaving.RestAdapterClassWriter;
import org.eclipse.persistence.internal.queries.CollectionContainerPolicy;
-import org.eclipse.persistence.internal.sessions.AbstractSession;
import org.eclipse.persistence.jaxb.DefaultXMLNameTransformer;
import org.eclipse.persistence.jpa.rs.exceptions.JPARSException;
import org.eclipse.persistence.jpa.rs.util.xmladapters.RelationshipLinkAdapter;
@@ -328,7 +329,8 @@
xmlChoiceMapping.addChoiceElement(compositeMapping.getXPath(), Link.class);
xmlChoiceMapping.addChoiceElement(compositeMapping.getXPath(), refDesc.getJavaClass());
- xmlChoiceMapping.setConverter(new XMLJavaTypeConverter(Class.forName(adapterClassName, true, cl)));
+ xmlChoiceMapping.setConverter(new XMLJavaTypeConverter(
+ (Class<? extends XmlAdapter<?,?>>) Class.forName(adapterClassName, true, cl)));
jaxbDescriptor.removeMappingForAttributeName(jaxbMapping.getAttributeName());
jaxbDescriptor.addMapping(xmlChoiceMapping);
@@ -343,7 +345,8 @@
xmlChoiceMapping.addChoiceElement(compositeMapping.getXPath(), refDesc.getJavaClass());
xmlChoiceMapping.setContainerPolicy(jaxbMapping.getContainerPolicy());
- xmlChoiceMapping.setConverter(new XMLJavaTypeConverter(Class.forName(adapterClassName, true, cl)));
+ xmlChoiceMapping.setConverter(new XMLJavaTypeConverter(
+ (Class<? extends XmlAdapter<?,?>>) Class.forName(adapterClassName, true, cl)));
jaxbDescriptor.removeMappingForAttributeName(jaxbMapping.getAttributeName());
jaxbDescriptor.addMapping(xmlChoiceMapping);
}
diff --git a/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/internal/jaxb/MultiArgInstantiationPolicy.java b/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/internal/jaxb/MultiArgInstantiationPolicy.java
index 4e5bd50..ee022db 100644
--- a/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/internal/jaxb/MultiArgInstantiationPolicy.java
+++ b/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/internal/jaxb/MultiArgInstantiationPolicy.java
@@ -15,15 +15,11 @@
package org.eclipse.persistence.internal.jaxb;
import java.lang.reflect.InvocationTargetException;
-import java.security.AccessController;
-import java.security.PrivilegedActionException;
import org.eclipse.persistence.exceptions.DescriptorException;
import org.eclipse.persistence.exceptions.ValidationException;
import org.eclipse.persistence.internal.descriptors.InstantiationPolicy;
import org.eclipse.persistence.internal.security.PrivilegedAccessHelper;
-import org.eclipse.persistence.internal.security.PrivilegedClassForName;
-import org.eclipse.persistence.internal.security.PrivilegedMethodInvoker;
/**
* Purpose:
@@ -60,20 +56,12 @@
if(parameterTypeNames != null) {
Class<?>[] values = new Class<?>[parameterTypeNames.length];
for(int i = 0; i < values.length; i++) {
- try{
- if (PrivilegedAccessHelper.shouldUsePrivilegedAccess()){
- try {
- values[i] = AccessController.doPrivileged(new PrivilegedClassForName<>(parameterTypeNames[i], true, loader));
- } catch (PrivilegedActionException exception) {
- throw ValidationException.classNotFoundWhileConvertingClassNames(parameterTypeNames[i], exception.getException());
- }
- } else {
- values[i] = org.eclipse.persistence.internal.security.PrivilegedAccessHelper.getClassForName(parameterTypeNames[i], true, loader);
- }
- } catch (ClassNotFoundException exc){
- throw ValidationException.classNotFoundWhileConvertingClassNames(factoryClassName, exc);
- }
- }
+ final String parameterTypeName = parameterTypeNames[i];
+ values[i] = PrivilegedAccessHelper.callDoPrivilegedWithException(
+ () -> org.eclipse.persistence.internal.security.PrivilegedAccessHelper.getClassForName(parameterTypeName, true, loader),
+ (ex) -> ValidationException.classNotFoundWhileConvertingClassNames(factoryClassName, ex)
+ );
+ }
this.parameterTypes = values;
}
}
@@ -102,30 +90,20 @@
*/
@Override
protected Object buildNewInstanceUsingFactory() throws DescriptorException {
- try {
- // If the method is static, the first argument is ignored and can be null
- if (PrivilegedAccessHelper.shouldUsePrivilegedAccess()){
- try {
- return AccessController.doPrivileged(new PrivilegedMethodInvoker(getMethod(), getFactory(), this.defaultValues));
- } catch (PrivilegedActionException exception) {
- Exception throwableException = exception.getException();
- if (throwableException instanceof IllegalAccessException) {
- throw DescriptorException.illegalAccessWhileMethodInstantiation(getMethod().toString(), this.getDescriptor(), throwableException);
+ return PrivilegedAccessHelper.callDoPrivilegedWithException(
+ () -> PrivilegedAccessHelper.invokeMethod(getMethod(), getFactory(), this.defaultValues),
+ (ex) -> {
+ if (ex instanceof IllegalAccessException) {
+ return DescriptorException.illegalAccessWhileMethodInstantiation(getMethod().toString(), this.getDescriptor(), ex);
+ } else if (ex instanceof InvocationTargetException) {
+ return DescriptorException.targetInvocationWhileMethodInstantiation(getMethod().toString(), this.getDescriptor(), ex);
+ } else if (ex instanceof NullPointerException) {
+ return DescriptorException.nullPointerWhileMethodInstantiation(this.getMethod().toString(), this.getDescriptor(), ex);
} else {
- throw DescriptorException.targetInvocationWhileMethodInstantiation(getMethod().toString(), this.getDescriptor(), throwableException);
+ return new RuntimeException("Unexpected exception from MultiArgInstantiationPolicy.buildNewInstanceUsingFactory()", ex);
}
}
- } else {
- return PrivilegedAccessHelper.invokeMethod(getMethod(), getFactory(), this.defaultValues);
- }
- } catch (IllegalAccessException exception) {
- throw DescriptorException.illegalAccessWhileMethodInstantiation(getMethod().toString(), this.getDescriptor(), exception);
- } catch (InvocationTargetException exception) {
- throw DescriptorException.targetInvocationWhileMethodInstantiation(getMethod().toString(), this.getDescriptor(), exception);
- } catch (NullPointerException exception) {
- // Some JVMs will throw a NULL pointer exception here
- throw DescriptorException.nullPointerWhileMethodInstantiation(this.getMethod().toString(), this.getDescriptor(), exception);
- }
+ );
}
}
diff --git a/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/internal/jaxb/XMLJavaTypeConverter.java b/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/internal/jaxb/XMLJavaTypeConverter.java
index b4fff8a..03b24be 100644
--- a/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/internal/jaxb/XMLJavaTypeConverter.java
+++ b/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/internal/jaxb/XMLJavaTypeConverter.java
@@ -16,12 +16,12 @@
import java.lang.reflect.Constructor;
import java.lang.reflect.Type;
-import java.security.AccessController;
import java.util.HashMap;
-import jakarta.xml.bind.annotation.adapters.XmlAdapter;
import javax.xml.namespace.QName;
+import jakarta.xml.bind.annotation.adapters.XmlAdapter;
+
import org.eclipse.persistence.core.mappings.converters.CoreConverter;
import org.eclipse.persistence.exceptions.ConversionException;
import org.eclipse.persistence.exceptions.JAXBException;
@@ -29,9 +29,6 @@
import org.eclipse.persistence.internal.oxm.XMLConversionManager;
import org.eclipse.persistence.internal.oxm.mappings.BinaryDataMapping;
import org.eclipse.persistence.internal.security.PrivilegedAccessHelper;
-import org.eclipse.persistence.internal.security.PrivilegedClassForName;
-import org.eclipse.persistence.internal.security.PrivilegedGetConstructorFor;
-import org.eclipse.persistence.internal.security.PrivilegedNewInstanceFromClass;
import org.eclipse.persistence.internal.sessions.AbstractSession;
import org.eclipse.persistence.jaxb.JAXBMarshaller;
import org.eclipse.persistence.jaxb.JAXBUnmarshaller;
@@ -51,12 +48,12 @@
public class XMLJavaTypeConverter extends org.eclipse.persistence.oxm.mappings.converters.XMLConverterAdapter {
protected Class<?> boundType = Object.class;
protected Class<?> valueType = Object.class;
- protected Class<?> xmlAdapterClass;
+ protected Class<? extends XmlAdapter<?,?>> xmlAdapterClass;
protected String xmlAdapterClassName;
- protected XmlAdapter xmlAdapter;
+ protected XmlAdapter<?,?> xmlAdapter;
protected QName schemaType;
protected DatabaseMapping mapping;
- protected CoreConverter nestedConverter;
+ protected CoreConverter<DatabaseMapping, Session> nestedConverter;
/**
* The default constructor. This constructor should be used
@@ -71,8 +68,9 @@
* converter.
*
*/
+ @SuppressWarnings("unchecked")
public XMLJavaTypeConverter(Class<?> xmlAdapterClass) {
- setXmlAdapterClass(xmlAdapterClass);
+ setXmlAdapterClass((Class<XmlAdapter<?,?>>) xmlAdapterClass);
}
/**
@@ -92,9 +90,10 @@
* will occur during marshal.
*
*/
+ @SuppressWarnings("unchecked")
public XMLJavaTypeConverter(Class<?> xmlAdapterClass, QName schemaType) {
setSchemaType(schemaType);
- setXmlAdapterClass(xmlAdapterClass);
+ setXmlAdapterClass((Class<XmlAdapter<?,?>>) xmlAdapterClass);
}
/**
@@ -116,11 +115,13 @@
@Override
public Object convertDataValueToObjectValue(Object dataValue, Session session, XMLUnmarshaller unmarshaller) {
try {
- XmlAdapter adapter = this.xmlAdapter;
+ XmlAdapter<?, ?> adapter = this.xmlAdapter;
if (unmarshaller != null) {
- HashMap adapters = (HashMap) unmarshaller.getProperty(JAXBUnmarshaller.XML_JAVATYPE_ADAPTERS);
+ @SuppressWarnings("unchecked")
+ HashMap<Class<XmlAdapter<?,?>>, XmlAdapter<?, ?>> adapters
+ = (HashMap<Class<XmlAdapter<?,?>>, XmlAdapter<?, ?>>) unmarshaller.getProperty(JAXBUnmarshaller.XML_JAVATYPE_ADAPTERS);
if (adapters != null) {
- XmlAdapter runtimeAdapter = (XmlAdapter) adapters.get(this.xmlAdapterClass);
+ XmlAdapter<?, ?> runtimeAdapter = adapters.get(this.xmlAdapterClass);
if (runtimeAdapter != null) {
adapter = runtimeAdapter;
}
@@ -143,7 +144,8 @@
}
}
}
- return adapter.unmarshal(toConvert);
+ //noinspection unchecked
+ return ((XmlAdapter<Object, ?>)adapter).unmarshal(toConvert);
} catch (Exception ex) {
if(unmarshaller == null || unmarshaller.getErrorHandler() == null){
throw ConversionException.couldNotBeConverted(dataValue, boundType, ex);
@@ -163,17 +165,20 @@
@Override
public Object convertObjectValueToDataValue(Object objectValue, Session session, XMLMarshaller marshaller) {
try {
- XmlAdapter adapter = this.xmlAdapter;
+ XmlAdapter<?, ?> adapter = this.xmlAdapter;
if (marshaller != null) {
- HashMap adapters = (HashMap) marshaller.getProperty(JAXBMarshaller.XML_JAVATYPE_ADAPTERS);
+ @SuppressWarnings("unchecked")
+ HashMap<Class<XmlAdapter<?,?>>, XmlAdapter<?,?>> adapters
+ = (HashMap<Class<XmlAdapter<?,?>>, XmlAdapter<?,?>>) marshaller.getProperty(JAXBMarshaller.XML_JAVATYPE_ADAPTERS);
if (adapters != null) {
- XmlAdapter runtimeAdapter = (XmlAdapter) adapters.get(this.xmlAdapterClass);
+ XmlAdapter<?,?> runtimeAdapter = adapters.get(this.xmlAdapterClass);
if (runtimeAdapter != null) {
adapter = runtimeAdapter;
}
}
}
- Object dataValue = adapter.marshal(objectValue);
+ @SuppressWarnings("unchecked")
+ Object dataValue = ((XmlAdapter<?, Object>) adapter).marshal(objectValue);
if(nestedConverter != null) {
dataValue = nestedConverter.convertObjectValueToDataValue(dataValue, session);
}
@@ -203,7 +208,7 @@
*
* @return xmlAdapterClass
*/
- public Class<?> getXmlAdapterClass() {
+ public Class<? extends XmlAdapter<?,?>> getXmlAdapterClass() {
return xmlAdapterClass;
}
@@ -231,15 +236,10 @@
// if the adapter class is null, try the adapter class name
ClassLoader loader = session.getDatasourceLogin().getDatasourcePlatform().getConversionManager().getLoader();
if (xmlAdapterClass == null) {
- try {
- if (PrivilegedAccessHelper.shouldUsePrivilegedAccess()) {
- xmlAdapterClass = AccessController.doPrivileged(new PrivilegedClassForName<>(getXmlAdapterClassName(), true, loader));
- } else {
- xmlAdapterClass = PrivilegedAccessHelper.getClassForName(getXmlAdapterClassName(), true, loader);
- }
- } catch (Exception e) {
- throw JAXBException.adapterClassNotLoaded(getXmlAdapterClassName(), e);
- }
+ xmlAdapterClass = PrivilegedAccessHelper.callDoPrivilegedWithException(
+ () -> PrivilegedAccessHelper.getClassForName(getXmlAdapterClassName(), true, loader),
+ (ex) -> JAXBException.adapterClassNotLoaded(getXmlAdapterClassName(), ex)
+ );
}
// validate adapter class extends jakarta.xml.bind.annotation.adapters.XmlAdapter
@@ -248,29 +248,23 @@
}
setBoundTypeAndValueTypeInCaseOfGenericXmlAdapter();
-
try {
- try {
- if (PrivilegedAccessHelper.shouldUsePrivilegedAccess()) {
- xmlAdapter = (XmlAdapter) AccessController.doPrivileged(new PrivilegedNewInstanceFromClass<>(getXmlAdapterClass()));
- } else {
- xmlAdapter = (XmlAdapter) PrivilegedAccessHelper.newInstanceFromClass(getXmlAdapterClass());
- }
+ try {
+ xmlAdapter = PrivilegedAccessHelper.callDoPrivilegedWithException(
+ () -> PrivilegedAccessHelper.newInstanceFromClass(getXmlAdapterClass())
+ );
} catch (IllegalAccessException e) {
- Constructor ctor = null;
- if (PrivilegedAccessHelper.shouldUsePrivilegedAccess()) {
- ctor = AccessController.doPrivileged(new PrivilegedGetConstructorFor<>(xmlAdapterClass, new Class<?>[0], true));
- } else {
- ctor = PrivilegedAccessHelper.getDeclaredConstructorFor(xmlAdapterClass, new Class<?>[0], true);
- }
- xmlAdapter = (XmlAdapter) PrivilegedAccessHelper.invokeConstructor(ctor, new Object[0]);
+ Constructor<? extends XmlAdapter<?,?>> ctor = PrivilegedAccessHelper.callDoPrivilegedWithException(
+ () -> PrivilegedAccessHelper.getDeclaredConstructorFor(xmlAdapterClass, new Class<?>[0], true)
+ );
+ xmlAdapter = PrivilegedAccessHelper.invokeConstructor(ctor, new Object[0]);
}
} catch (Exception ex) {
throw JAXBException.adapterClassCouldNotBeInstantiated(getXmlAdapterClassName(), ex);
}
- if(nestedConverter != null) {
- if(nestedConverter instanceof ObjectTypeConverter) {
- ((ObjectTypeConverter)nestedConverter).convertClassNamesToClasses(loader);
+ if (nestedConverter != null) {
+ if (nestedConverter instanceof ObjectTypeConverter) {
+ ((ObjectTypeConverter) nestedConverter).convertClassNamesToClasses(loader);
}
nestedConverter.initialize(mapping, session);
}
@@ -315,7 +309,7 @@
* Set the XmlAdapter class to be used with this converter.
*
*/
- public void setXmlAdapterClass(Class<?> xmlAdapterClass) {
+ public void setXmlAdapterClass(Class<? extends XmlAdapter<?,?>> xmlAdapterClass) {
this.xmlAdapterClass = xmlAdapterClass;
}
@@ -330,7 +324,7 @@
/**
* Get the nested converter to that is used in conjunction with the adapter.
*/
- public CoreConverter getNestedConverter() {
+ public CoreConverter<DatabaseMapping, Session> getNestedConverter() {
return nestedConverter;
}
@@ -339,7 +333,7 @@
* the nested converter is invoked after the adapter. On umarshal it is invoked before.
* Primarily used to support enumerations with adapters.
*/
- public void setNestedConverter(CoreConverter nestedConverter) {
+ public void setNestedConverter(CoreConverter<DatabaseMapping, Session> nestedConverter) {
this.nestedConverter = nestedConverter;
}
}
diff --git a/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/jaxb/JAXBBeanValidator.java b/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/jaxb/JAXBBeanValidator.java
index 10d633b..8d67c2d 100644
--- a/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/jaxb/JAXBBeanValidator.java
+++ b/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/jaxb/JAXBBeanValidator.java
@@ -14,9 +14,14 @@
// Marcel Valovy - 2.6 - initial implementation
package org.eclipse.persistence.jaxb;
-import org.eclipse.persistence.exceptions.BeanValidationException;
-import org.eclipse.persistence.internal.security.PrivilegedAccessHelper;
-import org.eclipse.persistence.jaxb.xmlmodel.XmlBindings;
+import java.security.CodeSource;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.Set;
+import java.util.concurrent.locks.ReentrantLock;
import jakarta.validation.ConstraintViolation;
import jakarta.validation.ConstraintViolationException;
@@ -26,18 +31,12 @@
import jakarta.validation.Validator;
import jakarta.validation.ValidatorFactory;
import jakarta.validation.groups.Default;
-import java.security.AccessController;
-import java.security.CodeSource;
-import java.security.PrivilegedAction;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.HashSet;
-import java.util.Iterator;
-import java.util.LinkedList;
-import java.util.Set;
-import java.util.concurrent.locks.ReentrantLock;
-import java.util.logging.Level;
-import java.util.logging.Logger;
+
+import org.eclipse.persistence.exceptions.BeanValidationException;
+import org.eclipse.persistence.internal.security.PrivilegedAccessHelper;
+import org.eclipse.persistence.jaxb.xmlmodel.XmlBindings;
+import org.eclipse.persistence.logging.DefaultSessionLog;
+import org.eclipse.persistence.logging.SessionLog;
/**
* INTERNAL:
@@ -52,9 +51,6 @@
*/
class JAXBBeanValidator {
- private static Logger logger =
- Logger.getLogger(JAXBBeanValidator.class.getName());
-
/**
* Represents the Default validation group. Storing it in constant saves resources.
*/
@@ -130,6 +126,9 @@
*/
private BeanValidationMode beanValidationMode = BeanValidationMode.NONE;
+ // Local logger instance.
+ private final SessionLog log = new DefaultSessionLog();
+
/**
* Private constructor. Only to be called by factory methods.
* @param prefix differentiates between marshaller and unmarshaller during logging
@@ -281,7 +280,7 @@
*/
Set<ConstraintViolationWrapper<Object>> getConstraintViolations() {
Set<ConstraintViolationWrapper<Object>> result = new HashSet<>(constraintViolations.size());
- for (ConstraintViolation cv : constraintViolations) {
+ for (ConstraintViolation<Object> cv : constraintViolations) {
result.add(new ConstraintViolationWrapper<>(cv));
}
return result;
@@ -385,7 +384,6 @@
*
* @return BeanValidationException, containing ConstraintViolationException.
*/
- @SuppressWarnings({"RedundantCast", "unchecked"})
private BeanValidationException buildConstraintViolationException() {
ConstraintViolationException cve = new ConstraintViolationException(
/* Do not remove the cast. */ constraintViolations);
@@ -405,7 +403,7 @@
Iterator<? extends ConstraintViolation<?>> iterator = constraintViolations.iterator();
assert iterator.hasNext(); // this method is to be called only if constraints violations are not empty
ConstraintViolation<?> cv = iterator.next();
- Collection<ConstraintViolationInfo> violatedConstraints = new LinkedList<ConstraintViolationInfo>(){
+ Collection<ConstraintViolationInfo> violatedConstraints = new LinkedList<>() {
@Override
public String toString() {
Iterator<ConstraintViolationInfo> it = iterator();
@@ -440,8 +438,8 @@
private void printValidatorInfo() {
if (!context.getHasLoggedValidatorInfo().getAndSet(true)) {
CodeSource validationImplJar = getValidatorCodeSource();
- if (logger.isLoggable(Level.FINE)) {
- logger.fine("EclipseLink is using " + validationImplJar + " as BeanValidation implementation.");
+ if (log.shouldLog(SessionLog.FINE)) {
+ log.log(SessionLog.FINE, "EclipseLink is using " + validationImplJar + " as BeanValidation implementation.");
}
}
}
@@ -453,16 +451,9 @@
* @return Validator code source. May be null.
*/
private CodeSource getValidatorCodeSource() {
- if (PrivilegedAccessHelper.shouldUsePrivilegedAccess()) {
- return AccessController.doPrivileged(new PrivilegedAction<CodeSource>() {
- @Override
- public CodeSource run() {
- return validator.getClass().getProtectionDomain().getCodeSource();
- }
- });
- } else {
- return validator.getClass().getProtectionDomain().getCodeSource();
- }
+ return PrivilegedAccessHelper.callDoPrivileged(
+ () -> validator.getClass().getProtectionDomain().getCodeSource()
+ );
}
/**
diff --git a/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/jaxb/JAXBContext.java b/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/jaxb/JAXBContext.java
index 2df447b..b5b5dc1 100644
--- a/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/jaxb/JAXBContext.java
+++ b/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/jaxb/JAXBContext.java
@@ -16,8 +16,6 @@
// Dmitry Kornilov - 2.6.1 - BeanValidationHelper refactoring
package org.eclipse.persistence.jaxb;
-import static org.eclipse.persistence.jaxb.javamodel.Helper.getQualifiedJavaTypeName;
-
import java.awt.Image;
import java.io.BufferedReader;
import java.io.InputStream;
@@ -26,13 +24,12 @@
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
-import java.security.AccessController;
-import java.security.PrivilegedAction;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Comparator;
import java.util.HashMap;
+import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
@@ -42,6 +39,11 @@
import java.util.Vector;
import java.util.concurrent.atomic.AtomicBoolean;
+import javax.xml.namespace.QName;
+import javax.xml.stream.FactoryConfigurationError;
+import javax.xml.stream.XMLInputFactory;
+import javax.xml.transform.Source;
+
import jakarta.xml.bind.JAXBElement;
import jakarta.xml.bind.Marshaller;
import jakarta.xml.bind.PropertyException;
@@ -49,13 +51,8 @@
import jakarta.xml.bind.ValidationEvent;
import jakarta.xml.bind.ValidationEventHandler;
import jakarta.xml.bind.annotation.adapters.XmlAdapter;
-import java.util.HashSet;
-import javax.xml.namespace.QName;
-import javax.xml.stream.FactoryConfigurationError;
-import javax.xml.stream.XMLInputFactory;
-import javax.xml.transform.Source;
-import org.eclipse.persistence.Version;
+import org.eclipse.persistence.Version;
import org.eclipse.persistence.core.queries.CoreAttributeGroup;
import org.eclipse.persistence.core.sessions.CoreProject;
import org.eclipse.persistence.descriptors.ClassDescriptor;
@@ -110,6 +107,8 @@
import org.eclipse.persistence.sessions.Project;
import org.eclipse.persistence.sessions.SessionEventListener;
+import static org.eclipse.persistence.jaxb.javamodel.Helper.getQualifiedJavaTypeName;
+
/**
* <p><b>Purpose:</b>Provide a EclipseLink implementation of the JAXBContext interface.</p>
* <p><b>Responsibilities:</b><ul>
@@ -945,14 +944,9 @@
* the binding layer for a Web Service provider.
*/
private JAXBContextState createContextState(Class<?>[] classesToBeBound, Map<String, XmlBindings> xmlBindings) throws jakarta.xml.bind.JAXBException {
- JaxbClassLoader loader = PrivilegedAccessHelper.shouldUsePrivilegedAccess()
- ? AccessController.doPrivileged(new PrivilegedAction<JaxbClassLoader>() {
- @Override
- public JaxbClassLoader run() {
- return new JaxbClassLoader(classLoader, classesToBeBound);
- }
- })
- : new JaxbClassLoader(classLoader, classesToBeBound);
+ JaxbClassLoader loader = PrivilegedAccessHelper.callDoPrivileged(
+ () -> new JaxbClassLoader(classLoader, classesToBeBound)
+ );
String defaultTargetNamespace = null;
AnnotationHelper annotationHelper = null;
boolean enableXmlAccessorFactory = false;
@@ -1143,14 +1137,9 @@
final TypeMappingInfo[] types = typesToBeBound;
- JaxbClassLoader loader = PrivilegedAccessHelper.shouldUsePrivilegedAccess()
- ? AccessController.doPrivileged(new PrivilegedAction<JaxbClassLoader>() {
- @Override
- public JaxbClassLoader run() {
- return new JaxbClassLoader(classLoader, types);
- }
- })
- : new JaxbClassLoader(classLoader, types);
+ JaxbClassLoader loader = PrivilegedAccessHelper.callDoPrivileged(
+ () -> new JaxbClassLoader(classLoader, types)
+ );
JavaModelImpl jModel;
if (annotationHelper != null) {
jModel = new JavaModelImpl(loader, annotationHelper);
diff --git a/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/jaxb/JAXBEnumTypeConverter.java b/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/jaxb/JAXBEnumTypeConverter.java
index 87404ae..e5a457c 100644
--- a/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/jaxb/JAXBEnumTypeConverter.java
+++ b/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/jaxb/JAXBEnumTypeConverter.java
@@ -14,17 +14,16 @@
// Oracle - initial API and implementation from Oracle TopLink
package org.eclipse.persistence.jaxb;
-import java.security.AccessController;
-import java.security.PrivilegedActionException;
-import java.util.*;
-import org.eclipse.persistence.sessions.Session;
-import org.eclipse.persistence.mappings.DatabaseMapping;
-import org.eclipse.persistence.mappings.converters.ObjectTypeConverter;
+import java.util.EnumSet;
+import java.util.Iterator;
+
import org.eclipse.persistence.exceptions.DescriptorException;
import org.eclipse.persistence.exceptions.ValidationException;
import org.eclipse.persistence.internal.oxm.mappings.Mapping;
import org.eclipse.persistence.internal.security.PrivilegedAccessHelper;
-import org.eclipse.persistence.internal.security.PrivilegedClassForName;
+import org.eclipse.persistence.mappings.DatabaseMapping;
+import org.eclipse.persistence.mappings.converters.ObjectTypeConverter;
+import org.eclipse.persistence.sessions.Session;
/**
* INTERNAL:
@@ -60,19 +59,10 @@
*/
@Override
public void convertClassNamesToClasses(ClassLoader classLoader){
- try {
- if (PrivilegedAccessHelper.shouldUsePrivilegedAccess()){
- try {
- m_enumClass = AccessController.doPrivileged(new PrivilegedClassForName<>(m_enumClassName, true, classLoader));
- } catch (PrivilegedActionException exception) {
- throw ValidationException.classNotFoundWhileConvertingClassNames(m_enumClassName, exception.getException());
- }
- } else {
- m_enumClass = org.eclipse.persistence.internal.security.PrivilegedAccessHelper.getClassForName(m_enumClassName, true, classLoader);
- }
- } catch (ClassNotFoundException exception){
- throw ValidationException.classNotFoundWhileConvertingClassNames(m_enumClassName, exception);
- }
+ m_enumClass = PrivilegedAccessHelper.callDoPrivilegedWithException(
+ () -> org.eclipse.persistence.internal.security.PrivilegedAccessHelper.getClassForName(m_enumClassName, true, classLoader),
+ (ex) -> ValidationException.classNotFoundWhileConvertingClassNames(m_enumClassName, ex)
+ );
}
/**
diff --git a/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/jaxb/JAXBMarshalListener.java b/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/jaxb/JAXBMarshalListener.java
index 6175085..ab5ce86 100644
--- a/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/jaxb/JAXBMarshalListener.java
+++ b/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/jaxb/JAXBMarshalListener.java
@@ -14,9 +14,6 @@
// Oracle - initial API and implementation from Oracle TopLink
package org.eclipse.persistence.jaxb;
-import java.lang.reflect.InvocationTargetException;
-import java.security.AccessController;
-import java.security.PrivilegedActionException;
import java.util.Map;
import jakarta.xml.bind.Marshaller;
@@ -24,7 +21,6 @@
import org.eclipse.persistence.exceptions.XMLMarshalException;
import org.eclipse.persistence.internal.oxm.Root;
import org.eclipse.persistence.internal.security.PrivilegedAccessHelper;
-import org.eclipse.persistence.internal.security.PrivilegedMethodInvoker;
import org.eclipse.persistence.jaxb.compiler.MarshalCallback;
import org.eclipse.persistence.oxm.XMLMarshalListener;
@@ -62,69 +58,39 @@
}
@Override
- public void beforeMarshal(Object obj) {
+ public void beforeMarshal(final Object obj) {
if(classBasedMarshalEvents != null) {
MarshalCallback callback = (MarshalCallback)classBasedMarshalEvents.get(obj.getClass().getName());
if(callback != null && callback.getBeforeMarshalCallback() != null) {
- try {
- if (PrivilegedAccessHelper.shouldUsePrivilegedAccess()){
- try{
- AccessController.doPrivileged(new PrivilegedMethodInvoker(callback.getBeforeMarshalCallback(), obj, new Object[]{marshaller}));
- }catch (PrivilegedActionException ex){
- if (ex.getCause() instanceof IllegalAccessException){
- throw (IllegalAccessException) ex.getCause();
- }
- if (ex.getCause() instanceof InvocationTargetException){
- throw (InvocationTargetException) ex.getCause();
- }
- throw (RuntimeException)ex.getCause();
- }
- }else{
- PrivilegedAccessHelper.invokeMethod(callback.getBeforeMarshalCallback(), obj, new Object[]{marshaller});
- }
- } catch(Exception ex) {
- throw XMLMarshalException.marshalException(ex);
- }
+ PrivilegedAccessHelper.callDoPrivilegedWithException(
+ () -> PrivilegedAccessHelper.invokeMethod(callback.getBeforeMarshalCallback(), obj, new Object[]{marshaller}),
+ (ex) -> XMLMarshalException.marshalException(ex)
+ );
}
}
if (listener != null) {
- if(obj instanceof Root){
- obj = jaxbContext.createJAXBElementFromXMLRoot((Root) obj, ((Root) obj).getDeclaredType());
- }
- listener.beforeMarshal(obj);
+ listener.beforeMarshal(
+ obj instanceof Root
+ ? jaxbContext.createJAXBElementFromXMLRoot((Root) obj, ((Root) obj).getDeclaredType()) : obj
+ );
}
}
@Override
- public void afterMarshal(Object obj) {
+ public void afterMarshal(final Object obj) {
if(classBasedMarshalEvents != null) {
MarshalCallback callback = (MarshalCallback)classBasedMarshalEvents.get(obj.getClass().getName());
if (callback != null && callback.getAfterMarshalCallback() != null) {
- try {
- if (PrivilegedAccessHelper.shouldUsePrivilegedAccess()){
- try{
- AccessController.doPrivileged(new PrivilegedMethodInvoker(callback.getAfterMarshalCallback(), obj, new Object[]{marshaller}));
- }catch (PrivilegedActionException ex){
- if (ex.getCause() instanceof IllegalAccessException){
- throw (IllegalAccessException) ex.getCause();
- }
- if (ex.getCause() instanceof InvocationTargetException){
- throw (InvocationTargetException) ex.getCause();
- }
- throw (RuntimeException)ex.getCause();
- }
- }else{
- PrivilegedAccessHelper.invokeMethod(callback.getAfterMarshalCallback(), obj, new Object[]{marshaller});
- }
- } catch(Exception ex) {
- throw XMLMarshalException.marshalException(ex);
- }
+ PrivilegedAccessHelper.callDoPrivilegedWithException(
+ () -> PrivilegedAccessHelper.invokeMethod(callback.getAfterMarshalCallback(), obj, new Object[]{marshaller}),
+ (ex) -> XMLMarshalException.marshalException(ex)
+ );
}
}
if (listener != null) {
- if(obj instanceof Root){
- obj = jaxbContext.createJAXBElementFromXMLRoot((Root) obj, ((Root) obj).getDeclaredType());
- }
- listener.afterMarshal(obj);
+ listener.afterMarshal(
+ obj instanceof Root
+ ? jaxbContext.createJAXBElementFromXMLRoot((Root) obj, ((Root) obj).getDeclaredType()) : obj
+ );
}
}
diff --git a/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/jaxb/JAXBUnmarshalListener.java b/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/jaxb/JAXBUnmarshalListener.java
index ee56f34..aeb23a9 100644
--- a/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/jaxb/JAXBUnmarshalListener.java
+++ b/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/jaxb/JAXBUnmarshalListener.java
@@ -14,16 +14,12 @@
// Oracle - initial API and implementation from Oracle TopLink
package org.eclipse.persistence.jaxb;
-import java.lang.reflect.InvocationTargetException;
-import java.security.AccessController;
-import java.security.PrivilegedActionException;
import java.util.Map;
import jakarta.xml.bind.Unmarshaller;
import org.eclipse.persistence.exceptions.XMLMarshalException;
import org.eclipse.persistence.internal.security.PrivilegedAccessHelper;
-import org.eclipse.persistence.internal.security.PrivilegedMethodInvoker;
import org.eclipse.persistence.jaxb.compiler.UnmarshalCallback;
import org.eclipse.persistence.oxm.XMLUnmarshalListener;
@@ -65,25 +61,10 @@
if(classBasedUnmarshalEvents != null) {
UnmarshalCallback callback = (UnmarshalCallback)classBasedUnmarshalEvents.get(target.getClass().getName());
if(callback != null && callback.getBeforeUnmarshalCallback() != null) {
- try {
- if (PrivilegedAccessHelper.shouldUsePrivilegedAccess()){
- try{
- AccessController.doPrivileged(new PrivilegedMethodInvoker(callback.getBeforeUnmarshalCallback(), target, new Object[]{unmarshaller, parent}));
- }catch (PrivilegedActionException ex){
- if (ex.getCause() instanceof IllegalAccessException){
- throw (IllegalAccessException) ex.getCause();
- }
- if (ex.getCause() instanceof InvocationTargetException){
- throw (InvocationTargetException) ex.getCause();
- }
- throw (RuntimeException)ex.getCause();
- }
- }else{
- PrivilegedAccessHelper.invokeMethod(callback.getBeforeUnmarshalCallback(), target, new Object[]{unmarshaller, parent});
- }
- } catch(Exception ex) {
- throw XMLMarshalException.unmarshalException(ex);
- }
+ PrivilegedAccessHelper.callDoPrivilegedWithException(
+ () -> PrivilegedAccessHelper.invokeMethod(callback.getBeforeUnmarshalCallback(), target, new Object[]{unmarshaller, parent}),
+ (ex) -> XMLMarshalException.unmarshalException(ex)
+ );
}
}
if(listener != null) {
@@ -95,25 +76,10 @@
if(classBasedUnmarshalEvents != null) {
UnmarshalCallback callback = (UnmarshalCallback)classBasedUnmarshalEvents.get(target.getClass().getName());
if(callback != null && callback.getAfterUnmarshalCallback() != null) {
- try {
- if (PrivilegedAccessHelper.shouldUsePrivilegedAccess()){
- try{
- AccessController.doPrivileged(new PrivilegedMethodInvoker(callback.getAfterUnmarshalCallback(), target, new Object[]{unmarshaller, parent}));
- }catch (PrivilegedActionException ex){
- if (ex.getCause() instanceof IllegalAccessException){
- throw (IllegalAccessException) ex.getCause();
- }
- if (ex.getCause() instanceof InvocationTargetException){
- throw (InvocationTargetException) ex.getCause();
- }
- throw (RuntimeException)ex.getCause();
- }
- }else{
- PrivilegedAccessHelper.invokeMethod(callback.getAfterUnmarshalCallback(), target, new Object[]{unmarshaller, parent});
- }
- } catch(Exception ex) {
- throw XMLMarshalException.unmarshalException(ex);
- }
+ PrivilegedAccessHelper.callDoPrivilegedWithException(
+ () -> PrivilegedAccessHelper.invokeMethod(callback.getAfterUnmarshalCallback(), target, new Object[]{unmarshaller, parent}),
+ (ex) -> XMLMarshalException.unmarshalException(ex)
+ );
}
}
if(listener != null) {
diff --git a/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/jaxb/MOXySystemProperties.java b/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/jaxb/MOXySystemProperties.java
index aeac1a5..8cdb75b 100644
--- a/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/jaxb/MOXySystemProperties.java
+++ b/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/jaxb/MOXySystemProperties.java
@@ -14,10 +14,6 @@
// Martin Vojtek - 2.6.0 - initial implementation
package org.eclipse.persistence.jaxb;
-import java.security.AccessController;
-import java.security.PrivilegedActionException;
-import java.security.PrivilegedExceptionAction;
-
import org.eclipse.persistence.internal.oxm.OXMSystemProperties;
import org.eclipse.persistence.internal.security.PrivilegedAccessHelper;
import org.eclipse.persistence.logging.AbstractSessionLog;
@@ -102,26 +98,9 @@
* @return value of the system property
*/
private static Boolean getBoolean(final String propertyName) {
- if (PrivilegedAccessHelper.shouldUsePrivilegedAccess()) {
- return runDoPrivileged(propertyName);
- } else {
- return getSystemPropertyValue(propertyName);
- }
+ return PrivilegedAccessHelper.callDoPrivileged(
+ () -> Boolean.getBoolean(propertyName)
+ );
}
- private static Boolean runDoPrivileged(final String propertyName) {
- try {
- return AccessController.doPrivileged(new PrivilegedExceptionAction<Boolean>() {
- @Override
- public Boolean run() throws Exception {
- return getSystemPropertyValue(propertyName);
- }});
- } catch (PrivilegedActionException e) {
- throw (RuntimeException) e.getCause();
- }
- }
-
- private static Boolean getSystemPropertyValue(final String propertyName) {
- return Boolean.getBoolean(propertyName);
- }
}
diff --git a/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/jaxb/ReflectionUtils.java b/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/jaxb/ReflectionUtils.java
index 5121e33..104f4db 100644
--- a/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/jaxb/ReflectionUtils.java
+++ b/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/jaxb/ReflectionUtils.java
@@ -17,12 +17,8 @@
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
-import java.security.PrivilegedAction;
-import java.security.PrivilegedActionException;
-import java.security.PrivilegedExceptionAction;
-import static java.security.AccessController.doPrivileged;
-import static org.eclipse.persistence.internal.security.PrivilegedAccessHelper.shouldUsePrivilegedAccess;
+import org.eclipse.persistence.internal.security.PrivilegedAccessHelper;
/**
* Utility class for handling reflection calls and using caller sensitive actions.
@@ -43,9 +39,6 @@
/**
* Retrieves class object.
- * <p>
- * If security is enabled, makes {@linkplain java.security.AccessController#doPrivileged(PrivilegedAction)
- * privileged calls}.
*
* @param clazz name of class to be retrieved
* @return class object
@@ -53,343 +46,53 @@
*/
static Class<?> forName(String clazz) throws ClassNotFoundException {
try {
- return shouldUsePrivilegedAccess()
- ? doPrivileged(ForNameIODH.PREDICATE_EXCEPTION_ACTION.with(clazz))
- : forNameInternal(clazz);
- } catch (PrivilegedActionException e) {
- throw (ClassNotFoundException) e.getException();
+ return PrivilegedAccessHelper.callDoPrivilegedWithException(
+ () -> Class.forName(clazz)
+ );
+ } catch (ClassNotFoundException ex) {
+ throw ex;
+ } catch (Exception ex) {
+ throw new RuntimeException(String.format("Could not retrieve class %s.", clazz), ex);
}
}
/**
* Retrieves declared fields.
- * <p>
- * If security is enabled, makes {@linkplain java.security.AccessController#doPrivileged(PrivilegedAction)
- * privileged calls}.
*
* @param clazz fields of that class will be returned
* @return array of declared fields
* @see Class#getDeclaredFields()
*/
static Field[] getDeclaredFields(Class<?> clazz) {
- return shouldUsePrivilegedAccess()
- ? doPrivileged(DeclaredFieldsIODH.PREDICATE_ACTION.with(clazz))
- : getDeclaredFieldsInternal(clazz);
+ return PrivilegedAccessHelper.callDoPrivileged(
+ clazz::getDeclaredFields
+ );
}
/**
* Retrieves declared constructors.
*
- * If security is enabled, makes {@linkplain java.security.AccessController#doPrivileged(PrivilegedAction)
- * privileged calls}.
- *
* @param clazz class that will be scanned
* @return declared constructors
* @see Class#getDeclaredConstructors()
*/
static Constructor<?>[] getDeclaredConstructors(Class<?> clazz) {
- return shouldUsePrivilegedAccess()
- ? doPrivileged(DeclaredConstructorsIODH.PREDICATE_ACTION.with(clazz))
- : getDeclaredConstructorsInternal(clazz);
+ return PrivilegedAccessHelper.callDoPrivileged(
+ clazz::getDeclaredConstructors
+ );
}
/**
* Retrieves declared methods.
*
- * If security is enabled, makes {@linkplain java.security.AccessController#doPrivileged(PrivilegedAction)
- * privileged calls}.
- *
* @param clazz class that will be scanned
* @return declared methods
* @see Class#getDeclaredMethods()
*/
static Method[] getDeclaredMethods(Class<?> clazz) {
- return shouldUsePrivilegedAccess()
- ? doPrivileged(DeclaredMethodsIODH.PREDICATE_ACTION.with(clazz))
- : getDeclaredMethodsInternal(clazz);
+ return PrivilegedAccessHelper.callDoPrivileged(
+ clazz::getDeclaredMethods
+ );
}
- /**
- * Retrieves declared method.
- *
- * If security is enabled, makes {@linkplain java.security.AccessController#doPrivileged(PrivilegedAction)
- * privileged calls}.
- *
- * @param clazz class that will be scanned
- * @param name name of the method to be retrieved
- * @param parameterTypes parameter types of the method to be retrieved
- * @return declared method
- * @throws NoSuchMethodException if method was not found
- * @see Class#getDeclaredMethod(String, Class...)
- */
- static Method getDeclaredMethod(Class<?> clazz, String name, Class<?>... parameterTypes) throws
- NoSuchMethodException {
- try {
- return shouldUsePrivilegedAccess()
- ? doPrivileged(DeclaredMethodIODH.PREDICATE_EXCEPTION_ACTION.with(clazz).with(name).with(parameterTypes))
- : getDeclaredMethodInternal(clazz, name, parameterTypes);
- } catch (PrivilegedActionException e) {
- throw (NoSuchMethodException) e.getException();
- }
- }
-
-
- /* Internal Methods */
- /**
- * INTERNAL:
- */
- private static Class<?> forNameInternal(String clazz) throws ClassNotFoundException {
- return Class.forName(clazz);
- }
-
- /**
- * INTERNAL:
- */
- private static Field[] getDeclaredFieldsInternal(Class<?> clazz) {
- return clazz.getDeclaredFields();
- }
-
- /**
- * INTERNAL:
- */
- private static Method[] getDeclaredMethodsInternal(Class<?> clazz) {
- return clazz.getDeclaredMethods();
- }
-
- /**
- * INTERNAL:
- */
- private static Constructor<?>[] getDeclaredConstructorsInternal(Class<?> clazz) {
- return clazz.getDeclaredConstructors();
- }
-
- /**
- * INTERNAL:
- */
- private static Method getDeclaredMethodInternal(Class<?> clazz, String name, Class<?>... parameterTypes) throws
- NoSuchMethodException {
- return clazz.getDeclaredMethod(name, parameterTypes);
- }
-
-
- /* Initialization on Demand Holders */
- /**
- * IODH for enhanced forName privileged action with exception using predicates.
- */
- private static final class ForNameIODH {
-
- /**
- * Enhanced {@link PrivilegedExceptionAction} using predicates.
- * - Singleton.
- * - Throws {@link java.lang.ClassNotFoundException}.
- */
- private static final PredicateWithException<Class<?>> PREDICATE_EXCEPTION_ACTION = new
- PredicateWithException<Class<?>>() {
-
- /* Predicates */
- private String clazz;
-
- @Override
- public PredicateWithException<Class<?>> with(String with) {
- this.clazz = with;
- return this;
- }
-
- @Override
- public PredicateWithException<Class<?>> with(Class<?> with) {
- throw new UnsupportedOperationException();
- }
-
- @Override
- public PredicateWithException<Class<?>> with(Class<?>[] with) {
- throw new UnsupportedOperationException();
- }
-
- @Override
- public Class<?> run() throws NoSuchMethodException, ClassNotFoundException {
- return forNameInternal(clazz);
- }
- };
- }
-
- /**
- * IODH for enhanced getDeclaredFields privileged action using predicates.
- */
- private static final class DeclaredFieldsIODH {
-
- /**
- * Enhanced {@link java.security.PrivilegedAction} using predicates.
- * - Singleton.
- */
- private static final Predicate<Field[]> PREDICATE_ACTION = new Predicate<Field[]>() {
-
- /* Predicates */
- private Class<?> clazz;
-
- @Override
- public Field[] run() {
- return getDeclaredFieldsInternal(clazz);
- }
-
- @Override
- public Predicate<Field[]> with(Class<?> clazz) {
- this.clazz = clazz;
- return this;
- }
- };
- }
-
- /**
- * IODH for getDeclaredMethods privileged action using predicates.
- */
- private static final class DeclaredMethodsIODH {
-
- /**
- * Enhanced {@link PrivilegedAction} using predicates.
- * - Singleton.
- */
- private static final Predicate<Method[]> PREDICATE_ACTION = new
- Predicate<Method[]>() {
-
- /* Predicates */
- private Class<?> clazz;
-
- @Override
- public Predicate<Method[]> with(Class<?> with) {
- this.clazz = with;
- return this;
- }
-
- @Override
- public Method[] run() {
- return getDeclaredMethodsInternal(clazz);
- }
- };
- }
- /**
- * IODH for getDeclaredConstructors privileged action using predicates.
- */
- private static final class DeclaredConstructorsIODH {
-
- /**
- * Enhanced {@link java.security.PrivilegedAction} using predicates.
- * - Singleton.
- */
- private static final Predicate<Constructor<?>[]> PREDICATE_ACTION = new
- Predicate<Constructor<?>[]>() {
-
- /* Predicates */
- private Class<?> clazz;
-
- @Override
- public Predicate<Constructor<?>[]> with(Class<?> with) {
- this.clazz = with;
- return this;
- }
-
- @Override
- public Constructor<?>[] run() {
- return getDeclaredConstructorsInternal(clazz);
- }
- };
- }
-
-
- /**
- * IODH for getMethod predicate wrapped privileged exception action.
- */
- private static final class DeclaredMethodIODH {
-
- /**
- * Enhanced {@link PrivilegedExceptionAction} using predicates.
- * - Singleton.
- * - Throws {@link NoSuchMethodException}.
- */
- private static final PredicateWithException<Method> PREDICATE_EXCEPTION_ACTION = new
- PredicateWithException<Method>() {
-
- /* Predicates */
- private Class<?> clazz;
- private String name;
- private Class<?>[] parameterTypes;
-
- @Override
- public PredicateWithException<Method> with(Class<?> with) {
- this.clazz = with;
- return this;
- }
-
- @Override
- public PredicateWithException<Method> with(String with) {
- this.name = with;
- return this;
- }
-
- @Override
- public PredicateWithException<Method> with(Class<?>[] with) {
- this.parameterTypes = with;
- return this;
- }
-
- @Override
- public Method run() throws NoSuchMethodException {
- return getDeclaredMethodInternal(clazz, name, parameterTypes);
- }
- };
- }
-
-
- /* Inner Interfaces */
-
- /**
- * Predicate-providing wrapper for {@link PrivilegedAction}.
- *
- * @param <T> return type of {@linkplain PrivilegedAction#run() computation}
- */
- private interface Predicate<T> extends PrivilegedAction<T> {
-
- /**
- * Assigns a predicate to the underlying privileged action.
- * Any previous predicate of the same type will be overwritten.
- *
- * @param with predicate
- * @return {@code this}
- */
- Predicate<T> with(Class<?> with);
- }
-
- /**
- * Predicate-providing wrapper for {@link PrivilegedExceptionAction}.
- *
- * @param <T> return type of {@linkplain PrivilegedExceptionAction#run() computation}
- */
- private interface PredicateWithException<T> extends PrivilegedExceptionAction<T> {
-
- /**
- * Assigns a predicate to the underlying privileged exception action.
- * Any previous predicate of the same type will be overwritten.
- *
- * @param with predicate
- * @return {@code this}
- */
- PredicateWithException<T> with(Class<?> with);
-
- /**
- * Assigns a predicate to the underlying privileged exception action.
- * Any previous predicate of the same type will be overwritten.
- *
- * @param with predicate
- * @return {@code this}
- */
- PredicateWithException<T> with(String with);
-
- /**
- * Assigns a predicate to the underlying privileged exception action.
- * Any previous predicate of the same type will be overwritten.
- *
- * @param with predicate
- * @return {@code this}
- */
- PredicateWithException<T> with(Class<?>[] with);
- }
}
diff --git a/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/jaxb/ValidationXMLReader.java b/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/jaxb/ValidationXMLReader.java
index 3c0d1ee..e7e0496 100644
--- a/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/jaxb/ValidationXMLReader.java
+++ b/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/jaxb/ValidationXMLReader.java
@@ -18,8 +18,6 @@
import java.io.IOException;
import java.io.InputStream;
-import java.security.AccessController;
-import java.security.PrivilegedActionException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
@@ -35,7 +33,6 @@
import org.eclipse.persistence.exceptions.BeanValidationException;
import org.eclipse.persistence.internal.helper.XMLHelper;
import org.eclipse.persistence.internal.security.PrivilegedAccessHelper;
-import org.eclipse.persistence.internal.security.PrivilegedGetContextClassLoader;
import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;
@@ -46,9 +43,9 @@
* Strategy:<br>
* 1. Parse validation.xml, looking for a constraints-file reference.<br>
* 2. For each reference, if file is found, parses the constraints file and puts all classes declared under
- * {@literal <bean class="clazz">} into
- * {@link org.eclipse.persistence.jaxb.BeanValidationHelper#constraintsOnClasses}
- * with value {@link Boolean#TRUE}.
+ * {@literal <bean class="clazz">} into {@code constraintsOnClasses} field
+ * of {@link org.eclipse.persistence.jaxb.BeanValidationHelper} class
+ * with {@link Boolean#TRUE} value.
* <p>
* This class contains resources-burdening instance fields (e.g. SAXParser) and as such was designed to be instantiated
* once (make the instance BOUNDED) and have {@link #call()} method called on that instance once.
@@ -74,7 +71,7 @@
private final List<String> constraintsFiles = new ArrayList<>(2);
- private Map<Class<?>, Boolean> constraintsOnClasses = new HashMap<>();
+ private final Map<Class<?>, Boolean> constraintsOnClasses = new HashMap<>();
// Created lazily
private SAXParser saxParser;
@@ -97,12 +94,7 @@
* Checks if validation.xml exists.
*/
public static boolean isValidationXmlPresent() {
- try {
- return getThreadContextClassLoader().getResource(VALIDATION_XML) != null;
- } catch (PrivilegedActionException ignored) {
- LOGGER.log(Level.WARNING, "Loading of " + VALIDATION_XML + " file failed. ", ignored);
- return false;
- }
+ return getThreadContextClassLoader().getResource(VALIDATION_XML) != null;
}
private void parseConstraintFiles() {
@@ -134,7 +126,7 @@
}
@Override
- public void characters(char ch[], int start, int length) throws SAXException {
+ public void characters(char[] ch, int start, int length) throws SAXException {
if (defaultPackageElement) {
defaultPackage = new String(ch, start, length);
defaultPackageElement = false;
@@ -171,17 +163,15 @@
if (validationXml != null) {
getSaxParser().parse(validationXml, handler);
}
- } catch (PrivilegedActionException | SAXException | IOException ignored) {
- LOGGER.log(Level.WARNING, "Parsing of validation.xml failed.", ignored);
+ } catch (SAXException | IOException ex) {
+ LOGGER.log(Level.WARNING, "Parsing of validation.xml failed.", ex);
}
}
- private static ClassLoader getThreadContextClassLoader() throws PrivilegedActionException {
- if (PrivilegedAccessHelper.shouldUsePrivilegedAccess()) {
- return AccessController.doPrivileged(new PrivilegedGetContextClassLoader(Thread.currentThread()));
- } else {
- return Thread.currentThread().getContextClassLoader();
- }
+ private static ClassLoader getThreadContextClassLoader() {
+ return PrivilegedAccessHelper.callDoPrivileged(
+ () -> Thread.currentThread().getContextClassLoader()
+ );
}
private final DefaultHandler validationHandler = new DefaultHandler() {
@@ -189,8 +179,7 @@
private boolean constraintsFileElement = false;
@Override
- public void startElement(String uri, String localName, String qName,
- Attributes attributes) throws SAXException {
+ public void startElement(String uri, String localName, String qName, Attributes attributes) {
if (CONSTRAINT_MAPPING_QNAME.equalsIgnoreCase(qName)) {
constraintsFileElement = true;
@@ -198,7 +187,7 @@
}
@Override
- public void characters(char ch[], int start, int length) throws SAXException {
+ public void characters(char[] ch, int start, int length) {
if (constraintsFileElement) {
constraintsFiles.add(new String(ch, start, length));
diff --git a/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/jaxb/compiler/MappingsGenerator.java b/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/jaxb/compiler/MappingsGenerator.java
index 7fc55f6..248913d 100644
--- a/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/jaxb/compiler/MappingsGenerator.java
+++ b/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/jaxb/compiler/MappingsGenerator.java
@@ -16,8 +16,6 @@
import java.awt.Image;
import java.beans.Introspector;
-import java.security.AccessController;
-import java.security.PrivilegedActionException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Deque;
@@ -35,6 +33,9 @@
import java.util.StringTokenizer;
import java.util.TreeSet;
+import javax.xml.namespace.QName;
+import javax.xml.transform.Source;
+
import jakarta.xml.bind.JAXBElement;
import jakarta.xml.bind.annotation.XmlAttribute;
import jakarta.xml.bind.annotation.XmlMixed;
@@ -42,8 +43,6 @@
import jakarta.xml.bind.annotation.XmlValue;
import jakarta.xml.bind.annotation.adapters.CollapsedStringAdapter;
import jakarta.xml.bind.annotation.adapters.NormalizedStringAdapter;
-import javax.xml.namespace.QName;
-import javax.xml.transform.Source;
import org.eclipse.persistence.config.DescriptorCustomizer;
import org.eclipse.persistence.core.descriptors.CoreDescriptor;
@@ -109,7 +108,6 @@
import org.eclipse.persistence.internal.oxm.record.XMLTransformationRecord;
import org.eclipse.persistence.internal.queries.ContainerPolicy;
import org.eclipse.persistence.internal.security.PrivilegedAccessHelper;
-import org.eclipse.persistence.internal.security.PrivilegedClassForName;
import org.eclipse.persistence.internal.sessions.AbstractSession;
import org.eclipse.persistence.jaxb.JAXBEnumTypeConverter;
import org.eclipse.persistence.jaxb.TypeMappingInfo;
@@ -2109,42 +2107,22 @@
directCollectionMapping.setAttributeAccessor(accessor);
JavaClass componentType = theType.getComponentType();
- try {
- Class<?> declaredClass;
- if (PrivilegedAccessHelper.shouldUsePrivilegedAccess()) {
- try {
- declaredClass = AccessController.doPrivileged(new PrivilegedClassForName<>(componentType.getRawName(), false, helper.getClassLoader()));
- } catch (PrivilegedActionException exception) {
- throw JAXBException.classNotFoundException(componentType.getRawName());
- }
- } else {
- declaredClass = PrivilegedAccessHelper.getClassForName(componentType.getRawName(), false, helper.getClassLoader());
- }
- directCollectionMapping.setAttributeElementClass(declaredClass);
- } catch (ClassNotFoundException e) {
- throw JAXBException.classNotFoundException(componentType.getRawName());
- }
+ Class<?> declaredClass = PrivilegedAccessHelper.callDoPrivilegedWithException(
+ () -> PrivilegedAccessHelper.getClassForName(componentType.getRawName(), false, helper.getClassLoader()),
+ (ex) -> JAXBException.classNotFoundException(componentType.getRawName())
+ );
+ directCollectionMapping.setAttributeElementClass(declaredClass);
}
} else if (helper.isCollectionType(theType)) {
Collection args = theType.getActualTypeArguments();
if (args.size() > 0) {
- JavaClass itemType = (JavaClass)args.iterator().next();
- try {
- Class<?> declaredClass;
- if (PrivilegedAccessHelper.shouldUsePrivilegedAccess()) {
- try {
- declaredClass = AccessController.doPrivileged(new PrivilegedClassForName<>(itemType.getRawName(), false, helper.getClassLoader()));
- } catch (PrivilegedActionException exception) {
- throw JAXBException.classNotFoundException(itemType.getRawName());
- }
- } else {
- declaredClass = PrivilegedAccessHelper.getClassForName(itemType.getRawName(), false, helper.getClassLoader());
- }
- if(declaredClass != String.class){
- directCollectionMapping.setAttributeElementClass(declaredClass);
- }
- } catch (ClassNotFoundException e) {
- throw JAXBException.classNotFoundException(itemType.getRawName());
+ JavaClass itemType = (JavaClass) args.iterator().next();
+ Class<?> declaredClass = PrivilegedAccessHelper.callDoPrivilegedWithException(
+ () -> PrivilegedAccessHelper.getClassForName(itemType.getRawName(), false, helper.getClassLoader()),
+ (ex) -> JAXBException.classNotFoundException(itemType.getRawName())
+ );
+ if (declaredClass != String.class) {
+ directCollectionMapping.setAttributeElementClass(declaredClass);
}
}
}
diff --git a/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/jaxb/compiler/MarshalCallback.java b/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/jaxb/compiler/MarshalCallback.java
index 48e07a4..f8a04b5 100644
--- a/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/jaxb/compiler/MarshalCallback.java
+++ b/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/jaxb/compiler/MarshalCallback.java
@@ -15,14 +15,12 @@
package org.eclipse.persistence.jaxb.compiler;
import java.lang.reflect.Method;
-import java.security.AccessController;
-import java.security.PrivilegedActionException;
import jakarta.xml.bind.Marshaller;
import org.eclipse.persistence.internal.security.PrivilegedAccessHelper;
-import org.eclipse.persistence.internal.security.PrivilegedClassForName;
-import org.eclipse.persistence.internal.security.PrivilegedGetMethod;
+import org.eclipse.persistence.logging.AbstractSessionLog;
+import org.eclipse.persistence.logging.SessionLog;
/**
* INTERNAL:
@@ -62,60 +60,44 @@
}
/**
+ * Initialize information about class based JAXB 2.0 Callback methods.
+ *
+ * @param loader source class loader for {@code domainClass}
*/
public void initialize(ClassLoader loader) {
try {
- if (PrivilegedAccessHelper.shouldUsePrivilegedAccess()){
- try{
- domainClass = AccessController.doPrivileged(new PrivilegedClassForName<>(domainClassName, true, loader));
- }catch (PrivilegedActionException ex){
- if (ex.getCause() instanceof ClassNotFoundException){
- throw (ClassNotFoundException) ex.getCause();
- }
- throw (RuntimeException)ex.getCause();
- }
- }else{
- domainClass = PrivilegedAccessHelper.getClassForName(domainClassName, true, loader);
- }
+ domainClass = PrivilegedAccessHelper.callDoPrivilegedWithException(
+ () -> PrivilegedAccessHelper.getClassForName(domainClassName, true, loader)
+ );
} catch (ClassNotFoundException ex) {
return;
+ } catch (Exception ex) {
+ throw new RuntimeException(String.format("Failed initialization of %s class", domainClassName), ex);
}
Class<?>[] params = new Class<?>[] { Marshaller.class };
if (hasBeforeMarshalCallback) {
try {
- Method beforeMarshal = null;
- if (PrivilegedAccessHelper.shouldUsePrivilegedAccess()){
- try{
- beforeMarshal = AccessController.doPrivileged(new PrivilegedGetMethod(domainClass, "beforeMarshal", params, false));
- }catch (PrivilegedActionException ex){
- if (ex.getCause() instanceof NoSuchMethodException){
- throw (NoSuchMethodException) ex.getCause();
- }
- throw (RuntimeException)ex.getCause();
- }
- }else{
- beforeMarshal = PrivilegedAccessHelper.getMethod(domainClass, "beforeMarshal", params, false);
- }
+ Method beforeMarshal = PrivilegedAccessHelper.callDoPrivilegedWithException(
+ () -> PrivilegedAccessHelper.getMethod(domainClass, "beforeMarshal", params, false)
+ );
setBeforeMarshalCallback(beforeMarshal);
- } catch (NoSuchMethodException nsmex) {}
+ } catch (NoSuchMethodException nsmex) {
+ // Ignore this exception
+ } catch (Exception ex) {
+ throw new RuntimeException(String.format("Failed initialization of beforeMarshal method of %s class", domainClassName), ex);
+ }
}
if (hasAfterMarshalCallback) {
try {
- Method afterMarshal = null;
- if (PrivilegedAccessHelper.shouldUsePrivilegedAccess()){
- try{
- afterMarshal = AccessController.doPrivileged(new PrivilegedGetMethod(domainClass, "afterMarshal", params, false));
- }catch (PrivilegedActionException ex){
- if (ex.getCause() instanceof NoSuchMethodException){
- throw (NoSuchMethodException) ex.getCause();
- }
- throw (RuntimeException)ex.getCause();
- }
- }else{
- afterMarshal = PrivilegedAccessHelper.getMethod(domainClass, "afterMarshal", params, false);
- }
+ Method afterMarshal = PrivilegedAccessHelper.callDoPrivilegedWithException(
+ () -> PrivilegedAccessHelper.getMethod(domainClass, "afterMarshal", params, false)
+ );
setAfterMarshalCallback(afterMarshal);
- } catch (NoSuchMethodException nsmex) {}
+ } catch (NoSuchMethodException nsmex) {
+ // Ignore this exception
+ } catch (Exception ex) {
+ throw new RuntimeException(String.format("Failed initialization of afterMarshal method of %s class", domainClassName), ex);
+ }
}
}
diff --git a/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/jaxb/compiler/UnmarshalCallback.java b/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/jaxb/compiler/UnmarshalCallback.java
index 1c60ccc..37dee1f 100644
--- a/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/jaxb/compiler/UnmarshalCallback.java
+++ b/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/jaxb/compiler/UnmarshalCallback.java
@@ -15,14 +15,12 @@
package org.eclipse.persistence.jaxb.compiler;
import java.lang.reflect.Method;
-import java.security.AccessController;
-import java.security.PrivilegedActionException;
import jakarta.xml.bind.Unmarshaller;
import org.eclipse.persistence.internal.security.PrivilegedAccessHelper;
-import org.eclipse.persistence.internal.security.PrivilegedClassForName;
-import org.eclipse.persistence.internal.security.PrivilegedGetMethod;
+import org.eclipse.persistence.logging.AbstractSessionLog;
+import org.eclipse.persistence.logging.SessionLog;
/**
* INTERNAL:
@@ -62,60 +60,44 @@
}
/**
+ * Initialize information about class based JAXB 2.0 Callback methods.
+ *
+ * @param loader source class loader for {@code domainClass}
*/
public void initialize(ClassLoader loader) {
try {
- if (PrivilegedAccessHelper.shouldUsePrivilegedAccess()){
- try{
- domainClass = AccessController.doPrivileged(new PrivilegedClassForName<>(domainClassName, true, loader));
- }catch (PrivilegedActionException ex){
- if (ex.getCause() instanceof ClassNotFoundException){
- throw (ClassNotFoundException) ex.getCause();
- }
- throw (RuntimeException)ex.getCause();
- }
- }else{
- domainClass = PrivilegedAccessHelper.getClassForName(domainClassName, true, loader);
- }
+ domainClass = PrivilegedAccessHelper.callDoPrivilegedWithException(
+ () -> PrivilegedAccessHelper.getClassForName(domainClassName, true, loader)
+ );
} catch (ClassNotFoundException ex) {
return;
+ } catch (Exception ex) {
+ throw new RuntimeException(String.format("Failed initialization of %s class", domainClassName), ex);
}
Class<?>[] params = new Class<?>[]{ Unmarshaller.class, Object.class };
if (hasBeforeUnmarshalCallback) {
try {
- Method beforeUnmarshal = null;
- if (PrivilegedAccessHelper.shouldUsePrivilegedAccess()){
- try{
- beforeUnmarshal = AccessController.doPrivileged(new PrivilegedGetMethod(domainClass, "beforeUnmarshal", params, false));
- }catch (PrivilegedActionException ex){
- if (ex.getCause() instanceof NoSuchMethodException){
- throw (NoSuchMethodException) ex.getCause();
- }
- throw (RuntimeException)ex.getCause();
- }
- }else{
- beforeUnmarshal = PrivilegedAccessHelper.getMethod(domainClass, "beforeUnmarshal", params, false);
- }
+ Method beforeUnmarshal = PrivilegedAccessHelper.callDoPrivilegedWithException(
+ () -> PrivilegedAccessHelper.getMethod(domainClass, "beforeUnmarshal", params, false)
+ );
setBeforeUnmarshalCallback(beforeUnmarshal);
- } catch (NoSuchMethodException nsmex) {}
+ } catch (NoSuchMethodException nsmex) {
+ // Ignore this exception
+ } catch (Exception ex) {
+ throw new RuntimeException(String.format("Failed initialization of beforeMarshal method of %s class", domainClassName), ex);
+ }
}
if (hasAfterUnmarshalCallback) {
try {
- Method afterUnmarshal = null;
- if (PrivilegedAccessHelper.shouldUsePrivilegedAccess()){
- try{
- afterUnmarshal = AccessController.doPrivileged(new PrivilegedGetMethod(domainClass, "afterUnmarshal", params, false));
- }catch (PrivilegedActionException ex){
- if (ex.getCause() instanceof NoSuchMethodException){
- throw (NoSuchMethodException) ex.getCause();
- }
- throw (RuntimeException)ex.getCause();
- }
- }else{
- afterUnmarshal = PrivilegedAccessHelper.getMethod(domainClass, "afterUnmarshal", params, false);
- }
+ Method afterUnmarshal = PrivilegedAccessHelper.callDoPrivilegedWithException(
+ () -> PrivilegedAccessHelper.getMethod(domainClass, "afterUnmarshal", params, false)
+ );
setAfterUnmarshalCallback(afterUnmarshal);
- } catch (NoSuchMethodException nsmex) {}
+ } catch (NoSuchMethodException nsmex) {
+ // Ignore this exception
+ } catch (Exception ex) {
+ throw new RuntimeException(String.format("Failed initialization of afterMarshal method of %s class", domainClassName), ex);
+ }
}
}
diff --git a/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/jaxb/dynamic/DynamicJAXBContext.java b/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/jaxb/dynamic/DynamicJAXBContext.java
index 6cd6336..a8ab555 100644
--- a/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/jaxb/dynamic/DynamicJAXBContext.java
+++ b/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/jaxb/dynamic/DynamicJAXBContext.java
@@ -17,17 +17,15 @@
import java.io.InputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
-import java.security.AccessController;
-import java.security.PrivilegedAction;
-import java.security.PrivilegedActionException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.StringTokenizer;
-import jakarta.xml.bind.JAXBException;
import javax.xml.transform.stream.StreamSource;
+import jakarta.xml.bind.JAXBException;
+
import org.eclipse.persistence.core.sessions.CoreProject;
import org.eclipse.persistence.descriptors.ClassDescriptor;
import org.eclipse.persistence.dynamic.DynamicClassLoader;
@@ -38,7 +36,6 @@
import org.eclipse.persistence.internal.descriptors.InstantiationPolicy;
import org.eclipse.persistence.internal.jaxb.JaxbClassLoader;
import org.eclipse.persistence.internal.security.PrivilegedAccessHelper;
-import org.eclipse.persistence.internal.security.PrivilegedGetContextClassLoader;
import org.eclipse.persistence.jaxb.compiler.Generator;
import org.eclipse.persistence.jaxb.dynamic.metadata.Metadata;
import org.eclipse.persistence.jaxb.dynamic.metadata.OXMMetadata;
@@ -213,46 +210,30 @@
// ========================================================================
static abstract class DynamicJAXBContextInput extends org.eclipse.persistence.jaxb.JAXBContext.JAXBContextInput {
+
public DynamicJAXBContextInput(Map properties, ClassLoader classLoader) {
super(properties, classLoader);
-
- DynamicClassLoader dClassLoader = null;
-
if (classLoader == null) {
- if (PrivilegedAccessHelper.shouldUsePrivilegedAccess()) {
- try {
- classLoader = AccessController.doPrivileged(new PrivilegedGetContextClassLoader(Thread.currentThread()));
- } catch (PrivilegedActionException pae) {
- //should not be thrown but make sure that when it does, it's properly reported
- throw new RuntimeException(pae);
- }
- } else {
- classLoader = PrivilegedAccessHelper.getContextClassLoader(Thread.currentThread());
- }
+ classLoader = PrivilegedAccessHelper.callDoPrivileged(
+ () -> PrivilegedAccessHelper.getContextClassLoader(Thread.currentThread())
+ );
}
+ final DynamicClassLoader dClassLoader;
if (classLoader instanceof DynamicClassLoader) {
dClassLoader = (DynamicClassLoader) classLoader;
} else {
final ClassLoader parent = classLoader;
- if (PrivilegedAccessHelper.shouldUsePrivilegedAccess()) {
- dClassLoader = AccessController.doPrivileged(new PrivilegedAction<DynamicClassLoader>() {
- @Override
- public DynamicClassLoader run() {
- return new DynamicClassLoader(new JaxbClassLoader(parent));
- }
- });
- } else {
- ClassLoader jaxbLoader = new JaxbClassLoader(parent);
- dClassLoader = new DynamicClassLoader(jaxbLoader);
- }
+ dClassLoader = PrivilegedAccessHelper.callDoPrivileged(
+ () -> new DynamicClassLoader(new JaxbClassLoader(parent))
+ );
}
-
this.classLoader = dClassLoader;
}
public DynamicClassLoader getClassLoader() {
return (DynamicClassLoader) this.classLoader;
}
+
}
static class MetadataContextInput extends DynamicJAXBContextInput {
diff --git a/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/jaxb/plugins/BeanValidationPlugin.java b/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/jaxb/plugins/BeanValidationPlugin.java
index 3cd3d55..5056708 100644
--- a/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/jaxb/plugins/BeanValidationPlugin.java
+++ b/moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/jaxb/plugins/BeanValidationPlugin.java
@@ -14,21 +14,7 @@
// Marcel Valovy - 2.6 - initial implementation
package org.eclipse.persistence.jaxb.plugins;
-import static com.sun.xml.xsom.XSFacet.FACET_FRACTIONDIGITS;
-import static com.sun.xml.xsom.XSFacet.FACET_LENGTH;
-import static com.sun.xml.xsom.XSFacet.FACET_MAXEXCLUSIVE;
-import static com.sun.xml.xsom.XSFacet.FACET_MAXINCLUSIVE;
-import static com.sun.xml.xsom.XSFacet.FACET_MAXLENGTH;
-import static com.sun.xml.xsom.XSFacet.FACET_MINEXCLUSIVE;
-import static com.sun.xml.xsom.XSFacet.FACET_MININCLUSIVE;
-import static com.sun.xml.xsom.XSFacet.FACET_MINLENGTH;
-import static com.sun.xml.xsom.XSFacet.FACET_PATTERN;
-import static com.sun.xml.xsom.XSFacet.FACET_TOTALDIGITS;
-
import java.io.IOException;
-import java.security.AccessController;
-import java.security.PrivilegedActionException;
-import java.security.PrivilegedExceptionAction;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
@@ -45,9 +31,6 @@
import jakarta.xml.bind.annotation.XmlElement;
-import org.xml.sax.ErrorHandler;
-import org.xml.sax.SAXParseException;
-
import com.sun.codemodel.JAnnotationArrayMember;
import com.sun.codemodel.JAnnotationUse;
import com.sun.codemodel.JClass;
@@ -78,6 +61,20 @@
import com.sun.xml.xsom.XSTerm;
import com.sun.xml.xsom.XSType;
import com.sun.xml.xsom.impl.parser.DelayedRef;
+import org.eclipse.persistence.internal.security.PrivilegedAccessHelper;
+import org.xml.sax.ErrorHandler;
+import org.xml.sax.SAXParseException;
+
+import static com.sun.xml.xsom.XSFacet.FACET_FRACTIONDIGITS;
+import static com.sun.xml.xsom.XSFacet.FACET_LENGTH;
+import static com.sun.xml.xsom.XSFacet.FACET_MAXEXCLUSIVE;
+import static com.sun.xml.xsom.XSFacet.FACET_MAXINCLUSIVE;
+import static com.sun.xml.xsom.XSFacet.FACET_MAXLENGTH;
+import static com.sun.xml.xsom.XSFacet.FACET_MINEXCLUSIVE;
+import static com.sun.xml.xsom.XSFacet.FACET_MININCLUSIVE;
+import static com.sun.xml.xsom.XSFacet.FACET_MINLENGTH;
+import static com.sun.xml.xsom.XSFacet.FACET_PATTERN;
+import static com.sun.xml.xsom.XSFacet.FACET_TOTALDIGITS;
/**
@@ -209,7 +206,6 @@
/* ######### CORE FUNCTIONALITY ######### */
private static final String PATTERN_ANNOTATION_NOT_APPLICABLE = "Facet \"pattern\" was detected on a DOM node with non-string base type. Annotation was not generated, because it is not supported by the Bean Validation specification.";
- private final boolean securityEnabled = System.getSecurityManager() != null;
private static final JClass ANNOTATION_VALID;
private static final JClass ANNOTATION_NOTNULL;
@@ -772,18 +768,15 @@
/* ######### GENERAL UTILITIES ######### */
private Class<?> loadClass(String className) {
Class<?> clazz = null;
- if (securityEnabled) try {
- clazz = AccessController.doPrivileged(ForNameActionExecutor.INSTANCE.with(className));
- } catch (PrivilegedActionException ignored) {
- // - Can be only of type ClassNotFoundException, no check needed, see AccessController.doPrivileged().
- /* - ClassNotFoundException for us "means" that the fieldVar is of some unknown class - not an issue to be
- solved by this plugin. */
- }
- else try {
- clazz = loadClassInternal(className);
+ try {
+ clazz = PrivilegedAccessHelper.callDoPrivilegedWithException(
+ () -> Class.forName(className)
+ );
} catch (ClassNotFoundException ignored) {
/* - ClassNotFoundException for us "means" that the fieldVar is of some unknown class - not an issue to be
solved by this plugin. */
+ } catch (Exception ex) {
+ throw new RuntimeException(String.format("Failed loading of %s class", className), ex);
}
return clazz;
}
@@ -945,30 +938,4 @@
}
}
- private static final class ForNameActionExecutor {
-
- private interface PrivilegedExceptionActionWith<T> extends PrivilegedExceptionAction<T> {
- PrivilegedExceptionAction<T> with(String className);
- }
-
- private static final PrivilegedExceptionActionWith<Class<?>> INSTANCE = new PrivilegedExceptionActionWith<Class<?>>() {
- private String className;
-
- @Override
- public Class<?> run() throws ClassNotFoundException {
- return loadClassInternal(className);
- }
-
- @Override
- public PrivilegedExceptionActionWith<Class<?>> with(String className) {
- this.className = className;
- return this;
- }
- };
- }
-
- private static Class<?> loadClassInternal(String className) throws ClassNotFoundException {
- return Class.forName(className);
- }
-
}
diff --git a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/oxm/classloader/JARClassLoader.java b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/oxm/classloader/JARClassLoader.java
index 1d80131..d567853 100644
--- a/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/oxm/classloader/JARClassLoader.java
+++ b/moxy/org.eclipse.persistence.moxy/src/test/java/org/eclipse/persistence/testing/oxm/classloader/JARClassLoader.java
@@ -14,15 +14,16 @@
// Oracle - initial API and implementation from Oracle TopLink
package org.eclipse.persistence.testing.oxm.classloader;
-import java.io.*;
+import java.io.DataInputStream;
+import java.io.File;
+import java.io.IOException;
import java.net.URISyntaxException;
-import java.security.AccessController;
-import java.security.PrivilegedActionException;
-import java.util.*;
-import java.util.zip.*;
+import java.util.Enumeration;
+import java.util.Hashtable;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipFile;
import org.eclipse.persistence.internal.security.PrivilegedAccessHelper;
-import org.eclipse.persistence.internal.security.PrivilegedGetClassLoaderForClass;
/**
@@ -35,7 +36,7 @@
*/
public class JARClassLoader extends ClassLoader {
/** Map each package name to the appropriate JAR file. */
- private Hashtable overridePackageNames;
+ private Hashtable<String, String> overridePackageNames;
/**
* Default constructor - initialize the new instance.
@@ -64,9 +65,7 @@
protected ZipFile buildJARFile(String jarFileName) {
try {
return new ZipFile(new File(Thread.currentThread().getContextClassLoader().getResource(jarFileName).toURI()));
- } catch (IOException e) {
- throw new RuntimeException(e);
- } catch (URISyntaxException e) {
+ } catch (IOException | URISyntaxException e) {
throw new RuntimeException(e);
}
}
@@ -80,7 +79,7 @@
* Return the class for the specified name, leaving it "unresolved".
*/
protected Class<?> customLoadUnresolvedClass(String className) throws ClassNotFoundException {
- String jarFileName = (String) overridePackageNames.get(this.buildPackageName(className));
+ String jarFileName = overridePackageNames.get(this.buildPackageName(className));
ZipFile jarFile = this.buildJARFile(jarFileName);
String url = className.replace('.', '/').concat(".class");
@@ -93,7 +92,6 @@
data = this.loadData(jarFile, jarEntry);
jarFile.close();
} catch (IOException e) {
- Object[] args = {jarFileName, url};
throw new ClassNotFoundException();
}
return this.defineClass(className, data, 0, data.length);
@@ -121,7 +119,7 @@
* Initialize the newly-created instance.
*/
protected void initialize() {
- this.overridePackageNames = new Hashtable();
+ this.overridePackageNames = new Hashtable<>();
}
/**
* Initialize
@@ -182,16 +180,9 @@
if (this.shouldCustomLoad(className)) {
return this.customLoadUnresolvedClass(className);
} else {
- ClassLoader cl = null;
- if (PrivilegedAccessHelper.shouldUsePrivilegedAccess()) {
- try{
- cl = AccessController.doPrivileged(new PrivilegedGetClassLoaderForClass(this.getClass()));
- }catch (PrivilegedActionException ex){
- throw (RuntimeException)ex.getCause();
- }
- }else{
- cl = PrivilegedAccessHelper.getClassLoaderForClass(this.getClass());
- }
+ final ClassLoader cl = PrivilegedAccessHelper.callDoPrivileged(
+ () -> PrivilegedAccessHelper.getClassLoaderForClass(this.getClass())
+ );
if (cl == null) {
// this should only occur under jdk1.1.x
return this.findSystemClass(className);
