Memcached学习笔记之二：入门使用

比眉伴天荒 2022-05-13 15:22 235阅读 0赞

# **使用** #

现在服务器已经正常运行了，下面我们就来写java的客户端连接程序。

将java\_memcached-release.zip解压，把java\_memcached-release.jar文件复制到java项目的lib目录下，

然后我们来编写代码，比如我提供的一个应用类如下：

package memcached.test;
    
    import java.util.Date;
    
    import com.danga.MemCached.MemCachedClient;
    import com.danga.MemCached.SockIOPool;
    
    /**
     * 使用memcached的缓存实用类.
     */
    public class MemCached {
        // 创建全局的唯一实例
        protected static MemCachedClient mcc = new MemCachedClient();
    
        protected static MemCached memCached = new MemCached();
    
        // 设置与缓存服务器的连接池
        static {
            // 服务器列表和其权重
            String[] servers = { "127.0.0.1:11211" };
            Integer[] weights = { 3 };
    
            // 获取socke连接池的实例对象
            // 这个类用来创建管理客户端和服务器通讯连接池，
            // 客户端主要的工作（包括数据通讯、服务器定位、hash码生成等）都是由这个类完成的。
            SockIOPool pool = SockIOPool.getInstance();
    
            // 设置服务器信息
            pool.setServers(servers);
            
            // 设置Server权重
            pool.setWeights(weights);
    
            // 设置初始连接数、最小和最大连接数以及最大处理时间
            pool.setInitConn(5);
            pool.setMinConn(5);
            pool.setMaxConn(250);
            pool.setMaxIdle(1000 * 60 * 60 * 6);
    
            // 设置主线程的睡眠时间
            pool.setMaintSleep(30);
    
            // 设置连接心跳监测开关
            // true:每次通信都要进行连接是否有效的监测，造成通信次数倍增，加大网络负载，
            // 因此在对HighAvailability要求比较高的场合应该设为true
            // 默认状态是false，建议保持默认。
            pool.setAliveCheck(false);
    
            // 设置连接失败恢复开关
            // 设置为true，当宕机的服务器启动或中断的网络连接后，这个socket连接还可继续使用，否则将不再使用.
            // 默认状态是true，建议保持默认。
            pool.setFailback(true);
    
            // 设置容错开关
            // true:当当前socket不可用时，程序会自动查找可用连接并返回，否则返回NULL
            // 默认状态是true，建议保持默认。
            pool.setFailover(true);
    
            // 设置hash算法
            // alg=0 使用String.hashCode()获得hash code,该方法依赖JDK，可能和其他客户端不兼容，建议不使用
            // alg=1 使用original 兼容hash算法，兼容其他客户端
            // alg=2 使用CRC32兼容hash算法，兼容其他客户端，性能优于original算法
            // alg=3 使用MD5 hash算法
            // 采用前三种hash算法的时候，查找cache服务器使用余数方法。采用最后一种hash算法查找cache服务时使用consistent方法。
            // 默认值为0
            pool.setHashingAlg(0);
    
            // 设置是否使用Nagle算法，因为我们的通讯数据量通常都比较大（相对TCP控制数据）而且要求响应及时，
            // 因此该值需要设置为false（默认是true）
            pool.setNagle(false);
            
            // 设置socket的读取等待超时值
            pool.setSocketTO(3000);
            
            // 设置socket的连接等待超时值
            pool.setSocketConnectTO(0);
    
            // 初始化连接池
            pool.initialize();
    
            // 压缩设置，超过指定大小（单位为K）的数据都会被压缩
            // mcc.setCompressEnable(true);    //UnsupportedOperation
            // mcc.setCompressThreshold(64 * 1024);
        }
    
        private MemCached() {
    
        }
    
        /**
         * 获取唯一实例.
         * singleton
         * @return
         */
        public static MemCached getInstance() {
            return memCached;
        }
    
        /**
         * 添加一个指定的键值对到缓存中.
         * 
         * @param key
         * @param value
         * @return
         */
        public boolean add(String key, Object value) {
            return mcc.add(key, value);
        }
    
        /**
         * 添加一个指定的键值对到缓存中.
         * 
         * @param key
         * @param value
         * @param expiry 多久之后过期
         * @return
         */
        public boolean add(String key, Object value, Date expiry) {
            return mcc.add(key, value, expiry);
        }
        
        
        public boolean set(String key, Object value) {
            return mcc.set(key, value);
        }
    
        public boolean set(String key, Object value, Date expiry) {
            return mcc.set(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);
        }

写个Main方法测试下：

public static void main(String[] args) {
            MemCached cache = MemCached.getInstance();
            boolean result1 = cache.add("hello", 1234, new Date(1000 * 2));// 设置2秒后过期
            System.out.println("第一次add : " + result1);
            System.out.println("Value : " + cache.get("hello"));
            
            boolean result2 =cache.add("hello", 12345, new Date(1000 * 2));// add fail
            System.out.println("第二次add : " + result2);
            
            boolean result3 =cache.set("hello", 12345, new Date(1000 * 2));// set successes
            System.out.println("调用set : " + result3);
            
            System.out.println("Value : " + cache.get("hello"));
    
            try {
                Thread.sleep(1000 * 2);
                System.out.println("已经sleep2秒了....");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Value : " + cache.get("hello"));
        }

执行结果如下：

第一次add : true
    Value : 1234
    第二次add : false
    调用set : true
    Value : 12345
    已经sleep2秒了....
    Value : null

说明：

1.  第二次add失败是因为"hello"这个key已经存在了。
2.  调用set成功，是因为set的时候覆盖了已存在的键值对，这正是add和set的不同之处
3.  设置过期之间之后，cache按时自动失效

上面的例子是对于基本数据类型，对于普通的POJO而言，如果要进行存储的话，那么比如让其实现java.io.Serializable接口。

因为memcached是一个分布式的缓存服务器，多台服务器间进行数据共享需要将对象序列化的，所以必须实现该接口，否则会报错的（java.io.NotSerializableException）。

下面来试试POJO的存储：

package memcached.test;
    public class Person implements java.io.Serializable {
        private static final long serialVersionUID = 1L;
    
        private String name;
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }

Main方法如下：

public static void main(String[] args) {
            MemCached cache = MemCached.getInstance();
    
            Person p1 = new Person();
            p1.setName("Jack");
            cache.add("bean", p1);
            
            Person p2 = (Person) cache.get("bean");
            System.out.println("name=" + p2.getName());//Jack
            p2.setName("Rose");
            
            // cache.replace("bean", p2);
            Person p3 = (Person) cache.get("bean");
            System.out.println("name=" + p3.getName());
        }

上面的代码中，我们通过p2.setName("Rose")修改了对象的名字，

最后一行打印的会是什么呢？

name=Jack
    name=Jack

Why?

这是因为我们修改的对象并不是缓存中的对象，而是通过序列化过来的一个实例对象

那么要修改怎么办？使用replace，注释掉的那一行把注释去掉就可以了。

# **二、其他** #

### Memcached的命令参数说明 ###

\-p <num>                监听的端口  
\-l <ip\_addr>            连接的IP地址, 默认是本机  
\-d start                   启动memcached服务  
\-d restart                重起memcached服务  
\-d stop|shutdown    关闭正在运行的memcached服务  
\-d install                  安装memcached服务  
\-d uninstall              卸载memcached服务  
\-u <username>       以<username>的身份运行 (仅在以root运行的时候有效)  
\-m <num>              最大内存使用，单位MB。默认64MB  
\-M                          内存耗尽时返回错误，而不是删除项  
\-c <num>                最大同时连接数，默认是1024  
\-f <factor>              块大小增长因子，默认是1.25  
\-n <bytes>             最小分配空间，key+value+flags默认是48  
\-h                          显示帮助

Memcached也可以在控制台中添加键值对，首先使用命令“telnet 127.0.0.1 11211”进入到Memcached控制台，

然后使用`set、``add、``replace、``get、``delete来操作。`

# **三、Memcached的优势和不足** #

说到Memcached的优势，那当然是：速度快，操作简便，易扩展

不足的话，主要有2点：

1.  数据的临时性(数据仅保存在内存中)
2.  只能通过指定键来读取数据，不支持模糊查询

# **四、Memcached停止时的保障措施** #

如果数据库的访问量比较大，就需要提前做好准备，以便应对在memcached停止时发生的负载问题。

如果能在停止memcached之前，把数据复制到其他的server就好了。恩，这个可以通过repcached来实现。

repcached是日本人开发的实现memcached复制功能，  
它是一个单master、单slave的方案，但它的master/slave都是可读写的，而且可以相互同步  
如果master坏掉，slave侦测到连接断了，它会自动listen而成为master