docs: private void valueProviderToBean(ValueProvider<String> valueProvider, Object bean) {
  		if (null == valueProvider) {
  			return;
  		}
  
  		final CopyOptions copyOptions = this.copyOptions;
  		Class<?> actualEditable = bean.getClass();
  		if (copyOptions.editable != null) {
  			// 检查限制类是否为target的父类或接口
  			if (false == copyOptions.editable.isInstance(bean)) {
  				throw new IllegalArgumentException(StrUtil.format("Target class [{}] not assignable to Editable class [{}]", bean.getClass().getName(), copyOptions.editable.getName()));
  			}
  			actualEditable = copyOptions.editable;
  		}
  		final HashSet<String> ignoreSet = (null != copyOptions.ignoreProperties) ? CollUtil.newHashSet(copyOptions.ignoreProperties) : null;
  		final Map<String, String> fieldReverseMapping = copyOptions.getReversedMapping();
  
  		final Collection<PropDesc> props = BeanUtil.getBeanDesc(actualEditable).getProps();
  		String fieldName;
  		Object value;
  		Method setterMethod;
  		Class<?> propClass;
  		for (PropDesc prop : props) {
  			// 获取值
  			fieldName = prop.getFieldName();
  			if (CollUtil.contains(ignoreSet, fieldName)) {
  				// 目标属性值被忽略或值提供者无此key时跳过
  				continue;
  			}
  			final String providerKey = mappingKey(fieldReverseMapping, fieldName);
  			if (false == valueProvider.containsKey(providerKey)) {
  				// 无对应值可提供
  				continue;
  			}
  			setterMethod = prop.getSetter();
  			if (null == setterMethod) {
  				// Setter方法不存在跳过
  				continue;
  			}
  
  			Type firstParamType = TypeUtil.getFirstParamType(setterMethod);
  			if (firstParamType instanceof ParameterizedType) {
  				// 参数为泛型参数类型，解析对应泛型类型为真实类型
  				ParameterizedType tmp = (ParameterizedType) firstParamType;
  				Type[] actualTypeArguments = tmp.getActualTypeArguments();
  				if (TypeUtil.hasTypeVeriable(actualTypeArguments)) {
  					// 泛型对象中含有未被转换的泛型变量
  					actualTypeArguments = TypeUtil.getActualTypes(this.destType, setterMethod.getDeclaringClass(), tmp.getActualTypeArguments());
  					if (ArrayUtil.isNotEmpty(actualTypeArguments)) {
  						// 替换泛型变量为实际类型
  						firstParamType = new ParameterizedTypeImpl(actualTypeArguments, tmp.getOwnerType(), tmp.getRawType());
  					}
  				}
  			} else if (firstParamType instanceof TypeVariable) {
  				// 参数为泛型，查找其真实类型（适用于泛型方法定义于泛型父类）
  				firstParamType = TypeUtil.getActualType(this.destType, setterMethod.getDeclaringClass(), (TypeVariable<?>) firstParamType);
  			}
  
  			value = valueProvider.value(providerKey, firstParamType);
  			if (null == value && copyOptions.ignoreNullValue) {
  				continue;// 当允许跳过空时，跳过
  			}
  			if (bean.equals(value)) {
  				continue;// 值不能为bean本身，防止循环引用
  			}
  
  			try {
  				// valueProvider在没有对值做转换且当类型不匹配的时候，执行默认转换
  				propClass = prop.getFieldClass();
  				if (false == propClass.isInstance(value)) {
  					value = Convert.convert(propClass, value);
  					if (null == value && copyOptions.ignoreNullValue) {
  						continue;// 当允许跳过空时，跳过
  					}
  				}
  
  				// 执行set方法注入值
  				setterMethod.invoke(bean, value);
  			} catch (Exception e) {
  				if (copyOptions.ignoreError) {
  					continue;// 忽略注入失败
  				} else {
  					throw new UtilException(e, "Inject [{}] error!", prop.getFieldName());
  				}
  			}
  		}
  	}