[SpringBoot test] Sample API 및 Sample 객체 코드

Sample API 및 Sample 객체 코드

Sample API 및 Sample 객체 코드는 com.iparking.api.sample 패키지에 있으니 참조 하면 된다

SampleApiController

Sample Controller 코드를 참조 하여 Controller 코드를 작성하면 된다

HTTP METHOD	API	Request	Response	설명
GET	/call	없음	"ok"	단순 서버 ping pong 테스트
GET	/test	없음	CommonResult<List>	CommonResult 응답 테스트
GET	/err	없음	CommonResult<Map<String, Object>>	ExceptionHandler 테스트
GET	/sample	ReqGetSample sample	CommonResult	GET 요청 Object 파라메터 테스트
GET	/sample/{seq}	ReqGetSample sample , @PathVariable Integer seq	CommonResult	GET 요청 @PathVariable Object 파라메터 테스트
GET	/sample/hobby/{hobby}	ReqGetSample sample , @PathVariable Hooby hooby	CommonResult	GET 요청 특정 카테고리 @PathVariable Object 파라메터 테스트
POST	/sample/body-string	@RequestBody String body	CommonResult	@RequestBody String 파라메터 테스트
POST	/sample/body-object	@RequestBody ReqJsonSample sample	CommonResult	@RequestBody Object 파라메터 테스트
PATCH	/sample/pathvariable-object/{seq}	@PathVariable Integer seq , @RequestBody ReqJsonSample sample	CommonResult	@PathVariable Object 파라메터 테스트
DELETE	/sample/pathvariable-object/{seq}	@PathVariable Integer seq , @RequestBody ReqJsonSample sample	CommonResult	@PathVariable Object 파라메터 테스트

package com.iparking.api.sample.controller;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.google.common.collect.Lists;
import com.iparking.api.sample.constant.Hobby;
import com.iparking.api.sample.packet.ReqGetSample;
import com.iparking.api.sample.packet.ReqJsonSample;
import com.iparking.api.sample.packet.ResGetSample;
import com.iparking.api.sample.service.SampleApiService;
import com.iparking.common.domain.CommonResult;
import io.swagger.annotations.*;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.context.request.RequestAttributes;
import org.springframework.web.context.request.WebRequest;

import javax.validation.Valid;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import static com.iparking.common.constant.ResCode.SUCCESS;


/**
 * Sample API 코드
 */
@Slf4j
@RestController
@RequiredArgsConstructor
// @RequestMapping("/v1")
@Api(value = "Sample API 컨트롤러", tags = "Sample API")
// @ApiIgnore
public class SampleApiController {

    private final SampleApiService service;
    private final ObjectMapper objectMapper;

    /**
     * 서버 접속 테스트
     * @return
     */
    @ApiOperation("서버 접속 테스트")
    @GetMapping("/call")
    public String call(){
        log.info("~~~~~~~~~~~~~~~");
        Map<String , Object> result = new HashMap<>();
//        result.put("list",service.test() );
        return "ok";
    }

    /**
     * 서버 접속 테스트
     * @return
     */
    @ApiOperation("서버 접속 테스트")
    @GetMapping("/test")
    public CommonResult<List<Integer>> test(){
        log.info("~~~~~~~~~~~~~~~");
        return new CommonResult<>(SUCCESS, SUCCESS.getMessage(), Lists.newArrayList(1,2,3));
    }

    /**
     * 에러 테스트
     * @return
     * @throws Exception
     */
    @ApiOperation("에러 테스트")
    @GetMapping(value = "/err")
    public CommonResult<Map<String, Object>> error() throws Exception {
        log.info("~~~~~~~~~~~~~~~");
        Map<String , Object> result = new HashMap<>();

        if(true) throw new Exception("ERROR TEST");

        return new CommonResult<>(SUCCESS, SUCCESS.getMessage(), result);
    }

    /**
     * GET 요청 Object 파라메터 테스트
     * @param sample
     * @return
     */
    @ApiOperation("GET 요청 Object 파라메터 테스트")
    @GetMapping(value = "/sample")
    public CommonResult<ResGetSample> sampleGet(@ApiParam("ReqGetSample 요청 객체")
                                                @Valid ReqGetSample sample) {
        log.info("sample = {}",sample);
        return new CommonResult<>(SUCCESS, SUCCESS.name(), new ResGetSample(sample));
    }

