ava中使用memcache（asf-cache-2.*.jar） 带数据库

要在Java中使用MemCached技术需要以下几个jar文件：

· alisoft-xplatform-asf-cache-2.5.1.jar

· commons-logging.jar

· log4j-1.2.15.jar

同时还需要一个服务器软件：memcached-1.2.1-win32.zip

在测试时，必须首先运行服务器软件，将该服务器启动。

现在开始在编写测试程序，其原理是利用JDBC技术将数据从数据库中查询出来，再将查询出来的数据利用MemCached技术放入到缓存中，以便下次使用时不再与数据可直接交互，提高软件性能。

首先，创建一个Web Project工程，将以上三个jar文件加入到Webroot目录下的WEB-INF文件夹下的lib文件夹下；

其次，依次创建实体类、数据库访问类和查询类；如下：

实体类 User.java，该类必须实现序列化，代码如下：

package cn.cheng.entity;

import java.io.Serializable;

public class User implements Serializable {

private static final long serialVersionUID = -3896605600471191953L;

private int uid;

private String uname;

private String upass;

public int getUid() {

return uid;

}

public void setUid(int uid) {

this.uid = uid;

}

public String getUname() {

return uname;

}

public void setUname(String uname) {

this.uname = uname;

}

public String getUpass() {

return upass;

}

public void setUpass(String upass) {

this.upass = upass;

}

}

数据可访问基类 BaseDao.java，代码如下：

package cn.cheng.dao;

import java.sql.Connection;

import java.sql.DriverManager;

import java.sql.SQLException;

public class BaseDao {

// 定义数据库连接常量

private final static String DRIVER = "com.mysql.jdbc.Driver";

private final static String URL = "jdbc:mysql://localhost:3306/cheng";

private final static String DBNAME = "root";

private final static String DBPASS = "root";

/** 得到数据库连接 */

public Connection getConn() throwsClassNotFoundException,SQLException {

// 加载驱动

Class.forName(DRIVER);

// 通过DriverManager对象得到连接

Connection conn = DriverManager.getConnection(URL,DBNAME,DBPASS);

// 返回数据库连接

return conn;

}

}

数据查询类 UserDao.java，代码如下：

package cn.cheng.dao;

import java.sql.Connection;

import java.sql.PreparedStatement;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.util.ArrayList;

import java.util.List;

import cn.cheng.entity.User;

public class UserDao extends BaseDao {

// 定义全局变量

Connection conn = null;

PreparedStatement pstmt = null;

ResultSet rs = null;

/**

* 根据Id查询用户

* @param uid

* @return

*/

public User getUserById(int uid) {

// 创建User对象

User user = null;

// 创建SQL语句

String sql = "select *from tbl_user where uid=?";

try {

// 获得数据库连接

conn = this.getConn();

// 通过Connection对象创建PrepareStatement对象

pstmt = conn.prepareStatement(sql);

// 设置SQL语句的参数

pstmt.setInt(1, uid);

// 执行查询，将查询结果赋给ResultSet对象

rs = pstmt.executeQuery();

// 遍历指针

while (rs.next())

{

user = new User();

user.setUid(rs.getInt("uid"));

user.setUname(rs.getString("uname"));

user.setUpass(rs.getString("upass"));

}

} catch (ClassNotFoundException e) {

e.printStackTrace();

} catch (SQLException e) {

e.printStackTrace();

}

return user;

}

/**

* 查询所有用户

*/

@SuppressWarnings("unchecked")

public List getUserList() {

// 创建ArrayList对象

List userList = new ArrayList();

// 创建SQL对象

String sql = "select * fromtbl_user";

try {

conn = this.getConn();

pstmt = conn.prepareStatement(sql);

rs = pstmt.executeQuery();

while (rs.next())

{

User user = new User();

user.setUid(rs.getInt("uid"));

user.setUname(rs.getString("uname"));

user.setUpass(rs.getString("upass"));

userList.add(user);

}

} catch (ClassNotFoundException e) {

e.printStackTrace();

} catch (SQLException e) {

e.printStackTrace();

}

return userList;

}

}

最后编写测试类，利用MemCached技术将从数据库得到的数据存入到缓存中；

package cn.cheng.memcachedtest;

import java.util.Date;

import java.util.List;

import cn.cheng.dao.UserDao;

import cn.cheng.entity.User;

importcom.alisoft.xplatform.asf.cache.memcached.client.MemCachedClient;

importcom.alisoft.xplatform.asf.cache.memcached.client.SockIOPool;

public class MemcachedManager {

// 创建MemCachedClient全局对象

private static MemCachedClient mcc = new MemCachedClient();

static {

// 创建服务器列表及其权重

String[] servers = {"127.0.0.1:11211"};

Integer[] weights = {3};

// 创建Socket连接池对象

SockIOPool pool = SockIOPool.getInstance();

// 设置服务器信息

pool.setServers(servers);

pool.setWeights(weights);

pool.setFailover(true);

// 设置初始连接数、最小和最大连接数以及最大处理时间

pool.setInitConn(5);

pool.setMinConn(5);

pool.setMaxConn(250);

pool.setMaxIdle(1000*60*60*6);

// 设置主线程睡眠时间

pool.setMaintSleep(30);

// 设置TCP参数、连接超时等

pool.setNagle(false);

pool.setSocketTO(3000);

pool.setSocketConnectTO(0);

pool.setAliveCheck(true);

// 初始化连接池

pool.initialize();

// 压缩设置，超过指定大小（单位为K）的数据都会被压缩

mcc.setCompressEnable(true);

mcc.setCompressThreshold(64 * 1024);

}

protected MemcachedManager (){

}

// 受保护的对象

protected static MemcachedManager instance = new MemcachedManager();

/**

* 为受保护的对象提供一个公共的访问方法

*/

public static MemcachedManager getInstance () {

return instance;

}

/** 添加对象到缓存中，构成方法重载 */

public boolean add(String key,Object value) {

return mcc.add(key, value);

}

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

return mcc.add(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);

}

/**

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

*/

public Object get(String key) {

return mcc.get(key);

}

/**

* 利用MemCached测试将单个对象存入缓存，并从缓存中取出

*/

//  public static void main(String[] args) {

//      // 得到MemcachedManager实例

//     MemcachedManager cache = MemcachedManager.getInstance();

//     // 创建UserDao对象

//     UserDao userDao = new UserDao();

//     // 查询单个User对象

//     User user = userDao.getUserById(4);

//

//     // 将User对象添加到缓存中

//     cache.add("user", user.getUname());

//

//     // 将User对象从缓存中取出来

//     String uname = (String)cache.get("user");

//     System.out.println("从缓存中取出的对象为：" + uname);

//  }

/** 利用MemCached对象将集合存入缓存，并从缓存中取出 */

@SuppressWarnings("unchecked")

public static void main(String[] args) {

// 得到MemcachedManager实例

MemcachedManager cache = MemcachedManager.getInstance();

// 创建UserDao对象

UserDao userDao = new UserDao();

// 得到集合对象

List userList = userDao.getUserList();

// 创建User对象

User user = null;

for (int i=0; i<userList.size(); i++)

{

// 循环遍历集合对象

user = (User)userList.get(i);

user.getUid();

user.getUname();

user.getUpass();

// 存入缓存中

cache.add("userList" + i,user.getUname());

// 从缓存中取出

String uname = (String)cache.get("userList"+i);

System.out.println("从缓存中取得的集合为：" + uname);

}

}
}