Java 类org.springframework.util.ClassUtils 实例源码

/**
 * Return the singleton instance of this class's proxy object,
 * lazily creating it if it hasn't been created already.
 * @return the shared singleton proxy
 */
private synchronized Object getSingletonInstance() {
    if (this.singletonInstance == null) {
        this.targetSource = freshTargetSource();
        if (this.autodetectInterfaces && getProxiedInterfaces().length == 0 && !isProxyTargetClass()) {
            // Rely on AOP infrastructure to tell us what interfaces to proxy.
            Class<?> targetClass = getTargetClass();
            if (targetClass == null) {
                throw new FactoryBeanNotInitializedException("Cannot determine target class for proxy");
            }
            setInterfaces(ClassUtils.getAllInterfacesForClass(targetClass, this.proxyClassLoader));
        }
        // Initialize the shared singleton instance.
        super.setFrozen(this.freezeProxy);
        this.singletonInstance = getProxy(createAopProxy());
    }
    return this.singletonInstance;
}

private static String getNumberConversionMethodName(Class<?> objectClass) {
    objectClass = ClassUtils.resolvePrimitiveIfNecessary(objectClass);
    if (Integer.class.isAssignableFrom(objectClass)) {
        return INT_VALUE;
    }
    if (Long.class.isAssignableFrom(objectClass)) {
        return LONG_VALUE;
    }
    if (Float.class.isAssignableFrom(objectClass)) {
        return FLOAT_VALUE;
    }
    if (Double.class.isAssignableFrom(objectClass)) {
        return DOUBLE_VALUE;
    }
    throw new IllegalArgumentException(
            "Cannot get conversion number for class " + objectClass);
}

private static FlowExecutor.TargetMappingExecutor parseTargetMapping(Method method) {
    logger.debug("解析目标对象映射方法：{}", method);
    // 校验方法类型
    if (!Modifier.isPublic(method.getModifiers())) {
        throw new IllegalArgumentException("目标对象映射方法" + ClassUtils.getQualifiedMethodName(method) + "必须是public类型");
    }
    // 校验入参
    Class[] parameterTypes = method.getParameterTypes();
    if (parameterTypes.length != 1) {
        throw new IllegalArgumentException("目标对象映射方法" + ClassUtils.getQualifiedMethodName(method) + "必须只能有一个入参");
    }
    // 校验返回参数
    if (method.getReturnType() != String.class) {
        throw new IllegalArgumentException("目标对象映射方法" + ClassUtils.getQualifiedMethodName(method) + "返回参数必须是String类型");
    }

    return new FlowExecutor.TargetMappingExecutor(method, parameterTypes[0]);
}

@ConfigurationPropertiesBinding
@Bean
public Converter<String, List<Class<? extends Throwable>>> commaSeparatedStringToThrowablesCollection() {
    return new Converter<String, List<Class<? extends Throwable>>>() {
        @Override
        public List<Class<? extends Throwable>> convert(final String source) {
            try {
                final List<Class<? extends Throwable>> classes = new ArrayList<>();
                for (final String className : StringUtils.commaDelimitedListToStringArray(source)) {
                    classes.add((Class<? extends Throwable>) ClassUtils.forName(className.trim(), getClass().getClassLoader()));
                }
                return classes;
            } catch (final Exception e) {
                throw new IllegalStateException(e);
            }
        }
    };
}

/**
 * Create a new prototype instance of this class's created proxy object,
 * backed by an independent AdvisedSupport configuration.
 * @return a totally independent proxy, whose advice we may manipulate in isolation
 */
private synchronized Object newPrototypeInstance() {
    // In the case of a prototype, we need to give the proxy
    // an independent instance of the configuration.
    // In this case, no proxy will have an instance of this object's configuration,
    // but will have an independent copy.
    if (logger.isTraceEnabled()) {
        logger.trace("Creating copy of prototype ProxyFactoryBean config: " + this);
    }

    ProxyCreatorSupport copy = new ProxyCreatorSupport(getAopProxyFactory());
    // The copy needs a fresh advisor chain, and a fresh TargetSource.
    TargetSource targetSource = freshTargetSource();
    copy.copyConfigurationFrom(this, targetSource, freshAdvisorChain());
    if (this.autodetectInterfaces && getProxiedInterfaces().length == 0 && !isProxyTargetClass()) {
        // Rely on AOP infrastructure to tell us what interfaces to proxy.
        copy.setInterfaces(
                ClassUtils.getAllInterfacesForClass(targetSource.getTargetClass(), this.proxyClassLoader));
    }
    copy.setFrozen(this.freezeProxy);

    if (logger.isTraceEnabled()) {
        logger.trace("Using ProxyCreatorSupport copy: " + copy);
    }
    return getProxy(copy.createAopProxy());
}