    /**
     * GET 요청 Object 파라메터 테스트
     * @param sample
     * @return
     */
    @ApiOperation("GET 요청 PathVariable Object 파라메터 테스트")
    @GetMapping(value = "/sample/{seq}")
    public CommonResult<ResGetSample> sampleGetPathVariable(@ApiParam("seq 값")
                                                @PathVariable("seq") Integer seq,
                                                            @ApiParam("ReqGetSample 요청 객체")
                                                @Valid ReqGetSample sample){
        sample.setSeq(seq);
        log.info("sample = {}",sample);
        return new CommonResult<>(SUCCESS, SUCCESS.name(), new ResGetSample(sample));
    }

    /**
     * GET 요청 PathVariable Object 파라메터 테스트
     * @param hobby
     * @param sample
     * @return
     */
    @ApiOperation("GET 요청 특정 카테고리 PathVariable Object 파라메터 테스트")
    @GetMapping(value = "/sample/hobby/{hobby}")
    public CommonResult<ResGetSample> sampleGetCategoryPathVariable (@ApiParam("hobby 취미 PathVriable 값")
                                                                     @PathVariable("hobby") Hobby hobby,
                                                                     @ApiParam("ReqGetSample 요청 객체")
                                                                     @Valid ReqGetSample sample){
        sample.setHobby(hobby);
        log.info("sample = {}",sample);
        return new CommonResult<>(SUCCESS, SUCCESS.name(), new ResGetSample(sample));
    }

    /**
     * RequestBody String 파라메터 테스트
     * @param body
     * @return
     */
    @ApiOperation("@RequestBody String 파라메터 테스트")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "Sample", value = "sample\n\n " +
                    "{\"my_address\": \\{\"city\": \"영등포구\", \"country\": \"한국\", \"state\": \"서울\", \"zip_code\": \"07276\"}, \"my_id\":\"abcd\",\"my_name\":\"홍길동\",\"my_age\":10,\"my_email\":\"abc@company.com\",\"my_job\":\"developer\"}",
                    required = true, dataTypeClass = ReqJsonSample.class, paramType = "body")
    })
    @PostMapping("/sample/body-string")
    public CommonResult<ReqJsonSample> bodyString(@ApiParam("ReqJsonSample String 요청 객체")
                                                  @Valid @RequestBody String body,
                                                  WebRequest webRequest) throws Exception {
        //ExceptionHandler로 RequestBody 값을 전달해주기 위한 셋팅
        webRequest.setAttribute("body", body, RequestAttributes.SCOPE_REQUEST);
        log.info("body = {}",body);
        ReqJsonSample sample = objectMapper.readValue(body, ReqJsonSample.class);
        log.info("sample = {}",sample);
        return new CommonResult<>(SUCCESS, SUCCESS.name(), sample);
    }

    /**
     * RequestBody Object 테스트
     * @param sample
     * @return
     */
    @ApiOperation("@RequestBody Object 파라메터 테스트")
    @PostMapping("/sample/body-object")
    public CommonResult<ReqJsonSample> bodyObject(@ApiParam("ReqJsonSample 요청 객체")
                                                  @Valid @RequestBody ReqJsonSample sample,
                                                  WebRequest webRequest) throws Exception {
        //ExceptionHandler로 RequestBody 값을 전달해주기 위한 셋팅
        webRequest.setAttribute("body", sample, RequestAttributes.SCOPE_REQUEST);
        log.info("sample = {}",sample);
        return new CommonResult<>(SUCCESS, SUCCESS.name(), sample);
    }

    @ApiOperation("PATCH - @PathVariable Object 파라메터 테스트")
    @PatchMapping("/sample/pathvariable-object/{seq}")
    public CommonResult<ReqJsonSample> patchBodyObjectPathvariable(@ApiParam("ReqJsonSample 요청 객체")
                                                         @PathVariable("seq") Integer seq,
                                                                   @ApiParam("ReqJsonSample 요청 객체")
                                                         @Valid @RequestBody ReqJsonSample sample,
                                                                   WebRequest webRequest) throws Exception {
        sample.setSeq(seq);
        //ExceptionHandler로 RequestBody 값을 전달해주기 위한 셋팅
        webRequest.setAttribute("body", sample, RequestAttributes.SCOPE_REQUEST);
        log.info("sample = {}",sample);
        return new CommonResult<>(SUCCESS, SUCCESS.name(), sample);
    }

    @ApiOperation("DELETE - @PathVariable Object 파라메터 테스트")
    @DeleteMapping("/sample/pathvariable-object/{seq}")
    public CommonResult<ReqJsonSample> deleteObjectPathVariable(@ApiParam("ReqJsonSample 요청 객체")
                                                    @PathVariable("seq") Integer seq,
                                                                @ApiParam("ReqJsonSample 요청 객체")
                                                    @Valid ReqJsonSample sample) throws Exception {
        sample.setSeq(seq);
        log.info("sample = {}",sample);
        return new CommonResult<>(SUCCESS, SUCCESS.name(), sample);
    }
}

