Ich bin ziemlich neu in der Spring-Welt und habe ein einfaches Projekt entwickelt, das Spring 3.2.1 und Hibernate 4.1.9 verwendet, um ein DAO zu implementieren. Das Projekt funktioniert einwandfrei, aber ich habe einige Zweifel an der Verwendung von@Transactional Frühlingsanmerkung zur CRUD-Methode dieses DAO.

Dies ist der gesamte Code der Klasse, die die CRUD-Operation meines Projekts implementiert:

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();
        }   

    }

}

Wie Sie sehen, werden einige Methoden mit @Transactional-Annotation annotiert.

Ich lese hier die offizielle Dokumentationhttp://static.springsource.org/spring/docs/3.2.x/spring-framework-reference/html/transaction.html über die Verwendung dieser Annotation auf Methoden und es sieht so aus:Eine mit @Transactional annotierte Methode muss eine Transaktionssemantik haben aber was bedeutet das mit transaktionssemantik?

Es bedeutet, dass die Methos-Ausführung als die Ausführung einer Transaktion betrachtet werden muss? Das bedeutet, dass die Methodenoperationen als eine einzige Operation betrachtet werden müssen, die zu einem Erfolg oder Misserfolg führen kann. Wenn sie erfolgreich sind, müssen die Ergebnisse der Operationen dauerhaft sein, während im Falle eines Misserfolgs die Rückkehr zum vorherigen Zustand fehlschlägt der Beginn der Transaktion.

Ist das die Bedeutung der Verwendung@Transactional Anmerkung zu einer Methode?

Und was genau bedeutet das?readOnly = false Attribut in der @ Transactional Annotation deraddPerson () Methode? es bedeutet, dass ich auch einen Datensatz in die Datenbank schreiben kann (und nicht nur lesen kann) oder was? Der Zweifel hängt damit zusammen, dass ich verstehe, dass eine mit @Transactional annotaion definierte Transaktion standardmäßig istlesen Schreiben und nicht nur lesen ... ich habe auch versucht das zu löschen(readOnly = false) Attribut und funktionieren immer noch gut (fügen Sie den neuen Datensatz in die Datenbanktabelle ein)

Die folgende Anweisung lautet: "Warum werden einige Methoden mit @Transactional-Annotation und andere nicht mit @Transactional-Annotation annotiert? Ist es eine gute Übung, ALL CRUD-Methoden mit @Transactional zu annotieren?"

Tnx

Andrea