javax.transaction.Status翻译

最新推荐文章于 2024-02-29 20:32:43 发布
最新推荐文章于 2024-02-29 20:32:43 发布
阅读量230 收藏
点赞数
文章标签： 活动 SUN
博客介绍了javax.transaction中Status接口，该接口定义了用于事务状态码的静态变量，如STATUS_ACTIVE、STATUS_MARKED_ROLLBACK等，还提及版权归2003年Sun Microsystems, Inc.所有。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

<!-- ========= START OF TOP NAVBAR ======= --> <!-- -->
<!-- -->
Overview Package Class Tree Deprecated Index Help
JavaTM 2 Platform
Ent. Ed. v1.4
PREV CLASS NEXT CLASS FRAMES NO FRAMES <!-- if(window==top) { document.writeln('<A HREF="../../allclasses-noframe.html"><B>All Classes</B></A>'); } //--> All Classes <noscript></noscript>
SUMMARY:NESTED|FIELD|CONSTR|METHOD DETAIL:FIELD|CONSTR|METHOD
<!-- ========= END OF TOP NAVBAR ========= --> <!-- ======== START OF CLASS DATA ======== -->

javax.transaction
Interface Status

public interface Status

The Status interface defines static variables used for transaction status codes. Status接口定义了一些用于事务状态码的静态变量。

<!-- ======== NESTED CLASS SUMMARY ======== --><!-- =========== FIELD SUMMARY =========== --><!-- -->

Field Summary
staticint STATUS_ACTIVE
A transaction is associated with the target object and it is in the active state. 与目标对象关联的事务处于活动状态。
staticint STATUS_COMMITTED
A transaction is associated with the target object and it has been committed. 与目标对象关联的事务已被提交。
staticint STATUS_COMMITTING
A transaction is associated with the target object and it is in the process of committing. 与目标对象关联的事务正在提交过程中。
staticint STATUS_MARKED_ROLLBACK
A transaction is associated with the target object and it has been marked for rollback, perhaps as a result of a setRollbackOnly operation. 与目标对象关联的事务已被标记为回滚，也许是setRollbackOnly操作的结果。
staticint STATUS_NO_TRANSACTION
No transaction is currently associated with the target object. 目标对象目前没有关联事务。
staticint STATUS_PREPARED
A transaction is associated with the target object and it has been prepared. 与目标对象关联的事务已准备好。
staticint STATUS_PREPARING
A transaction is associated with the target object and it is in the process of preparing. 与目标对象关联的事务正在准备过程中。
staticint STATUS_ROLLEDBACK
A transaction is associated with the target object and the outcome has been determined to be rollback. 与目标对象关联的事务被定义为回滚。
staticint STATUS_ROLLING_BACK
A transaction is associated with the target object and it is in the process of rolling back. 与目标对象关联的事务正在回滚过程中。
staticint STATUS_UNKNOWN
A transaction is associated with the target object but its current status cannot be determined. 目标对象有关联事务，但当前状态还未定义。
<!-- ======== CONSTRUCTOR SUMMARY ======== --><!-- ========== METHOD SUMMARY =========== -->

<!-- ============ FIELD DETAIL =========== --><!-- -->

Field Detail
<!-- -->

STATUS_ACTIVE

 


 
 
  A transaction is associated with the target object and it is in the active state. An implementation returns this status after a transaction has been started and prior to a Coordinator issuing any prepares, unless the transaction has been marked for rollback. 与目标对象关联的事务处于活动状态。事务已开始，并且在协调器进行准备之前， 实现返回该状态，除非事务已被标记为回滚。 
  
 
  

   
    See Also: 
    
   

    Constant Field Values
   
 
  

 




<!-- -->

STATUS_MARKED_ROLLBACK
 

 


 
 
  A transaction is associated with the target object and it has been marked for rollback, perhaps as a result of a setRollbackOnly operation. 与目标对象关联的事务已被标记为回滚，也许是setRollbackOnly操作的结果。 
  
 
  

   
    See Also: 
    
   

    Constant Field Values
   
 
  

 




