/**
* 查找自增主键并填充到队列中
*
* @param objs 填充对象
* @throws IllegalArgumentException exception
* @throws IllegalAccessException exception
* @throws SQLException exception
*/
public void find(Object... objs)
throws IllegalArgumentException, IllegalAccessException, SQLException {
Class<?> clz = objs[0].getClass();
Field[] fields = clz.getDeclaredFields();
for (Field field : fields) {
ORMColumn oc = field.getAnnotation(ORMColumn.class);
if (oc != null && oc.physicalPkFld() && oc.autoIncrement()) {
// 找到最后一个自增id
QueryRunner qr = new QueryRunner();
Object identityVal = qr.query(conn, selectKey.getQuery(), new ScalarHandler<Object>());
Long identity = NumberUtils.parseNumber(identityVal.toString(), Long.class);
field.setAccessible(true);
// 填充到所有当中
for (int i = objs.length - 1; i >= 0; i--) {
if (field.get(objs[i]) == null) { // 判null，要求主键都是包装类
// 类型转换
@SuppressWarnings("unchecked")
Object val =
NumberUtils.convertNumberToTargetClass(identity, ((Class<Number>) field.getType()));
field.set(objs[i], val);
identity--;
}
}
break;
}
}
}
/** Parse the Number from the given text, using the specified NumberFormat. */
@Override
public void setAsText(String text) throws IllegalArgumentException {
if (this.allowEmpty && !StringUtils.hasText(text)) {
// Treat empty String as null value.
setValue(null);
} else if (this.numberFormat != null) {
// Use given NumberFormat for parsing text.
setValue(NumberUtils.parseNumber(text, this.numberClass, this.numberFormat));
} else {
// Use default valueOf methods for parsing text.
setValue(NumberUtils.parseNumber(text, this.numberClass));
}
}
/** Coerce a Number value into the required target class, if necessary. */
@Override
public void setValue(Object value) {
if (value instanceof Number) {
super.setValue(NumberUtils.convertNumberToTargetClass((Number) value, this.numberClass));
} else {
super.setValue(value);
}
}
/**
* Convert the value to the required type (if necessary from a String), for the specified
* property.
*
* @param propertyName name of the property
* @param oldValue the previous value, if available (may be {@code null})
* @param newValue the proposed new value
* @param requiredType the type we must convert to (or {@code null} if not known, for example in
* case of a collection element)
* @param typeDescriptor the descriptor for the target property or field
* @return the new value, possibly the result of type conversion
* @throws IllegalArgumentException if type conversion failed
*/
@SuppressWarnings("unchecked")
public <T> T convertIfNecessary(
String propertyName,
Object oldValue,
Object newValue,
Class<T> requiredType,
TypeDescriptor typeDescriptor)
throws IllegalArgumentException {
// Custom editor for this type?
PropertyEditor editor =
this.propertyEditorRegistry.findCustomEditor(requiredType, propertyName);
ConversionFailedException conversionAttemptEx = null;
// No custom editor but custom ConversionService specified?
ConversionService conversionService = this.propertyEditorRegistry.getConversionService();
if (editor == null && conversionService != null && newValue != null && typeDescriptor != null) {
TypeDescriptor sourceTypeDesc = TypeDescriptor.forObject(newValue);
if (conversionService.canConvert(sourceTypeDesc, typeDescriptor)) {
try {
return (T) conversionService.convert(newValue, sourceTypeDesc, typeDescriptor);
} catch (ConversionFailedException ex) {
// fallback to default conversion logic below
conversionAttemptEx = ex;
}
}
}
Object convertedValue = newValue;
// Value not of required type?
if (editor != null
|| (requiredType != null && !ClassUtils.isAssignableValue(requiredType, convertedValue))) {
if (typeDescriptor != null
&& requiredType != null
&& Collection.class.isAssignableFrom(requiredType)
&& convertedValue instanceof String) {
TypeDescriptor elementTypeDesc = typeDescriptor.getElementTypeDescriptor();
if (elementTypeDesc != null) {
Class<?> elementType = elementTypeDesc.getType();
if (Class.class == elementType || Enum.class.isAssignableFrom(elementType)) {
convertedValue = StringUtils.commaDelimitedListToStringArray((String) convertedValue);
}
}
}
if (editor == null) {
editor = findDefaultEditor(requiredType);
}
convertedValue = doConvertValue(oldValue, convertedValue, requiredType, editor);
}
boolean standardConversion = false;
if (requiredType != null) {
// Try to apply some standard type conversion rules if appropriate.
if (convertedValue != null) {
if (Object.class == requiredType) {
return (T) convertedValue;
} else if (requiredType.isArray()) {
// Array required -> apply appropriate conversion of elements.
if (convertedValue instanceof String
&& Enum.class.isAssignableFrom(requiredType.getComponentType())) {
convertedValue = StringUtils.commaDelimitedListToStringArray((String) convertedValue);
}
return (T)
convertToTypedArray(convertedValue, propertyName, requiredType.getComponentType());
} else if (convertedValue instanceof Collection) {
// Convert elements to target type, if determined.
convertedValue =
convertToTypedCollection(
(Collection<?>) convertedValue, propertyName, requiredType, typeDescriptor);
standardConversion = true;
} else if (convertedValue instanceof Map) {
// Convert keys and values to respective target type, if determined.
convertedValue =
convertToTypedMap(
(Map<?, ?>) convertedValue, propertyName, requiredType, typeDescriptor);
standardConversion = true;
}
if (convertedValue.getClass().isArray() && Array.getLength(convertedValue) == 1) {
convertedValue = Array.get(convertedValue, 0);
standardConversion = true;
}
if (String.class == requiredType
&& ClassUtils.isPrimitiveOrWrapper(convertedValue.getClass())) {
// We can stringify any primitive value...
return (T) convertedValue.toString();
} else if (convertedValue instanceof String && !requiredType.isInstance(convertedValue)) {
if (conversionAttemptEx == null
&& !requiredType.isInterface()
&& !requiredType.isEnum()) {
try {
Constructor<T> strCtor = requiredType.getConstructor(String.class);
return BeanUtils.instantiateClass(strCtor, convertedValue);
} catch (NoSuchMethodException ex) {
// proceed with field lookup
if (logger.isTraceEnabled()) {
logger.trace(
"No String constructor found on type [" + requiredType.getName() + "]", ex);
}
} catch (Exception ex) {
if (logger.isDebugEnabled()) {
logger.debug(
"Construction via String failed for type [" + requiredType.getName() + "]", ex);
}
}
}
String trimmedValue = ((String) convertedValue).trim();
if (requiredType.isEnum() && "".equals(trimmedValue)) {
// It's an empty enum identifier: reset the enum value to null.
return null;
}
convertedValue = attemptToConvertStringToEnum(requiredType, trimmedValue, convertedValue);
standardConversion = true;
} else if (convertedValue instanceof Number
&& Number.class.isAssignableFrom(requiredType)) {
convertedValue =
NumberUtils.convertNumberToTargetClass(
(Number) convertedValue, (Class<Number>) requiredType);
standardConversion = true;
}
} else {
// convertedValue == null
if (requiredType == Optional.class) {
convertedValue = Optional.empty();
}
}
if (!ClassUtils.isAssignableValue(requiredType, convertedValue)) {
if (conversionAttemptEx != null) {
// Original exception from former ConversionService call above...
throw conversionAttemptEx;
} else if (conversionService != null) {
// ConversionService not tried before, probably custom editor found
// but editor couldn't produce the required type...
TypeDescriptor sourceTypeDesc = TypeDescriptor.forObject(newValue);
if (conversionService.canConvert(sourceTypeDesc, typeDescriptor)) {
return (T) conversionService.convert(newValue, sourceTypeDesc, typeDescriptor);
}
}
// Definitely doesn't match: throw IllegalArgumentException/IllegalStateException
StringBuilder msg = new StringBuilder();
msg.append("Cannot convert value of type '")
.append(ClassUtils.getDescriptiveType(newValue));
msg.append("' to required type '")
.append(ClassUtils.getQualifiedName(requiredType))
.append("'");
if (propertyName != null) {
msg.append(" for property '").append(propertyName).append("'");
}
if (editor != null) {
msg.append(": PropertyEditor [")
.append(editor.getClass().getName())
.append("] returned inappropriate value of type '")
.append(ClassUtils.getDescriptiveType(convertedValue))
.append("'");
throw new IllegalArgumentException(msg.toString());
} else {
msg.append(": no matching editors or conversion strategy found");
throw new IllegalStateException(msg.toString());
}
}
}
if (conversionAttemptEx != null) {
if (editor == null
&& !standardConversion
&& requiredType != null
&& Object.class != requiredType) {
throw conversionAttemptEx;
}
logger.debug(
"Original ConversionService attempt failed - ignored since "
+ "PropertyEditor based conversion eventually succeeded",
conversionAttemptEx);
}
return (T) convertedValue;
}