domain 객체

DB 컬럼과 일치한 객체만을 유지하는 것이 도메인 객체 이다
DB 컬럼 이외에 컬럼을 추가하려면 별도의 dto 객체를 추가하여야 한다
dto 객체나 packet

객체는 아래와 같이 최대한 상세히 객체에 대해 알 수 있도록 작성 하는 것이 좋다
타 개발자가 봤을때 명확히 알 수 있고 Swagger API Docs 에서 테스트가 수월하기 때문이다

packet 객체에서 사용 하기 위한 도메인 객체나 model 객체는 아래와 같이 @ApiModel, @ApiModelProperty 설정을 해주어야 한다
packet 객체에서 사용하지 않는다면 @ApiModel, @ApiModelProperty 설정을 하지 말아야 한다

@ApiModelProperty 의 옵션

아래의 옵션을 부가적으로 설정 해주면 훨씬 더 명확하게 model에 대한 Docs가 표현되고
테스트 값으로 임의로 활용할 수 있다

• value - 파라메터 이름
• name - Swagger에서 입력 받을 리얼 파라메터 명
• notes - 부가설명
• example - 지정된 임의 테스트 값을 입력 함
• required - 필수 입력 여부

GetSample

GetSample 도메인 객체 snake case로 GET 요청이 들어온 데이터를
객체에 camel case 로 변환해서 받을 수 있는 @ParamName 설정이 추가 되어 있다

package com.iparking.api.sample.domain;

import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.annotation.JsonInclude.Include;
import com.iparking.api.sample.model.Address;
import com.iparking.api.sample.packet.ReqGetSample;
import com.iparking.common.annotation.ParamName;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.*;

import javax.validation.constraints.Email;
import javax.validation.constraints.Min;
import javax.validation.constraints.NotNull;

/**
 * Created by KMS on 14/11/2019.
 * 샘플 객체
 */
@Getter
@Setter
@NoArgsConstructor
@AllArgsConstructor
@EqualsAndHashCode
@ToString
@ApiModel("샘플 GET RequestParam 객체 도메인") // 모델명
@JsonInclude(Include.ALWAYS)
public class GetSample {
    @ApiModelProperty(value = "순번", notes = "순번 데이터", example = "1")
    protected Integer seq;
    @NotNull(message = "아이디는 필수 입력갑 입니다")
    /*
        @ApiModelProperty 사용법
        value - 파라메터 이름
        name - Swagger에서 입력 받을 리얼 파라메터 명
        notes - 부가설명
        example - 지정된 임의 테스트 값을 입력 함
        required - 필수 입력 여부

     */
    @ApiModelProperty(value = "아이디",name = "my_id", notes = "이곳에 아이디를 넣어주세요", example = "abcd", required = true)
    @ParamName("my_id") // my_id 로 들어온 파라메터를 myId에 맵핑 시켜준다
    protected String myId;

    @NotNull(message = "이름은 필수 입력값 입니다")
    @ApiModelProperty(value = "이름",name = "my_name", notes = "이곳에 이름을 넣어주세요", example = "홍길동", required = true)
    @ParamName("my_name")
    protected String myName;

    @Min(value = 10, message = "나이는 최소 10살이상 입니다")
    @ApiModelProperty(value = "나이\n최소 10살이상",name = "my_age", notes = "나이는 최소 10살이상 입니다", example = "10")
    @ParamName("my_age")
    protected Integer myAge;

