尝试遍历并调用此类的所有构造方法，直到构造成功并返回

@param <T> 对象类型
@param beanClass 被构造的类
@return 构造后的对象
333221
public static <T> T newInstanceIfPossible(Class<T> beanClass) {
		Assert.notNull(beanClass);
		try {
			return newInstance(beanClass);
		} catch (Exception e) {
			// ignore
			// 默认构造不存在的情况下查找其它构造
		}
		
		final Constructor<T>[] constructors = getConstructors(beanClass);
		Class<?>[] parameterTypes;
		for (Constructor<T> constructor : constructors) {
			parameterTypes = constructor.getParameterTypes();
			if (0 == parameterTypes.length) {
				continue;
			}
			constructor.setAccessible(true);
			try {
				return constructor.newInstance(ClassUtil.getDefaultValues(parameterTypes));
			} catch (Exception e) {
				// 构造出错时继续尝试下一种构造方式
				continue;
			}
		}
		return null;
	}
1056834
protected Class<?> getBeanClass(String beanName) {
        Class<?> clazz = context.getType(beanName);
        while (Proxy.isProxyClass(clazz) || Enhancer.isEnhanced(clazz)) {
            clazz = clazz.getSuperclass();
        }
        return clazz;
    }
341996
public <T> T getModel(Class<T> modelClass) {
		return (T)Injector.injectModel(modelClass, request, false);
	}
1153042
public static <T> T getBean(Class<T> clazz) {
        return getSenBotContext().context.getBean(clazz);
    }
1370500
public static Method[] getMethods(Class<?> beanClass) throws SecurityException {
		Method[] allMethods = METHODS_CACHE.get(beanClass);
		if (null != allMethods) {
			return allMethods;
		}

		allMethods = getMethodsDirectly(beanClass, true);
		return METHODS_CACHE.put(beanClass, allMethods);
	}
29698
public static Class<?> getPropertyClass(Class<?> beanClass, String field) {
        try {
            return INSTANCE.findPropertyClass(beanClass, field);
        } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
            throw handleReflectionException(beanClass, field, e);
        }
    }
1208177
public void setBeanClass(Class<?> beanClass) {
        this.beanClass = beanClass;
        this.className = beanClass.getName();
        this.factoryBean = FactoryBean.class.isAssignableFrom(beanClass);
        this.disposableBean = DisposableBean.class.isAssignableFrom(beanClass);
        this.initializableBean = InitializableBean.class.isAssignableFrom(beanClass);
        this.initializableTransletBean = InitializableTransletBean.class.isAssignableFrom(beanClass);
    }
282929
public <T extends Annotation> T getAnnotation(Class<T> annotationClass) {
        T result = null;
        if (field != null) {
            result = field.getAnnotation(annotationClass);
        }
        if (result == null && setter != null) {
            result = setter.getAnnotation(annotationClass);
        }
        if (result == null && getter != null) {
            result = getter.getAnnotation(annotationClass);
        }
        return result;
    }
1305810
public T executeFrom(Object bean) {
    List<T> executeFromCollectionResult = executeFrom(Collections.singleton(bean));
    if (CollectionUtils.isEmpty(executeFromCollectionResult)) {
      return null;
    } else {
      return executeFromCollectionResult.get(0);
    }
  }
1298921
public <T> List<T> find(Entity where, Class<T> beanClass) throws SQLException {
		return find(where.getFieldNames(), where, BeanListHandler.create(beanClass));
	}
314139
public static <E, T> List<E> convert(List<T> source, Class<E> targetClass) {
        return BeansConvertStrategy.convertBeans(source, targetClass, false);
    }
146903
private static List<PropertyDescriptor> getPropertyDescriptorsOptional(
        Class<?> beanClass)
    {
        BeanInfo beanInfo = getBeanInfoOptional(beanClass);
        if (beanInfo == null)
        {
            return Collections.emptyList();
        }
        PropertyDescriptor propertyDescriptors[] = 
            beanInfo.getPropertyDescriptors();
        if (propertyDescriptors == null)
        {
            return Collections.emptyList();
        }
        return Collections.unmodifiableList(
            new ArrayList<PropertyDescriptor>(
                Arrays.asList(propertyDescriptors)));
    }
350889
public static <T> T toBean(Map<String, ?> property, Class<T> clazz) {
        T bean = null;
        try {
            bean = clazz.newInstance();
            BeanUtils.populate(bean, property);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        return bean;
    }
671702
public ClassType<BeanType<T>> getOrCreateClazz()
   {
      Node node = childNode.getOrCreate("class");
      ClassType<BeanType<T>> clazz = new ClassTypeImpl<BeanType<T>>(this, "class", childNode, node);
      return clazz;
   }
112647
public <T> T toBean(Class<T> clazz) {
		return BeanUtil.mapToBean(this, clazz, false);
	}
1350521
public static EntityTable getEntityTable(Class<?> entityClass) {
        EntityTable entityTable = entityTableMap.get(entityClass);
        if (entityTable == null) {
            throw new MapperException("无法获取实体类" + entityClass.getCanonicalName() + "对应的表名!");
        }
        return entityTable;
    }
242373
public FacesBackingBean getFacesBackingBeanInstance( Class beanClass )
        throws InstantiationException, IllegalAccessException
    {
        assert FacesBackingBean.class.isAssignableFrom( beanClass )
                : "Class " + beanClass.getName() + " does not extend " + FacesBackingBean.class.getName();
        return ( FacesBackingBean ) beanClass.newInstance();
    }