今天闲来无事，因为工作中要用到缓存，这里决定使用Memcache,所以利用周末，在家里做了个demo，发表出来希望对大家有用。
1,?开始肯定是下载需要的文件了，这里就下载附件里的文件就好，我也是在网上down的，放这好找。然后我们安装一下Memcache服务器，找到解压的memcached-1.2.1-win32，启动cmd ,进入解压目录，输入命令?D:\memcached-1.2.6-win32\memcached.exe -d install.然后再键入命令'D:\memcached\memcached.exe -d start'启动,这样memcache就会作为windows系统服务在每次开机时启动memcache服务。
2,下面我们开始在使用java进行配置开发。添加Spring功能。在web.xml中添加配置。
?
?
<context-param> <param-name>contextConfigLocation</param-name> <param-value>classpath:/spring/applicationContext-common.xml, classpath:/spring/spring-memcache.xml </param-value> </context-param>
?
3，在src下新建spring目录，并新建applicationContext-common.xml和spring-memcache.xml。内容分别如下。
applicationContext-common.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:p="http://www.springframework.org/schema/p" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd"> <bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"> <property name="locations"> <list> <value>classpath:memcache.properties</value> <value>classpath:jdbc.properties</value> </list> </property> </bean> <bean id="springContextHolder" class="com.hxrainbow.crm.util.SpringContextHolder"/> </beans>
spring-memcache.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:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
<bean id="memcachedPool" class="com.danga.MemCached.SockIOPool" factory-method="getInstance"
init-method="initialize" destroy-method="shutDown">
<property name="servers">
<list>
<value>${memcache.server}</value>
</list>
</property>
<property name="initConn">
<value>${memcache.initConn}</value>
</property>
<property name="minConn">
<value>${memcache.minConn}</value>
</property>
<property name="maxConn">
<value>${memcache.maxConn}</value>
</property>
<property name="maintSleep">
<value>${memcache.maintSleep}</value>
</property>
<property name="nagle">
<value>${memcache.nagle}</value>
</property>
<property name="socketTO">
<value>${memcache.socketTO}</value>
</property>
</bean>
<bean id="memcachedClient" class="com.danga.MemCached.MemCachedClient">
</bean>
</beans>
在配置文件中我们会看到memcache.properties，jdbc.properties和springContextHolder。
他们的内容分别是：
memcache.properties memcache.server=127.0.0.1:11211 memcache.initConn=20 memcache.minConn=10 memcache.maxConn=50 memcache.maintSleep=3000 memcache.nagle=false memcache.socketTO=3000
?
jdbc.properties
?
import java.util.Map;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
/**
*
* 以静态变量保存Spring ApplicationContext, 可在任何代码任何地方任何时候中取出ApplicaitonContext.
**/
public class SpringContextHolder implements ApplicationContextAware {
private static ApplicationContext applicationContext;
/**
*
* 实现ApplicationContextAware接口的context注入函数, 将其存入静态变量.
*/
public void setApplicationContext(ApplicationContext applicationContext) {
SpringContextHolder.applicationContext = applicationContext;
}
/**
*
* 取得存储在静态变量中的ApplicationContext.
*/
public static ApplicationContext getApplicationContext() {
checkApplicationContext();
return applicationContext;
}
/**
*
* 从静态变量ApplicationContext中取得Bean, 自动转型为所赋值对象的类型.
*/
@SuppressWarnings("unchecked")
public static <T> T getBean(String name) {
checkApplicationContext();
return (T) applicationContext.getBean(name);
}
/**
*
* 从静态变量ApplicationContext中取得Bean, 自动转型为所赋值对象的类型.
*
* 如果有多个Bean符合Class, 取出第一个.
*/
@SuppressWarnings({ "unchecked", "rawtypes" })
public static <T> T getBean(Class<T> clazz) {
checkApplicationContext();
Map beanMaps = applicationContext.getBeansOfType(clazz);
if (beanMaps != null && !beanMaps.isEmpty()) {
return (T) beanMaps.values().iterator().next();
} else {
return null;
}
}
private static void checkApplicationContext() {
if (applicationContext == null) {
throw new IllegalStateException(
"applicaitonContext未注入,请在applicationContext.xml中定义SpringContextHolder");
}
}
?配置文件我们写完了，下面我们开始测试使用。
?
做Bean类
import java.io.Serializable;
public class Bean implements Serializable{
/**
*
*/
private static final long serialVersionUID = 1L;
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String toString() {
String bean = "{name:"+this.getName()+",age:"+this.getAge()+"}";
return bean;
}
}
?
做测试使用类：
import java.util.ArrayList;
import java.util.List;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;
import com.danga.MemCached.MemCachedClient;
import com.danga.MemCached.SockIOPool;
public class MemcacheUtilTest {
public static void main(String[] args) {
ApplicationContext ctx = new FileSystemXmlApplicationContext(new String[]{"src/spring/spring-memcache.xml","src/spring/applicationContext-common.xml"});
SockIOPool s =SpringContextHolder.getBean("memcachedPool");
System.out.println("s="+s.getInitConn());
MemCachedClient mc = (MemCachedClient) ctx.getBean("memcachedClient");
//开始设值
mc.set("name", " string ");
mc.set("int", 5);
mc.set("double", 5.5);
Bean bean = new Bean();
bean.setAge(21);
bean.setName("名字");
mc.set("bean", bean);
List<Bean> data = new ArrayList<Bean>();
for(int i=0;i<3;i++)
{
Bean xbean = new Bean();
xbean.setAge(i);
xbean.setName("test_"+i);
data.add(xbean) ;
}
mc.set("data", data);
try{
Thread.sleep(50);
//开始取值
String name =(String) mc.get("name");
int i = (Integer) mc.get("int");
double d = (Double) mc.get("double") ;
Bean b = (Bean) mc.get("bean") ;
data = (List<Bean>) mc.get("data") ;
System.out.println("字符串："+name);
System.out.println("数字型："+i);
System.out.println("双精度："+d);
System.out.println("bean toString ："+b.toString());
System.out.println("data toString ："+data.toString());
//开始删除值
System.out.println("开始删除 ：》》》》》》》》》");
mc.delete("name");
mc.delete("int");
mc.delete("double");
mc.delete("bean");
String name_d =(String) mc.get("name");
int i_d = (Integer) mc.get("int");
double d_d = (Double) mc.get("double") ;
Bean b_d = (Bean) mc.get("bean") ;
System.out.println("字符串："+name_d);
System.out.println("数字型："+i_d);
System.out.println("双精度："+d_d);
System.out.println("bean toString ："+b_d.toString());
}catch(Exception e){
e.printStackTrace();
}
}
}
?运行一下，看看结果吧。具体可参考java_memcached-release_1.6\doc\HOWTO.txt.注意Bean要实现序列化。
?