用Java缓存机制创建更快的Web应用----基本用法

  学习JCS的基本原理的一个好的方法是看它的API的最一般的用法。从缓存区自身的初始化开始是最好的地方。通过初始化JCS缓存区对象，你会获得访问缓存区所需要的几乎所有的共通方法。下面列出了初始化JCS对象并取得默认的缓存区实例的方法：

1. // Initialize the JCS object and get an instance of the default cache region
2. JCS cache = JCS.getInstance("default");
3. 
   

  取得 JCS 实例以后，就可以调用大多数需要的方法。 put 方法把一个新的对象放到缓存区中。键（第一个参数）和值（第二个参数）是调用这个方法所需要的全部内容。下面是一个基本的例子：

1. // Set up
2. String key = "key0";
3. String value = "value0";
5. // Place a new object in the cache
6. cache.put(key, value);

在上面的例子中使用字符串作为参数的值，但是你可以使用任何对象。

 

  使用 JCS 提供的 get 方法取得缓存中的对象也同样简单。下面是一个简单的例子，例子中也使用了一个字符串参数，但是你也是其他任意对象：

1. // Retrieve a cached object
2. String cachedData = (String)cache.get(key);

  在处理一个正在缓存的系统时，另一个可能需要的方法是验证缓存数据的有效性。对于测试缓存项目是否存在， JCS 中没有定义特定的方法，但是可以使用 get 方法的返回值来达到验证的目的。下面的例子演示获得这个必要的功能的方法：

1. // Retrieve a cached object
2. String cachedData = (String)cache.get(key);
4. // Check if the retrieval worked
5. if (cachedData != null) {
6.   // The cachedData is valid and can be used
7.   System.out.println("Valid cached Data: " + cachedData);
8. }

    最后需要的更多的共通的缓存功能是清楚 JCS 的缓存项目和工作完成后的缓存区。 JCS 提供了一个 clear 方法，调用这个方法可以从缓存区删除所有的缓存数据，同时还提供了一个 remove 方法，用于删除指定的缓存项目。 dispose 方法也是有效的，它用于释放被初始化的 JCS 缓存区。下面列出了这些方法的使用方法：    

1. // Dispose of a specific cached item
2. cache.remove(key);
3. // Dispose of all cache data
4. cache.clear();
5. // Dispose of the cache region
6. cache.dispose();

JCS和Java对象

    JCS优于其他缓存系统的特点之一就是它能和类对象一起很好的工作。大多数用Java技术创建的Web应用程序都使用面向对象的方法。如果经常的从数据库中反复获取相同的对象，那么缓存这些对象有助于应用程序获得更好的性能，例如：

    首先，在设计一个简单的面向对象的网站中，要围绕JCS以需要保存的对象作为开始。在这个例子中，开发了一个简单的博客站点，因此要保存blog对象自身，下面给出了将要使用的BlogObject类。

1. package com.ibm.developerWorks.objects;
3. import java.io.Serializable;
4. import java.util.Date;
6. public class BlogObject implements Serializable {
7.   private static final long serialVersionUID = 6392376146163510046L;
8.   private int blogId;
9.   private String author;
10.   private Date date;
11.   private String title;
12.   private String content;
14.   public BlogObject(int blogId, String author, Date date, String title, String content) {
15.     this.blogId = blogId;
16.     this.author = author;
17.     this.date = date;
18.     this.title = title;
19.     this.content = content;
20.   }
22.   public int getBlogId() {
23.     return this.blogId;
24.   }
26.   public String getAuthor() {
27.     return this.author;
28.   }
30.   public Date getDate() {
31.     return this.date;
32.   }
34.   public String getTitle() {
35.     return this.title;
36.   }
38.   public String getContent() {
39.     return this.content;
40.   }
41. }

  一旦有一个类对象实例，接下来就需要一个类来管理它，这个管理器来处理所有的管理事务和相对于blog对象的缓存功能。在这个例子中，管理器将处理三个主要的任务：

　・获取blog对象

　・把blog对象设定到缓存中

　・从缓存中删除blog对象

　在下面的代码中，getBolg()方法取得blog对象。这个方法首先试着从缓存中取得blog对象，如果在缓存中没有，它会用另外的机制来获得：

1. public BlogObject getBlog(int id) {
2.   BlogObject blog = null;
3. 
   
4.   try {
5.     blogCache = JCS.getInstance(blogCacheRegion);
6.     blog = (BlogObject)blogCache.get(id);
7.   } catch (CacheException ce) {
8.     blog = null;
9.   }
10. 
    
11.   if (blog == null) {
12.     blog = DatabaseManager.getBlog(id);
13.     this.setBlog(
14.       blog.getBlogId(),
15.       blog.getAuthor(),
16.       blog.getDate(),
17.       blog.getTitle(),
18.       blog.getContent()
19.     );
20.   }
21. 
    
22.   return blog;
23. }

  上面的代码中使用了一个数据库做为获取对象的一种可选机制，在从这种可选机制中获取对象时，应该把那个对象设定到缓存中，以便于下次能够从缓存中直接取得。

 

  下面的代码中的setBlog方法，会把blog对象放到缓存中。这个方法很简单，因为它只是用传递给他的信息创建一个新的blog对象，然后把它放到缓存中。

