[Spring, React] 객체 중심인 JPA에 맞춰서 코드 수정하기.

 

 

초반에 DB 코드를 작성할 때,
테이블 중심으로 코드를 작성했다.
그러나 JPA는 객체 중심이기 때문에
코드를 수정해야할 필요성을 느꼈다.

 

 

 

 

1. 상황설명

• 초반 프로젝트는 관리자 영역에서 총 3개의 레포지토리를 가지고 있다.
• AdminRepository : 관리자 정보를 저장한다.
• PemissionRepository : 권한 정보를 저장한다. 지금 프로젝트에선 총 5가지 권한이 있다. 조회 | 추가 | 수정 | 삭제 | 검색을 가지고 있으며 각각 1번, 2번, 3번... 이런식으로 번호를 부여했다.
• AdminPermissionRepository : 어떤 관리자가 어떤 권한을 갖고 있는지 저장한다. 예를 들어 id가 1번인 관리자가 조회, 수정 권한을 가지고 있으면 '1-1', '1-3' 대충 이런식으로 정보가 저장된다.
• 처음 로직은 다음과 같다. 관리자 수정이 요청되면 내부에서 원래 있던 관리자 id를 찾아 연결된 권한을 모두 삭제한다. 그리고 다시 새롭게 요청 받은 권한을 추가 한다. => 여기서 문제가 발생했다. flush( )를 통해 강제로 삭제 요청을 해야만 수정이 이뤄진다는 것이다.
• flush( )는 원래 프레임워크가 알아서 해줘야한다. 내가 생각했던 로직은 삭제 요청이 일어나면 알아서 flush( )가 이뤄진 뒤 새로운 정보를 insert하는거였다. 그런데 지금 코드는 직접 flush( )를 작성해야만 수정이 완료된다. 이걸 보고 지금 코드는 JPA를 제대로 다루지 못하고 있다고 판단했다.

 

 

 

---

 

 

 

 

2. 수정 전 AdminService 코드 분석

• 권한 전부 삭제

adminPermissionRepository.deleteByAdminId(id);
adminPermissionRepository.flush();
savePermissions(id, request.getPermissions());

이 코드는 AdminPermissionRepository를 직접 주입받아서 사용하고 있다. 관리자의 권한을 전부 지우기 위해 repository까지 직접 사용하는 것이다. 게다가 기존 권한이랑 똑같은 수정 요청이 들어와도 이 코드는 기존 걸 치우고 다시 넣는다.  - 수정방향 → 이제 이 부분을 수정해야한다. 테이블 중심 방식이 아닌 객체 중심 방식으로 바꿔야한다. 그리고 권한을 모두 삭제하지 않고 Admin 엔티티 안의 adminPermission 컬렉션을 기준으로 직접 비교하여 처리해야한다.

 

 

• permissions가 null이 아닌 경우만

if (request.getPermissions() != null) {
    assignPermissions(admin, request.getPermissions());
}

List.of("CUSTOMER_READ", "CUSTOMER_READ", " ", null)

permissons가 null이 아닐 때만 권한을 추가했다. 두번째 코드처럼 들어오면 현재 코드는 null만 처리하기 때문에 문제가 발생한다. 사실 null만 처리한 이유는 이 프로젝트가 실제 운영될 서비스도 아닐 뿐더러, 권한은 체크박스로 표시하기 때문에 큰 문제가 발생하지 않을 것 같아서 그렇게 작성했다. 그러나 이런 부분도 이중보안처럼 꼼꼼하게 작성하는 게 좋을 것 같다는 생각이 들었다.  - 수정방향 →  새로운 메서드를 만들어야할 것 같다. null, 공백, 중복 권한 코드를 새로운 메서드에서 정리한 뒤 더 꼼꼼하게 로직을 작성해야할 것 같다.

 

 

 

 

---

 

 

 

 

3. 수정 후 AdminService 코드 분석

• 새로운 메서드 replacePermission 작성

["CUSTOMER_READ", "CUSTOMER_ADD"]

관리자가 가진 권한 목록을 화면에서 새로 넘어온 permissionCodes 목록과 똑같이 교체하는 코드다. 위와 같이 넘어오면 admin의 기존 권한 중 이 목록에 없는 것은 삭제하고, 없는 권한은 새로 추가한다.

 

// 1.
 Set<String> requestedCodes = permissionCodes == null
                // 2.
                ? Set.of() 
                // 3.
                : permissionCodes.stream()
                // 4.
                .filter(Objects::nonNull)
                // 5.
                .map(String::trim)
                // 6.
                .filter(code -> !code.isBlank())
                // 7.
                .collect(Collectors.toCollection(LinkedHashSet::new));

