Primavera / LDAP - métodos setter Invocación en la configuración de los granos

Question

Estoy escribiendo una aplicación Primavera LDAP y tengo que fijar la estrategia de autenticación para mi ContextSource. Me gustaría hacer esto en mi archivo XML granos. El Javadoc para ContextSource dice que tiene un método llamado colocador

setAuthenticationStrategy(
    DirContextAuthenticationStrategy authenticationStrategy
)

Para invocar esta colocador de mi archivo de frijoles, es el siguiente XML suficiente?

<bean id="authStrategy"
    class="org.springframework...DefaultTlsDirContextAuthenticationStrategy">
 ...
</bean>

<bean id="contextSource"
    class="org.springframework.ldap.core.support.LdapContextSource">

    <property name="url" ... />
    <property name="base" ... />
     ...
    <property name="authenticationStrategy" ref="authStrategy" /> 
</bean>

Es decir, lo que determina exactamente la invocación del método setAuthenticationStrategy? Es que mi nombre de propiedad es authenticationStrategy? Qué primavera se traduce automáticamente los nombres de propiedades con el método setter apropiado?

Answer 1

Su sospecha es correcta:. Primavera traduce los nombres de propiedad a los métodos setter

El grano está utilizando como argumento es de tipo DefaultTlsDirContextAuthenticationStrategy, y el método acepta un objeto de tipo DirContextAuthenticationStrategy, por lo DefaultTlsDirContextAuthenticationStrategy debe ser una subclase de implementador de DirContextAuthenticationStrategy.

Answer 2

En realidad, se entiende mal el significado de la palabra 'propiedad' en el contexto JavaBean.

Propiedades de frijol vs Los campos

El estándar JavaBeans (que sigue de cerca la primavera) define una propiedad de la haba como algo que tiene un método Getter y / o un método Setter que sigue un cierto convención de nomenclatura:

para una propiedad 'foo bar', o bien el Bar getFoo() captador (o isFoo() de propiedades booleanas) o la setFoo(Bar) colocador debe estar presente (o ambos), pero no tiene que ser un campo denominado "foo". Por convención, por lo general hay un campo con el mismo nombre que la propiedad, pero es de ninguna manera necesarias.

por ejemplo. la clase siguiente (que se ajusta a las JavaBeans estándar) tiene un grano de propiedad "foo" de tipo entero, aunque el campo subyacente se llama iAmNotFoo y es de tipo String.

public class Dummy {
    private String  iAmNotFoo;
    public Integer getFoo() {
        return  Integer.valueOf(this.iAmNotFoo);
    }

    public void setFoo(final Integer foo) {
        this.iAmNotFoo = foo.toString();
    }
}

puede poner a prueba esta hipótesis con el siguiente código:

public static void main(final String[] args) throws Exception {
    for (final PropertyDescriptor descriptor :
        Introspector
            .getBeanInfo(Dummy.class, Object.class)
            .getPropertyDescriptors()) {
        System.out.println(
            "Property: "
            + descriptor.getName()
            + ", type: "
            + descriptor.getPropertyType()
        );
    }
    for (final Field field : Dummy.class.getDeclaredFields()) {
        System.out.println(
            "Field: " 
            + field.getName() 
            + ", type: " 
            + field.getType());
    }
}

Salida:

Propiedad: foo, Tipo: Clase java.lang.Integer
Campo: iAmNotFoo, Tipo: java.lang.String clase

Propiedades en la primavera

Como he dicho anteriormente, Spring utiliza este mecanismo exacto de propiedades de deformación. Por eso, cuando se configura un frijol como esto

<bean class="Dummy">
    <property name="foo" value="123" />
</bean>

"foo" se refiere a la "foo" propiedad de bean y por lo tanto a la setter setFoo()

Lo que hace construcciones como posible lo siguiente:

public class Dummy2 {
    private List<String> foos;
    public void setFoos(List<String> foos) {
        this.foos = foos;
    }
    public void setFoo(String foo){
        this.foos = Collections.singletonList(foo);
    }
}

Se puede transferir la siguiente manera

<bean class="Dummy2">
    <!-- either set a single value -->
    <property name="foo" value="123" /> 
    <!-- or a list of values -->
    <property name="foos"> 
        <util:list>
            <value>Abc</value>
            <value>Xyz</value>
            <value>123</value>
            <value>789</value>
        </util:list>
    </property>
</bean>

Como se puede ver, los métodos setter son relevantes para la primavera, no los campos reales.

Por lo tanto, en JavaBeans habla: ¡El campo = propiedad, aunque en la mayoría de los casos existe un campo del mismo tipo y nombre que la propiedad

.