API integration and XML payload handling in Java using HttpURLConnection and the Apache HttpClient library. To integrate with a client API using an API and XML-based payload, the entire process includes:

1. ClientURLConfig.properties: Used to store client credential details Making an API call with an JSON/XML payload and pushing data communication.
2. Data Communication from the two Client API using the JSON/XML payload API.

Step 1: ClientURLConfig.properties

Step 2: Making an API call with an XML payload and pushing master data to the location.

1. A REST API Controller is responsible for handling HTTP requests (such as GET, POST, PUT, DELETE) from clients and routing them to the appropriate service methods. It acts as the entry point for external clients to interact with the backend application. 
2. Purpose: The main role of the controller is to manage incoming HTTP requests, map them to specific methods (often called endpoints), and return appropriate responses to the client. 
3. Responsibilities: Handle HTTP requests (e.g., GET, POST, PUT, DELETE). Map the incoming requests to service methods. Return HTTP responses, often in JSON or XML format. Perform basic request validation or authentication. Act as the "interface" between the client and the service layer. In a Spring Boot application, for example, the controller is typically annotated with @RestController and the request mappings are handled using annotations like @GetMapping, @PostMapping, etc. 

Example of a REST Controller in Spring Boot with handlined XML Payload :

 
@RestController @RequestMapping("/api/users") public class UserController { private static final Logger logger = LogManager.getLogger(UserController.class); @Autowired private UserService customerServiceImpl; // controller class mathod @PostMapping(value = "/pushCustomerToClient") @ResponseBody public ResponseEntity<APIResponseEntityBean> pushCustomerToClient() throws Exception { synchronized (this) { logger.info(" Running Block !"); APIResponseEntityBean responseEntityBean = null; Object retunResult = null; try { retunResult = customerServiceImpl.getAllCustomerStores();; responseEntityBean = new APIResponseEntityBean("SUCCESS", "Response Generated Successfully!", dtFormater.format(new Date()), retunResult); } catch (Exception e) { responseEntityBean = new APIResponseEntityBean("ERROR", e.getMessage(), dtFormater.format(new Date()), retunResult); logger.error("Error In Method pushCustomerToClient of MasterAPIController.class :" + PrintStackTraceLogger.getStackTrace(e)); e.printStackTrace(); } return new ResponseEntity<APIResponseEntityBean>(responseEntityBean, HttpStatus.OK); } } }  

The Service class is a part of the business logic layer of your application. It contains methods that implement the core functionality of the application (e.g., creating, reading, updating, deleting data). The service class is called by the controller to perform operations that are not directly related to the web request itself. 

Example of a Service Class in Spring Boot: 

