development_developdoc의 캐시 사용 시나리오, 주의 사항, 장단점 분석

개발 중 캐시의 사용 시나리오, 주의사항, 장단점 분석

2024-07-12

1. 캐싱 개요

캐시는 애플리케이션이 매번 디스크나 다른 느린 저장 장치에서 데이터를 읽을 필요 없이 메모리에서 데이터를 빠르게 검색할 수 있도록 하는 데이터 저장 기술입니다. Java 개발에서 캐싱은 시스템 성능을 향상시키고 데이터베이스 액세스 횟수를 줄이며 리소스 활용도를 최적화하는 데 자주 사용됩니다.

2. 캐시 사용 시나리오

높은 데이터 반복성: 예를 들어 인기 제품 목록, 사용자의 최근 탐색 기록 등과 같이 자주 쿼리되는 데이터의 경우 캐싱을 통해 각 요청에 대해 데이터베이스로 이동하는 것을 방지하여 응답 속도를 향상시킬 수 있습니다.

예:

 // 假设有一个热门商品列表，需要频繁查询
List<Product> hotProducts = getHotProductsFromDatabase();

// 将热门商品列表缓存起来
Map<String, List<Product>> hotProductCache = new HashMap<>();
hotProductCache.put("hot_products", hotProducts);

// 当需要获取热门商品列表时，首先检查缓存是否已经存在
if (hotProductCache.containsKey("hot_products")) {
    hotProducts = hotProductCache.get("hot_products");
} else {
    // 如果缓存不存在，则从数据库获取并更新缓存
    hotProducts = getHotProductsFromDatabase();
    hotProductCache.put("hot_products", hotProducts);
}

