diff --git a/jpa/org.eclipse.persistence.jpa/META-INF/MANIFEST.MF b/jpa/org.eclipse.persistence.jpa/META-INF/MANIFEST.MF
index 9811be2..aee8aa5 100644
--- a/jpa/org.eclipse.persistence.jpa/META-INF/MANIFEST.MF
+++ b/jpa/org.eclipse.persistence.jpa/META-INF/MANIFEST.MF
@@ -55,7 +55,6 @@
  javax.transaction.xa;version="1.1.0";resolution:=optional,
  javax.validation;resolution:=optional,
  javax.validation.groups;resolution:=optional,
- javax.validation.metadata;resolution:=optional,
  javax.xml.parsers;resolution:=optional,
  javax.xml.transform;resolution:=optional,
  javax.xml.transform.stream;resolution:=optional,
diff --git a/jpa/org.eclipse.persistence.jpa/src/org/eclipse/persistence/internal/jpa/metadata/listeners/BeanValidationListener.java b/jpa/org.eclipse.persistence.jpa/src/org/eclipse/persistence/internal/jpa/metadata/listeners/BeanValidationListener.java
index 78fc7a1..6c6e8de 100644
--- a/jpa/org.eclipse.persistence.jpa/src/org/eclipse/persistence/internal/jpa/metadata/listeners/BeanValidationListener.java
+++ b/jpa/org.eclipse.persistence.jpa/src/org/eclipse/persistence/internal/jpa/metadata/listeners/BeanValidationListener.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2009, 2016 Sun Microsystems, Inc, IBM Corporation. All rights reserved.
+ * Copyright (c) 2009, 2015 Sun Microsystems, Inc, IBM Corporation. All rights reserved.
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0
  * which accompanies this distribution.
@@ -10,8 +10,6 @@
  * Contributors:
  *     08/20/2014-2.5 Rick Curtis
  *       - 441890: Cache Validator instances.
- *     02/17/2016-2.6 Dalia Abo Sheasha
- *       - 487889: Fix EclipseLink Bean Validation optimization
  *     Marcel Valovy - 2.6 - skip validation of objects that are not constrained.
  ******************************************************************************/
 
