냉장고 가계부 프로젝트 40

식품을 추가하면, 해당 식품이 어떤 종류인지 사람은 쉽게 유추할 수 있다.
예를들어, 우유, 치즈 같은 제품은 유제품으로 분류할 수 있고, 사과, 바나나, 딸기 같은 제품은 과일로 분류할 수 있다.
이렇게 같은 특성을 지닌 부류나 범위를 범주, 또는 카테고리 라고 한다.

사용자가 새로운 식품을 추가하면, 해당 식품이 어느 범주에 속하는지를 분류해서 입력값으로 넘겨준다면 좋겠지만, 너무 많은 입력을 요구하면 View가 복잡해지고 사용자 편의성이 떨어지게 된다.
따라서, 입력되는 식품명을 기반으로 해당 식품의 범주가 어디에 속하는지 분류해준다면 편리할 것이다.

식품명에 따른 범주화해주는 로직은 다음과 같다.

1. 사용자로부터 식품명을 입력받는다.
2. 사전에 분류해둔 키워드 데이터들과 입력받은 식품명의 유사도를 측정한다.
3. 측정된 유사도 결과값 중에서 가장 유사한 키워드의 범주를 반환한다.

예를들어, {사과, 바나나, 딸기} 는 "과일" 이라는 집단으로 분류하고, {우유, 치즈, 요거트} 는 "유제품" 이라는 집단으로 분류한다.
사용자가 입력한 식품명이 "맛있는 사과 5kg (23과내)" 라고 주어졌을 때, "사과" - "맛있는 사과 5kg (23과내)" 와 유사도를 측정하고, "바나나" - "맛있는 사과 5kg (23과내)" 와 유사도를 측정하고, "딸기" - "맛있는 사과 5kg (23과내)" 와 유사도를 측정한다.
같은 방식으로 유제품의 키워드들과도 유사도를 측정한다.
키워드 각각 주어진 식품명과 유사도를 측정해서 나온 결과 값이 가장 높은 키워드의 범주값을 반환한다.

키워드 데이터와 주어진 문자열 사이의 유사한 정도를 측정하기 위해서 자카드 유사도 라는 알고리즘을 사용한다.
자카드 유사도(자카드 지수)는 두 집합 사이의 유사도를 측정하는 방법이다.
자카드 유사도 알고리즘을 구현한 Apache Commons Text 라이브러리의 JaccardSimilarity 클래스를 조금만 수정해서 사용한다.

자동완성을 위해 생성한 fridge-search 프로젝트에 범주화 서비스도 함께 제공하도록 한다.
fridge-search 프로젝트에 자카드 유사도 클래스 파일을 생성한다.

public class JaccardSimilarity {
    
    public Double apply(String left, String right) {
        if (left == null || right == null) {
            throw new IllegalArgumentException("Input cannot be null");
        }
        left = StringUtils.lowerCase(left);
        right = StringUtils.lowerCase(right);
        return calculateJaccardSimilarity(left, right);
    }
    
    private Double calculateJaccardSimilarity(final CharSequence left, final CharSequence right) {
        final int leftLength = left.length();
        final int rightLength = right.length();
        if (leftLength == 0 || rightLength == 0) {
            return 0d;
        }
        final MultiSet<CharSequence> leftSet = new HashMultiSet<>();
        for (int i = 0; i < leftLength - 1; i++) {
            CharSequence word = left.subSequence(i, i+2);
            if(!isValidWord(word)) {
                continue;
            }
            leftSet.add(word);
        }
        final MultiSet<CharSequence> rightSet = new HashMultiSet<>();
        for (int i = 0; i < rightLength - 1; i++) {
            CharSequence word = right.subSequence(i, i+2);
            if(!isValidWord(word)) {
                continue;
            }
            rightSet.add(word);
        }
        if(leftSet.isEmpty() && rightSet.isEmpty()) {
            return 1.0d;
        }
        final MultiSet<CharSequence> unionSet = new HashMultiSet<>(leftSet);
        unionSet.addAll(rightSet);
        long intersection = unionSet.entrySet()
            .parallelStream().filter(entry -> {
                return entry.getCount() > 1;
            })
            .count();
        return 1.0d * intersection / unionSet.uniqueSet().size();
    }
    