/**
 * Creates a {@link PublicationTargetIdentifier} for the given {@link Method}.
 * 
 * @param method must not be {@literal null}.
 * @return
 */
public static PublicationTargetIdentifier forMethod(Method method) {

    String typeName = ClassUtils.getUserClass(method.getDeclaringClass()).getName();
    String methodName = method.getName();
    String parameterTypes = StringUtils.arrayToDelimitedString(method.getParameterTypes(), ", ");

    return PublicationTargetIdentifier.of(String.format("%s.%s(%s)", typeName, methodName, parameterTypes));
}

/**
 * Actually create the EntityManager proxy.
 * @param rawEm raw EntityManager
 * @param emIfc the (potentially vendor-specific) EntityManager
 * interface to proxy, or {@code null} for default detection of all interfaces
 * @param cl the ClassLoader to use for proxy creation (maybe {@code null})
 * @param exceptionTranslator the PersistenceException translator to use
 * @param jta whether to create a JTA-aware EntityManager
 * (or {@code null} if not known in advance)
 * @param containerManaged whether to follow container-managed EntityManager
 * or application-managed EntityManager semantics
 * @param synchronizedWithTransaction whether to automatically join ongoing
 * transactions (according to the JPA 2.1 SynchronizationType rules)
 * @return the EntityManager proxy
 */
private static EntityManager createProxy(
        EntityManager rawEm, Class<? extends EntityManager> emIfc, ClassLoader cl,
        PersistenceExceptionTranslator exceptionTranslator, Boolean jta,
        boolean containerManaged, boolean synchronizedWithTransaction) {

    Assert.notNull(rawEm, "EntityManager must not be null");
    Set<Class<?>> ifcs = new LinkedHashSet<Class<?>>();
    if (emIfc != null) {
        ifcs.add(emIfc);
    }
    else {
        ifcs.addAll(ClassUtils.getAllInterfacesForClassAsSet(rawEm.getClass(), cl));
    }
    ifcs.add(EntityManagerProxy.class);
    return (EntityManager) Proxy.newProxyInstance(
            (cl != null ? cl : ExtendedEntityManagerCreator.class.getClassLoader()),
            ifcs.toArray(new Class<?>[ifcs.size()]),
            new ExtendedEntityManagerInvocationHandler(
                    rawEm, exceptionTranslator, jta, containerManaged, synchronizedWithTransaction));
}

protected Set<Class<?>> scanForEntities(String basePackage) throws ClassNotFoundException {
    if (!StringUtils.hasText(basePackage)) {
        return Collections.emptySet();
    }

    final Set<Class<?>> initialEntitySet = new HashSet<Class<?>>();

    if (StringUtils.hasText(basePackage)) {
        final ClassPathScanningCandidateComponentProvider componentProvider =
                new ClassPathScanningCandidateComponentProvider(false);
        componentProvider.addIncludeFilter(new AnnotationTypeFilter(Persistent.class));

        for (final BeanDefinition candidate : componentProvider.findCandidateComponents(basePackage)) {

            initialEntitySet
                    .add(ClassUtils.forName(candidate.getBeanClassName(),
                            DocumentDbConfigurationSupport.class.getClassLoader()));
        }
    }

    return initialEntitySet;
}

public HandlerMethodService(ConversionService conversionService,
        List<HandlerMethodArgumentResolver> customArgumentResolvers,
        ObjectMapper objectMapper, ApplicationContext applicationContext) {
    this.conversionService = conversionService;
    this.parameterNameDiscoverer = new DefaultParameterNameDiscoverer();

    this.argumentResolvers = new HandlerMethodArgumentResolverComposite();

    ConfigurableBeanFactory beanFactory = ClassUtils.isAssignableValue(
            ConfigurableApplicationContext.class, applicationContext)
                    ? ((ConfigurableApplicationContext) applicationContext)
                            .getBeanFactory()
                    : null;

    this.argumentResolvers.addResolver(
            new HeaderMethodArgumentResolver(this.conversionService, beanFactory));
    this.argumentResolvers.addResolver(new HeadersMethodArgumentResolver());
    this.argumentResolvers.addResolver(new WampMessageMethodArgumentResolver());
    this.argumentResolvers.addResolver(new PrincipalMethodArgumentResolver());
    this.argumentResolvers.addResolver(new WampSessionIdMethodArgumentResolver());
    this.argumentResolvers.addResolvers(customArgumentResolvers);

    this.objectMapper = objectMapper;
}

/**
 * Invoke the method after resolving its argument values in the context of the given
 * message.
 * <p>
 * Argument values are commonly resolved through
 * {@link HandlerMethodArgumentResolver}s. The {@code providedArgs} parameter however
 * may supply argument values to be used directly, i.e. without argument resolution.
 * @param message the current message being processed
 * @param arguments
 * @param argumentsKw
 * @return the raw value returned by the invoked method
 * @exception Exception raised if no suitable argument resolver can be found, or if
 * the method raised an exception
 */
