标签: transactional

我写了这个简单的例子:

//file TestController.java
public interface TestController {

    public List<Test> findAll();

}

//file TestControllerImp.java
@Controller
public class TestControllerImp implements TestController{

    @Autowired
    private SessionFactory sessionFactory;

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

    public List<Test> findAll() {
        return sessionFactory.getCurrentSession().createQuery("from Test").list();
    }

}

//file TestService.java
@Service
public class TestService {

    @Autowired
    private TestController controller;

    public boolean flag=true;

    public void setController(TestController controller){
        this.controller=controller;
    }

    @Transactional
    public List<Test> useController(){
        flag=false;
        return controller.findAll();
    }

}

这是我的尝试:

TestService s1=context.getBean(TestService.class);
TestService s2=context.getBean(TestService.class);
List<Test> list=s1.useController();
System.out.println(s1.flag+"  "+s2.flag);

现在奇怪的行为(即时通讯非常新的春天):

1. 如果我声明@Transactional …

我正在将一个EJB应用程序移植到Spring,而我正面临一些问题.该应用程序使用eclipselink独立运行(这就是我们选择spring的原因).

在这个应用程序中,我需要创建一个Order,我首先需要创建一个Customer,OrderLines,然后为这个Order添加一个Payment.

问题是我想在单个事务中进行所有插入操作,这样如果付款未能保留,则不能保留任何内容.我试图实现这一点,但看起来我正在跨越多个独立事务,因为如果发生故障,数据会持久存储到数据库(例如:付款失败,无论如何都会创建客户).

这是切入点:

public static void main(String[] args) {
    AbstractApplicationContext context = new ClassPathXmlApplicationContext(new String[] { "applicationContext.xml" });
    BeanFactory beanFactory = (BeanFactory) context;
    MyService service = beanFactory.getBean(MyService.class);
    service.getNewOrders(true);
}

这是我正在解决的bean(使用beanFactory.getBean):

@Component
@Scope("prototype")
public class MyService {

    @Autowired
    private CustomerService customerService;

    @Autowired
    private OrderService orderService;

    @Autowired
    private PaymentService paymentService;

