今天终于回来了(差不多10多天没有coding啦)感觉有点生疏了

今天继续完成Memcache(缓存)的使用

http://www.cnblogs.com/mycifeng/p/5882509.html(参考文档)

开始测试连接(memcached的文件夹下面)

telnet 127.0.0.1 11211 (本地的连接)

连接成功

telnet 47.94.**.** 11211 (服务器连接)

连接成功

开始链接阿里云的时候连接不上

是端口没有开启(要在安全组里面开启端口 11211 )

接下来就是怎么让java怎么连接memcached的服务

http://www.runoob.com/memcached/java-memcached.html(参考文档)

添加maven的jar包

http://mvnrepository.com/artifact/com.whalin/Memcached-Java-Client/3.0.2(jar包位置)

http://blog.csdn.net/qiyongkang520/article/details/57083642(参考文档)

添加maven jar

配置memcached.properties

#######################Memcached配置#######################

#服务器地址

memcached.server=47.94.14.145

memcached.port=11211

#初始化时对每个服务器建立的连接数目

memcached.initConn=20

#每个服务器建立最小的连接数

memcached.minConn=10

#每个服务器建立最大的连接数

memcached.maxConn=50

#自查线程周期进行工作，其每次休眠时间

memcached.maintSleep=3000

#Socket的参数，如果是true在写数据时不缓冲，立即发送出去

memcached.nagle=false

#Socket阻塞读取数据的超时时间

memcached.socketTO=3000

配置memcachedContext.xml

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:mvc="http://www.springframework.org/schema/mvc"

xmlns:context="http://www.springframework.org/schema/context"

xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"

xmlns:p="http://www.springframework.org/schema/p"

xsi:schemaLocation="

http://www.springframework.org/schema/mvc

http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd

http://www.springframework.org/schema/tx

http://www.springframework.org/schema/tx/spring-tx-3.0.xsd

http://www.springframework.org/schema/aop

http://www.springframework.org/schema/aop/spring-aop-3.0.xsd

http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans-3.0.xsd

http://www.springframework.org/schema/context

http://www.springframework.org/schema/context/spring-context-3.0.xsd">

<!-- properties config -->

<bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">

<property name="order" value="1"/>

<property name="ignoreUnresolvablePlaceholders" value="true"/>

<property name="locations">

<list>

<value>classpath:memcached.properties</value>

</list>

</property>

</bean>

<!-- Memcached配置 -->

<bean id="memcachedPool" class="com.whalin.MemCached.SockIOPool"

factory-method="getInstance" init-method="initialize" destroy-method="shutDown">

<property name="servers">

<list>

<value>${memcached.server}:${memcached.port}</value>

</list>

</property>

<property name="initConn">

<value>${memcached.initConn}</value>

</property>

<property name="minConn">

<value>${memcached.minConn}</value>

</property>

<property name="maxConn">

<value>${memcached.maxConn}</value>

</property>

<property name="maintSleep">

<value>${memcached.maintSleep}</value>

</property>

<property name="nagle">

<value>${memcached.nagle}</value>

</property>

<property name="socketTO">

<value>${memcached.socketTO}</value>

</property>

</bean>

</beans>

具体的类的实现

package com.fuwei.util;

import java.io.PrintWriter;

import java.io.StringWriter;

import java.util.Date;

import com.whalin.MemCached.MemCachedClient;

import org.apache.log4j.LogManager;

import org.apache.log4j.Logger;

