import org.apache.ojb.broker.accesslayer.conversions.FieldConversion; //导入依赖的package包/类
public void saveValue(Object objekt, Object value)
{
    if ((this.fieldSource == SOURCE_FIELD) && (this.returnedByProcedure))
    {
        FieldDescriptor fd = this.getFieldRef();
        FieldConversion conversion = null;
        if (fd != null)
        {
            conversion = fd.getFieldConversion();
            if (conversion == null)
            {
                fd.getPersistentField().set(objekt, value);
            }
            else
            {
                fd.getPersistentField().set(objekt, conversion.sqlToJava(value));
            }
        }
    }
}
 

import org.apache.ojb.broker.accesslayer.conversions.FieldConversion; //导入依赖的package包/类
/** gets the annotation but also adds an import in the process if a Convert annotation is required. */
@Override
protected NodeData getAnnotationNodes(String enclosingClass, String fieldName, String mappedClass) {
    final FieldDescriptor fd = OjbUtil.findFieldDescriptor(mappedClass, fieldName, descriptorRepositories);

    if (fd != null) {
        final FieldConversion fc = fd.getFieldConversion();
        //in ojb all columns have at least the default field conversion
        if (fc != null && FieldConversionDefaultImpl.class != fc.getClass()) {
            LOG.info(enclosingClass + "." + fieldName + " for the mapped class " + mappedClass + " field has a converter " + fc.getClass().getName());

            final String jpaConverter = getJpaConverterForOjbClass(fc.getClass().getName());
            if (jpaConverter == null) {
                LOG.error(ResolverUtil.logMsgForField(enclosingClass, fieldName, mappedClass) + " field has a converter " + fc.getClass().getName()
                    + " but a replacement converter was not configured, unable to set Convert class");
                return new NodeData(new NormalAnnotationExpr(new NameExpr(SIMPLE_NAME), Collections.singletonList(new MemberValuePair("converter", new NameExpr(null)))),
                        new ImportDeclaration(new QualifiedNameExpr(new NameExpr(PACKAGE), SIMPLE_NAME), false, false));
            } else if ( StringUtils.isBlank(jpaConverter) ) {
                LOG.info(ResolverUtil.logMsgForField(enclosingClass, fieldName, mappedClass) + " field has a converter " + fc.getClass().getName()
                        + " But no converter definition is needed due to default converter configuration." );
            } else {
                final String shortClassName = ClassUtils.getShortClassName(jpaConverter);
                final String packageName = ClassUtils.getPackageName(jpaConverter);
                return new NodeData(new NormalAnnotationExpr(new NameExpr(SIMPLE_NAME),  Collections.singletonList(new MemberValuePair("converter", new NameExpr(shortClassName + ".class")))),
                        new ImportDeclaration(new QualifiedNameExpr(new NameExpr(PACKAGE), SIMPLE_NAME), false, false),
                        Collections.singletonList(new ImportDeclaration(new QualifiedNameExpr(new NameExpr(packageName), shortClassName), false, false)));
            }
        }
    }
    return null;
}
 

import org.apache.ojb.broker.accesslayer.conversions.FieldConversion; //导入依赖的package包/类
/**
 * Answer the FieldConversions for the PkFields 
 * @param cld
 * @return the pk FieldConversions
 */
private FieldConversion[] getPkFieldConversion(ClassDescriptor cld)
{
    FieldDescriptor[] pks = cld.getPkFields();
    FieldConversion[] fc = new FieldConversion[pks.length]; 
    
    for (int i= 0; i < pks.length; i++)
    {
        fc[i] = pks[i].getFieldConversion();
    }
    
    return fc;
}
 

import org.apache.ojb.broker.accesslayer.conversions.FieldConversion; //导入依赖的package包/类
/**
 * Convert the Values using the FieldConversion.sqlToJava
 * @param fcs
 * @param values
 */
private Object[] convert(FieldConversion[] fcs, Object[] values)
{
    Object[] convertedValues = new Object[values.length];
    
    for (int i= 0; i < values.length; i++)
    {
        convertedValues[i] = fcs[i].sqlToJava(values[i]);
    }

    return convertedValues;
}
 

import org.apache.ojb.broker.accesslayer.conversions.FieldConversion; //导入依赖的package包/类
/**
 * Sets the fieldConversion.
 * @param fieldConversionClassName The fieldConversion to set
 */
public void setFieldConversionClassName(String fieldConversionClassName)
{
    try
    {
        this.fieldConversion = (FieldConversion) ClassHelper.newInstance(fieldConversionClassName);
    }
    catch (Exception e)
    {
        throw new MetadataException(
                "Could not instantiate FieldConversion class using default constructor", e);
    }
}
 

import org.apache.ojb.broker.accesslayer.conversions.FieldConversion; //导入依赖的package包/类
public Object getValue(Object objekt)
{
    switch (this.fieldSource)
    {
        case SOURCE_FIELD :
            if (objekt == null)
            {
                return null;
            }
            else
            {
                FieldDescriptor fd = this.getFieldRef();
                Object value = null;
                FieldConversion conversion = null;
                if (fd != null)
                {
                    conversion = fd.getFieldConversion();
                    value = fd.getPersistentField().get(objekt);
                    if (conversion != null)
                    {
                        value = conversion.javaToSql(value);
                    }
                }
                return value;
            }
        case SOURCE_VALUE :
            return this.constantValue;
        case SOURCE_NULL :
            return null;
        default :
            return null;
    }
}
 

import org.apache.ojb.broker.accesslayer.conversions.FieldConversion; //导入依赖的package包/类
/**
 * Sets the fieldConversion.
 * @param fieldConversion The fieldConversion to set
 * @deprecated use setFieldConversionClassName instead
 */
public void setFieldConversion(FieldConversion fieldConversion)
{
    this.fieldConversion = fieldConversion;
}