Java ClassData类代码示例

import edu.umd.cs.findbugs.classfile.analysis.ClassData; //导入依赖的package包/类
public ClassNameAndSuperclassInfo analyze(IAnalysisCache analysisCache, ClassDescriptor descriptor)
        throws CheckedAnalysisException {
    // Get InputStream reading from class data
    ClassData classData = analysisCache.getClassAnalysis(ClassData.class, descriptor);
    DataInputStream classDataIn = new DataInputStream(new ByteArrayInputStream(classData.getData()));

    // Read the class info
    ClassParserInterface parser = new ClassParser(classDataIn, descriptor, classData.getCodeBaseEntry());
    ClassNameAndSuperclassInfo.Builder classInfoBuilder = new ClassNameAndSuperclassInfo.Builder();
    parser.parse(classInfoBuilder);
    ClassNameAndSuperclassInfo classInfo = classInfoBuilder.build();

    if (!classInfo.getClassDescriptor().equals(descriptor)) {
        throw new ClassNameMismatchException(descriptor, classInfo.getClassDescriptor(), classData.getCodeBaseEntry());
    }
    return classInfo;
}
 

import edu.umd.cs.findbugs.classfile.analysis.ClassData; //导入依赖的package包/类
@SuppressWarnings("unchecked")
private static <A> Class<A> getQualifierClass(ClassDescriptor typeQualifier) throws ClassNotFoundException {
    @DottedClassName String className = typeQualifier.getDottedClassName();
    if (DEBUG_CLASSLOADING)
        System.out.println("Getting qualifier class for " + className);
    if (className.startsWith("javax.annotation"))
        return (Class<A>) Class.forName(className);
    try {
        Global.getAnalysisCache().getClassAnalysis(ClassData.class, typeQualifier);
    } catch (CheckedAnalysisException e) {
        throw new ClassNotFoundException("No class data found for " + className);
    }
    
    ValidatorClassLoader validatorLoader = ValidatorClassLoader.INSTANCE;
    return (Class<A>) validatorLoader.loadClass(typeQualifier.getDottedClassName());
}
 

import edu.umd.cs.findbugs.classfile.analysis.ClassData; //导入依赖的package包/类
public ClassInfo analyze(IAnalysisCache analysisCache, ClassDescriptor descriptor) throws CheckedAnalysisException {

        if (descriptor instanceof ClassInfo)
            return (ClassInfo) descriptor;
        ClassData classData;
        try {
            classData = analysisCache.getClassAnalysis(ClassData.class, descriptor);
        } catch (edu.umd.cs.findbugs.classfile.MissingClassException e) {
            if (!descriptor.getSimpleName().equals("package-info"))
                throw e;

            ClassInfo.Builder builder = new ClassInfo.Builder();
            builder.setClassDescriptor(descriptor);
            builder.setAccessFlags(1536);
            return builder.build();
        }

        // Read the class info

        FBClassReader reader = analysisCache.getClassAnalysis(FBClassReader.class, descriptor);
        ClassParserInterface parser = new ClassParserUsingASM(reader, descriptor, classData.getCodeBaseEntry());

        ClassInfo.Builder classInfoBuilder = new ClassInfo.Builder();
        parser.parse(classInfoBuilder);
        ClassInfo classInfo = classInfoBuilder.build();

        if (!classInfo.getClassDescriptor().equals(descriptor)) {
            throw new ClassNameMismatchException(descriptor, classInfo.getClassDescriptor(), classData.getCodeBaseEntry());
        }
        return classInfo;
    }
 

import edu.umd.cs.findbugs.classfile.analysis.ClassData; //导入依赖的package包/类
private void reuseClassCache() {
    SoftReference<Map<ClassDescriptor, Object>> wr = classAnalysisCache.get(project);
    Map<ClassDescriptor, Object> classAnalysis = wr != null? wr.get() : null;
    if(classAnalysis != null) {
        analysisCache.reuseClassAnalysis(ClassData.class, classAnalysis);
        // TODO would be nice to reuse ClassInfoAnalysisEngine: XClass.class,
        // JavaClassAnalysisEngine: JavaClass.class
        // but unfortunately there are side effects for analysis during data generation
        // which we can't have if we would just re-use the data
    }
}
 

import edu.umd.cs.findbugs.classfile.analysis.ClassData; //导入依赖的package包/类
public void registerWith(IAnalysisCache analysisCache) {
    analysisCache.registerClassAnalysisEngine(ClassData.class, this);
}
 

import edu.umd.cs.findbugs.classfile.analysis.ClassData; //导入依赖的package包/类
private byte[] loadClassData(String name) throws CheckedAnalysisException {
    ClassDescriptor d = DescriptorFactory.createClassDescriptorFromDottedClassName(name);
    ClassData data = Global.getAnalysisCache().getClassAnalysis(ClassData.class, d);
    return data.getData();
}
 

import edu.umd.cs.findbugs.classfile.analysis.ClassData; //导入依赖的package包/类
static byte[] loadClassData(String name) throws CheckedAnalysisException {
    ClassDescriptor d = DescriptorFactory.createClassDescriptorFromDottedClassName(name);
    ClassData data = Global.getAnalysisCache().getClassAnalysis(ClassData.class, d);
    return data.getData();
}
 

import edu.umd.cs.findbugs.classfile.analysis.ClassData; //导入依赖的package包/类
public FBClassReader analyze(IAnalysisCache analysisCache, ClassDescriptor descriptor) throws CheckedAnalysisException {

        ClassData classData = analysisCache.getClassAnalysis(ClassData.class, descriptor);

        FBClassReader classReader = new FBClassReader(classData.getData());

        return classReader;
    }