基于XMemcache 的分布式 Memcache的实现

最新推荐文章于 2016-04-09 12:58:08 发布
最新推荐文章于 2016-04-09 12:58:08 发布
阅读量2.1k 收藏
点赞数
分类专栏： MemCache
本文介绍了一种基于 XMemcached 的连接池实现方案，通过 MemcachedClientKeeper 类来保持连接并定期发送心跳包监测连接状态。文章详细展示了如何通过心跳逻辑调整节点状态，以及如何在一组服务器中进行数据的读写操作。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

MemcachedClientKeeper 完成对XMemcached连接的保持，并提供心跳 维护自身状态

Java代码 复制代码  收藏代码
  1. package com.iuwcity.memcached.group;   
  2.   
  3. import java.io.IOException;   
  4. import java.net.InetSocketAddress;   
  5. import java.util.Map;   
  6. import java.util.concurrent.Callable;   
  7. import java.util.concurrent.Executors;   
  8. import java.util.concurrent.ScheduledExecutorService;   
  9. import java.util.concurrent.TimeUnit;   
  10.   
  11. import net.rubyeye.xmemcached.XMemcachedClient;   
  12.   
  13. public class MemcachedClientKeeper {   
  14.        
  15.     public static final String OP_SUC = "0";   
  16.        
  17.     public static final String OP_FAL = "1";   
  18.   
  19.     private XMemcachedClient client;   
  20.        
  21.     private String host;   
  22.        
  23.     private int port;   
  24.   
  25.     private long breathTime = 5;   
  26.   
  27.     private long initalTime = 5;   
  28.        
  29.     private int breathBreakThreshold = 5; //心跳异常允许的次数   
  30.        
  31.     private int breathBreak = 0; //当前心跳异常次数   
  32.   
  33.     private int status = MemcachedGroup.READ_WRITE;   
  34.        
  35.     private int beforeStatus = status;   
  36.   
  37.     private BreathLogic breathLogic = new BreathLogic();   
  38.        
  39.     public PutLogic putLogic = new PutLogic("",0,"");   
  40.        
  41.     public GetLogic getLogic = new GetLogic("");   
  42.   
  43.     private ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);   
  44.        
  45.     private boolean isLaunched = false;   
  46.   
  47.     public MemcachedClientKeeper(final String host, final int port) throws IOException {   
  48.         this.host = host;   
  49.         this.port = port;   
  50.         this.client = new XMemcachedClient(host, port);   
  51.     }   
  52.   
  53.     public XMemcachedClient getClient() {   
  54.         return client;   
  55.     }   
  56.   
  57.     public long getBreathTime() {   
  58.         return breathTime;   
  59.     }   
  60.   
  61.     public void setBreathTime(long breathTime) {   
  62.         this.breathTime = breathTime;   
  63.     }   
  64.   
  65.     public long getInitalTime() {   
  66.         return initalTime;   
  67.     }   
  68.   
  69.     public void setInitalTime(long initalTime) {   
  70.         this.initalTime = initalTime;   
  71.     }   
  72.   
  73.     public int getStatus() {   
  74.         return status;   
  75.     }   
  76.   
  77.     public void setStatus(int status) {   
  78.         this.status = status;   
  79.     }   
  80.        
  81.        
  82.     public int getBreathBreakThreshold() {   
  83.         return breathBreakThreshold;   
  84.     }   
  85.   
  86.     public void setBreathBreakThreshold(int breathBreakThreshold) {   
  87.         this.breathBreakThreshold = breathBreakThreshold;   
  88.     }   
  89.   
  90.     public int getBreathBreak() {   
  91.         return breathBreak;   
  92.     }   
  93.   
  94.     public void setBreathBreak(int breathBreak) {   
  95.         this.breathBreak = breathBreak;   
  96.     }   
  97.   
  98.     /**  
  99.      * 启动  
  100.      */  
  101.     public void launch(){   
  102.         if(!isLaunched){   
  103.             scheduler.scheduleAtFixedRate(this.breathLogic, this.initalTime,   
  104.                     this.breathTime, TimeUnit.SECONDS);   
  105.             isLaunched = !isLaunched;   
  106.         }   
  107.     }   
  108.        
  109.     public BreathLogic getBreathLogic() {   
  110.         return breathLogic;   
  111.     }   
  112.   
  113.     public void setBreathLogic(BreathLogic breathLogic) {   
  114.         this.breathLogic = breathLogic;   
  115.     }   
  116.        
  117.   
  118.     public ScheduledExecutorService getScheduler() {   
  119.         return scheduler;   
  120.     }   
  121.   
  122.     public void setScheduler(ScheduledExecutorService scheduler) {   
  123.         this.scheduler = scheduler;   
  124.     }   
  125.        
  126.   
  127.     public String getHost() {   
  128.         return host;   
  129.     }   
  130.   
  131.     public void setHost(String host) {   
  132.         this.host = host;   
  133.     }   
  134.   
  135.     public int getPort() {   
  136.         return port;   
  137.     }   
  138.   
  139.     public void setPort(int port) {   
  140.         this.port = port;   
  141.     }   
  142.   
  143.     public int getBeforeStatus() {   
  144.         return beforeStatus;   
  145.     }   
  146.   
  147.     public void setBeforeStatus(int beforeStatus) {   
  148.         this.beforeStatus = beforeStatus;   
  149.     }   
  150.   
  151.   
  152.   
  153.     /**  
  154.      * 心跳逻辑  
  155.      *   
  156.      * @author xuchen  
  157.      *   
  158.      */  
  159.     public class BreathLogic implements Runnable {   
  160.   
  161.         public void run() {   
  162.             try {   
  163.                 Map<String,String> stat = client.stats(new InetSocketAddress(host,port));   
  164.                 System.out.println("breath : " + stat);   
  165.             } catch (Exception e) {   
  166.                 //心跳异常    
  167.                 breathBreak ++;   
  168.                 if(breathBreak >= breathBreakThreshold ){ //达到允许次数   
  169.                     breathBreak = 0;   
  170.                     //记录服务节点之前的状态   
  171.                     beforeStatus = status;   
  172.                     status = MemcachedGroup.NOT_READY;   
  173.                        
  174.                     //todo 发出报警   
  175.                 }   
  176.                 e.printStackTrace();   
  177.                 return ;   
  178.             }   
  179.             //判断如果服务器正常 则恢复到出现问题之前的状态   
  180.             if(MemcachedGroup.NOT_READY == status){   
  181.                 status = beforeStatus;   
  182.             }   
  183.         }   
  184.   
  185.     }   
  186.        
  187.     public class PutLogic implements Callable<Object> {   
  188.            
  189.         private String key ;   
  190.            
  191.         private int exp = 0;   
  192.            
  193.         private Object value;   
  194.            
  195.            
  196.         public String getKey() {   
  197.             return key;   
  198.         }   
  199.   
  200.         public void setKey(String key) {   
  201.             this.key = key;   
  202.         }   
  203.   
  204.         public int getExp() {   
  205.             return exp;   
  206.         }   
  207.   
  208.         public void setExp(int exp) {   
  209.             this.exp = exp;   
  210.         }   
  211.   
  212.         public Object getValue() {   
  213.             return value;   
  214.         }   
  215.   
  216.         public void setValue(Object value) {   
  217.             this.value = value;   
  218.         }   
  219.   
  220.         public PutLogic(final String key,final Object value){   
  221.             this(key,0,value);   
  222.         }   
  223.            
  224.         public PutLogic(final String key,final int exp,final Object value){   
  225.             this.key = key;   
  226.             this.exp = exp;   
  227.             this.value = value;   
  228.         }   
  229.   
  230.         public Object call() throws Exception {   
  231.             try {   
  232.                 if(client.add(key, exp, value)){   
  233.                     return OP_SUC + "|" + host + ":" + port;   
  234.                 }else {   
  235.                     return OP_FAL + "|" + host + ":" + port;   
  236.                 }   
  237.             }catch (Exception e){   
  238.                 e.printStackTrace();   
  239.                 return OP_FAL + "|" + host + ":" + port;   
  240.             }   
  241.         }   
  242.            
  243.     }   
  244.        
  245.     /**  
  246.      * @author xuchen  
  247.      *  
  248.      */  
  249.     public class GetLogic implements Callable<Object> {   
  250.            
  251.         private String key;   
  252.            
  253.         public String getKey() {   
  254.             return key;   
  255.         }   
  256.   
  257.         public void setKey(String key) {   
  258.             this.key = key;   
  259.         }   
  260.   
  261.            
  262.         public GetLogic(final String key){   
  263.             this.key = key;   
  264.         }   
  265.   
  266.         public Object call() throws Exception {   
  267.             return client.get(this.key);   
  268.         }   
  269.            
  270.     }   
  271.   
  272. }  
