public class PackagedAnnotatedControllerConfigurer extends AnnotatedControllerConfigurer {
	private static final String SCOPED_TARGET_NAME_PREFIX = "scopedTarget.";

	private String activePackage = "";

	public void setActivePackage(String activePackage) {
		this.activePackage = activePackage;
	}

	@Override
	protected Set<DataFetcherMappingInfo> detectHandlerMethods() {
		Set<DataFetcherMappingInfo> results = new LinkedHashSet<>();
		ApplicationContext context = obtainApplicationContext();
		for (String beanName : context.getBeanNamesForType(Object.class)) {
			if (beanName.startsWith(SCOPED_TARGET_NAME_PREFIX)) {
				continue;
			}
			Class<?> beanType = null;
			try {
				beanType = context.getType(beanName);
			}
			catch (Throwable ex) {
				// An unresolvable bean type, probably from a lazy bean - let's ignore it.
				if (this.logger.isTraceEnabled()) {
					this.logger.trace("Could not resolve type for bean '" + beanName + "'", ex);
				}
			}
			if (beanType == null || !AnnotatedElementUtils.hasAnnotation(beanType, Controller.class) || !isPackageMatched(beanType)) {
				continue;
			}
			Class<?> beanClass = context.getType(beanName);
			findHandlerMethods(beanName, beanClass).forEach((info) -> addHandlerMethod(info, results));
		}

		return results;
	}

	/**
	 * Actually added only this check. All of code is copy from source class
	 */
	private boolean isPackageMatched(Class<?> beanType) {
		return StringUtils.isEmpty(activePackage) || activePackage.contains(beanType.getPackageName());
	}

	private Collection<DataFetcherMappingInfo> findHandlerMethods(Object handler, @Nullable Class<?> handlerClass) {
		if (handlerClass == null) {
			return Collections.emptyList();
		}

		Class<?> userClass = ClassUtils.getUserClass(handlerClass);
		Map<Method, DataFetcherMappingInfo> map = MethodIntrospector.selectMethods(
				userClass, (Method method) -> getMappingInfo(method, handler, userClass));

		return map.values();
	}

	private void addHandlerMethod(DataFetcherMappingInfo info, Set<DataFetcherMappingInfo> results) {
		HandlerMethod handlerMethod = getHandlerMethod(info);
		DataFetcherMappingInfo existing = results.stream().filter((o) -> o.equals(info)).findFirst().orElse(null);
		if (existing != null && !getHandlerMethod(existing).equals(handlerMethod)) {
			throw new IllegalStateException(
					"Ambiguous mapping. Cannot map '" + handlerMethod.getBean() + "' method \n" +
							handlerMethod + "\n" + ": There is already '" +
							getHandlerMethod(existing).getBean() + "' bean method\n" + existing + " mapped.");
		}
		results.add(info);
		((AnnotatedControllerExceptionResolver)this.getExceptionResolver()).registerController(handlerMethod.getBeanType());
	}
}

	wiringConfigurers.orderedStream().forEach(customizer -> {
			if (customizer instanceof PackagedAnnotatedControllerConfigurer packaged) {
				packaged.setActivePackage(activePackage);
			}
			builder.configureRuntimeWiring(customizer);
		});