Java SignatureAttribute类代码示例

import javassist.bytecode.SignatureAttribute; //导入依赖的package包/类
private void replaceGenericResponseMethods(CtClass clazz)
    throws NotFoundException, CannotCompileException, BadBytecode {
  for (CtMethod method : clazz.getMethods()) {
    if (method.getReturnType().subtypeOf(getGenericResponseClass())) {
      MethodInfo methodInfo = method.getMethodInfo();
      CtMethod replacementMethod = CtNewMethod
          .abstractMethod(
              getResponseClass(), method.getName(), method.getParameterTypes(),
              method.getExceptionTypes(), clazz);

      for (Object attributeInfo : methodInfo.getAttributes()) {
        if (attributeInfo instanceof SignatureAttribute) {
          String sig = transformMethodSignature((SignatureAttribute) attributeInfo);
          replacementMethod.getMethodInfo().addAttribute(
              new SignatureAttribute(((SignatureAttribute) attributeInfo).getConstPool(), sig));
        } else {
          replacementMethod.getMethodInfo().addAttribute((AttributeInfo) attributeInfo);
        }
      }
      clazz.removeMethod(method);
      clazz.addMethod(replacementMethod);
    }
  }
}
 

import javassist.bytecode.SignatureAttribute; //导入依赖的package包/类
private String transformMethodSignature(SignatureAttribute signatureAttribute)
    throws BadBytecode {
  String originalSig = signatureAttribute.getSignature();
  SignatureAttribute.MethodSignature methodSignature =
      SignatureAttribute.toMethodSignature(originalSig);

  SignatureAttribute.ClassType returnType =
      new SignatureAttribute.ClassType("javax.ws.rs.core.Response");
  SignatureAttribute.MethodSignature replacementSignature =
      new SignatureAttribute.MethodSignature(
          methodSignature.getTypeParameters(),
          methodSignature.getParameterTypes(),
          returnType,
          methodSignature.getExceptionTypes());
  return replacementSignature.encode();
}
 

import javassist.bytecode.SignatureAttribute; //导入依赖的package包/类
static Type signatureTypeToType(SignatureAttribute.Type signatureType, TypeSolver typeSolver, TypeParametrizable typeParametrizable) {
    if (signatureType instanceof SignatureAttribute.ClassType) {
        SignatureAttribute.ClassType classType = (SignatureAttribute.ClassType) signatureType;
        List<Type> typeParameters = classType.getTypeArguments() == null ? Collections.emptyList() : Arrays.stream(classType.getTypeArguments()).map(ta -> typeArgumentToType(ta, typeSolver, typeParametrizable)).collect(Collectors.toList());
        final String typeName =
                classType.getDeclaringClass() != null ?
                        classType.getDeclaringClass().getName() + "." + classType.getName() :
                        classType.getName();
        ReferenceTypeDeclaration typeDeclaration = typeSolver.solveType(
                internalNameToCanonicalName(typeName));
        return new ReferenceTypeImpl(typeDeclaration, typeParameters, typeSolver);
    } else if (signatureType instanceof SignatureAttribute.TypeVariable) {
        SignatureAttribute.TypeVariable typeVariableSignature = (SignatureAttribute.TypeVariable)signatureType;
        Optional<TypeParameterDeclaration> typeParameterDeclarationOpt = typeParametrizable.findTypeParameter(typeVariableSignature.getName());
        if (!typeParameterDeclarationOpt.isPresent()) {
            throw new UnsolvedSymbolException("Unable to solve TypeVariable " + typeVariableSignature);
        }
        TypeParameterDeclaration typeParameterDeclaration = typeParameterDeclarationOpt.get();
        return new TypeVariable(typeParameterDeclaration);
    } else {
        throw new RuntimeException(signatureType.getClass().getCanonicalName());
    }
}
 

import javassist.bytecode.SignatureAttribute; //导入依赖的package包/类
@Override
public ParameterDeclaration getParam(int i) {
    try {
        boolean variadic = false;
        if ((ctMethod.getModifiers() & javassist.Modifier.VARARGS) > 0) {
            variadic = i == (ctMethod.getParameterTypes().length - 1);
        }
        if (ctMethod.getGenericSignature() != null) {
            SignatureAttribute.MethodSignature methodSignature = SignatureAttribute.toMethodSignature(ctMethod.getGenericSignature());
            SignatureAttribute.Type signatureType = methodSignature.getParameterTypes()[i];
            return new JavassistParameterDeclaration(JavassistUtils.signatureTypeToType(signatureType, typeSolver, this), typeSolver, variadic);
        } else {
            return new JavassistParameterDeclaration(ctMethod.getParameterTypes()[i], typeSolver, variadic);
        }
    } catch (NotFoundException e) {
        throw new RuntimeException(e);
    } catch (BadBytecode badBytecode) {
        throw new RuntimeException(badBytecode);
    }
}
 

