javassist.bytecode.FieldInfo Java Examples

@Test
public void givenTableOfInstructions_whenAddNewInstruction_thenShouldConstructProperSequence() throws NotFoundException, BadBytecode, CannotCompileException, IllegalAccessException, InstantiationException {
    // given
    ClassFile cf = ClassPool.getDefault().get("com.baeldung.javasisst.ThreeDimensionalPoint").getClassFile();

    // when
    FieldInfo f = new FieldInfo(cf.getConstPool(), "id", "I");
    f.setAccessFlags(AccessFlag.PUBLIC);
    cf.addField(f);

    ClassPool classPool = ClassPool.getDefault();
    Field[] fields = classPool.makeClass(cf).toClass().getFields();
    List<String> fieldsList = Stream.of(fields).map(Field::getName).collect(Collectors.toList());
    assertTrue(fieldsList.contains("id"));

}
 

@Override
public boolean isPublic(@Nullable Object o) {
    if (o == null) {
        return false;
    }

    if (o instanceof ClassFile) {
        return AccessFlag.isPublic(((ClassFile) o).getAccessFlags());
    }

    if (o instanceof MethodInfo) {
        return AccessFlag.isPublic(((MethodInfo) o).getAccessFlags());
    }

    if (o instanceof FieldInfo) {
        return AccessFlag.isPublic(((FieldInfo) o).getAccessFlags());
    }

    if (o instanceof Class) {
        return Modifier.isPublic(((Class) o).getModifiers());
    }

    return false;
}
 

@Override
public void scan(final Object cls) {
  final ClassFile classFile = (ClassFile)cls;
  AnnotationsAttribute annotations = ((AnnotationsAttribute)classFile.getAttribute(AnnotationsAttribute.visibleTag));
  if (annotations != null) {
    boolean isAnnotated = false;
    for (javassist.bytecode.annotation.Annotation a : annotations.getAnnotations()) {
      if (annotationsToScan.contains(a.getTypeName())) {
        isAnnotated = true;
      }
    }
    if (isAnnotated) {
      List<AnnotationDescriptor> classAnnotations = getAnnotationDescriptors(annotations);
      List<FieldInfo> classFields = classFile.getFields();
      List<FieldDescriptor> fieldDescriptors = new ArrayList<>(classFields.size());
      for (FieldInfo field : classFields) {
        String fieldName = field.getName();
        AnnotationsAttribute fieldAnnotations = ((AnnotationsAttribute) field.getAttribute(AnnotationsAttribute.visibleTag));
        fieldDescriptors.add(new FieldDescriptor(fieldName, field.getDescriptor(), getAnnotationDescriptors(fieldAnnotations)));
      }
      functions.add(new AnnotatedClassDescriptor(classFile.getName(), classAnnotations, fieldDescriptors));
    }
  }
}
 

private ArrayList<Signature> getDeclaredFields(boolean areStatic) {
    if ((areStatic ? this.fieldsStatic : this.fieldsObject) == null) {
        final ArrayList<Signature> fields = new ArrayList<Signature>();
        final List<FieldInfo> fieldsJA = this.cf.getFields();
        for (FieldInfo fld : fieldsJA) {
            if (Modifier.isStatic(AccessFlag.toModifier(fld.getAccessFlags())) == areStatic) {
                final Signature sig = new Signature(getClassName(), fld.getDescriptor(), fld.getName());
                fields.add(sig);
            }
        }
        if (areStatic) {
            this.fieldsStatic = fields;
        } else {
            this.fieldsObject = fields;
        }
    }
    return (areStatic ? this.fieldsStatic : this.fieldsObject);
}
 

@Override
public Collection<Method> select(AnnotationsScannerProcess process, AnnotationScannerStore store) {
    Set<String> selectedClasses = new HashSet<>();
    MetadataAdapter<ClassFile, FieldInfo, MethodInfo> adapter = process.getMetadataAdapter();

    for (ClassFile cachedClassFile : store.getCachedClassFiles()) {
        for (MethodInfo method : adapter.getMethods(cachedClassFile)) {
            for (String annotationName : adapter.getMethodAnnotationNames(method)) {
                if (annotationType.getName().equals(annotationName)) {
                    selectedClasses.add(adapter.getMethodFullKey(cachedClassFile, method));
                }
            }
        }
    }

    return AnnotationsScannerUtils.forMethods(process, selectedClasses);
}
 

