memcache-client-for java下载安装及使用

迈不过友情╰ 2022-06-10 09:54 173阅读 0赞

# memcache-client-for java下载安装及使用  #

2015-05-08 16:58  710人阅读 评论(0) 收藏 举报

![category_icon.jpg][] 分类：

memcash*（1）* ![arrow_triangle_20_down.jpg][] ![arrow_triangle_up.jpg][]

[作者同类文章][Link 1] *X*

目录(?)\[+\]

1.  下载
    
    1.  memcache win7 64位 安装文件
2.  安装
    
    1.  解压放某个盘下面比如
    2.  在cmd命令界面下输入以下命令将memcached安装成为windows服务
    3.  再输入下面命令启动
    4.  控制台命令
3.  简介
4.  Cache Client单客户端配置
    
    1.  创建memcached的标签
    2.  创建 client的标签
    3.  创建socketpool的标签
    4.  创建 servers 标签作为socketPool的子标签设置memcache服务端实例地址支持多个地址设置例如1022243633001 或 1022243633001 1022244633002
    5.  写一个java类

# 下载 #

### [![rar文件][rar]memcache win7 64位 安装文件][rar_rar_memcache win7 64_] ###

或

a. 下载最新版：[http://blog.couchbase.com/memcached-windows-64-bit-pre-release-available][http_blog.couchbase.com_memcached-windows-64-bit-pre-release-available]  
b. 直接下载： [ memcached-win64-1.4.4-14.zip][memcached-win64-1.4.4-14.zip]

# 安装 #

## 1. 解压放某个盘下面，比如: ##

D:\\WampServer\\bin\\memcached\\memcached.exe

## 2. 在cmd命令界面下输入以下命令，将memcached安装成为windows服务 ##

D:\\WampServer\\bin\\memcached>memcached.exe -d install

## 3. 再输入下面命令启动： ##

D:\\WampServer\\bin\\memcached>memcached.exe -d start

或者

memcached  -m 128 -l 127.0.0.1 -p 11211 （128M内存，默认64；地址127.0.0.1；端口：默认11211）  
这里参数有很多，这里就不介绍了，有兴趣的可以自己去查一下。

## 控制台命令： ##

命令提示符下运行

安装：

memcached -d install

memcached -d start

net start "Memcached Server"

卸载：

memcached -d stop

memcached -d remove

sc delete "Memcached Server"

memcached的基本设置：

\-p 监听的端口

\-l 连接的IP地址, 默认是本机

\-d start 启动memcached服务

\-d restart 重起memcached服务

\-d stop|shutdown 关闭正在运行的memcached服务

\-d install 安装memcached服务

\-d uninstall 卸载memcached服务

\-u 以的身份运行 (仅在以root运行的时候有效)

\-m 最大内存使用，单位MB。默认64MB

\-M 内存耗尽时返回错误，而不是删除项

\-c 最大同时连接数，默认是1024

\-f 块大小增长因子，默认是1.25

\-n 最小分配空间，key+value+flags默认是48

\-h 显示帮助

# 简介    #

项目地址 ([memcache-client-for java][]) https://code.google.com/p/memcache-client-forjava/

下载对应的jar文件 alisoft-xplatform-asf-cache-2.5.1.jar

这个jar文件依赖于一些开源的库文件（参考大神写的 Memcached\_Client\_HandBook.docx ，里面详细列举了需要的依赖包）

commons-logging-1.0.4.jar or high version  
log4j-1.2.12.jar or high version  
codehaus/woodstox/wstx-asl-3.2.1.jar or high version  
codehaus/staxapi/stax-api-1.0.1.jar or high version  
2.5.2版本以后还需要caucho/hessian/hessian-3.2.0.jar or high version

# Cache Client单客户端配置 #

memcached.xml，存放目录 /src目录下

**\[html\]**  view plain  copy

print ?

1.  <?xml version="1.0" encoding="UTF-8"?>  
2.    
3.  <memcached>  
4.        
5.      <client name="mclient0" compressEnable="true" defaultEncoding="UTF-8" socketpool="pool0">  
6.          <errorHandler>com.alisoft.xplatform.asf.cache.memcached.MemcachedErrorHandler</errorHandler>  
7.      </client>  
8.        
9.      <socketpool name="pool0" failover="true" initConn="5" minConn="5" maxConn="250" maintSleep="0"  
10.         nagle="false" socketTO="3000" aliveCheck="true">  
11.         <servers>127.0.0.1:33001</servers>  
12.     </socketpool>   
13.       
14.     <cluster name="cluster1">  
15.         <memCachedClients>mclient0</memCachedClients>  
16.     </cluster>  
17.                   
18. </memcached>

## 1.创建memcached的标签。 ##

## 2.创建 client的标签。 ##

注意：

name 属性是程序中使用Cache的唯一标识。

socketpool 属性将会关联到后面的socketpool配置。

errorHandler 可选，用来处理出错情况。注意在Tag中不要使用空格或者Tab键。

## 3.创建socketpool的标签。 ##

注意：

name 属性和client 配置中的socketpool 属性相关联。

maintSleep属性是后台线程管理SocketIO池的检查间隔时间，如果设置为0，则表明不需要后台线程维护SocketIO线程池，默认需要管理。

socketTO 属性是Socket操作超时配置，单位ms。

aliveCheck 属性表示在使用Socket以前是否先检查Socket状态。

## 4.创建 servers 标签作为socketPool的子标签.设置memcache服务端实例地址，支持多个地址设置，例如“10.2.224.36:33001” 或 “10.2.224.36:33001, 10.2.224.46:33002”. ##

## 5.创建 weights 标签作为socketPool的子标签(可选),它表明了上面设置的服务器实例的Load权重. 例如 <weights>3,7</weights> 表示30% load 在 10.2.224.36:33001, 70% load 在 10.2.224.46:33001 ##

好了，基础的配置就如上。

或者，也可以配置多个client,如下：

**\[html\]**  view plain  copy

print ?

1.  <?xml version="1.0" encoding="UTF-8"?>    
2.  <memcached>    
3.      <client name="mclient0" compressEnable="true" defaultEncoding="UTF-8" socketpool="pool0">    
4.          <errorHandler>com.alisoft.xplatform.asf.cache.memcached.MemcachedErrorHandler</errorHandler>                
5.      </client>    
6.      <client name="mclient1" compressEnable="true" defaultEncoding="UTF-8" socketpool="pool1">    
7.          <errorHandler>com.alisoft.xplatform.asf.cache.memcached.MemcachedErrorHandler</errorHandler>                
8.      </client>    
9.      <client name="mclient2" compressEnable="true" defaultEncoding="UTF-8" socketpool="pool2">    
10.         <errorHandler>com.alisoft.xplatform.asf.cache.memcached.MemcachedErrorHandler</errorHandler>                
11.     </client>    
12.     <socketpool name="pool0" failover="true" initConn="5" minConn="5" maxConn="250" maintSleep="5000" nagle="false" socketTO="3000" aliveCheck="true">    
13.         <servers>127.0.0.1:11211</servers>    
14.         <weights>1</weights>    
15.     </socketpool>     
16.     <socketpool name="pool1" failover="true" initConn="5" minConn="5" maxConn="250" maintSleep="5000" nagle="false" socketTO="3000" aliveCheck="true">    
17.         <servers>127.0.0.1:11311</servers>    
18.         <weights>1</weights>    
19.     </socketpool>    
20.     <socketpool name="pool2" failover="true" initConn="5" minConn="5" maxConn="250" maintSleep="5000" nagle="false" socketTO="3000" aliveCheck="true">    
21.         <servers>127.0.0.1:11411</servers>    
22.         <weights>1</weights>    
23.     </socketpool>    
24. </memcached>

<?xml version="1.0" encoding="UTF-8"?>  
    <memcached>  
    	<client name="mclient0" compressEnable="true" defaultEncoding="UTF-8" socketpool="pool0">  
    		<errorHandler>com.alisoft.xplatform.asf.cache.memcached.MemcachedErrorHandler</errorHandler>              
    	</client>  
    	<client name="mclient1" compressEnable="true" defaultEncoding="UTF-8" socketpool="pool1">  
    		<errorHandler>com.alisoft.xplatform.asf.cache.memcached.MemcachedErrorHandler</errorHandler>              
    	</client>  
    	<client name="mclient2" compressEnable="true" defaultEncoding="UTF-8" socketpool="pool2">  
    		<errorHandler>com.alisoft.xplatform.asf.cache.memcached.MemcachedErrorHandler</errorHandler>              
    	</client>  
    	<socketpool name="pool0" failover="true" initConn="5" minConn="5" maxConn="250" maintSleep="5000" nagle="false" socketTO="3000" aliveCheck="true">  
    		<servers>127.0.0.1:11211</servers>  
    		<weights>1</weights>  
    	</socketpool>   
    	<socketpool name="pool1" failover="true" initConn="5" minConn="5" maxConn="250" maintSleep="5000" nagle="false" socketTO="3000" aliveCheck="true">  
    		<servers>127.0.0.1:11311</servers>  
    		<weights>1</weights>  
    	</socketpool>  
    	<socketpool name="pool2" failover="true" initConn="5" minConn="5" maxConn="250" maintSleep="5000" nagle="false" socketTO="3000" aliveCheck="true">  
    		<servers>127.0.0.1:11411</servers>  
    		<weights>1</weights>  
    	</socketpool>  
    </memcached>

使用前，必须按照配置文件来启动memcached！例如：

memcached -d -m 128 -l 127.0.0.1 -p 11211

## 写一个java类： ##

**\[html\]**  view plain  copy

print ?

1.  /\*\*  
2.   \*  
3.   \*/  
4.  package com.icss.biz.util;  
5.    
6.  import java.util.Date;  
7.    
8.  import com.alisoft.xplatform.asf.cache.memcached.client.MemCachedClient;  
9.  import com.alisoft.xplatform.asf.cache.memcached.client.SockIOPool;  
10.   
11. /\*\*  
12.  \*    
13.  \*  @author xxl  
14.  \*  
15.  \*/  
16. public class MemCachedManager  
17. \{  
18.   
19.  // 创建全局的唯一实例  
20.     protected static MemCachedClient mcc = new MemCachedClient();  
21.        
22.     protected static MemCachedManager memCached = new MemCachedManager();  
23.        
24.     // 设置与缓存服务器的连接池  
25.     static \{  
26.         // 服务器列表和其权重  
27.         String\[\] servers = \{ "127.0.0.1:33001" \};  
28.         Integer\[\] weights = \{ 3 \};  
29.   
30.         // 获取socke连接池的实例对象  
31.         SockIOPool pool = SockIOPool.getInstance();  
32.   
33.         // 设置服务器信息  
34.         pool.setServers( servers );  
35.         pool.setWeights( weights );  
36.   
37.         // 设置初始连接数、最小和最大连接数以及最大处理时间  
38.         pool.setInitConn( 5 );  
39.         pool.setMinConn( 5 );  
40.         pool.setMaxConn( 250 );  
41.         pool.setMaxIdle( 1000 \* 60 \* 60 \* 6 );  
42.   
43.         // 设置主线程的睡眠时间  
44.         pool.setMaintSleep( 30 );  
45.   
46.         // 设置TCP的参数，连接超时等  
47.         pool.setNagle( false );  
48.         pool.setSocketTO( 3000 );  
49.         pool.setSocketConnectTO( 0 );  
50.   
51.         // 初始化连接池  
52.         pool.initialize();  
53.   
54.         // 压缩设置，超过指定大小（单位为K）的数据都会被压缩  
55.         mcc.setCompressEnable( true );  
56.         mcc.setCompressThreshold( 64 \* 1024 );  
57.     \}  
58.        
59.     /\*\*  
60.      \* 保护型构造方法，不允许实例化！  
61.      \*  
62.      \*/  
63.     protected MemCachedManager()  
64.     \{  
65.            
66.     \}  
67.        
68.     /\*\*  
69.      \* 获取唯一实例.  
70.      \* @return  
71.      \*/  
72.     public static MemCachedManager getInstance()  
73.     \{  
74.         return memCached;  
75.     \}  
76.        
77.     /\*\*  
78.      \* 添加一个指定的值到缓存中.  
79.      \* @param key  
80.      \* @param value  
81.      \* @return  
82.      \*/  
83.     public boolean add(String key, Object value)  
84.     \{  
85.         return mcc.add(key, value);  
86.     \}  
87.        
88.     public boolean add(String key, Object value, Date expiry)  
89.     \{  
90.         return mcc.add(key, value, expiry);  
91.     \}  
92.        
93.     public boolean replace(String key, Object value)  
94.     \{  
95.         return mcc.replace(key, value);  
96.     \}  
97.        
98.     public boolean replace(String key, Object value, Date expiry)  
99.     \{  
100.         return mcc.replace(key, value, expiry);  
101.     \}  
102.        
103.     /\*\*  
104.      \* 根据指定的关键字获取对象.  
105.      \* @param key  
106.      \* @return  
107.      \*/  
108.     public Object get(String key)  
109.     \{  
110.         return mcc.get(key);  
111.     \}  
112.        
113.     public static void main(String\[\] args)  
114.     \{  
115.         MemCachedManager cache = MemCachedManager.getInstance();  
116.         long startDate=System.currentTimeMillis();  
117.         for (int i = 0; i < 10; i++) \{  
118. //            cache.add("test"+i , "中国");  
119.         \}  
120.         cache.add("test0" , "中国");  
121.         cache.add("test1" , "中国");  
122.         long endDate=System.currentTimeMillis();  
123.             
124.         long nowDate=(endDate-startDate)/1000;  
125.         System.out.println(nowDate);  
126.         System.out.print( " get value : " + cache.get( "test0" ));  
127.     \}  
128.     \}

/**
     *
     */
    package com.icss.biz.util;
    
    import java.util.Date;
    
    import com.alisoft.xplatform.asf.cache.memcached.client.MemCachedClient;
    import com.alisoft.xplatform.asf.cache.memcached.client.SockIOPool;
    
    /**
     *  
     *  @author xxl
     *
     */
    public class MemCachedManager
    {
    
     // 创建全局的唯一实例
        protected static MemCachedClient mcc = new MemCachedClient();
         
        protected static MemCachedManager memCached = new MemCachedManager();
         
        // 设置与缓存服务器的连接池
        static {
            // 服务器列表和其权重
            String[] servers = { "127.0.0.1:33001" };
            Integer[] weights = { 3 };
    
            // 获取socke连接池的实例对象
            SockIOPool pool = SockIOPool.getInstance();
    
            // 设置服务器信息
            pool.setServers( servers );
            pool.setWeights( weights );
    
            // 设置初始连接数、最小和最大连接数以及最大处理时间
            pool.setInitConn( 5 );
            pool.setMinConn( 5 );
            pool.setMaxConn( 250 );
            pool.setMaxIdle( 1000 * 60 * 60 * 6 );
    
            // 设置主线程的睡眠时间
            pool.setMaintSleep( 30 );
    
            // 设置TCP的参数，连接超时等
            pool.setNagle( false );
            pool.setSocketTO( 3000 );
            pool.setSocketConnectTO( 0 );
    
            // 初始化连接池
            pool.initialize();
    
            // 压缩设置，超过指定大小（单位为K）的数据都会被压缩
            mcc.setCompressEnable( true );
            mcc.setCompressThreshold( 64 * 1024 );
        }
         
        /**
         * 保护型构造方法，不允许实例化！
         *
         */
        protected MemCachedManager()
        {
             
        }
         
        /**
         * 获取唯一实例.
         * @return
         */
        public static MemCachedManager getInstance()
        {
            return memCached;
        }
         
        /**
         * 添加一个指定的值到缓存中.
         * @param key
         * @param value
         * @return
         */
        public boolean add(String key, Object value)
        {
            return mcc.add(key, value);
        }
         
        public boolean add(String key, Object value, Date expiry)
        {
            return mcc.add(key, value, expiry);
        }
         
        public boolean replace(String key, Object value)
        {
            return mcc.replace(key, value);
        }
         
        public boolean replace(String key, Object value, Date expiry)
        {
            return mcc.replace(key, value, expiry);
        }
         
        /**
         * 根据指定的关键字获取对象.
         * @param key
         * @return
         */
        public Object get(String key)
        {
            return mcc.get(key);
        }
         
        public static void main(String[] args)
        {
            MemCachedManager cache = MemCachedManager.getInstance();
            long startDate=System.currentTimeMillis();
            for (int i = 0; i < 10; i++) {
    //            cache.add("test"+i , "中国");
            }
            cache.add("test0" , "中国");
            cache.add("test1" , "中国");
            long endDate=System.currentTimeMillis();
              
            long nowDate=(endDate-startDate)/1000;
            System.out.println(nowDate);
            System.out.print( " get value : " + cache.get( "test0" ));
        }
        }

具体详情（未整理）：

**\[html\]**  view plain  copy

print ?

1.  3 新建类 user.java  
2.    
3.  package bean;  
4.    
5.  import java.io.Serializable;  
6.    
7.  public class User implements Serializable\{  
8.     
9.      /\*\*  
10.      \* 序列号  
11.      \*/  
12.     private static final long serialVersionUID = -3896605600471191953L;  
13.     private int uid;  
14.     private String uname;  
15.     private String upass;  
16.      
17.     public int getUid() \{  
18.        return uid;  
19.     \}  
20.     public void setUid(int uid) \{  
21.        this.uid = uid;  
22.     \}  
23.     public String getUname() \{  
24.        return uname;  
25.     \}  
26.     public void setUname(String uname) \{  
27.        this.uname = uname;  
28.     \}  
29.     public String getUpass() \{  
30.        return upass;  
31.     \}  
32.     public void setUpass(String upass) \{  
33.        this.upass = upass;  
34.     \}  
35.   
36.   
37. \}  
38.   
39. 4 新建 JdbcConnector.java  
40.   
41. package util;  
42.   
43. import java.sql.Connection;  
44. import java.sql.DriverManager;  
45. import java.sql.SQLException;  
46.   
47. public class JdbcConnector \{  
48.   // 定义数据库连接常量  
49.     private final static String DRIVER = "com.mysql.jdbc.Driver";  
50.     private final static String URL = "jdbc:mysql://192.168.1.13:3306/test";  
51.     private final static String DBNAME = "root";  
52.     private final static String DBPASS = "123456";  
53.      
54.     /\*\*  
55.      \* 得到数据库连接  
56.      \* @return  
57.      \* @throws ClassNotFoundException  
58.      \* @throws SQLException  
59.      \*/  
60.     public Connection getConn()throws ClassNotFoundException,SQLException \{  
61.        // 加载驱动  
62.        Class.forName(DRIVER);  
63.        // 通过DriverManager对象得到连接  
64.        Connection conn = DriverManager.getConnection(URL,DBNAME,DBPASS);  
65.        // 返回数据库连接  
66.        return conn;  
67.     \}  
68. \}  
69.   
70. 5 新建 UserDao.java  
71.   
72. package util;  
73.   
74. import java.sql.SQLException;  
75. import java.util.ArrayList;  
76. import java.util.List;  
77.   
78. import bean.User;  
79.   
80. import com.mysql.jdbc.Connection;  
81. import com.mysql.jdbc.PreparedStatement;  
82. import com.mysql.jdbc.ResultSet;  
83.   
84. public class UserDao extends JdbcConnector \{  
85.     // 定义全局变量  
86.     Connection conn = null;  
87.     PreparedStatement pstmt = null;  
88.     ResultSet rs = null;  
89.      
90.     /\*\*  
91.      \* 根据Id查询用户  
92.      \* @param uid  
93.      \* @return  
94.      \*/  
95.     public User getUserById(int uid) \{  
96.        // 创建User对象  
97.        User user = null;  
98.        // 创建SQL语句  
99.        String sql = "select \* from user where uid=?";  
100.         
101.        try \{  
102.            // 获得数据库连接  
103.            conn = (Connection) this.getConn();  
104.            // 通过Connection对象创建PrepareStatement对象  
105.            pstmt = (PreparedStatement) conn.prepareStatement(sql);  
106.            // 设置SQL语句的参数  
107.            pstmt.setInt(2, uid);  
108.            // 执行查询，将查询结果赋给ResultSet对象  
109.            rs = (ResultSet) pstmt.executeQuery();  
110.            // 遍历指针  
111.            while (rs.next())  
112.            \{  
113.               user = new User();  
114.               user.setUid(rs.getInt("uid"));  
115.               user.setUname(rs.getString("uname"));  
116.               user.setUpass(rs.getString("upass"));  
117.            \}  
118.        \} catch (ClassNotFoundException e) \{  
119.            e.printStackTrace();  
120.        \} catch (SQLException e) \{  
121.            e.printStackTrace();  
122.        \}  
123.        return user;  
124.     \}  
125.      
126.     /\*\*  
127.      \* 查询所有用户  
128.      \* @return  
129.      \*/  
130.     @SuppressWarnings("unchecked")  
131.     public List getUserList() \{  
132.        // 创建ArrayList对象  
133.        List userList = new ArrayList();  
134.         
135.        // 创建SQL对象  
136.        String sql = "select \* from user";  
137.         
138.        try \{  
139.            conn = (Connection) this.getConn();  
140.            pstmt = (PreparedStatement) conn.prepareStatement(sql);  
141.            rs = (ResultSet) pstmt.executeQuery();  
142.            while (rs.next())  
143.            \{  
144.               User user = new User();  
145.               user.setUid(rs.getInt("uid"));  
146.               user.setUname(rs.getString("uname"));  
147.               user.setUpass(rs.getString("upass"));  
148.                
149.               userList.add(user);  
150.            \}  
151.        \} catch (ClassNotFoundException e) \{  
152.            e.printStackTrace();  
153.        \} catch (SQLException e) \{  
154.            e.printStackTrace();  
155.        \}  
156.        return userList;  
157.     \}  
158.   
159. \}  
160.   
161. 6 新建 MemcachedManager.java  
162.   
163. package memcachedTest;  
164.   
165. import java.util.Date;  
166. import java.util.List;  
167.   
168. import util.UserDao;  
169. import bean.User;  
170.   
171. import com.alisoft.xplatform.asf.cache.memcached.client.MemCachedClient;  
172. import com.alisoft.xplatform.asf.cache.memcached.client.SockIOPool;  
173.   
174. public class MemcachedManager \{  
175.    
176.    // 创建MemCachedClient全局对象  
177.     private static MemCachedClient mcc = new MemCachedClient();  
178.      
179.     static \{  
180.        // 创建服务器列表及其权重  
181.        String\[\] servers = \{"127.0.0.1:11211"\};  
182.        Integer\[\] weights = \{3\};  
183.         
184.        // 创建Socket连接池对象  
185.        SockIOPool pool = SockIOPool.getInstance();  
186.         
187.        // 设置服务器信息  
188.        pool.setServers(servers);  
189.        pool.setWeights(weights);  
190.        pool.setFailover(true);  
191.         
192.        // 设置初始连接数、最小和最大连接数以及最大处理时间  
193.        pool.setInitConn(5);  
194.        pool.setMinConn(5);  
195.        pool.setMaxConn(250);  
196.        pool.setMaxIdle(1000\*60\*60\*6);  
197.         
198.        // 设置主线程睡眠时间  
199.        pool.setMaintSleep(30);  
200.         
201.        // 设置TCP参数、连接超时等  
202.        pool.setNagle(false);  
203.        pool.setSocketTO(3000);  
204.        pool.setSocketConnectTO(0);  
205.        pool.setAliveCheck(true);  
206.         
207.        // 初始化连接池  
208.        pool.initialize();  
209.         
210.        // 压缩设置，超过指定大小（单位为K）的数据都会被压缩  
211.        mcc.setCompressEnable(true);  
212.        mcc.setCompressThreshold(64 \* 1024);  
213.     \}  
214.      
215.     /\*\*  
216.      \* 无参构造  
217.      \*/  
218.     protected MemcachedManager ()\{  
219.         
220.     \}  
221.      
222.     // 受保护的对象  
223.     protected static MemcachedManager instance = new MemcachedManager();  
224.      
225.     /\*\*  
226.      \* 为受保护的对象提供一个公共的访问方法  
227.      \*/  
228.     public static MemcachedManager getInstance () \{  
229.        return instance;  
230.     \}  
231.      
232.     /\*\*  
233.      \* 添加对象到缓存中，构成方法重载  
234.      \* @param key  
235.      \* @param value  
236.      \* @return  
237.      \*/  
238.     public boolean add(String key,Object value) \{  
239.        return mcc.add(key, value);  
240.     \}  
241.     public boolean add (String key,Object value,Date expiry) \{  
242.        return mcc.add(key, value,expiry);  
243.     \}  
244.      
245.     public boolean replace (String key,Object value) \{  
246.        return mcc.replace(key, value);  
247.     \}  
248.      
249.     public boolean replace (String key,Object value,Date expiry)  
250.     \{  
251.        return mcc.replace(key, value, expiry);  
252.     \}  
253.      
254.     /\*\*  
255.      \* 根据指定的关键字获取对象  
256.      \*/  
257.     public Object get(String key) \{  
258.        return mcc.get(key);  
259.     \}  
260.      
261.      
262.      
263.     /\*\*  
264.      \* 利用MemCached测试将单个对象存入缓存，并从缓存中取出  
265.      \*/  
266. //  public static void main(String\[\] args) \{  
267. //      // 得到MemcachedManager实例  
268. //     MemcachedManager cache = MemcachedManager.getInstance();  
269. //      
270. //     // 创建UserDao对象  
271. //     UserDao userDao = new UserDao();  
272. //     // 查询单个User对象  
273. //     User user = userDao.getUserById(4);  
274. //      
275. //     // 将User对象添加到缓存中  
276. //     cache.add("user", user.getUname());  
277. //      
278. //     // 将User对象从缓存中取出来  
279. //     String uname = (String)cache.get("user");  
280. //      
281. //     System.out.println("从缓存中取出的对象为：" + uname);  
282. //  \}  
283.      
284.      
285.      
286.     /\*\*  
287.      \* 利用MemCached对象将集合存入缓存，并从缓存中取出  
288.      \*/  
289.     @SuppressWarnings(\{ "unchecked", "rawtypes" \})  
290.     public static void main(String\[\] args) \{  
291.        // 得到MemcachedManager实例  
292.        MemcachedManager cache = MemcachedManager.getInstance();  
293.         
294.        // 创建UserDao对象  
295.        UserDao userDao = new UserDao();  
296.        // 得到集合对象  
297.        List userList = userDao.getUserList();  
298.         
299.        // 创建User对象  
300.        User user = null;  
301.        for (int i=0; i<userList.size(); i++)  
302.        \{  
303.            // 循环遍历集合对象  
304.            user = (User)userList.get(i);  
305.            user.getUid();  
306.            user.getUname();  
307.            user.getUpass();  
308.             
309.            // 将集合对象存入缓存中  
310.            cache.add("userList" + i,user.getUname());  
311.             
312.            // 将集合从缓存中取出  
313.            String uname = (String)cache.get("userList"+i);  
314.             
315.            System.out.println("从缓存中取得的集合为：" + uname);  
316.        \}  
317.     \}  
318.   
319.   
320. \}  
321.   
322.    
323.   
324.    
325.   
326. 结果从控制台输出:  
327.   
328. 从缓存中取得的集合为：uname  
329. 从缓存中取得的集合为：uname1  
330. 从缓存中取得的集合为：uname2  
331. 从缓存中取得的集合为：uname3

3 新建类 user.java
    
    package bean;
    
    import java.io.Serializable;
    
    public class User implements Serializable{
     
        /**
         * 序列号
         */
        private static final long serialVersionUID = -3896605600471191953L;
        private int uid;
        private String uname;
        private String upass;
       
        public int getUid() {
           return uid;
        }
        public void setUid(int uid) {
           this.uid = uid;
        }
        public String getUname() {
           return uname;
        }
        public void setUname(String uname) {
           this.uname = uname;
        }
        public String getUpass() {
           return upass;
        }
        public void setUpass(String upass) {
           this.upass = upass;
        }
    
    
    }
    
    4 新建 JdbcConnector.java
    
    package util;
    
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.SQLException;
    
    public class JdbcConnector {
      // 定义数据库连接常量
        private final static String DRIVER = "com.mysql.jdbc.Driver";
        private final static String URL = "jdbc:mysql://192.168.1.13:3306/test";
        private final static String DBNAME = "root";
        private final static String DBPASS = "123456";
       
        /**
         * 得到数据库连接
         * @return
         * @throws ClassNotFoundException
         * @throws SQLException
         */
        public Connection getConn()throws ClassNotFoundException,SQLException {
           // 加载驱动
           Class.forName(DRIVER);
           // 通过DriverManager对象得到连接
           Connection conn = DriverManager.getConnection(URL,DBNAME,DBPASS);
           // 返回数据库连接
           return conn;
        }
    }
    
    5 新建 UserDao.java
    
    package util;
    
    import java.sql.SQLException;
    import java.util.ArrayList;
    import java.util.List;
    
    import bean.User;
    
    import com.mysql.jdbc.Connection;
    import com.mysql.jdbc.PreparedStatement;
    import com.mysql.jdbc.ResultSet;
    
    public class UserDao extends JdbcConnector {
        // 定义全局变量
        Connection conn = null;
        PreparedStatement pstmt = null;
        ResultSet rs = null;
       
        /**
         * 根据Id查询用户
         * @param uid
         * @return
         */
        public User getUserById(int uid) {
           // 创建User对象
           User user = null;
           // 创建SQL语句
           String sql = "select * from user where uid=?";
          
           try {
               // 获得数据库连接
               conn = (Connection) this.getConn();
               // 通过Connection对象创建PrepareStatement对象
               pstmt = (PreparedStatement) conn.prepareStatement(sql);
               // 设置SQL语句的参数
               pstmt.setInt(2, uid);
               // 执行查询，将查询结果赋给ResultSet对象
               rs = (ResultSet) pstmt.executeQuery();
               // 遍历指针
               while (rs.next())
               {
                  user = new User();
                  user.setUid(rs.getInt("uid"));
                  user.setUname(rs.getString("uname"));
                  user.setUpass(rs.getString("upass"));
               }
           } catch (ClassNotFoundException e) {
               e.printStackTrace();
           } catch (SQLException e) {
               e.printStackTrace();
           }
           return user;
        }
       
        /**
         * 查询所有用户
         * @return
         */
        @SuppressWarnings("unchecked")
        public List getUserList() {
           // 创建ArrayList对象
           List userList = new ArrayList();
          
           // 创建SQL对象
           String sql = "select * from user";
          
           try {
               conn = (Connection) this.getConn();
               pstmt = (PreparedStatement) conn.prepareStatement(sql);
               rs = (ResultSet) pstmt.executeQuery();
               while (rs.next())
               {
                  User user = new User();
                  user.setUid(rs.getInt("uid"));
                  user.setUname(rs.getString("uname"));
                  user.setUpass(rs.getString("upass"));
                 
                  userList.add(user);
               }
           } catch (ClassNotFoundException e) {
               e.printStackTrace();
           } catch (SQLException e) {
               e.printStackTrace();
           }
           return userList;
        }
    
    }
    
    6 新建 MemcachedManager.java
    
    package memcachedTest;
    
    import java.util.Date;
    import java.util.List;
    
    import util.UserDao;
    import bean.User;
    
    import com.alisoft.xplatform.asf.cache.memcached.client.MemCachedClient;
    import com.alisoft.xplatform.asf.cache.memcached.client.SockIOPool;
    
    public class MemcachedManager {
     
       // 创建MemCachedClient全局对象
        private static MemCachedClient mcc = new MemCachedClient();
       
        static {
           // 创建服务器列表及其权重
           String[] servers = {"127.0.0.1:11211"};
           Integer[] weights = {3};
          
           // 创建Socket连接池对象
           SockIOPool pool = SockIOPool.getInstance();
          
           // 设置服务器信息
           pool.setServers(servers);
           pool.setWeights(weights);
           pool.setFailover(true);
          
           // 设置初始连接数、最小和最大连接数以及最大处理时间
           pool.setInitConn(5);
           pool.setMinConn(5);
           pool.setMaxConn(250);
           pool.setMaxIdle(1000*60*60*6);
          
           // 设置主线程睡眠时间
           pool.setMaintSleep(30);
          
           // 设置TCP参数、连接超时等
           pool.setNagle(false);
           pool.setSocketTO(3000);
           pool.setSocketConnectTO(0);
           pool.setAliveCheck(true);
          
           // 初始化连接池
           pool.initialize();
          
           // 压缩设置，超过指定大小（单位为K）的数据都会被压缩
           mcc.setCompressEnable(true);
           mcc.setCompressThreshold(64 * 1024);
        }
       
        /**
         * 无参构造
         */
        protected MemcachedManager (){
          
        }
       
        // 受保护的对象
        protected static MemcachedManager instance = new MemcachedManager();
       
        /**
         * 为受保护的对象提供一个公共的访问方法
         */
        public static MemcachedManager getInstance () {
           return instance;
        }
       
        /**
         * 添加对象到缓存中，构成方法重载
         * @param key
         * @param value
         * @return
         */
        public boolean add(String key,Object value) {
           return mcc.add(key, value);
        }
        public boolean add (String key,Object value,Date expiry) {
           return mcc.add(key, value,expiry);
        }
       
        public boolean replace (String key,Object value) {
           return mcc.replace(key, value);
        }
       
        public boolean replace (String key,Object value,Date expiry)
        {
           return mcc.replace(key, value, expiry);
        }
       
        /**
         * 根据指定的关键字获取对象
         */
        public Object get(String key) {
           return mcc.get(key);
        }
       
       
       
        /**
         * 利用MemCached测试将单个对象存入缓存，并从缓存中取出
         */
    //  public static void main(String[] args) {
    //      // 得到MemcachedManager实例
    //     MemcachedManager cache = MemcachedManager.getInstance();
    //    
    //     // 创建UserDao对象
    //     UserDao userDao = new UserDao();
    //     // 查询单个User对象
    //     User user = userDao.getUserById(4);
    //    
    //     // 将User对象添加到缓存中
    //     cache.add("user", user.getUname());
    //    
    //     // 将User对象从缓存中取出来
    //     String uname = (String)cache.get("user");
    //    
    //     System.out.println("从缓存中取出的对象为：" + uname);
    //  }
       
       
       
        /**
         * 利用MemCached对象将集合存入缓存，并从缓存中取出
         */
        @SuppressWarnings({ "unchecked", "rawtypes" })
        public static void main(String[] args) {
           // 得到MemcachedManager实例
           MemcachedManager cache = MemcachedManager.getInstance();
          
           // 创建UserDao对象
           UserDao userDao = new UserDao();
           // 得到集合对象
           List userList = userDao.getUserList();
          
           // 创建User对象
           User user = null;
           for (int i=0; i<userList.size(); i++)
           {
               // 循环遍历集合对象
               user = (User)userList.get(i);
               user.getUid();
               user.getUname();
               user.getUpass();
              
               // 将集合对象存入缓存中
               cache.add("userList" + i,user.getUname());
              
               // 将集合从缓存中取出
               String uname = (String)cache.get("userList"+i);
              
               System.out.println("从缓存中取得的集合为：" + uname);
           }
        }
    
    
    }
    
     
    
     
    
    结果从控制台输出:
    
    从缓存中取得的集合为：uname
    从缓存中取得的集合为：uname1
    从缓存中取得的集合为：uname2
    从缓存中取得的集合为：uname3

[category_icon.jpg]: /images/20220610/f4005eee756f4df880e489dc6278763f.png
[arrow_triangle_20_down.jpg]: http://static.blog.csdn.net/images/arrow_triangle%20_down.jpg
[arrow_triangle_up.jpg]: /images/20220610/cfb1ae01f82e436d890d9b09530e4161.png
[Link 1]: http://blog.csdn.net/Leolu007/article/category/1213699
[rar]: http://download.csdn.net/images/minetype/rar.gif
[rar_rar_memcache win7 64_]: /images/20220610/92e34d3e9cfd46eda06eb2bbd66252c3.png
[http_blog.couchbase.com_memcached-windows-64-bit-pre-release-available]: http://blog.couchbase.com/memcached-windows-64-bit-pre-release-available
[memcached-win64-1.4.4-14.zip]: http://www.jb51.net/softs/205839.html
[memcache-client-for java]: https://code.google.com/p/memcache-client-forjava/