@Nullable
public Object invoke(WampMessage message, List<Object> arguments,
        Map<String, Object> argumentsKw) throws Exception {
    Object[] args = getMethodArgumentValues(message, arguments, argumentsKw);
    if (this.logger.isTraceEnabled()) {
        this.logger.trace("Invoking '"
                + ClassUtils.getQualifiedMethodName(getMethod(), getBeanType())
                + "' with arguments " + Arrays.toString(args));
    }
    Object returnValue = doInvoke(args);
    if (this.logger.isTraceEnabled()) {
        this.logger.trace("Method ["
                + ClassUtils.getQualifiedMethodName(getMethod(), getBeanType())
                + "] returned [" + returnValue + "]");
    }
    return returnValue;
}

private Method getSpecificmethod(ProceedingJoinPoint pjp) {
    MethodSignature methodSignature = (MethodSignature) pjp.getSignature();
    Method method = methodSignature.getMethod();
    // The method may be on an interface, but we need attributes from the
    // target class. If the target class is null, the method will be
    // unchanged.
    Class<?> targetClass = AopProxyUtils.ultimateTargetClass(pjp.getTarget());
    if (targetClass == null && pjp.getTarget() != null) {
        targetClass = pjp.getTarget().getClass();
    }
    Method specificMethod = ClassUtils.getMostSpecificMethod(method, targetClass);
    // If we are dealing with method with generic parameters, find the
    // original method.
    specificMethod = BridgeMethodResolver.findBridgedMethod(specificMethod);
    return specificMethod;
}

@Override
public boolean equals(Object obj) {

    if (null == obj) {
        return false;
    }

    if (this == obj) {
        return true;
    }

    if (!getClass().equals(ClassUtils.getUserClass(obj))) {
        return false;
    }

    AbstractPersistable<?> that = (AbstractPersistable<?>) obj;

    return null != this.getId() && this.getId().equals(that.getId());
}

@Override
public EmbeddedServletContainer getEmbeddedServletContainer(ServletContextInitializer... initializers) {
    ClassLoader parentClassLoader = resourceLoader != null ? resourceLoader.getClassLoader() : ClassUtils.getDefaultClassLoader();
    Package nettyPackage = Bootstrap.class.getPackage();
    String title = nettyPackage.getImplementationTitle();
    String version = nettyPackage.getImplementationVersion();
    logger.info("Running with " + title + " " + version);
    NettyEmbeddedContext context = new NettyEmbeddedContext(getContextPath(), new URLClassLoader(new URL[]{}, parentClassLoader), SERVER_INFO);
    if (isRegisterDefaultServlet()) {
        logger.warn("This container does not support a default servlet");
    }
    /*if (isRegisterJspServlet()) {
        logger.warn("This container does not support a JSP servlet");
    }*/
    for (ServletContextInitializer initializer : initializers) {
        try {
            initializer.onStartup(context);
        } catch (ServletException e) {
            throw new RuntimeException(e);
        }
    }
    int port = getPort() > 0 ? getPort() : new Random().nextInt(65535 - 1024) + 1024;
    InetSocketAddress address = new InetSocketAddress(port);
    logger.info("Server initialized with port: " + port);
    return new NettyEmbeddedServletContainer(address, context);
}

public static URL getURL(String resourceLocation)
        throws FileNotFoundException {
    Assert.notNull(resourceLocation, "Resource location must not be null");
    if (resourceLocation.startsWith("classpath:")) {
        String path = resourceLocation.substring("classpath:".length());
        ClassLoader cl = ClassUtils.getDefaultClassLoader();
        URL url = cl != null ? cl.getResource(path) : ClassLoader.getSystemResource(path);
        if (url == null) {
            String description = "class path resource [" + path + "]";
            throw new FileNotFoundException(description + " cannot be resolved to URL because it does not exist");
        }

        return url;
    }
    try {
        return new URL(resourceLocation);
    } catch (MalformedURLException ex) {
        try {
            return new File(resourceLocation).toURI().toURL();
        } catch (MalformedURLException ex2) {
        }
    }
    throw new FileNotFoundException("Resource location [" + resourceLocation + "] is neither a URL not a well-formed file path");
}

/**
 * 解析流程事务
 *
 * @param flowTx             流程事务
 * @param transactionManager 事务管理器
 * @return 流程事务执行器
 */