import javassist.bytecode.SignatureAttribute; //导入依赖的package包/类
@Override
public ParameterDeclaration getParam(int i) {
    try {
        boolean variadic = false;
        if ((ctConstructor.getModifiers() & javassist.Modifier.VARARGS) > 0) {
            variadic = i == (ctConstructor.getParameterTypes().length - 1);
        }
        if (ctConstructor.getGenericSignature() != null) {
            SignatureAttribute.MethodSignature methodSignature = SignatureAttribute.toMethodSignature(ctConstructor.getGenericSignature());
            SignatureAttribute.Type signatureType = methodSignature.getParameterTypes()[i];
            return new JavassistParameterDeclaration(JavassistUtils.signatureTypeToType(signatureType, typeSolver, this), typeSolver, variadic);
        } else {
            return new JavassistParameterDeclaration(ctConstructor.getParameterTypes()[i], typeSolver, variadic);
        }
    } catch (NotFoundException e) {
        throw new RuntimeException(e);
    } catch (BadBytecode badBytecode) {
        throw new RuntimeException(badBytecode);
    }
}
 

import javassist.bytecode.SignatureAttribute; //导入依赖的package包/类
@Override
public ResolvedParameterDeclaration getParam(int i) {
    try {
        boolean variadic = false;
        if ((ctMethod.getModifiers() & javassist.Modifier.VARARGS) > 0) {
            variadic = i == (ctMethod.getParameterTypes().length - 1);
        }
        if (ctMethod.getGenericSignature() != null) {
            SignatureAttribute.MethodSignature methodSignature = SignatureAttribute.toMethodSignature(ctMethod.getGenericSignature());
            SignatureAttribute.Type signatureType = methodSignature.getParameterTypes()[i];
            return new JavassistParameterDeclaration(JavassistUtils.signatureTypeToType(signatureType, typeSolver, this), typeSolver, variadic);
        } else {
            return new JavassistParameterDeclaration(ctMethod.getParameterTypes()[i], typeSolver, variadic);
        }
    } catch (NotFoundException e) {
        throw new RuntimeException(e);
    } catch (BadBytecode badBytecode) {
        throw new RuntimeException(badBytecode);
    }
}
 

import javassist.bytecode.SignatureAttribute; //导入依赖的package包/类
@Override
public ResolvedParameterDeclaration getParam(int i) {
    try {
        boolean variadic = false;
        if ((ctConstructor.getModifiers() & javassist.Modifier.VARARGS) > 0) {
            variadic = i == (ctConstructor.getParameterTypes().length - 1);
        }
        if (ctConstructor.getGenericSignature() != null) {
            SignatureAttribute.MethodSignature methodSignature = SignatureAttribute.toMethodSignature(ctConstructor.getGenericSignature());
            SignatureAttribute.Type signatureType = methodSignature.getParameterTypes()[i];
            return new JavassistParameterDeclaration(JavassistUtils.signatureTypeToType(signatureType, typeSolver, this), typeSolver, variadic);
        } else {
            return new JavassistParameterDeclaration(ctConstructor.getParameterTypes()[i], typeSolver, variadic);
        }
    } catch (NotFoundException e) {
        throw new RuntimeException(e);
    } catch (BadBytecode badBytecode) {
        throw new RuntimeException(badBytecode);
    }
}
 

import javassist.bytecode.SignatureAttribute; //导入依赖的package包/类
@SuppressWarnings("unchecked")
private static void renameAttributes(List<AttributeInfo> attributes, ReplacerClassMap map, SignatureType type) {
	try {
		
		// make the rename class method accessible
		Method renameClassMethod = AttributeInfo.class.getDeclaredMethod("renameClass", Map.class);
		renameClassMethod.setAccessible(true);
		
		for (AttributeInfo attribute : attributes) {
			if (attribute instanceof SignatureAttribute) {
				// this has to be handled specially because SignatureAttribute.renameClass() is buggy as hell
				SignatureAttribute signatureAttribute = (SignatureAttribute)attribute;
				String newSignature = type.rename(signatureAttribute.getSignature(), map);
				if (newSignature != null) {
					signatureAttribute.setSignature(newSignature);
				}
			} else if (attribute instanceof CodeAttribute) {
				// code attributes have signature attributes too (indirectly)
				CodeAttribute codeAttribute = (CodeAttribute)attribute;
				renameAttributes(codeAttribute.getAttributes(), map, type);
			} else if (attribute instanceof LocalVariableTypeAttribute) {
				// lvt attributes have signature attributes too
				LocalVariableTypeAttribute localVariableAttribute = (LocalVariableTypeAttribute)attribute;
				renameLocalVariableTypeAttribute(localVariableAttribute, map);
			} else {
				renameClassMethod.invoke(attribute, map);
			}
		}
		
	} catch(NoSuchMethodException | IllegalAccessException | IllegalArgumentException | InvocationTargetException ex) {
		throw new Error("Unable to call javassist methods by reflection!", ex);
	}
}
 