<!-- -->

STATUS_PREPARED
 

 


 
 
  A transaction is associated with the target object and it has been prepared. That is, all subordinates have agreed to commit. The target object may be waiting for instructions from a superior as to how to proceed. 与目标对象关联的事务已准备好。也就是说所有相关已准备提交。目标对象可能正在等待 上一级关于如何进行的指令。 
  
 
  

   
    See Also: 
    
   

    Constant Field Values
   
 
  

 




<!-- -->

STATUS_COMMITTED
 

 


 
 
  A transaction is associated with the target object and it has been committed. It is likely that heuristics exist; otherwise, the transaction would have been destroyed and NoTransaction returned. 与目标对象关联的事务已被提交。它可能只是理论上存在，因为事务将会结束，返回NoTransaction。 
  
 
  

   
    See Also: 
    
   

    Constant Field Values
   
 
  

 




<!-- -->

STATUS_ROLLEDBACK
 

 


 
 
  A transaction is associated with the target object and the outcome has been determined to be rollback. It is likely that heuristics exist; otherwise, the transaction would have been destroyed and NoTransaction returned. 与目标对象关联的事务正在回滚过程中。它可能只是理论上存在，因为事务将会结束， 返回NoTransaction。 
  
 
  

   
    See Also: 
    
   

    Constant Field Values
   
 
  

 




<!-- -->

STATUS_UNKNOWN
 

 


 
 
  A transaction is associated with the target object but its current status cannot be determined. This is a transient condition and a subsequent invocation will ultimately return a different status. 目标对象有关联事务，但当前状态还未定义。这只是暂时的状态，随后的调用最终将 返回另外的状态。 
  
 
  

   
    See Also: 
    
   

    Constant Field Values
   
 
  

 




<!-- -->

STATUS_NO_TRANSACTION
 

 


 
 
  No transaction is currently associated with the target object. This will occur after a transaction has completed. 目标对象目前没有关联事务。出现在事务完成之后。 
  
 
  

   
    See Also: 
    
   

    Constant Field Values
   
 
  

 




<!-- -->

STATUS_PREPARING
 

 


 
 
  A transaction is associated with the target object and it is in the process of preparing. An implementation returns this status if it has started preparing, but has not yet completed the process. The likely reason for this is that the implementation is probably waiting for responses to prepare from one or more Resources. 与目标对象关联的事务正在准备过程中。如果已经开始准备但还未完成该过程，实现将返回 该状态。这样设计的原因可能因为实现有可能等待来自于一个或多个资源的响应作准备。 
  
 
  

   
    See Also: 
    
   

    Constant Field Values
   
 
  

 




<!-- -->

STATUS_COMMITTING
 

 


 
 
  A transaction is associated with the target object and it is in the process of committing. An implementation returns this status if it has decided to commit but has not yet completed the committing process. This occurs because the implementation is probably waiting for responses from one or more Resources. 与目标对象关联的事务正在提交过程中。如果已经确定提交但还未完成提交过程， 实现返回该状态。当实现有可能等待来自于一个或多个资源的响应时发生。 
  
 
  

   
    See Also: 
    
   

    Constant Field Values
   
 
  

 




<!-- -->

STATUS_ROLLING_BACK
 

 


 
 
  A transaction is associated with the target object and it is in the process of rolling back. An implementation returns this status if it has decided to rollback but has not yet completed the process. The implementation is probably waiting for responses from one or more Resources. 与目标对象关联的事务正在回滚过程中。如果已经确定回滚但还未完成该过程， 实现返回该状态。实现有可能等待来自于一个或多个资源的响应。 
  
 
  

   
    See Also: 
    
   

    Constant Field Values
   
 
  

 


<!-- ========= CONSTRUCTOR DETAIL ======== --><!-- ============ METHOD DETAIL ========== --><!-- ========= END OF CLASS DATA ========= -->
<!-- ======= START OF BOTTOM NAVBAR ====== -->
<!-- -->


 <!-- -->
    
 Overview  Package Class Tree  Deprecated  Index  Help 