public static FlowTxExecutor parseFlowTx(Object flowTx, PlatformTransactionManager transactionManager) {
    // 获取目标class（应对AOP代理情况）
    Class<?> flowTxClass = AopUtils.getTargetClass(flowTx);
    logger.debug("解析流程事务：{}", ClassUtils.getQualifiedName(flowTxClass));
    FlowTx flowTxAnnotation = flowTxClass.getAnnotation(FlowTx.class);
    // 创建流程事务执行器
    FlowTxExecutor flowTxExecutor = new FlowTxExecutor(flowTxAnnotation.flow(), flowTx, transactionManager);
    for (Method method : flowTxClass.getDeclaredMethods()) {
        for (Class clazz : FlowTxExecutor.FLOW_TX_OPERATE_ANNOTATIONS) {
            if (method.isAnnotationPresent(clazz)) {
                // 设置流程事务操作执行器
                flowTxExecutor.setOperateExecutor(clazz, parseFlowTxOperate(method));
                break;
            }
        }
    }
    flowTxExecutor.validate();

    return flowTxExecutor;
}

@Override
public String toString() {
    StringBuilder sb = new StringBuilder();
    Advice advice = this.advisor.getAdvice();
    sb.append(ClassUtils.getShortName(advice.getClass()));
    sb.append(": ");
    if (this.advisor instanceof Ordered) {
        sb.append("order ").append(((Ordered) this.advisor).getOrder()).append(", ");
    }
    if (advice instanceof AbstractAspectJAdvice) {
        AbstractAspectJAdvice ajAdvice = (AbstractAspectJAdvice) advice;
        sb.append(ajAdvice.getAspectName());
        sb.append(", declaration order ");
        sb.append(ajAdvice.getDeclarationOrder());
    }
    return sb.toString();
}

protected final AbstractBeanDefinition createSqlSessionFactoryBean(String dataSourceName, String mapperPackage,
        String typeAliasesPackage, Dialect dialect, Configuration configuration) {
    configuration.setDatabaseId(dataSourceName);
    BeanDefinitionBuilder bdb = BeanDefinitionBuilder.rootBeanDefinition(SqlSessionFactoryBean.class);
    bdb.addPropertyValue("configuration", configuration);
    bdb.addPropertyValue("failFast", true);
    bdb.addPropertyValue("typeAliases", this.saenTypeAliases(typeAliasesPackage));
    bdb.addPropertyReference("dataSource", dataSourceName);
    bdb.addPropertyValue("plugins", new Interceptor[] { new CustomPageInterceptor(dialect) });
    if (!StringUtils.isEmpty(mapperPackage)) {
        try {
            mapperPackage = new StandardEnvironment().resolveRequiredPlaceholders(mapperPackage);
            String mapperPackages = ClassUtils.convertClassNameToResourcePath(mapperPackage);
            String mapperPackagePath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX + mapperPackages + "/*.xml";
            Resource[] resources = new PathMatchingResourcePatternResolver().getResources(mapperPackagePath);
            bdb.addPropertyValue("mapperLocations", resources);
        } catch (Exception e) {
            log.error("初始化失败", e);
            throw new RuntimeException( String.format("SqlSessionFactory 初始化失败  mapperPackage=%s", mapperPackage + ""));
        }
    }
    return bdb.getBeanDefinition();
}

/**
 * 将符合条件的Bean以Class集合的形式返回
 * 
 * @return
 * @throws IOException
 * @throws ClassNotFoundException
 */
public Set<Class<?>> getClassSet() throws IOException, ClassNotFoundException {
    this.classSet.clear();
    if (!this.packagesList.isEmpty()) {
        for (String pkg : this.packagesList) {
            String pattern = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX
                    + ClassUtils.convertClassNameToResourcePath(pkg) + RESOURCE_PATTERN;
            Resource[] resources = this.resourcePatternResolver.getResources(pattern);
            MetadataReaderFactory readerFactory = new CachingMetadataReaderFactory(this.resourcePatternResolver);
            for (Resource resource : resources) {
                if (resource.isReadable()) {
                    MetadataReader reader = readerFactory.getMetadataReader(resource);
                    String className = reader.getClassMetadata().getClassName();
                    if (matchesEntityTypeFilter(reader, readerFactory)) {
                        this.classSet.add(Class.forName(className));
                    }
                }
            }
        }
    }
    return this.classSet;
}

public void addParameter(Object askFor, Object valueParam)
throws InstantiationException, IllegalAccessException {
    try {
        Class clz = ClassUtils.forName((String)askFor);
        if (log.isDebugEnabled()) {
            log.debug("trying to resolve the following class from the Spring bean container: " + clz.getName());
        }

        Map beansOfType = ((ListableBeanFactory)beanFactory).getBeansOfType(clz);
        if (log.isDebugEnabled()) {
            log.debug("beans: " + beansOfType + " - " + beansOfType.size());
        }
        if (beansOfType.size() == 0) {
            log.debug("adding parameter the normal way");
            super.addParameter(askFor, valueParam);
        } else if (beansOfType.size() > 1) {
            // TODO: handle multiple declarations
            throw new InstantiationException("multiple beans of type '" + clz.getName() + "' were found in the spring configuration");
        } else {
            this.beans.put(askFor, beansOfType.values().iterator().next());
        }
    } catch (ClassNotFoundException e) {
        super.addParameter(askFor, valueParam);
    }
}

