/*
* 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.tomcat.util.xreflection;
import java.io.File;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.net.InetAddress;
import java.util.Arrays;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;
import org.apache.tomcat.util.IntrospectionUtils;
public final class ObjectReflectionPropertyInspector {
public static void main(String... args) throws Exception {
if (args.length == 0) {
System.err.println("Usage: " + "org.apache.tomcat.util.xreflection.ObjectReflectionPropertyInspector" +
" <destination directory>");
System.exit(1);
}
File outputDir = new File(args[0]);
if (!outputDir.exists() || !outputDir.isDirectory()) {
System.err.println("Invalid output directory: " + outputDir.getAbsolutePath());
System.exit(1);
}
Set<SetPropertyClass> baseClasses =
getKnownClasses().stream().map(ObjectReflectionPropertyInspector::processClass)
.collect(Collectors.toCollection(LinkedHashSet::new));
generateCode(baseClasses, "org.apache.tomcat.util", outputDir, "XReflectionIntrospectionUtils");
}
private static Set<Class<?>> getKnownClasses() throws ClassNotFoundException {
return Collections.unmodifiableSet(new LinkedHashSet<>(Arrays.asList(
Class.forName("org.apache.catalina.authenticator.jaspic.SimpleAuthConfigProvider"),
Class.forName("org.apache.catalina.authenticator.jaspic.PersistentProviderRegistrations$Property"),
Class.forName("org.apache.catalina.authenticator.jaspic.PersistentProviderRegistrations$Provider"),
Class.forName("org.apache.catalina.connector.Connector"),
Class.forName("org.apache.catalina.core.ContainerBase"),
Class.forName("org.apache.catalina.core.StandardContext"),
Class.forName("org.apache.catalina.core.StandardEngine"),
Class.forName("org.apache.catalina.core.StandardHost"),
Class.forName("org.apache.catalina.core.StandardServer"),
Class.forName("org.apache.catalina.core.StandardService"),
Class.forName("org.apache.catalina.filters.AddDefaultCharsetFilter"),
Class.forName("org.apache.catalina.filters.RestCsrfPreventionFilter"),
Class.forName("org.apache.catalina.loader.ParallelWebappClassLoader"),
Class.forName("org.apache.catalina.loader.WebappClassLoaderBase"),
Class.forName("org.apache.catalina.realm.UserDatabaseRealm"),
Class.forName("org.apache.catalina.valves.AccessLogValve"),
Class.forName("org.apache.coyote.AbstractProtocol"),
Class.forName("org.apache.coyote.ajp.AbstractAjpProtocol"),
Class.forName("org.apache.coyote.ajp.AjpNio2Protocol"),
Class.forName("org.apache.coyote.ajp.AjpNioProtocol"),
Class.forName("org.apache.coyote.http11.AbstractHttp11Protocol"),
Class.forName("org.apache.coyote.http11.Http11Nio2Protocol"),
Class.forName("org.apache.coyote.http11.Http11NioProtocol"),
Class.forName("org.apache.tomcat.util.descriptor.web.ContextResource"),
Class.forName("org.apache.tomcat.util.descriptor.web.ResourceBase"),
Class.forName("org.apache.tomcat.util.modeler.AttributeInfo"),
Class.forName("org.apache.tomcat.util.modeler.FeatureInfo"),
Class.forName("org.apache.tomcat.util.modeler.ManagedBean"),
Class.forName("org.apache.tomcat.util.modeler.OperationInfo"),
Class.forName("org.apache.tomcat.util.modeler.ParameterInfo"),
Class.forName("org.apache.tomcat.util.net.AbstractEndpoint"),
Class.forName("org.apache.tomcat.util.net.AbstractNetworkChannelEndpoint"),
Class.forName("org.apache.tomcat.util.net.Nio2Endpoint"),
Class.forName("org.apache.tomcat.util.net.NioEndpoint"),
Class.forName("org.apache.tomcat.util.net.SocketProperties"))));
}
// types of properties that IntrospectionUtils.setProperty supports
private static final Set<Class<?>> ALLOWED_TYPES = Collections.unmodifiableSet(
new LinkedHashSet<>(Arrays.asList(Boolean.TYPE, Integer.TYPE, Long.TYPE, String.class, InetAddress.class)));
private static final Map<Class<?>,SetPropertyClass> classes = new LinkedHashMap<>();
public static void generateCode(Set<SetPropertyClass> baseClasses, String packageName, File location,
String className) throws Exception {
String packageDirectory = packageName.replace('.', '/');
File sourceFileLocation = new File(location, packageDirectory);
ReflectionLessCodeGenerator.generateCode(sourceFileLocation, className, packageName, baseClasses);
}
private static boolean isAllowedField(Field field) {
return ALLOWED_TYPES.contains(field.getType()) && !Modifier.isFinal(field.getModifiers());
}
private static boolean isAllowedSetMethod(Method method) {
return method.getName().startsWith("set") && method.getParameterTypes().length == 1 &&
ALLOWED_TYPES.contains(method.getParameterTypes()[0]) && !Modifier.isPrivate(method.getModifiers());
}
private static boolean isAllowedGetMethod(Method method) {
return (method.getName().startsWith("get") || method.getName().startsWith("is")) &&
method.getParameterTypes().length == 0 && ALLOWED_TYPES.contains(method.getReturnType()) &&
!Modifier.isPrivate(method.getModifiers());
}
private static SetPropertyClass getOrCreateSetPropertyClass(Class<?> clazz) {
boolean base = (clazz.getSuperclass() == null || clazz.getSuperclass() == Object.class);
SetPropertyClass spc = classes.get(clazz);
if (spc == null) {
spc = new SetPropertyClass(clazz, base ? null : getOrCreateSetPropertyClass(clazz.getSuperclass()));
classes.put(clazz, spc);
}
return spc;
}
static Method findGetter(Class<?> declaringClass, String propertyName) {
for (String getterName : Arrays.asList("get" + IntrospectionUtils.capitalize(propertyName),
"is" + propertyName)) {
try {
Method method = declaringClass.getMethod(getterName);
if (!Modifier.isPrivate(method.getModifiers())) {
return method;
}
} catch (NoSuchMethodException e) {
// Ignore
}
}
try {
Method method = declaringClass.getMethod("getProperty", String.class, String.class);
if (!Modifier.isPrivate(method.getModifiers())) {
return method;
}
} catch (NoSuchMethodException e) {
// Ignore
}
return null;
}
static Method findSetter(Class<?> declaringClass, String propertyName, Class<?> propertyType) {
try {
Method method = declaringClass.getMethod("set" + IntrospectionUtils.capitalize(propertyName), propertyType);
if (!Modifier.isPrivate(method.getModifiers())) {
return method;
}
} catch (NoSuchMethodException e) {
// Ignore
}
try {
Method method = declaringClass.getMethod("setProperty", String.class, String.class);
if (!Modifier.isPrivate(method.getModifiers())) {
return method;
}
} catch (NoSuchMethodException e) {
// Ignore
}
return null;
}
static String decapitalize(String name) {
if (name == null || name.isEmpty()) {
return name;
}
if (name.length() > 1 && Character.isUpperCase(name.charAt(1)) && Character.isUpperCase(name.charAt(0))) {
return name;
}
char[] chars = name.toCharArray();
chars[0] = Character.toLowerCase(chars[0]);
return new String(chars);
}
static SetPropertyClass processClass(Class<?> clazz) {
SetPropertyClass spc = getOrCreateSetPropertyClass(clazz);
final Method[] methods = clazz.getDeclaredMethods();
for (Method method : methods) {
if (isAllowedSetMethod(method)) {
String propertyName = decapitalize(method.getName().substring(3));
Class<?> propertyType = method.getParameterTypes()[0];
Method getter = findGetter(clazz, propertyName);
Method setter = findSetter(clazz, propertyName, propertyType);
ReflectionProperty property =
new ReflectionProperty(spc.getClazz().getName(), propertyName, propertyType, setter, getter);
spc.addProperty(property);
} else if (isAllowedGetMethod(method)) {
boolean startsWithIs = method.getName().startsWith("is");
String propertyName = decapitalize(method.getName().substring(startsWithIs ? 2 : 3));
Class<?> propertyType = method.getReturnType();
Method getter = findGetter(clazz, propertyName);
Method setter = findSetter(clazz, propertyName, propertyType);
ReflectionProperty property =
new ReflectionProperty(spc.getClazz().getName(), propertyName, propertyType, setter, getter);
spc.addProperty(property);
}
}
final Field[] fields = clazz.getDeclaredFields();
for (Field field : fields) {
if (isAllowedField(field)) {
Method getter = findGetter(field.getDeclaringClass(), IntrospectionUtils.capitalize(field.getName()));
Method setter = findSetter(field.getDeclaringClass(), IntrospectionUtils.capitalize(field.getName()),
field.getType());
ReflectionProperty property = new ReflectionProperty(spc.getClazz().getName(), field.getName(),
field.getType(), setter, getter);
spc.addProperty(property);
}
}
if (!spc.isBaseClass()) {
SetPropertyClass parent = getOrCreateSetPropertyClass(spc.getClazz().getSuperclass());
parent.addSubClass(spc);
return processClass(parent.getClazz());
} else {
return spc;
}
}
}