memcached-Xmemcached

妖狐艹你老母 2022-07-16 15:57 105阅读 0赞

package memcache;

/\*\*  
\*  
\* XMemcached同样是基于java nio的客户端， java nio相比于传统阻塞io模型来说 有效率高（特别在高并发下）和资源耗费相对较少的优点。  
\* 传统阻塞IO为了提高效率，需要创建一定数量的连接形成连接池， 而nio仅需要一个连接即可（当然,nio也是可以做池化处理），  
\* 相对来说减少了线程创建和切换的开销，这一点在高并发下特别明显。  
\* 因此XMemcached与Spymemcached在性能都非常优秀，在某些方面（存储的数据比较小的情况下）  
\* Xmemcached比Spymemcached的表现更为优秀，具体可以看这个Java Memcached Clients Benchmark。  
\*  
\*/  
import java.io.IOException;  
import java.io.Serializable;  
import java.util.ArrayList;  
import java.util.HashMap;  
import java.util.List;  
import java.util.Map;  
import java.util.concurrent.TimeoutException;

import net.rubyeye.xmemcached.CASOperation;  
import net.rubyeye.xmemcached.MemcachedClient;  
import net.rubyeye.xmemcached.MemcachedClientBuilder;  
import net.rubyeye.xmemcached.XMemcachedClientBuilder;  
import net.rubyeye.xmemcached.exception.MemcachedException;  
import net.rubyeye.xmemcached.utils.AddrUtil;

public class Xmemcached \{  
private MemcachedClientBuilder builder = null;  
private MemcachedClient client = null;

public Xmemcached(String address, int[] weight) {
        builder = new XMemcachedClientBuilder(AddrUtil.getAddresses(address),
                weight);
        builder.setConnectionPoolSize(5);
        try {
            client = builder.build();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    
    public void set(String key, int exp, Object value) {
        try {
            if (!client.set(key, exp, value)) {
                System.err.println("set error, key is " + key + " value is "
                        + value);
            }
        } catch (TimeoutException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (MemcachedException e) {
            e.printStackTrace();
        }
    }
    
    public void delete(String key) {
        try {
            client.delete(key);
        } catch (TimeoutException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (MemcachedException e) {
            e.printStackTrace();
        }
    }
    
    public void update(String key, final Object value) {
        try {
            client.cas(key, 10, new CASOperation<Object>() {
                public int getMaxTries() {
                    return 1;
                }
    
                public Object getNewValue(long currentCAS, Object currentValue) {
                    return value;
                }
            });
        } catch (TimeoutException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (MemcachedException e) {
            e.printStackTrace();
        }
    }
    
    public Object get(String key) {
        try {
            return client.get(key);
        } catch (TimeoutException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (MemcachedException e) {
            e.printStackTrace();
        }
        return null;
    }
    
    public void addServer(String server, int port, int weight) {
        try {
            client.addServer(server, port, weight);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    
    public void removeServer(String hostList) {
        client.removeServer(hostList);
    }
    
    public static void main(String[] args) {
        // testCRUD();
        testSerObject();
    }
    
    public static void testCRUD() {
        String address = "arreat00:11211 arreat01:11211 arreat02:11211";
        Xmemcached cache = new Xmemcached(address, new int[] { 1, 1, 1 });
        cache.set("hello", 10, "test");
        System.out.println(cache.get("hello"));
        cache.update("hello", "ssss");
        System.out.println(cache.get("hello"));
        cache.delete("hello");
        System.out.println(cache.get("hello"));
    }
    
    public static void testSerObject() {
        String address = "127.0.0.1:11211";
        Xmemcached cache = new Xmemcached(address, new int[] { 1, 1, 1 });
        User user = new User();
        user.setId(1);
        user.setMobile("13564316073");
        user.setEmail("qianjc@unionpaysmart.com");
        user.setPasswd("ttt");
        user.setUserName("qianjc");
        List<String> asseat = new ArrayList<String>();
        asseat.add("asseat0");
        asseat.add("asseat1");
    
        Map<String, String> car = new HashMap<String, String>();
        car.put("car1", "val1");
        car.put("car2", "val2");
    
        user.setAsseat(asseat);
        user.setCar(car);
    
        user.setBook(buildBook(1, "memcached进阶", "smart出版"));
        user.setBooks(buildBooks());
    
        cache.set("user1", 0, user);
        System.out.println(cache.get("user1"));
    }
    
    public static Book buildBook(int id, String name, String pulish) {
        Book book = new Book();
        book.setId(id);
        book.setName(name);
        book.setPulish(pulish);
        return book;
    }
    
    public static List<Book> buildBooks() {
        List<Book> books = new ArrayList<Book>();
    
        for (int i = 0; i < 2; ++i) {
            books.add(buildBook(i, "memcached进阶" + i, "smart出版" + i));
        }
        return books;
    }

class User implements Serializable \{  
/\*\*  
\*  
\*/  
private static final long serialVersionUID = -5730809227893545651L;  
private int id;  
private List books;  
private Book book;  
private Map

memcached-Xmemcached

发表评论取消回复

还没有评论，来说两句吧...

相关阅读