public static Class<?> malform(Class<?> type) throws Exception {
ClassReader classReader = new ClassReader(type.getName());
ClassWriter classWriter = new ClassWriter(classReader, 0);
classReader.accept(new SignatureMalformer(classWriter), 0);
ClassLoader classLoader =
new ByteArrayClassLoader(
null,
Collections.singletonMap(type.getName(), classWriter.toByteArray()),
null,
ByteArrayClassLoader.PersistenceHandler.MANIFEST,
PackageDefinitionStrategy.NoOp.INSTANCE);
return classLoader.loadClass(type.getName());
}
protected byte[] transformClass(byte[] bytes, String clssname) {
InputStream is = getClass().getResourceAsStream("/" + clssname.replace('.', '/') + ".class");
ClassReader orig = null;
try {
ClassReader crRepl = new ClassReader(is);
ClassNode cnRepl = new ClassNode(Opcodes.ASM4);
crRepl.accept(cnRepl, ClassReader.SKIP_FRAMES);
ClassReader crOrig = new ClassReader(bytes);
ClassNode cnOrig = new ClassNode(Opcodes.ASM4);
crOrig.accept(cnOrig, ClassReader.SKIP_FRAMES);
for (Object ofnRepl : cnRepl.fields) {
FieldNode fnRepl = (FieldNode) ofnRepl;
if (hasReplaceAnnotation(fnRepl.visibleAnnotations)) {
FieldNode fnOrig = findField(cnOrig.fields, fnRepl);
if (fnOrig != null) {
cnOrig.fields.remove(fnOrig);
cnOrig.fields.add(cnOrig.fields.size(), scrubField(cnOrig, cnRepl, fnRepl));
}
} else if (hasAddAnnotation(fnRepl.visibleAnnotations)) {
cnOrig.fields.add(cnOrig.fields.size(), scrubField(cnOrig, cnRepl, fnRepl));
}
}
for (Object omnRepl : cnRepl.methods) {
MethodNode mnRepl = (MethodNode) omnRepl;
if (hasReplaceAnnotation(mnRepl.visibleAnnotations)) {
MethodNode mnOrig = findMethod(cnOrig.methods, mnRepl);
if (mnOrig != null) {
cnOrig.methods.remove(mnOrig);
cnOrig.methods.add(cnOrig.methods.size(), scrubMethod(cnOrig, cnRepl, mnRepl));
}
} else if (hasAddAnnotation(mnRepl.visibleAnnotations)) {
cnOrig.methods.add(cnOrig.methods.size() + 1, scrubMethod(cnOrig, cnRepl, mnRepl));
}
}
ClassWriter cwNew = new ClassWriter(ClassWriter.COMPUTE_MAXS | ClassWriter.COMPUTE_FRAMES);
cnOrig.accept(cwNew);
return cwNew.toByteArray();
} catch (IOException e) {
e.printStackTrace(); // To change body of catch statement use File | Settings | File
// Templates.
}
return bytes;
}
private void generateProxyClass(
ClassWriter visitor,
StructSchema<?> viewSchema,
StructSchema<?> delegateSchema,
Collection<String> interfacesToImplement,
Set<Class<?>> typesToDelegate,
Type generatedType,
Type superclassType) {
ModelType<?> viewType = viewSchema.getType();
Class<?> viewClass = viewType.getConcreteClass();
declareClass(visitor, interfacesToImplement, generatedType, superclassType);
declareStateField(visitor);
declareTypeConverterField(visitor);
declareManagedTypeField(visitor);
declareCanCallSettersField(visitor);
writeStaticConstructor(visitor, generatedType, viewClass);
writeConstructor(visitor, generatedType, superclassType, delegateSchema);
writeToString(visitor, generatedType, viewClass, delegateSchema);
writeManagedInstanceMethods(visitor, generatedType);
if (delegateSchema != null) {
declareDelegateField(visitor, delegateSchema);
writeDelegateMethods(visitor, generatedType, delegateSchema, typesToDelegate);
}
writeGroovyMethods(visitor, viewClass);
writePropertyMethods(visitor, generatedType, viewSchema, delegateSchema);
writeHashCodeMethod(visitor, generatedType);
writeEqualsMethod(visitor, generatedType);
visitor.visitEnd();
}
/**
* Construct a proxy generator. This generator is used when we need to create a proxy object for a
* class or an interface given a map of closures.
*
* @param closureMap the delegates implementations
* @param superClass corresponding to the superclass class visitor
* @param interfaces extra interfaces the proxy should implement
* @param proxyLoader the class loader which should be used to load the generated proxy
* @param delegateClass if not null, generate a delegate field with the corresponding class
* @param emptyBody if set to true, the unimplemented abstract methods will receive an empty body
* instead of throwing an {@link UnsupportedOperationException}.
*/
public ProxyGeneratorAdapter(
final Map<Object, Object> closureMap,
final Class superClass,
final Class[] interfaces,
final ClassLoader proxyLoader,
final boolean emptyBody,
final Class delegateClass) {
super(new ClassWriter(0));
this.visitedMethods = new LinkedHashSet<Object>();
this.delegatedClosures =
closureMap.isEmpty() ? EMPTY_DELEGATECLOSURE_MAP : new HashMap<String, Boolean>();
boolean wildcard = false;
for (Map.Entry<Object, Object> entry : closureMap.entrySet()) {
String name = entry.getKey().toString();
if ("*".equals(name)) {
wildcard = true;
}
this.delegatedClosures.put(name, Boolean.FALSE);
}
this.hasWildcard = wildcard;
// if we have to delegate to another object, generate the appropriate delegate field
// and collect the name of the methods for which delegation is active
this.generateDelegateField = delegateClass != null;
this.objectDelegateMethods =
generateDelegateField
? createDelegateMethodList(delegateClass, interfaces)
: EMPTY_STRING_SET;
this.delegateClass = delegateClass;
// a proxy is supposed to be a concrete class, so it cannot extend an interface.
// If the provided superclass is an interface, then we replace the superclass with Object
// and add this interface to the list of implemented interfaces
boolean isSuperClassAnInterface = superClass.isInterface();
this.superClass = isSuperClassAnInterface ? Object.class : superClass;
// create the base list of classes which have possible methods to be overloaded
this.classList = new LinkedList<Class>();
this.classList.add(superClass);
if (generateDelegateField) {
classList.add(delegateClass);
}
if (interfaces != null) {
Collections.addAll(this.classList, interfaces);
}
this.proxyName = proxyName();
this.loader = proxyLoader != null ? new InnerLoader(proxyLoader) : findClassLoader(superClass);
this.emptyBody = emptyBody;
// generate bytecode
ClassWriter writer = (ClassWriter) cv;
ClassReader cr = createClassVisitor(Object.class);
cr.accept(this, 0);
byte[] b = writer.toByteArray();
// CheckClassAdapter.verify(new ClassReader(b), true, new PrintWriter(System.err));
cachedClass = loader.defineClass(proxyName.replace('/', '.'), b);
// cache no-arg constructor
Class[] args =
generateDelegateField ? new Class[] {Map.class, delegateClass} : new Class[] {Map.class};
Constructor constructor;
try {
constructor = cachedClass.getConstructor(args);
} catch (NoSuchMethodException e) {
constructor = null;
}
cachedNoArgConstructor = constructor;
}
