Java springboot应用程序中的事务管理

我最近开始从事springBoot项目。 我编写了一个示例程序，从数据库中获取数据，修改数据并将其存储回数据库

我面临的问题是，我能够从数据库中获取数据，但在将其保存回数据库时，我得到以下异常

org.springframework.dao.InvalidDataAccessApiUsageException: no transaction is in progress; nested exception is
javax.persistence.TransactionRequiredException: no transaction is in progress at
org.springframework.orm.jpa.EntityManagerFactoryUtils.convertJpaAccessExceptionIfPossible(EntityManagerFactoryUtils.java:413) at
org.springframework.orm.jpa.vendor.HibernateJpaDialect.translateExceptionIfPossible(HibernateJpaDialect.java:246)

下面是我的代码。 dataconfigurationon.java

import java.util.Properties;


import javax.sql.DataSource;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.autoconfigure.domain.EntityScan;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
import org.springframework.jdbc.datasource.DriverManagerDataSource;
import org.springframework.orm.jpa.JpaTransactionManager;
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
import org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter;

import org.springframework.transaction.annotation.EnableTransactionManagement;
/**
 * 
 * This class contains code to configure database. 
 * @author satish
 *
 */
@Configuration
@EntityScan(basePackages= {"com.tushar.common.model"})
@ComponentScan(basePackages= {"com.tushar.common.model"})
@EnableJpaRepositories(basePackages={"com"})
@EnableTransactionManagement 
public class DataConfiguration {

    @Value("${spring.datasource.driver-class-name}")
    private String driverClassName;

    @Value("${spring.datasource.url}")
    private String url;

    @Value("${spring.datasource.username}")
    private String username;

    @Value("${spring.datasource.password}")
    private String password;

    @Value("${spring.datasource.dialect}")
    private String dialect;

    /**
     * 
     * It will scan the package where our entities appears.
     * @param dataSource
     * @return
     */
    @Bean
    @Autowired
    public LocalContainerEntityManagerFactoryBean  entityManagerFactory(DataSource dataSource) {
        HibernateJpaVendorAdapter vendorAdapter = new HibernateJpaVendorAdapter();
        vendorAdapter.setGenerateDdl(true);

        Properties jpaProperties = new Properties();
        jpaProperties.setProperty("hibernate.show_sql", "true");
        jpaProperties.setProperty("hibernate.dialect", dialect);
        jpaProperties.setProperty("hibernate.hbm2ddl.auto", "update");

        LocalContainerEntityManagerFactoryBean localContainerEntityManagerFactoryBean = 
                new LocalContainerEntityManagerFactoryBean();
        localContainerEntityManagerFactoryBean.setJpaVendorAdapter(vendorAdapter);
        localContainerEntityManagerFactoryBean.setPackagesToScan(new String[]  {"com.att.pricerd.discountmanagement.model"});
        localContainerEntityManagerFactoryBean.setDataSource(dataSource);

       localContainerEntityManagerFactoryBean.setJpaProperties(jpaProperties);



        return localContainerEntityManagerFactoryBean;
    }
    /**
     * 
     * It will set the database properties to the data Source.
     * @return
     */
    @Bean
    public DataSource dataSource(){
        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setDriverClassName(driverClassName);
        dataSource.setUrl(url);
        dataSource.setUsername(username);
        dataSource.setPassword(password);
        return dataSource;
    }

    @Bean
    @Autowired
    public JpaTransactionManager transactionManager(LocalContainerEntityManagerFactoryBean emf) throws Exception {
    JpaTransactionManager transactionManager = new JpaTransactionManager();
    transactionManager.setEntityManagerFactory(emf.getObject());
    transactionManager.setEntityManagerFactory(emf.getNativeEntityManagerFactory());
    return transactionManager;
    }

}

存储库

@Repository
public interface EmployeeRepository extends JpaRepository<Employee,Long> {

}

@存储库
公共接口EmployeeRepository扩展了JpaRepository{
}

刀类

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;

