Java MappedRecord类代码示例

import javax.resource.cci.MappedRecord; //导入依赖的package包/类
@Test
public void testInflowCCIReuseReleasedEndpoint() throws Exception {
    _adapter.fireCreateEndpoint();
    MappedRecord input1 = _recordFactory.createMappedRecord("testInflowCCIReuseReleasedEndpoint input1");
    input1.put("input", "World3");
    Record result1 = _adapter.fireDelivery(input1);
    Assert.assertTrue(result1 instanceof MappedRecord);
    Assert.assertEquals("Hello World3 !", ((MappedRecord)result1).get("input"));
    _adapter.fireRelease();
    
    MappedRecord input2 = _recordFactory.createMappedRecord("testInflowCCIReuseReleasedEndpoint input2");
    input2.put("input", "World4");
    Record result2 = _adapter.fireDelivery(input2);
    Assert.assertTrue(result2 instanceof MappedRecord);
    Assert.assertEquals("Hello World4 !", ((MappedRecord)result2).get("input"));
}
 

import javax.resource.cci.MappedRecord; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
public void mapFrom(MappedRecordBindingData source, Context context) throws Exception {
    super.mapFrom(source, context);

    MappedRecord record = source.getRecord();
    String recordName = record.getRecordName();
    if (recordName != null) {
        context.setProperty(JCAConstants.CCI_RECORD_NAME_KEY, recordName).addLabels(MAPPED_RECORD_LABELS);
    }
    String recordDescription = record.getRecordShortDescription();
    if (recordDescription != null) {
        context.setProperty(JCAConstants.CCI_RECORD_SHORT_DESC_KEY, recordDescription).addLabels(MAPPED_RECORD_LABELS);
    }

    for (Object obj : record.keySet()) {
        if (obj instanceof String) {
            String key = (String) obj;
            if (matches(key, getIncludeRegexes(), new ArrayList<Pattern>())) {
                context.setProperty(key, record.get(key), Scope.EXCHANGE);
            }
        }
    }
}
 

import javax.resource.cci.MappedRecord; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@SuppressWarnings("unchecked")
@Override
public void mapTo(Context context, MappedRecordBindingData target) throws Exception {
    super.mapTo(context, target);

    MappedRecord record = target.getRecord();
    for (Property property : context.getProperties()) {
        String name = property.getName();
        Object value = property.getValue();
        if (value == null) {
            continue;
        }
        if (name.equals(JCAConstants.CCI_RECORD_NAME_KEY)) {
            record.setRecordName(value.toString());
        } else if (name.equals(JCAConstants.CCI_RECORD_SHORT_DESC_KEY)) {
            record.setRecordShortDescription(value.toString());
        } else if (matches(name)) {
            record.put(name, value);
        } else if (matches(name, getIncludeRegexes(), new ArrayList<Pattern>())) {
            record.put(name, value);
        }
    }
}
 

import javax.resource.cci.MappedRecord; //导入依赖的package包/类
@Override
public Record onMessage(Record record) {
    SynchronousInOutHandler inOutHandler = new SynchronousInOutHandler();
    MappedRecord sourceRecord = MappedRecord.class.cast(record);
    try {
        MappedRecordBindingData bindingData = new MappedRecordBindingData(sourceRecord);
        String operation = _selector != null ? _selector.selectOperation(bindingData).getLocalPart() : null;
        Exchange exchange = createExchange(operation, inOutHandler);
        exchange.send(_composer.compose(bindingData, exchange));

        exchange = inOutHandler.waitForOut(_waitTimeout);
        MappedRecord returnRecord = _recordFactory.createMappedRecord(_recordName);
        returnRecord.setRecordShortDescription(_description);
        return _composer.decompose(exchange, new MappedRecordBindingData(returnRecord)).getRecord();
    } catch (Exception e) {
        throw new SwitchYardException(e);
    }
}
 

