今天，我回答了一些Java初学者的普通question。稍后我认为认真对待他的问题会很有趣，所以我实现了他想要的东西。
我为运行时类生成创建了一个简单的代码。大多数代码都来自模板，唯一可能的变化是声明一些字段。生成的代码可以写成：
public class Container implements Storage {
private int foo; // user defined (runtime generated)
private Object boo; // user defined (runtime generated)
public Container() {
super();
}
}
然后使用自定义ClassLoader将生成的Class文件加载到JVM中。
然后我实现了像＃34;静态哈希表＆＃34;这样的东西。程序员输入所有可能的键，然后生成一个Class（每个键都作为一个字段）。在我们有这个类的实例的那一刻，我们也可以使用反射保存或读取那些生成的字段。
这是一个完整的代码：
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Hashtable;
import java.util.Random;
class ClassGenerator extends ClassLoader {
private ArrayList<FieldInfo> fields = new ArrayList<ClassGenerator.FieldInfo>();
public static class FieldInfo {
public final String name;
public final Class<?> type;
public FieldInfo(String name, Class<?> type) {
this.name = name;
this.type = type;
}
}
private static class ComponentTypeInfo {
private final Class<?> type;
private final int arrayDimensions;
public ComponentTypeInfo(Class<?> type, int arrayDimensions) {
this.type = type;
this.arrayDimensions = arrayDimensions;
}
}
private static ComponentTypeInfo getComponentType(Class<?> type) {
Class<?> tmp = type;
int array = 0;
while (tmp.isArray()) {
tmp = tmp.getComponentType();
array++;
}
return new ComponentTypeInfo(tmp, array);
}
public static String getFieldDescriptor(Class<?> type) {
ComponentTypeInfo componentTypeInfo = getComponentType(type);
Class<?> componentTypeClass = componentTypeInfo.type;
int componentTypeArray = componentTypeInfo.arrayDimensions;
String result = "";
for (int i = 0; i < componentTypeArray; i++) {
result += "[";
}
if (componentTypeClass.isPrimitive()) {
if (componentTypeClass.equals(byte.class)) return result + "B";
if (componentTypeClass.equals(char.class)) return result + "C";
if (componentTypeClass.equals(double.class)) return result + "D";
if (componentTypeClass.equals(float.class)) return result + "F";
if (componentTypeClass.equals(int.class)) return result + "I";
if (componentTypeClass.equals(long.class)) return result + "J";
if (componentTypeClass.equals(short.class)) return result + "S";
if (componentTypeClass.equals(boolean.class)) return result + "Z";
throw new RuntimeException("Unknown primitive type.");
} else {
return result + "L" + componentTypeClass.getCanonicalName().replace('.', '/') + ";";
}
}
public void addField(String name, Class<?> type) {
this.fields.add(new FieldInfo(name, type));
}
private Class<?> defineClass(byte[] data) {
return this.defineClass(null, data, 0, data.length);
}
private byte[] toBytes(short[] data) {
byte[] result = new byte[data.length];
for (int i = 0; i < data.length; i++) {
result[i] = (byte) data[i];
}
return result;
}
private byte[] toBytes(short value) {
return new byte[]{(byte) (value >> 8), (byte) (value & 0xFF)};
}
public Class<?> getResult() throws IOException {
ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
outputStream.write(toBytes(new short[]{
0xCA, 0xFE, 0xBA, 0xBE, // magic
0x00, 0x00, 0x00, 0x33, // version
}));
// constantPoolCount
outputStream.write(toBytes((short) (0x0C + (this.fields.size() * 2))));
// constantPool
outputStream.write(toBytes(new short[]{
0x01, 0x00, 0x09, 'C', 'o', 'n', 't', 'a', 'i', 'n', 'e', 'r',
0x01, 0x00, 0x10, 'j', 'a', 'v', 'a', '/', 'l', 'a', 'n', 'g', '/', 'O', 'b', 'j', 'e', 'c', 't',
0x01, 0x00, 0x06, '<', 'i', 'n', 'i', 't', '>',
0x01, 0x00, 0x03, '(', ')', 'V',
0x01, 0x00, 0x04, 'C', 'o', 'd', 'e',
0x07, 0x00, 0x01, // class Container
0x07, 0x00, 0x02, // class java/lang/Object
0x0C, 0x00, 0x03, 0x00, 0x04, // nameAndType
0x0A, 0x00, 0x07, 0x00, 0x08, // methodRef
0x01, 0x00, 0x07, 'S', 't', 'o', 'r', 'a', 'g', 'e',
0x07, 0x00, 0x0A, // class Storage
}));
for (FieldInfo field : fields) {
String name = field.name;
String descriptor = getFieldDescriptor(field.type);
byte[] nameBytes = name.getBytes();
byte[] descriptorBytes = descriptor.getBytes();
outputStream.write(0x01);
outputStream.write(toBytes((short) nameBytes.length));
outputStream.write(nameBytes);
outputStream.write(0x01);
outputStream.write(toBytes((short) descriptorBytes.length));
outputStream.write(descriptorBytes);
}
outputStream.write(toBytes(new short[]{
0x00, 0x01, // accessFlags,
0x00, 0x06, // thisClass
0x00, 0x07, // superClass
0x00, 0x01, // interfacesCount
0x00, 0x0B // interface Storage
}));
// fields
outputStream.write(toBytes((short) this.fields.size()));
for (int i = 0; i < fields.size(); i++) {
outputStream.write(new byte[]{0x00, 0x01});
outputStream.write(toBytes((short) (12 + 2 * i)));
outputStream.write(toBytes((short) (12 + 2 * i + 1)));
outputStream.write(new byte[]{0x00, 0x00});
}
// methods and rest of the class file
outputStream.write(toBytes(new short[]{
0x00, 0x01, // methodsCount
// void <init>
0x00, 0x01, // accessFlags
0x00, 0x03, // nameIndex
0x00, 0x04, // descriptorIndex,
0x00, 0x01, // attributesCount
0x00, 0x05, // nameIndex
0x00, 0x00, 0x00, 0x11, // length
0x00, 0x01, // maxStack
0x00, 0x01, // maxLocals,
0x00, 0x00, 0x00, 0x05, // codeLength
0x2A, // aload_0
0xB7, 0x00, 0x09, // invokespecial #9
0xB1, // return
0x00, 0x00, // exceptionTableLength
0x00, 0x00, // attributesCount
0x00, 0x00, // attributesCount
}));
return defineClass(outputStream.toByteArray());
}
}
class SuperTable<T> {
private Class<?> generatedClass = null;
private Storage container = null;
public SuperTable(String[] keys, Class<T> type) {
ClassGenerator classGenerator = new ClassGenerator();
for (String key : keys) {
classGenerator.addField(key, type);
}
try {
this.generatedClass = classGenerator.getResult();
this.container = (Storage) generatedClass.newInstance();
} catch (Exception e) {
throw new RuntimeException(e);
}
}
public void put(String name, Object value) {
try {
this.generatedClass.getDeclaredField(name).set(container, value);
} catch (Exception e) {
throw new RuntimeException("Such a field doesn't exist or is not accessible.");
}
}
public Object get(String name) {
try {
return this.generatedClass.getDeclaredField(name).get(container);
} catch (Exception e) {
throw new RuntimeException("Such a field doesn't exist or is not accessible.");
}
}
}
public class Test {
private static final String[] keys = new String[(int) Math.pow(26, 3)];
private static final Random randomizer = new Random();
static {
int index = 0;
for (char a = 'a'; a <= 'z'; a++) {
for (char b = 'a'; b <= 'z'; b++) {
for (char c = 'a'; c <= 'z'; c++) {
keys[index] = new String(new char[]{a, b, c});
index++;
}
}
}
}
public static float test1(Hashtable<String, Integer> table, long count) {
long time0 = System.currentTimeMillis();
for (long i = 0; i < count; i++) {
boolean step = randomizer.nextBoolean();
String key = keys[randomizer.nextInt(keys.length)];
if (step) {
table.put(key, randomizer.nextInt());
} else {
table.get(key);
}
}
return System.currentTimeMillis() - time0;
}
public static float test2(SuperTable<Integer> table, long count) {
long time0 = System.currentTimeMillis();
for (long i = 0; i < count; i++) {
boolean step = randomizer.nextBoolean();
String key = keys[randomizer.nextInt(keys.length)];
if (step) {
table.put(key, randomizer.nextInt());
} else {
table.get(key);
}
}
return System.currentTimeMillis() - time0;
}
public static void main(String[] args) throws Exception {
Hashtable<String, Integer> table = new Hashtable<String, Integer>();
SuperTable<Integer> table2 = new SuperTable<Integer>(keys, Integer.class);
long count = 500000;
System.out.printf("Hashtable: %f ms\n", test1(table, count));
System.out.printf("SuperTable: %f ms\n", test2(table2, count));
}
}
它有效，但速度非常慢。我预计数据存储在字段中会更快一些，这些字段由JVM操作（使用本机代码）。我能想到的最严重的解释是反思非常缓慢。
为了说清楚，我还是不打算用它。事件，如果它实际上更快，代码是如此可怕和不可维护，它是不值得的。功能也非常有限（密钥必须是有效的字段名称等）。它看起来像是一个很酷的实验。
无论如何，是否有人知道为什么它比普通＆＃34;慢约100倍？哈希表？我想这是由反思引起的，但我会很感激别人的意见。
更新：这真的是由锑和NSF指出的反思引起的。我试图在＆＃34; normal＆＃34;中设置一些静态字段。方式和使用反射。根据这个测试，反射慢约280倍。但我不明白为什么。
答案 0 :(得分：2)
与常规代码相比，反射速度通常要慢一个，因为JVM无法执行某些优化：
http://docs.oracle.com/javase/tutorial/reflect/index.html
你的是一个有趣的方法，但我不敢实用。
此外，测试也可能是一个问题：请注意，两个测试用例是一个接一个地执行的，而第二个测试用例可能会在其中执行。
答案 1 :(得分：2)
好的，我明白了。我认为方法 getDeclaredField 是本机的，JVM将字段存储在某个哈希表中。在这种情况下，我的解决方案可能非常快。
但是， getDeclaredField 不是原生的。不知何故，它将所有声明的字段作为数组获取，然后使用 searchFields 找到正确的字段。
以下是Oracle JDK的摘录：
private Field searchFields(Field[] fields, String name) {
String internedName = name.intern();
for (int i = 0; i < fields.length; i++) {
if (fields[i].getName() == internedName) {
return getReflectionFactory().copyField(fields[i]);
}
}
return null;
}
从我们看到的，它遍历数组并比较名称。
现在它完全有道理。在上面的示例中，有 17 576个字段。当我们假设通常一个字段位于中间的某个位置时，它会为我们提供 8800次迭代来定位字段。
字段的方法 set 和 get 都不是原生的。在某些方面，它必须明显落入本机代码，但它比我预期的要晚得多。
那么，我的代码到底是做什么的？它不是使用某些JVM的内部哈希表（可能甚至不存在），而是在至少一层上使用普通数组。
就这一点而言，即使不照顾其他层，它也必须非常慢 - 而且确实如此。
积分：锑和 NSF 以正确的方式踢。
答案 2 :(得分：1)
首先，Java中的标准反射非常慢。但即使不是，我也不确定为什么你期望这段代码很快。
考虑JIT如何优化此代码，如果它在某种程度上足够智能以优化反射，并且它被编码为针对这种情况进行优化。优化它的最佳方法是构建一个哈希表，其中classname为键，以便在后台查找每个字段。但在那时，你刚刚创建了一个较慢版本的哈希表！这是最好的理想情况！
进一步加剧问题的是JIT旨在优化常见案例。没有人能够做到这一点，所以不太可能进行优化。