수학과의 개발자 도전기

특정 단어를 입력하면 해당 단어를 포함하는 모든 공고를 리스트로 응답하는 API이다 

필드가 정해져있지 않아서 어떻게 해야하나 여러 시도를 해봤다 

repository에서 in 쿼리 사용해서 해당 단어를 가지고 있는 객체 리스트 반환(컴파일 에러 발생함)

각 필드마다 find하는 시그니처 만들어서 각자 진행하는 것(실패)

그러던 중 모든 recruitment를 찾은 다음 각 recruiment의 필드에서 해당 단어를 가지고 있으면 그걸 리스트에 추가한 후 

반환하는 로직을 생각했다 

- getSearchRecruitList()

위치 : /web/recruitment/RecruitmentController.class

@GetMapping("/search")
public ApiResponse<List<GetSearchRecruitResponse>> getSearchRecruitList(@RequestParam String search) {
    List<GetSearchRecruitResponse> response = recruitmentService.getSearchRecruitList(search);
    return ApiResponse.success(response);
}

- getSearchRecruitList()

Java에선 != 로 문자열을 비교하면 에러가 발생하므로, .equals()를 이용해야한다 

문제에선 원티드로 검색했을 때 원티드와 원티드코리아의 채용공고가 조회되었으므로, 해당 단어와 정확히 일치하는 것뿐만 아니라 

포함하는 것도 조회해야한다고 생각해서 .contains()를 이용했다 

코드가 아직 단순하고 문제가 많을 것 같지만 일단 지금까지의 최선이다 

하나의 채용공고에 서로 다른 필드가 중복되는 단어를 가지고 있는 경우 같은 공고가 여러개 반환되는 문제가 발생한다 

public List<GetSearchRecruitResponse> getSearchRecruitList(String search) {
    List<Recruitment> all = recruitmentRepository.findAll();

    List<GetSearchRecruitResponse> result = new ArrayList<>();
    for (Recruitment recruitment : all) {
        if (recruitment.getCompany().getCompanyName().contains(search) || recruitment.getCompany().getCountry().contains(search) || recruitment.getCompany().getRegion().contains(search)) {
            GetSearchRecruitResponse response = GetSearchRecruitResponse.of(recruitment);

            result.add(response);
        }

        if (recruitment.getPosition().contains(search) || recruitment.getTechInfo().contains(search)) {
            GetSearchRecruitResponse response = GetSearchRecruitResponse.of(recruitment);

            result.add(response);
        }
    }
    return result;
}

- GetSearchRecruitResponse

위치 : /web/recruitment/dto/response

@ToString
@Getter
@NoArgsConstructor(access = AccessLevel.PROTECTED)
public class GetSearchRecruitResponse {

    private Long recruitId;
    private String companyName;
    private String country;
    private String region;
    private String position;
    private Integer reward;
    private String techInfo;

    @Builder
    public GetSearchRecruitResponse(Long recruitId, String companyName, String country, String region, String position, Integer reward, String techInfo) {
        this.recruitId = recruitId;
        this.companyName = companyName;
        this.country = country;
        this.region = region;
        this.position = position;
        this.reward = reward;
        this.techInfo = techInfo;
    }

    public static GetSearchRecruitResponse of(Recruitment recruitment) {
        GetSearchRecruitResponse response = GetSearchRecruitResponse.builder()
                .recruitId(recruitment.getId())
                .companyName(recruitment.getCompany().getCompanyName())
                .country(recruitment.getCompany().getCountry())
                .region(recruitment.getCompany().getRegion())
                .position(recruitment.getPosition())
                .reward(recruitment.getReward())
                .techInfo(recruitment.getTechInfo())
                .build();

        return response;
    }
}

Postman

RequestParam 

key = search, value = naver

ResponseBody

naver를 포함한 모든 회사의 채용공고 리스트를 반환하는 것을 볼 수 있다 

