A menudo puede encontrarse en una situación con muchas definiciones de proxy similares, especialmente cuando se definen proxy transaccionales. Al utilizar definiciones de beans primarios y secundarios junto con definiciones de beans internos, puede obtener definiciones de proxy mucho más limpias y concisas.

Primero, cree una definición de bean de plantilla principal para el proxy, como se muestra a continuación:

<bean id="txProxyTemplate" abstract="true"
        class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
    <nombre de propiedad="transactionManager" ref="transactionManager"/>
    <nombre de propiedad="transactionAttributes">
        <accesorios>
            <prop key="*">PROPAGATION_REQUIRED</prop>
        </accesorios>
    </propiedad>
</bean>

Nunca se crea una instancia por sí solo, por lo que es posible que no esté completo. Luego, cada proxy que deba crearse será una definición de bean secundario, envolviendo el objetivo del proxy como una definición de bean interna, ya que el objetivo nunca se usa por sí solo. El siguiente ejemplo muestra un bean hijo como este:

<bean id="myService" parent="txProxyTemplate">
    <nombre de propiedad="destino">
        <bean class="org.springframework.samples.MyServiceImpl">
        </frijol>
    </propiedad>
</bean>

Puede anular las propiedades de la plantilla principal. En el siguiente ejemplo, anulamos la configuración de propagación de transacciones:

<bean id="mySpecialService" parent="txProxyTemplate">
    <nombre de propiedad="destino">
        <bean class="org.springframework.samples.MySpecialServiceImpl">
        </frijol>
    </propiedad>
    <nombre de propiedad="transactionAttributes">
        <accesorios>
            <prop key="get*">PROPAGATION_REQUIRED,readOnly</prop>
            <prop key="find*">PROPAGATION_REQUIRED,readOnly</prop>
            <prop key="load*">PROPAGATION_REQUIRED,readOnly</prop>
            <prop key="store*">PROPAGATION_REQUIRED</prop>
        </accesorios>
    </propiedad>
</bean>

Tenga en cuenta que en el ejemplo del bean principal, marcamos explícitamente la definición del bean principal como abstracta estableciendo el atributo abstract en true, de modo que su instancia en realidad nunca existió. realmente creado. Los contextos de aplicación (pero no las simples fábricas de beans) crean previamente de forma predeterminada todas las instancias singleton. Por lo tanto, es importante (al menos en el caso de los beans singleton) que si tienes una definición de bean (principal) que solo vas a usar como plantilla, y esa definición define una clase, entonces debes asegurarte de que el atributo abstract está establecido en true. De lo contrario, el contexto de la aplicación intentará crear previamente una instancia de la misma.

Crear un proxy AOP mediante programación usando ProxyFactory

Crear proxies AOP mediante programación usando Spring es muy fácil. Esto le permitirá utilizar el módulo Spring AOP sin depender del módulo Spring IoC.

Las interfaces implementadas por el objetivo se proxy automáticamente. La siguiente lista demuestra la creación de un proxy para un objetivo con un interceptor y un asesor:

Java
ProxyFactory factory = new ProxyFactory(myBusinessInterfaceImpl);
factory.addAdvice(myMethodInterceptor);
factory.addAdvisor(miAsesor);
MyBusinessInterface tb = (MyBusinessInterface) factory.getProxy();
Kotlin
val factory = ProxyFactory(myBusinessInterfaceImpl)
factory.addAdvice(miMethodInterceptor)
factory.addAdvisor(miAsesor)
val tb = factory.proxy como MyBusinessInterface

El primer paso es crear un objeto de tipo org.springframework.aop.framework.ProxyFactory. Se puede crear utilizando un objeto de destino, como en el ejemplo anterior, o puede especificar las interfaces que serán proxy en un constructor alternativo.

Puede agregar sugerencias (con interceptores como un tipo de asesoramiento especializado), asesores o ambos, y manipularlos durante todo el ciclo de vida de ProxyFactory. Si agrega IntroductionInterceptionAroundAdvisor, se puede forzar al proxy a implementar interfaces adicionales.

ProxyFactory también tiene métodos convenientes (heredados de AdvisedSupport) que le permiten agregar otros tipos de consejos, como el consejo "antes" y la "excepción de lanzamiento". consejo. AdvisedSupport es la superclase de ProxyFactory y ProxyFactoryBean.

Integrar la creación de proxy AOP con un marco IoC es una práctica recomendada en la mayoría de las aplicaciones. Recomendamos transferir la configuración del código Java a un archivo externo usando AOP, como se debe hacer en general.