package com.iuwcity.memcached.group;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.util.Map;
import java.util.concurrent.Callable;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

import net.rubyeye.xmemcached.XMemcachedClient;

public class MemcachedClientKeeper {
	
	public static final String OP_SUC = "0";
	
	public static final String OP_FAL = "1";

	private XMemcachedClient client;
	
	private String host;
	
	private int port;

	private long breathTime = 5;

	private long initalTime = 5;
	
	private int breathBreakThreshold = 5; //心跳异常允许的次数
	
	private int breathBreak = 0; //当前心跳异常次数

	private int status = MemcachedGroup.READ_WRITE;
	
	private int beforeStatus = status;

	private BreathLogic breathLogic = new BreathLogic();
	
	public PutLogic putLogic = new PutLogic("",0,"");
	
	public GetLogic getLogic = new GetLogic("");

	private ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
	
	private boolean isLaunched = false;

	public MemcachedClientKeeper(final String host, final int port) throws IOException {
		this.host = host;
		this.port = port;
		this.client = new XMemcachedClient(host, port);
	}

	public XMemcachedClient getClient() {
		return client;
	}

	public long getBreathTime() {
		return breathTime;
	}

	public void setBreathTime(long breathTime) {
		this.breathTime = breathTime;
	}

	public long getInitalTime() {
		return initalTime;
	}