{
    "data": [
        {
            "recruitId": 1,
            "companyName": "naverwebtoon",
            "country": "korea",
            "region": "seoul",
            "position": "Backend Developer 1",
            "reward": 125000000,
            "techInfo": "Java"
        },
        {
            "recruitId": 2,
            "companyName": "naverwebtoon",
            "country": "korea",
            "region": "seoul",
            "position": "Backend Developer 2",
            "reward": 125000000,
            "techInfo": "Java"
        },
        {
            "recruitId": 3,
            "companyName": "naverwebtoon",
            "country": "korea",
            "region": "seoul",
            "position": "Backend Developer 3",
            "reward": 125000000,
            "techInfo": "Python"
        },
        {
            "recruitId": 4,
            "companyName": "naver",
            "country": "korea",
            "region": "seoul",
            "position": "Backend Developer 1",
            "reward": 125000000,
            "techInfo": "Python"
        },
        {
            "recruitId": 5,
            "companyName": "naver",
            "country": "korea",
            "region": "seoul",
            "position": "Backend Developer 2",
            "reward": 125000000,
            "techInfo": "Java"
        }
    ]
}

채용 공고 리스트를 조회하는 API이다 

채용 공고 등록할 때는 회사 정보를 입력하지 않아서 회사 엔티티를 만들지 않았는데, 목록의 각 개체에 회사정보가 있길래 회사 관련 정보도 추가해서 진행했다 

-getRecruitList()

위치 : /web/recruitment/RecruitmentController.class

채용공고 목록만 확인하는 것이므로 따로 requestbody가 필요하지 않다고 생각했다 

@GetMapping("/list")
public ApiResponse<List<GetRecruitListResponse>> getRecruitList() {
    List<GetRecruitListResponse> responses = recruitmentService.getRecruitList();
    return ApiResponse.success(responses);
}

-getRecruitList()

위치 : /service/RecruitmentService.class

public List<GetRecruitListResponse> getRecruitList() {

    List<Recruitment> all = recruitmentRepository.findAll();

    List<GetRecruitListResponse> recruitList = new ArrayList<>();
    for (Recruitment recruitment : all) {
        Company recruitCompany = recruitment.getCompany();

        GetRecruitListResponse response = GetRecruitListResponse.of(recruitCompany, recruitment);

        recruitList.add(response);
    }

    return recruitList;
}

- GetRecruitListResponse

위치 : /web/recruitment/dto/response

@ToString
@Getter
@NoArgsConstructor(access = AccessLevel.PROTECTED)
public class GetRecruitListResponse {

    private Long recruitId;
    private String companyName;
    private String country;
    private String region;
    private String position;
    private Integer reward;
    private String techInfo;

    @Builder
    public GetRecruitListResponse(Long recruitId, String companyName, String country, String region, String position, Integer reward, String techInfo) {
        this.recruitId = recruitId;
        this.companyName = companyName;
        this.country = country;
        this.region = region;
        this.position = position;
        this.reward = reward;
        this.techInfo = techInfo;
    }

