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

下载

memcache win7 64位
安装文件

或

a. 下载最新版：http://blog.couchbase.com/memcached-windows-64-bit-pre-release-available

b. 直接下载：
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目录下

<?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>
    
    <socketpool name="pool0" failover="true" initConn="5" minConn="5" maxConn="250" maintSleep="0"
        nagle="false" socketTO="3000" aliveCheck="true">
        <servers>127.0.0.1:33001</servers>
    </socketpool> 
    
    <cluster name="cluster1">
        <memCachedClients>mclient0</memCachedClients>
    </cluster>
                
</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,如下：

<?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类：

/**
 *
 */
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" ));
    }
    }

具体详情（未整理）：

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