	public void setInitalTime(long initalTime) {
		this.initalTime = initalTime;
	}

	public int getStatus() {
		return status;
	}

	public void setStatus(int status) {
		this.status = status;
	}
	
	
	public int getBreathBreakThreshold() {
		return breathBreakThreshold;
	}

	public void setBreathBreakThreshold(int breathBreakThreshold) {
		this.breathBreakThreshold = breathBreakThreshold;
	}

	public int getBreathBreak() {
		return breathBreak;
	}

	public void setBreathBreak(int breathBreak) {
		this.breathBreak = breathBreak;
	}

	/**
	 * 启动
	 */
	public void launch(){
		if(!isLaunched){
			scheduler.scheduleAtFixedRate(this.breathLogic, this.initalTime,
					this.breathTime, TimeUnit.SECONDS);
			isLaunched = !isLaunched;
		}
	}
	
	public BreathLogic getBreathLogic() {
		return breathLogic;
	}

	public void setBreathLogic(BreathLogic breathLogic) {
		this.breathLogic = breathLogic;
	}
	

	public ScheduledExecutorService getScheduler() {
		return scheduler;
	}

	public void setScheduler(ScheduledExecutorService scheduler) {
		this.scheduler = scheduler;
	}
	

	public String getHost() {
		return host;
	}

	public void setHost(String host) {
		this.host = host;
	}

	public int getPort() {
		return port;
	}

	public void setPort(int port) {
		this.port = port;
	}

	public int getBeforeStatus() {
		return beforeStatus;
	}

	public void setBeforeStatus(int beforeStatus) {
		this.beforeStatus = beforeStatus;
	}



	/**
	 * 心跳逻辑
	 * 
	 * @author xuchen
	 * 
	 */
	public class BreathLogic implements Runnable {

		public void run() {
			try {
				Map<String,String> stat = client.stats(new InetSocketAddress(host,port));
				System.out.println("breath : " + stat);
			} catch (Exception e) {
				//心跳异常 
				breathBreak ++;
				if(breathBreak >= breathBreakThreshold ){ //达到允许次数
					breathBreak = 0;
					//记录服务节点之前的状态
					beforeStatus = status;
					status = MemcachedGroup.NOT_READY;
					
					//todo 发出报警
				}
				e.printStackTrace();
				return ;
			}
			//判断如果服务器正常 则恢复到出现问题之前的状态
			if(MemcachedGroup.NOT_READY == status){
				status = beforeStatus;
			}
		}

	}
	
	public class PutLogic implements Callable<Object> {
		
		private String key ;
		
		private int exp = 0;
		
