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);