classsaver.java

Java Bytecode Editor 是一个 JAVA 的字节码反汇编和修改器。它可以很方便的修改已经编译成 Class 文件的 JAVA 文件。

			for (int i = 0; i < constants.length; i++) {
				if (i != constantPoolIndex) {
					newPool[j] = constants[i];
					j++;
				}

			}
			cp.setConstantPool(newPool);
			javaClass.setConstantPool(cp);
			javaClass.dump(fileName);

		} catch (IOException ioe) {
			exceptionOccured = true;
			exceptionVerbose = ioe.getMessage();
			ioe.printStackTrace();
		}
	}

	public void removeMethod(String fileName, int methodIndex) {
		try {
			JavaClass javaClass = new ClassParser(fileName).parse();
			Method[] methods = javaClass.getMethods();

			Method[] newMethods = new Method[methods.length - 1];
			int j = 0;
			for (int i = 0; i < methods.length; i++) {
				if (i != methodIndex) {
					newMethods[j] = methods[i];
					j++;
				}

			}
			javaClass.setMethods(newMethods);
			javaClass.dump(fileName);

		} catch (IOException ioe) {
			exceptionOccured = true;
			exceptionVerbose = ioe.getMessage();

			ioe.printStackTrace();
		}
	}

	public void removeField(String fileName, int fieldIndex) {
		try {
			JavaClass javaClass = new ClassParser(fileName).parse();
			Field[] fields = javaClass.getFields();

			Field[] newFields = new Field[fields.length - 1];
			int j = 0;
			for (int i = 0; i < fields.length; i++) {
				if (i != fieldIndex) {
					newFields[j] = fields[i];
					j++;
				}

			}
			javaClass.setFields(newFields);
			javaClass.dump(fileName);

		} catch (IOException ioe) {
			exceptionOccured = true;
			exceptionVerbose = ioe.getMessage();

			ioe.printStackTrace();
		}
	}

	public void removeInterface(String fileName, int interfaceIndex) {
		try {
			JavaClass javaClass = new ClassParser(fileName).parse();
			int[] interfaces = javaClass.getInterfaceIndices();

			int[] newInterfaces = new int[interfaces.length - 1];
			int j = 0;
			for (int i = 0; i < interfaces.length; i++) {
				if (i != interfaceIndex) {
					newInterfaces[j] = interfaces[i];
					j++;
				}

			}
			javaClass.setInterfaces(newInterfaces);
			javaClass.dump(fileName);

		} catch (IOException ioe) {
			exceptionOccured = true;
			exceptionVerbose = ioe.getMessage();

			ioe.printStackTrace();
		}

	}

	public void removeException(String fileName, int methodIndex,
			int exceptionIndex) {

		try {
			JavaClass javaClass = new ClassParser(fileName).parse();
			CodeException[] codeExceptions = javaClass.getMethods()[methodIndex]
					.getCode().getExceptionTable();
			CodeException[] newExceptions = new CodeException[codeExceptions.length - 1];
			int j = 0;
			for (int i = 0; i < codeExceptions.length; i++) {
				if (i != exceptionIndex) {
					newExceptions[j] = codeExceptions[i];
					j++;
				}

			}

			javaClass.getMethods()[methodIndex].getCode().setExceptionTable(
					newExceptions);
			javaClass.dump(fileName);
		} catch (IOException ioe) {
			exceptionOccured = true;
			exceptionVerbose = ioe.getMessage();

			ioe.printStackTrace();
		}

	}

	public void addException(String fileName, int methodIndex, int startPc,
			int endPc, int handlerPc, String handlerClass) {
		JavaClass javaClass;
		try {
			javaClass = new ClassParser(fileName).parse();
			CodeException[] codeExceptions = javaClass.getMethods()[methodIndex]
					.getCode().getExceptionTable();

			// resize the array via creating a new one and using the arraycopy
			CodeException[] newExceptions = new CodeException[codeExceptions.length + 1];
			System.arraycopy(codeExceptions, 0, newExceptions, 0,
					codeExceptions.length);

			// create a constant for handler
			ConstantPool constants = javaClass.getConstantPool();
			ConstantPoolGen cpg = new ConstantPoolGen(constants);
			int handlerIndex = cpg.addClass(handlerClass);
			javaClass.setConstantPool(cpg.getFinalConstantPool());

			CodeException ce = new CodeException(startPc, endPc, handlerPc,
					handlerIndex);
			newExceptions[newExceptions.length - 1] = ce;

			javaClass.getMethods()[methodIndex].getCode().setExceptionTable(
					newExceptions);
			javaClass.dump(fileName);

		} catch (ClassFormatException e) {
			exceptionOccured = true;
			exceptionVerbose = e.getMessage();

			e.printStackTrace();
		} catch (IOException e) {
			exceptionOccured = true;
			exceptionVerbose = e.getMessage();

			e.printStackTrace();
		}

	}

	public void addMethod(String fileName, int accessFlags, String methodName,
			String methodDescriptor) {
		try {

			JavaClass javaClass = new ClassParser(fileName).parse();

			ConstantPool constants = javaClass.getConstantPool();
			ConstantPoolGen cpg = new ConstantPoolGen(constants);

			constants = javaClass.getConstantPool();

			MethodGen methodGen = new MethodGen(accessFlags, methodName,
					methodDescriptor, javaClass.getClassName(),
					new InstructionList(), cpg);
			methodGen.removeLocalVariables();
			methodGen.setMaxLocals();
			methodGen.setMaxStack();
			Method[] oldMethods = javaClass.getMethods();
			Method[] newMethods = new Method[oldMethods.length + 1];
			for (int i = 0; i < oldMethods.length; i++) {
				newMethods[i] = oldMethods[i];
			}
			newMethods[oldMethods.length] = methodGen.getMethod();

			javaClass.setConstantPool(cpg.getFinalConstantPool());
			javaClass.setMethods(newMethods);
			javaClass.dump(fileName);

		} catch (ClassFormatException e) {
			exceptionOccured = true;
			exceptionVerbose = e.getMessage();
			e.printStackTrace();
		} catch (IOException e) {
			exceptionOccured = true;
			exceptionVerbose = e.getMessage();
			e.printStackTrace();
		}
	}

	public void addInterface(String fileName, String interfaceName) {
		try {
			JavaClass javaClass = new ClassParser(fileName).parse();

			ConstantPool constants = javaClass.getConstantPool();
			ConstantPoolGen cpg = new ConstantPoolGen(constants);
			int ref = cpg.addClass(interfaceName);
			int[] interfaces = javaClass.getInterfaceIndices();

			int[] newInterfaces = new int[interfaces.length + 1];
			for (int i = 0; i < interfaces.length; i++) {
				newInterfaces[i] = interfaces[i];
			}
			newInterfaces[interfaces.length] = ref;

			javaClass.setConstantPool(cpg.getFinalConstantPool());
			javaClass.setInterfaces(newInterfaces);
			javaClass.dump(fileName);

		} catch (ClassFormatException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	public void addField(String fileName, String fieldName,
			String fieldDescriptor, int access) {
		try {
			JavaClass javaClass = new ClassParser(fileName).parse();

			ConstantPool constants = javaClass.getConstantPool();
			ConstantPoolGen cpg = new ConstantPoolGen(constants);

			constants = javaClass.getConstantPool();

			FieldGen fieldGen = new FieldGen(access, fieldName,
					fieldDescriptor, cpg);

			Field[] oldFields = javaClass.getFields();
			Field[] newFields = new Field[oldFields.length + 1];
			for (int i = 0; i < oldFields.length; i++) {
				newFields[i] = oldFields[i];
			}
			newFields[oldFields.length] = fieldGen.getField();

			javaClass.setConstantPool(cpg.getFinalConstantPool());
			javaClass.setFields(newFields);
			javaClass.dump(fileName);

		} catch (ClassFormatException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	public void run() {
		if (state == SAVE_MISC) {
			saveMisc(fileName, maxStack, maxLocals, index);
		} else if (state == SAVE_CODE) {
			saveCode(fileName, methodBody, index);
		} else if (state == REMOVE_FIELD) {
			removeField(fileName, index);
		} else if (state == REMOVE_METHOD) {
			removeMethod(fileName, index);
		} else if (state == REMOVE_CONSTANT) {
			removeConstant(fileName, index);
		} else if (state == REMOVE_INTERFACE) {
			removeInterface(fileName, index);
		} else if (state == SAVE_CONSTANT) {
			saveConstant(fileName, constInfo, constType);
		} else if (state == SAVE_EXCEPTION) {
			addException(fileName, index, startPc, endPc, handlerPc,
					handlerClass);
		} else if (state == REMOVE_EXCEPTION) {
			removeException(fileName, index, exceptionIndex);
		} else if (state == ADD_METHOD) {
			addMethod(fileName, accessFlags, methodName, methodDescriptor);
		} else if (state == ADD_INTERFACE) {
			addInterface(fileName, interfaceName);
		} else if (state == ADD_FIELD) {
			addField(fileName, fieldName, fieldDescriptor, accessFlags);
		}

	}

	public boolean exceptionOccured() {
		return exceptionOccured;
	}

	public String getExceptionVerbose() {
		return exceptionVerbose;
	}

}