 Method Internal Working ->getAllCustomerStores()->buildCustomerXmlPayload()->pushCustomerXmlToa143mkClient().

 
@Service public class UserService { @Autowired private UserRepository customerRepo; //Create controller request services and have the controller send back an XML payload @Override @Transactional(readOnly = true, propagation = Propagation.SUPPORTS) public String getAllCustomerStores() throws Exception { List<MastBean> customerList = customerRepo.getCustomerDataFromDB(); //get Date for DataBase if(customerList!=null) { String xmlPayload = buildCustomerXmlPayload(customerList); //Get Master Details form Database return pushCustomerXmlToa143mkClient(xmlPayload); } } public String buildCustomerXmlPayload(List<MastBean> list) throws Exception{ StringBuilder sb = new StringBuilder(); sb.append("<?xml version=\"1.0\" encoding=\"utf-8\"?>\n"); sb.append("<AmkfData>\n<Header>\n"); sb.append("<DocumentVersion>1V</DocumentVersion>\n"); sb.append("<OriginSystem>APPv3</OriginSystem>\n"); sb.append("<ClientEnvCode>a143mk1</ClientEnvCode>\n"); sb.append("<ParentCompanyCode>a143mk</ParentCompanyCode>\n"); sb.append("<Entity>store</Entity>\n"); sb.append("<TimeStamp>").append(java.time.LocalDateTime.now()).append("</TimeStamp>\n"); sb.append("<MessageId>").append("str").append(System.currentTimeMillis()).append("</MessageId>\n"); sb.append("</Header>\n<ListOfStores>\n"); for (MastBean customer : list) { sb.append("<store>\n"); sb.append("<c_code>").append(nonNull(customer.getConceptCode())).append("</c_code>\n"); sb.append("<code>").append(nonNull(customer.getCustomerNo()))).append("</code>\n"); sb.append("<name>").append(nonNull(customer.getCustomerName())).append("</name>\n"); // Customer address // Split as per character limits String address1 = substringSafe(customer.getAddress(), 0, 60); String locality = substringSafe(customer.getLocality(), 60, 190); sb.append("<address_1>").append(address1.replace("&",",")).append("</address_1>\n"); sb.append("<locality>").append(locality).append("</locality>\n"); sb.append("<city>").append(nonNull(customer.getCityName())).append("</city>\n"); sb.append("<state>").append(customer.getStateCode()).append("</state>\n"); sb.append("<zip>").append(nonNull(customer.getPinCode())).append("</zip>\n"); sb.append("<country>INDIA</country>\n"); sb.append("<email>").append(nonNull(customer.getEmailId())).append("</email>\n"); sb.append("<contact></contact>\n"); sb.append("<action_code>CREATE</action_code>\n"); sb.append("<lang>es_IN</lang>\n"); sb.append("<default_ship_via_code></default_ship_via_code>\n"); sb.append("<a143mkClient_managed_flg></a143mkClient_managed_flg>\n"); sb.append("</store>\n"); } sb.append("</ListOfStores>\n</AmkfData>"); System.out.println("Data payload \n" + sb); return sb.toString(); } // create push "pushCustomerXmlToa143mkClient" Mathod. public String pushCustomerXmlToa143mkClient(String xmlPayload) throws Exception{ InputStream input; String CUST_URL =""; String CUST_USER_PASS_AUTH =""; Properties prop = new Properties(); try { input = CustomerServiceImpl.class.getClassLoader().getResourceAsStream("a143mkClientURL.properties"); prop.load(input); CUST_URL=prop.getProperty("CUST_URL"); CUST_USER_PASS_AUTH=prop.getProperty("CUST_USER_PASS_AUTH"); String encodedAuth = Base64.getEncoder().encodeToString(CUST_USER_PASS_AUTH.getBytes(StandardCharsets.UTF_8)); HttpPost post = new HttpPost(CUST_URL); post.setHeader("Authorization", "Basic " + encodedAuth); post.setHeader("Content-Type", "application/x-www-form-urlencoded"); List<NameValuePair> params = new ArrayList<>(); params.add(new BasicNameValuePair("xml_data", xmlPayload)); try (CloseableHttpClient client = HttpClients.createDefault()) { post.setEntity(new UrlEncodedFormEntity(params, StandardCharsets.UTF_8)); try (CloseableHttpResponse response = client.execute(post)) { System.out.println("API response: " + response.getStatusLine()); String responseBody = EntityUtils.toString(response.getEntity(), StandardCharsets.UTF_8); System.out.println("Response Body: " + responseBody); return responseBody; } } catch (IOException e) { logger.error("IOException of pushCustomerXmlToa143mkClient() "+e.toString()); throw new RuntimeException("Error while sending XML to a143mkClient", e); } } catch (Exception e) { logger.error("Exception of pushCustomerXmlToa143mkClient() "+e.toString()); return null; } } }

To test an API endpoint URL like https://a143mk.com/api/puchCustData/pushCustomerToClient using Postman, refer to the image. This will allow you to verify the API's functionality and inspect the response.

CROSS is a system that allows client web applications (such as JavaScript code) loaded on one domain to interact with resources located on a different domain.
Origin: An "Origin" (or source) URL consists of three parts: Protocol (scheme): Such as http or https. Domain (host): Such as a143mk.blogspot.com or localhost. Port (port number): Such as 8080 or 3000. If any of these three parts are different in a request, it is called a Cross-Origin request.
Example:
If your frontend (endpoints.com) sends a request to a backend API (api.com), it is Cross-Origin and will be intercepted by the browser. CORS is a way to relax this security restriction in a controlled manner, allowing legitimate cross-origin communication.

 
import org.springframework.web.bind.annotation.CrossOrigin; import org.springframework.web.bind.annotation.RestController; @RestController @CrossOrigin(origins = "http://localhost:3000") // Example: Allow only this Origin public class MyController { // ... methods }
Configuring CORS globally in Spring Boot is the preferred approach, as it saves you from having to apply the @CrossOrigin annotation to every controller or method and keeps the configuration centralized.
Example: This method defines global CORS settings 

package com.example.demo.config; import org.springframework.context.annotation.Configuration; import org.springframework.web.servlet.config.annotation.CorsRegistry; import org.springframework.web.servlet.config.annotation.WebMvcConfigurer; @Configuration public class CorsConfig implements WebMvcConfigurer { @Override public void addCorsMappings(CorsRegistry registry) { registry.addMapping("/**").allowedOrigins("http://localhost:3000", "https://your-client-app.com") .allowedMethods("GET", "POST", "PUT", "DELETE", "OPTIONS").allowedHeaders("*") .allowCredentials(true).maxAge(3600); } }