实战：Memcached的概念作用以及用法详解

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

packagememcached.test;

importjava.util.Date;

importcom.danga.MemCached.MemCachedClient;

importcom.danga.MemCached.SockIOPool;

/**

 * 使用memcached的缓存实用类.

 */

publicclassMemCached {

  // 创建全局的唯一实例

  protectedstaticMemCachedClient mcc = newMemCachedClient();

  protectedstaticMemCached memCached = newMemCached();

  // 设置与缓存服务器的连接池

  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);

  }

  privateMemCached() {

  }

  /**

   * 获取唯一实例.

   * singleton

   * @return

   */

  publicstaticMemCached getInstance() {

    returnmemCached;

  }

  /**

   * 添加一个指定的键值对到缓存中.

   *

   * @param key

   * @param value

   * @return

   */

  publicbooleanadd(String key, Object value) {

    returnmcc.add(key, value);

  }

  /**

   * 添加一个指定的键值对到缓存中.

   *

   * @param key

   * @param value

   * @param expiry 多久之后过期

   * @return

   */

  publicbooleanadd(String key, Object value, Date expiry) {

    returnmcc.add(key, value, expiry);

  }

  publicbooleanset(String key, Object value) {

    returnmcc.set(key, value);

  }

  publicbooleanset(String key, Object value, Date expiry) {

    returnmcc.set(key, value, expiry);

  }

  publicbooleanreplace(String key, Object value) {

    returnmcc.replace(key, value);

  }

  publicbooleanreplace(String key, Object value, Date expiry) {

    returnmcc.replace(key, value, expiry);

  }

  /**

   * 根据指定的关键字获取对象.

   *

   * @param key

   * @return

   */

  publicObject get(String key) {

    returnmcc.get(key);

  }

}

MemCached

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

publicstaticvoidmain(String[] args) {

    MemCached cache = MemCached.getInstance();

    booleanresult1 = cache.add("hello", 1234, newDate(1000* 2));// 设置2秒后过期

    System.out.println("第一次add : "+ result1);

    System.out.println("Value : "+ cache.get("hello"));

    booleanresult2 =cache.add("hello", 12345, newDate(1000* 2));// add fail

    System.out.println("第二次add : "+ result2);

    booleanresult3 =cache.set("hello", 12345, newDate(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"));

  }

1

2

3

4

5

6

7

第一次add : true

Value : 1234

第二次add : false

调用set : true

Value : 12345

已经sleep2秒了....

Value : null

1

2

3

4

5

6

7

8

9

10

11

12

13

14

packagememcached.test;

publicclassPerson implementsjava.io.Serializable {

  privatestaticfinallongserialVersionUID = 1L;

  privateString name;

  publicString getName() {

    returnname;

  }

  publicvoidsetName(String name) {

    this.name = name;

  }

}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

publicstaticvoidmain(String[] args) {

    MemCached cache = MemCached.getInstance();

    Person p1 = newPerson();

    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());

  }