public class MemcacheUtil {

private static Logger logger = LogManager.getLogger(MemcacheUtil.class);

private static String MEMCACHE_POOL_NAME = "default";

/**

* cachedClient.

*/

private static MemCachedClient cachedClient;

static {

if (cachedClient == null) {

cachedClient = new MemCachedClient(MEMCACHE_POOL_NAME);

}

}

/**

* 构造函数.

*/

private MemcacheUtil() {

}

/**

* 向缓存添加新的键值对。如果键已经存在，则之前的值将被替换.

*/

public static boolean set(String key, Object value) {

return setExp(key, value, null);

}

/**

* 向缓存添加新的键值对。如果键已经存在，则之前的值将被替换.

* 过期时间 New Date(1000*10)：十秒后过期

* @return boolean

*/

public static boolean set(String key, Object value, Date expire) {

return setExp(key, value, expire);

}

/**

* 向缓存添加新的键值对。如果键已经存在，则之前的值将被替换.

* 过期时间 New Date(1000*10)：十秒后过期

* @return boolean

*/

private static boolean setExp(String key, Object value, Date expire) {

boolean flag = false;

try {

flag = cachedClient.set(key, value, expire);

} catch (Exception e) {

logger.error("Memcached set方法报错，key值：" + key + "\r\n" + exceptionWrite(e));

}

return flag;

}

/**

* 仅当缓存中不存在键时，add 命令才会向缓存中添加一个键值对.

*/

public static boolean add(String key, Object value) {

return addExp(key, value, null);

}

/**

* 仅当缓存中不存在键时，add 命令才会向缓存中添加一

* 过期时间 New Date(1000*10)：十秒后过期

* @return boolean

*/

public static boolean add(String key, Object value, Date expire) {

return addExp(key, value, expire);

}

/**

* 仅当缓存中不存在键时，add 命令才会向缓存中添加一个键值对.

* 过期时间 New Date(1000*10)：十秒后过期

* @return boolean

*/

private static boolean addExp(String key, Object value, Date expire) {

boolean flag = false;

try {

flag = cachedClient.add(key, value, expire);

} catch (Exception e) {

logger.error("Memcached add方法报错，key值：" + key + "\r\n" + exceptionWrite(e));

}

return flag;

}

/**

* 仅当键已经存在时，replace 命令才会替换缓存中的键.

*/

public static boolean replace(String key, Object value) {

return replaceExp(key, value, null);

}

/**

* 仅当键已经存在时，replace 命令才会替换缓存中的键.

* 过期时间 New Date(1000*10)：十秒后过期

* @return boolean

*/

public static boolean replace(String key, Object value, Date expire) {

return replaceExp(key, value, expire);

}

/**

* 仅当键已经存在时，replace 命令才会替换缓存中的键.

* 过期时间 New Date(1000*10)：十秒后过期

* @return boolean

*/

private static boolean replaceExp(String key, Object value, Date expire) {

boolean flag = false;

try {

flag = cachedClient.replace(key, value, expire);

} catch (Exception e) {

logger.error("Memcached replace方法报错，key值：" + key + "\r\n" + exceptionWrite(e));

}

return flag;

}

/**

* get 命令用于检索与之前添加的键值对相关的值.

*/

public static Object get(String key) {

Object obj = null;

try {

obj = cachedClient.get(key);

} catch (Exception e) {

logger.error("Memcached get方法报错，key值：" + key + "\r\n" + exceptionWrite(e));

}

}

/**

* 删除 memcached 中的任何现有值.

*/

public static boolean delete(String key) {

return cachedClient.delete(key);

}

/**清理缓存中的所有键/值对.

*/

public static boolean flashAll() {

boolean flag = false;

try {

flag = cachedClient.flushAll();

} catch (Exception e) {

logger.error("Memcached flashAll方法报错\r\n" + exceptionWrite(e));

}

return flag;

}

/**

* 返回异常栈信息，String类型.

*/

private static String exceptionWrite(Exception e) {

StringWriter sw = new StringWriter();

PrintWriter pw = new PrintWriter(sw);

e.printStackTrace(pw);

pw.flush();

return sw.toString();

}

}

测试的类

package com.fuwei.util;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MemcacheClientTest {

public static void main(String[] args) {

new ClassPathXmlApplicationContext("applicationContext.xml");

//设置key

boolean isSuccess = MemcacheUtil.set("name", "qiyongkang");

System.out.println("是否成功：" + isSuccess);

Object obj = MemcacheUtil.get("name");

System.out.println("获取name:" + obj);

}

}

测试运行

出现错误,感觉流程是对的

今天完成的事情:就是实现java的memcached的实现,查了很多的博客,感觉这个流程还是比较完整,但是感觉还是有点问题,就是感觉主函数的测试加载不了,可能是配置还是哪里的问题,还是需要多看一下,还是对这个memcached的了解不够.

今天遇到的困难:可能是对这个memcached 的理解还不是很熟悉,接下来的任务就是继续解决这个问题

明天的计划:继续完成这个错误和熟悉memcached,最近开学还有很多的事情我类处理,收假期的报告,还有书本的事情,同学们的基本情况,跑办公室(还是每天坚持)

坚持