    @Email(message = "이메일 형식에 맞게 입력하세요")
    @ApiModelProperty(value = "이메일\n이메일 형식에 맞게 입력",name = "my_email", notes = "이메일 형식에 맞게 입력해주세요",example = "abc@company.com")
    @ParamName("my_email")
    protected String myEmail;

    @NotNull(message = "직업은 필수 입력값 입니다")
    @ApiModelProperty(value = "직업",name = "my_job", notes = "직업을 입력하세요", example = "developer", required = true)
    @ParamName("my_job")
    protected String myJob;

    //내부 객체는 @ParamName이 먹히지 않는다 방법을 연구해봐야 한다
    //그냥 myAddress.city 이런 형식으로만 받을 수 있다
    @ParamName("my_address")
    protected Address myAddress;

    public GetSample(ReqGetSample reqGetSample) {
        this.seq = reqGetSample.getSeq();
        this.myId = reqGetSample.getMyId();
        this.myName = reqGetSample.getMyName();
        this.myAge = reqGetSample.getMyAge();
        this.myEmail = reqGetSample.getMyEmail();
        this.myJob = reqGetSample.getMyJob();
        this.myAddress = reqGetSample.getMyAddress();
    }
}

JsonSample

JsonSample 도메인 객체 snake case로 @RequestBody 요청이 들어온 데이터를
객체에 camel case 로 변환해서 받을 수 있는 @JsonProperty 설정이 추가 되어 있다

package com.iparking.api.sample.domain;

import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.annotation.JsonInclude.Include;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.iparking.api.sample.model.Address;
import com.iparking.api.sample.packet.ReqJsonSample;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.*;

import javax.validation.constraints.Email;
import javax.validation.constraints.Min;
import javax.validation.constraints.NotNull;

/**
 * Created by KMS on 14/11/2019.
 * 샘플 객체
 */
@Getter
@Setter
@NoArgsConstructor
@AllArgsConstructor
@EqualsAndHashCode
@ToString
@ApiModel("샘플 POST RequestBody 객체 도메인") // 모델명
@JsonInclude(Include.ALWAYS)
public class JsonSample {
    @ApiModelProperty(value = "순번", notes = "순번 데이터", example = "1")
    protected Integer seq;
    @NotNull
    /*
        @ApiModelProperty 사용법
        value - 파라메터 이름
        name - Swagger에서 입력 받을 리얼 파라메터 명
        notes - 부가설명
        example - 지정된 임의 테스트 값을 입력 함
        required - 필수 입력 여부

     */
    @ApiModelProperty(value = "아이디",name = "my_id", notes = "이곳에 아이디를 넣어주세요", example = "abcd", required = true)
    @JsonProperty("my_id")
    protected String myId;

    @NotNull
    @ApiModelProperty(value = "이름",name = "my_name", notes = "이곳에 이름을 넣어주세요", example = "홍길동", required = true)
    @JsonProperty("my_name")
    protected String myName;

    @Min(10)
    @ApiModelProperty(value = "나이\n최소 10살이상",name = "my_age", notes = "나이는 최소 10살이상 입니다", example = "10")
    @JsonProperty("my_age")
    protected Integer myAge;

    @Email
    @ApiModelProperty(value = "이메일\n이메일 형식에 맞게 입력",name = "my_email", notes = "이메일 형식에 맞게 입력해주세요",example = "abc@company.com")
    @JsonProperty("my_email")
    protected String myEmail;

    @NotNull
    @ApiModelProperty(value = "직업",name = "my_job", notes = "직업을 입력하세요", example = "developer", required = true)
    @JsonProperty("my_job")
    protected String myJob;

    @ApiModelProperty(value = "주소",name = "my_address", notes = "county, state, city, zipCode")
    @JsonProperty("my_address")
    protected Address myAddress;

    public JsonSample(ReqJsonSample reqJsonSample) {
        this.seq = reqJsonSample.getSeq();
        this.myId = reqJsonSample.getMyId();
        this.myName = reqJsonSample.getMyName();
        this.myAge = reqJsonSample.getMyAge();
        this.myEmail = reqJsonSample.getMyEmail();
        this.myJob = reqJsonSample.myJob;
        this.myAddress = reqJsonSample.myAddress;
    }
}

