Ao usar o Spring, é possível definir uma propriedade apenas se o valor passado não for nul

Exemplo

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

O comportamento que estou procurando é:

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

A razão pela qual eu preciso disso é porqueabc tem um valor padrão que não quero substituir por umnull. E o Bean que estou criando não está sob meu controle de origem - portanto, não posso mudar seu comportamento. (Além disso,abc para esse propósito pode ser um primitivo, então não posso defini-lo com um nulo de qualquer maneir

EDITAR
De acordo com as respostas, acho que minha pergunta requer esclarecimento

Eu tenho bean, preciso instanciar e passar para terceiros que eu uso. Este bean possui muitas propriedades (12 atualmente) de vários tipos int, boolean, String, etc.)
Cada propriedade tem um valor padrão - não sei o que é e preferiria não precisar saber, a menos que isso se tornasse um problema. O que estou procurando é uma solução genérica que deriva das habilidades do Spring - atualmente a única solução que tenho é uma reflexão.

Configuraçã

<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 verdadeira "dificuldade" está em implementarconvertToValue para todos os tipos de valor possíveis. Eu fiz isso mais de uma vez na minha vida - portanto, não é um problema importante implementá-lo para todos os tipos possíveis de que preciso (principalmente primitivos e algumas enumerações) - mas esperava que houvesse uma solução mais inteligente.