Java ClassUtil类代码示例

import org.febit.util.ClassUtil; //导入依赖的package包/类
protected Render resolveRender(final ActionRequest actionRequest, final Object result) {
    Render render = null;
    for (Class<?> type : ClassUtil.impls(result.getClass())) {
        render = renderCache.get(type);
        if (render != null) {
            break;
        }
        RenderWith anno = type.getAnnotation(RenderWith.class);
        if (anno != null) {
            Class renderClass = anno.value();
            render = renderCache.get(renderClass);
            if (render != null) {
                break;
            }
            render = (Render) petite.get(renderClass);
            if (render != null) {
                render = renderCache.putIfAbsent(renderClass, render);
                break;
            }
        }
    }
    if (render == null) {
        render = defaultRender;
    }
    return renderCache.putIfAbsent(result.getClass(), render);
}
 

import org.febit.util.ClassUtil; //导入依赖的package包/类
@Override
public Argument resolveArgument(final Class<?> type, final String name, final int index) {
    Argument argument = argumentCache.get(type);
    if (argument != null) {
        return argument;
    }
    for (Class cls : ClassUtil.impls(type)) {
        argument = argumentCache.get(cls);
        if (argument != null) {
            break;
        }
    }
    if (argument == null) {
        argument = defaultArgument;
    }
    return argumentCache.putIfAbsent(type, argument);
}
 

import org.febit.util.ClassUtil; //导入依赖的package包/类
@SuppressWarnings("unchecked")
private static ArangoLinkInfo[] collectInfosIfAbsent(Class type) {
    ArangoLinkInfo[] infos = LINKS_CACHING.get(type);
    if (infos != null) {
        return infos;
    }

    final List<ArangoLinkInfo> list = new ArrayList<>();
    for (Field field : ClassUtil.getMemberFields(type)) {
        if (field.getType() != String.class) {
            continue;
        }
        ArangoLink linkAnno = field.getAnnotation(ArangoLink.class);
        if (linkAnno == null) {
            continue;
        }
        ClassUtil.setAccessible(field);
        Class<Entity> linkType = linkAnno.value();
        Class<?> serviceClass = linkAnno.service() != Object.class ? linkAnno.service()
                : linkType.getAnnotation(ArangoLink.class).value();

        list.add(new ArangoLinkInfo(((ArangoService) Services.get(serviceClass)).getDao(), field, linkType));
    }
    infos = list.isEmpty() ? EMPTY_LINKS : list.toArray(new ArangoLinkInfo[list.size()]);
    return LINKS_CACHING.putIfAbsent(type, infos);
}
 

import org.febit.util.ClassUtil; //导入依赖的package包/类
private FieldInfos process() {
    FieldInfos fieldInfos = new FieldInfos();

    ClassUtil.getFields(beanType, this.fieldFilter)
            .forEach(fieldInfos::registField);

    // getters and setters
    for (Method method : beanType.getMethods()) {
        if (!methodFilter.test(method)) {
            continue;
        }
        fieldInfos.registMethod(method);
    }

    return fieldInfos;
}
 

import org.febit.util.ClassUtil; //导入依赖的package包/类
public static HandlerConfig create(Object action, Method method, String macroString) {
    if (ClassUtil.isStatic(method)) {
        action = null;
    } else if (action == null) {
        throw new IllegalArgumentException("action is required to invoke member method: " + method);
    }
    ClassUtil.setAccessible(method);
    BasePathMacros macros = new RegExpPathMacros();
    boolean success = macros.init(macroString, MACRO_SEPARATORS);
    if (!success) {
        macros = null;
    }
    String[] names = macros == null
            ? new String[0]
            : macros.getNames();
    Class<?>[] paramTypes = method.getParameterTypes();
    String[] paramNames = resolveParameterNames(method);
    // assert paramNames.length == paramTypes.length
    int[] paramIndexer = new int[paramTypes.length];

    for (int i = 0; i < paramTypes.length; i++) {
        Class<?> paramType = paramTypes[i];
        if (OutgoingMessage.class.isAssignableFrom(paramType)) {
            paramIndexer[i] = -2;
        } else {
            String paramName = paramNames[i];
            int index = ArraysUtil.indexOf(names, paramName);
            paramIndexer[i] = index >= 0 ? index : -1;
        }
    }
    return new HandlerConfig(action, method, macroString, macros, paramTypes, paramIndexer);
}
 

import org.febit.util.ClassUtil; //导入依赖的package包/类
public void scanActions() {
    final List<Class> actionClasses = new ArrayList<>();
    final ClassScanner scanner = new ClassScanner() {

        @Override
        protected void onEntry(ClassFinder.EntryData ed) throws Exception {
            String className = ed.getName();
            if (!className.endsWith("Action")) {
                return;
            }
            Class actionClass = ClassUtil.getClass(className);
            if (ClassUtil.isAbstract(actionClass)
                    || _discardCaching.contains(actionClass)
                    || !AnnotationUtil.isAction(actionClass)) {
                return;
            }
            LOG.debug("Find action: {}", actionClass);
            actionClasses.add(actionClass);
        }
    };
    String[] includes = new String[_basePkgs.size()];
    for (int i = 0; i < _basePkgs.size(); i++) {
        includes[i] = _basePkgs.get(i)._1 + '*';
    }
    scanner.setExcludeAllEntries(true);
    scanner.setIncludeResources(false);
    scanner.setIncludedEntries(includes);
    scanner.scanDefaultClasspath();

    // register actions
    actionClasses.forEach(this::register);
}
 

