MACRO NEPAL
Building a Robust SAP Connector in Java
awiskar acharya
November 22, 2025
3:28 pm

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

  1. Download SAP JCo 3 library from SAP Marketplace
  2. 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

  1. Connection Pooling: Always use connection pooling for JCo destinations
  2. Error Handling: Implement comprehensive error handling and retry mechanisms
  3. Timeouts: Configure appropriate connection and response timeouts
  4. Security: Use secure credential storage and avoid hardcoding passwords
  5. Monitoring: Implement logging and monitoring for SAP connections
  6. Testing: Create mock SAP services for unit testing
  7. 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
Category : JAVA

Leave a Reply

Your email address will not be published. Required fields are marked *


Macro Nepal Helper