import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Root;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class EmployeeDataManagementDaoImpl implements EmployeeDataManagementDao {

    private static final Logger LOG = LoggerFactory.getLogger(EmployeeDataManagementDaoImpl.class);

    @Autowired
    private EmployeeDataManagmentUtil EmployeeDataManagmentUtil;

    @Autowired
    private SalesEmployeesRepository salesEmployeesRepository;

    @Autowired
    private EmployeeRepository employeeRepository;

    @PersistenceContext
    private EntityManager em;

    @Override
    public void addEmployee(EmployeeDetailsRequestVo EmployeeRequest) {
        convertAndSaveSalesEmployee(EmployeeRequest);
    }

    /**
     * Fetch data from DB, update the inital and maximum Employee and
     * save it back to DB. 
     * @throws DataNotFoundException
     * 
     */
    @Override
    public void changeEmployee(List<Employee> Employees) throws EmployeeManagementException {
        for (Employee employee : Employees) {

            List<Employee> EmployeesDB;
            try {
                EmployeesDB = getEmployeeFromDB(employee);
            } catch (DataNotFoundException e) {
                List<String> errorMessage = new ArrayList<>();
                errorMessage.add(e.getMessage());
                LOG.error(e.getMessage(),e);
                throw new EmployeeManagementException(errorMessage);
            }

            for (Employee employee : EmployeesDB) {
                if (employee.getMaxEmployee() != null) {
                    Employee.setMaxEmployee(employee.getMaxEmployee());
                }
                if (employee.getInitialEmployee() != null) {
                    Employee.setInitialEmployee(employee.getInitialEmployee());
                }
                employeeRepository.saveAndFlush(Employee);
            }
        }

    }

    /**
     * This method is used to get the Employee details from DB.
     * 
     * @param employee
     * @return List<Employee>
     * @throws DataNotFoundException
     */
    private List<Employee> getEmployeeFromDB(Employee employee)
            throws DataNotFoundException {
        List<Employee> EmployeesDB = findByAllEmployeesFilters(employee.getempId(),
                employee.getyearsExp(), employee.getdeptLevInd(), employee.getsalary(),
                employee.getaddress(), employee.getCountryCd(), employee.getpinCode());

        if (EmployeesDB.isEmpty()) {
            String errCode = ""; // error code for data not found, yet to be
                                    // decided.
            LOG.error("ERROR CODE :: {}", errCode);
            throw new DataNotFoundException(errCode);
        }
        return EmployeesDB;
    }

    /**
     * This method will update the end date Employee
     * @param List<Employee>
     */
    @Override
    public void inactivateEmployee(List<Employee> Employees)
            throws EmployeeManagementException {
        for (Employee employee : Employees) {

            List<Employee> employeesDB;
            try {
                employeesDB = getEmployeeFromDB(employee);
            } catch (DataNotFoundException e) {
                List<String> errorMessage = new ArrayList<>();
                errorMessage.add(e.getMessage());
                LOG.error(e.getMessage(),e);
                throw new EmployeeManagementException(errorMessage);
            }
            for (Employee employee : EmployeesDB) {
                if (employee.getEmployeeEndDate() != null) {
                    employee.setEmployeeEndDate(employee.getEmployeeEndDate());
                }
                //
                employeeRepository.saveAndFlush(Employee);
            }
        }
    }

    /**
     * 
     * @param empId
     * @param yearsExp
     * @param bigDecimal
     * @param salary
     * @param regionId
     * @param countryCd
     * @param pinCode
     * @return
     */
    private List<Employee> findByAllEmployeeFilters(BigDecimal empId, BigDecimal yearsExp,
            BigDecimal bigDecimal, BigDecimal salary, String regionId, String countryCd, String pinCode) {
        CriteriaBuilder criteriaBuilder = em.getCriteriaBuilder();
        CriteriaQuery<Employee> criteriaQuery = criteriaBuilder
                .createQuery(Employee.class);
        Root<Employee> root = criteriaQuery.from(Employee.class);

        criteriaQuery.where(criteriaBuilder.equal(root.get("empId"), empId),
                criteriaBuilder.equal(root.get("deptLevInd"), bigDecimal),
                criteriaBuilder.equal(root.get("yearsExp"), yearsExp), criteriaBuilder.equal(root.get("salary"), salary),
                criteriaBuilder.equal(root.get("address"), regionId),
                criteriaBuilder.equal(root.get("countryCd"), countryCd),
                criteriaBuilder.equal(root.get("pinCode"), pinCode));


        return em.createQuery(criteriaQuery).getResultList();
    }

}