1. public boolean setBlog(int bId, String author, Date date, String title, String content) {
2.   BlogObject blog = new BlogObject(bId, author, date, title, content);
4.   try {
5.     blogCache = JCS.getInstance(blogCacheRegion);
6.     blogCache.put(bId, blog);
7.     return true;
8.   } catch (CacheException ce) {
9.     return false;
10.   }
11. }

  下面代码中cleanBlog方法，既可以清除指定的一个blog对象也可以清除缓存中的所有blog对象。这个方法使用JCS的remove和clear方法来清除缓存对象。

1. public boolean cleanBlog(int blogId) {
2.   try {
3.     blogCache = JCS.getInstance(blogCacheRegion);
4.     blogCache.remove(blogId);
5.   } catch (CacheException ce) {
6.     return false;
7.   }
8.   return true;
9. }
11. public boolean cleanBlog() {
12.   try {
13.     blogCache = JCS.getInstance(blogCacheRegion);
14.     blogCache.clear();
15.   } catch (CacheException ce) {
16.     return false;
17.   }
18.   return true;
19. }

  前面的类中演示了用JCS怎样简单的缓存对象以及管理对象，在Web应用程序中，这是一种强大的但却简单的处理对象的方法。

 

缓存元数据

   JCS提供了比我们前面介绍的基本内容要丰富的多的功能。例如，它提供了搜集缓存对象和缓存区的元数据的功能，可以很容易的取得一下内容：

　・缓存的键名；

　・缓存项目被创建的时间；

　・缓存的最大生存周期；

　・被缓存项目的生存周期

下面的代码显示了怎样获取缓存项目的元数据。

1. try {
2.   JCSAdminBean admin = new JCSAdminBean();
3.   LinkedList linkedList = admin.buildElementInfo(regionName);
4.   ListIterator iterator = linkedList.listIterator();
5. 
   
6.   while (iterator.hasNext()) {
7.     CacheElementInfo info = (CacheElementInfo)iterator.next();
8.     System.out.println("Key: " + info.getKey());
9.     System.out.println("Creation Time: " + info.getCreateTime());
10.     System.out.println("Maximum Life (seconds): " + info.getMaxLifeSeconds());
11.     System.out.println("Expires in (seconds): " + info.getExpiresInSeconds());
12.   }
13. } catch (Exception e) {
14. }

　对于被缓存项目的元数据是有用的，但是对于每个缓存区的元数据也是有益的。这些信息能够让你知道有多少缓存数据进入了缓存区，包括缓存失败还是成功，以及缓存的更新，下面的代码显示怎样搜集这些信息。

1. try {
2.   JCSAdminBean admin = new JCSAdminBean();
3.   LinkedList linkedList = admin.buildCacheInfo();
4.   ListIterator iterator = linkedList.listIterator();
6.   while (iterator.hasNext()) {
7.     CacheRegionInfo info = (CacheRegionInfo)iterator.next();
8.     CompositeCache compCache = info.getCache();
9.     System.out.println("Cache Name: " + compCache.getCacheName());
10.     System.out.println("Cache Type: " + compCache.getCacheType());
11.     System.out.println("Cache Misses (not found): " + compCache.getMissCountNotFound());
12.     System.out.println("Cache Misses (expired): " + compCache.getMissCountExpired());
13.     System.out.println("Cache Hits (memory): " + compCache.getHitCountRam());
14.     System.out.println("Cache Updates: " + compCache.getUpdateCount());
15.   }
16. } catch (Exception e) {
17. }

　搜集缓存区和缓存对象的元数据，来帮助分析Web站点的那个缓存区或缓存对象需要被优化。元数据还会帮助你管理时间敏感性的缓存数据，对于特定的需要更新数据的用户，可以使用最大的生命周期和每个缓存项目的终止时间来刷新缓存数据。

 

总结：

　对于Java开发者，JCS是一个强大的，然而却简单易用的缓存系统。它为桌面和Web应用程序提供了同样的数据缓存。桌面应用程序的增长----像Web应用要求增强速度和灵活性一样，通过使用缓存数据也有助于达到同样的效果。这篇文章概要介绍了怎样配置和使用JCS，同时包括了基本缓存方法所需要的语法，在一个普通的Web应用程序中使用的缓存对象，以及获取缓存元数据的方法。