uzyskiwanie pakietu org.springframework.transaction.annotation nie istnieje błąd podczas pakowania aplikacji

Question

Jestem całkiem nowy w świecie Wiosny. Rozwinąłem DAO używając Spring 3.2 i Hibernate 4.1.9, ale zauważyłem dziwną rzecz.

Wszystkie używane zależności związane ze sprężyną należą do wersji 3.2.1, z wyjątkiem tych związanych z modułem spring-aop. Dla tego modułu muszę korzystać z wersji 3.2.0, ponieważ jeśli używam 3.2.1 we wdrażaniu klasy dao nie znajdziesz tego importu: org.springframework.transaction.annotation.Transactional

To jest mój Oryginalny pom.xml pliku (który działa dobrze):

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> 
    <modelVersion>4.0.0</modelVersion> 

    <groupId>org.andrea.myexample</groupId> 
    <artifactId>HibernateOnSpring</artifactId> 
    <version>0.0.1-SNAPSHOT</version> 
    <packaging>jar</packaging> 

    <name>HibernateOnSpring</name> 
    <url>http://maven.apache.org</url> 

    <properties> 
     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> 
    </properties> 

    <dependencies> 
     <dependency> 
      <groupId>junit</groupId> 
      <artifactId>junit</artifactId> 
      <version>3.8.1</version> 
      <scope>test</scope> 
     </dependency> 

     <!-- Dipendenze di Spring Framework --> 
     <dependency> 
      <groupId>org.springframework</groupId> 
      <artifactId>spring-core</artifactId> 
      <version>3.2.1.RELEASE</version> 
     </dependency> 
     <dependency> 
      <groupId>org.springframework</groupId> 
      <artifactId>spring-beans</artifactId> 
      <version>3.2.1.RELEASE</version> 
     </dependency> 
     <dependency> 
      <groupId>org.springframework</groupId> 
      <artifactId>spring-context</artifactId> 
      <version>3.2.1.RELEASE</version> 
     </dependency> 
     <dependency> 
      <groupId>org.springframework</groupId> 
      <artifactId>spring-context-support</artifactId> 
      <version>3.2.1.RELEASE</version> 
     </dependency> 


     <dependency> <!-- Usata da Hibernate 4 per LocalSessionFactoryBean --> 
      <groupId>org.springframework</groupId> 
      <artifactId>spring-orm</artifactId> 
      <version>3.2.0.RELEASE</version> 
     </dependency> 

     <!-- Dipendenze per AOP --> 
     <dependency> 
      <groupId>cglib</groupId> 
      <artifactId>cglib</artifactId> 
      <version>2.2.2</version> 
     </dependency> 

     <!-- Dipendenze per Persistence Managment --> 

     <dependency> <!-- Apache BasicDataSource --> 
      <groupId>commons-dbcp</groupId> 
      <artifactId>commons-dbcp</artifactId> 
      <version>1.4</version> 
     </dependency> 

     <dependency> <!-- MySQL database driver --> 
      <groupId>mysql</groupId> 
      <artifactId>mysql-connector-java</artifactId> 
      <version>5.1.23</version> 
     </dependency> 

     <dependency> <!-- Hibernate --> 
      <groupId>org.hibernate</groupId> 
      <artifactId>hibernate-core</artifactId> 
      <version>4.1.9.Final</version> 
     </dependency> 

    </dependencies> 
</project> 

i to jest moje PersonDAOImpl klasy (klasa że wdrożenie mój konkretny DAO):

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; 

    public void setSessionFactory(SessionFactory sessionFactory) { 
     this.sessionFactory = sessionFactory; 
    } 

    // CREATE CRUD Operation: 
    @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(); 
     } 

    } 

} 

Problemem jest to, że w przypadku korzystania z wersji 3.2.1 dla wiosna-AOP modułu zamiast 3.2.0 zmieniającym się tę zależność w następujący sposób:

<dependency> <!-- Usata da Hibernate 4 per LocalSessionFactoryBean --> 
     <groupId>org.springframework</groupId> 
     <artifactId>spring-orm</artifactId> 
     <version>3.2.1.RELEASE</version> 
    </dependency> 