JavaTM 2 Platform
Ent. Ed. v1.4 
 PREV CLASS NEXT CLASS  FRAMES NO FRAMES <!-- if(window==top) { document.writeln('<A HREF="../../allclasses-noframe.html"><B>All Classes</B></A>'); } //--> All Classes <noscript></noscript> 
 SUMMARY:NESTED|FIELD|CONSTR|METHOD  DETAIL:FIELD|CONSTR|METHOD 

<!-- ======== END OF BOTTOM NAVBAR ======= -->

Submit a bug or feature
 

Copyright 2003 Sun Microsystems, Inc. All rights reserved. 

                

        




    

    
  



    

      

        

            

              
                
                  iteye_15968
                
              
            

            

                关注
              
            

        

        

          
      

      










                



	

		

			

				
					
解决org.springframework.transaction.UnexpectedRollbackException: Transaction silently rolled back beca

				
			

			

				

					念兮为美
				

				

					03-02
					
					9002
					
				

			

		

		

			
				
解决org.springframework.transaction.UnexpectedRollbackException: Transaction silently rolled back because it has been marked as rollback-only的问题，并通过该错误来分析来分析spring boot的事务机制。

			
		

	



                

            
              



	

		

			

				
					
聊一聊Spring中的@Transactional注解【上】【源码详解】

				
			

			

				

					lazysnail的博客
				

				

					11-01
					
					1551
					
				

			

		

		

			
				
从源码的角度聊一聊@Transactional的实现和使用过程。

			
		

	



              


  
              

                


	

		

			

				
					
javax.transaction.jar

				
			

			

				

					04-26
				

			

		

		

			
				
javax.transaction.jar  javax.transaction.jar

			
		

	





	

		

			

				
					
javax.transaction.Transaction翻译

				
			

			

				

					编程资料大全
				

				

					11-17
					
					284
					
				

			

		

		

			
				
&lt;!-- ========= START OF TOP NAVBAR ======= --&gt;&lt;!-- --&gt;


&lt;!-- --&gt;

Overview


Package

Class

Tree


Deprecated


Index


Help



JavaTM 2 PlatformEnt. Ed. v1.4 



PREV CLASS NEXT C...

			
		

	



		

			
		



	

		

			

				
					
Java异常对象

				
			

			

				

					weixin_44371237的博客
				

				

					12-07
					
					467
					
				

			

		

		

			
				
Error和Exception区分：
Error是编译时错误和系统错误，系统错误在除特殊情况下，都不需要你来关心，基本不会出现。而编译时错误，如果你使用了编译器，那么编译器会提示。
Exception则是可以被抛出的基本类型，我们需要主要关心的也是这个类。
Exception又分为RunTimeException和其他Exception。
RunTimeException和其他Exception区分：
其他Exception，受检查异常。可以理解为错误，必须要开发者解决以后才能编译通过，解决的方法有两种，.

			
		

	





	

		

			

				
					
使用atomikos 如何实现 JTA/XA全局事务

				
			

			

				

					qq_41692749的博客
				

				

					11-01
					
					776
					
				

			

		

		

			
				
写在前面的话
最近终于忙完了自考的事情，可以有更多的时间总结了。
久违的国家考试，听着广播里播放着考试相关的信息，以及感受着考场上紧张的氛围，突然还很怀念。
这样的机会真是越来越少呢。
什么是JTA
在介绍atomikos先介绍下JTA。
首先JTA是一个规范。
Java事务API（JTA：Java Transaction API）和它的同胞Java事务服务（JTS：Java Transaction Service），为J2EE平台提供了分布式事务服务（distributed transaction）的能力

			
		

	





	

		

			

				
					
javax.transaction.xa.XAException: The function PREPARE: failed. The status is: -4. Error: "*** SQLJDBC_XA DTC_ERROR Context: xa_prepare, state=1, StatusCode:-4 (0xFFFFFFFC) ***"

				
			

			

				

					07-14
				

			

		

		

			
				
