1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
package com.vci.server.bof.service;
 
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
 
import com.vci.corba.common.VCIError;
import com.vci.corba.omd.data.BusinessObject;
import com.vci.corba.omd.data.LinkObject;
import com.vci.server.bof.delegate.BOFactoryServerDelegate;
 
 
public class BatchTransferService {
    /**
     * 长事务数据缓存对象
     * @author Jason
     *
     */
    private class TransactionData{
        BusinessObject[] createBOs = new BusinessObject[0];
        LinkObject[] createLOs = new LinkObject[0];
        BusinessObject[] updateBOs = new BusinessObject[0];
        LinkObject[] updateLOs = new LinkObject[0];
        BusinessObject[] deleteBOs = new BusinessObject[0];
        LinkObject[] deleteLOs = new LinkObject[0];
    }
    
    /**
     * 长事务数据缓存
     */
    private Map<String, TransactionData> _mapTransactionData = new ConcurrentHashMap<String, TransactionData>();
 
    private static BatchTransferService _instance = null;
 
    public static synchronized BatchTransferService getInstance() {
        if (_instance == null) {
            _instance = new BatchTransferService();
        }
        
        return _instance;
    }
 
    /**
     * 开始长事务
     * @return
     */
    public String beginTransaction() {
        String sessionKey = UUID.randomUUID().toString();
        //res.success = true;
        return sessionKey;
    }
 
    /**
     * 批量传递长事务缓存数据
     * @param sessionKey
     * @param createBOs
     * @param createLOs
     * @param updateBOs
     * @param updateLOs
     * @param deleteBOs
     * @param deleteLOs
     * @return
     * @throws VCIError
     */
    public boolean batchCUDBOLO(String sessionKey,
            BusinessObject[] createBOs, LinkObject[] createLOs,
            BusinessObject[] updateBOs, LinkObject[] updateLOs,
            BusinessObject[] deleteBOs, LinkObject[] deleteLOs) throws VCIError {
        TransactionData trData = getInnerDataFromSession(sessionKey);
        
        trData.createBOs = getMergedBusinessObjects(createBOs, trData.createBOs);
        trData.createLOs = getMergedLinkObjects(createLOs, trData.createLOs);
        trData.updateBOs = getMergedBusinessObjects(updateBOs, trData.updateBOs);
        trData.updateLOs = getMergedLinkObjects(updateLOs, trData.updateLOs);
        trData.deleteBOs = getMergedBusinessObjects(deleteBOs, trData.deleteBOs);
        trData.deleteLOs = getMergedLinkObjects(deleteLOs, trData.deleteLOs);
        
        _mapTransactionData.put(sessionKey, trData);
        
        return false;
    }
 
    public boolean commitTransaction(String sessionKey) throws VCIError {
        boolean res = false;
        
        TransactionData trData = getInnerDataFromSession(sessionKey);
        
//        BusinessObjectListHolder cbosHolder = new BusinessObjectListHolder();
//        BusinessObjectListHolder ubosHolder = new BusinessObjectListHolder();
//
//        LinkObjectListHolder closHolder = new LinkObjectListHolder();
//        LinkObjectListHolder ulosHolder = new LinkObjectListHolder();
 
        BOFactoryServerDelegate bofDelegate = BOFactoryServerDelegate.getInstance();
        return bofDelegate.batchCUDBOLO(trData.createBOs, trData.createLOs, 
                trData.updateBOs, trData.updateLOs, 
                trData.deleteBOs, trData.deleteLOs);
    }
 
    
    private BusinessObject[] getMergedBusinessObjects(BusinessObject[] bos1, BusinessObject[] bos2){
        BusinessObject[] bos = new BusinessObject[bos1.length + bos2.length];
        System.arraycopy(bos1, 0, bos, 0, bos1.length);
        System.arraycopy(bos2, 0, bos, bos1.length, bos2.length);
        return bos;
    }
    private LinkObject[] getMergedLinkObjects(LinkObject[] los1, LinkObject[] los2){
        LinkObject[] bos = new LinkObject[los1.length + los2.length];
        System.arraycopy(los1, 0, bos, 0, los1.length);
        System.arraycopy(los2, 0, bos, los1.length, los2.length);
        return bos;
    }
    
 
    protected TransactionData getInnerDataFromSession(String sessionKey){
        Object obj = _mapTransactionData.get(sessionKey);
        if(obj != null && obj instanceof TransactionData){
            return (TransactionData)obj;
        }
        return new TransactionData();
    }
}