org.apache.bval.jsr303.xml.AnnotationProxyBuilder Maven / Gradle / Ivy
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.bval.jsr303.xml;
import java.lang.annotation.Annotation;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.util.HashMap;
import java.util.Map;
import javax.validation.Payload;
import javax.validation.ValidationException;
import org.apache.bval.jsr303.ConstraintAnnotationAttributes;
import org.apache.bval.jsr303.util.SecureActions;
/**
* Description: Holds the information and creates an annotation proxy during xml
* parsing of validation mapping constraints.
*/
// TODO move this guy up to org.apache.bval.jsr303 or
// org.apache.bval.jsr303.model
final public class AnnotationProxyBuilder {
private final Class type;
private final Map elements = new HashMap();
/**
* Create a new AnnotationProxyBuilder instance.
*
* @param annotationType
*/
public AnnotationProxyBuilder(Class annotationType) {
this.type = annotationType;
}
/**
* Create a new AnnotationProxyBuilder instance.
*
* @param annotationType
* @param elements
*/
public AnnotationProxyBuilder(Class annotationType, Map elements) {
this(annotationType);
for (Map.Entry entry : elements.entrySet()) {
this.elements.put(entry.getKey(), entry.getValue());
}
}
/**
* Create a builder initially configured to create an annotation equivalent
* to annot.
*
* @param annot Annotation to be replicated.
*/
@SuppressWarnings("unchecked")
public AnnotationProxyBuilder(A annot) {
this((Class) annot.annotationType());
// Obtain the "elements" of the annotation
final Method[] methods = doPrivileged(SecureActions.getDeclaredMethods(annot.annotationType()));
for (Method m : methods) {
if (!m.isAccessible()) {
m.setAccessible(true);
}
try {
Object value = m.invoke(annot);
this.elements.put(m.getName(), value);
} catch (IllegalArgumentException e) {
// No args, so should not happen
throw new ValidationException("Cannot access annotation " + annot + " element: " + m.getName());
} catch (IllegalAccessException e) {
throw new ValidationException("Cannot access annotation " + annot + " element: " + m.getName());
} catch (InvocationTargetException e) {
throw new ValidationException("Cannot access annotation " + annot + " element: " + m.getName());
}
}
}
/**
* Add an element to the configuration.
*
* @param elementName
* @param value
*/
public void putValue(String elementName, Object value) {
elements.put(elementName, value);
}
/**
* Get the specified element value from the current configuration.
*
* @param elementName
* @return Object value
*/
public Object getValue(String elementName) {
return elements.get(elementName);
}
/**
* Learn whether a given element has been configured.
*
* @param elementName
* @return true if an elementName element is found
* on this annotation
*/
public boolean contains(String elementName) {
return elements.containsKey(elementName);
}
/**
* Get the number of configured elements.
*
* @return int
*/
public int size() {
return elements.size();
}
/**
* Get the configured Annotation type.
*
* @return Class
*/
public Class getType() {
return type;
}
/**
* Configure the well-known JSR303 "message" element.
*
* @param message
*/
public void setMessage(String message) {
ConstraintAnnotationAttributes.MESSAGE.put(elements, message);
}
/**
* Configure the well-known JSR303 "groups" element.
*
* @param groups
*/
public void setGroups(Class[] groups) {
ConstraintAnnotationAttributes.GROUPS.put(elements, groups);
}
/**
* Configure the well-known JSR303 "payload" element.
*
* @param payload
*/
public void setPayload(Class[] payload) {
ConstraintAnnotationAttributes.PAYLOAD.put(elements, payload);
}
/**
* Create the annotation represented by this builder.
*
* @return {@link Annotation}
*/
public A createAnnotation() {
ClassLoader classLoader = SecureActions.getClassLoader(getType());
@SuppressWarnings("unchecked")
final Class proxyClass = (Class) Proxy.getProxyClass(classLoader, getType());
final InvocationHandler handler = new AnnotationProxy(this);
return doPrivileged(new PrivilegedAction() {
public A run() {
try {
Constructor constructor = proxyClass.getConstructor(InvocationHandler.class);
return constructor.newInstance(handler);
} catch (Exception e) {
throw new ValidationException("Unable to create annotation for configured constraint", e);
}
}
});
}
private static T doPrivileged(final PrivilegedAction action) {
if (System.getSecurityManager() != null) {
return AccessController.doPrivileged(action);
} else {
return action.run();
}
}
}