    private boolean isValidWord(CharSequence word) {
        return Pattern.matches("^[a-zA-Z0-9ㄱ-ㅎ가-힣]*$", word);
    }
    
}

apply 메서드는 비교할 문자열 left, right를 파라미터로 입력받고, 유사도값을 Double 타입으로 리턴한다.
내부에서는 문자열 변수가 둘중 하나라도 null일 경우 IllegalArgumentException을 던진다.
입력된 문자열의 대소문자 구분을 하지 않기 위해 모두 소문자로 변환하고 calculateJaccardSimilarity 메서드에 넘긴다.

calculateJaccardSimilarity 메서드는 Apache Commons Collections 라이브러리의 다중집합 MultiSet을 사용해서 각 문자열을 두 글자씩 잘라서 집합에 넣는다.
두 글자씩 자른 후에 알파벳, 숫자, 한글을 제외한 나머지 글자가 있는경우 집합에 넣지 않는다.
isValidWord 메서드는 문자열에 알파벳, 숫자, 한글을 제외한 나머지 글자가 있는지 확인한다.

두 문자열 left, right가 각각 leftSet, rightSet 다중집합에 두 글자씩 분리되어 집합원소로 구성된다. 만약 두 다중집합이 모두 비었을 경우 유사도 1을 리턴한다.

합집합 unionSet에 leftSet, rightSet의 원소를 모두 집어넣고 교집합 갯수 / 합집합 갯수를 리턴한다.

JaccardSimilarity 클래스는 두 문자열을 비교하므로, 식품명과 사전 키워드들을 비교하는 기능을 제공하는 CategoryClassifier 클래스를 다음과 같이 작성한다.

@Component
public class CategoryClassifier {
    private List<Category> categories = Collections.synchronizedList(new ArrayList<>());
    private static final JaccardSimilarity jaccardSimilarity = new JaccardSimilarity();
    
    public void addAll(List<Category> categories) {
        this.categories.addAll(categories);
    }

    public List<Category> getCategories() {
        return Collections.unmodifiableList(categories);
    }

    public Category process(String query) {
        return categories.stream()
            .map(category -> {
                double score = category.getKeywords().parallelStream()
                        .map(keyword -> jaccardSimilarity.apply(keyword, query))
                        .max(Comparator.naturalOrder()).orElse(0.0);
                category.setScore(score);
                return category;
            }).collect(Collectors.maxBy(Comparator.comparing(Category::getScore)))
            .orElse(null);
    }

}

CategoryClassifier 클래스는 멤버변수로 categories, jaccardSimilarity를 가진다.
categories 변수는 빈 ArrayList를 Collections.synchronizedList 메서드로 감싼 List<Category> 형 변수이다. jaccardSimilarity는 위에서 생성한 자카드 유사도 클래스이다.

addAll 메서드는 파라미터로 전달받은 키워드 목록을 categories 멤버변수에 부어준다.

getCategories 메서드는 멤버변수 categories를 Collections.unmodifiableList 메서드로 감싸서, 불변 리스트로 변환해서 반환한다.

process 메서드는 query 문자열변수를 파라미터로 전달받고, Category 클래스 타입을 리턴한다.
query 변수는 사용자가 입력한 식품명 문자열이다. process 메서드는 categories 멤버변수의 Category 아이템 각각이 가지고있는 키워드 목록을 jaccardSimilarity를 이용해서 query문자열과 비교한다.
jaccardSimilarity 의 리턴결과인 유사도값들 중에서 가장 유사한 값을 가지는 Category 객체를 리턴한다.

Category 클래스는 다음과 같다.

@NoArgsConstructor
@Data
@Entity
public class Category {
    @Id 
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    private Long id;
    private String name;
    
    @JsonIgnore
    @ElementCollection(fetch=FetchType.EAGER)
    @Column(name="keyword")
    private Set<String> keywords = new HashSet<>();
    
    @JsonIgnore
    @Transient
    private double score;
    
    @Builder
    public Category(Long id, String name) {
        this.id = id;
        this.name = name;
    }
}

