com.sun.faces.application.ConverterPropertyEditorFactory Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of javax.faces Show documentation
Show all versions of javax.faces Show documentation
This is the master POM file for Oracle's Implementation of the JSF 2.2 Specification.
/*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
*
* Copyright (c) 1997-2014 Oracle and/or its affiliates. All rights reserved.
*
* The contents of this file are subject to the terms of either the GNU
* General Public License Version 2 only ("GPL") or the Common Development
* and Distribution License("CDDL") (collectively, the "License"). You
* may not use this file except in compliance with the License. You can
* obtain a copy of the License at
* https://glassfish.java.net/public/CDDL+GPL_1_1.html
* or packager/legal/LICENSE.txt. See the License for the specific
* language governing permissions and limitations under the License.
*
* When distributing the software, include this License Header Notice in each
* file and include the License file at packager/legal/LICENSE.txt.
*
* GPL Classpath Exception:
* Oracle designates this particular file as subject to the "Classpath"
* exception as provided by Oracle in the GPL Version 2 section of the License
* file that accompanied this code.
*
* Modifications:
* If applicable, add the following below the License Header, with the fields
* enclosed by brackets [] replaced by your own identifying information:
* "Portions Copyright [year] [name of copyright owner]"
*
* Contributor(s):
* If you wish your version of this file to be governed by only the CDDL or
* only the GPL Version 2, indicate your decision by adding "[Contributor]
* elects to include this software in this distribution under the [CDDL or GPL
* Version 2] license." If you don't indicate a single choice of license, a
* recipient has the option to distribute your version of this file under
* either the CDDL, the GPL Version 2 or to extend the choice of license to
* its licensees as provided above. However, if you add GPL Version 2 code
* and therefore, elected the GPL Version 2 license, then the option applies
* only if the new code is made subject to such option by the copyright
* holder.
*/
package com.sun.faces.application;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import java.lang.ref.WeakReference;
import java.util.Map;
import java.util.TreeSet;
import java.util.WeakHashMap;
import java.util.HashMap;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.security.AccessController;
import java.security.PrivilegedAction;
import com.sun.faces.util.FacesLogger;
/**
*
* Factory for dynamically generating PropertyEditor classes that extend
* {@link ConverterPropertyEditorBase} and replace any references to the target
* class from the template with a supplied target class.
*
*/
public class ConverterPropertyEditorFactory {
private static final Logger LOGGER = FacesLogger.APPLICATION.getLogger();
/**
*
* Capture information extracted from a "template" PropertyEditor class, and
* perform manipulation of the byte codes in order to generate the bytes for
* a new PropertyEditor class.
*
*
* The new class bytes are generated by identifying UTF8Info entries in the
* constant pool of the template class, and replacing them with new UTF8
* constants to define a new class. The constants to be replaced are those
* for:
*
* - The name of the class itself
* (com/sun/faces/application/ConverterPropertyEditorFor_XXXX).
* - The class name as a type reference
* (Lcom/sun/faces/application/ConverterPropertyEditorFor_XXXX;).
* - The name of the target class that the editor will be
* manipulating (java/util/Date in the current template).
*
*
*/
private static class ClassTemplateInfo {
/**
* Capture details of the location of a UTF8Info entry in the constant
* pool of the template class.
*/
private static class Utf8InfoRef {
/**
* The position of the constant in the byte array that defines the
* template class.
*/
int index;
/**
* The number of bytes that the constant occupies in the byte array
* that defines the template class.
*/
int length;
public Utf8InfoRef(int index, int length) {
super();
this.index = index;
this.length = length;
}
}
/**
* Capture details of a single substitution to be made in the template
* class while generating the new class. Implements
* {@link java.lang.Comparable} so that the replacements can be ordered
* according to the order they appear in the source.
*/
private static class Utf8InfoReplacement implements
Comparable {
/**
* The utf8 constant reference from the template source.
*/
Utf8InfoRef ref;
/**
* The bytes to replace the constant with (must also be a valid utf8
* constant pool entry).
*/
byte[] replacement;
public Utf8InfoReplacement(Utf8InfoRef ref, String replacement) {
super();
this.ref = ref;
this.replacement = getUtf8InfoBytes(replacement);
}
/**
* Order by the index position of the source UTF8Info reference.
*/
@Override
public int compareTo(Utf8InfoReplacement rhs) {
return ref.index - rhs.ref.index;
}
}
// The source template class on which to base the definition of the new
// PropertyEditor classes.
private Class templateClass;
// The bytes that define the source template class.
private byte[] templateBytes;
// The constant_pool_count from the template class bytecodes.
private int constant_pool_count;
// Reference to the class name utf8 constant
private Utf8InfoRef classNameConstant;
// Reference to the class name ref utf8 constant
private Utf8InfoRef classNameRefConstant;
// Reference to the target class name utf8 constant
private Utf8InfoRef targetClassConstant;
/**
* Default constructor uses the {@link ConverterPropertyEditorFor_XXXX}
* class as the source template.
*/
public ClassTemplateInfo() {
this(ConverterPropertyEditorFor_XXXX.class);
}
/**
* Construct a template info instance based on the supplied class.
*
* @param templateClass
* is a "template" class (but not in the java generics sense)
* which must extend {@link ConverterPropertyEditorBase} and
* override the
* {@link ConverterPropertyEditorBase#getTargetClass} method.
*/
public ClassTemplateInfo(
Class templateClass) {
this.templateClass = templateClass;
try {
ConverterPropertyEditorBase tc = templateClass.newInstance();
Class templateTargetClass = tc.getTargetClass();
loadTemplateBytes();
classNameConstant = findConstant(getVMClassName(templateClass));
classNameRefConstant = findConstant(
new StringBuilder(64).append('L').append(getVMClassName(templateClass)).append(';').toString());
targetClassConstant = findConstant(getVMClassName(templateTargetClass));
} catch (InstantiationException | IllegalAccessException | IOException e) {
if (LOGGER.isLoggable(Level.FINE)) {
LOGGER.log(Level.FINE,
"Unexected exception ClassTemplateInfo",
e);
}
}
}
/**
* Check whether the targetBytes match the content of the
* templateBytes at the given index.
*
* @param targetBytes
* byte array to compare.
* @param index
* the index into templateBytes at which to
* compare.
* @return true if the bytes from targetBytes match the
* bytes from templateBytes.
*/
private boolean matchAtIndex(byte[] targetBytes, int index) {
if (index < 0 || index + targetBytes.length > templateBytes.length) {
return false;
}
for (int i = 0; i < targetBytes.length; ++i) {
if (targetBytes[i] != templateBytes[index + i]) {
return false;
}
}
return true;
}
/**
* Find an instance of UTF8Info in the source class's constant pool
* where the text matches the given argument.
*
* @param text
* the text that the UTF8Info must contain.
* @return A {@link Utf8InfoRef} instance refering to the matched
* constant pool entry, or null if no match was
* found.
*/
private Utf8InfoRef findConstant(String text) {
byte[] utf8InfoBytes = getUtf8InfoBytes(text);
assert utf8InfoBytes[0] == 1;
int off = 10;
for (int i = 1; i < constant_pool_count
&& off < templateBytes.length; ++i) {
if (matchAtIndex(utf8InfoBytes, off)) {
return new Utf8InfoRef(off, utf8InfoBytes.length);
}
switch (templateBytes[off]) {
case 1:// CONSTANT_Utf8
{
int len = (templateBytes[off + 1] & 0xff << 8)
+ (templateBytes[off + 2] & 0xff);
off += 3 + len;
break;
}
case 7:// CONSTANT_Class
case 8:// CONSTANT_String
off += 3;
break;
case 3:// CONSTANT_Integer
case 4:// CONSTANT_Float
case 9:// CONSTANT_Fieldref
case 10:// CONSTANT_Methodref
case 11:// CONSTANT_InterfaceMethodref
case 12:// CONSTANT_NameAndType
off += 5;
break;
case 5:// CONSTANT_Long
case 6:// CONSTANT_Double
off += 9;
break;
default:
throw new IllegalArgumentException(
"Unrecognized class file constant pool tag "
+ templateBytes[off]);
}
}
return null;
}
/**
* Obtain the bytes that define the given class by looking for the
* ".class" resource and loading the binary data.
*
* @throws IOException if an error occurs loading the binary data
*/
private void loadTemplateBytes() throws IOException {
String resourceName = '/'
+ templateClass.getName().replace('.', '/') + ".class";
try (InputStream in = ConverterPropertyEditorFactory.class
.getResourceAsStream(resourceName)) {
if (in != null) {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
byte[] buff = new byte[1024];
int more;
while ((more = in.read(buff)) > 0) {
baos.write(buff, 0, more);
}
templateBytes = baos.toByteArray();
// The bytes should start with the CAFEBABE "magic" header
// for class files.
assert templateBytes.length > 9;
assert templateBytes[0] == (byte) 0xCA;
assert templateBytes[1] == (byte) 0xFE;
assert templateBytes[2] == (byte) 0xBA;
assert templateBytes[3] == (byte) 0xBE;
constant_pool_count = ((templateBytes[8] & 0xff) << 8)
+ (templateBytes[9] & 0xff);
}
}
}
/**
* Generate a class name to use for the generated PropertyEditor class,
* based on the full name of the target class. This is done by replacing
* the "XXXX" in the template class name with a version of the target
* class name.
*
* @param targetClass
* The target class which the PropertyEditor will operate on.
* @param vmFormat
* If true, the package name components will be '/'
* separated. Otherwise they will be '.' separated.
* @return The full name to use for the generated PropertyEditor class.
*/
public String generateClassNameFor(Class targetClass,
boolean vmFormat) {
String name = targetClass.getName();
if (targetClass.isArray()) {
int idx = name.lastIndexOf('[');
int bracketCount = idx + 1;
int semiIdx = name.indexOf(';');
if (semiIdx == -1) {
// primitive array
name = PRIM_MAP.get(name.charAt(idx + 1));
} else {
// Object array
name = name.substring(idx + 2, semiIdx);
}
name += "Array" + bracketCount + 'd';
}
Matcher m = UNDERSCORE_PATTERN.matcher(name);
// Replace existing underscores with one extra underscore.
name = m.replaceAll("$0_");
// Replace existing dots with a single underscore.
name = name.replace('.', '_');
if (vmFormat) {
return getVMClassName(templateClass).replace("XXXX", name);
} else {
return templateClass.getName().replace("XXXX", name);
}
}
/**
* Extract the original target class name from the generated
* PropertyEditor class name. (This is the reverse of
* {@link #generateClassNameFor}).
*
* @param className
* name of the generated PropertyEditor class.
* @return the target class name, or null if the given
* className was not a generated PropertyEditor
* name.
*/
public String getTargetClassName(String className) {
String prefix = templateClass.getName().replace("XXXX", "");
if (className.startsWith(prefix)) {
String name = className.substring(prefix.length());
name = SingleUnderscorePattern.matcher(name)
.replaceAll("$1.$2");
name = MultipleUnderscorePattern.matcher(name).replaceAll("$1");
return name;
}
return null;
}
/**
* Generate the bytes for a new class based on the
* templateBytes, but with all the replacements in
* replacements performed.
*
* @param replacements one or more Utf8InfoReplacments
* @return the bytes for the new class definition.
*/
private byte[] replaceInTemplate(Utf8InfoReplacement... replacements) {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
// Sort the replacements, and weed out any that have no source match
TreeSet sorted = new TreeSet<>();
for (Utf8InfoReplacement r : replacements) {
if (r.ref != null && r.replacement != null) {
sorted.add(r);
}
}
// Now create the output bytes by applying the remaining
// replacements
int from = 0;
for (Utf8InfoReplacement r : sorted) {
baos.write(templateBytes, from, r.ref.index - from);
from = r.ref.index + r.ref.length;
baos.write(r.replacement, 0, r.replacement.length);
}
baos.write(templateBytes, from, templateBytes.length - from);
return baos.toByteArray();
}
/**
* @return the bytes for a new class with the given name and target
* class.
*
* @param newClassName
* the binary name of the new class.
* @param targetClassName
* the binary name of the PropertyEditor's target class.
*/
public byte[] generateClassBytesFor(String newClassName,
String targetClassName) {
return replaceInTemplate(new Utf8InfoReplacement(classNameConstant,
newClassName), new Utf8InfoReplacement(classNameRefConstant,
new StringBuilder(32).append('L').append(newClassName).append(';').toString()), new Utf8InfoReplacement(
targetClassConstant, targetClassName));
}
}
/**
*
* A custom class loader for the definition of the generated classes. When
* the generated class is loaded, it will need to be able to resolve both
* the base class ({@link ConverterPropertyEditorBase}) which comes from
* myLoader and the target class which comes from
* targetLoader. This class loader defines only the
* generated class, and delegates to the above two loaders for the rest.
*
*
* The {@link ConverterPropertyEditorFactory} will keep a cache of these
* class loaders (via weak references), one for each class loader that the
* target classes come from. That way the target class loader (which is
* likely to be a webapp specific loader) can be disposed of and replaced
* when the webapp is removed or reinstalled.
*
*/
private class DisposableClassLoader extends ClassLoader {
// The class loader which loaded the target class.
private ClassLoader targetLoader;
// The class loader which loaded the base class
private ClassLoader myLoader;
public DisposableClassLoader(ClassLoader targetLoader) {
super(targetLoader);
this.targetLoader = targetLoader;
this.myLoader = ConverterPropertyEditorBase.class.getClassLoader();
}
/**
* Override class loading to enable possible delegation to the two class
* loaders, rather than just to the parent.
*/
@Override
protected synchronized Class loadClass(String name, boolean resolve)
throws ClassNotFoundException {
// First, check if the class has already been loaded
Class c = findLoadedClass(name);
// Otherwise check if myLoader is able to load it ...
//noinspection ObjectEquality
if ((c == null) && (myLoader != null) && (myLoader != targetLoader)) {
try {
c = myLoader.loadClass(name);
} catch (ClassNotFoundException ignored) {
if (LOGGER.isLoggable(Level.FINEST)) {
LOGGER.log(Level.FINEST, "Ignoring ClassNotFoundException, continuing with parent ClassLoader.", ignored);
}
}
}
// Otherwise go ahead with the targetLoader and with the dynamic
// class generation ...
if (c == null) {
c = super.loadClass(name, false);
}
if (resolve) {
resolveClass(c);
}
return c;
}
/**
* If super.loadClass is unable to locate a class, it
* will call this method to define it. If the className
* is a generated PropertyEditor class name, then create the new class.
* Otherwise call super.findClass which will throw a
* {@link ClassNotFoundException}.
*/
@Override
protected Class findClass(String className)
throws ClassNotFoundException {
String targetClassName = getTemplateInfo().getTargetClassName(
className);
if (targetClassName != null) {
// Need to generate an appropriate PropertyEditor class for the
// specified target class.
byte[] classBytes = getTemplateInfo().generateClassBytesFor(
className.replace('.', '/'),
targetClassName.replace('.', '/'));
Class editorClass = defineClass(className,
classBytes,
0,
classBytes.length);
if (LOGGER.isLoggable(Level.FINE)) {
LOGGER.fine("Defined editorClass " + editorClass);
}
return editorClass;
}
// This will just cause ClassNotFoundException to be thrown.
return super.findClass(className);
}
}
private static final Pattern UNDERSCORE_PATTERN = Pattern.compile("_+");
private static final Pattern SingleUnderscorePattern = Pattern
.compile("([^_])_([^_])");
private static final Pattern MultipleUnderscorePattern = Pattern
.compile("_(_+)");
private static ConverterPropertyEditorFactory defaultInstance;
// Template information extracted from the source template class.
private ClassTemplateInfo templateInfo;
// Cache of DisposableClassLoaders keyed on the class loader of the target.
private Map> classLoaderCache;
private static final Map PRIM_MAP =
new HashMap<>(8, 1.0f);
static {
PRIM_MAP.put('B', "byte");
PRIM_MAP.put('C', "char");
PRIM_MAP.put('S', "short");
PRIM_MAP.put('I', "int");
PRIM_MAP.put('F', "float");
PRIM_MAP.put('J', "long");
PRIM_MAP.put('D', "double");
PRIM_MAP.put('Z', "boolean");
}
/**
* Create a ConverterPropertyEditorFactory that uses the
* default template class ({@link ConverterPropertyEditorFor_XXXX}).
*/
public ConverterPropertyEditorFactory() {
// Use the default template class
templateInfo = new ClassTemplateInfo();
}
/**
* Create a ConverterPropertyEditorFactory that uses the
* specified template class.
*
* @param templateClass the template
*/
public ConverterPropertyEditorFactory(
Class templateClass) {
templateInfo = new ClassTemplateInfo(templateClass);
}
/**
* @return the single default instance of this class (created with the
* default template class).
*/
public static synchronized ConverterPropertyEditorFactory getDefaultInstance() {
if (defaultInstance == null) {
defaultInstance = new ConverterPropertyEditorFactory();
}
return defaultInstance;
}
private ClassTemplateInfo getTemplateInfo() {
return templateInfo;
}
/**
* Return a PropertyEditor class appropriate for editing the given
* targetClass. The new class will be defined from a
* DisposableClassLoader.
*
* @param targetClass
* the class of object that the returned property editor class
* will be editing.
* @return the dynamically generated PropertyEditor class.
*/
@SuppressWarnings("unchecked")
public Class definePropertyEditorClassFor(
final Class targetClass) {
try {
String className = getTemplateInfo().generateClassNameFor(
targetClass, false);
if (classLoaderCache == null) {
// Use a WeakHashMap so as not to prevent the class loaders from
// being garbage collected.
//noinspection CollectionWithoutInitialCapacity
classLoaderCache = new WeakHashMap<>();
}
DisposableClassLoader loader;
WeakReference loaderRef = classLoaderCache
.get(targetClass.getClassLoader());
if (loaderRef == null || (loader = loaderRef.get()) == null) {
loader = (DisposableClassLoader) AccessController.doPrivileged(
new PrivilegedAction() {
@Override
public Object run() {
return new DisposableClassLoader(targetClass.getClassLoader());
}
});
if (loader == null) {
return null;
}
classLoaderCache.put(targetClass.getClassLoader(),
new WeakReference(loader));
}
return (Class) loader
.loadClass(className);
} catch (ClassNotFoundException e) {
if (LOGGER.isLoggable(Level.WARNING)) {
LOGGER.log(Level.WARNING,
"definePropertyEditorClassFor: ClassNotFoundException: "
+ e.getMessage(), e);
}
}
return null;
}
/**
* @param c
* the class to find the name of.
* @return the binary name of the class as used by the VM ('/' instead of
* '.' as a package name separator).
*/
private static String getVMClassName(Class c) {
return c.getName().replace('.', '/');
}
/**
* Create a UTF8Info constant pool structure for the given text.
*
* @param text
* the text to create the UTF8 constant from.
* @return the bytes for the UTF8Info constant pool entry, including the
* tag, length, and utf8 content.
*/
private static byte[] getUtf8InfoBytes(String text) {
byte[] utf8;
try {
utf8 = text.getBytes("UTF-8");
} catch (UnsupportedEncodingException e) {
// The DM_DEFAULT_ENCODING warning is acceptable here
// because we explicitly *want* to use the Java runtime's
// default encoding.
utf8 = text.getBytes();
}
byte[] info = new byte[utf8.length + 3];
info[0] = 1;
info[1] = (byte) ((utf8.length >> 8) & 0xff);
info[2] = (byte) (utf8.length & 0xff);
System.arraycopy(utf8, 0, info, 3, utf8.length);
return info;
}
}