import javassist.bytecode.SignatureAttribute; //导入依赖的package包/类
private static String renameClassSignature(String signature, ReplacerClassMap map) {
	try {
		ClassSignature type = renameType(SignatureAttribute.toClassSignature(signature), map);
		if (type != null) {
			return type.encode();
		}
		return null;
	} catch (BadBytecode ex) {
		throw new Error("Can't parse field signature: " + signature);
	}
}
 

import javassist.bytecode.SignatureAttribute; //导入依赖的package包/类
private static String renameFieldSignature(String signature, ReplacerClassMap map) {
	try {
		ObjectType type = renameType(SignatureAttribute.toFieldSignature(signature), map);
		if (type != null) {
			return type.encode();
		}
		return null;
	} catch (BadBytecode ex) {
		throw new Error("Can't parse class signature: " + signature);
	}
}
 

import javassist.bytecode.SignatureAttribute; //导入依赖的package包/类
private static String renameMethodSignature(String signature, ReplacerClassMap map) {
	try {
		MethodSignature type = renameType(SignatureAttribute.toMethodSignature(signature), map);
		if (type != null) {
			return type.encode();
		}
		return null;
	} catch (BadBytecode ex) {
		throw new Error("Can't parse method signature: " + signature);
	}
}
 

import javassist.bytecode.SignatureAttribute; //导入依赖的package包/类
@Override
public List<TypeParameterDeclaration.Bound> getBounds(TypeSolver typeSolver) {
    List<Bound> bounds = new ArrayList<>();
    if (wrapped.getClassBound() != null && !wrapped.getClassBound().toString().equals(Object.class.getCanonicalName())) {
        throw new UnsupportedOperationException(wrapped.getClassBound().toString());
    }
    for (SignatureAttribute.ObjectType ot : wrapped.getInterfaceBound()) {
        throw new UnsupportedOperationException(ot.toString());
    }
    return bounds;
}
 

import javassist.bytecode.SignatureAttribute; //导入依赖的package包/类
private static Type objectTypeArgumentToType(SignatureAttribute.ObjectType typeArgument, TypeSolver typeSolver, TypeParametrizable typeParametrizable) {
    String typeName = typeArgument.jvmTypeName();
    Optional<Type> type = getGenericParameterByName(typeName, typeParametrizable);
    return type.orElseGet(() -> new ReferenceTypeImpl(
        typeSolver.solveType(internalNameToCanonicalName(typeName)),
        typeSolver));
}
 

import javassist.bytecode.SignatureAttribute; //导入依赖的package包/类
private static Type typeArgumentToType(SignatureAttribute.TypeArgument typeArgument, TypeSolver typeSolver, TypeParametrizable typeParametrizable) {
    if (typeArgument.isWildcard()) {
        if (typeArgument.getType() == null) {
            return Wildcard.UNBOUNDED;
        } else if (typeArgument.getKind() == '+') {
            return Wildcard.extendsBound(objectTypeArgumentToType(typeArgument.getType(), typeSolver, typeParametrizable));
        } else if (typeArgument.getKind() == '-') {
            return Wildcard.superBound(objectTypeArgumentToType(typeArgument.getType(), typeSolver, typeParametrizable));
        } else {
            throw new UnsupportedOperationException();
        }
    } else {
        return objectTypeArgumentToType(typeArgument.getType(), typeSolver, typeParametrizable);
    }
}
 

import javassist.bytecode.SignatureAttribute; //导入依赖的package包/类
@Override
public List<TypeParameterDeclaration> getTypeParameters() {
    try {
        if (ctMethod.getGenericSignature() == null) {
            return Collections.emptyList();
        }
        SignatureAttribute.MethodSignature methodSignature = SignatureAttribute.toMethodSignature(ctMethod.getGenericSignature());
        return Arrays.stream(methodSignature.getTypeParameters()).map((jasTp) -> new JavassistTypeParameter(jasTp, this, typeSolver)).collect(Collectors.toList());
    } catch (BadBytecode badBytecode) {
        throw new RuntimeException(badBytecode);
    }
}