1. 요청으로 들어온 권한 코드들을 Set으로 정리한다. Set은 알아서 중복을 제거하는 특징이 있고 contains( )로 포함 여부를 빠르게 확인할 수 있다. 
2. permissionCodes가 null이면 빈 Set을 만든다. 그니까 요청 권한이 아무것도 없다고 처리하는 것이다.
3. permissionCodes가 null이 아니면 Stream으로 하나씩 처리한다.
4. null인 권한 코드는 제거한다. ["CUSTOMER_READ", null, "CUSTOMER_ADD"]으로 들어왔다면 여기서 null을 제거한다.
5. 각 권한의 앞뒤 공백을 제거한다. " CUSTOMER_READ " -> "CUSTOMER_READ"
6. 빈 문자열을 제거한다. ["CUSTOMER_READ","  ", "CUSTOMER_ADD"]으로 들어왔다면 여기서 "  "을 제거한다.
7. 최종적으로 LinkedHashSet으로 모은다. 그 이유는 중복 제거를 하면서 입력된 순서를 유지시키기 위함이다.

 

 

Q. Set이 contains( )로 포함 여부를 빠르게 확인할 수 있는 이유는?

A. 해시 테이블 알고리즘을 사용하기 때문이다. ArrayList는 특정 데이터를 찾기 위해 처음부터 끝까지 모두 확인한다. 만약 N개의 데이터가 있을 때, 최악의 경우 N번을 다 찾아봐야 하므로 O(N)이 걸리게 된다. HashSet은 주소를 계산해서 한 번에 찾아낸다. HashSet은 데이터를 저장할 때 내부적으로 해시 함수를 이용해 데이터가 저장될 인덱스를 미리 계산한다. 

예를 들어, ROLE_ADMIN 이라는 권한 코드가 들어오면 내부는 "ROLE_ADMIN".hashCode( )를 호출한다. 그리고 고유한 숫자(예: 12345)를 뽑아내 해시 코드를 생성한다. 이 숫자를 해시 테이블의 크기로 나누어 인덱스를 알아낸다. 그래서 저장할 때 5번이면, 5번에 데이터를 집어넣는다. 호출할 때도 마찬가지다. contains("ROLE_ADMIN")을 호출하면, 똑같이 계산해서 바로 5번으로 직행한 뒤, 거기에 데이터가 있는지 확인한다.

이런 계산으로 데이터가 엄청나게 많아도 방 번호를 계산하는 단 한 번의 과정만 거치므로 평균적으로 O(1)이 걸린다.

 

 

        if (requestedCodes.isEmpty()) {
            admin.getAdminPermissions().clear();
            return;
        }

정리된 요청 권한 코드가 하나도 없는 경우 admin이 가지고 있던 권한 목록을 전부 비운다. 이제 이 관리자는 아무 권한도 가지지 않게 되는 것이다. 더이상 처리할 권환이 없으니 return으로 메서드를 종료한다.

 

List<Permission> permissions = permissionRepository.findByCodeIn(List.copyOf(requestedCodes));

requestCodes에 있는 권한 코드들이 실제 permission 테이블에 존재하는지 조회한다. findByCodeIn이 DB에서 해당 code를 가진 Permission들을 찾아온다.

List.copyOf는 파라미터 타입을 맞추기 위해 사용됐다. CodeIn은 메서드 이름에서 알 수 있듯이 SQL의 IN절을 생성한다.(예시: WHERE code IN (?, ?, ...)) JPA에서 IN 쿼리 메서드를 정의할 때, 파라미터 타입을 List<String>으로 선언해 두는 경우가 많다. 하지만 현재 requestedCode의 타입은 Set<String>이다. 그래서 Set 타입을 List 타입으로 변환하기 위해 List.copyOf를 사용했다.

사실 new ArrayList<>(requestedCodes)로 써도된다. 그런데 List.copyOf를 사용한 이유는 수정 불가능한 List를 만들기 위함이다. 아니면 Collection<String>으로 바꿔도 된다.

 

Set<String> foundCodes = permissions.stream()
                // Permission 객체에서 code만 꺼낸다.
                // Permission(code="CUSTOMER_READ") -> "CUSTOMER_READ"
                .map(Permission::getCode)
                // 꺼낸 code 값들을 Set으로 모은다.
                .collect(Collectors.toSet());

DB에서 실제로 찾은 권한 코드를 Set으로 모으는 코드이다. 

 

   List<String> missingCodes = requestedCodes.stream()
                // requestCodes 중 foundCodes에 없는 code만 남긴다.
                .filter(code -> !foundCodes.contains(code))
                // 그 결과를 List로 반환한다.
                .toList();

요청으로 들어온 권한 코드 중에서 DB에서 찾지 못한 권한 코드들을 missingCodes에 담는다.

 

    if (!missingCodes.isEmpty()) {
            throw new IllegalArgumentException("존재하지 않는 권한 코드입니다: " + String.join(", ", missingCodes));
        }

DB에 존재하지 않는 권한 코드가 하나라도 있다면 잘못된 권한 코드가 요청되었으므로 예외를 발생시킨다.

 