private static ListenExecutor parseListen(Listen listenAnnotation, Method method) {
    logger.debug("解析监听方法：{}", method);
    // 校验方法类型
    if (!Modifier.isPublic(method.getModifiers())) {
        throw new IllegalArgumentException("监听方法" + ClassUtils.getQualifiedMethodName(method) + "必须是public类型");
    }
    // 校验返回类型
    if (method.getReturnType() != void.class) {
        throw new IllegalArgumentException("监听方法" + ClassUtils.getQualifiedMethodName(method) + "的返回必须是void");
    }
    // 创建监听解决器
    ListenResolver resolver = (ListenResolver) ReflectUtils.newInstance(listenAnnotation.resolver());
    resolver.init(method);

    return new ListenExecutor(resolver, listenAnnotation.priorityAsc(), method);
}

public Object toTarantoolNativeType(Object value, Class<?> targetType) {
    if (value instanceof Boolean ||
        value instanceof Number ||
        value instanceof String ||
        value instanceof byte[]
    ) {
        return value;
    }

    if (ClassUtils.isAssignable(Boolean.class, targetType)) {
        return conversionService.convert(value, Boolean.class);
    } else if (ClassUtils.isAssignable(Number.class, targetType)) {
        return conversionService.convert(value, Number.class);
    } else if (ClassUtils.isAssignable(String.class, targetType)) {
        return conversionService.convert(value, String.class);
    } else if (ClassUtils.isAssignable(byte[].class, targetType)) {
        return conversionService.convert(value, byte[].class);
    } else {
        throw new IllegalStateException("Unknown targetType: " + targetType);
    }
}

@Override
public void init(Method listenMethod) {
    ConfigListener configListenerAnnotation = AnnotatedElementUtils.findMergedAnnotation(listenMethod.getDeclaringClass(), ConfigListener.class);
    if (configListenerAnnotation == null) {
        throw new IllegalArgumentException("@ListenConfigModified只能标注在配置监听器（@ConfigListener）的方法上");
    }
    // 校验入参
    Class[] parameterTypes = listenMethod.getParameterTypes();
    if (parameterTypes.length != 1) {
        throw new RuntimeException("监听配置被修改方法" + ClassUtils.getQualifiedMethodName(listenMethod) + "的入参必须是（List<ModifiedProperty>）");
    }
    if (parameterTypes[0] != List.class) {
        throw new RuntimeException("监听配置被修改方法" + ClassUtils.getQualifiedMethodName(listenMethod) + "的入参必须是（List<ModifiedProperty>）");
    }
    ResolvableType resolvableType = ResolvableType.forMethodParameter(listenMethod, 0);
    if (resolvableType.getGeneric(0).resolve(Object.class) != ModifiedProperty.class) {
        throw new RuntimeException("监听配置被修改方法" + ClassUtils.getQualifiedMethodName(listenMethod) + "的入参必须是（List<ModifiedProperty>）");
    }
    // 设置事件类型
    ListenConfigModified listenConfigModifiedAnnotation = AnnotatedElementUtils.findMergedAnnotation(listenMethod, ListenConfigModified.class);
    eventType = new ConfigModifiedEventType(configListenerAnnotation.configContextName(), listenConfigModifiedAnnotation.prefix());
}

/**
 * 解析处理器
 *
 * @param processor 处理器
 * @return 处理器执行器
 */
public static ProcessorExecutor parseProcessor(Object processor) {
    // 获取目标class（应对AOP代理情况）
    Class<?> processorClass = AopUtils.getTargetClass(processor);
    logger.debug("解析处理器：{}", ClassUtils.getQualifiedName(processorClass));
    // 获取处理器名称
    String processorName = processorClass.getAnnotation(Processor.class).name();
    if (StringUtils.isEmpty(processorName)) {
        processorName = ClassUtils.getShortNameAsProperty(processorClass);
    }
    // 创建处理器执行器
    ProcessorExecutor processorExecutor = new ProcessorExecutor(processorName, processor);
    for (Method method : processorClass.getDeclaredMethods()) {
        for (Class clazz : ProcessorExecutor.PROCESSOR_METHOD_ANNOTATIONS) {
            if (method.isAnnotationPresent(clazz)) {
                // 设置处理器方法执行器
                processorExecutor.setMethodExecutor(clazz, parseProcessorMethod(clazz, method));
                break;
            }
        }
    }
    processorExecutor.validate();

    return processorExecutor;
}

