缓存应用：单例模式在缓存机制中的应用

 转载:http://blog.csdn.net/defonds/article/details/4765594#comments

单例模式：顾名思义，一个系统中中定义的某类只有一个实例。
    缓存应用：将要用到的资源提前从数据库或其他地方下载到内存，提高系统反应速度，增强用户体验满意度。
    本例子来自于一个真实的项目，作者巧妙地将单例模式应用于缓存机制中。阅读本文，对单例模式，缓存机制都可以有进一步的认识和把握。

    背景：
    JavaME 中绘制本地图片太频繁，同一图片不同地方绘制，每次都要下载图片，每次都要新建对象。

    解决方案：
    缓存应用：加载程序时，将所有有可能画的本地图片全部下载到缓存，需要绘制的时候直接从缓存中读取.由于缓存器被设置为登记式缓存，即使以后有新图片加入本地资源，也无须更改原有代码，直接在新增功能程序里调用缓存即可。

    具体实现：采用单例的设计模式来实现缓存应用。原因：缓存控制器整个系统中只需要一个即可。

    源代码：
    ImageBean.java（封装下载的图片的 Javabean）

[java]  view plain copy print ?

1. package com.xxx.bean;  
2. /** 
3.  * 文件名：ImageBean.java 
4.  * 
5.  * 版本信息： 
6.  * 日期：2009-10-21 
7.  * Copyright xxx Corporation 2009  
8.  * 版权所有 
9.  * 
10.  */  
11. /** 
12.  *  
13.  * 项目名称：Test 
14.  * 类名称：ImageBean 
15.  * 类描述：封装下载的图片的 Javabean. 
16.  * 创建人：Defonds 
17.  * 创建时间：2009-10-21 上午11:30:45 
18.  * 修改人：Defonds 
19.  * 修改时间：2009-10-21 上午11:30:45 
20.  * 修改备注： 
21.  * @version  
22.  *  
23.  */  
24. public class ImageBean  
25. {  
26.     //------------------------------------------------------  
27.     //fields.  
28.       
29.     /** 
30.      *  地图图片的横坐标. 
31.      */  
32.     private int abscissa;  
33.       
34.     /** 
35.      *  地图图片的纵坐标. 
36.      */  
37.     private int ordinate;  
38.       
39.     /** 
40.      *  要下载地图的 http url 链接地址. 
41.      */  
42.     private String url;  
43.       
44.     /** 
45.      *  下载的图片的字节流. 
46.      */  
47.     private byte[] byteOfImage;  
48.     //--------------------------------------------------------------------  
49.     //The getters and setters.  
50.       
51.     public int getAbscissa()  
52.     {  
53.         return abscissa;  
54.     }  
55.     public void setAbscissa(int abscissa)  
56.     {  
57.         this.abscissa = abscissa;  
58.     }  
59.     public int getOrdinate()  
60.     {  
61.         return ordinate;  
62.     }  
63.     public void setOrdinate(int ordinate)  
64.     {  
65.         this.ordinate = ordinate;  
66.     }  
67.     public String getUrl()  
68.     {  
69.         return url;  
70.     }  
71.     public void setUrl(String url)  
72.     {  
73.         this.url = url;  
74.     }  
75.     public byte[] getByteOfImage()  
76.     {  
77.         return byteOfImage;  
78.     }  
79.     public void setByteOfImage(byte[] byteOfImage)  
80.     {  
81.         this.byteOfImage = byteOfImage;  
82.     }  
83.       
84. }  

    ImageManager.java（单例类负责所有本地图片的管理工作 [缓存器的管理类]）

[java]  view plain copy print ?

1. /** 
2.  * 文件名：ImageManager.java 
3.  * 
4.  * 版本信息： 
5.  * 日期：2009-10-28 
6.  * Copyright xxx Corporation 2009  
7.  * 版权所有 
8.  * 
9.  */  
10. package com.xxx.util;  
11. import java.io.IOException;  
12. import java.util.Hashtable;  
13. import javax.microedition.lcdui.Image;  
14. /** 
15.  *  
16.  * 项目名称：Basic1.0 
17.  * 类名称：ImageManager 
18.  * 类描述：单例类负责所有本地图片的管理工作 [缓存器的管理类] 
19.  * 创建人：Defonds 
20.  * 创建时间：2009-10-28 上午11:32:43 
21.  * 修改人：Defonds 
22.  * 修改时间：2009-10-28 上午11:32:43 
23.  * 修改备注： 
24.  * @version  
25.  *  
26.  */  
27. public class ImageManager  
28. {  
29.     /** 
30.      * 缓存器.专门用来存放程序中用到的图片. 
31.      */  
32.     private static Hashtable imageCache = null;  
33.       
34.     /** 
35.      * 饿汉式单例模式,类加载器加载时就有了本类的一个实例,提高了系统效率. 
36.      */  
37.     private static ImageManager instance = new ImageManager();  
38.     /** 
39.      * 私有的构造子,防止被任意调用,保证本类在整个项目中只能有一个实例. 
40.      */  
41.     private ImageManager()  
42.     {  
43.         imageCache = new Hashtable();  
44.     }  
45.     /** 
46.      * 这里提供了一个供外部调用本 class 的静态方法,可以直接访问 
47.      */  
48.     public static ImageManager getInstance()  
49.     {  
50.         return instance;  
51.     }  
52.     /** 
53.      * 登记式缓存器的应用. 
54.      * 如果图片是第一次访问本方法,产生一个实例并返回.同时将此实例加载到缓存器之中 
55.      * 如果图片是第2,3,,,n次访问本方法,直接返回该图片实例,大大提高了系统运行效率 
56.      */  
57.     public Image getImage(String name)  
58.     {  
59.         Image image = null;  
60.         try  
61.         {  
62.             System.out.println("111111111111111");  
63.             if (null == imageCache.get(name))  
64.             {  
65.                 System.out.println("222222222222222");  
66.                 image = Image.createImage("/" + name + ".png");  
67.                 System.out.println("33333333333333333333");  
68.                 imageCache.put(name, image);  
69.             }else  
70.             {  
71.                 image = (Image)imageCache.get(name);  
72.             }  
73.         }catch (IOException ioe)  
74.         {  
75.             ioe.printStackTrace();  
76.         }  
77.           
78.         return image;  
79.     }  
80.       
81.     /** 
82.      * 批量将一个数组中所有的图片放入缓存器[一般是在 MIDlet 中对缓存器初始化时使用 
83.      */  
84.     public  void loadImagesCache(String[] names)  
85.     {  
86.         for (int i = 0; i < names.length; i++)  
87.         {  
88.             try  
89.             {  
90.                 if (names[i] != null)  
91.                 {  
92.                     imageCache.put(names[i], Image.createImage("/" + names[i] + ".png"));  
93.                 }  
94.             }catch (IOException ioe)  
95.             {  
96.                 ioe.printStackTrace();  
97.             }  
98.         }  
99.     }  
100. }  

    客户端使用缓存示例：

[java]  view plain copy print ?

1. ImageManager imageManager = ImageManager.getInstance();  
2. Image image = imageManager.getImage("logo");