Building a Robust SAP Connector in Java

SAP systems are the backbone of many enterprise operations, and connecting Java applications to SAP is a common requirement. This article explores various methods for building a reliable SAP connector in Java, from official SAP libraries to REST-based approaches.

Architecture Overview

Java applications can connect to SAP through several channels:

Java Application → SAP Java Connector (JCo) → SAP RFC → SAP Cloud SDK → OData Services → REST HTTP → SAP Gateway → SOAP Web Services → SAP SOAP RFC

Method 1: SAP Java Connector (JCo) - The Traditional Approach

SAP JCo is the official, high-performance connector for RFC (Remote Function Call) communication.

Prerequisites

Download SAP JCo 3 library from SAP Marketplace
Add to your project dependencies

Implementation

package com.yourapp.sap; import com.sap.conn.jco.*; import org.springframework.stereotype.Component; @Component public class SAPJCoConnector { private JCoDestination destination; public SAPJCoConnector() { initializeDestination(); } private void initializeDestination() { try { // Configure destination data provider PropertiesConnectivityRepository dataProvider = new PropertiesConnectivityRepository(); JCoContext.begin(destination); // Create destination destination = JCoDestinationManager.getDestination("SAP_DEV"); } catch (JCoException e) { throw new RuntimeException("Failed to initialize SAP connection", e); } } /** * Call RFC function module */ public Map<String, Object> callRFC(String functionName, Map<String, Object> inputParams) { try { JCoFunction function = destination.getRepository().getFunction(functionName); if (function == null) { throw new RuntimeException("RFC function " + functionName + " not found"); } // Set input parameters JCoParameterList input = function.getImportParameterList(); for (Map.Entry<String, Object> entry : inputParams.entrySet()) { input.setValue(entry.getKey(), entry.getValue()); } // Execute RFC call function.execute(destination); // Process output JCoParameterList output = function.getExportParameterList(); return convertJCoParamsToMap(output); } catch (JCoException e) { throw new RuntimeException("RFC call failed: " + functionName, e); } } /** * Call BAPI (Business API) with transaction handling */ public String callBAPI(String bapiName, Map<String, Object> parameters) { try { JCoContext.begin(destination); // Get BAPI function JCoFunction bapiFunction = destination.getRepository().getFunction(bapiName); // Set parameters JCoParameterList importParams = bapiFunction.getImportParameterList(); for (Map.Entry<String, Object> entry : parameters.entrySet()) { importParams.setValue(entry.getKey(), entry.getValue()); } // Execute BAPI bapiFunction.execute(destination); // Check return message JCoParameterList exportParams = bapiFunction.getExportParameterList(); JCoStructure returnStructure = exportParams.getStructure("RETURN"); if (returnStructure != null) { String type = returnStructure.getString("TYPE"); String message = returnStructure.getString("MESSAGE"); if ("E".equals(type) || "A".equals(type)) { throw new RuntimeException("BAPI error: " + message); } return message; } return "BAPI executed successfully"; } catch (JCoException e) { throw new RuntimeException("BAPI call failed: " + bapiName, e); } finally { try { JCoContext.end(destination); } catch (JCoException e) { // Log error but don't throw } } } private Map<String, Object> convertJCoParamsToMap(JCoParameterList params) { Map<String, Object> result = new HashMap<>(); if (params != null) { for (int i = 0; i < params.getMetaData().getFieldCount(); i++) { String fieldName = params.getMetaData().getName(i); result.put(fieldName, params.getValue(fieldName)); } } return result; } }

Configuration Class

@Configuration public class SAPJCoConfig { @Value("${sap.jco.ashost}") private String ashost; @Value("${sap.jco.sysnr}") private String sysnr; @Value("${sap.jco.client}") private String client; @Value("${sap.jco.username}") private String username; @Value("${sap.jco.password}") private String password; @Value("${sap.jco.lang}") private String lang; @PostConstruct public void setupJCo() { Properties connectProperties = new Properties(); connectProperties.setProperty("jco.client.ashost", ashost); connectProperties.setProperty("jco.client.sysnr", sysnr); connectProperties.setProperty("jco.client.client", client); connectProperties.setProperty("jco.client.user", username); connectProperties.setProperty("jco.client.passwd", password); connectProperties.setProperty("jco.client.lang", lang); connectProperties.setProperty("jco.destination.pool_capacity", "3"); connectProperties.setProperty("jco.destination.peak_limit", "10"); try { JCoDestinationManager.registerDestinationConfiguration( new CustomDestinationDataProvider(connectProperties)); } catch (Exception e) { throw new RuntimeException("Failed to configure SAP JCo", e); } } private static class CustomDestinationDataProvider implements JCoDestinationDataProvider { private final Properties properties; public CustomDestinationDataProvider(Properties properties) { this.properties = properties; } @Override public JCoDestinationData getDestinationData(String destinationName) { return new JCoDestinationData() { @Override public Properties getProperties() { return properties; } @Override public JCoCredentials getCredentials() { return null; // Use properties for credentials } }; } } }

Method 2: SAP Cloud SDK - Modern Cloud Approach

The SAP Cloud SDK provides a more modern, cloud-native way to connect to SAP systems.

Dependencies

<dependency> <groupId>com.sap.cloud.sdk.s4hana</groupId> <artifactId>s4hana-all</artifactId> <version>3.17.0</version> </dependency>

Implementation with SAP Cloud SDK

package com.yourapp.sap; import com.sap.cloud.sdk.cloudplatform.connectivity.*; import com.sap.cloud.sdk.s4hana.datamodel.odata.services.*; import com.sap.cloud.sdk.s4hana.datamodel.odata.namespaces.businesspartner.BusinessPartner; import com.sap.cloud.sdk.s4hana.datamodel.odata.namespaces.businesspartner.BusinessPartnerAddress; import org.springframework.stereotype.Service; import javax.annotation.Nonnull; import java.util.List; @Service public class SAPCloudSDKConnector { private final DefaultBusinessPartnerService businessPartnerService; public SAPCloudSDKConnector() { this.businessPartnerService = new DefaultBusinessPartnerService(); } /** * Get business partners using OData service */ public List<BusinessPartner> getBusinessPartners(String country) { try { return businessPartnerService .getAllBusinessPartner() .select(BusinessPartner.BUSINESS_PARTNER, BusinessPartner.LAST_NAME, BusinessPartner.FIRST_NAME) .filter(BusinessPartner.BUSINESS_PARTNER_ADDRESS.country.eq(country)) .execute(getErpConfig()); } catch (Exception e) { throw new RuntimeException("Failed to fetch business partners", e); } } /** * Create business partner */ public BusinessPartner createBusinessPartner(BusinessPartner businessPartner) { try { return businessPartnerService .createBusinessPartner(businessPartner) .execute(getErpConfig()); } catch (Exception e) { throw new RuntimeException("Failed to create business partner", e); } } @Nonnull private ErpConfigContext getErpConfig() { return new ErpConfigContext("S4HANA"); } /** * Call custom OData service */ public <T> List<T> executeODataQuery(String servicePath, Class<T> resultType, String query) { try { return ODataQueryBuilder .withEntity(servicePath, resultType.getSimpleName()) .select(query) .build() .execute(getErpConfig()) .asList(); } catch (Exception e) { throw new RuntimeException("OData query failed", e); } } }

Method 3: REST API with SAP Gateway

For SAP systems with OData services exposed via SAP Gateway.

REST Client Implementation

package com.yourapp.sap; import org.springframework.beans.factory.annotation.Value; import org.springframework.http.*; import org.springframework.stereotype.Service; import org.springframework.web.client.RestTemplate; import org.springframework.web.util.UriComponentsBuilder; import java.util.*; @Service public class SAPGatewayConnector { @Value("${sap.gateway.baseurl}") private String gatewayBaseUrl; @Value("${sap.gateway.username}") private String username; @Value("${sap.gateway.password}") private String password; private final RestTemplate restTemplate; public SAPGatewayConnector(RestTemplate restTemplate) { this.restTemplate = restTemplate; } /** * Get OData entities from SAP Gateway */ public <T> List<T> getODataEntities(String servicePath, String entitySet, Class<T> responseType, Map<String, String> queryParams) { String url = buildODataUrl(servicePath, entitySet, queryParams); HttpEntity<String> entity = new HttpEntity<>(createHeaders()); try { ResponseEntity<ODataResponseWrapper> response = restTemplate.exchange( url, HttpMethod.GET, entity, ODataResponseWrapper.class); if (response.getBody() != null && response.getBody().getD() != null) { ODataResponseWrapper wrapper = response.getBody(); // Extract results based on your OData service structure return extractResults(wrapper, responseType); } return Collections.emptyList(); } catch (Exception e) { throw new RuntimeException("OData request failed", e); } } /** * Create entity via OData */ public <T> T createEntity(String servicePath, String entitySet, T entity, Class<T> responseType) { String url = gatewayBaseUrl + "/" + servicePath + "/" + entitySet; HttpEntity<T> requestEntity = new HttpEntity<>(entity, createHeaders()); try { ResponseEntity<T> response = restTemplate.exchange( url, HttpMethod.POST, requestEntity, responseType); return response.getBody(); } catch (Exception e) { throw new RuntimeException("Create entity failed", e); } } private String buildODataUrl(String servicePath, String entitySet, Map<String, String> queryParams) { UriComponentsBuilder builder = UriComponentsBuilder .fromHttpUrl(gatewayBaseUrl) .pathSegment(servicePath, entitySet); if (queryParams != null) { queryParams.forEach(builder::queryParam); } return builder.toUriString(); } private HttpHeaders createHeaders() { HttpHeaders headers = new HttpHeaders(); headers.setContentType(MediaType.APPLICATION_JSON); headers.setAccept(Collections.singletonList(MediaType.APPLICATION_JSON)); // Basic authentication String auth = username + ":" + password; String encodedAuth = Base64.getEncoder().encodeToString(auth.getBytes()); headers.set("Authorization", "Basic " + encodedAuth); // SAP-specific headers headers.set("x-csrf-token", "fetch"); return headers; } @SuppressWarnings("unchecked") private <T> List<T> extractResults(ODataResponseWrapper wrapper, Class<T> type) { // Implementation depends on your OData service structure // This is a simplified example try { if (wrapper.getD() instanceof Map) { Map<String, Object> data = (Map<String, Object>) wrapper.getD(); if (data.containsKey("results")) { return (List<T>) data.get("results"); } } return Collections.emptyList(); } catch (Exception e) { throw new RuntimeException("Failed to parse OData response", e); } } // OData response wrapper class public static class ODataResponseWrapper { private Object d; public Object getD() { return d; } public void setD(Object d) { this.d = d; } } }

Configuration and Error Handling

Application Properties

# SAP JCo Configuration sap.jco.ashost=your-sap-server sap.jco.sysnr=00 sap.jco.client=100 sap.jco.username=your-username sap.jco.password=your-password sap.jco.lang=EN # SAP Gateway Configuration sap.gateway.baseurl=https://your-gateway-server:port sap.gateway.username=gateway-user sap.gateway.password=gateway-password # Connection Pool Settings sap.connection.pool.max-size=10 sap.connection.pool.min-idle=2 sap.connection.timeout=30000

Comprehensive Error Handler

@Component public class SAPErrorHandler { private static final Logger logger = LoggerFactory.getLogger(SAPErrorHandler.class); public void handleJCoException(JCoException e) { switch (e.getKey()) { case "JCO_ERROR_LOGON_FAILURE": logger.error("SAP Logon failed: Invalid credentials or user locked"); break; case "JCO_ERROR_COMMUNICATION": logger.error("SAP Communication error: Network issue or server unavailable"); break; case "JCO_ERROR_RESOURCE": logger.error("SAP Resource error: Connection pool exhausted"); break; default: logger.error("SAP JCo error: {}", e.getMessage(), e); } } public void handleRFCException(String functionName, Exception e) { logger.error("RFC call failed for {}: {}", functionName, e.getMessage()); // Implement retry logic or alerting } }

Best Practices

Connection Pooling: Always use connection pooling for JCo destinations
Error Handling: Implement comprehensive error handling and retry mechanisms
Timeouts: Configure appropriate connection and response timeouts
Security: Use secure credential storage and avoid hardcoding passwords
Monitoring: Implement logging and monitoring for SAP connections
Testing: Create mock SAP services for unit testing
Performance: Cache frequently accessed data to reduce RFC calls

Example Usage

@RestController public class SAPController { private final SAPJCoConnector sapConnector; public SAPController(SAPJCoConnector sapConnector) { this.sapConnector = sapConnector; } @GetMapping("/business-partners") public ResponseEntity<List<BusinessPartner>> getBusinessPartners(@RequestParam String country) { try { List<BusinessPartner> partners = sapConnector.getBusinessPartners(country); return ResponseEntity.ok(partners); } catch (Exception e) { return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build(); } } @PostMapping("/create-customer") public ResponseEntity<String> createCustomer(@RequestBody CustomerData customer) { try { Map<String, Object> params = new HashMap<>(); params.put("CUSTOMER_NAME", customer.getName()); params.put("CUSTOMER_COUNTRY", customer.getCountry()); String result = sapConnector.callBAPI("BAPI_CUSTOMER_CREATE", params); return ResponseEntity.ok(result); } catch (Exception e) { return ResponseEntity.badRequest().body(e.getMessage()); } } }

Choose the connection method based on your SAP landscape:

JCo for direct RFC connections to on-premise SAP systems
Cloud SDK for S/4HANA Cloud and modern development
REST/OData for SAP Gateway and UI5 applications