1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
|
/*******************************************************************************
* Copyright (c) 2009, 2016 Oracle, Inc. 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:
* 08/01/2012-2.5 Chris Delahunt
* - 371950: Metadata caching
******************************************************************************/
package org.eclipse.persistence.internal.jpa.deployment;
import java.security.AccessController;
import java.security.PrivilegedActionException;
import java.util.Map;
import javax.validation.Validation;
import javax.validation.ValidatorFactory;
import org.eclipse.persistence.config.PersistenceUnitProperties;
import org.eclipse.persistence.descriptors.ClassDescriptor;
import org.eclipse.persistence.exceptions.PersistenceUnitLoadingException;
import org.eclipse.persistence.internal.jpa.metadata.listeners.BeanValidationListener;
import org.eclipse.persistence.internal.security.PrivilegedAccessHelper;
import org.eclipse.persistence.internal.security.PrivilegedClassForName;
import org.eclipse.persistence.internal.sessions.AbstractSession;
/**
* Responsible for intialializing Bean Validation. The only expected instance of this interface is the inner class.
* @author Mitesh Meswani
*/
public interface BeanValidationInitializationHelper {
public void bootstrapBeanValidation(Map puProperties, AbstractSession session, ClassLoader appClassLoader);
static class BeanValidationInitializationHelperImpl implements BeanValidationInitializationHelper {
@Override
public void bootstrapBeanValidation(Map puProperties, AbstractSession session, ClassLoader appClassLoader) {
ValidatorFactory validatorFactory = getValidatorFactory(puProperties);
//Check user/environment has specified the validator factory
if (validatorFactory != null) {
// We could obtain a validator factory => Bean Validation API is available at runtime. It is ok to cast now
ValidatorFactory beanValidatorFactory = validatorFactory;
Class[] groupPrePersit = translateValidationGroups(
(String) puProperties.get(PersistenceUnitProperties.VALIDATION_GROUP_PRE_PERSIST), appClassLoader) ;
Class[] groupPreUpdate = translateValidationGroups(
(String) puProperties.get(PersistenceUnitProperties.VALIDATION_GROUP_PRE_UPDATE), appClassLoader);
Class[] groupPreRemove = translateValidationGroups(
(String) puProperties.get(PersistenceUnitProperties.VALIDATION_GROUP_PRE_REMOVE), appClassLoader);
BeanValidationListener validationListener =
new BeanValidationListener(beanValidatorFactory, groupPrePersit, groupPreUpdate, groupPreRemove);
//Install BeanValidationListener on the desc
for (ClassDescriptor descriptor : session.getProject().getOrderedDescriptors()) {
if (descriptor.isDescriptorTypeNormal()) {
//add only to entities
descriptor.getEventManager().addInternalListener(validationListener);
}
}
}
}
/**
* INTERNAL:
* @param puProperties merged properties for this persitence unit
* @return ValidatorFactory instance to be used for this persistence unit.
*/
private ValidatorFactory getValidatorFactory(Map puProperties) {
ValidatorFactory validatorFactory = (ValidatorFactory)puProperties.get(PersistenceUnitProperties.VALIDATOR_FACTORY);
if (validatorFactory == null) {
validatorFactory = Validation.buildDefaultValidatorFactory();
}
return validatorFactory;
}
/**
* INTERNAL:
* translate validation group specified as fully qualifed class names deliminated by ',' into Class[]
* @param validationGroups Array of "," deliminated fully qualified class names
* @param appClassLoader The classloader for application
* @return Array of classes corresponding to classnames in given <code>validationGroups</code>.
* <code>null<code> if given <code>validationGroups</code> is null or empty
*/
private Class[] translateValidationGroups(String validationGroups, ClassLoader appClassLoader) {
Class[] validationGroupsClasses = null;
if(validationGroups != null && validationGroups.length() != 0 ) {
String[] validationGroupClassNames = validationGroups.split(",");
validationGroupsClasses = new Class[validationGroupClassNames.length];
for(int i = 0; i < validationGroupClassNames.length; i++) {
String validationGroupClassName = validationGroupClassNames[i];
try {
validationGroupsClasses[i] = loadClass(validationGroupClassName, appClassLoader);
} catch (Exception e) {
throw PersistenceUnitLoadingException.exceptionLoadingClassWhileInitializingValidationGroups(validationGroupClassName, e);
}
}
}
return validationGroupsClasses;
}
/**
* Internal:
* Helper to load class.
* Please do not make this method protected or public else it would expose a security hole that would
* allow malicious code to use this method to load any class without security permission
* @param className Fully qualified class name
* @param classLoader ClassLoader to be used for loading the class
* @return Loaded Class
* @throws java.security.PrivilegedActionException
* @throws ClassNotFoundException
*/
private Class loadClass(String className, ClassLoader classLoader) throws PrivilegedActionException, ClassNotFoundException {
Class loadedClass = null;
if (PrivilegedAccessHelper.shouldUsePrivilegedAccess()) {
loadedClass = AccessController.doPrivileged(
new PrivilegedClassForName(className, true, classLoader));
} else {
loadedClass = PrivilegedAccessHelper.getClassForName(className, true, classLoader);
}
return loadedClass;
}
}
}
|
