Maven项目集合Memcached框架

时间 2019-11-07

标签 maven 项目集合 memcached 框架栏目 Maven 繁體版

原文原文链接

前言

Memcached说明

Memcached是一个基于键值对的HashMap的分布式内存对象缓存系统，其协议简单，存取方便。不过只要重启mencached或者达到指定值，memcached会删除不使用的缓存。
客户端管理工具

安装过程

基于Windows的安装过程

1.下载安装程序
2.经过【cmd】进入memcached安装程序目录
3.输入memcached -d install
4.测试，Telnet 127.0.0.1 11211 这里为本地IP，默认端口号为11211

memcached调整内存大小

1.点击【运行】输入【regedit】
2.注册表中找到【HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\memcached Server】
3.将ImagePath键的值【："c:${安装目录}\memcached.exe" -d runservice】，改成：【"c:\memcached\memcached.exe" -d runservice -m 512 -p 11211】这边的512就是memcached缓存的大小。
4.重启memcached服务便可，能够经过Telnet 127.0.0.1 11211 输入stats查看更改后的内存大小参数

基于Linux的安装过程

一、因为memcached是基于libevent的，因此先检查是否安装了libevent，没有则安装

rpm -qa|grep libevent
yum install libevent libevent-devel-y

二、执行如下命令安装memcached，并启动

yum -y install –enablerepo=rpmforge memcached
/usr/bin/memcached -d -m 1024m -c 1024 -u root

三、检查运行状态printf "stats\r\n" | nc 127.0.0.1 11211

memcached调整内存大小

经过启动设置参数

/usr/local/memcached/bin/memcached -d -m 10m -p 11211 -u root

memcached部分参数说明

-d选项是启动一个守护进程，

-m是分配给Memcache使用的内存数量，单位是MB，这里是10MB，

-u是运行Memcache的用户，这里是root，

-l是监听的服务器IP地址，若是有多个地址的话，这里指定了服务器的IP地址192.168.0.200，

-p是设置Memcache监听的端口，这里设置了12000，最好是1024以上的端口，

-c选项是最大运行的并发链接数，默认是1024，这里设置了256，按照服务器的负载量来设定，

-P是设置保存Memcache的pid文件，我这里是保存在 /tmp/memcached.pid，也能够启动多个守护进程，不过端口不能重复

项目集合过程

1.添加maven Jar包

<!-- 缓存 -->
        <dependency>
            <groupId>com.whalin</groupId>
            <artifactId>Memcached-Java-Client</artifactId>
            <version>3.0.1</version>
            <type>jar</type>
            <scope>compile</scope>
        </dependency>

2.添加memcached工具类

public class MemCached {
   
    // 建立全局的惟一实例
    public static MemCachedClient mcc = new MemCachedClient();

    public volatile static MemCached memCached = null;

    // 设置与缓存服务器的链接池
    static {
        // 服务器列表和其权重
        String[] servers = {"119.23.245.84:11211"};
        //String[] servers = {"120.77.44.111:10201"};
        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() {

    }

    /**
     *<p>Description:单例模式-二次校验</p>
     *<p>Author:Boomer</p>
     *<p>Date:2017/8/24 13:32</p>
     **/
    public static MemCached getInstance() {
        if (null == memCached) {
            synchronized (MemCached.class) {// 二次校验
                if (null == memCached) {
                    memCached = new MemCached();
                }
            }
        }
        return memCached;
    }

    /**
     * 添加一个指定的键值对到缓存中.
     *
     * @param key
     * @param value
     * @return
     */
    public boolean add(String key, Object value) {
        return mcc.add(key, value);
    }

    /**
     * 添加一个指定的键值对到缓存中.
     *
     * @param key
     * @param value
     * @param minute 多少分钟以后过时
     * @return
     */
    public boolean add(String key, Object value, int minute) {
        return mcc.add(key, value, new Date(60000 * minute));
    }


    public boolean set(String key, Object value) {
        return mcc.set(key, value);
    }

    public boolean set(String key, Object value, int minute) {
        return mcc.set(key, value, new Date(60000 * minute));
    }

    public boolean replace(String key, Object value) {
        return mcc.replace(key, value);
    }

    public boolean replace(String key, Object value, int minute) {
        return mcc.replace(key, value, new Date(60000 * minute));
    }


    /**
     * 根据指定的关键字获取对象.
     *
     * @param key
     * @return
     */
    public Object get(String key) {
        return mcc.get(key);
    }

    /**
     * 删除指定缓存
     *
     * @param key
     * @return
     */
    public boolean del(String key) {
        return mcc.delete(key);
    }
}

3.使用方式

MemCached memCached = MemCached.getInstance();
        memCached.add("test","hello World");
        System.out.println(memCached.get("test"));

输出 hello World 成功算法

后语

缓存类必定要加相应的过时时间，不然很容易达到内存上限。