这个错误信息表明在执行 PREPARE 函数时出现了问题，状态码为 -4。根据错误信息中提供的更多细节，可以看到涉及到 SQLJDBC_XA 和 DTC_ERROR。  一种可能的原因是分布式事务管理器（DTC）与数据库之间的通信出现了...

			
		

	





	

		

			

				
					
ShardingSphere Narayana XA 事务不回滚问题定位

				
			

			

				

					flyingzc的博客
				

				

					02-29
					
					536
					
				

			

		

		

			
				
这个报错的含义简单来说就是这个事务已经在其他地方被标记成只可回滚了，不能再进行后续其他的操作。

			
		

	





	

		

			

				
					

package com.kucun.data.entity;

import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.OneToOne;
import javax.persistence.Table;

import com.fasterxml.jackson.annotation.JsonBackReference;
import com.fasterxml.jackson.annotation.JsonManagedReference;
/**

板材
@author Administrator
*/
@Entity
@Table(name=“bancai”)
public class Bancai {
@Id
private int id;
@ManyToOne(cascade = CascadeType.ALL, fetch = FetchType.LAZY)
@JoinColumn(name = “caizhi_id”) //
@JsonManagedReference // 标记为“主”关联方
private Caizhi caizhi;
@ManyToOne(cascade = CascadeType.ALL, fetch = FetchType.LAZY)
@JoinColumn(name = “mupi1_id”)
private Mupi mupi1;
@ManyToOne(cascade = CascadeType.ALL, fetch = FetchType.LAZY)
@JoinColumn(name = “mupi2_id”)

private Mupi mupi2;

private Double houdu;

@OneToOne(cascade = CascadeType.ALL, fetch = FetchType.LAZY)
@JoinColumn(name = “kucun_id”, referencedColumnName = “id”)
private Kucun kucun;

public Kucun getKucun() {
return kucun;
}
public void setKucun(Kucun kucun) {
this.kucun = kucun;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public Caizhi getCaizhi() {
return caizhi;
}
public void setCaizhi(Caizhi caizhi) {
this.caizhi = caizhi;
}
public Mupi getMupi1() {
return mupi1;
}
public void setMupi1(Mupi mupi1) {
this.mupi1 = mupi1;
}
public Mupi getMupi2() {
return mupi2;
}
public void setMupi2(Mupi mupi2) {
this.mupi2 = mupi2;
}
public Double getHoudu() {
return houdu;
}
public void setHoudu(Double houdu) {
this.houdu = houdu;
}

public Bancai(int id, Caizhi caizhi, Mupi mupi1, Mupi mupi2, Double houdu) {
super();
this.id = id;
this.caizhi = caizhi;
this.mupi1 = mupi1;
this.mupi2 = mupi2;
this.houdu = houdu;
}
public Bancai() {
super();
}

}
package com.kucun.data.entity;

import java.util.List;

import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.OneToMany;
import javax.persistence.Table;

import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
/**

板材材质
@author Administrator
*/
@Entity
@Table(name=“caizhi”)
@JsonIgnoreProperties({“hibernateLazyInitializer”, “handler”})
public class Caizhi {
@Id

private int id ;
private String name;

@OneToMany(mappedBy=“caizhi”)
@JsonIgnore
private List<Bancai> bancais;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return “{id:” + id + “, name:” + name + “}”;
}
public Caizhi(int id, String name) {
super();
this.id = id;
this.name = name;
}
public Caizhi() {
super();
}
// 添加反向关联维护方法
public void addBancai(Bancai bancai) {
bancais.add(bancai);
bancai.setCaizhi(this);
}

// 添加移除方法
public void removeBancai(Bancai bancai) {
bancais.remove(bancai);
bancai.setCaizhi(null);
}

}
package com.kucun.data.entity;