public List<JField> getFields() {

    	boolean isJavaLangThrowable = "java.lang.Throwable".equals(this.getName());
    	boolean isJavaLangSystem = "java.lang.System".equals(this.getName());
    	
        final List<JField> retVal = new ArrayList<JField>();
        @SuppressWarnings("unchecked")
        final List<FieldInfo> fields = (List<FieldInfo>) getClassFile().getFields();

        for (FieldInfo next : fields) {
        	if (isJavaLangThrowable && ("backtrace".equals(next.getName()))) {
        		// See http://bugs.sun.com/bugdatabase/view_bug.do;jsessionid=d7621f5189c86f127fe5737490903?bug_id=4496456
        		continue;
        	}
        	if (isJavaLangSystem && ("security".equals(next.getName()))) {
                continue;
            }
            retVal.add(JField.getJField(next, this, getResolver()));
        }
        return retVal;
    }
 

private void addReadWriteMethods(ClassFile classfile)
		throws CannotCompileException {
	List fields = classfile.getFields();
	for (Iterator field_iter = fields.iterator(); field_iter.hasNext();) {
		FieldInfo finfo = (FieldInfo) field_iter.next();
		if ((finfo.getAccessFlags() & AccessFlag.STATIC) == 0
		    && (!finfo.getName().equals(HANDLER_FIELD_NAME))) {
			// case of non-static field
			if (filter.handleRead(finfo.getDescriptor(), finfo
					.getName())) {
				addReadMethod(classfile, finfo);
				readableFields.put(finfo.getName(), finfo
						.getDescriptor());
			}
			if (filter.handleWrite(finfo.getDescriptor(), finfo
					.getName())) {
				addWriteMethod(classfile, finfo);
				writableFields.put(finfo.getName(), finfo
						.getDescriptor());
			}
		}
	}
}
 

@Test
public void givenJavasisstAPI_whenConstructClass_thenGenerateAClassFile() throws CannotCompileException, IOException, ClassNotFoundException, IllegalAccessException, InstantiationException {
    // given
    String classNameWithPackage = "com.baeldung.JavassistGeneratedClass";
    ClassFile cf = new ClassFile(false, classNameWithPackage, null);
    cf.setInterfaces(new String[] { "java.lang.Cloneable" });

    FieldInfo f = new FieldInfo(cf.getConstPool(), "id", "I");
    f.setAccessFlags(AccessFlag.PUBLIC);
    cf.addField(f);

    // when
    String className = "JavassistGeneratedClass.class";
    cf.write(new DataOutputStream(new FileOutputStream(className)));

    // then
    ClassPool classPool = ClassPool.getDefault();
    Field[] fields = classPool.makeClass(cf).toClass().getFields();
    assertEquals(fields[0].getName(), "id");

    String classContent = new String(Files.readAllBytes(Paths.get(className)));
    assertTrue(classContent.contains("java/lang/Cloneable"));
}
 

/**
 * 代理缓存字段
 * 
 * <pre>
 * private final [clazz.name] _object;
 * private final CacheManager _manager;
 * </pre>
 * 
 * @param clazz
 * @param proxyClass
 * @throws Exception
 */
private void proxyCacheFields(Class<?> clazz, CtClass proxyClass) throws Exception {
    ConstPool constPool = proxyClass.getClassFile2().getConstPool();
    CtField managerField = new CtField(classPool.get(ProxyManager.class.getName()), FIELD_MANAGER, proxyClass);
    CtField informationField = new CtField(classPool.get(CacheInformation.class.getName()), FIELD_INFORMATION, proxyClass);

    List<CtField> fields = Arrays.asList(managerField, informationField);
    List<String> types = Arrays.asList("javax.persistence.Transient", "org.springframework.data.annotation.Transient");
    for (CtField field : fields) {
        field.setModifiers(Modifier.PRIVATE + Modifier.FINAL + Modifier.TRANSIENT);
        FieldInfo fieldInfo = field.getFieldInfo();
        for (String type : types) {
            AnnotationsAttribute annotationsAttribute = new AnnotationsAttribute(constPool, AnnotationsAttribute.visibleTag);
            Annotation annotation = new Annotation(type, constPool);
            annotationsAttribute.addAnnotation(annotation);
            fieldInfo.addAttribute(annotationsAttribute);
        }
        proxyClass.addField(field);
    }
}
 

@Override
public boolean isFieldFinal(Signature fieldSignature) throws FieldNotFoundException {
    final FieldInfo fld = findField(fieldSignature);
    if (fld == null) {
        throw new FieldNotFoundException(fieldSignature.toString());
    }
    return Modifier.isFinal(AccessFlag.toModifier(fld.getAccessFlags()));
}
 

@Override
public boolean hasFieldConstantValue(Signature fieldSignature) throws FieldNotFoundException {
    final FieldInfo fld = findField(fieldSignature);
    if (fld == null) {
        throw new FieldNotFoundException(fieldSignature.toString());
    }
    return (fld.getConstantValue() != 0);
}
 