    @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
    public void getNewOrders(boolean formattedOutput) {
        try {
            List<RawData> rawData = // Acquire data from a remote web service (http rest based)

            for (RawData …

以下是我的所有代码.未创建数据库行.没有异常抛出.

package com.rishi.app.models;

import java.util.Collection;

import javax.management.Query;
import javax.persistence.Entity;
import javax.persistence.EntityManager;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.PersistenceContext;
import javax.persistence.PersistenceUnit;
import javax.persistence.TypedQuery;

@Entity
public class Customer {

    @Id
    @GeneratedValue(strategy=GenerationType.AUTO)
    private int id;
    private String firstName;
    private String lastName;

    protected Customer() {}

    public Customer(String firstName, String lastName) {
        this.firstName = firstName;
        this.lastName = lastName;
    }

    @Override
    public String toString() {
        return String.format(
                "Customer[id=%d, firstName='%s', lastName='%s']",
                id, firstName, lastName);
    }

}


package com.rishi.app.repositories;

import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.transaction.Transactional;

import org.springframework.stereotype.Repository; …

我在我的网页上创建了一个自定义主题('mytheme'),我想在交易电子邮件中添加一个来自此模板的图像(.../skin/frontend/mytheme/default/images/myimage.png)

我尝试了一些选项,但有人工作:

<div sytle="background: {{skin url="images/myimage.png" _area="frontend"}}"></div>

<div sytle="background: {{skin url="images/myimage.png" _area="frontend" _theme="mytheme"}}"></div>

<div sytle="background: {{skin url="images/myimage.png" _area="frontend" _theme="mytheme" _package="default"}}"></div>

我有一个用例,其中有三个文档,我想以事务方式更新它们,即如果其中任何一个失败,那么其他文档也不应该在数据库中更新.我正在寻找一个选项但在JavaSDK中找不到.那么我有什么方法可以在事务上执行此操作.我使用CAS值来处理并发.请给我一个同时处理此操作的方法.

Couchbase版本:4.0 Java SDK:2.1.6

任何帮助表示赞赏.

 @Transactional
 public void setSomething(String name) { ... }

很抱歉问这个非常基本的问题,Spring事务注释是如此强大但却难以理解.根据上面的代码,我没有rollbackFor控制权,这意味着,如果有异常,这个事务上下文将不会回滚.但是根据我以旧方式覆盖事务块的经验,如果没有异常回滚,commit将被跳过并导致(Oracle)数据库的表被锁定(挂起,其他用户无法提交他们的SQL).Spring会不会使用相同的问题rollbackFor吗？

我们将spring-boot-starter-parent1.4.1 与spring-boot-starter-redis和一起使用spring-boot-starter-data-redis。我们使用 Redis 来 (a) 向外部应用程序传递消息，以及 (b) 在存储库中存储一些信息。我们的 redis 配置如下所示

@Configuration
@EnableRedisRepositories
open class RedisConfig {

    @Bean // for message passing
    @Profile("test")
    open fun testRedisChannelProvider(): RedisParserChannelProvider {
        return RedisParserChannelProvider("test_parser:parse.job", "test_parser:parse.joblist")
    }

    @Bean // for message passing
    @Profile("!test")
    open fun productionRedisChannelProvider(): RedisParserChannelProvider {
        return RedisParserChannelProvider("parser:parse.job", "parser:parse.joblist")
    }

    @Bean // for message passing
    open fun parseJobTemplate(connectionFactory: RedisConnectionFactory): RedisTemplate<String, ParseJob> {
        val template = RedisTemplate<String, ParseJob>()
        template.connectionFactory = connectionFactory
        template.valueSerializer = Jackson2JsonRedisSerializer<ParseJob>(ParseJob::class.java)

        return template
    }

    //@Bean // …

我尝试编写一个非常简单的代码来测试@Transactional,但是当我使用Propagation.REQUIRED时它不会回滚.这是代码.

    @Component
    public class A {

        private JdbcTemplate jdbcTemplate;

        @Resource(name="dataSource")
        public void setDataSource(DataSource dataSource) {
            this.jdbcTemplate = new JdbcTemplate(dataSource);
        }

        @Transactional(propagation=Propagation.REQUIRED)
        public void add(Person person) throws Exception {
        try {
            String sql = "insert into person (id, name) values(?,?)";
            jdbcTemplate.update(sql, new  Object[{person.getId(),person.getName()});
        } catch (Exception e) {
            throw new RuntimeException();
        }

        @Transactional(propagation=Propagation.REQUIRED)
        public void delete(String id) throws Exception {
            throw new RuntimeException();
            ***throw a RuntimeException on purpose***
        }
    }

    public class cases {

        @Transactional
        public static void testPro() throws Exception …

我的主要功能类:

public class Database2Redis
{
    public static void test(ApplicationContext applicationContext)
    {
        BaseFckImpl service = applicationContext.getBean(BaseFckImpl.class);
        // ...
    }

    public static void main(String[] args) throws Exception
    {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-config.xml");

        test(applicationContext);
    }
}

我的BaseFck类:

@Service
public interface BaseFck
{
    @Transactional
    void test();
}

我的BaseFckImpl类:

@Service
public class BaseFckImpl implements BaseFck
{
    @Transactional
    public  void test()
    {
            Log.debug("------test---------");
    }
}

我的spring-config.xml的一部分

<?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:aop="http://www.springframework.org/schema/aop"
    xmlns:mvc="http://www.springframework.org/schema/mvc"
    xsi:schemaLocation="http://www.springframework.org/schema/mvc
    http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd
    http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
    http://www.springframework.org/schema/tx 
    http://www.springframework.org/schema/tx/spring-tx-3.2.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context-3.2.xsd
    http://www.springframework.org/schema/aop …

我有一个非常简单的代码，由 Service -> RequestProcessor -> DAO 组成，每层有 2-3 个类（接口、抽象、具体）。

服务层：-

public interface Service {
   public void saveOrUpdate(Object entity, String operationName);
 }
}

public abstract class AbstractService implements Service{

   public abstract ReqProcessor getRP();
   @Override
   public void saveOrUpdate(Object entity, String operationName) {
     ReqProcessor hiberTestRP = getRP();
     hiberTestRP.saveOrUpdate(entity, operationName);
 }
}

@Component
public class ServiceImpl extends AbstractService {

  @Autowired
  public ReqProcessor hibertestRPImpl;

  @Override
  public HiberTestRP getRP() {
    return hibertestRPImpl;
 }
}

ReqProcessor 层：-

public interface ReqProcessor {
   public void saveOrUpdate(Object entity, String operationName); …

我有一个Spring应用程序，该@Transactional方法使用一种方法更新MySQL DB中的特定实体详细信息，并且在同一方法中，我试图调用另一个端点，使用@Async该端点是另一个Spring应用程序，该应用程序从MySql DB中读取相同的实体并更新其中的值Redis存储。

现在的问题是，每次我更新实体的某些值时，有时会在redis中更新它，有时却没有。

当我尝试调试时，我发现有时第二个应用程序从MySql读取实体时会选择旧值而不是更新值。

谁能建议我可以做些什么来避免这种情况，并确保第二个应用程序始终从Mysql中选择该实体的更新值？