import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.Id;
import javax.persistence.ManyToOne;
import javax.persistence.OneToMany;
import javax.persistence.OneToOne;
/**

产品组件关联类
@author Administrator
*/
@Entity
public class Chanpin_zujian {
@Id
private Integer id;
@ManyToOne(cascade = CascadeType.ALL, fetch = FetchType.LAZY)
private Chanpin chanpins;

@ManyToOne(cascade = CascadeType.ALL, fetch = FetchType.LAZY)
private Zujian zujian;
@ManyToOne(cascade = CascadeType.ALL, fetch = FetchType.LAZY)
private Bancai bancai;
private Double one_howmany;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}

public Chanpin getChanpins() {
return chanpins;
}
public void setChanpins(Chanpin chanpins) {
this.chanpins = chanpins;
}
public Zujian getZujian() {
return zujian;
}
public void setZujian(Zujian zujian) {
this.zujian = zujian;
}
public Bancai getBancai() {
return bancai;
}
public void setBancai(Bancai bancai) {
this.bancai = bancai;
}
public Double getOne_howmany() {
return one_howmany;
}
public void setOne_howmany(Double one_howmany) {
this.one_howmany = one_howmany;
}

public Chanpin_zujian() {
super();
// TODO Auto-generated constructor stub
}
}
package com.kucun.data.entity;

import java.util.List;

import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.Id;
import javax.persistence.OneToMany;
/**

产品类
@author Administrator
*/
@Entity
public class Chanpin {
@Id
private Integer id;
@OneToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY)
private List<Dingdan_chanpin> dingdians;
private String bianhao;
@OneToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY)
private List<Chanpin_zujian> zujians;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public List<Dingdan_chanpin> getDingdians() {
return dingdians;
}
public void setDingdians(List<Dingdan_chanpin> dingdians) {
this.dingdians = dingdians;
}
public String getBianhao() {
return bianhao;
}
public void setBianhao(String bianhao) {
this.bianhao = bianhao;
}
public List<Chanpin_zujian> getZujians() {
return zujians;
}
public void setZujians(List<Chanpin_zujian> zujians) {
this.zujians = zujians;
}
public Chanpin(Integer id, List<Dingdan_chanpin> dingdians, String bianhao, List<Chanpin_zujian> zujians) {
super();
this.id = id;
this.dingdians = dingdians;
this.bianhao = bianhao;
this.zujians = zujians;
}
public Chanpin() {
super();
// TODO Auto-generated constructor stub
}

}
package com.kucun.data.entity;

import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.Id;
import javax.persistence.ManyToOne;

/**

一个订单中的产品组件订购板材数量
@author Administrator
*/
@Entity
public class Dingdan_chanpin_zujian {

@Id
private Integer id;

//订单
@ManyToOne(cascade = CascadeType.ALL, fetch = FetchType.LAZY)
private Dingdan dingdan;
//板材
@ManyToOne(cascade = CascadeType.ALL, fetch = FetchType.LAZY)
private Bancai bancai;
//产品组件
@ManyToOne(cascade = CascadeType.ALL, fetch = FetchType.LAZY)
private Chanpin_zujian zujians;
//订购数
private Integer shuliang ;

public Dingdan_chanpin_zujian() {
super();
// TODO Auto-generated constructor stub
}

public Integer getId() {
return id;
}

public void setId(Integer id) {
this.id = id;
}

public Dingdan getDingdan() {
return dingdan;
}

public void setDingdan(Dingdan dingdan) {
this.dingdan = dingdan;
}

public Bancai getBancai() {
return bancai;
}

public void setBancai(Bancai bancai) {
this.bancai = bancai;
}

public Chanpin_zujian getZujians() {
return zujians;
}

public void setZujians(Chanpin_zujian zujians) {
this.zujians = zujians;
}

public Integer getShuliang() {
return shuliang;
}

public void setShuliang(Integer shuliang) {
this.shuliang = shuliang;
}

}
package com.kucun.data.entity;

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.Id;
import javax.persistence.ManyToOne;
/**

订单和产品关联
@author Administrator
*/
@Entity
public class Dingdan_chanpin {
@Id
private Integer id;
//产品信息
@ManyToOne (cascade = CascadeType.ALL, fetch = FetchType.LAZY)

private Dingdan dingdan;
//产品数量
@ManyToOne(cascade = CascadeType.ALL, fetch = FetchType.LAZY)

private Chanpin chanpin;

public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public Dingdan getDingdan() {
return dingdan;
}
public void setDingdan(Dingdan dingdan) {
this.dingdan = dingdan;
}
public Chanpin getChanping() {
return chanpin;
}
public void setChanping(Chanpin chanping) {
this.chanpin = chanping;
}
}
package com.kucun.data.entity;

