Java Reflections.getTypesAnnotatedWith方法代码示例

import org.reflections.Reflections; //导入方法依赖的package包/类
@SuppressWarnings("unchecked")
private void registerAnnotations() {
    final Reflections reflections = new Reflections(packagePrefix);
    final Set<Class<?>> namedClasses = reflections.getTypesAnnotatedWith(Named.class);
    for (final Class<?> namedClass : namedClasses) {
        final ServiceReference reference = namedClassReference(namedClass);
        final Constructor<?> namedConstructor = constructorFinder.apply(namedClass);
        final ServiceReference<?>[] parameters = stream(namedConstructor.getParameterTypes())
                .map(NamedClassReference::namedClassReference)
                .toArray(ServiceReference<?>[]::new);
        accept(serviceDefinition(
                namedClassReference(namedClass),
                constructor(reference, namedConstructor, parameters),
                postConstructDependencyFinder.apply(namedClass)
        ));
        stream(serviceFromMethodFinder.apply(namedClass)).forEach(this);
    }
}
 

import org.reflections.Reflections; //导入方法依赖的package包/类
private void searchRouters(RouteRegister register, String pacakge) {
    Reflections reflections = new Reflections(pacakge);
    Set<Class<?>> annotated = reflections.getTypesAnnotatedWith(Route.class);
    for (Class<?> c : annotated) {
        Route annotation = c.getAnnotation(Route.class);
        try {
            if (annotation.method().length > 0)
                register.registerRouter(annotation.method()[0], annotation.path(),
                        (Handler<RoutingContext>) c.newInstance());
            else
                register.registerRouter(annotation.path(), (Handler<RoutingContext>) c.newInstance());
        } catch (InstantiationException | IllegalAccessException | RegisterException e) {
            e.printStackTrace();
        }
    }
}
 

import org.reflections.Reflections; //导入方法依赖的package包/类
/**
 * Auto register classes annotated with `Service`
 */
private void autoRegister() {

    Reflections reflections = ReflectKit.getReflections(appClass);

    // scan inject annotated class
    Set<Class<?>> types = reflections.getTypesAnnotatedWith(Service.class);
    types.forEach(this::recursiveRegisterType);

    // cache constructors
    types.forEach(t -> {
        try {

            ConstructorWalker.findInjectConstructor(t);
        } catch (Exception e) {

            log.error(e.getMessage());
        }
    });
}
 

import org.reflections.Reflections; //导入方法依赖的package包/类
/**
 * 获取方法映射map
 *
 * @param reflections 反射类列表
 * @return 方法映射map
 */
private Map<String, ServerMethod> getMethodMap(Reflections reflections)
        throws IllegalAccessException, InstantiationException {
    // 获取HermesService注解类
    Set<Class<?>> classes = reflections.getTypesAnnotatedWith(HermesService.class);
    Map<String, ServerMethod> map = new TreeMap<>();
    for (Class<?> c : classes) {
        for (Method method : c.getDeclaredMethods()) {
            Object object = c.newInstance();
            HermesMapping hermesMapping = method.getAnnotation(HermesMapping.class);
            if (hermesMapping != null) {
                map.put(hermesMapping.value(), new ServerMethod(object, method));
            }
        }
    }
    return map;
}
 

import org.reflections.Reflections; //导入方法依赖的package包/类
EventListener() {
    final Reflections loader = new Reflections("jukebot.commands");

    Set<Class<?>> discoveredCommands = loader.getTypesAnnotatedWith(CommandProperties.class);
    JukeBot.LOG.info("Discovered " + discoveredCommands.size() + " commands");

    for (Class klass : discoveredCommands) {
        try {
            final Command cmd = (Command) klass.newInstance();

            if (!cmd.properties().enabled())
                continue;

            commands.put(cmd.name().toLowerCase(), cmd);
        } catch (InstantiationException | IllegalAccessException e) {
            JukeBot.LOG.error("An error occurred while creating a new instance of command '" + klass.getName() + "'");
        }
    }
}
 

