Cuando se usa Spring, ¿es posible establecer una propiedad solo si el valor pasado no es nulo?

Ejemplo

<bean name="myBean" class="some.Type">
   <property name="abc" value="${some.param}"/>
</bean>

El comportamiento que estoy buscando es:

some.Type myBean = new some.Type();
if (${some.param} != null) myBean.setAbc(${some.param});

La razón por la que necesito esto es porqueabc tiene un valor predeterminado que no quiero anular con unanull. Y el Bean que estoy creando no está bajo mi control de origen, por lo que no puedo cambiar su comportamiento. (También,abc para este propósito puede ser primitivo, por lo que no puedo configurarlo con un valor nulo de todos modos.

EDITAR
Según las respuestas, creo que mi pregunta requiere aclaración.

Tengo bean que necesito para instanciar y pasar a la tercera parte que uso. Este bean tiene muchas propiedades (12 actualmente) de varios tipos int, boolean, String, etc.)
Cada propiedad tiene un valor predeterminado: no sé qué es y preferiría no necesitar saberlo a menos que se convierta en un problema. Lo que estoy buscando es una solución genérica que provenga de las habilidades de Spring: actualmente, la única solución que tengo es una reflexión.

Configuració

<bean id="myBean" class="some.TypeWrapper">
   <property name="properties">
     <map>
         <entry key="abc" value="${some.value}"/>
         <entry key="xyz" value="${some.other.value}"/>
         ...
      </map>
   </property>
</bean>

Códig

public class TypeWrapper
{
    private Type innerBean;

    public TypeWrapper()
    {
        this.innerBean = new Type();
    }

    public void setProperties(Map<String,String> properties)
    {
        if (properties != null)
        {
            for (Entry<String, Object> entry : properties.entrySet())
            {
                String propertyName = entry.getKey();
                Object propertyValue = entry.getValue();

                setValue(propertyName, propertyValue);
            }
        }
    }

    private void setValue(String propertyName, Object propertyValue)
    {
        if (propertyValue != null)
        {
           Method method = getSetter(propertyName);
           Object value = convertToValue(propertyValue, method.getParameterTypes()[0]);
           method.invoke(innerBean, value);
        }
    }

    private Method getSetter(String propertyName)
    {
      // Assume a valid bean, add a "set" at the beginning and toUpper the 1st character.
      // Scan the list of methods for a method with the same name, assume it is a "valid setter" (i.e. single argument)
      ... 
    }

    private Object convertToValue(String valueAsString, Class type)
    {
        // Check the type for all supported types and convert accordingly
        if (type.equals(Integer.TYPE))
        {
          ...
        }
        else if (type.equals(Integer.TYPE))
        {
          ...
        }
        ...
    }
}

a verdadera "dificultad" está en implementarconvertToValue para todos los tipos de valores posibles. Lo he hecho más de una vez en mi vida, por lo que no es un problema importante implementarlo para todos los tipos posibles que necesito (principalmente primitivas y algunas enumeraciones), pero esperaba que existiera una solución más inteligente.