Bom, sendo iniciante não vai ter jeito, você vai ter que dar uma lida na documentação do spring.
A maneira que acho mais fácil é fazer a transação por meio da anotação @Transactional do spring.
Assim, você anota um método ou mesmo uma classe com essa anotação, e o spring já configura a transação para quando o método ou métodos da classe forem chamados.
Assim, ele já gerencia tudo pra você, e quando ocorrerem exceções ele já faz rollback por default (isso também pode ser customizado).
Outra opção é declarar no application-context.xml, as classes e métodos que você quer que sejam transacionais, é somente um outro método de configuração, caso não seja possível usar anotações.
Dos dois jeitos, o spring irá interceptar a chamada do método configurado para ser transacional, e criará uma transação por debaixo dos panos.
Vou passar um exemplo de configuracao usando anotações:
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
xmlns:tx="http://www.springframework.org/schema/tx" xmlns:security="http://www.springframework.org/schema/security"
xmlns:lang="http://www.springframework.org/schema/lang"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/lang
http://www.springframework.org/schema/lang/spring-lang-3.0.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.0.xsd
http://www.springframework.org/schema/security
http://www.springframework.org/schema/security/spring-security-3.0.xsd">
<context:property-placeholder location="classpath:application.properties" />
<context:component-scan base-package="com.meu.pacote" />
<tx:annotation-driven transaction-manager="txManager" />
<bean id="entityManagerFactory"
class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
<property name="persistenceUnitName" value="transportadora" />
<!-- <property name="jpaVendorAdapter"> <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
<property name="databasePlatform" value="${database.target}" /> <property
name="showSql" value="${database.showSql}" /> <property name="generateDdl"
value="${database.generateDdl}" /> </bean> </property> -->
<!-- <property name="dataSource" ref="dataSource" /> -->
</bean>
<bean id="dataSource"
class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="${database.driver}" />
<property name="url" value="${database.url}" />
<property name="username" value="${database.username}" />
<property name="password" value="${database.password}" />
</bean>
<bean id="txManager" class="org.springframework.orm.jpa.JpaTransactionManager">
<property name="entityManagerFactory" ref="entityManagerFactory" />
</bean>
<bean
class="org.springframework.dao.annotation.PersistenceExceptionTranslationPostProcessor" />
<bean
class="org.springframework.orm.jpa.support.PersistenceAnnotationBeanPostProcessor" />
</beans>
O que mais interessa é as duas linhas:
<context:component-scan base-package="com.meu.pacote" />
<tx:annotation-driven transaction-manager="txManager" />
A primeira diz pro Spring escanear todas as suas classes começando do pacote que você indica no atributo (com.meu.pacote).
Assim, ele escaneia as anotações e configura quando encontrar qualquer anotação, @Repository, @Autowired, @Service, @Transactional, etc.
A segunda linha você diz que vai fazer a configuração de transações por meio de anotações.
Agora, você só tem que colocar tua classe service no pacote declarado, e fazer a anotação @Transactional no método, sem se preocupar em abrir, fechar, comitar e dar rollback nas suas transações, o spring faz isso automaticamente pra você.
