Soy bastante nuevo en Spring World y he desarrollado un proyecto simple que utiliza Spring 3.2.1 e Hibernate 4.1.9 para implementar un DAO. El proyecto funciona correctamente pero tengo algunas dudas sobre el uso de@Transaccional Anotación primaveral sobre el método CRUD de este DAO.

Este es el código completo de la clase que implementa la operación CRUD de mi proyecto:

package org.andrea.myexample.HibernateOnSpring.dao;

import java.util.List;

import org.andrea.myexample.HibernateOnSpring.entity.Person;

import org.hibernate.Criteria;
import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;
import org.hibernate.service.ServiceRegistryBuilder;
import org.springframework.transaction.annotation.Transactional;

public class PersonDAOImpl implements PersonDAO {

    // Factory per la creazione delle sessioni di Hibernate:
    private static SessionFactory sessionFactory;

    // Metodo Setter per l'iniezione della dipendenza della SessionFactory:
    public void setSessionFactory(SessionFactory sessionFactory) {
        this.sessionFactory = sessionFactory;
    }

    /** CREATE CRUD Operation:
     * Aggiunge un nuovo record rappresentato nella tabella rappresentato
     * da un oggetto Person
     */
    @Transactional(readOnly = false)
    public Integer addPerson(Person p) {

        System.out.println("Inside addPerson()");

        Session session = sessionFactory.openSession();

        Transaction tx = null;
        Integer personID = null;

        try {
            tx = session.beginTransaction();

            personID = (Integer) session.save(p);
            tx.commit();
        } catch (HibernateException e) {
            if (tx != null)
                tx.rollback();
            e.printStackTrace();
        } finally {
            session.close();
        }

        return personID;

    }

    // READ CRUD Operation (legge un singolo record avente uno specifico id):
    public Person getById(int id) {

        System.out.println("Inside getById()");

        Session session = sessionFactory.openSession();

        Transaction tx = null;          
        Person retrievedPerson = null;  

        try {
            tx = session.beginTransaction();
            retrievedPerson = (Person) session.get(Person.class, id);
            tx.commit();
        }catch (HibernateException e) { 
            if (tx != null)                 
                tx.rollback();          
            e.printStackTrace();
        } finally {                 
            session.close();
        }

        return retrievedPerson;
    }

    // READ CRUD Operation (recupera la lista di tutti i record nella tabella):
    @SuppressWarnings("unchecked")
    public List<Person> getPersonsList() {

        System.out.println("Inside getPersonsList()");

        Session session = sessionFactory.openSession();
        Transaction tx = null;
        List<Person> personList = null;

        try {
            tx = session.beginTransaction();
            Criteria criteria = session.createCriteria(Person.class);
            personList = criteria.list();
            System.out.println("personList: " + personList);
            tx.commit();
        }catch (HibernateException e) { 
            if (tx != null)                 
                tx.rollback();          
            e.printStackTrace();
        } finally {
            session.close();
        }
        return personList;
    }

    // DELETE CRUD Operation (elimina un singolo record avente uno specifico id):
    public void delete(int id) {

        System.out.println("Inside delete()");

        Session session = sessionFactory.openSession();
        Transaction tx = null;

        try {
            tx = session.beginTransaction();
            Person personToDelete = getById(id);
            session.delete(personToDelete);
            tx.commit();
        }catch (HibernateException e) { 
            if (tx != null)                 
                tx.rollback();          
            e.printStackTrace();
        } finally {
            session.close();
        }

    }

    @Transactional
    public void update(Person personToUpdate) {

        System.out.println("Inside update()");

        Session session = sessionFactory.openSession();
        Transaction tx = null;

        try {
            System.out.println("Insite update() method try");
            tx = session.beginTransaction();
            session.update(personToUpdate);

            tx.commit();
        }catch (HibernateException e) { 
            if (tx != null)                 
                tx.rollback();          
            e.printStackTrace();
        } finally {
            session.close();
        }   

    }

}

Ok, como puede ver, algunos métodos están anotados usando @Transactional nototation.

Estoy leyendo la documentación oficial aquí.http://static.springsource.org/spring/docs/3.2.x/spring-framework-reference/html/transaction.html sobre el uso de esta anotación en los métodos y ver que:Un método anotado usando @Transactional debe tener semántica transaccional ¿Pero qué significa con semántica transaccional?

¿Significa que la ejecución de methos debe considerarse como la ejecución de una transacción? Por lo tanto, significa que las operaciones del método se deben considerar como una sola operación que puede llevar a un éxito o una falla, si tienen éxito, los resultados de las operaciones deben ser permanentes, mientras que en caso de no regresar al estado antes de El inicio de la transacción.

¿Es este el significado de uso?@Transaccional anotación sobre un método?

¿Y qué significa exactamente elreadOnly = false atributo en la @ anotación transaccional de laaddPerson () ¿método? ¿Significa que también puedo escribir un registro en la base de datos (y no solo leerlo) o qué? La duda está relacionada porque tengo entendido que, de forma predeterminada, una transacción definida utilizando @Transactional annotaion esleer escribir Y no solo leer ... También he intentado borrar el(readOnly = false) atributo y aún funciona bien (inserte el nuevo registro en la tabla de la base de datos)

La siguiente pregunta es: "¿por qué algunos métodos se anotan utilizando @Transactional anotación y otros métodos no? ¿Es una buena práctica anotar TODO el método CRUD retirado @Transactional?"

Tnx

Andrea