1. Integrating SAP the
Java EE way
JBoss OneDayTalk 2012
Carsten Erker

2. Remember those
days...?

3. Statement st = conn.createStatement();
ResultSet rs = st.executeQuery( "SELECT * FROM customer" );
List<Customer> customers = new ArrayList<Customer>();
while ( rs.next() )
{
Customer customer = new Customer();
customer.setId( rs.getString( "ID" ) );
customer.setFirstName( rs.getString( "FIRST_NAME" ) );
customer.setLastName( rs.getString( "LAST_NAME" ) );
...
customers.add( customer );
}
...

4. Who is still doing this?

5. Nowadays we do
something like this...

6. @Entity
public class Customer
{
@Id @GeneratedValue
private Long id;
private String firstName;
private String lastName;
...
}

7. List<Customer> customers = entityManager
.createQuery( "select c from Customer c" )
.getResultList();

8. When calling business
logic in SAP we don‘t
want to go the old
way...

9. Setting the stage...
Courtesy of Special Collections, University of Houston Libraries. UH Digital Library.

10. The SAP Java
Connector (JCo)

11. How it works...

12. Calls function modules
in SAP backend

13. Function modules are a
piece of code written in
ABAP

14. They have an interface
with different types of
parameters to pass data

15. FUNCTION BAPI_SFLIGHT_GETLIST.
*"-----------------------------------------------------
*"*"Lokale Schnittstelle:
*" IMPORTING
*" VALUE(FROMCITY) LIKE BAPISFDETA-CITYFROM
*" VALUE(TOCITY) LIKE BAPISFDETA-CITYTO
*" VALUE(AIRLINECARRIER) LIKE BAPISFDETA-CARRID
*" EXPORTING
*" VALUE(RETURN) LIKE BAPIRET2 STRUCTURE BAPIRET2
*" TABLES
*" FLIGHTLIST STRUCTURE BAPISFLIST
*"-----------------------------------------------------

16. JCo runs on top of
the SAP-proprietary
RFC interface
(Remote Function Call)

17. JCo can be used in
Client and Server mode

18. Example code calling a
function module in
SAP...

19. JCoDestination destination = JCoDestinationManager.getDestination( "NSP" );
JCoFunction function =
destination.getRepository().getFunction( "BAPI_FLCUST_GETLIST" );
function.getImportParameterList().setValue( "MAX_ROWS", 10 );
function.execute( destination );
JCoParameterList tableParams = function.getTableParameterList();
JCoTable table = tableParams.getTable( "CUSTOMER_LIST" );
List<Customer> customers = new ArrayList<Customer>();
for ( int i = 0; i < table.getNumRows(); i++ )
{
table.setRow( i );
Customer customer = new Customer();
customer.setId( table.getLong( "CUSTOMERID" ) );
customer.setLastName( table.getString( "CUSTNAME" ) );
customers.add( customer );
}
...

20. => Lots of glue code,
tedious mapping of
parameters

21. But - JCo has some
benefits that make it a
good fit for business
apps...

22. It can be used with
Transactions

23. It implements
Connection Pooling

24. SAP functions can be
called asynchronously

25. It is fast

26. The bad points...

27. The programming
model

28. Does not fit very well
into the Java EE world:

29. Not trivial to use it
with CMT

30. The same goes for
Security

31. The alternative:
Java EE Connector
Architecture (JCA)

32. JCA is a Java EE
standard

33. JCA was created for
the interaction of Java
EE applications with
Enterprise Information
Systems, such as SAP

34. A Resource Adapter is
an implementation of
JCA for a certain EIS

35. A RA is deployed in an
Application Server in
form of a Resource
Archive (.rar)

36. The RA takes care of...

37. Transaction
Management

38. Connection
Management

39. Security
Management

40. ... all this in a standard
way

41. JCA solves a lot of
problems, except one...