		private Object value;
		
		
		public String getKey() {
			return key;
		}

		public void setKey(String key) {
			this.key = key;
		}

		public int getExp() {
			return exp;
		}

		public void setExp(int exp) {
			this.exp = exp;
		}

		public Object getValue() {
			return value;
		}

		public void setValue(Object value) {
			this.value = value;
		}

		public PutLogic(final String key,final Object value){
			this(key,0,value);
		}
		
		public PutLogic(final String key,final int exp,final Object value){
			this.key = key;
			this.exp = exp;
			this.value = value;
		}

		public Object call() throws Exception {
			try {
				if(client.add(key, exp, value)){
					return OP_SUC + "|" + host + ":" + port;
				}else {
					return OP_FAL + "|" + host + ":" + port;
				}
			}catch (Exception e){
				e.printStackTrace();
				return OP_FAL + "|" + host + ":" + port;
			}
		}
		
	}
	
	/**
	 * @author xuchen
	 *
	 */
	public class GetLogic implements Callable<Object> {
		
		private String key;
		
		public String getKey() {
			return key;
		}

		public void setKey(String key) {
			this.key = key;
		}

		
		public GetLogic(final String key){
			this.key = key;
		}

		public Object call() throws Exception {
			return client.get(this.key);
		}
		
	}

}

 

MemcachedGroupHandle 保持一组Keeper 简单的操作 put/get 

put方式只是遍历当前可写节点进行写操作

 

get方式也比较简单 对可读的节点 目前默认取第一个 进行读

 

Java代码 复制代码  收藏代码
  1. package com.iuwcity.memcached.group;   
  2.   
  3. import java.io.IOException;   
  4. import java.util.ArrayList;   
  5. import java.util.List;   
  6. import java.util.concurrent.ExecutorService;   
  7. import java.util.concurrent.Executors;   
  8. import java.util.concurrent.Future;   
  9.   
  10. import net.rubyeye.xmemcached.XMemcachedClient;   
  11.   
  12. public class MemcachedGroupHandle implements MemcachedGroup {   
  13.   
  14.     // FIX ME   
  15.     private List<MemcachedClientKeeper> serverKeepers = new ArrayList<MemcachedClientKeeper>();   
  16.   
  17.     private ExecutorService service = Executors.newCachedThreadPool();   
  18.   
  19.     public void addServer(final String host, final int port) throws IOException {   
  20.         MemcachedClientKeeper keeper = new MemcachedClientKeeper(host, port);   
  21.         this.addServer(keeper);   
  22.     }   
  23.   
  24.     public void addServer(MemcachedClientKeeper keeper) throws IOException {   
  25.         keeper.launch();   
  26.         this.serverKeepers.add(keeper);   
  27.     }   
  28.   
  29.     public void putByFuture(final String key, final int exp, final Object value) throws Exception {   
  30.   
  31.         List<Future<Object>> futures = new ArrayList<Future<Object>>();   
  32.   
  33.         // 遍历所有服务器进行写操作 此处有待优化   
  34.         for (MemcachedClientKeeper keeper : serverKeepers) {   
  35.             if (keeper.getStatus() != MemcachedGroup.NOT_READY && keeper.getStatus() != MemcachedGroup.READ_ONLY) {   
  36.                 keeper.putLogic.setKey(key);   
  37.                 keeper.putLogic.setExp(exp);   
  38.                 keeper.putLogic.setValue(value);   
  39.                 Future<Object> f = service.submit(keeper.putLogic);   
  40.                 futures.add(f);   
  41.             }   
  42.         }   
  43.   
  44.         for (Future<Object> f : futures) {   
  45.             if (f.get() != null) {   
  46.                 String result = f.get().toString();   
  47.                 if (result.startsWith(MemcachedClientKeeper.OP_FAL)) {   
  48.                     // 写失败操作   
  49.                 }   
  50.             }   
  51.         }   
  52.     }   
  53.        
  54.     /**  
  55.      * 遍历第一个可读节点即返回  
  56.      * @param key  
  57.      * @return  
  58.      * @throws Exception  
  59.      */  
  60.     public Object getByFuture(final String key) throws Exception {   
  61.   
  62.         // 遍历所有服务器进行写操作 此处有待优化   
  63.         for (MemcachedClientKeeper keeper : serverKeepers) {   
  64.             if (keeper.getStatus() != MemcachedGroup.NOT_READY && keeper.getStatus() != MemcachedGroup.WRITE_ONLY) {   
  65.                 keeper.getLogic.setKey(key);   
  66.                 Future<Object> f = service.submit(keeper.getLogic);   
  67.                 return f.get();   
  68.             }   
  69.         }   
  70.         return null;   
  71.     }   
  72.        
  73.     /**  
  74.      * 遍历第一个可读节点即返回  
  75.      * @param key  
  76.      * @return  
  77.      * @throws Exception  
  78.      */  
  79.     public Object get(final String key) throws Exception {   
  80.   
  81.         // 遍历所有服务器进行写操作 此处有待优化   
  82.         for (MemcachedClientKeeper keeper : serverKeepers) {   
  83.             if (keeper.getStatus() != MemcachedGroup.NOT_READY && keeper.getStatus() != MemcachedGroup.WRITE_ONLY) {   
  84.                 return keeper.getClient().get(key);   
  85.             }   
  86.         }   
  87.         return null;   
  88.     }   
  89.   
  90.     public void put(final String key, final int exp, final Object value) throws Exception {   
  91.   
  92.         // 遍历所有服务器进行写操作 此处有待优化   
  93.         for (MemcachedClientKeeper keeper : serverKeepers) {   
  94.             if (keeper.getStatus() != MemcachedGroup.NOT_READY && keeper.getStatus() != MemcachedGroup.READ_ONLY) {   
  95.                 XMemcachedClient client = keeper.getClient();   
  96.                 if(client.add(key, exp, value)){   
  97.                     //todo写异常   
  98.                        
  99.                 }   
  100.                    
  101.             }   
  102.         }   
  103.     }   
  104.   
  105.     public ExecutorService getService() {   
  106.         return service;   
  107.     }   
  108.   
  109.     public void setService(ExecutorService service) {   
  110.         this.service = service;   
  111.     }   
  112.   
  113. }  