Category 클래스는 하이버네이트 엔티티 클래스로 primary key인 long id와 카테고리명을 의미하는 String name, 해당 카테고리의 키워드들인 Set<String> keywords, 유사도를 잠시 저장하는 double score 로 이뤄져있다.

테이블 스키마는 다음과 같다.

CREATE TABLE category (
    id BIGINT GENERATED BY DEFAULT AS IDENTITY(START WITH 1, INCREMENT BY 1) PRIMARY KEY,
    name VARCHAR(30) NOT NULL
);

CREATE TABLE category_keywords (
    category_id BIGINT NOT NULL,
    keyword VARCHAR(60) NOT NULL
);

ALTER TABLE category_keywords
ADD CONSTRAINT CATEGORY_ID_FK
FOREIGN KEY (category_id) REFERENCES category;

category 테이블은 id, name 두 컬럼으로 구성되며 primary key는 id 이다.
category_keywords 테이블은 Category 엔티티의 Set<String> keywords 와 대응되는 테이블이다.
category_id 컬럼은 category 테이블의 식별키 값이 저장되고, keyword 문자열은 keywords 집합의 원소값 각각이 저장된다.
category_id 컬럼은 외래키로 지정한다.

JPA Data Rest 서비스를 제공하기 위해 JpaRepository 인터페이스를 상속하는 CategoryRepository 인터페이스를 생성한다.

UI서버와 통신을 위해서 CategoryController 클래스를 다음과 같이 작성한다.

@RestController
@RequiredArgsConstructor
public class CategoryController {
    private final CategoryClassifier classifier;
    
    @GetMapping("/classifyCategories")
    public Category classifyCategories(String query) {
        return classifier.process(query);
    }
    
    @GetMapping("/categoryNames")
    public List<Category> categoryNames() {
        return classifier.getCategories();
    }

}

classifyCategories 메서드는 Get /classifyCategories URL을 매핑한다. 쿼리스트링으로 전달된 query문자열을 CategoryClassifier 클래스의 process 메서드에 파라미터로 전달하면, 유사도가 높은 Category 객체를 응답한다.

categoryNames 메서드는 View 페이지에서 사전 범주목록을 제공하기 위해서 작성한다.
Get 방식으로 /categoryNames URL로 매핑된다.
CategoryClassifier 클래스의 멤버변수인 categories 를 반환하는 getCategories 메서드를 호출해서 리턴한다.

fridge-service 프로젝트의 Food 엔티티에 Category 값을 저장하기 위해 categoryId 멤버변수를 추가한다.

@NoArgsConstructor
@Getter
@Setter
@ToString
@Entity
public class Food extends BaseEntity {
    @Id 
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    private Long id;
    private String name;
    private int quantity;
    private LocalDate expiryDate;
    
    @ManyToOne
    private Fridge fridge;
    private Long categoryId;
    
    @Builder
    public Food(Long id, String name, int quantity, LocalDate expiryDate, Fridge fridge) {
        this.id = id;
        this.name = name;
        this.quantity = quantity;
        this.expiryDate = expiryDate;
        this.fridge = fridge;
    }
    
    public Integer getFridgeId() {
        return fridge.getId();
    }
    public void setFridgeId(Integer fridgeId) {
        if(fridge == null) {
            fridge = new Fridge();
        }
        fridge.setId(fridgeId);
    }
    
}

Food 테이블 스키마도 수정한다.

CREATE TABLE food (
    id BIGINT GENERATED BY DEFAULT AS IDENTITY(START WITH 1, INCREMENT BY 1) PRIMARY KEY,
    fridge_id INTEGER,
    category_id BIGINT,
    name VARCHAR(64) NOT NULL,
    quantity INTEGER DEFAULT 0 NOT NULL,
    expiry_date DATE,
    created_date TIMESTAMP,
    last_modified_date TIMESTAMP
);

categoriy_id 컬럼은 BIGINT 타입으로 Category 엔티티의 식별키를 저장한다.

fridge-ui 프로젝트의 SearchClient 인터페이스에 다음과 같이 메서드를 추가한다.

@FeignClient(name="fridge-search")
public interface SearchClient {
    
    @GetMapping("/searchProductName")
    public String[] searchProductName(@RequestParam("query") String query);
    