Sample

일반적인 Sample 도메인 객체
packet 객체로 Swagger Api Docs 에 노출될 일이 없다면
@ApiModel 은 주석처리 하면 해당 도메인 객체는 Swagger Api Docs 에 노출되지 않는다

package com.iparking.api.sample.domain;

import com.iparking.api.sample.model.Address;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.*;

/**
 * Created by KMS on 14/11/2019.
 * 샘플 도메인 객체
 * DB 컬럼과 일치하는 도메인 객체를 생성
 */
@Getter
@Setter
@NoArgsConstructor
@AllArgsConstructor
@EqualsAndHashCode
@ToString
@ApiModel("샘플 Domain 객체") // 모델명
public class Sample {
    /*
        @ApiModelProperty 사용법
        value - 파라메터 이름
        name - Swagger에서 입력 받을 리얼 파라메터 명
        notes - 부가설명
        example - 지정된 임의 테스트 값을 입력 함
        required - 필수 입력 여부

     */
    @ApiModelProperty(value = "아이디", notes = "이곳에 아이디를 넣어주세요", example = "abcd", required = true)
    private String myId;

    @ApiModelProperty(value = "이름", notes = "이곳에 이름을 넣어주세요", example = "홍길동", required = true)
    private String myName;

    @ApiModelProperty(value = "나이\n최소 10살이상", notes = "나이는 최소 10살이상 입니다", example = "10")
    private Integer myAge;

    @ApiModelProperty(value = "이메일\n이메일 형식에 맞게 입력", notes = "이메일 형식에 맞게 입력",example = "abc@company.com")
    private String myEmail;

    @ApiModelProperty(value = "직업", notes = "농부, 광부, 개발자", example = "developer", required = true)
    private String myJob;

    @ApiModelProperty(value = "주소", notes = "county, state, city, zipCode")
    private Address address;
}

model 객체

domain, packet, dto 객체들에서 공통적으로 사용하는 객체는 model 객체로 생성 한다
model 객체는 주로 다른 객체에서 변수 타입으로 사용한다

package com.iparking.api.sample.model;

import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.annotation.JsonInclude.Include;
import com.fasterxml.jackson.annotation.JsonProperty;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.*;

import javax.validation.constraints.NotEmpty;

/**
 * Created by KMS on 25/11/2019.
 * 도메인에 공통 적으로 사용되는 객체는 모델에 정의
 */
@Getter
@Setter
@NoArgsConstructor
@ToString
@ApiModel("샘플 모델 객체") // 모델명
@JsonInclude(Include.ALWAYS)
public class Address {

    @NotEmpty
    @ApiModelProperty(value = "국가", notes = "국가 입력", example = "한국")
    //@JsonProperty("country")
    private String country;

    @NotEmpty
    @ApiModelProperty(value = "시도", notes = "시도 입력", example = "서울")
    //@JsonProperty("state")
    private String state;

    @NotEmpty
    @ApiModelProperty(value = "면읍구군시", notes = "면읍구군시 입력", example = "영등포구")
    //@JsonProperty("city")
    private String city;

    @NotEmpty
    @ApiModelProperty(value = "우편번호", name = "zip_code", notes = "우편번호 입력", example = "07276")
    @JsonProperty("zip_code")
    private String zipCode;

    @Builder
    public Address(final String country, final String state, final String city, final String zipCode) {
        this.country = country;
        this.state = state;
        this.city = city;
        this.zipCode = zipCode;
    }

    /*
    public String getFullAddress() {
        return String.format("%s %s %s", this.state, this.city, this.zipCode);
    }
    */
}

packet

packet 객체는 Api Docs 에 공개되는 파마메터와 return 타입으로 사용한다
@ApiModel, @ApiModelProperty 를 상세히 작성하여 Api Docs 에 잘 표현될 수 있도록 한다

packet 객체들은 각각 자신의 타입에 맞는 domain 객체를 상속 받았으며 @Builder 패턴을 생성 하였다
@Builder 패턴은 상속 받는 객체를 포함해서 하나만 존재 해야 하므로 상속 받는 부모의 객체에는 @Builder 패턴을 지정하지 않는 것이 좋다

ReqGetSample