package com.iuwcity.memcached.group;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

import net.rubyeye.xmemcached.XMemcachedClient;

public class MemcachedGroupHandle implements MemcachedGroup {

	// FIX ME
	private List<MemcachedClientKeeper> serverKeepers = new ArrayList<MemcachedClientKeeper>();

	private ExecutorService service = Executors.newCachedThreadPool();

	public void addServer(final String host, final int port) throws IOException {
		MemcachedClientKeeper keeper = new MemcachedClientKeeper(host, port);
		this.addServer(keeper);
	}

	public void addServer(MemcachedClientKeeper keeper) throws IOException {
		keeper.launch();
		this.serverKeepers.add(keeper);
	}

	public void putByFuture(final String key, final int exp, final Object value) throws Exception {

		List<Future<Object>> futures = new ArrayList<Future<Object>>();

		// 遍历所有服务器进行写操作 此处有待优化
		for (MemcachedClientKeeper keeper : serverKeepers) {
			if (keeper.getStatus() != MemcachedGroup.NOT_READY && keeper.getStatus() != MemcachedGroup.READ_ONLY) {
				keeper.putLogic.setKey(key);
				keeper.putLogic.setExp(exp);
				keeper.putLogic.setValue(value);
				Future<Object> f = service.submit(keeper.putLogic);
				futures.add(f);
			}
		}

		for (Future<Object> f : futures) {
			if (f.get() != null) {
				String result = f.get().toString();
				if (result.startsWith(MemcachedClientKeeper.OP_FAL)) {
					// 写失败操作
				}
			}
		}
	}
	
	/**
	 * 遍历第一个可读节点即返回
	 * @param key
	 * @return
	 * @throws Exception
	 */
	public Object getByFuture(final String key) throws Exception {

		// 遍历所有服务器进行写操作 此处有待优化
		for (MemcachedClientKeeper keeper : serverKeepers) {
			if (keeper.getStatus() != MemcachedGroup.NOT_READY && keeper.getStatus() != MemcachedGroup.WRITE_ONLY) {
				keeper.getLogic.setKey(key);
				Future<Object> f = service.submit(keeper.getLogic);
				return f.get();
			}
		}
		return null;
	}
	