/**
 * Create a new SimpleLoadTimeWeaver for the given class loader.
 * @param classLoader the {@code ClassLoader} to delegate to for
 * weaving (<i>must</i> support the required weaving methods).
 * @throws IllegalStateException if the supplied {@code ClassLoader}
 * does not support the required weaving methods
 */
public ReflectiveLoadTimeWeaver(ClassLoader classLoader) {
    Assert.notNull(classLoader, "ClassLoader must not be null");
    this.classLoader = classLoader;
    this.addTransformerMethod = ClassUtils.getMethodIfAvailable(
            this.classLoader.getClass(), ADD_TRANSFORMER_METHOD_NAME,
            new Class<?>[] {ClassFileTransformer.class});
    if (this.addTransformerMethod == null) {
        throw new IllegalStateException(
                "ClassLoader [" + classLoader.getClass().getName() + "] does NOT provide an " +
                "'addTransformer(ClassFileTransformer)' method.");
    }
    this.getThrowawayClassLoaderMethod = ClassUtils.getMethodIfAvailable(
            this.classLoader.getClass(), GET_THROWAWAY_CLASS_LOADER_METHOD_NAME, new Class<?>[0]);
    // getThrowawayClassLoader method is optional
    if (this.getThrowawayClassLoaderMethod == null) {
        if (logger.isInfoEnabled()) {
            logger.info("The ClassLoader [" + classLoader.getClass().getName() + "] does NOT provide a " +
                    "'getThrowawayClassLoader()' method; SimpleThrowawayClassLoader will be used instead.");
        }
    }
}

private boolean isSpringSecurityEnabled(ConditionContext ctx) {

        boolean enabled = true;

        Environment env = ctx.getEnvironment();

        for (String propName : props) {
            if (env.containsProperty(propName)) {
                if (!Boolean.parseBoolean(env.getProperty(propName))) {
                    enabled = false;
                    break;
                }
            }
        }

        if (enabled) {
            enabled = ClassUtils.isPresent(SPRING_SEC_CLASS_NAME, ctx.getClassLoader());
        }

        return enabled;
    }

private Class<?> determineCommonType(Class<?> oldType, Class<?> newType) {
    if (oldType == null) {
        return newType;
    }
    if (oldType.isAssignableFrom(newType)) {
        return oldType;
    }
    Class<?> nextType = newType;
    while (nextType != Object.class) {
        if (nextType.isAssignableFrom(oldType)) {
            return nextType;
        }
        nextType = nextType.getSuperclass();
    }
    Class<?>[] interfaces = ClassUtils.getAllInterfacesForClass(newType);
    for (Class<?> nextInterface : interfaces) {
        if (nextInterface.isAssignableFrom(oldType)) {
            return nextInterface;
        }
    }
    return Object.class;
}

/**
 * Delegate to the {@link WebArgumentResolver} instance.
 * @exception IllegalStateException if the resolved value is not assignable
 * to the method parameter.
 */
@Override
public Object resolveArgument(
        MethodParameter parameter, ModelAndViewContainer mavContainer,
        NativeWebRequest webRequest, WebDataBinderFactory binderFactory)
        throws Exception {

    Class<?> paramType = parameter.getParameterType();
    Object result = this.adaptee.resolveArgument(parameter, webRequest);
    if (result == WebArgumentResolver.UNRESOLVED || !ClassUtils.isAssignableValue(paramType, result)) {
        throw new IllegalStateException(
                "Standard argument type [" + paramType.getName() + "] in method " + parameter.getMethod() +
                "resolved to incompatible value of type [" + (result != null ? result.getClass() : null) +
                "]. Consider declaring the argument type in a less specific fashion.");
    }
    return result;
}

/**
 * 解析处理器方法
 */
private static ProcessorMethodExecutor parseProcessorMethod(Class clazz, Method method) {
    logger.debug("解析处理器方法：{}", method);
    // 校验方法类型
    if (!Modifier.isPublic(method.getModifiers())) {
        throw new IllegalArgumentException("处理器方法" + ClassUtils.getQualifiedMethodName(method) + "必须是public类型");
    }
    // 校验入参
    Class[] parameterTypes = method.getParameterTypes();
    if (parameterTypes.length != 1) {
        throw new IllegalArgumentException("处理器方法" + ClassUtils.getQualifiedMethodName(method) + "入参必须是（TargetContext）");
    }
    if (parameterTypes[0] != TargetContext.class) {
        throw new IllegalArgumentException("处理器方法" + ClassUtils.getQualifiedMethodName(method) + "入参必须是（TargetContext）");
    }
    // 校验返回类型
    if (clazz != ProcessorExecute.class && method.getReturnType() != void.class) {
        throw new IllegalArgumentException("非@ProcessorExecute类型的处理器方法" + ClassUtils.getQualifiedMethodName(method) + "的返回类型必须是void");
    }
    // 获取目标对象类型
    ResolvableType resolvableType = ResolvableType.forMethodParameter(method, 0);
    Class classOfTarget = resolvableType.getGeneric(0).resolve(Object.class);

    return new ProcessorMethodExecutor(method, classOfTarget);
}