import java.math.BigDecimal；
导入java.util.ArrayList；
导入java.util.List；
导入javax.persistence.EntityManager；
导入javax.persistence.PersistenceContext；
导入javax.persistence.criteria.CriteriaBuilder；
导入javax.persistence.criteria.CriteriaQuery；
导入javax.persistence.criteria.Root；
导入org.slf4j.Logger；
导入org.slf4j.LoggerFactory；
导入org.springframework.beans.factory.annotation.Autowired；
导入org.springframework.stereotype.Component；
@组成部分
公共类EmployeeDataManagementDaoImpl实现EmployeeDataManagementDao{
私有静态最终记录器LOG=LoggerFactory.getLogger（EmployeeDataManagementDaoImpl.class）；
@自动连线
私人雇员数据管理工具雇员数据管理工具；
@自动连线
私人销售雇员储蓄销售雇员储蓄；
@自动连线
私人雇员住所雇员住所；
@持久上下文
私人实体管理者；
@凌驾
public void addEmployee（EmployeeDetailsRequestVo EmployeeRequest）{
convertAndSaveSalesEmployee（EmployeeRequest）；
}
/**
*从数据库获取数据，更新初始和最大员工数，并
*将其保存回数据库。
*@抛出DataNotFoundException
* 
*/
@凌驾
public void changemployee（列出员工）抛出EmployeeManagementException{
用于（员工：员工）{
雇员名单；
试一试{
EmployeesDB=getEmployeeFromDB（员工）；
}捕获（DataNotFounde异常）{
List errorMessage=new ArrayList（）；
errorMessage.add（例如getMessage（））；
LOG.error（e.getMessage（），e）；
抛出新的EmployeeManagementException（errorMessage）；
}
适用于（员工：EmployeesDB）{
if（employee.getMaxEmployee（）！=null）{
Employee.setMaxEmployee（Employee.getMaxEmployee（））；
}
if（employee.getInitialEmployee（）！=null）{
Employee.setInitialEmployee（Employee.getInitialEmployee（））；
}
employeeRepository.saveAndFlush（雇员）；
}
}
}
/**
*此方法用于从DB获取员工详细信息。
* 
*@param雇员
*@返回列表
*@抛出DataNotFoundException
*/
私有列表getEmployeeFromDB（员工）
抛出DataNotFoundException{
List EmployeesDB=findByAllEmployeesFilters（employee.getempId（），
employee.getyearsExp（），employee.getdeptLevInd（），employee.getsalary（），
employee.getaddress（）、employee.getCountryCd（）、employee.getpinCode（））；
if（EmployeesDB.isEmpty（））{
字符串errCode=“”；//未找到数据的错误代码，尚未找到
//决定。
error（“错误代码：：{}”，errCode）；
抛出新的DataNotFoundException（错误代码）；
}
返回员工数据库；
}
/**
*此方法将更新员工的结束日期
*@param列表
*/
@凌驾
公共雇员（列出雇员）
抛出EmployeeManagementException{
用于（员工：员工）{
雇员名单；
试一试{
employeesDB=getEmployeeFromDB（员工）；
}捕获（DataNotFounde异常）{
List errorMessage=new ArrayList（）；
errorMessage.add（例如getMessage（））；
LOG.error（e.getMessage（），e）；
抛出新的EmployeeManagementException（errorMessage）；
}
适用于（员工：EmployeesDB）{
if（employee.getEmployeeEndDate（）！=null）{
employee.setEmployeeEndDate（employee.getEmployeeEndDate（））；
}
//
employeeRepository.saveAndFlush（雇员）；
}
}
}
/**
* 
*@param empId
*@param yearsExp
*@param bigDecimal
*@param工资
*@param regionId
*@param countryCd
*@param pinCode
*@返回
*/
私有列表findByAllEmployeeFilters（BigDecimal empId、BigDecimal YearsXP、，
BigDecimal，BigDecimal工资，字符串regionId，字符串countryCd，字符串pinCode）{
CriteriaBuilder CriteriaBuilder=em.getCriteriaBuilder（）；
CriteriaQuery CriteriaQuery=criteriaBuilder
.createQuery（Employee.class）；
Root=criteriaQuery.from（Employee.class）；
其中（criteriaBuilder.equal（root.get（“empId”），empId），
criteriaBuilder.equal（root.get（“deptLevInd”）、bigDecimal），
criteriaBuilder.equal（root.get（“yearsExp”）、yearsExp）、criteriaBuilder.equal（root.get（“salary”）、salary），
criteriaBuilder.equal（root.get（“地址”），regionId），
criteriaBuilder.equal（root.get（“countryCd”）、countryCd），
qual（root.get（“pinCode”），pinCode））；
返回em.createQuery（criteriaQuery）.getResultList（）；
}
}

---

getEmployeeFromDB

从DB获取值，但saveAndFlush给了我一个例外。

实际上Bedla是正确的，您应该使用@Transactional。我想添加的是，应该在服务类中声明changeEmployee方法。正确的设计是创建

EmployeeServiceorg.springframework.dao.InvalidDataAccessApiUsageException: no transaction is in progress; nested exception is
javax.persistence.TransactionRequiredException: no transaction is in progress at
org.springframework.orm.jpa.EntityManagerFactoryUtils.convertJpaAccessExceptionIfPossible(EntityManagerFactoryUtils.java:413) at
org.springframework.orm.jpa.vendor.HibernateJpaDialect.translateExceptionIfPossible(HibernateJpaDialect.java:246)