import javax.resource.cci.MappedRecord; //导入依赖的package包/类
public MappedRecord mapFunctionMapValuesToMappedRecord(final String bapiName,
                                                       final RecordFactory recordFactory,
                                                       final Map<String, Object> functionMap) throws ResourceException {
    LOG.debug("mapFunctionMapValuesToMappedRecord() functionMap=" + functionMap);

    MappedRecord mappedInputRecord = recordFactory.createMappedRecord(bapiName);

    final Map<String, Object> importMap = UnsafeCastHelper.castToMap(functionMap.get(BapiConstants.IMPORT));
    mapToMappedRecord(recordFactory, mappedInputRecord, importMap);

    final Map<String, Object> changingMap = UnsafeCastHelper.castToMap(functionMap.get(BapiConstants.CHANGING));
    mapToMappedRecord(recordFactory, mappedInputRecord, changingMap);

    final Map<String, Object> tableMap = UnsafeCastHelper.castToMap(functionMap.get(TABLE));
    mapToMappedRecord(recordFactory, mappedInputRecord, tableMap);

    LOG.debug("mapFunctionMapValuesToMappedRecord() record=" + mappedInputRecord);

    return mappedInputRecord;
}
 

import javax.resource.cci.MappedRecord; //导入依赖的package包/类
public void execute(final BapiMapping bapiMapping, final Map<String, Object> functionMap) {
    Record result;

    try {
        MappedRecord mappedInputRecord = mapper.mapFunctionMapValuesToMappedRecord(bapiMapping.getBapiName(), recordFactory,
                functionMap);

        LOG.debug("JCA Execute: " + bapiMapping.getBapiName() + ", arguments= " + functionMap + "\ninputRecord = "
                + mappedInputRecord);

        result = connectionProvider.getConnection().createInteraction().execute(null, mappedInputRecord);

        LOG.debug("JCA Execute: " + bapiMapping.getBapiName() + ", result = " + result);

        final Map<String, Object> resultMap = UnsafeCastHelper.castToMap(result);
        mapper.mapRecordToFunctionMap(functionMap, resultMap, bapiMapping);
    } catch (final ResourceException e) {
        throw new HibersapException("Error executing function module " + bapiMapping.getBapiName(), e);
    }
}
 

import javax.resource.cci.MappedRecord; //导入依赖的package包/类
@Test
public void testCreateMappedRecord() throws ResourceException {
	ConnectionFactory connectionFactory = mock(ConnectionFactory.class);
	RecordFactory recordFactory = mock(RecordFactory.class);
	MappedRecord mappedRecord = mock(MappedRecord.class);

	given(connectionFactory.getRecordFactory()).willReturn(recordFactory);
	given(recordFactory.createMappedRecord("name")).willReturn(mappedRecord);

	CciTemplate ct = new CciTemplate(connectionFactory);
	ct.createMappedRecord("name");

	verify(recordFactory).createMappedRecord("name");
}
 

import javax.resource.cci.MappedRecord; //导入依赖的package包/类
@Test
public void testOutboundCCI() throws Exception {
    _adapter.fireCreateEndpoint();
    MappedRecord input = _recordFactory.createMappedRecord("testOutboundCCI input");
    input.put("name", "Uragasumi");
    Record result = _adapter.fireDelivery(input);
    _adapter.fireRelease();
    Assert.assertTrue(result instanceof MappedRecord);
    Assert.assertEquals("Hello, Uragasumi!", MappedRecord.class.cast(result).get("name"));
}
 

import javax.resource.cci.MappedRecord; //导入依赖的package包/类
@Test
public void testInflowCCI() throws Exception {
    _adapter.fireCreateEndpoint();
    MappedRecord input = _recordFactory.createMappedRecord("testInflowCCI input");
    input.put("input", "World");
    Record result = _adapter.fireDelivery(input);
    _adapter.fireRelease();
    
    Assert.assertTrue(result instanceof MappedRecord);
    Assert.assertEquals("Hello World !", ((MappedRecord)result).get("input"));
}
 