import org.reflections.Reflections; //导入方法依赖的package包/类
public static void main(String[] args) throws FileNotFoundException {
    if (args.length != 1) throw new IllegalArgumentException("Missing argument 0: Path to write routes");

    Reflections reflections = new Reflections("io.t2l.matrix.homeserver.federation.transport.http.routes");
    Set<Class<?>> routedClasses = reflections.getTypesAnnotatedWith(Route.class);

    try (PrintWriter writer = new PrintWriter(args[0])) {
        writer.println("# !!!!! This file is automatically generated !!!!!");
        writer.println("# !  Any changes you make may not be saved. Use  !");
        writer.println("# !  `gradle buildRoutes` to change these routes !");
        writer.println("# !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
        for (Class<?> clazz : routedClasses) {
            String route = clazz.getAnnotation(Route.class).value();
            writer.println("rest." + route + "=" + clazz.getName());
            System.out.println("Writing route " + route + " for class " + clazz.getName());
        }
    }
}
 

import org.reflections.Reflections; //导入方法依赖的package包/类
public void load() throws Exception {
    Reflections reflections = ReflectionsUtils.getSharedReflectionsInstance();
    Set<Class<?>> annotated = reflections.getTypesAnnotatedWith(Module.class);

    for (Class<?> moduleClass : annotated) {
        Module moduleInfo = moduleClass.getAnnotation(Module.class);

        if (!UnknownPandaModule.class.isAssignableFrom(moduleClass)) {
            UnknownPandaServer.getLogger().error(moduleClass + " is not a description");
            continue;
        }

        UnknownPandaServer.getLogger().info("Including " + moduleInfo.author() + ":" + moduleInfo.name() + " v" + moduleInfo.version());
        UnknownPandaModule module = (UnknownPandaModule) moduleClass.newInstance();
        module.description = moduleInfo;

        manager.registerModule(module);
    }

    UnknownPandaServer.getLogger().info(manager.countModules() + " modules have been loaded");
}
 

import org.reflections.Reflections; //导入方法依赖的package包/类
/**
 * Searches the class path for types with the given annotation
 *
 * @param annotationClass The annotation for which to search
 * @return A map of classes with the given annotation
 */
private Map<ComponentKey, Class<?>> lookupAnnotatedClasses(Class<? extends Annotation> annotationClass) {
	Reflections reflections = new Reflections("gov.cms");
	Set<Class<?>> annotatedClasses = reflections.getTypesAnnotatedWith(annotationClass);
	Map<ComponentKey, Class<?>> registry = new HashMap<>(annotatedClasses.size());

	for (Class<?> annotatedClass : annotatedClasses) {
		for (ComponentKey key : getComponentKeys(annotatedClass)) {
			registry.put(key, annotatedClass);
		}
	}

	return registry;
}
 

import org.reflections.Reflections; //导入方法依赖的package包/类
public void scan(List<String> scanPackages) {
    ExecutionTimer timer = new ExecutionTimer(LogLevel.Info, true);
    for (String scanPackage : scanPackages) {
        logger.debug("Scanning for limberest services in package: {}", scanPackage);
        Reflections reflect = new Reflections(scanPackage);
        // service classes
        for (Class<?> classWithPath : reflect.getTypesAnnotatedWith(Path.class)) {
            logger.info("Found service class: {}", classWithPath.getName());
            Path pathAnnotation = classWithPath.getAnnotation(Path.class);
            if (pathAnnotation != null) {
                String path = pathAnnotation.value();
                if (path != null) {
                    logger.info("  -> and registering with path: {}", path);
                    Produces producesAnnotation = classWithPath.getAnnotation(Produces.class);
                    if (producesAnnotation != null && producesAnnotation.value() != null) {
                        // TODO can only produce one thing and consume if present must match produce
                        Consumes consumesAnnotation = classWithPath.getAnnotation(Consumes.class);
                        for (String contentType : producesAnnotation.value()) {
                            logger.info("  -> for content-type: {}", contentType);
                            @SuppressWarnings({"unchecked", "rawtypes"})
                            Class<? extends RestService<?>> serviceClass = (Class)classWithPath.asSubclass(RestService.class);
                            if (!RestService.class.isAssignableFrom(serviceClass))
                                throw new IllegalArgumentException(serviceClass + " does not extend " + RestService.class);
                            RegistryKey key = new RegistryKey(new ResourcePath(path), contentType);
                            ServiceRegistry.getInstance().put(key, serviceClass);
                        }
                    }
                }
            }
        }
    }
    if (timer.isEnabled())
        timer.log("limberest initializer scanned " + scanPackages.size() + " packages in ");
}
 

import org.reflections.Reflections; //导入方法依赖的package包/类
/**
 * 发现服务, 查找所有扩展了abstractService的类, 这些类保存下来作为service
 */
private static void findService() {
    try {
        Reflections reflections = new Reflections("com.recklessMo.rpc");
        Set<Class<?>> classSet = reflections.getTypesAnnotatedWith(RpcServiceFlag.class, true);
        for (Class<?> inner : classSet) {
            RpcServiceFlag rpcServiceFlag = inner.getAnnotation(RpcServiceFlag.class);
            if (!serverMap.containsKey(rpcServiceFlag.value())) {
                serverMap.put(rpcServiceFlag.value(), inner.newInstance());
            }
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}
 

import org.reflections.Reflections; //导入方法依赖的package包/类
@Bean
public Map<String, Class<?>> entityList() {
	Map<String, Class<?>> result = new HashMap<>();
	Reflections reflections = new Reflections("com.bats.criteriagenerator.entity");
	Set<Class<?>> annotated = reflections.getTypesAnnotatedWith(Entity.class);
	for (Class<?> clazz : annotated)
	{
		Entity entity = clazz.getAnnotation(Entity.class);
		result.put(entity.name(), clazz);
	}
	return result;
}
 

import org.reflections.Reflections; //导入方法依赖的package包/类
public static Kryo registerAllAnnotated(Kryo destination, Class<? extends Annotation> annotationType,
          String sourcePackageName)
  {
Reflections reflections = new Reflections(getUsedPackageName());
      Set<Class<?>> registerableTypes = reflections.getTypesAnnotatedWith(annotationType);
      destination = registerCollection(destination, registerableTypes);
      Set<Class<?>> registerableBaseTypes = reflections.getTypesAnnotatedWith(defaultAnnotationBase);
      destination = registerSubTypesOf(destination, registerableBaseTypes);
      return destination;
  }
 

import org.reflections.Reflections; //导入方法依赖的package包/类
private static void registerEntityTypes(Configuration config)
{
	Reflections reflections = new Reflections("pl.mmorpg.prototype.server.database.entities");
	Set<Class<?>> entityTypes = reflections.getTypesAnnotatedWith(Table.class);
	for (Class<?> type : entityTypes)
		config = config.addAnnotatedClass(type);
}
 

import org.reflections.Reflections; //导入方法依赖的package包/类
@SuppressWarnings("unchecked")
public static void init() {
	final Reflections reflections = new Reflections();
	final Set<Class<?>> exporterClasses = reflections.getTypesAnnotatedWith(Exporter.class);
	exporterClasses.forEach(clazz -> {
		final String key = clazz.getAnnotation(Exporter.class).value();
		exporters.put(key, (Class<? extends DictionaryExporter>) clazz);
	});
}
 

import org.reflections.Reflections; //导入方法依赖的package包/类
public static boolean init() {
	LogUtils.infof("Initializing commands...");

	Reflections reflections = new Reflections(Shadbot.class.getPackage().getName(), new SubTypesScanner(), new TypeAnnotationsScanner());
	for(Class<?> cmdClass : reflections.getTypesAnnotatedWith(Command.class)) {
		if(!AbstractCommand.class.isAssignableFrom(cmdClass)) {
			LogUtils.errorf("An error occurred while generating command, %s cannot be cast to AbstractCommand.", cmdClass.getSimpleName());
			continue;
		}

		try {
			AbstractCommand cmd = (AbstractCommand) cmdClass.newInstance();

			List<String> names = cmd.getNames();
			if(!cmd.getAlias().isEmpty()) {
				names.add(cmd.getAlias());
			}

			for(String name : names) {
				if(COMMANDS_MAP.putIfAbsent(name, cmd) != null) {
					LogUtils.errorf(String.format("Command name collision between %s and %s",
							cmdClass.getSimpleName(), COMMANDS_MAP.get(name).getClass().getSimpleName()));
					continue;
				}
			}
		} catch (InstantiationException | IllegalAccessException err) {
			LogUtils.errorf(err, "An error occurred while initializing command %s.", cmdClass.getDeclaringClass().getSimpleName());
			return false;
		}
	}

	LogUtils.infof("%s initialized.", StringUtils.pluralOf((int) COMMANDS_MAP.values().stream().distinct().count(), "command"));
	return true;
}