42. The programming
model
:-(

43. JCA defines the
Common Client
Interface (CCI) for a
standard way to access
an EIS

44. Because of the many
different natures of
EIS‘s, it is overly generic

45. It operates on Lists,
Maps and/or ResultSets
representing the data

46. Additionally, a lot of
glue code needs to be
written

47. In this, it is not too
different from SAP‘s
Java Connector...

48. @Resource( mappedName = "java:jboss/eis/NSP" )
private ConnectionFactory connectionFactory;
...
Connection connection = connectionFactory.getConnection();
Interaction interaction = connection.createInteraction();
RecordFactory rf = connectionFactory.getRecordFactory();
MappedRecord input = rf.createMappedRecord( "BAPI_FLCUST_GETLIST" );
input.put( "CUSTOMER_NAME", "Ernie" );
input.put( "MAX_ROWS", 20 );
MappedRecord output = ( MappedRecord ) interaction.execute( null, input );
...

49. List<Customer> customers = new ArrayList<Customer>();
IndexedRecord customerTable = ( IndexedRecord ) output.get( "CUST_LIST" );
for ( Object row : customerTable )
{
MappedRecord record = ( MappedRecord ) row;
Customer customer = new Customer();
customer.setId( ( String ) record.get( "CUSTOMERID" ) );
customer.setName( ( String ) record.get( "CUSTNAME" ) );
...
result.addCustomer( customer );
}

50. SAP offers a RA that
only runs on SAP
Application Servers

51. Any more alternatives?

52. For read-only and
less frequent SAP calls
consider using
Web Services

53. A SOA platform may be
well suited for not-so-
tight integration

54. Introducing the cool
stuff...
Photo by Alan Levine, CC-BY 2.0, http://www.flickr.com/photos/cogdog

56. It implements JCA
version 1.5

57. It currently only
supports the
outbound way

58. Under the hood, it uses
the SAP Java
Connector (JCo)

59. The next steps...

60. Upgrading Cuckoo to
JCA version 1.6

61. Adding inbound
capability

62. Cuckoo is
Open Source under
LGPL License

63. More info:
https://sourceforge.net/p/cuckoo-ra/

64. Example application:
https://github.com/cerker/
cuckoo-example

65. What was all the fuss
about the programming
model?

66. We still have to solve
this problem...

68. Hibersap is something
like an O/R mapper for
SAP functions

69. It makes use of Java
annotations to map
SAP functions and their
parameters to Java
objects

70. It has an API that is
quite similar to
Hibernate/JPA

71. Thus it fits very well
into the modern Java
world

72. Hibersap takes care of
most of the glue code

73. It can be either used
with JCo or with a JCA
Resource Adapter

74. Switching between
them is a matter of
configuration

75. This makes integration
testing a breeze

76. Finally, some code...

77. The business object...

78. @Bapi( "BAPI_FLCUST_GETLIST" )
public class CustomerList
{
@Import @Parameter("MAX_ROWS")
private int maxRows;
@Table @Parameter( "CUSTOMER_LIST" )
private List<Customer> customers;
...
} public class Customer
{
@Parameter("CUSTOMERID")
private String id;
@Parameter( "CUSTNAME" )
private String firstName;
...
}

79. The API...

80. Session session = sessionManager.openSession();
CustomerList customerList = new CustomerList( 10 );
session.execute( customerList );
List<Customer> customers = customerList.getCustomers();

81. The configuration...

82. META-INF/hibersap.xml => JCA
<hibersap>
<session-manager name="NSP">
<context>org.hibersap.execution.jca.JCAContext</context>
<jca-connection-factory>
java:jboss/eis/sap/NSP
</jca-connection-factory>
<annotated-classes>
<annotated-class>
de.akquinet.jbosscc.cuckoo.example.model.CustomerSearch
</annotated-class>
...
</annotated-classes>
</session-manager>
</hibersap>

83. META-INF/hibersap.xml => JCo
<hibersap>
<session-manager name="NSP">
<context>org.hibersap.execution.jco.JCoContext</context>
<properties>
" " " <property name="jco.client.client" value="001" />
" " " <property name="jco.client.user" value="sapuser" />
" " " <property name="jco.client.passwd" value="password" />
" " " <property name="jco.client.ashost" value="10.20.30.40" />
" " " <property name="jco.client.sysnr" value="00" />
...
" " </properties>
<annotated-classes>
<annotated-class>
de.akquinet.jbosscc.cuckoo.example.model.CustomerSearch
</annotated-class>
...
</annotated-classes>
</session-manager>
</hibersap>

84. Bean Validation can be
used on parameter
fields...

85. @Parameter( "COUNTR_ISO" )
@NotNull @Size(min = 2, max = 2)
private String countryKeyIso;

86. Converters allow for
data type or format
conversion on
parameter fields...

87. @Parameter( "TYPE" )
@Convert( converter = SeverityConverter.class )
private Severity severity;

88. Hibersap is Open
Source and licensed
under LGPL

89. More info:
http://hibersap.org

90. Putting it all together...

91. In a Java EE application
we should use
Cuckoo RA

92. Thus, we can make use
of CMT in EJBs

93. ...and all the other
benefits of JCA

94. Using Hibersap, we gain
an elegant and
lightweight
programming model

95. ... especially when using
Hibersap‘s EJB tools

96. Thus, we get much
nicer code that is easier
to understand, maintain
and test

97. Example application:
https://github.com/cerker/
cuckoo-hibersap-example

98. Tooling...

99. JBoss Forge plugin:
https://github.com/
forge/plugin-hibersap
See also:
http://blog.akquinet.de/
2012/07/12/

100. Hibersap-Camel
Component:
https://github.com/
bjoben/camel-hibersap

101. About me...

102. Carsten Erker
Software Architect and Consultant
akquinet AG in Berlin / Germany
carsten.erker@akquinet.de

103. Questions?