import javax.resource.cci.MappedRecord; //导入依赖的package包/类
@Test
public void testInflowCCIWithBeforeAfterDelivery() throws Exception {
    _adapter.fireCreateEndpoint();
    _adapter.fireBeforeDelivery();
    MappedRecord input1 = _recordFactory.createMappedRecord("testInflowCCIWithBeforeAfterDelivery input1");
    input1.put("input", "World2");
    Record result1 = _adapter.fireDelivery(input1);
    _adapter.fireAfterDelivery();
    
    Assert.assertTrue(result1 instanceof MappedRecord);
    Assert.assertEquals("Hello World2 !", ((MappedRecord)result1).get("input"));
}
 

import javax.resource.cci.MappedRecord; //导入依赖的package包/类
@Test(expected = RuntimeException.class)
public void testInflowCCIErrorMultipleDelivery() throws Exception {
    _adapter.fireCreateEndpoint();
    _adapter.fireBeforeDelivery();
    MappedRecord input1 = _recordFactory.createMappedRecord("testInflowCCIErrorMultipleDelivery input1");
    input1.put("input", "World5");
    MappedRecord input2 = _recordFactory.createMappedRecord("testInflowCCIErrorMultipleDelivery input2");
    input2.put("input", "World6");
    Record result1 = _adapter.fireDelivery(input1);
    Record result2 = _adapter.fireDelivery(input2);
}
 

import javax.resource.cci.MappedRecord; //导入依赖的package包/类
@Test(expected = RuntimeException.class)
public void testInflowCCIErrorAfterDeliveryWithoutBefore() throws Exception {
    _adapter.fireCreateEndpoint();
    MappedRecord input1 = _recordFactory.createMappedRecord("testInflowCCIErrorAfterDeliveryWithoutBefore input1");
    input1.put("input", "World7");
    Record result1 = _adapter.fireDelivery(input1);
    _adapter.fireAfterDelivery();
}
 

import javax.resource.cci.MappedRecord; //导入依赖的package包/类
@Test(expected = RuntimeException.class)
public void testInflowCCIErrorBeforeDeliveryWithoutPreviousAfter() throws Exception {
    _adapter.fireCreateEndpoint();
    _adapter.fireBeforeDelivery();
    MappedRecord input1 = _recordFactory.createMappedRecord("testInflowCCIErrorBeforeDeliveryWithoutPreviousAfter input1");
    input1.put("input", "World8");
    Record result1 = _adapter.fireDelivery(input1);
    
    _adapter.fireBeforeDelivery();
}
 

import javax.resource.cci.MappedRecord; //导入依赖的package包/类
@SuppressWarnings("unchecked")
private void appendToRecord(final Record record, final String fieldName, final Object value) {
    if (record instanceof IndexedRecord) {
        ((IndexedRecord) record).add(value);
    } else {
        ((MappedRecord) record).put(fieldName, value);
    }
}
 

import javax.resource.cci.MappedRecord; //导入依赖的package包/类
@SuppressWarnings("unchecked")
private void mapToMappedRecord(final RecordFactory recordFactory, final Record record, final Map<String, Object> map)
        throws ResourceException {
    for (final String fieldName : map.keySet()) {
        final Object value = map.get(fieldName);

        if (Map.class.isAssignableFrom(value.getClass())) {
            final Map<String, Object> structureMap = UnsafeCastHelper.castToMap(value);
            final Record structure = recordFactory.createMappedRecord(fieldName);

            appendToRecord(record, fieldName, structure);

            mapToMappedRecord(recordFactory, structure, structureMap);
        } else if (Collection.class.isAssignableFrom(value.getClass())) {
            final Collection<Map<String, Object>> tableMap = UnsafeCastHelper.castToCollectionOfMaps(value);
            final IndexedRecord table = recordFactory.createIndexedRecord(fieldName);

            appendToRecord(record, fieldName, table);

            int i = 0;
            for (final Map<String, Object> row : tableMap) {
                MappedRecord rowRecord = recordFactory.createMappedRecord(fieldName + ":row:" + i);
                mapToMappedRecord(recordFactory, rowRecord, row);
                table.add(rowRecord);
                i++;
            }
        } else {
            appendToRecord(record, fieldName, value);
        }
    }
}