example - transaction manager bean spring

Spring @Transactional no funciona

Question

Anteriormente tenía una publicación sobre este problema que se resolvió. Sin embargo, desde la reconstrucción del proyecto con beans cableados automáticamente y menos configuración XML, encuentro que estoy revisando este problema. He seguido la forma en que mi proyecto anterior implementó esto pero no funciona. ¿Puede alguien ayudarme con por qué o qué debo cambiar para que funcione?

Estoy a propósito usando un nombre de tabla inexistente en el método de insertar detalles de usuario para lanzar deliberadamente una excepción. Sin embargo, las declaraciones para insertar usuario e insertar roles de usuario no se retrotraen. Por favor ayuda.

Mi diseño actual para el registro es así.

Parte de servlet.xml :

<context:component-scan base-package="com.doyleisgod.golfer.controllers"/>
<context:component-scan base-package="com.doyleisgod.golfer.dao"/>
<context:component-scan base-package="com.doyleisgod.golfer.services"/>
<context:component-scan base-package="com.doyleisgod.golfer.validators"/>

Parte del contexto de la aplicación :

<context:annotation-config />
<tx:annotation-driven />
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
<property name="driverClassName" value="${jdbc.driverClassName}"/>
<property name="url" value="${jdbc.url}"/>
<property name="username" value="${jdbc.username}"/>
<property name="password" value="${jdbc.password}"/>
</bean>
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"/>
</bean>

Controlador de registro:

package com.doyleisgod.golfer.controllers;
import javax.validation.Valid;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.WebDataBinder;
import org.springframework.web.bind.annotation.InitBinder;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import com.doyleisgod.golfer.formdata.RegistrationForm;
import com.doyleisgod.golfer.services.IRegistrationService;
import com.doyleisgod.golfer.validators.RegistrationFormValidator;
/**
* Description: Registration controller provides and processes the registration form.
* @author Chris Doyle
*/
@Controller
@RequestMapping("/registration.htm")
public class RegistrationController {
protected final Log logger = LogFactory.getLog(getClass());
@Autowired private IRegistrationService iRegistrationService;
@Autowired private RegistrationFormValidator registrationFormValidator;
// sets a customer validator for the registration form
@InitBinder
protected void initBinder(WebDataBinder binder) {
binder.setValidator(registrationFormValidator);
}
// Description: Method called by a get request to the registration controller. Returns the
@RequestMapping(method=RequestMethod.GET)
public String registration (Model model){
model.addAttribute(new RegistrationForm());
return "registration";
}
// Description: Method called by a post request to the registration controller. Method calls validation on the registration form using custom validator and returning
// any errors back to the user.
@RequestMapping(method=RequestMethod.POST)
public String processRegistration (@Valid RegistrationForm registrationForm, BindingResult bindingResult, Model model){
logger.info("Received the following registration form details");
logger.info(registrationForm.toString());
if (bindingResult.hasErrors()) {
logger.warn("Registration Validation Failed");
model.addAttribute("validationError", "Please correct the fields marked with errors");
return "registration";
}
try {
iRegistrationService.registerUser(registrationForm);
} catch (Exception e) {
logger.error("An Exception has occured processing the registration form");
model.addAttribute("exceptionError", "An exception has occured, please try again.");
e.printStackTrace();
return "registration";
}
return "redirect:login.htm?registration=sucessful";
}
}

Servicio de registro:

package com.doyleisgod.golfer.services;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.authentication.encoding.ShaPasswordEncoder;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.support.TransactionSynchronizationManager;
import com.doyleisgod.golfer.dao.IRegistrationDAO;
import com.doyleisgod.golfer.formdata.RegistrationForm;
@Service("IRegistrationService")
public class RegistrationService implements IRegistrationService {
@Autowired private IRegistrationDAO iRegistrationDAO;
private final boolean enabled = true;
private final String roles = "ROLE_USER";
@Override
@Transactional (rollbackFor = Exception.class)
public void registerUser(RegistrationForm registrationForm) throws Exception {
System.out.println("inside the registerUser method. is wrapped in transaction: "+TransactionSynchronizationManager.isActualTransactionActive());
String username = registrationForm.getUsername();
String password = registrationForm.getPassword();
String firstname = registrationForm.getFirstname();
String lastname = registrationForm.getLastname();
String email = registrationForm.getEmail();
int handicap = Integer.parseInt(registrationForm.getHandicap());
String encryptedPassword = ((new ShaPasswordEncoder()).encodePassword(password, username));
iRegistrationDAO.insertUser(username, encryptedPassword, enabled);
iRegistrationDAO.insertRoles(username, roles);
iRegistrationDAO.insertUserDetails(username, firstname, lastname, email, handicap);
}
@Override
public boolean checkUser(String username) {
return iRegistrationDAO.checkUserName(username);
}
}

Registro DAO :

package com.doyleisgod.golfer.dao;
import javax.annotation.Resource;
import org.apache.commons.dbcp.BasicDataSource;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.support.TransactionSynchronizationManager;
@Repository("iRegistrationDAO")
public class RegistrationDAO extends JdbcTemplate implements IRegistrationDAO {
@Resource private BasicDataSource dataSource;
@Override
public boolean checkUserName(String username) {
int db_user = queryForInt("select count(username) from users where username = ?", username);
if (db_user == 1 ){
return true;
}
return false;
}
@Override
public void insertUser(String username, String password, boolean enabled) throws Exception {
System.out.println("inside the insertuser method. is wrapped in transaction: "+TransactionSynchronizationManager.isActualTransactionActive());
update("insert into users (username, password, enabled) VALUES (?,?,?)", username, password, enabled);
}
@Override
public void insertRoles(String username, String roles) throws Exception {
update("insert into user_roles (username, authority) VALUES (?,?)", username, roles);
}
@Override
public void insertUserDetails(String username, String firstname, String lastname, String email, int handicap) throws Exception {
update("insert into user_detailss (username, first_name, last_name, email_address, handicap)" +
"VALUES (?,?,?,?,?)", username, firstname, lastname, email, handicap);
}
public void setDataSource(BasicDataSource dataSource) {
this.dataSource = dataSource;
}
public BasicDataSource getDataSource() {
return dataSource;
}
}

Answer 1

El motivo por el cual el context:component-scan etiquetas de context:component-scan en el contexto de la aplicación xml solucionó el comportamiento transaccional es: <tx:annotation-driven /> es un postprocesador que envuelve los métodos @Transactional bean con un interceptor de método AOP que maneja transaccional comportamiento. Los postprocesadores de Spring solo operan en el contexto de aplicación específico en el que se definen.

En su caso, ha definido el post-procesador <tx:annotation-driven /> en el contexto de la aplicación, mientras que los beans anotados con @Transactional están en el contexto de la aplicación del servlet. Por lo tanto, el post-procesador <tx:annotation-driven /> solo funcionaba en los beans de contexto de la aplicación, no en los beans de contexto de servlet. Cuando las etiquetas context:component-scan se movieron al contexto de la aplicación, el post-procesador <tx:annotation-driven /> envolvió sus métodos transaccionales adecuadamente.

Espero que tenga sentido.

[Editar]

¿Cuál es la diferencia entre el contexto de la aplicación y el contexto de un servlet?

¿Qué es un post-procesador Spring y cómo funciona?

¿Qué es el AOP en primavera?