Jestem całkiem nowy w świecie wiosennym i opracowałem prosty projekt, który wykorzystuje Spring 3.2.1 i Hibernate 4.1.9 do implementacji DAO. Projekt działa poprawnie, ale mam pewne wątpliwości co do użycia@Transakcyjny Wiosenna adnotacja na temat metody CRUD tego DAO.

To jest cały kod klasy, która implementuje operację CRUD mojego projektu:

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, jak widać, niektóre metody są opisywane przy użyciu adnotacji @ Transakcyjnej.

Czytam tutaj oficjalną dokumentacjęhttp://static.springsource.org/spring/docs/3.2.x/spring-framework-reference/html/transaction.html o użyciu tej adnotacji na temat metod i zobacz, że:Metoda opisana przy użyciu @Transactional musi mieć semantykę transakcyjną ale co to znaczy z semantyką transakcyjną?

Oznacza to, że wykonanie metosu należy uznać za wykonanie transakcji? Oznacza to, że operacje na metodzie muszą być traktowane jako pojedyncza operacja, która może prowadzić do sukcesu lub niepowodzenia, jeśli się powiedzie, wyniki operacji muszą być trwałe, podczas gdy w przypadku braku powrotu do stanu sprzed początek transakcji.

Czy to jest sens używania@Transakcyjny adnotacja na metodzie?

A co dokładnie oznaczareadOnly = false atrybut w adnotacji @ TransakcyjnejaddPerson () metoda? to znaczy, że mogę również zapisać rekord w bazie danych (i nie tylko go przeczytać) lub co? Wątpliwość jest związana, ponieważ rozumiem, że domyślnie transakcja określona za pomocą @ Adnotacja transakcyjna jestodczyt / zapis i nie tylko czytać ... Próbowałem również usunąć(readOnly = false) atrybut i nadal działa dobrze (wstaw nowy rekord do tabeli bazy danych)

Następujące dout to: „dlaczego niektóre metody są adnotowane przy użyciu adnotacji @ Transactional, a niektóre inne metody nie?

Tnx

Andrea