@Override
public int fieldConstantValueIndex(Signature fieldSignature) throws FieldNotFoundException, AttributeNotFoundException {
    final FieldInfo fld = findField(fieldSignature);
    if (fld == null) {
        throw new FieldNotFoundException(fieldSignature.toString());
    }
    final int cpVal = fld.getConstantValue();
    if (cpVal == 0) {
        throw new AttributeNotFoundException();
    }
    return cpVal;
}
 

@Override
public boolean isFieldPublic(Signature fieldSignature) throws FieldNotFoundException {
    final FieldInfo fld = findField(fieldSignature);
    if (fld == null) {
        throw new FieldNotFoundException(fieldSignature.toString());
    }
    return Modifier.isPublic(AccessFlag.toModifier(fld.getAccessFlags()));
}
 

protected void scanFields(ClassFile cf) {
    List<ClassFile> fields = cf.getFields();
    if (fields == null)
        return;
    for (Object obj : fields) {
        FieldInfo field = (FieldInfo) obj;
        AnnotationsAttribute visible = (AnnotationsAttribute) field.getAttribute(AnnotationsAttribute.visibleTag);
        AnnotationsAttribute invisible = (AnnotationsAttribute) field
                .getAttribute(AnnotationsAttribute.invisibleTag);
        if (visible != null)
            populate(visible.getAnnotations(), cf.getName());
        if (invisible != null)
            populate(invisible.getAnnotations(), cf.getName());
    }
}
 

@Override
public boolean isFieldPackage(Signature fieldSignature) throws FieldNotFoundException {
    final FieldInfo fld = findField(fieldSignature);
    if (fld == null) {
        throw new FieldNotFoundException(fieldSignature.toString());
    }
    return Modifier.isPackage(AccessFlag.toModifier(fld.getAccessFlags()));
}
 

@Override
public boolean isFieldPrivate(Signature fieldSignature) throws FieldNotFoundException {
    final FieldInfo fld = findField(fieldSignature);
    if (fld == null) {
        throw new FieldNotFoundException(fieldSignature.toString());
    }
    return Modifier.isPrivate(AccessFlag.toModifier(fld.getAccessFlags()));
}
 

@Override
public boolean isFieldStatic(Signature fieldSignature) throws FieldNotFoundException {
    final FieldInfo fld = findField(fieldSignature);
    if (fld == null) {
        throw new FieldNotFoundException(fieldSignature.toString());
    }
    return Modifier.isStatic(AccessFlag.toModifier(fld.getAccessFlags()));
}
 

@Override
public String getFieldGenericSignatureType(Signature fieldSignature) 
throws FieldNotFoundException {
    final FieldInfo fld = findField(fieldSignature);
    if (fld == null) {
        throw new FieldNotFoundException(fieldSignature.toString());
    }
    SignatureAttribute sa = (SignatureAttribute) fld.getAttribute(SignatureAttribute.tag);
    return (sa == null ? null : sa.getSignature());
}
 

@Override
public boolean isFieldProtected(Signature fieldSignature) throws FieldNotFoundException {
    final FieldInfo fld = findField(fieldSignature);
    if (fld == null) {
        throw new FieldNotFoundException(fieldSignature.toString());
    }
    return Modifier.isProtected(AccessFlag.toModifier(fld.getAccessFlags()));
}
 

private @Nullable ClassFile scanFile(AnnotationsScannerFile file) {
    MetadataAdapter<ClassFile, FieldInfo, MethodInfo> metadataAdapter = process.getMetadataAdapter();

    for (AnnotationsFilter<AnnotationsScannerFile> fileFilter : process.getProcessConfiguration().fileFilters) {
        if (!fileFilter.check(metadataAdapter, file)) {
            return null;
        }
    }

    long time = System.nanoTime();
    ClassFile pseudoClass;

    try {
        pseudoClass = metadataAdapter.getOfCreateClassObject(scanner, file);
    } catch (Exception e) {
        return null; // mute
    } finally {
        jaTime += (System.nanoTime() - time);
    }

    for (AnnotationsFilter<ClassFile> pseudoClassFilter : process.getProcessConfiguration().classFileFilters) {
        if (!pseudoClassFilter.check(metadataAdapter, pseudoClass)) {
            return null;
        }
    }

    if (!StringUtils.isEmpty(pseudoClass.getSuperclass())) {
        store.addInheritors(pseudoClass.getSuperclass(), pseudoClass.getName());
    }

    if (pseudoClass.getInterfaces() != null) {
        for (String anInterface : pseudoClass.getInterfaces()) {
            store.addInheritors(anInterface, pseudoClass.getName());
        }
    }

    return pseudoClass;
}
 