    public static GetRecruitListResponse of(Company company, Recruitment recruitment) {
        GetRecruitListResponse response = GetRecruitListResponse.builder()
                .recruitId(recruitment.getId())
                .companyName(company.getCompanyName())
                .country(company.getCountry())
                .region(company.getRegion())
                .position(recruitment.getPosition())
                .reward(recruitment.getReward())
                .techInfo(recruitment.getTechInfo())
                .build();

        return response;
    }

Postman

company 생성 (두 개의 회사)

{
    "companyName" : "wanted",
    "country" : "korea",
    "region" : "seoul"
}

{
    "data": null
}

company에서 recruitment 생성 

{
    "companyId" : 2,
    "position" : "backend junior developer",
    "reward" : 225000000,
    "contents" : "now wanted is hiring for,,,",
    "techInfo" : "Java"
}

{
    "data": {
        "id": 3,
        "position": "backend junior developer",
        "reward": 225000000,
        "contents": "now wanted is hiring for,,,",
        "techInfo": "Java"
    }
}

사용자가 recruitment list 조회 

{
    "data": [
        {
            "recruitId": 1,
            "companyName": "naver",
            "country": "korea",
            "region": "seoul",
            "position": "backend senior developer",
            "reward": 325000000,
            "techInfo": "Java"
        },
        {
            "recruitId": 2,
            "companyName": "naver",
            "country": "korea",
            "region": "seoul",
            "position": "backend jenior developer",
            "reward": 125000000,
            "techInfo": "Java"
        },
        {
            "recruitId": 3,
            "companyName": "wanted",
            "country": "korea",
            "region": "seoul",
            "position": "backend junior developer",
            "reward": 225000000,
            "techInfo": "Java"
        }
    ]
}

- deleteRecruit()

위치 : /web/recruitment/RecruitmentController.class

@DeleteMapping("/delete")
    public ApiResponse<String> deleteRecruit(@RequestBody DeleteRecruitRequest request) {
        String response = recruitmentService.deleteRecruit(request);
        return ApiResponse.success(response);
}

- deleteRecruit()

위치 : /service/recruitment/RecruitmentService.class

public String deleteRecruit(DeleteRecruitRequest request) {
        Optional<Recruitment> findRecruit = recruitmentRepository.findById(request.getId());
        String position = findRecruit.get().getPosition();

        recruitmentRepository.delete(findRecruit.get());

        return "해당 " + position + " 채용 공고가 삭제되었습니다.";
}

- DeleteRecruitRequest

위치 : /web/recruitment/dto/request

@Getter
public class DeleteRecruitRequest {
    private Long id;
}

Postman 

Delete http://localhost:8080/recruitment/delete

Request Body

{   
    "id" : 1
}

Response Body

{
    "data": "해당 Backend Junior Position 채용 공고가 삭제되었습니다."
}

- updateRecruit()

위치 : /web/recruitment/RecruitmentController.class

@PatchMapping("/update")
public ApiResponse<UpdateRecruitResponse> updateRecruit(@RequestBody UpdateRecruitRequest request) {
    UpdateRecruitResponse response = recruitmentService.updateRecruit(request);
    return ApiResponse.success(response);
}

- updateRecruit()

위치 : /service/RecruitmentService.class

user validation 이나 exception을 하지 않아서 그런지 코드가 약간 빈약해보인다 

public UpdateRecruitResponse updateRecruit(UpdateRecruitRequest request) {

    Optional<Recruitment> findRecruit = recruitmentRepository.findById(request.getId());

    findRecruit.get().setPosition(request.getPosition());
    findRecruit.get().setReward(request.getReward());
    findRecruit.get().setContents(request.getContents());
    findRecruit.get().setTechInfo(request.getTechInfo());

    Recruitment updated = recruitmentRepository.save(findRecruit.get());

    UpdateRecruitResponse response = UpdateRecruitResponse.of(updated);

    return response;
}

- UpdateRecruitRequest

위치 : /web/recruitment/dto/request

@ToString
@Getter
@NoArgsConstructor(access = AccessLevel.PROTECTED)
public class UpdateRecruitRequest {

    private Long id;
    private String position;
    private Integer reward;
    private String contents;
    private String techInfo;
}

- UpdateRecruitResponse

위치 : /web/recruitment/dto/response

@ToString
@Getter
@NoArgsConstructor(access = AccessLevel.PROTECTED)
public class UpdateRecruitResponse {

    private String position;
    private Integer reward;
    private String contents;
    private String techInfo;

    @Builder
    public UpdateRecruitResponse(String position, Integer reward, String contents, String techInfo) {
        this.position = position;
        this.reward = reward;
        this.contents = contents;
        this.techInfo = techInfo;
    }

    public static UpdateRecruitResponse of(Recruitment recruitment) {
        UpdateRecruitResponse response = UpdateRecruitResponse.builder()
                .position(recruitment.getPosition())
                .reward(recruitment.getReward())
                .contents(recruitment.getContents())
                .techInfo(recruitment.getTechInfo())
                .build();
        return response;
    }
}

- Postman 

PATCH http://localhost:8080/recruitment/update

Request Body

• application/json

{   
    "id" : 1,
    "position" : "Backend Junior Position",
    "reward" : 1300000, //1500000에서 수정
    "contents" : "wanted now hiring backend junior position",
    "techInfo" : "Python" 
}

Response Body

{
    "data": {
        "position": "Backend Junior Position",
        "reward": 1300000,
        "contents": "wanted now hiring backend junior position",
        "techInfo": "Python"
    }
}