@Override
public TransactionAttribute getTransactionAttribute(Method method, Class<?> targetClass) {
    if (!ClassUtils.isUserLevelMethod(method)) {
        return null;
    }

    // Look for direct name match.
    String methodName = method.getName();
    TransactionAttribute attr = this.nameMap.get(methodName);

    if (attr == null) {
        // Look for most specific name match.
        String bestNameMatch = null;
        for (String mappedName : this.nameMap.keySet()) {
            if (isMatch(methodName, mappedName) &&
                    (bestNameMatch == null || bestNameMatch.length() <= mappedName.length())) {
                attr = this.nameMap.get(mappedName);
                bestNameMatch = mappedName;
            }
        }
    }

    return attr;
}

/**
 * Determine whether the given bean property is excluded from dependency checks.
 * <p>This implementation excludes properties defined by CGLIB.
 * @param pd the PropertyDescriptor of the bean property
 * @return whether the bean property is excluded
 */
public static boolean isExcludedFromDependencyCheck(PropertyDescriptor pd) {
    Method wm = pd.getWriteMethod();
    if (wm == null) {
        return false;
    }
    if (!wm.getDeclaringClass().getName().contains("$$")) {
        // Not a CGLIB method so it's OK.
        return false;
    }
    // It was declared by CGLIB, but we might still want to autowire it
    // if it was actually declared by the superclass.
    Class<?> superclass = wm.getDeclaringClass().getSuperclass();
    return !ClassUtils.hasMethod(superclass, wm.getName(), wm.getParameterTypes());
}

@Test
public void testWithMockedChrome() {
    load(new Class[]{},
        "com.greglturnquist.webdriver.firefox.enabled:false",
        "com.greglturnquist.webdriver.safari.enabled:false");
    WebDriver driver = context.getBean(WebDriver.class);
    assertThat(ClassUtils.isAssignable(TakesScreenshot.class,
        driver.getClass())).isTrue();
    assertThat(ClassUtils.isAssignable(ChromeDriver.class,
        driver.getClass())).isTrue();
}

@Override
public Object invoke(MethodInvocation invocation) throws Throwable {
    Method method = invocation.getMethod();
    if (logger.isDebugEnabled()) {
        logger.debug("Incoming " + this.exporterNameClause + "remote call: " +
                ClassUtils.getQualifiedMethodName(method));
    }
    try {
        Object retVal = invocation.proceed();
        if (logger.isDebugEnabled()) {
            logger.debug("Finished processing of " + this.exporterNameClause + "remote call: " +
                    ClassUtils.getQualifiedMethodName(method));
        }
        return retVal;
    }
    catch (Throwable ex) {
        if (ex instanceof RuntimeException || ex instanceof Error) {
            if (logger.isWarnEnabled()) {
                logger.warn("Processing of " + this.exporterNameClause + "remote call resulted in fatal exception: " +
                        ClassUtils.getQualifiedMethodName(method), ex);
            }
        }
        else {
            if (logger.isInfoEnabled()) {
                logger.info("Processing of " + this.exporterNameClause + "remote call resulted in exception: " +
                        ClassUtils.getQualifiedMethodName(method), ex);
            }
        }
        throw ex;
    }
}

@Override
public void setAsText(String text) throws IllegalArgumentException {
    if (StringUtils.hasText(text)) {
        String[] classNames = StringUtils.commaDelimitedListToStringArray(text);
        Class<?>[] classes = new Class<?>[classNames.length];
        for (int i = 0; i < classNames.length; i++) {
            String className = classNames[i].trim();
            classes[i] = ClassUtils.resolveClassName(className, this.classLoader);
        }
        setValue(classes);
    }
    else {
        setValue(null);
    }
}

public static String getNameForGenerateCode(JavaType javaType) {
  if (byte[].class.equals(javaType.getRawClass())) {
    return "byte[]";
  }

  if (!javaType.isArrayType()) {
    Class<?> rawClass = ClassUtils.resolvePrimitiveIfNecessary(javaType.getRawClass());
    return rawClass.getTypeName();
  }

  return javaType.getContentType().getRawClass().getName() + "[]";
}