import java.util.List;

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.Id;
import javax.persistence.ManyToMany;
import javax.persistence.OneToMany;

/**

订单
@author Administrator
*/

@Entity
public class Dingdan {
@Id
private Integer id;
//订单号
private String number;

@OneToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY)
private List<Dingdan_chanpin> dingdan_chanpins;

@OneToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY)
private List<Dingdan_chanpin_zujian> dingdan_chanpins_zujians;

public List<Dingdan_chanpin> getDingdan_chanpins() {
return dingdan_chanpins;
}
public void setDingdan_chanpins(List<Dingdan_chanpin> dingdan_chanpins) {
this.dingdan_chanpins = dingdan_chanpins;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getNumber() {
return number;
}
public void setNumber(String number) {
this.number = number;
}
public Dingdan(Integer id, String number) {
super();
this.id = id;
this.number = number;
}
public Dingdan() {
super();
// TODO Auto-generated constructor stub
}

}
package com.kucun.data.entity;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
/**

通信类
@author Administrator
*/
public class Information {
private static final ObjectMapper mapper = new ObjectMapper();
private Integer Status ;
private String text;
private Object data;
public Integer getStatus() {
return Status;
}
public void setStatus(Integer status) {
Status = status;
}
public String getText() {
return text;
}
public void setText(String text) {
this.text = text;
}
public Object getData() {
return data;
}
public void setData(Object data) {
this.data = data;
}
public Information(Integer status, String text, Object data) {
super();
Status = status;
this.text = text;

this.data = data;
}

@SuppressWarnings({“unchecked”,“rawtypes”})
public Information(Integer status, String text, String data, Class T) throws Exception {
super();
Status = status;
this.text = text;

this.data = fromJson(data,T);
}

public Information() {
super();
// TODO Auto-generated constructor stub
}

public String DataJson() throws JsonProcessingException {
// Java对象转JSON

return mapper.writeValueAsString(this);
}
@SuppressWarnings(“unchecked”)
public <T> T fromJson(String json, Class<T> clazz) throws Exception {
data= mapper.readValue(json, clazz);
return (T) data;
}
public static Information NewSuccess(Object data) {

return new Information(200, “success”, data);
}
public static Information NewSuccess(String data) {

return new Information(200, “success”, data);
}
public static Information Newfail(Integer status,String text,Object data) {

return new Information(status, “success”, data);
}
}
package com.kucun.data.entity;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.OneToOne;
/**

库存
@author Administrator
*/
@Entity
public class Kucun {
@Id
private Integer id;

private Long shuliang;

@OneToOne(fetch = FetchType.LAZY) // 正确映射 Bancai 实体
@JoinColumn(name = “bancai_id”, referencedColumnName = “id”)
private Bancai bancai;
public Integer getId() {
return id;
}

public void setId(Integer id) {
this.id = id;
}

public Bancai getBancai() {
return bancai;
}

public void setBancai(Bancai bancai) {
this.bancai = bancai;
}

public Long getShuliang() {
return shuliang;
}

public void setShuliang(Long shuliang) {
this.shuliang = shuliang;
}

public Kucun(Integer id, Bancai bancai, Long shuliang) {
super();
this.id = id;
this.bancai = bancai;
this.shuliang = shuliang;
}

public Kucun() {
super();
// TODO Auto-generated constructor stub
}

}
package com.kucun.data.entity;