GET 타입( GET, DELETE )의 API 에 사용되는 요청 packet 객체 이다
GetSample domain 객체를 상속 받았다

package com.iparking.api.sample.packet;

import com.iparking.api.sample.constant.Hobby;
import com.iparking.api.sample.domain.GetSample;
import com.iparking.api.sample.model.Address;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.*;

import javax.validation.constraints.Email;
import javax.validation.constraints.Min;
import javax.validation.constraints.NotNull;

/**
 * Created by KMS on 14/11/2019.
 * 샘플 객체
 */
@Getter
@Setter
@NoArgsConstructor
@ToString
@ApiModel("샘플 GET 요청 RequestParam 객체") // 모델명
public class ReqGetSample extends GetSample {

    @ApiModelProperty("취미")
    private Hobby hobby;

    @Builder
    public ReqGetSample(Integer seq, @NotNull(message = "아이디는 필수 입력갑 입니다") String myId, @NotNull(message = "이름은 필수 입력값 입니다") String myName, @Min(value = 10, message = "나이는 최소 10살이상 입니다") Integer myAge, @Email(message = "이메일 형식에 맞게 입력하세요") String myEmail, @NotNull(message = "직업은 필수 입력값 입니다") String myJob, Address myAddress, Hobby hobby) {
        super(seq, myId, myName, myAge, myEmail, myJob, myAddress);
        this.hobby = hobby;
    }
}

ReqJsonSample

@RequestBody 타입( POST, PUT, PATCH )의 API 에 사용되는 요청 packet 객체 이다
JsonSample domain 객체를 상속 받았다

package com.iparking.api.sample.packet;

import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.annotation.JsonInclude.Include;
import com.iparking.api.sample.constant.Hobby;
import com.iparking.api.sample.domain.JsonSample;
import com.iparking.api.sample.model.Address;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.*;

import javax.validation.constraints.Email;
import javax.validation.constraints.Min;
import javax.validation.constraints.NotNull;

/**
 * Created by KMS on 14/11/2019.
 * 샘플 객체
 */
@Getter
@Setter
@NoArgsConstructor
@ToString
@ApiModel("샘플 POST 요청 RequestBody 객체") // 모델명
@JsonInclude(Include.ALWAYS)
public class ReqJsonSample extends JsonSample {

    @ApiModelProperty("취미")
    private Hobby hobby;

    @Builder
    public ReqJsonSample(Integer seq, @NotNull String myId, @NotNull String myName, @Min(10) Integer myAge, @Email String myEmail, @NotNull String myJob, Address myAddress, Hobby hobby) {
        super(seq, myId, myName, myAge, myEmail, myJob, myAddress);
        this.hobby = hobby;
    }
}

ResGetSample

GET 타입의 API 에 사용되는 응답 packet 객체 이다
GetSample domain 객체를 상속 받았다

package com.iparking.api.sample.packet;

import com.iparking.api.sample.constant.Hobby;
import com.iparking.api.sample.domain.GetSample;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import lombok.ToString;

/**
 * Created by KMS on 12/03/2020.
 */
@Getter
@Setter
@NoArgsConstructor
@ToString
// @ApiModel("샘플 Get 응답 객체") // 모델명
public class ResGetSample extends GetSample {

    @ApiModelProperty("취미")
    private Hobby hobby;

    public ResGetSample(ReqGetSample reqGetSample) {
        super(reqGetSample);
        this.hobby = reqGetSample.getHobby();
    }
}

ResJsonSample

@RequestBody 타입의 API 에 사용되는 packet 객체 이다
JsonSample domain 객체를 상속 받았다

package com.iparking.api.sample.packet;

import com.iparking.api.sample.constant.Hobby;
import com.iparking.api.sample.domain.JsonSample;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import lombok.ToString;

/**
 * Created by KMS on 12/03/2020.
 */
@Getter
@Setter
@NoArgsConstructor
@ToString
// @ApiModel("샘플 Json 응답 객체") // 모델명
public class ResJsonSample extends JsonSample {

    @ApiModelProperty("취미")
    private Hobby hobby;

    public ResJsonSample(ReqJsonSample reqJsonSample) {
        super(reqJsonSample);
        this.hobby = reqJsonSample.getHobby();
    }
}