4.3.9.RELEASE Spring Framework
743
public class
MyDaoImpl extends
CciDaoSupport implements
MyDao {
public String getDataString input {
ECIInteractionSpec interactionSpec = ...; String output = String getCciTemplate.executeinteractionSpec,
new InteractionCallback {
public Object doInInteractionInteraction interaction,
ConnectionFactory factory throws
ResourceException { Record input =
new CommAreaRecordinputString.getBytes;
Record output = new
CommAreaRecord; interaction.executeholder.getInteractionSpec, input, output;
return new
Stringoutput.toByteArray; }
};
return output;
} }
For the examples above, the corresponding configuration of the involved Spring beans could look like this in non-managed mode:
bean id
= managedConnectionFactory
class =
com.ibm.connector2.cics.ECIManagedConnectionFactory property
name =
serverName value
= TXSERIES
property name
= connectionURL
value =
local: property
name =
userName value
= CICSUSER
property name
= password
value =
CICS bean
bean id
= connectionFactory
class =
org.springframework.jca.support.LocalConnectionFactoryBean property
name =
managedConnectionFactory ref
= managedConnectionFactory
bean bean
id =
component class
= mypackage.MyDaoImpl
property name
= connectionFactory
ref =
connectionFactory bean
In managed mode that is, in a Java EE environment, the configuration could look as follows:
jee:jndi-lookup id
= connectionFactory
jndi-name =
eiscicseci bean
id =
component class
= MyDaoImpl
property name
= connectionFactory
ref =
connectionFactory bean
32.4 Modeling CCI access as operation objects
The org.springframework.jca.cci.object
package contains support classes that allow you to access the EIS in a different style: through reusable operation objects, analogous to Spring’s JDBC
operation objects see JDBC chapter. This will usually encapsulate the CCI API: an application-level input object will be passed to the operation object, so it can construct the input record and then convert
the received record data to an application-level output object and return it.
Note
This approach is internally based on the CciTemplate
class and the RecordCreator
RecordExtractor interfaces, reusing the machinery of Spring’s core CCI support.
MappingRecordOperation
MappingRecordOperation essentially performs the same work as
CciTemplate , but represents
a specific, pre-configured operation as an object. It provides two template methods to specify how to
4.3.9.RELEASE Spring Framework
744
convert an input object to a input record, and how to convert an output record to an output object record mapping:
• createInputRecord..
to specify how to convert an input object to an input Record
• extractOutputData..
to specify how to extract an output object from an output Record
Here are the signatures of these methods:
public abstract
class MappingRecordOperation
extends EisOperation {
...
protected abstract
Record createInputRecordRecordFactory recordFactory, Object inputObject
throws ResourceException, DataAccessException {
... }
protected abstract
Object extractOutputDataRecord outputRecord
throws ResourceException, SQLException, DataAccessException {
... }
... }
Thereafter, in order to execute an EIS operation, you need to use a single execute method, passing in an application-level input object and receiving an application-level output object as result:
public abstract
class MappingRecordOperation
extends EisOperation {
...
public Object executeObject inputObject
throws DataAccessException {
} ...
}
As you can see, contrary to the CciTemplate
class, this execute..
method does not have an InteractionSpec
as argument. Instead, the InteractionSpec
is global to the operation. The following constructor must be used to instantiate an operation object with a specific
InteractionSpec :
InteractionSpec spec = ...; MyMappingRecordOperation eisOperation =
new MyMappingRecordOperationgetConnectionFactory, spec;
...
MappingCommAreaOperation
Some connectors use records based on a COMMAREA which represents an array of bytes containing parameters to send to the EIS and data returned by it. Spring provides a special operation class
for working directly on COMMAREA rather than on records. The MappingCommAreaOperation
class extends the MappingRecordOperation
class to provide such special COMMAREA support. It implicitly uses the
CommAreaRecord class as input and output record type, and provides two new
methods to convert an input object into an input COMMAREA and the output COMMAREA into an output object.
4.3.9.RELEASE Spring Framework
745
public abstract
class MappingCommAreaOperation
extends MappingRecordOperation {
...
protected abstract
byte [] objectToBytesObject inObject
throws IOException, DataAccessException;
protected abstract
Object bytesToObject byte
[] bytes
throws IOException, DataAccessException;
... }
Automatic output record generation
As every MappingRecordOperation
subclass is based on CciTemplate internally, the same way to automatically generate output records as with
CciTemplate is available. Every operation object
provides a corresponding setOutputRecordCreator..
method. For further information, see the section called “Automatic output record generation”.
Summary
The operation object approach uses records in the same manner as the CciTemplate
class. Table 32.2. Usage of Interaction execute methods
MappingRecordOperation method signature
MappingRecordOperation outputRecordCreator
property execute method called on the CCI
Interaction
Object executeObject not set
Record executeInteractionSpec, Record Object executeObject
set boolean executeInteractionSpec,
Record, Record
Example for MappingRecordOperation usage
In this section, the usage of the MappingRecordOperation
will be shown to access a database with the Blackbox CCI connector.
Note
The original version of this connector is provided by the Java EE SDK version 1.3, available from Oracle.
Firstly, some initializations on the CCI InteractionSpec
must be done to specify which SQL request to execute. In this sample, we directly define the way to convert the parameters of the request to a CCI
record and the way to convert the CCI result record to an instance of the Person
class.
4.3.9.RELEASE Spring Framework
746
public class
PersonMappingOperation extends
MappingRecordOperation {
public PersonMappingOperationConnectionFactory connectionFactory {
setConnectionFactoryconnectionFactory; CciInteractionSpec interactionSpec =
new CciConnectionSpec;
interactionSpec.setSql select from person where person_id=?
; setInteractionSpecinteractionSpec;
}
protected Record createInputRecordRecordFactory recordFactory,
Object inputObject throws
ResourceException { Integer id = Integer inputObject;
IndexedRecord input = recordFactory.createIndexedRecord input
; input.add
new Integerid;
return input;
}
protected Object extractOutputDataRecord outputRecord
throws ResourceException, SQLException {
ResultSet rs = ResultSet outputRecord; Person person = null;
if rs.next {
Person person = new
Person; person.setIdrs.getInt
person_id ;
person.setLastNamers.getString person_last_name
; person.setFirstNamers.getString
person_first_name ;
}
return person;
} }
Then the application can execute the operation object, with the person identifier as argument. Note that operation object could be set up as shared instance, as it is thread-safe.
public class
MyDaoImpl extends
CciDaoSupport implements
MyDao {
public Person getPerson
int id {
PersonMappingOperation query = new
PersonMappingOperationgetConnectionFactory; Person person = Person query.execute
new Integerid;
return person;
} }
The corresponding configuration of Spring beans could look as follows in non-managed mode:
4.3.9.RELEASE Spring Framework
747
bean id
= managedConnectionFactory
class =
com.sun.connector.cciblackbox.CciLocalTxManagedConnectionFactory property
name =
connectionURL value
= jdbc:hsqldb:hsql:localhost:9001
property name
= driverName
value =
org.hsqldb.jdbcDriver bean
bean id
= targetConnectionFactory
class =
org.springframework.jca.support.LocalConnectionFactoryBean property
name =
managedConnectionFactory ref
= managedConnectionFactory
bean bean
id =
connectionFactory class
= org.springframework.jca.cci.connection.ConnectionSpecConnectionFactoryAdapter
property name
= targetConnectionFactory
ref =
targetConnectionFactory property
name =
connectionSpec bean
class =
com.sun.connector.cciblackbox.CciConnectionSpec property
name =
user value
= sa
property name
= password
value =
bean property
bean bean
id =
component class
= MyDaoImpl
property name
= connectionFactory
ref =
connectionFactory bean
In managed mode that is, in a Java EE environment, the configuration could look as follows:
jee:jndi-lookup id
= targetConnectionFactory
jndi-name =
eisblackbox bean
id =
connectionFactory class
= org.springframework.jca.cci.connection.ConnectionSpecConnectionFactoryAdapter
property name
= targetConnectionFactory
ref =
targetConnectionFactory property
name =
connectionSpec bean
class =
com.sun.connector.cciblackbox.CciConnectionSpec property
name =
user value
= sa
property name
= password
value =
bean property
bean bean
id =
component class
= MyDaoImpl
property name
= connectionFactory
ref =
connectionFactory bean
Example for MappingCommAreaOperation usage
In this section, the usage of the MappingCommAreaOperation
will be shown: accessing a CICS with ECI mode with the IBM CICS ECI connector.
Firstly, the CCI InteractionSpec
needs to be initialized to specify which CICS program to access and how to interact with it.
4.3.9.RELEASE Spring Framework
748
public abstract
class EciMappingOperation
extends MappingCommAreaOperation {
public EciMappingOperationConnectionFactory connectionFactory, String programName {
setConnectionFactoryconnectionFactory; ECIInteractionSpec interactionSpec =
new ECIInteractionSpec,
interactionSpec.setFunctionNameprogramName; interactionSpec.setInteractionVerbECIInteractionSpec.SYNC_SEND_RECEIVE;
interactionSpec.setCommareaLength30; setInteractionSpecinteractionSpec;
setOutputRecordCreator new
EciOutputRecordCreator; }
private static
class EciOutputRecordCreator
implements RecordCreator {
public Record createRecordRecordFactory recordFactory
throws ResourceException {
return new
CommAreaRecord; }
} }
The abstract EciMappingOperation
class can then be subclassed to specify mappings between custom objects and
Records .
public class
MyDaoImpl extends
CciDaoSupport implements
MyDao {
public OutputObject getDataInteger id {
EciMappingOperation query = new
EciMappingOperationgetConnectionFactory, MYPROG
{
protected abstract
byte [] objectToBytesObject inObject
throws IOException {
Integer id = Integer inObject;
return String.valueOfid;
}
protected abstract
Object bytesToObject byte
[] bytes throws
IOException; String str =
new Stringbytes;
String field1 = str.substring0,6; String field2 = str.substring6,1;
String field3 = str.substring7,1;
return new
OutputObjectfield1, field2, field3; }
};
return OutputObject query.execute
new Integerid;
} }
The corresponding configuration of Spring beans could look as follows in non-managed mode:
bean id
= managedConnectionFactory
class =
com.ibm.connector2.cics.ECIManagedConnectionFactory property
name =
serverName value
= TXSERIES
property name
= connectionURL
value =
local: property
name =
userName value
= CICSUSER
property name
= password
value =
CICS bean
bean id
= connectionFactory
class =
org.springframework.jca.support.LocalConnectionFactoryBean property
name =
managedConnectionFactory ref
= managedConnectionFactory
bean bean
id =
component class
= MyDaoImpl
property name
= connectionFactory
ref =
connectionFactory bean
In managed mode that is, in a Java EE environment, the configuration could look as follows:
4.3.9.RELEASE Spring Framework
749
jee:jndi-lookup id
= connectionFactory
jndi-name =
eiscicseci bean
id =
component class
= MyDaoImpl
property name
= connectionFactory
ref =
connectionFactory bean
32.5 Transactions
