Step 1: Obtain the authentication details/Requirements from the client as shown in the example below.

Step 2: Making an API call with an Json 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 Json 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 "ClientApiController.java" of a REST Controller in Spring Boot with handlined Json Payload :

 
package a143mk.a143mkCustMasterMaster.SystemClientcontroller; import java.net.URL; import java.text.Format; import java.text.SimpleDateFormat; import java.util.Date; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.http.HttpStatus; import org.springframework.http.ResponseEntity; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestMethod; import org.springframework.web.bind.annotation.RestController; import a143mk.a143mkCustMasterMaster.FromBean.APIResponseEntityBean; import a143mk.a143mkCustMasterMaster.SystemClientServices.CustMastSysteCliService; import org.apache.log4j.PropertyConfigurator; @RestController @RequestMapping("/CUST_T_API") public class ClientApiController { private static final Logger logger = LoggerFactory.getLogger(CustomerMasterCoSysteCli.class); @Autowired private CustMastSysteCliService custMasteServ; @RequestMapping(method = RequestMethod.POST, value="/cust") public ResponseEntity<APIResponseEntityBean> getCustMasterSysteCli() { APIResponseEntityBean responseEntityBean = null; Object retunResult=null; try { /*Log4je Config*/ ClassLoader loader = Thread.currentThread().getContextClassLoader(); URL url = loader.getResource("application.properties"); PropertyConfigurator.configure(url); /* End Log4je Config*/ logger.info("Push A143mk Customer TO SysteCli Method is getCustMasterSysteCli()"); retunResult=custMasteServ.CustMastSystemNameService(); responseEntityBean = new APIResponseEntityBean("SUCCESS", "Please check Log file For Success or not!", dtFormater.format(new Date()), retunResult); } catch (Exception e) { // TODO: handle exception responseEntityBean = new APIResponseEntityBean("ERROR", e.getMessage(),dtFormater.format(new Date()), retunResult); logger.error(e.getMessage()); //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. 

1. Purpose: The service layer acts as a mediator between the controller and the data layer (such as a repository or database). It focuses on business logic and operations. 
2. Responsibilities: Perform the core business logic of the application. Interact with the database (via repositories or DAOs). Provide methods for the controller to use (i.e., encapsulate business operations). Handle any necessary validation or transformation before sending data back to the controller. In a Spring Boot application, service classes are typically annotated with @Service, and they are injected into the controller using @Autowired (or constructor injection). 

Example "CustMastSystemNameService.java" of a Service Class in Spring Boot: 

 Method Internal Working ->geta143mkCustMasterFOrSYS() ->pusha143mkCustToSystemNameSystem().

 
package a143mk.a143mkCustMaster.SYSServices; import java.io.Serializable; import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.Optional; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; import a143mk.a143mkCustMaster.Entity.a143mkCustAddressMaster; import a143mk.a143mkCustMaster.Entity.a143mkCustMaster; import a143mk.a143mkCustMaster.Repository.a143mkCustAddressMasterRepository; import a143mk.a143mkCustMaster.Repository.a143mkCustMasterRepository; import a143mk.a143mkCustMaster.SYSConfig.SSLStopGetToken; import org.springframework.http.*; import org.springframework.web.client.RestTemplate; @SuppressWarnings("serial") @Service public class CustMastSystemNameService implements Serializable { private static final Logger logger = LoggerFactory.getLogger(CustMastSystemNameService.class); @Autowired private a143mkCustMasterRepository customerMastRepositM1Table; @Autowired private a143mkCustAddressMasterRepository custAdderssMastRepoM2Table; public List<Map<String, Object>> geta143mkCustMasterFOrSYS() { List<Map<String, Object>> pusha143mkCustSystemNameList = new ArrayList<>(); try { logger.info("Start a143mkCust_push"); List<a143mkCustMaster> getMasterV = customerMastRepositM1Table.mdmCustDetailsSystemName(); if (getMasterV != null) { for (a143mkCustMaster getCust : getMasterV) { // Use a Map instead of JSONObject Map<String, Object> customerMap = new HashMap<>(); customerMap.put("name", getCust.geta143mkCustName()); customerMap.put("type", "Business"); customerMap.put("sub_type", "a143mkCust"); customerMap.put("phone", Optional.ofNullable(getCust.getPhoneNo()).map(String::trim).filter(p->p.length()>10).orElse("no")); customerMap.put("email", Optional.ofNullable(getCust.getEmailId()).orElse("no")); customerMap.put("code", Optional.ofNullable(getCust.getWhDepotStoreNo()).map(String::trim).filter(p->p.length()>5).orElse("no")); customerMap.put("user_id", "AA143Mkbolgs"); //Pass the client_id value or pass the value according to your client. pusha143mkCustSystemNameList.add(customerMap); // Address logic List<a143mkCustAddressMaster> cutoAddressSystemName = custAdderssMastRepoM2Table.geta143mkCustAddressTableList(getCust.getLegacyCustNo()); List<Map<String, Object>> pushAddressList = new ArrayList<>(); if (cutoAddressSystemName != null) { for (a143mkCustAddressMaster custAdde : cutoAddressSystemName) { Map<String, Object> address = new HashMap<>(); address.put("address_1", custAdde.getAddress1()); address.put("address_2", Optional.ofNullable(custAdde.getAddress2()).orElse("")); address.put("address_3", Optional.ofNullable(custAdde.getAddress3()).orElse("")); address.put("city", Optional.ofNullable(custAdde.getCityName()).orElse("no")); address.put("state", Optional.ofNullable(custAdde.getStateCode()).orElse("")); address.put("pincode", Optional.ofNullable(custAdde.getPincode()).orElse("") ); address.put("state_code", custAdde.getStateCode()); pushAddressList.add(address); } } // Add the address list to the customer map customerMap.put("address_details", pushAddressList); } ResponseEntity<String> returnto=pusha143mkCustToSystemNameSystem(pusha143mkCustSystemNameList); if(returnto!=null) { logger.info("Success:" +returnto); }else { logger.error("Error to Push customer to SystemName", returnto); } } } catch (Exception e) { logger.error("Error in geta143mkCustMasterFOrSYS", e); } return pusha143mkCustSystemNameList; } private ResponseEntity<String> pusha143mkCustToSystemNameSystem(List<Map<String, Object>> pusha143mkCustSystemNameList) { RestTemplate restTemplate = new RestTemplate(); try { // 1. Get token String getTokenTms = new SSLStopGetToken().GetToken(); if (getTokenTms == null) { throw new RuntimeException("Failed to get SystemName token"); } // 2. Set headers HttpHeaders headers = new HttpHeaders(); headers.set("Authorization", "Bearer " + getTokenTms); // 3. Build the request entity HttpEntity<List<Map<String, Object>>> request = new HttpEntity<>(pusha143mkCustSystemNameList, headers); // 4. This is the Client Master API URL through which client master data can be sent. This is a test URL; you can modify it according to your client's requirements. String url = "https://a143mk-uat.client.com/api/master/push_customer"; ResponseEntity<String> response = restTemplate.postForEntity(url, request, String.class); // 5. Get response body /* responseObject = response.getBody(); System.out.println("Response: " + responseObject); logger.info("statuse for in geta143mkCustMasterFOrSYS: ", responseObject);*/ return response; } catch (Exception e) { logger.error("Error pushing customer to SystemName", e); return null; } } }

Implementing JWT (JSON Web Token) in Java typically involves creating a secure authentication mechanism for your web applications. Below is a basic guide to implement JWT using Java, Spring MVC, and jjwt (a popular Java JWT library).

The lifecycle of a JSON Web Token (JWT) typically involves several stages, from creation to expiration and validation. JWTs are widely used for securely transmitting information between parties in the form of a signed and optionally encrypted token. Here’s an overview of the typical lifecycle: Token Creation
Authentication: When a user logs in, they typically provide credentials (e.g., username and password).
Server Validation: The server validates these credentials (e.g., checks the database for the user’s password).
JWT Creation: If the credentials are correct, the server generates a JWT. The token contains:
Header: Describes the signing algorithm (e.g., HS256, RS256) and token type (JWT).
Payload: Contains the claims. Claims are pieces of information (e.g., user ID, expiration time) that are encoded in the token.
Signature: The header and payload are signed with a secret key (HMAC) or a private key (RSA or ECDSA) to ensure integrity.

 
Download Jar file: jjwt-api-0.10.5.jar

To create a A143mk.JWTAPIConfig, we first need to define a package that will be handled in the configuration.
Create classes name in the A143mk.JWTAPIConfig package. 

1. JwtRequestFilter package a143mk.JWTAPIConfig; import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter; import org.springframework.web.filter.OncePerRequestFilter; import javax.servlet.Filter; import javax.servlet.FilterChain; import javax.servlet.FilterConfig; import javax.servlet.ServletException; import javax.servlet.ServletRequest; import javax.servlet.ServletResponse; import javax.servlet.annotation.WebFilter; import javax.servlet.http.HttpServletRequest; import java.io.IOException; @SuppressWarnings("unused") @WebFilter(urlPatterns = "/api/*") public class JwtRequestFilter extends OncePerRequestFilter { private JwtUtil jwtUtil = new JwtUtil(); @Override protected void doFilterInternal(HttpServletRequest request, javax.servlet.http.HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException { final String token = request.getHeader("Authorization"); if (token != null && token.startsWith("Bearer ")) { String username = jwtUtil.extractUsername(token.substring(7)); if (username != null && jwtUtil.validateToken(token, username)) { // Set user authentication here } } filterChain.doFilter(request, response); } }
2.JwtUtil package a143mk.JWTAPIConfig; import io.jsonwebtoken.Claims; import io.jsonwebtoken.Jwts; import io.jsonwebtoken.SignatureAlgorithm; import io.jsonwebtoken.security.Keys; import java.security.Key; import java.util.Date; public class JwtUtil { private String secretKey = "a143mkJWT3API"; // use a more secure key in production! // private Key secretKey = Keys.secretKeyFor(SignatureAlgorithm.HS256); // Generate token public String generateToken(String username) { return Jwts.builder() .setSubject(username) .setIssuedAt(new Date()) .setExpiration(new Date(System.currentTimeMillis() + 1000 * 60 * 60)) // Token expires in 1 hour .signWith(SignatureAlgorithm.HS256, secretKey) .compact(); } // Extract username from token public String extractUsername(String token) { return extractClaims(token).getSubject(); } // Extract claims (payload) private Claims extractClaims(String token) { return Jwts.parser() .setSigningKey(secretKey) .parseClaimsJws(token) .getBody(); } // Validate token public boolean validateToken(String token, String username) { return (username.equals(extractUsername(token)) && !isTokenExpired(token)); } // Check if token is expired private boolean isTokenExpired(String token) { return extractClaims(token).getExpiration().before(new Date()); } }
3. SecurityConfig package a143mk.JWTAPIConfig; import org.springframework.security.config.annotation.web.builders.HttpSecurity; import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter; import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter; import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity; @EnableWebSecurity public class SecurityConfig extends WebSecurityConfigurerAdapter { @Override protected void configure(HttpSecurity http) throws Exception { http.csrf().disable() // Disable CSRF .authorizeRequests() .antMatchers("/api/authenticate").permitAll() // Allow unauthenticated access to login endpoint .anyRequest().authenticated() // All other requests require authentication .and() .addFilterBefore(new JwtRequestFilter(), UsernamePasswordAuthenticationFilter.class); // Add JWT filter } }
4. AuthRequest/PayloderBeanClass package a143mk.JWTAPIConfig; public class AuthRequest { private String username; private String password; public String getUsername() { return username; } public void setUsername(String username) { this.username = username; } public String getPassword() { return password; } public void setPassword(String password) { this.password = password; } }
Create a Controller class create a simple controller name is AuthController an endpoint is accessed.
package a143mk.JWTAPIController; import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.Logger; import org.directwebremoting.export.Data; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.web.bind.annotation.PostMapping; import org.springframework.web.bind.annotation.RequestBody; import org.springframework.web.bind.annotation.RestController; import a143mk.JWTAPIConfig.AuthRequest; import a143mk.JWTAPIConfig.JwtUtil; import a143mk.service.InterTransferOutWardService; @RestController public class AuthController { private static final Logger logger = LogManager.getLogger(AuthController.class); private JwtUtil jwtUtil = new JwtUtil(); @Autowired InterTransferOutWardService interOutward; @PostMapping("/api/authenticate") public String createToken(@RequestBody AuthRequest authRequest) { String token=jwtUtil.generateToken(authRequest.getUsername()); logger.info("DATE_Time:"+new Data()+" Token Ganrate: "+token ); interOutward.tokenSave(token); return jwtUtil.generateToken(authRequest.getUsername()); } }
Steps to Test JWT Token in Postman:
Obtain the JWT Token: First, you need to obtain the JWT token from your authentication endpoint. Typically, this is done by making a POST request to your login endpoint with the correct user credentials (username, password, etc.). 

Result :