[Spring] Server(Client) to Server연결

다른 Server와의 연결해보기!(2개의 Server 이용)

client역할의 server

client(spring Server긴함)

• client의 Controller

@RestController
@RequestMapping("/api/client")
public class CntApiController {

    private final RestTemplateService restTemplateService;

    public CntApiController(RestTemplateService restTemplateService) {
        this.restTemplateService = restTemplateService;
    }

    @GetMapping("/get")
    public UserResponse getHello(){
        return restTemplateService.get();
    }

    @PostMapping("/post")
    public UserResponse postHello(){
        return restTemplateService.post();
    }

    @PostMapping("/post/exchange")
    public UserResponse exchangeHello(){
        return restTemplateService.exchange();
    }

    @PostMapping("/post/generic-exchange")
    public Req<UserResponse> genericExchangeHello(){
        return restTemplateService.genericExchange();
    }
}

1. GET 방식

• client가 server에 요청한 url에 대한 response 처리 부분(echo임)

@Service
public class RestTemplateService {

    // http://localhost:9091/api/server/get
    // response 받아옴
    public UserResponse hello(){
        URI uri = UriComponentsBuilder
                .fromUriString("http://localhost:9091")
                .path("/api/server/get")
                .queryParam("name","aaaaaa")
                .queryParam("age",99999)
                .encode()
                .build()
                .toUri(); // request url을 만드는 부분
        System.out.println(uri.toString());

        RestTemplate restTemplate = new RestTemplate();
        // http GET 방식으로 String Object를 가져오겠다
//        String result = restTemplate.getForObject(uri, String.class);
        // http GET 방식으로 Entity(데이터)를 가져옴, entity에 담겨져 있는 것이 많음
        ResponseEntity<UserResponse> result = restTemplate.getForEntity(uri, UserResponse.class);

        System.out.println(result.getStatusCode());
        System.out.println(result.getBody());

        return result.getBody();
    }
}

2. POST 방식

• 아주 기본적인 POST 요청/응답 방식

public UserResponse post(){
        // http://localhost:9091/api/server/post/user/{userId}/name/{userName}
        URI uri = UriComponentsBuilder
                .fromUriString("http://localhost:9091")
                .path("/api/server/post/user/{userId}/name/{userName}")
                .encode()
                .build()
                .expand(100,"steve")
                .toUri(); // expand는 pathVar에 순서대로 매칭됨
        System.out.println(uri);

        // http body -> object -> object mapper -> json -> rest template -> http body json
        // 위 과정이 자동으로 이루어짐
        UserRequest req = new UserRequest();
        req.setName("steve");
        req.setAge(10);

        // response를 뭘로 받을 지 설정
        RestTemplate restTemplate = new RestTemplate();
        ResponseEntity<UserResponse> response = restTemplate.postForEntity(uri, req, UserResponse.class);

        System.out.println(response.getStatusCode());
        System.out.println(response.getHeaders());
        System.out.println(response.getBody());

        return response.getBody();
    }

2-1. POST-exchange 방식

• POST인데 Header,body 내용 편집(exchange)

public UserResponse exchange(){
        URI uri = UriComponentsBuilder
                .fromUriString("http://localhost:9091")
                .path("/api/server/post/user/{userId}/name/{userName}")
                .encode()
                .build()
                .expand(100,"steve")
                .toUri();
        System.out.println(uri);

        UserRequest req = new UserRequest();
        req.setName("steve");
        req.setAge(10);

        RequestEntity<UserRequest> requestEntity = RequestEntity
                .post(uri)
                .contentType(MediaType.APPLICATION_JSON)
                .header("x-authorization","abcd")
                .header("custom-header","ffffff")
                .body(req); // request header, body 직접 만들기

        RestTemplate restTemplate = new RestTemplate();
        ResponseEntity<UserResponse> response = restTemplate.exchange(requestEntity, UserResponse.class);
        return response.getBody();
    }

2-2. POST-exchange,generic(json의 내용이 고정적이지 않을 때)

• exchange 내용에 json의 내용이 고정적이지 않기 때문에 genericType사용

public Req<UserResponse> genericExchange(){ // json이 재사용될 때!!
        URI uri = UriComponentsBuilder
                .fromUriString("http://localhost:9091")
                .path("/api/server/post/user/{userId}/name/{userName}")
                .encode()
                .build()
                .expand(100,"steve")
                .toUri();
        System.out.println(uri);

        UserRequest userRequest = new UserRequest();
        userRequest.setName("steve");
        userRequest.setAge(10);

        Req<UserRequest> req = new Req<UserRequest>();
        req.setHeader(
                new Req.Header()
        );
        req.setResBody(
                userRequest
        );

        RequestEntity<Req<UserRequest>> requestEntity = RequestEntity
                .post(uri)
                .contentType(MediaType.APPLICATION_JSON)
                .header("x-authorization","abcd")
                .header("custom-header","ffffff")
                .body(req);

        RestTemplate restTemplate = new RestTemplate();

        ResponseEntity<Req<UserResponse>> response = restTemplate
                .exchange(requestEntity, new ParameterizedTypeReference<>(){});

        // response.getBody() -> ResponseEntity의 내용 추출
        // response.getBody().getrBody() -> ResponseEntity를 넘어서 Req<UserResponse> 내용 추출
       return response.getBody();
    }

Server(데이터를보내주는 서버)

post 요청 메서드는 client의 2-2방식에 대한 response코드만 작성되어있음

@Slf4j
@RestController
@RequestMapping("/api/server")
public class ServerApiController {

    @GetMapping("/get")
    public User hello(@RequestParam String name, @RequestParam int age){
        User user = new User();
        user.setName(name);
        user.setAge(age);
        return user;
    }

    @PostMapping("/post/user/{userId}/name/{userName}")
    public Req<User> post(
                     // HttpEntity<String> entity, // request 디버그 용도
                     @RequestBody Req<User> user,
                     @PathVariable int userId,
                     @PathVariable String userName,
                     @RequestHeader("x-authorization") String authorization,
                     @RequestHeader("custom-header") String customHeader
                     ){
        //log.info("req : {}", entity.getBody());
        log.info("userId : {}, userName : {}",userId,userName);
        log.info("authrization : {}, custom : {}",authorization,customHeader);
        log.info("client req : {}",user);

        Req<User> response = new Req<>();
        response.setHeader(
                new Req.Header()
        );
        response.setResBody(user.getResBody());

        return response;
    }
}

출처 : 한 번에 끝내는 Java/Spring 웹 개발 마스터 초격차 패키지 Online.