memcached简介及java使用方法

最新推荐文章于 2024-07-20 12:59:04 发布

workman_lz

最新推荐文章于 2024-07-20 12:59:04 发布

阅读量365

点赞数

分类专栏：缓存 Memcached java缓存

缓存同时被 3 个专栏收录

1 篇文章 0 订阅

订阅专栏

Memcached

1 篇文章 0 订阅

订阅专栏

java缓存

1 篇文章 0 订阅

订阅专栏

今天在网上查了一下java缓存memcached，在度娘中真是千百度啊，自己留下做个笔记

一、概念

Memcached是danga.com（运营LiveJournal的技术团队）开发的一套分布式内存对象缓存系统，用于在动态系统中减少数据库负载，提升性能。

二、适用场合

1. 分布式应用。由于memcached本身基于分布式的系统，所以尤其适合大型的分布式系统。

2. 数据库前段缓存。数据库常常是网站系统的瓶颈。数据库的大并发量访问，常常造成网站内存溢出。当然我们也可以使用Hibernate的缓存机制。但memcached是基于分布式的，并可独立于网站应用本身，所以更适合大型网站进行应用的拆分。

3. 服务器间数据共享。举例来讲，我们将网站的登录系统、查询系统拆分为两个应用，放在不同的服务器上，并进行集群，那这个时候用户登录后，登录信息如何从登录系统服务器同步到查询系统服务器呢？这时候，我们便可以使用memcached，登录系统将登录信息缓存起来，查询系统便可以获得登录信息，就像获取本地信息一样。

三、不适用场合

那些不需要“分布”的，不需要共享的，或者干脆规模小到只有一台服务器的应用，memcached不会带来任何好处，相反还会拖慢系统效率，因为网络连接同样需要资源

四、安装

这里介绍windows环境的安装。

1. 下载memcache的windows稳定版，解压放某个盘下面，比如在c:\memcached

2. 在cmd下输入 'c:\memcached\memcached.exe -d install' 安装

3. 再输入： 'c:\memcached\memcached.exe -d start' 启动。

以后memcached将作为windows的一个服务每次开机时自动启动。这样服务器端已经安装完毕了。

五、java程序

User.java

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

UserDao.java

public class UserDao extends JdbcConnector {
// 定义全局变量
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 memcached_user where uids=?";

try {
// 获得数据库连接
conn = (Connection) this.getConn();
// 通过Connection对象创建PrepareStatement对象
pstmt = (PreparedStatement) conn.prepareStatement(sql);
// 设置SQL语句的参数
pstmt.setInt(1, uid);
// 执行查询，将查询结果赋给ResultSet对象
rs = (ResultSet) pstmt.executeQuery();
// 遍历指针
while (rs.next())
{
user = new User();
user.setUid(rs.getInt("uids"));
user.setUname(rs.getString("uname"));
user.setUpass(rs.getString("upass"));
}
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (SQLException e) {
e.printStackTrace();
}
return user;
}

/**
* 查询所有用户
* @return
*/
@SuppressWarnings("unchecked")
public List getUserList() {
// 创建ArrayList对象
List userList = new ArrayList();

// 创建SQL对象
String sql = "select * from memcached_user";

try {
conn = (Connection) this.getConn();
pstmt = (PreparedStatement) conn.prepareStatement(sql);
rs = (ResultSet) pstmt.executeQuery();
while (rs.next())
{
User user = new User();
user.setUid(rs.getInt("uids"));
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;
}
}

JdbcConnector.java

public class JdbcConnector {
// 定义数据库连接常量，此处用的oracle
private final static String DRIVER = "oracle.jdbc.driver.OracleDriver";
private final static String URL = "jdbc:oracle:thin:@(DESCRIPTION =(ADDRESS = (PROTOCOL = TCP)(HOST = localhost)(PORT = 1521))(CONNECT_DATA =(SERVER = DEDICATED)(SERVICE_NAME = orcl)))";
private final static String DBNAME = "orcl";
private final static String DBPASS = "admin";

/**
* 得到数据库连接
* @return
* @throws ClassNotFoundException
* @throws SQLException
*/
public Connection getConn()throws ClassNotFoundException,SQLException {
// 加载驱动
Class.forName(DRIVER);
// 通过DriverManager对象得到连接
Connection conn = DriverManager.getConnection(URL,DBNAME,DBPASS);
// 返回数据库连接
return conn;
}
}

MemcachedManager.java

import java.util.Date;

import com.danga.MemCached.MemCachedClient;
import com.danga.MemCached.SockIOPool;
import com.test.dao.UserDao;
import com.test.entity.User;
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;
}

/**
* 添加对象到缓存中，构成方法重载
* @param key
* @param value
* @return
*/
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", "rawtypes" })
// 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);
// }
// }
}