	/**
	 * 遍历第一个可读节点即返回
	 * @param key
	 * @return
	 * @throws Exception
	 */
	public Object get(final String key) throws Exception {

		// 遍历所有服务器进行写操作 此处有待优化
		for (MemcachedClientKeeper keeper : serverKeepers) {
			if (keeper.getStatus() != MemcachedGroup.NOT_READY && keeper.getStatus() != MemcachedGroup.WRITE_ONLY) {
				return keeper.getClient().get(key);
			}
		}
		return null;
	}

	public void put(final String key, final int exp, final Object value) throws Exception {

		// 遍历所有服务器进行写操作 此处有待优化
		for (MemcachedClientKeeper keeper : serverKeepers) {
			if (keeper.getStatus() != MemcachedGroup.NOT_READY && keeper.getStatus() != MemcachedGroup.READ_ONLY) {
				XMemcachedClient client = keeper.getClient();
				if(client.add(key, exp, value)){
					//todo写异常
					
				}
				
			}
		}
	}

	public ExecutorService getService() {
		return service;
	}

	public void setService(ExecutorService service) {
		this.service = service;
	}

}

 

还有个接口类 方法定义没家进去 里边还有很多FIXME TODO 主要看看大家的看法 听说XMemcached 的作者要加入集群功能了 首先对此表示非常的感谢

 

Java代码 复制代码  收藏代码
  1. package com.iuwcity.memcached.group;   
  2.   
  3. public interface MemcachedGroup {   
  4.        
  5.     public static final int READ_ONLY = 1;   
  6.        
  7.     public static final int WRITE_ONLY = 2;   
  8.        
  9.     public static final int READ_WRITE = 3;   
  10.        
  11.     public static final int NOT_READY = 4;   
  12.        
  13.     public static final int WRITE_NO_READ = 5;   
  14.        
  15. }  
package com.iuwcity.memcached.group;

public interface MemcachedGroup {
	
	public static final int READ_ONLY = 1;
	
	public static final int WRITE_ONLY = 2;
	
	public static final int READ_WRITE = 3;
	
	public static final int NOT_READY = 4;
	
	public static final int WRITE_NO_READ = 5;
	
}

 

公司要求可能要用到集群 自己无聊写了一个 与ali的机群客户端一起测试过 由于是基于XMemcached 所以在多线程下速度相对ali较高 

 

欢迎大家给点看法

 

附件里有写代码是没用的 不用看 就这三类有用

