La primavera se inicia una transacción con objeto creado por el nuevo

Question

Tengo una clase POJO con un método anotado con @Transactional

public class Pojo {

    @Transactional
    public void doInTransaction() {
        ...
    }
}

gestión de transacciones declarativa primavera está basado en AOP, pero no tengo ninguna experiencia con eso. Mi pregunta es: ¿Es posible que cuando se invoca el (new Pojo).doInTransaction() solo, la primavera se iniciará una transacción.

Answer 1

Spring transacción declarativa gestión se basa en APO pero no lo hacen tienen alguna experiencia con eso.

Yo recomendaría para empezar a trabajar con él y obtendrá la experiencia de usar consejos de transacción utilizando AOP. Un buen punto de partida es href="http://static.springsource.org/spring/docs/3.0.x/spring-framework-reference/html/transaction.html" aquí .

¿Es posible que cuando se invoca el (Nueva Pojo) .doInTransaction () por sí sola, La primavera se iniciará una transacción.

No, no se puede esperar la primavera para estar al tanto de un grano que ha invocado de forma manual. Sin embargo, suena como que usted está deseando para evitar la gestión de transacciones declarativa y hacer la gestión de transacciones programática. Hay una manera de hacerlo con la primavera con el Plantilla Transacción . Es eso lo que estabas buscando?

Answer 2

No deja de ser posible, pero de una manera engorrosa: Debe utilizar el AutowireCapableBeanFactory mecanismo.

Aquí es una clase transaccional como ejemplo

public interface FooBar{
    void fooIze(Object foo);
}

public class FooBarImpl implements FooBar{
    @Transactional
    @Override
    public void fooIze(final Object foo){
        // do stuff here
    }
}

Y aquí es cómo podemos utilizarlo:

public class FooService implements ApplicationContextAware{

    private ApplicationContext applicationContext;

    @Override
    public void setApplicationContext(
    final ApplicationContext applicationContext){
        this.applicationContext = applicationContext;
    }

    public void serviceMethod(){

        //declare variable as interface, initialize to implementation
        FooBar fooBar = new FooBarImpl();

        // try to use it, won't work, as it's not a proxy yet
        Object target = new Object[0];
        fooBar.fooIze(target); // no transaction

        // now let spring create the proxy and re-assign the variable
        // to the proxy:
        fooBar = // this is no longer an instance of FooBarImpl!!!
            (FooBar) applicationContext
                .getAutowireCapableBeanFactory()
                .applyBeanPostProcessorsAfterInitialization(fooBar,
                    "someBeanName");
        fooBar.fooIze(fooBar); // this time it should work

    }

}

Esto no es una buena práctica. Por un lado, hace que su aplicación altamente consciente de la Spring Framework y también, viola los principios de inyección de dependencia. Así que utilice esta opción sólo si no hay otra manera!

Answer 3

Sí, es posible. La primavera hace no requerir el uso de proxies dinámicos para @Transactional de trabajo. En su lugar, puede utilizar "verdadero AOP", según lo dispuesto por AspectJ.

Para los detalles, véase http://static.springsource.org/spring/docs/3.0.x/spring-framework-reference/html/transaction.html#transaction-declarative-aspectj

Answer 4

El mango primavera manera la transacción a través de anotación está usando AOP como usted ha dicho. El bit de AOP se implementa utilizando servidores proxy dinámico (ver doc )

Así que para hacerlo tendrá que recuperar una instancia de la clase (Pojo aquí) a través del contenedor de primavera ya que para hacer que funcione, la primavera le devolverá un proxy dinámico sobre su Pojo que automáticamente envolvente cualquier anotada método con el código de gestión de transacciones.

Si sólo tiene que hacer un

Pojo p = new Pojo();
p.doInTransaction();

La primavera no tiene ningún papel que desempeñar aquí y su llamada al método no será dentro de una transacción.

Así que lo que hay que hacer es algo como esto

ApplicationContext springContext = ...;
Pojo p = (Pojo) springContext.getBean("your.pojo.id");
p.doInTransaction();

Nota: este es un ejemplo, se debe preferir la inyección de dependencia en lugar de recuperar su grano de forma manual desde el contexto

De este modo, y con un Contexto primavera correctamente configurado, primavera debe tener mirador sus clases de escanear para la anotación de transacciones y envuelto de forma automática sus granos en anotación en cuenta casos proxies dinámicos. Desde su punto de vista que no cambia nada, todavía tendrá emitir su objeto a sus propias clases, pero si intenta imprimir el nombre de la clase de su contexto primavera frijol Pojo, obtendrá algo tan Proxy $. .. y no el de su clase original.

Tener un vistazo a este enlace de todas formas: texto del enlace