admin.getAdminPermissions().removeIf(adminPermission -> {
            // 1.
            Permission permission = adminPermission.getPermission();
            // 2.
            return permission == null
                    // 3.
                    || permission.getCode() == null
                    // 4.
                    || !requestedCodes.contains(permission.getCode());
        });

현재 admin이 가지고 있는 권한 중에서 요청 권한 목록에 없는 권한을 제거한다. removeIf가 컬렉션 안의 요소를 하나씩 보면서, 조건이 true인 요소를 삭제한다. 아래 더 구체적으로 설명을 적어보겠다.

 

// 구조가 이렇게 있으면 removeIf가 AdminPermission을 하나씩 꺼내서 검사한다.
// removeIf는 직접 반복하면서 삭제까지 해주는 메서드이다.

Admin
 └── adminPermissions
      ├── AdminPermission(admin=admin, permission=CUSTOMER_READ)
      ├── AdminPermission(admin=admin, permission=CUSTOMER_ADD)
      └── AdminPermission(admin=admin, permission=CUSTOMER_DELETE)

 

// Permission permission = adminPermission.getPermission();
// AdminPermission은 admin과 permission을 연결하는 중간 객체인데
// 여기서 그 안에 들어있는 실제 권한 Permission을 꺼낸다.

AdminPermission
 ├── admin = adminA
 └── permission = CUSTOMER_READ
 
 // adminPermission.getPermission()을 하면 CUSTOMER_READ에 해당하는 Permission 객체가 나온다.

 

// 여기서 true가 나오면 삭제된다.

// 정상적인 데이터는 AdminPermission(admin=admin, permission=CUSTOMER_READ) 이런 형태인데
// AdminPermission(admin=admin, permission=null) 이런 데이터가 오면 삭제한다.
return permission == null
    
        // 정상적인 데이터는 Permission(code="CUSTOMER_READ") 이런 형태인데
        // Permission(code=null) 이런 상태면 삭제한다.
        || permission.getCode() == null
        
        // 실제로 권한이 교체되는 코드이다.
        // 현재 admin이 가진 권한 코드가, 새로 요청된 권한 목록에 없으면 삭제한다.
        // 기존 권한: CUSTOMER_READ, CUSTOMER_ADD, CUSTOMER_DELETE
        // 수정 요청: requestedCodes: CUSTOMER_READ, CUSTOMER_ADD
        // 하나씩 검사하면 CUSTOMER_READ, CUSTOMER_ADD는 ture가 되는데 !가 붙어서 False가 된다.
        // 그래서 삭제가 안되고 CUSTOMER_DELETE는 FAlSE로 !가 붙어 true가 되어 삭제된다.
        || !requestedCodes.contains(permission.getCode());

 

        Set<String> existingCodes = admin.getAdminPermissions().stream()
                // 1.
                .map(AdminPermission::getPermission)
                // 2.
                .filter(Objects::nonNull)
                // 3.
                .map(Permission::getCode)
                // 4.
                .filter(Objects::nonNull)
                // 5.
                .collect(Collectors.toSet());

removeIf 이후에도 admin에게 남아 있는 권한 코드들을 모은다. 나중에 중복 추가를 막기 위해 사용한다. 

1. AdminPermission에서 Permission 객체를 꺼낸다.
2. Permission이 null인 경우 제외한다.
3. Permission 객체에서 code만 꺼낸다.
4. code가 null인 경우를 제외한다.
5. 최종적으로 현재 admin이 이미 가지고 있는 권한 코드들을 Set으로 모은다.

 

       for (Permission permission : permissions) {
       
            // 1.
            if (existingCodes.contains(permission.getCode())) {
                continue;
            }

            // 2.
            AdminPermission adminPermission = new AdminPermission();
            // 3.
            adminPermission.setAdmin(admin);
            // 4.
            adminPermission.setPermission(permission);
            // 5.
            admin.getAdminPermissions().add(adminPermission);
        }
    }

removeIf로 기존 권한은 삭제했다. 이제 새로운 권한을 집어넣어야한다. DB에서 조회한 실제 Permission 목록을 하나씩 반복한다. 

1. 현재 admin이 이 권한을 가지고 있다면 새로 추가할 필요가 없으므로 다음 permission으로 넘어간다.
2. admin에게 없는 권한이라면 새 AdminPermission 객체를 만든다.
3. 새 AdminPermission에 현재 admin을 연결한다. 
4. 새 AdminPermission에 추가할 Pemission을 연결한다. 
5. admin의 권한 목록에 새 AdminPemission을 추가한다. 

처음 코드는 수정 자체가 요청되면 관리자의 권한을 모두 삭제하고 다시 저장했다. 그런데 이제는 코드를 바꿔서 바뀐 권한을 확인하고 그 권한만 삭제하거나 추가하는 방식으로 코드를 변경했다. AdminPermissionRepository를 직접 사용했던 이전 코드와 달리 의존성이 확 줄어든 코드이다.