@@ -100,11 +98,10 @@
 
     private void validateOnCallbackEvent(DescriptorEvent event, String callbackEventName, Class[] validationGroup) {
         Object source = event.getSource();
-        Validator validator = getValidator(event);
         boolean noOptimization = "true".equalsIgnoreCase((String) event.getSession().getProperty(PersistenceUnitProperties.BEAN_VALIDATION_NO_OPTIMISATION));
-        boolean shouldValidate = noOptimization || validator.getConstraintsForClass(source.getClass()).isBeanConstrained();
+        boolean shouldValidate = noOptimization || beanValidationHelper.isConstrained(source.getClass());
         if (shouldValidate) {
-            Set<ConstraintViolation<Object>> constraintViolations = validator.validate(source, validationGroup);
+            Set<ConstraintViolation<Object>> constraintViolations = getValidator(event).validate(source, validationGroup);
             if (constraintViolations.size() > 0) {
                 // There were errors while call to validate above.
                 // Throw a ConstrainViolationException as required by the spec.
diff --git a/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/beanvalidation/BeanValidationHelperTestCase.java b/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/beanvalidation/BeanValidationHelperTestCase.java
new file mode 100644
index 0000000..ce3a968
--- /dev/null
+++ b/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/beanvalidation/BeanValidationHelperTestCase.java
@@ -0,0 +1,159 @@
+/*******************************************************************************
+ * Copyright (c) 2015  Oracle and/or its affiliates. All rights reserved.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0
+ * which accompanies this distribution.
+ * The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
+ * and the Eclipse Distribution License is available at
+ * http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors:
+ *     Dmitry Kornilov - initial implementation
+ ******************************************************************************/
+package org.eclipse.persistence.testing.jaxb.beanvalidation;
+
+import mockit.Expectations;
+import mockit.Mock;
+import mockit.MockUp;
+import mockit.Mocked;
+import mockit.integration.junit4.JMockit;
+import org.eclipse.persistence.jaxb.BeanValidationHelper;
+import org.eclipse.persistence.jaxb.ValidationXMLReader;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import javax.naming.InitialContext;
+import javax.naming.NamingException;
+import java.util.Map;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+/**
+ * This class contains BeanValidationHelper related tests.
+ *
+ * @author Dmitry Kornilov
+ */
+@RunWith(JMockit.class)
+public class BeanValidationHelperTestCase {
+
+    /**
+     * Tests that validation.xml parsing is not called if validation.xml doesn't exist.
+     */
+    @Test
+    public void testValidationXmlExists(final @Mocked ValidationXMLReader reader) throws NamingException {
+        new Expectations() {{
+            ValidationXMLReader.isValidationXmlPresent(); result = false;
+            new ValidationXMLReader(); times = 0;
+        }};
+
+        BeanValidationHelper beanValidationHelper = new BeanValidationHelper();
+        assertNotNull(beanValidationHelper.getConstraintsMap());
+        assertTrue(beanValidationHelper.getConstraintsMap().size() == 0);
+    }
+
+    /**
+     * Tests that managed executor service doesn't get shutdown.
+     */
+    @Test
+    public void testManagedExecutorService(final @Mocked InitialContext initialContext,
+                                           final @Mocked ExecutorService managedExecutorService,
+                                           final @Mocked ValidationXMLReader reader) throws NamingException {
+        new Expectations() {{
+            ValidationXMLReader.isValidationXmlPresent(); result = true;
+            new InitialContext();
+            initialContext.lookup("java:comp/env/concurrent/ThreadPool"); returns(managedExecutorService);
+            new ValidationXMLReader();
+            managedExecutorService.submit((Callable) any);
+            managedExecutorService.shutdown(); times=0;
+        }};
+
+        new BeanValidationHelper();
+    }
+
+    /**
+     * Tests that JDK executor service gets properly shutdown.
+     */
+    @Test
+    public void testJDKExecutorService(final @Mocked InitialContext initialContext,
+                                       final @Mocked ExecutorService jdkExecutorService,
+                                       final @Mocked ValidationXMLReader reader) throws NamingException {
+        new MockUp<Executors>() {
+            @Mock
+            public ExecutorService newFixedThreadPool(int nThreads) {
+                return jdkExecutorService;
+            }
+        };
+
+        new Expectations() {
+            {
+                ValidationXMLReader.isValidationXmlPresent(); result = true;
+                new InitialContext();
+                initialContext.lookup("java:comp/env/concurrent/ThreadPool"); result = new NamingException();
+                new ValidationXMLReader();
+                jdkExecutorService.submit((Callable) any);
+                jdkExecutorService.shutdown();
+            }
+        };
+
+        new BeanValidationHelper();
+    }
+
+    /**
+     * Tests that validation.xml gets parsed when asynchronous attempt failed.
+     */
+    @Test
+    public void testAsyncParsingFailed(final @Mocked ValidationXMLReader reader) throws Exception {
+        new MockUp<Future<Map<Class<?>, Boolean>>>() {
+            @Mock
+            public Future<Map<Class<?>, Boolean>> get() throws InterruptedException, ExecutionException {
+                throw new InterruptedException();
+            }
+        };
+
+        new Expectations() {{
+            ValidationXMLReader.isValidationXmlPresent(); result = true;
+            new ValidationXMLReader();
+            reader.call();
+        }};
+
+        BeanValidationHelper beanValidationHelper = new BeanValidationHelper();
+        assertNotNull(beanValidationHelper.getConstraintsMap());
+    }
+
+    /**
+     * Tests that validation.xml gets parsed if async task submission failed.
+     */
+    @Test
+    public void testAsyncSubmissionFailed(final @Mocked InitialContext initialContext,
+                                          final @Mocked ExecutorService jdkExecutorService,
+                                          final @Mocked ValidationXMLReader reader) throws Exception {
+        new MockUp<Executors>() {
+            @Mock
+            public ExecutorService newFixedThreadPool(int nThreads) {
+                return jdkExecutorService;
+            }
+        };
+
+        new Expectations() {
+            {
+                ValidationXMLReader.isValidationXmlPresent(); result = true;
+                new InitialContext();
+                initialContext.lookup("java:comp/env/concurrent/ThreadPool"); result = new NamingException();
+                new ValidationXMLReader();
+                jdkExecutorService.submit((Callable) any); result = new OutOfMemoryError();
+                jdkExecutorService.shutdown();
+                new ValidationXMLReader();
+                reader.call();
+            }
+        };
+
+        BeanValidationHelper beanValidationHelper = new BeanValidationHelper();
+        assertNotNull(beanValidationHelper.getConstraintsMap());
+    }
+}
diff --git a/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/beanvalidation/BeanValidationSpecialtiesTestCase.java b/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/beanvalidation/BeanValidationSpecialtiesTestCase.java
index eabb6ea..04e1508 100644
--- a/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/beanvalidation/BeanValidationSpecialtiesTestCase.java
+++ b/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/beanvalidation/BeanValidationSpecialtiesTestCase.java
@@ -32,6 +32,7 @@
 import javax.validation.metadata.ConstraintDescriptor;
 
 import org.eclipse.persistence.exceptions.BeanValidationException;
+import org.eclipse.persistence.jaxb.BeanValidationHelper;
 import org.eclipse.persistence.jaxb.ConstraintViolationWrapper;
 import org.eclipse.persistence.jaxb.JAXBContext;
 import org.eclipse.persistence.jaxb.JAXBContextFactory;
@@ -103,36 +104,36 @@
         }
     }
 
-//    /**
-//     * Tests that we do not skip validation on classes that do not have any bean validation annotations on fields or
-//     * methods but have some on constructors.
-//     */
-//    public void testConstructorAnnotations() throws Exception {
-//        JAXBContext context = (JAXBContext)JAXBContextFactory.createContext(new Class[]{ConstructorAnnotatedEmployee.class}, null);
-//        JAXBMarshaller marshaller = context.createMarshaller();
+    /**
+     * Tests that we do not skip validation on classes that do not have any bean validation annotations on fields or
+     * methods but have some on constructors.
+     */
+    public void testConstructorAnnotations() throws Exception {
+        JAXBContext context = (JAXBContext)JAXBContextFactory.createContext(new Class[]{ConstructorAnnotatedEmployee.class}, null);
+        JAXBMarshaller marshaller = context.createMarshaller();
+
+        ConstructorAnnotatedEmployee employee = new ConstructorAnnotatedEmployee(null);
+
+        try {
+            marshaller.marshal(employee, new StringWriter());
+        } catch (BeanValidationException ignored) {
+        }
+
+        // Ok, HV is not picking up constraints on constructor. But that does not mean anything. Our job is to ensure
+        // that we correctly identify that the class is constrained and pass the object to the underlying BV impl.
+        BeanValidationHelper beanValidationHelper = context.getBeanValidationHelper();
+        assertTrue(beanValidationHelper.getConstraintsMap().containsKey(ConstructorAnnotatedEmployee.class));
+
+        // This will not detect the constraints violation on constructor (on HV 5.1), although it should.
+//        Set<? extends ConstraintViolation<?>> violations = marshaller.getConstraintViolations();
 //
-//        ConstructorAnnotatedEmployee employee = new ConstructorAnnotatedEmployee(null);
+//        assertFalse(violations.isEmpty());
 //
-//        try {
-//            marshaller.marshal(employee, new StringWriter());
-//        } catch (BeanValidationException ignored) {
+//        // For all, i.e. one constraintViolations.
+//        for (ConstraintViolation constraintViolation : violations) {
+//            assertEquals(NOT_NULL_MESSAGE, constraintViolation.getMessageTemplate());
 //        }
-//
-//        // Ok, HV is not picking up constraints on constructor. But that does not mean anything. Our job is to ensure
-//        // that we correctly identify that the class is constrained and pass the object to the underlying BV impl.
-//        BeanValidationHelper beanValidationHelper = context.getBeanValidationHelper();
-//        assertTrue(beanValidationHelper.getConstraintsMap().containsKey(ConstructorAnnotatedEmployee.class));
-//
-//        // This will not detect the constraints violation on constructor (on HV 5.1), although it should.
-////        Set<? extends ConstraintViolation<?>> violations = marshaller.getConstraintViolations();
-////
-////        assertFalse(violations.isEmpty());
-////
-////        // For all, i.e. one constraintViolations.
-////        for (ConstraintViolation constraintViolation : violations) {
-////            assertEquals(NOT_NULL_MESSAGE, constraintViolation.getMessageTemplate());
-////        }
-//    }
+    }
 
     /**
      * Tests {@link org.eclipse.persistence.jaxb.JAXBContextProperties#BEAN_VALIDATION_NO_OPTIMISATION} property.
diff --git a/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/beanvalidation/ValidationXMLTestCase.java b/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/beanvalidation/ValidationXMLTestCase.java
index 4901aaf..bd061ec 100644
--- a/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/beanvalidation/ValidationXMLTestCase.java
+++ b/moxy/eclipselink.moxy.test/src/org/eclipse/persistence/testing/jaxb/beanvalidation/ValidationXMLTestCase.java
@@ -13,8 +13,8 @@
 package org.eclipse.persistence.testing.jaxb.beanvalidation;
 
 import org.eclipse.persistence.exceptions.BeanValidationException;
-import org.eclipse.persistence.internal.cache.AdvancedProcessor;
 import org.eclipse.persistence.jaxb.ConstraintViolationWrapper;
+import org.eclipse.persistence.jaxb.JAXBContext;
 import org.eclipse.persistence.jaxb.JAXBContextFactory;
 import org.eclipse.persistence.jaxb.JAXBMarshaller;
 import org.eclipse.persistence.testing.jaxb.beanvalidation.special.ExternallyConstrainedEmployee;
@@ -26,6 +26,7 @@
 import java.io.File;
 import java.io.IOException;
 import java.io.StringWriter;
+import java.lang.reflect.Field;
 import java.net.URISyntaxException;
 import java.util.Set;
 
@@ -108,6 +109,21 @@
     @Before
     public void setUp() throws Exception {
         createTimeWindow();
+        resetBeanValidation();
+    }
+
+    private void resetBeanValidation() throws Exception {
+        Field beanValidationHelper = JAXBContext.class.getDeclaredField("beanValidationHelper");
+        Field beanValidationPresent = JAXBContext.class.getDeclaredField("beanValidationPresent");
+
+        beanValidationHelper.setAccessible(true);
+        beanValidationPresent.setAccessible(true);
+
+        beanValidationHelper.set(JAXBContext.class, null);
+        beanValidationPresent.set(JAXBContext.class, null);
+
+        beanValidationHelper.setAccessible(false);
+        beanValidationPresent.setAccessible(false);
     }
 
     @After
diff --git a/moxy/org.eclipse.persistence.moxy/src/org/eclipse/persistence/jaxb/BeanValidationHelper.java b/moxy/org.eclipse.persistence.moxy/src/org/eclipse/persistence/jaxb/BeanValidationHelper.java
new file mode 100644
index 0000000..2049fb1
--- /dev/null
+++ b/moxy/org.eclipse.persistence.moxy/src/org/eclipse/persistence/jaxb/BeanValidationHelper.java
@@ -0,0 +1,275 @@
+/*******************************************************************************
+ * Copyright (c) 2015, 2016 Oracle and/or its affiliates. All rights reserved.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0
+ * which accompanies this distribution.
+ * The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
+ * and the Eclipse Distribution License is available at
+ * http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors:
+ *     Marcel Valovy - 2.6 - initial API and implementation
+ *     Dmitry Kornilov - 2.6.1 - removed static maps
+ ******************************************************************************/
+package org.eclipse.persistence.jaxb;
+
+import javax.naming.InitialContext;
+import javax.naming.NamingException;
+import javax.validation.Constraint;
+import javax.validation.Valid;
+import javax.validation.constraints.AssertFalse;
+import javax.validation.constraints.AssertTrue;
+import javax.validation.constraints.DecimalMax;
+import javax.validation.constraints.DecimalMin;
+import javax.validation.constraints.Digits;
+import javax.validation.constraints.Max;
+import javax.validation.constraints.Min;
+import javax.validation.constraints.NotNull;
+import javax.validation.constraints.Past;
+import javax.validation.constraints.Pattern;
+import javax.validation.constraints.Size;
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+
+import org.eclipse.persistence.logging.AbstractSessionLog;
+import org.eclipse.persistence.logging.SessionLog;
+/**
+ * INTERNAL:
+ *
+ * Asynchronously starts validation.xml file processing when created. Holds a map of classes with BV annotations.
+ *
+ * @author Marcel Valovy, Dmitry Kornilov
+ * @since 2.6
+ */
+final public class BeanValidationHelper {
+
+    private Future<Map<Class<?>, Boolean>> future;
+
+    /**
+     * Set of all default BeanValidation field or method annotations and known custom field or method constraints.
+     */
+    private final Set<Class<? extends Annotation>> knownConstraints = new HashSet<>();
+
+    /**
+     * Map of all classes that have undergone check for bean validation constraints.
+     * Maps the key with boolean value telling whether the class contains an annotation from {@link #knownConstraints}.
+     */
+    private Map<Class<?>, Boolean> constraintsOnClasses = null;
+
+    {
+        knownConstraints.add(Valid.class);
+        knownConstraints.add(Max.class);
+        knownConstraints.add(Min.class);
+        knownConstraints.add(DecimalMax.class);
+        knownConstraints.add(DecimalMin.class);
+        knownConstraints.add(Digits.class);
+        knownConstraints.add(NotNull.class);
+        knownConstraints.add(Pattern.class);
+        knownConstraints.add(Size.class);
+        knownConstraints.add(AssertTrue.class);
+        knownConstraints.add(AssertFalse.class);
+        knownConstraints.add(javax.validation.constraints.Future.class);
+        knownConstraints.add(Past.class);
+        knownConstraints.add(Max.List.class);
+        knownConstraints.add(Min.List.class);
+        knownConstraints.add(DecimalMax.List.class);
+        knownConstraints.add(DecimalMin.List.class);
+        knownConstraints.add(Digits.List.class);
+        knownConstraints.add(NotNull.List.class);
+        knownConstraints.add(Pattern.List.class);
+        knownConstraints.add(Size.List.class);
+        knownConstraints.add(AssertTrue.List.class);
+        knownConstraints.add(AssertFalse.List.class);
+        knownConstraints.add(javax.validation.constraints.Future.List.class);
+        knownConstraints.add(Past.List.class);
+    }
+
+    /**
+     * Creates a new instance. Starts asynchronous parsing of validation.xml if it exists.
+     */
+    public BeanValidationHelper() {
+        // Try to run validation.xml parsing asynchronously if validation.xml exists
+        if (ValidationXMLReader.isValidationXmlPresent()) {
+            parseValidationXmlAsync();
+        } else {
+            // validation.xml doesn't exist -> create an empty map
+            constraintsOnClasses = new HashMap<>();
+        }
+    }
+
+    /**
+     * Tells whether any of the class's fields, methods or constructors are constrained by Bean Validation annotations
+     * or custom constraints.
+     *
+     * @param clazz checked class
+     * @return true or false
+     */
+    boolean isConstrained(Class<?> clazz) {
+        Boolean annotated = getConstraintsMap().get(clazz);
+        if (annotated == null) {
+            annotated = detectConstraints(clazz);
+            getConstraintsMap().put(clazz, annotated);
+        }
+        return annotated;
+    }
+
+    /**
+     * Lazy getter for constraintsOnClasses property. Waits until the map is returned by async XML reader.
+     */
+    public Map<Class<?>, Boolean> getConstraintsMap() {
+        if (constraintsOnClasses == null) {
+            if (future == null) {
+                // This happens when submission of async task is failed. Run validation.xml parsing synchronously.
+                constraintsOnClasses = parseValidationXml();
+            } else {
+                // Async task was successfully submitted. get a result from future
+                try {
+                    constraintsOnClasses = future.get();
+                } catch (InterruptedException | ExecutionException e) {
+                    // For some reason the async parsing attempt failed. Call it synchronously.
+                    AbstractSessionLog.getLog().log(SessionLog.WARNING, SessionLog.MOXY, "Error parsing validation.xml the async way", new Object[0], false);
+                    AbstractSessionLog.getLog().logThrowable(SessionLog.WARNING, SessionLog.MOXY, e);
+                    constraintsOnClasses = parseValidationXml();
+                }
+            }
+        }
+        return constraintsOnClasses;
+    }
+
+    /**
+     * Tries to run validation.xml parsing asynchronously.
+     */
+    private void parseValidationXmlAsync() {
+        Executor executor = null;
+        try {
+            executor = createExecutor();
+            future = executor.executorService.submit(new ValidationXMLReader());
+        } catch (Throwable e) {
+            // In the rare cases submitting a task throws OutOfMemoryError. In this case we call validation.xml
+            // parsing lazily when requested
+            AbstractSessionLog.getLog().log(SessionLog.WARNING, SessionLog.MOXY, "Error creating/submitting async validation.xml parsing task.", new Object[0], false);
+            AbstractSessionLog.getLog().logThrowable(SessionLog.WARNING, SessionLog.MOXY, e);
+            future = null;
+        } finally {
+            // Shutdown is needed only for JDK executor
+            if (executor != null && executor.shutdownNeeded) {
+                executor.executorService.shutdown();
+            }
+        }
+    }
+
+    /**
+     * Runs validation.xml parsing synchronously.
+     */
+    private Map<Class<?>, Boolean> parseValidationXml() {
+        final ValidationXMLReader reader = new ValidationXMLReader();
+        Map<Class<?>, Boolean> result;
+        try {
+            result = reader.call();
+        } catch (Exception e) {
+            AbstractSessionLog.getLog().log(SessionLog.WARNING, SessionLog.MOXY, "Error parsing validation.xml synchronously", new Object[0], false);
+            AbstractSessionLog.getLog().logThrowable(SessionLog.WARNING, SessionLog.MOXY, e);
+            result = new HashMap<>();
+        }
+        return result;
+    }
+
+    /**
+     * Reveals whether any of the class's fields or methods are constrained by Bean Validation annotations or custom
+     * constraints.
+     * Uses reflection.
+     */
+    private Boolean detectConstraints(Class<?> clazz) {
+        for (Field f : ReflectionUtils.getDeclaredFields(clazz)) {
+            for (Annotation a : f.getDeclaredAnnotations()) {
+                final Class<? extends Annotation> type = a.annotationType();
+                if (knownConstraints.contains(type)){
+                    return true;
+                }
+                // Check for custom annotations on the field (+ check inheritance on class annotations).
+                // Custom bean validation annotation is defined by having @Constraint annotation on its class.
+                for (Annotation typesClassAnnotation : type.getAnnotations()) {
+                    final Class<? extends Annotation> classAnnotationType = typesClassAnnotation.annotationType();
+                    if (Constraint.class == classAnnotationType) {
+                        knownConstraints.add(type);
+                        return true;
+                    }
+                }
+            }
+        }
+        for (Method m : ReflectionUtils.getDeclaredMethods(clazz)) {
+            for (Annotation a : m.getDeclaredAnnotations()) {
+                final Class<? extends Annotation> type = a.annotationType();
+                if (knownConstraints.contains(type)){
+                    return true;
+                }
+                // Check for custom annotations on the method (+ check inheritance on class annotations).
+                // Custom bean validation annotation is defined by having @Constraint annotation on its class.
+                for (Annotation typesClassAnnotation : type.getAnnotations()) {
+                    final Class<? extends Annotation> classAnnotationType = typesClassAnnotation.annotationType();
+                    if (Constraint.class == classAnnotationType) {
+                        knownConstraints.add(type);
+                        return true;
+                    }
+                }
+            }
+        }
+        for (Constructor<?> c : ReflectionUtils.getDeclaredConstructors(clazz)) {
+            for (Annotation a : c.getDeclaredAnnotations()) {
+                final Class<? extends Annotation> type = a.annotationType();
+                if (knownConstraints.contains(type)){
+                    return true;
+                }
+                // Check for custom annotations on the constructor (+ check inheritance on class annotations).
+                // Custom bean validation annotation is defined by having @Constraint annotation on its class.
+                for (Annotation typesClassAnnotation : type.getAnnotations()) {
+                    final Class<? extends Annotation> classAnnotationType = typesClassAnnotation.annotationType();
+                    if (Constraint.class == classAnnotationType) {
+                        knownConstraints.add(type);
+                        return true;
+                    }
+                }
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Creates an executor service. Tries to get a managed executor service. If failed creates a JDK one.
+     * Sets shutdownNeeded property to true in case JDK executor is created.
+     */
+    private Executor createExecutor() {
+        try {
+            InitialContext jndiCtx = new InitialContext();
+            // type:      javax.enterprise.concurrent.ManagedExecutorService
+            // jndi-name: concurrent/ThreadPool
+            return new Executor((ExecutorService) jndiCtx.lookup("java:comp/env/concurrent/ThreadPool"), false);
+        } catch (NamingException ignored) {
+            // aka continue to proceed with retrieving jdk executor
+        }
+        return new Executor(Executors.newFixedThreadPool(1), true);
+    }
+
+    /**
+     * This class holds a managed or JDK executor instance with a flag indicating do we need to shut it down or not.
+     */
+    private static class Executor {
+        ExecutorService executorService;
+        boolean shutdownNeeded;
+
+        Executor(ExecutorService executorService, boolean shutdownNeeded) {
+            this.executorService = executorService;
+            this.shutdownNeeded = shutdownNeeded;
+        }
+    }
+}
diff --git a/moxy/org.eclipse.persistence.moxy/src/org/eclipse/persistence/jaxb/JAXBBeanValidator.java b/moxy/org.eclipse.persistence.moxy/src/org/eclipse/persistence/jaxb/JAXBBeanValidator.java
index 237e665..a0531c0 100644
--- a/moxy/org.eclipse.persistence.moxy/src/org/eclipse/persistence/jaxb/JAXBBeanValidator.java
+++ b/moxy/org.eclipse.persistence.moxy/src/org/eclipse/persistence/jaxb/JAXBBeanValidator.java
@@ -9,8 +9,6 @@
  *
  * Contributors:
  *     Marcel Valovy - 2.6 - initial implementation
- *     02/17/2016-2.6 Dalia Abo Sheasha
- *       - 487889: Fix EclipseLink Bean Validation optimization
  ******************************************************************************/
 package org.eclipse.persistence.jaxb;
 
@@ -115,8 +113,6 @@
      */
     private boolean stopSearchingForValidator;
 
-    private static boolean buildingFactory;
-
     /**
      * This field will usually be {@code null}. However, user may pass his own instance of
      * {@link javax.validation.ValidatorFactory} to
@@ -173,7 +169,7 @@
     /**
      * PUBLIC:
      *
-     * First, check if validation has been turned off before.
+     * First, if validation has not been turned off before, check if passed value is constrained.
      *
      * Second, depending on Bean Validation Mode, either returns false or tries to initialize Validator:
      *  - AUTO tries to initialize Validator:
@@ -185,8 +181,7 @@
      * BeanValidationMode is fetched from (un)marshaller upon each call.
      * If change in mode is detected, the internal state of the JAXBBeanValidator will be switched.
      *
-     * Third, checks if passed value has any constraints using the Validator. If there are no constraints,
-     * returns false since there is no need to validate.
+     * Third, analyses the value and determines whether validation may be skipped.
      *
      * @param beanValidationMode Bean validation mode - allowed values AUTO, CALLBACK, NONE.
      * @param value validated object. It is passed because validation on some objects may be skipped, 
@@ -209,19 +204,17 @@
 
         this.noOptimisation = noOptimisation;
 
+        if (!isConstrainedObject(value)) return false;
+
         /* Mode or validator factory was changed externally (or it's the first time this method is called). */
-        if (!buildingFactory) {
-            if (this.beanValidationMode != beanValidationMode || this.validatorFactory != preferredValidatorFactory) {
-                this.beanValidationMode = beanValidationMode;
-                this.validatorFactory = (ValidatorFactory) preferredValidatorFactory;
-                changeInternalState();
-            }
+        if (this.beanValidationMode != beanValidationMode || this.validatorFactory != preferredValidatorFactory) {
+            this.beanValidationMode = beanValidationMode;
+            this.validatorFactory = (ValidatorFactory)preferredValidatorFactory;
+            changeInternalState();
         }
 
-        /* If the changeInternalState() call detects that the beanValidationMode is NONE or it fails
-         * to initialize the Validator, we will return false.
-         * Otherwise, we will use the Validator to check if there are constraints on the value. */
-        return canValidate && isConstrainedObject(value);
+        /* Is Validation implementation ready to validate. */
+        return canValidate;
     }
 
     /**
@@ -257,12 +250,9 @@
             return !(value instanceof XmlBindings);
         }
 
-        if (validator == null) {
-            return false;
-        } else {
-            /* Ensure that the class has constraints. If not, skip validation & speed things up. */
-            return validator.getConstraintsForClass(value.getClass()).isBeanConstrained();
-        }
+        /* Ensure that the class contains BV annotations. If not, skip validation & speed things up.
+         * note: This also effectively skips XmlBindings. */
+        return context.getBeanValidationHelper().isConstrained(value.getClass());
     }
 
     /**
@@ -345,9 +335,7 @@
     private boolean initValidator() throws BeanValidationException {
         if (validator == null && !stopSearchingForValidator){
             try {
-                buildingFactory = true;
                 ValidatorFactory factory = getValidatorFactory();
-                buildingFactory = false;
                 validator = factory.getValidator();
                 printValidatorInfo();
             } catch (ValidationException ve) {
diff --git a/moxy/org.eclipse.persistence.moxy/src/org/eclipse/persistence/jaxb/JAXBContext.java b/moxy/org.eclipse.persistence.moxy/src/org/eclipse/persistence/jaxb/JAXBContext.java
index eed7648..6cee732 100644
--- a/moxy/org.eclipse.persistence.moxy/src/org/eclipse/persistence/jaxb/JAXBContext.java
+++ b/moxy/org.eclipse.persistence.moxy/src/org/eclipse/persistence/jaxb/JAXBContext.java
@@ -11,8 +11,6 @@
  *     Oracle - initial API and implementation from Oracle TopLink
  *     Marcel Valovy - 2.6 - added case insensitive unmarshalling property
  *     Dmitry Kornilov - 2.6.1 - BeanValidationHelper refactoring
- *     02/17/2016-2.6 Dalia Abo Sheasha
- *       - 487889: Fix EclipseLink Bean Validation optimization
  ******************************************************************************/
 package org.eclipse.persistence.jaxb;
 
@@ -181,14 +179,19 @@
     private boolean initializedXMLInputFactory = false;
     private JAXBMarshaller jsonSchemaMarshaller;
 
+    private static volatile BeanValidationHelper beanValidationHelper;
+    private static volatile Boolean beanValidationPresent;
+
     protected JAXBContext() {
         super();
         contextState = new JAXBContextState();
+        initBeanValidation();
     }
 
     protected JAXBContext(JAXBContextInput contextInput) throws javax.xml.bind.JAXBException {
         this.contextInput = contextInput;
         this.contextState = contextInput.createContextState();
+        initBeanValidation();
     }
 
     /**
@@ -197,6 +200,7 @@
      */
     public JAXBContext(XMLContext context) {
         contextState = new JAXBContextState(context);
+        initBeanValidation();
     }
 
     /**
@@ -205,6 +209,7 @@
      */
     public JAXBContext(XMLContext context, Generator generator, Type[] boundTypes) {
         contextState = new JAXBContextState(context, generator, boundTypes, null);
+        initBeanValidation();
     }
 
     /**
@@ -213,6 +218,31 @@
      */
     public JAXBContext(XMLContext context, Generator generator, TypeMappingInfo[] boundTypes) {
         contextState = new JAXBContextState(context, generator, boundTypes, null);
+        initBeanValidation();
+    }
+
+    /**
+     * Initializes bean validation if javax.validation.api bundle is on the class path.
+     */
+    private void initBeanValidation() {
+        if (beanValidationPresent == null) {
+            beanValidationPresent = BeanValidationChecker.isBeanValidationPresent();
+        }
+        if (beanValidationPresent && beanValidationHelper == null) {
+            synchronized (JAXBContext.class) {
+                if (beanValidationHelper == null) {
+                    // Bean validation is optional
+                    beanValidationHelper = new BeanValidationHelper();
+                }
+            }
+        }
+    }
+
+    /**
+     * Returns BeanValidationHelper. Can return null if bean validation jar is not on class path.
+     */
+    public BeanValidationHelper getBeanValidationHelper() {
+        return beanValidationHelper;
     }
 
     public XMLInputFactory getXMLInputFactory() {
diff --git a/moxy/org.eclipse.persistence.moxy/src/org/eclipse/persistence/jaxb/ReflectionUtils.java b/moxy/org.eclipse.persistence.moxy/src/org/eclipse/persistence/jaxb/ReflectionUtils.java
new file mode 100644
index 0000000..e5c349a
--- /dev/null
+++ b/moxy/org.eclipse.persistence.moxy/src/org/eclipse/persistence/jaxb/ReflectionUtils.java
@@ -0,0 +1,393 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Oracle and/or its affiliates. All rights reserved.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0
+ * which accompanies this distribution.
+ * The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
+ * and the Eclipse Distribution License is available at
+ * http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors:
+ *     Marcel Valovy - 2.6 - initial implementation
+ ******************************************************************************/
+package org.eclipse.persistence.jaxb;
+
+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;
+
+/**
+ * Utility class for handling reflection calls and using caller sensitive actions.
+ *
+ *  - Singleton lazy-loaded actions honoring Initialization On Demand Holder idiom.
+ *  - Lazy-loaded inner classes and inner interfaces. Only loaded if security is enabled.
+ *
+ * @author Marcel Valovy - marcel.valovy@oracle.com
+ * @since 2.6
+ */
+final class ReflectionUtils {
+
+    /**
+     * Non-instantiable utility class. Reflection instantiation permitted.
+     */
+    private ReflectionUtils() {
+    }
+
+    /**
+     * 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
+     * @see Class#forName(String)
+     */
+    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();
+        }
+    }
+
+    /**
+     * 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);
+    }
+
+    /**
+     * 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);
+    }
+
+    /**
+     * 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);
+    }
+
+    /**
+     * 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/org/eclipse/persistence/jaxb/ValidationXMLReader.java b/moxy/org.eclipse.persistence.moxy/src/org/eclipse/persistence/jaxb/ValidationXMLReader.java
new file mode 100644
index 0000000..1f26595
--- /dev/null
+++ b/moxy/org.eclipse.persistence.moxy/src/org/eclipse/persistence/jaxb/ValidationXMLReader.java
@@ -0,0 +1,208 @@
+/*******************************************************************************
+ * Copyright (c) 2015, 2016 Oracle and/or its affiliates. All rights reserved.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0
+ * which accompanies this distribution.
+ * The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
+ * and the Eclipse Distribution License is available at
+ * http://www.eclipse.org/org/documents/edl-v10.php.
+ * <p/>
+ * Contributors:
+ *      Marcel Valovy - initial API and implementation
+ *      Dmitry Kornilov - BeanValidationHelper refactoring
+ *      Miroslav Kos - BeanValidationHelper refactoring
+ ******************************************************************************/
+package org.eclipse.persistence.jaxb;
+
+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;
+import java.util.Map;
+import java.util.concurrent.Callable;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import javax.xml.parsers.ParserConfigurationException;
+import javax.xml.parsers.SAXParser;
+import javax.xml.parsers.SAXParserFactory;
+
+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;
+
+/**
+ * Detects external Bean Validation configuration.
+ * <p>
+ * 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}.
+ * <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.
+ * <p>
+ * Not suitable for singleton (memory burden). The method #parse() will be invoked only once per class load of this
+ * class. After that the instance and all its fields should be made collectible by GC.
+ *
+ * @author Marcel Valovy
+ * @author Dmitry Kornilov
+ * @author Miroslav Kos
+ * @since 2.6
+ */
+public class ValidationXMLReader implements Callable<Map<Class<?>, Boolean>> {
+
+    public static final String DEFAULT_PACKAGE_QNAME = "default-package";
+    public static final String BEAN_QNAME = "bean";
+    public static final String CONSTRAINT_MAPPING_QNAME = "constraint-mapping";
+    public static final String CLASS_QNAME = "class";
+    public static final String PACKAGE_SEPARATOR = ".";
+
+    private static final String VALIDATION_XML = "META-INF/validation.xml";
+    private static final Logger LOGGER = Logger.getLogger(ValidationXMLReader.class.getName());
+
+    private final List<String> constraintsFiles = new ArrayList<>(2);
+
+    private Map<Class<?>, Boolean> constraintsOnClasses = new HashMap<>();
+
+    // Created lazily
+    private SAXParser saxParser;
+
+    /**
+     * Parses validation.xml.
+     * @return returns a map with classes found in validation.xml as keys and true as a value. Never returns null.
+     */
+    @Override
+    public Map<Class<?>, Boolean> call() throws Exception {
+        parseValidationXML(VALIDATION_XML, validationHandler);
+
+        if (!constraintsFiles.isEmpty()) {
+            parseConstraintFiles();
+        }
+        return constraintsOnClasses;
+    }
+
+    /**
+     * 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;
+        }
+    }
+
+    private void parseConstraintFiles() {
+        final DefaultHandler referencedFileHandler = new DefaultHandler() {
+
+            private boolean defaultPackageElement = false;
+            private String defaultPackage = "";
+
+            @Override
+            public void startElement(String uri, String localName, String qName,
+                                     Attributes attributes) throws SAXException {
+
+                if (DEFAULT_PACKAGE_QNAME.equalsIgnoreCase(qName)) {
+                    defaultPackageElement = true;
+                } else if (BEAN_QNAME.equalsIgnoreCase(qName)) {
+                    String className = defaultPackage + PACKAGE_SEPARATOR + attributes.getValue(CLASS_QNAME);
+                    if (LOGGER.isLoggable(Level.INFO)) {
+                        String msg = "Detected external constraints on class " + className;
+                        LOGGER.info(msg);
+                    }
+                    try {
+                        Class<?> clazz = ReflectionUtils.forName(className);
+                        constraintsOnClasses.put(clazz, Boolean.TRUE);
+                    } catch (ClassNotFoundException e) {
+                        String errMsg = "Loading found class failed. Exception: " + e.getMessage();
+                        LOGGER.warning(errMsg);
+                    }
+                }
+            }
+
+            @Override
+            public void characters(char ch[], int start, int length) throws SAXException {
+                if (defaultPackageElement) {
+                    defaultPackage = new String(ch, start, length);
+                    defaultPackageElement = false;
+                }
+            }
+        };
+
+        // Parse constraints file referenced in validation.xml. Add all classes declared under <bean class="clazz"> to
+        // org.eclipse.persistence.jaxb.BeanValidationHelper#constraintsOnClasses with value Boolean#TRUE.
+        for (String file : constraintsFiles) {
+            parseValidationXML(file, referencedFileHandler);
+        }
+    }
+
+    /**
+     * Lazy getter for SAX parser.
+     */
+    private SAXParser getSaxParser() {
+        if (saxParser == null) {
+            try {
+                SAXParserFactory factory = XMLHelper.createParserFactory(false);
+                saxParser = factory.newSAXParser();
+            } catch (ParserConfigurationException | SAXException e) {
+                String msg = "ValidationXMLReader initialization failed. Exception: " + e.getMessage();
+                LOGGER.severe(msg);
+                throw new BeanValidationException(msg, e);
+            }
+        }
+        return saxParser;
+    }
+
+    private void parseValidationXML(String constraintsFilePath, DefaultHandler handler) {
+        try (InputStream validationXml = getThreadContextClassLoader().getResourceAsStream(constraintsFilePath)) {
+            if (validationXml != null) {
+                getSaxParser().parse(validationXml, handler);
+            }
+        } catch (PrivilegedActionException | SAXException | IOException ignored) {
+            LOGGER.log(Level.WARNING, "Parsing of validation.xml failed.", ignored);
+        }
+    }
+
+    private static ClassLoader getThreadContextClassLoader() throws PrivilegedActionException {
+        if (PrivilegedAccessHelper.shouldUsePrivilegedAccess()) {
+            return AccessController.doPrivileged(new PrivilegedGetContextClassLoader(Thread.currentThread()));
+        } else {
+            return Thread.currentThread().getContextClassLoader();
+        }
+    }
+
+    private final DefaultHandler validationHandler = new DefaultHandler() {
+
+        private boolean constraintsFileElement = false;
+
+        @Override
+        public void startElement(String uri, String localName, String qName,
+                                 Attributes attributes) throws SAXException {
+
+            if (CONSTRAINT_MAPPING_QNAME.equalsIgnoreCase(qName)) {
+                constraintsFileElement = true;
+            }
+        }
+
+        @Override
+        public void characters(char ch[], int start, int length) throws SAXException {
+
+            if (constraintsFileElement) {
+                constraintsFiles.add(new String(ch, start, length));
+                constraintsFileElement = false;
+            }
+        }
+    };
+
+}