import java.util.List;

import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.ManyToMany;
import javax.persistence.OneToMany;
import javax.persistence.Table;

import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
/**

木皮
@author Administrator
*/
@Entity
@Table(name=“mupi”)

@JsonIgnoreProperties({“hibernateLazyInitializer”, “handler”})
public class Mupi {
@Id

private int id;
private String name;
/**

是否有油漆 */ private Boolean you; // 添加 OneToMany 映射 @OneToMany(mappedBy = “mupi1”) // 指向 Bancai 中的 mupi1 字段 @JsonIgnore private List<Bancai> bancaisForMupi1; @OneToMany(mappedBy = “mupi2”) // 指向 Bancai 中的 mupi2 字段 @JsonIgnore private List<Bancai> bancaisForMupi2;
public Mupi(int id, String name, List<Bancai> bancaisForMupi1, List<Bancai> bancaisForMupi2) {
super();
this.id = id;
this.name = name;
this.bancaisForMupi1 = bancaisForMupi1;
this.bancaisForMupi2 = bancaisForMupi2;
}
public List<Bancai> getBancaisForMupi1() {
return bancaisForMupi1;
}
public void setBancaisForMupi1(List<Bancai> bancaisForMupi1) {
this.bancaisForMupi1 = bancaisForMupi1;
}
public List<Bancai> getBancaisForMupi2() {
return bancaisForMupi2;
}
public void setBancaisForMupi2(List<Bancai> bancaisForMupi2) {
this.bancaisForMupi2 = bancaisForMupi2;
}

@Override
public String toString() {
return “{id:” + id + “, name:” + name + “}”;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Mupi(int id, String name) {
super();
this.id = id;
this.name = name;
}
public Mupi() {
super();
}
public Boolean getYou() {
return you;
}
public void setYou(Boolean you) {
this.you = you;
}
}
package com.kucun.data.entity;

import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.ManyToOne;

@Entity
public class Zujian {
@Id
private Integer id;

private String name;
@ManyToOne
private Chanpin_zujian chanpin;

public Chanpin_zujian getChanpin() {
return chanpin;
}
public void setChanpin(Chanpin_zujian chanpin) {
this.chanpin = chanpin;
}
public Zujian() {
super();
// TODO Auto-generated constructor stub
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}public interface DingdanRepository extends JpaRepository<Dingdan, Integer> {

}
实现api能通过参数搜索符合条件的订单 产品 组件 板材库存的大部分信息的数据，参数为订单number ，返回数据结构不变属性名不变 属性可以null

					
最新发布

				
			

			

				