Kiedy uruchomić Maven ---> Maven zainstalować zdarzyć kompilacja powiedzie i zwróci następujący komunikat o błędzie:

[ERROR] COMPILATION ERROR : 
[INFO] ------------------------------------------------------------- 
[ERROR] /home/andrea/Documents/ws/HibernateOnSpring/src/main/java/org/andrea/myexample/HibernateOnSpring/dao/PersonDAOImpl.java:[15,49] error: package org.springframework.transaction.annotation does not exist 
[ERROR] /home/andrea/Documents/ws/HibernateOnSpring/src/main/java/org/andrea/myexample/HibernateOnSpring/dao/PersonDAOImpl.java:[27,2] error: cannot find symbol 
[ERROR] class PersonDAOImpl 
/home/andrea/Documents/ws/HibernateOnSpring/src/main/java/org/andrea/myexample/HibernateOnSpring/dao/PersonDAOImpl.java:[128,2] error: cannot find symbol 
[INFO] 3 errors 
[INFO] ------------------------------------------------------------- 
[INFO] ------------------------------------------------------------------------ 
[INFO] BUILD FAILURE 
[INFO] ------------------------------------------------------------------------ 
[INFO] Total time: 3.288s 
[INFO] Finished at: Fri Mar 08 13:19:23 CET 2013 
[INFO] Final Memory: 12M/105M 
[INFO] ------------------------------------------------------------------------ 
[ERROR] Failed to execute goal org.apache.maven.plugins:maven-compiler-plugin:2.3.2:compile (default-compile) on project HibernateOnSpring: Compilation failure: Compilation failure: 
[ERROR] /home/andrea/Documents/ws/HibernateOnSpring/src/main/java/org/andrea/myexample/HibernateOnSpring/dao/PersonDAOImpl.java:[15,49] error: package org.springframework.transaction.annotation does not exist 
[ERROR] /home/andrea/Documents/ws/HibernateOnSpring/src/main/java/org/andrea/myexample/HibernateOnSpring/dao/PersonDAOImpl.java:[27,2] error: cannot find symbol 
[ERROR] class PersonDAOImpl 
[ERROR] /home/andrea/Documents/ws/HibernateOnSpring/src/main/java/org/andrea/myexample/HibernateOnSpring/dao/PersonDAOImpl.java:[128,2] error: cannot find symbol 
[ERROR] -> [Help 1] 
[ERROR] 
[ERROR] To see the full stack trace of the errors, re-run Maven with the -e switch. 
[ERROR] Re-run Maven using the -X switch to enable full debug logging. 
[ERROR] 
[ERROR] For more information about the errors and possible solutions, please read the following articles: 
[ERROR] [Help 1] http://cwiki.apache.org/confluence/display/MAVEN/MojoFailureException 

andin z PersonDAOImpl zdarzyć, że don” t znaleźć następujące importowane klasy:

org.springframework.transaction.annotation.Transactional; 

Dlaczego mam ten problem, jeśli staram się korzystać z wersji 3.2.1 modułu sprężyny-orm? Jak mogę go rozwiązać, aby z niego skorzystać?

Answer 1

Adnotacja @Transactional znajduje się w module spring-tx. Dołącz wersję 3.2.1 tego i zawsze upewnij się, że używasz tej samej wersji wszystkich modułów Spring.

Answer 2

Spróbuj użyć wszystkich zależności związanych z wiosną w tej samej wersji. Przypuszczam, że org.springframework.transaction.annotation.Transactional jest obecny wiosną 3.2.0. To nie powinno być problemu. Włącza zależność spring-tx, aby @Transactionl działał.

Answer 3

Pakiet org.springframework.transaction jest dostarczany przez artefakt spring-tx. Dodaj poniższe do swojego pom.xml i wykonaj aktualizację, która powinna zrobić:

<dependency> 
    <groupId>org.springframework</groupId> 
    <artifactId>spring-tx</artifactId> 
    <version>${org.springframework-version}</version> 
</dependency>