// 使用缓存中的热门商品列表
for (Product product : hotProducts) {
    System.out.println(product.getName());
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

낮은 데이터 업데이트 빈도: 기본 사용자 정보, 구성 매개변수 등과 같이 자주 업데이트되지 않는 데이터의 경우 캐싱을 사용하여 데이터베이스에 대한 읽기 및 쓰기 부담을 줄일 수 있습니다.

예:

// 假设有一个用户基本信息，更新频率较低
User user = getUserFromDatabase(userId);

// 将用户基本信息缓存起来
Map<String, User> userCache = new HashMap<>();
userCache.put(userId, user);

// 当需要获取用户基本信息时，首先检查缓存是否已经存在
if (userCache.containsKey(userId)) {
    user = userCache.get(userId);
} else {
    // 如果缓存不存在，则从数据库获取并更新缓存
    user = getUserFromDatabase(userId);
    userCache.put(userId, user);
}

// 使用缓存中的用户基本信息
System.out.println(user.getName());
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

대용량 데이터: 페이징 쿼리, 집계 쿼리 등 대용량 데이터를 포함하는 쿼리 작업의 경우 캐싱을 사용하면 데이터베이스의 부하를 줄이고 쿼리 효율성을 높일 수 있습니다.

예:

// 假设有一个分页查询结果集，数据量较大
List<PageResult> pageResults = getLargeDataFromDatabase(pageNumber, pageSize);

// 将分页查询结果集缓存起来
Map<Integer, List<PageResult>> pageResultCache = new HashMap<>();
pageResultCache.put(pageNumber, pageResults);

// 当需要获取分页查询结果集时，首先检查缓存是否已经存在
if (pageResultCache.containsKey(pageNumber)) {
    pageResults = pageResultCache.get(pageNumber);
} else {
    // 如果缓存不存在，则从数据库获取并更新缓存
    pageResults = getLargeDataFromDatabase(pageNumber, pageSize);
    pageResultCache.put(pageNumber, pageResults);
}

// 使用缓存中的分页查询结果集
for (PageResult result : pageResults) {
    System.out.println(result.getContent());
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

3. 캐싱 주의사항

캐시 일관성 문제: 데이터가 업데이트될 때 캐시의 데이터가 데이터베이스와 동기화된 상태를 유지하도록 어떻게 보장합니까? 일반적인 접근 방식은 만료 시간 설정, 데이터베이스 변경 모니터링 등과 같은 캐시 무효화 전략을 사용하는 것입니다.

예:

// 假设有一个用户信息，需要实时更新
User user = getUserFromDatabase(userId);

// 将用户信息缓存起来，并设置过期时间
Map<String, User> userCache = new HashMap<>();
userCache.put(userId, user);
userCache.get(userId).setExpirationTime(System.currentTimeMillis() + EXPIRATION_TIME_IN_MILLIS);

// 当用户信息更新时，需要清除缓存
userCache.remove(userId);

// 当需要获取用户信息时，首先检查缓存是否已经存在
if (userCache.containsKey(userId)) {
   user = userCache.get(userId);
} else {
   // 如果缓存不存在，则从数据库获取并更新缓存
   user = getUserFromDatabase(userId);
   userCache.put(userId, user);
}

// 使用缓存中的用户信息
System.out.println(user.getName());
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

캐시 용량 제한: 캐시는 무한하지 않습니다. 캐시 오버플로로 인한 시스템 성능 저하를 방지하려면 실제 상황에 따라 캐시 용량을 합리적으로 계획해야 합니다.

예:

// 假设有一个缓存容器，需要根据实际情况合理规划缓存容量
Map<String, Object> cacheContainer = new HashMap<>();
int maxCacheSize = MAX_CACHE_SIZE;
while (cacheContainer.size() > maxCacheSize) {
   // 清除最久未被访问的缓存项
   cacheContainer.remove(cacheContainer.firstKey());
}

// 当需要添加新的缓存项时，先检查容量是否已满
if (cacheContainer.size() < maxCacheSize) {
   // 添加新的缓存项
   cacheContainer.put(key, value);
}
1
2
3
4
5
6
7
8
9
10
11
12
13

캐시 보안 문제: 캐시의 데이터에는 비밀번호, 주문 금액 등과 같은 민감한 정보가 포함될 수 있습니다. 데이터 보안을 보장하려면 해당 암호화 조치를 취해야 합니다.

예:

// 假设有一个密码，需要进行加密处理后再缓存
String password = "my_password";
byte[] encryptedPassword = encrypt(password);
Map<String, byte[]> passwordCache = new HashMap<>();
passwordCache.put(userId, encryptedPassword);

// 当需要获取密码时，首先检查缓存是否已经存在
if (passwordCache.containsKey(userId)) {
   byte[] decryptedPassword = decrypt(passwordCache.get(userId));
   String passwordFromCache = new String(decryptedPassword);
   System.out.println("Password from cache: " + passwordFromCache);
} else {
   // 如果缓存不存在，则从数据库获取并更新缓存
   String passwordFromDatabase = getUserPasswordFromDatabase(userId);
   byte[] encryptedPassword = encrypt(passwordFromDatabase);
   passwordCache.put(userId, encryptedPassword);
}

// 使用缓存中的密码
System.out.println("Password from database: " + passwordFromDatabase);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

4. 캐싱의 장점과 단점

이점:

시스템 성능 향상: 캐싱을 통해 데이터베이스에 대한 직접 액세스가 줄어들고 시스템 응답 속도가 향상됩니다.
데이터베이스 부하 감소: 캐싱은 특히 동시성이 높은 시나리오에서 데이터베이스에 대한 읽기 및 쓰기 압력을 효과적으로 줄일 수 있습니다.
단순화된 코드 논리: 캐싱을 통해 복잡한 쿼리 논리를 캐시 서비스로 캡슐화하여 클라이언트 코드 구현을 단순화할 수 있습니다.

결점:

데이터 일관성 문제: 캐시의 존재로 인해 데이터 불일치가 발생할 수 있으며, 이를 해결하려면 추가적인 설계 및 관리 메커니즘이 필요합니다.
캐시 업데이트 지연: 데이터가 업데이트되면 캐시에 있는 데이터가 업데이트되는 데 시간이 걸릴 수 있으며, 이로 인해 데이터 불일치가 발생할 수 있습니다.
캐시 관리는 복잡합니다. 캐시 용량 계획, 무효화 전략, 데이터 동기화 및 기타 문제를 해결하려면 개발자가 신중하게 고려하고 관리해야 합니다.

5. 요약:

Java 개발에 있어서 캐싱은 시스템의 성능과 안정성을 크게 향상시킬 수 있는 매우 중요한 기술입니다. 그러나 캐시를 올바르게 사용하려면 개발자에게 특정 경험과 기술이 필요합니다. 캐싱의 작동 원리와 적용 시나리오를 완전히 이해해야만 캐싱의 장점을 더 잘 활용하고 잠재적인 문제를 피할 수 있습니다.

기술나눔