private static boolean isNeedWrap(Class<?> cls) {
  // protobuf不支持原子类型、enum、string、数组、collection等等作为msg
  // 只有pojo类型才可以
  // java.lang.Object也不可以，因为这可以是任意类型，结果不确定
  return ClassUtils.isPrimitiveOrWrapper(cls) || cls.isArray() || cls.isEnum()
      || String.class.isAssignableFrom(cls)
      || Collection.class.isAssignableFrom(cls)
      || Map.class.isAssignableFrom(cls)
      || Date.class.isAssignableFrom(cls)
      || Object.class.equals(cls);
}

/**
   * <p>
   * 别名通配符设置
   * </p>
   * <p>
   * <property name="typeAliasesPackage" value="com.baomidou.*.entity"/>
   * </p>
   *
   * @param typeAliasesPackage 类别名包路径
   * @return
   */
  public static String[] convertTypeAliasesPackage(String typeAliasesPackage) {
      ResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
      MetadataReaderFactory metadataReaderFactory = new CachingMetadataReaderFactory(resolver);
      String pkg = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX
              + ClassUtils.convertClassNameToResourcePath(typeAliasesPackage) + "/*.class";

/*
       * 将加载多个绝对匹配的所有Resource
 * 将首先通过ClassLoader.getResource("META-INF")加载非模式路径部分，然后进行遍历模式匹配，排除重复包路径
 */
      try {
          Set<String> set = new HashSet<>();
          Resource[] resources = resolver.getResources(pkg);
          if (resources != null && resources.length > 0) {
              MetadataReader metadataReader;
              for (Resource resource : resources) {
                  if (resource.isReadable()) {
                      metadataReader = metadataReaderFactory.getMetadataReader(resource);
                      set.add(Class.forName(metadataReader.getClassMetadata().getClassName()).getPackage().getName());
                  }
              }
          }
          if (!set.isEmpty()) {
              return set.toArray(new String[]{});
          } else {
              throw new MybatisPlusException("not find typeAliasesPackage:" + pkg);
          }
      } catch (Exception e) {
          throw new MybatisPlusException("not find typeAliasesPackage:" + pkg, e);
      }
  }

public static TProcessor buildProcessor(Class<?> svcInterface, Object service) throws Exception {
    Class<TProcessor> processorClass = (Class<TProcessor>) getThriftServiceInnerClassOrNull(svcInterface.getEnclosingClass(), PROCESSOR_NAME, false);
    if (processorClass == null) {
        throw new ThriftRuntimeException("the processor is null");
    }

    Constructor<TProcessor> constructor = ClassUtils.getConstructorIfAvailable(processorClass, svcInterface);
    if (constructor == null) {
        throw new ThriftRuntimeException("the processor constructor is null");
    }

    return constructor.newInstance(service);
}

/**
 * 获取指定类型的监听器执行器
 *
 * @param type 监听器类型
 * @throws IllegalArgumentException 如果不存在该类型的监听器执行器
 */
public List<ListenerExecutor> getRequiredListenerExecutors(Class type) {
    if (!listenerExecutorsMap.containsKey(type)) {
        throw new IllegalArgumentException("不存在" + ClassUtils.getShortName(type) + "类型的监听器");
    }
    return listenerExecutorsMap.get(type);
}

/**
 * 设置服务阶段执行器
 *
 * @param clazz         服务阶段注解的class
 * @param phaseExecutor 服务阶段执行器
 * @throws IllegalArgumentException 如果入参class不是服务阶段注解
 * @throws IllegalStateException    如果已存在该类型的服务阶段执行器
 */
public void setPhaseExecutor(Class clazz, ServicePhaseExecutor phaseExecutor) {
    if (!Arrays.asList(SERVICE_PHASE_ANNOTATIONS).contains(clazz)) {
        throw new IllegalArgumentException(ClassUtils.getShortName(clazz) + "不是服务阶段注解");
    }
    if (phaseExecutorMap.containsKey(clazz)) {
        throw new IllegalStateException("服务" + serviceName + "存在多个@" + ClassUtils.getShortName(clazz) + "类型方法");
    }
    phaseExecutorMap.put(clazz, phaseExecutor);
}

/**
 * Create a new TypeMismatchException without PropertyChangeEvent.
 * @param value the offending value that couldn't be converted (may be {@code null})
 * @param requiredType the required target type (or {@code null} if not known)
 * @param cause the root cause (may be {@code null})
 */
public TypeMismatchException(Object value, Class<?> requiredType, Throwable cause) {
    super("Failed to convert value of type '" + ClassUtils.getDescriptiveType(value) + "'" +
            (requiredType != null ? " to required type '" + ClassUtils.getQualifiedName(requiredType) + "'" : ""),
            cause);
    this.value = value;
    this.requiredType = requiredType;
}