import org.febit.util.ClassUtil; //导入依赖的package包/类
@Override
public Object newInstance(Class<?> type, Petite petite) {
    if (!isSupportType(type)) {
        return null;
    }
    if (type.isInterface()) {
        return null;
    }
    return ClassUtil.newInstance(type);
}
 

import org.febit.util.ClassUtil; //导入依赖的package包/类
protected <E extends Entity> IdGenerator resolveIdCenerator(Class<E> entityType) {
    ArangoIdGenerator generatorAnno = entityType.getAnnotation(ArangoIdGenerator.class);
    if (generatorAnno == null) {
        return null;
    }
    Class<? extends IdGenerator> generatorType = generatorAnno.value();
    if (generatorType.equals(DefaultIdGenerator.class)) {
        return DefaultIdGenerator.getInstance();
    }
    if (generatorType.equals(IncreateIdGenerator.class)) {
        return IncreateIdGenerator.getInstance();
    }
    return ClassUtil.newInstance(generatorAnno.value());
}
 

import org.febit.util.ClassUtil; //导入依赖的package包/类
public static Stream<FieldInfo> resolveFieldInfo(Class<?> type) {
    return FieldInfoResolver.of(type)
            .withNameFormatter(ArangoUtil::fixFieldName)
            .filterMethod(m -> false)
            .filterField(f -> !ClassUtil.isTransient(f) && ClassUtil.isSettable(f) && f.getAnnotation(ArangoIgnore.class) == null)
            .stream();
}
 

import org.febit.util.ClassUtil; //导入依赖的package包/类
protected CheckConfig[] resolveCheckConfigs(Class<?> type) {
    List<CheckConfig> checkConfigs = new ArrayList<>();
    FieldInfoResolver.of(type)
            .overrideFieldFilter(f -> ClassUtil.notStatic(f) && f.getAnnotations().length != 0)
            .stream()
            .filter(f -> f.getField() != null && f.isGettable())
            .forEach(f -> collectCheckConfig(f, checkConfigs::add));

    if (checkConfigs.isEmpty()) {
        return EMPTY_CHECK_CONFIGS;
    }
    return checkConfigs.toArray(new CheckConfig[checkConfigs.size()]);
}
 

import org.febit.util.ClassUtil; //导入依赖的package包/类
protected Check createCheck(Class<? extends Annotation> annoType) throws InstantiationException, IllegalAccessException, ClassNotFoundException {
    Class checkType;
    String checkTypeName = annoType.getName() + "Check";
    try {
        checkType = ClassUtil.getClass(checkTypeName);
    } catch (ClassNotFoundException e) {
        // try to use annoType's classloader
        checkType = annoType.getClassLoader().loadClass(checkTypeName);
    }
    Check check = (Check) checkType.newInstance();
    Services.inject(check);
    return check;
}
 

import org.febit.util.ClassUtil; //导入依赖的package包/类
private static void scanFormField(final Class<?> formClass, Consumer<FormField> consumer) {
    FieldInfoResolver.of(formClass)
            .overrideFieldFilter(f -> ClassUtil.notStatic(f) && f.getAnnotations().length != 0)
            .stream()
            .filter(f -> f.getField() != null && f.isGettable())
            .map(BaseFormUtil::toFormField)
            .filter(f -> f != null)
            .forEach(consumer);
}
 

import org.febit.util.ClassUtil; //导入依赖的package包/类
public static Class toClass(String string) {
    if (string == null) {
        return null;
    }
    try {
        return ClassUtil.getClass(string);
    } catch (ClassNotFoundException ex) {
        throw new RuntimeException(ex);
    }
}
 

import org.febit.util.ClassUtil; //导入依赖的package包/类
@Override
public Object newInstance(Class<?> type, Petite petite) {
    if (!isSupportType(type)) {
        return null;
    }
    if (ClassUtil.isAbstract(type)) {
        return null;
    }
    return ClassUtil.newInstance(type);
}
 

import org.febit.util.ClassUtil; //导入依赖的package包/类
@Override
public Reader openReader(String path, String encoding) throws IOException {
    path = formatPath(path);
    if (path == null) {
        return null;
    }
    final InputStream in = ClassUtil.getDefaultClassLoader()
            .getResourceAsStream(path);
    if (in != null) {
        return new InputStreamReader(in, Defaults.or(encoding, StringPool.UTF_8));
    } else {
        throw new IOException("Resource Not Found: ".concat(path));
    }
}