    @PutMapping("/increaseScore")
    public void increaseScore(String query);
    
    @GetMapping("/classifyCategories")
    public Category classifyCategories(@RequestParam("query") String query);
    
    @GetMapping("/categories/{id}")
    public Category findCategoryById(@PathVariable("id") long id);
    
    @GetMapping("/categoryNames")
    public List<Category> categoryNames();

}

classifyCategories, categoryNames 메서드는 fridge-search 프로젝트의 CategoryController클래스의 메서드와 동일한 시그니쳐이며, findCategoryById 메서드는 JpaDataRest에서 제공한다.
식품을 등록할 때 Category 엔티티의 ID값을 category_id 변수에 저장하기 때문에, category 정보를 불러오기 위해서 findCategoryById 메서드를 추가한다.

FoodController 클래스에서 searchClient 호출부분은 다음과 같이 추가한다.

public class FoodController {
    ...
    
    @PostMapping("/add")
    public String processRegistrationFood(@ModelAttribute @Valid Food food, 
            Errors errors, 
            RedirectAttributes ra, 
            SessionStatus sessionStatus) {
        if(errors.hasErrors()) {
            return "foods/registerFoodForm";
        }
        
        if(food.getExpiryDate() == null) {
            food.setDefaultExpiryDate();
        }
        
        Category category = searchClient.classifyCategories(food.getName());
        if(category != null) {
            food.setCategoryId(category.getId());
        }
        
        if(client.createFood(food) != null) {
            searchClient.increaseScore(food.getName());
            ra.addFlashAttribute("message", "식품을 저장했습니다.");
            sessionStatus.setComplete();
        }
        return "redirect:/fridges/me";
    }
    
    @GetMapping("/{id}")
    public String updateFoodForm(@PathVariable("fridgeId") Integer fridgeId, 
            @PathVariable long id, Model model) {
        Food food = client.loadFoodById(id);
        food.setFridgeId(fridgeId);
        if(food.getCategoryId() != null) {
            food.setCategory(searchClient.findCategoryById(food.getCategoryId()));
        }
        model.addAttribute("food", food);
        model.addAttribute("categories", searchClient.categoryNames());
        return "foods/updateFoodForm";
    }
    
    ...

}

processRegistrationFood 메서드에서 client.createFood 메서드가 호출되기 전에 searchClient.classifyCategories 메서드를 호출해서 category의 id값을 food객체에 저장한다.

updateFoodForm 메서드는 식품 수정 폼페이지인데, 저장된 CategoryId 값을 이용해서 Category 정보를 얻기위해 searchClient.findCategoryById 메서드를 호출한뒤 food 커맨드클래스의 Category 멤버변수에 설정한다.
View 페이지에 카테고리 목록을 제공하기 위해서 searchClient.categoryNames 메서드를 호출해서 리턴되는 Category 컬렉션 데이터를 model에 추가한다.

updateFoodForm.html 파일에 카테고리 목록을 위한 <select> 엘리먼트를 추가한다.

<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml" 
    xmlns:th="http://www.thymeleaf.org" 
    xmlns:layout="http://www.ultraq.net.nz/thymeleaf/layout"
    layout:decorate="~{templates/default}">
<head>
  <title>Food</title>
</head>
<body>
   ...
    
            <div class="mb-3">
                <label for="categoryId">카테고리:</label>
                <select class="form-control" th:field="*{categoryId}">
                    <option th:each="category : ${categories}" 
                            th:value="${category.id}"
                            th:text="${category.name}">과일</option>
                </select>
            </div>
   ...
</body>
</html>

간단한 테스트를 통해서 카테고리 분류를 잘하는지 확인해본다.

식품명을 "횡성한우 양지 1등급 미절단(팩)100g" 이라고 입력한 뒤 저장한다.

수정 페이지로 이동하면 위와 같이 카테고리가 정육으로 저장됨을 확인할 수 있다.

카테고리 목록은 위와 같다.

카테고리를 잘 분류하기 위해서는 사전에 키워드 데이터를 많이 확보해둬야 한다.

이전글: 냉장고 가계부 프로젝트 39
다음글: 냉장고 가계부 프로젝트 41