memcache的分布式缓存问题
sparkliang的专栏
10-18 6231
<br />有关使用memcache做分布式缓存的方案，简单写下来，仅供参考。<br /> <br />memcache是优异的缓存解决方案，很多项目都有使用。<br /> memcache服务本身并不具备分布式缓存的能力，它提供的就是对{key, value}对的访问能力，分布式的能力则完全来自于客户端。基于consistent hashing算法的分布式缓存<br />现在有不少memcache的客户端lib采用consistent hashing作为分布式算法，采用consistent hashin
基于redis分布式缓存实现
springML的博客
07-25 945
第一：Redis 是什么？ Redis是基于内存、可持久化的日志型、Key-Value数据库 高性能存储系统，并提供多种语言的API. 第二：出现背景 数据结构(Data Structure)需求越来越多, 但memcache中没有, 影响开发效率 性能需求, 随着读操作的量的上升需要解决，经历的过程有:  数据库读写分离(M/S)–&gt;数据库使用多个Slave–&gt;增加Cach...
Xmemcached一个java实现的分布式缓存
03-30
Xmemcached一个java实现的分布式缓存Xmemcached一个java实现的分布式缓存Xmemcached一个java实现的分布式缓存Xmemcached一个java实现的分布式缓存
XMemcached使用
lgh1117的专栏
08-29 4254
Xmemcached  一、 XMemcached 简介  XMemcached 是一个新 java memcached client 。也许你还不知道 memcached 是什么？可以先看看这里。简单来说， Memcached  是一个高性能的分布式内存对象的 key-value 缓存系统，用于动态 Web 应用以减轻数据库负载，现在也有很多人将它作为内存式数据库在使用， memca
用xmemcache作为JPA(Hibernate实现)二级缓存
suhuanzheng7784877的专栏
06-30 242
1.  持久层的缓存 Hibernate中提供了两级Cache，第一级别的缓存是Session级别的缓存，它是属于事务范围的缓存。这一级别的缓存由hibernate自身进行管理的，一般情况下无需进行干预，默认一级缓存也是打开的；第二级别的缓存是SessionFactory级别的缓存，它是属于进程范围或群集范围的缓存。这一级别的缓存比较重量级，可以进行配置和更改，并且可以动态加载和卸载。 Hibe...
xmemcache api
08-09
xmemcache api 内容较为详细 方便开发
PHP实现分布式memcache设置web集群session同步的方法
10-18
主要介绍了PHP实现分布式memcache设置web集群session同步的方法,结合实例形式分析了php设置与使用memcache实现web集群session同步的相关操作技巧与注意事项,需要的朋友可以参考下
ThinkPHP 3.1.2实现分布式Memcache缓存解决方案
由于ThinkPHP 3.1.2版本默认不支持分布式Memcache配置，需要对官方提供的缓存类库进行改造，以实现分布式缓存的功能。改造过程通常包括以下几个步骤： 1. 修改`CacheMemcache.class.php`文件，实现分布式Memcache...
thinkPHP实现MemCache分布式缓存功能
12-19
通过这种方式，我们可以利用ThinkPHP实现的MemCache分布式缓存功能，不仅提升了应用性能，还增强了系统的可靠性。对于大型或高并发的Web应用来说，这是必不可少的优化手段。同时，理解如何配置和使用分布式缓存也能...
基于MemCache的分布式扩展算法.pdf
08-09
【基于MemCache的分布式扩展算法】是针对互联网高速发展背景下，传统关系型数据库无法满足高并发读写需求的问题而提出的解决方案。随着Web2.0和移动互联网的爆发，NoSQL数据库，特别是基于Key-Value模型的缓存关系...
xmemcache与SPRING整合
09-26
如何基于Spring进行配置memcache及开发使用
Java的开源高性能memcached客户端XMemcached.zip
07-19
Xmemcached是基于java nio实现的高性能可扩展的memcached客户端。它的主要特点： 高性能，稳定可靠，已经在众多公司的众多项目里得到应用。 功能完备：客户端分布式、权重、最新最完整的协议支持。 可扩展，易于集成 可动态增删memached节点 客户端操作统计 NIO连接池 等等，更多信息请见wiki文档。 标签：XMemcached
xmemcached 中文开发手册
12-02
xmemcached中文开发手册，提供的版本较老，但针对2.0的版本次文档同样适用，可以入门
memcache架构图
01-19
这是我搜集的memcache架构图的文件夹，里面汇聚了许多经典的例子
xmemcached-1.4.3.jar
05-19
xmemcached-1.4.3.jar
Spring集成memcache（二）xmemcache
tom_seed的专栏
08-14 333
xmemcache是国内开发的jar包，，与Spring集成也比较简单，步骤如下： 1.添加xmemcache.jar包至工程中； 2.在web.xml文件中添加配置 &lt;context-param&gt; &lt;param-name&gt;contextConfigLocation&lt;/param-name&gt; &lt;param-value&gt; ...
Spring使用注解式@Cache集成xmemcache
Alec‘s blog
06-05 519
转自：http://tom-seed.iteye.com/blog/2104416 需要注意的是扩展支持注解需要Spring AOP的支持，需要导入相应的jar包： 1.aopalliance-1.0.jar 2.aopalliance-alpha1.jar 3.slf4j-api-1.7.5.jar 其中slf4j-api-1.7.5.jar提供的是日志的接口规范，如果工程目录下使用...
XMemcached客户端序列化方式
xiemingmei的专栏
03-18 288
XMemcached客户端序列化方式 默认为SerializingTranscoder 见XMemcachedClientBuilder的代码： Transcoder transcoder = new SerializingTranscoder(); 也可使用Kryo序列化, 但有bug, 数据类新老版本不兼容。 最优选Hessian序列化, 数据类新老版本兼容。...
Java之XMemcached使用及源码详解
q243021856的专栏
04-09 576
前言       本文主要讲述如何使用XMemcached客户端与Memcached服务端进行交互。通过XMemcached的API调用与Memcached的set/get命令对比及跟踪XMemcached源码，使大家对XMemcached的API有更深层次的理解，能够从底层上去了解其工作原理，从而能在项目中进行一些针对性的接口封闭及优化工作。  是叫Memcache还是Memcach
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值