					06-06
				

			

		

		

			
				
importorg.springframework.transaction.annotation.Transactional;importjavax.persistence.EntityManager;importjavax.persistence.PersistenceContext;importjava.util.List;@ServicepublicclassDingdanService{@...

			
		

	





	

		

			

				
					
事务模型

				
			

			

				

					wangpeng1201的博客
				

				

					12-26
					
					1394
					
				

			

		

		

			
				
3种事务模型

本地事务模型

本地事务模型的名称来自于它实际上不是管理事务的框架，而是本地资源管理器。资源管理器是与之通信的数据源的实际提供者。例如，对于数据库，资源管理器是通过数据库驱动程序和DBMS实现的。对于JMS，资源管理器是通过特定的JMS提供程序实现的队列（或主题）连接工厂。使用本地事务模型，开发人员管理连接，而不是事务。实际管理本地事务的是DBMS或JMS提供程序。关于本地事务，事...

			
		

	





	

		

			

				
					
weblogic The transaction is no longer active - status: Marked rollback

				
			

			

				

					关注系统性能调优
				

				

					03-14
					
					7406
					
				

			

		

		

			
				
总部有个系统tzjh工作流报流程超时，无法走下去。分析性能问题，按我的风格，先做一个httpwatch的结果，根据结果大致定位。
   看到结果后就是一个主请求很慢，定位到是java和SQL的问题，weblogic服务一切良好。找出问题时段的Oracle AWR，可以看到下面的SQL执行了4百多秒。
   delete from gg_ru_todo_task_IPMS t
 where e

			
		

	





	

		

			

				
					
MySQL----事务transaction

				
			

			

				

					qq_41420788的博客
				

				

					08-11
					
					1189
					
				

			

		

		

			
				
..

			
		

	





	

		

			

				
					
记录错误Transaction was marked for rollback only； cannot commit

				
			

			

				

					xiashaoqi的博客
				

				

					03-12
					
					6208
					
				

			

		

		

			
				
记录错误Transaction was marked for rollback only; cannot commit

			
		

	





	

		

			

				
					
JTA使用心得 

				
			

			

				

					ReeBoo
				

				

					06-08
					
					295
					
				

			

		

		

			
				
JTA是一种J2EE分布式事务框架，用于支持多数据源的分布式事务。

1、使用JTA，在应用服务器中配置的数据源必须是XA类型的，否则JTA不生效。
2、各大应用服务器都有JTA的实现。但tomcat不支持。
3、今天遇到了事务在异步情况下的问题。如果事务中的一部分在是在独立的线程中运行，那么。。。。目前还没找到好的办法，不知道是否是无解的。
下面的这些代码片断支持嵌套JTA事务
启动...

			
		

	





	

		

			

				
					
@Transactional嵌套事务失效异常Transaction rolled back because it has been marked as rollback-only

				
			

			

				

					竹林幽深
				

				

					07-19
					
					4610
					
				

			

		

		

			
				
Transactional嵌套事务失效异常Transaction rolled back because it has been marked as rollback-only

			
		

	





	

		

			

				
					
spring事务（Transaction ）报 marked as rollback-only异常的原因及解决方法

				
			

			

				

					Dare_Huang的博客
				

				

					03-09
					
					2041
					
				

			

		

		

			
				
在spring中，在事务方法中调用多个事务方法时，spring将会把这些事务合二为一。当整个方法中每个子方法没报错时，整个方法执行完才提交事务（大家可以使用debug测试），如果某个子方法有异常，spring将该事务标志为rollback only。如果这个子方法没有将异常往上整个方法抛出或整个方法未往上抛出，那么改异常就不会触发事务进行回滚，事务就会在整个方法执行完后就会提交，这时就会造成Transaction rolled back because it has been marked as rollb

			
		

	





	

		

			

				
					
mysql事务在提交后才发送给数据库执行_如何在数据库事务提交成功后进行异步操作...

				
			

			

				

					weixin_35664081的博客
				

				

					01-25
					
					524
					
				

			

		

		

			
				
问题业务场景业务需求上经常会有一些边缘操作，比如主流程操作A：用户报名课程操作入库，边缘操作B：发送邮件或短信通知。业务要求操作A操作数据库失败后，事务回滚，那么操作B不能执行。操作A执行成功后，操作B也必须执行成功如何实现普通的执行A，之后执行B，是可以满足要求1，对于要求2通常需要设计补偿的操作一般边缘的操作，通常会设置成为异步的，以提升性能，比如发送MQ，业务系统负责事务成功后消息发送成功，...

			
		

	





	

		

			

				
					
 如何在数据库事务提交成功后进行异步操作

				
			

			

				

					weixin_33711647的博客
				

				

					01-01
					
					582
					
				

			

		

		

			
				
问题
业务场景
业务需求上经常会有一些边缘操作，比如主流程操作A：用户报名课程操作入库，边缘操作B：发送邮件或短信通知。
业务要求

操作A操作数据库失败后，事务回滚，那么操作B不能执行。
操作A执行成功后，操作B也必须执行成功

如何实现

普通的执行A，之后执行B，是可以满足要求1，对于要求2通常需要设计补偿的操作
一般边缘的操作，通...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

  
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值