@Override
public int getFieldModifiers(Signature fieldSignature) 
throws FieldNotFoundException {
    final FieldInfo fld = findField(fieldSignature);
    if (fld == null) {
        throw new FieldNotFoundException(fieldSignature.toString());
    }
    return AccessFlag.toModifier(fld.getAccessFlags());
}
 

@Override
public byte[] getFieldAnnotationsRaw(Signature fieldSignature) 
throws FieldNotFoundException {
    final FieldInfo fld = findField(fieldSignature);
    if (fld == null) {
        throw new FieldNotFoundException(fieldSignature.toString());
    }
    final AttributeInfo attrVisible = fld.getAttribute(AnnotationsAttribute.visibleTag);
    final AttributeInfo attrInvisible = fld.getAttribute(AnnotationsAttribute.invisibleTag);
    return mergeVisibleAndInvisibleAttributes(attrVisible, attrInvisible);
}
 

@Override
public boolean check(MetadataAdapter<ClassFile, FieldInfo, MethodInfo> metadataAdapter, URL element) {
    String url = element.toString();

    for (String path : paths) {
        if (url.contains(path)) {
            return !exclude;
        }
    }

    return exclude;
}
 

private FieldInfo findField(Signature fieldSignature) {
    final List<FieldInfo> fieldsJA = this.cf.getFields();
    for (FieldInfo fld : fieldsJA) {
        if (fld.getDescriptor().equals(fieldSignature.getDescriptor()) && 
            fld.getName().equals(fieldSignature.getName())) {
            return fld;
        }
    }
    return null;
}
 

public static void addResourceAnnotation(CtField field, String beanName) {
	FieldInfo fi = field.getFieldInfo();
	
	AnnotationsAttribute attr = new AnnotationsAttribute(
			field.getFieldInfo().getConstPool(), 
			AnnotationsAttribute.visibleTag);
	Annotation annot = new Annotation(Resource.class.getName(), fi.getConstPool());
	
	StringMemberValue nameValue = new StringMemberValue(fi.getConstPool());
	nameValue.setValue(beanName);
	annot.addMemberValue("name", nameValue);
	
	attr.addAnnotation(annot);
	fi.addAttribute(attr);
}
 

private void addFieldHandlerField(ClassFile classfile)
		throws CannotCompileException {
	ConstPool cp = classfile.getConstPool();
	FieldInfo finfo = new FieldInfo(cp, HANDLER_FIELD_NAME,
	                                HANDLER_FIELD_DESCRIPTOR);
	finfo.setAccessFlags(AccessFlag.PRIVATE | AccessFlag.TRANSIENT);
	classfile.addField(finfo);
}
 

@Override
public void scan(final Object cls) {
  final ClassFile classFile = (ClassFile)cls;
  AnnotationsAttribute annotations = ((AnnotationsAttribute)classFile.getAttribute(AnnotationsAttribute.visibleTag));
  if (annotations != null) {
    boolean isAnnotated = false;
    for (javassist.bytecode.annotation.Annotation a : annotations.getAnnotations()) {
      if (annotationsToScan.contains(a.getTypeName())) {
        isAnnotated = true;
      }
    }
    if (isAnnotated) {
      List<AnnotationDescriptor> classAnnotations = getAnnotationDescriptors(annotations);
      @SuppressWarnings("unchecked")
      List<FieldInfo> classFields = classFile.getFields();
      List<FieldDescriptor> fieldDescriptors = new ArrayList<>(classFields.size());
      for (FieldInfo field : classFields) {
        String fieldName = field.getName();
        AnnotationsAttribute fieldAnnotations = ((AnnotationsAttribute)field.getAttribute(AnnotationsAttribute.visibleTag));
        final List<AnnotationDescriptor> annotationDescriptors =
            (fieldAnnotations != null) ? getAnnotationDescriptors(fieldAnnotations) : Collections.<AnnotationDescriptor>emptyList();
        fieldDescriptors.add(new FieldDescriptor(fieldName, field.getDescriptor(), annotationDescriptors));
      }
      functions.add(new AnnotatedClassDescriptor(classFile.getName(), classAnnotations, fieldDescriptors));
    }
  }
}
 

protected JField(FieldInfo fieldInfo, JClass jClass, ClasspathResolver resolver) {
    super(fieldInfo.getName(), resolver);
    this.fieldInfo = fieldInfo;
    this.jClass = jClass;
}
 

public static JField getJField(FieldInfo fieldInfo, JClass jClass, ClasspathResolver resolver) {
    return new JField(fieldInfo, jClass, resolver);
}
 

public FieldInfo getFieldInfo() {
    return fieldInfo;
}