Cassandra Hector版DAO

cassandra所有客户端：http://wiki.apache.org/cassandra/ClientOptions

Astyanax号称Hector的son，api看上去挺诱人，可惜无全包下载，工程又是maven(不喜欢maven)。Hector看上去不错，其它未知，懒得折腾了，就抓个Hector吧。

参考Hector例子：me.prettyprint.cassandra.examples.ExampleDaoV2

package ***;

import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import me.prettyprint.cassandra.serializers.AbstractSerializer;
import me.prettyprint.cassandra.serializers.StringSerializer;
import me.prettyprint.cassandra.service.CassandraHostConfigurator;
import me.prettyprint.cassandra.service.KeyIterator;
import me.prettyprint.hector.api.Cluster;
import me.prettyprint.hector.api.Keyspace;
import me.prettyprint.hector.api.Serializer;
import me.prettyprint.hector.api.beans.HColumn;
import me.prettyprint.hector.api.beans.Rows;
import me.prettyprint.hector.api.ddl.ColumnFamilyDefinition;
import me.prettyprint.hector.api.ddl.KeyspaceDefinition;
import me.prettyprint.hector.api.exceptions.HectorException;
import me.prettyprint.hector.api.factory.HFactory;
import me.prettyprint.hector.api.mutation.Mutator;
import me.prettyprint.hector.api.query.ColumnQuery;
import me.prettyprint.hector.api.query.MultigetSliceQuery;
import me.prettyprint.hector.api.query.QueryResult;

/**
 * 
 * @author zzf
 * 
 *  
 */
public class CassandraHectorGateWay {
	private final String name;
	private final Cluster cluster;
	private final String keyspace;
	private final Keyspace keyspaceObj;
	private Serializer nameSerializer = StringSerializer.get();

	public CassandraHectorGateWay(String keyspace, String hostIps) {
		this(keyspace, hostIps, null);
	}

	public CassandraHectorGateWay(String keyspace, String hostIps,
			Map<String, String> credentials) {
		name = "Cluster-" + hostIps.hashCode();
		cluster = getOrCreateCluster(name, hostIps, credentials);
		this.keyspace = keyspace;
		keyspaceObj = getOrCreateKeyspace(keyspace);
	}

	public Serializer getNameSerializer() {
		return nameSerializer;
	}

	public void setNameSerializer(Serializer nameSerializer) {
		this.nameSerializer = nameSerializer;
	}

	/**
	 * 获取集群对象(不存在则)
	 * 
	 * @param clusterName
	 *            给获取集群的命名(作用范围只在客户端，给已经获取的Cluster实例命名，与服务端的集群服务器命名无任何关系)
	 * @param hostIps
	 *            集群机器的集合，多个用逗号分割，格式：{ip:port,ip:port,...}
	 * @param credentials
	 *            验权属性{username:xxx,password:xxx}
	 */
	private Cluster getOrCreateCluster(String clusterName, String hostIps,
			Map<String, String> credentials) {
		// 注意，这里的create只是创建客户端的“幻影”(相当于rpc的interface)，然后给这个集群命名。
		return HFactory.getOrCreateCluster(clusterName,
				new CassandraHostConfigurator(hostIps), credentials);
	}

	private Keyspace getOrCreateKeyspace(String keyspace) {
		boolean exists = false;
		List<KeyspaceDefinition> ksList = cluster.describeKeyspaces();
		for (KeyspaceDefinition ks : ksList) {
			if (keyspace.equals(ks.getName())) {
				exists = true;
				break;
			}
		}
		if (!exists) {
			// 服务端创建真实的keyspace
			// cluster.addKeyspace(new ThriftKsDef(keyspace,
			// "org.apache.cassandra.locator.SimpleStrategy", 1,
			// new ArrayList<ColumnFamilyDefinition>()));
			// replicationFactor数=可用的集群节点数。
			KeyspaceDefinition ks_def = HFactory.createKeyspaceDefinition(
					keyspace, "org.apache.cassandra.locator.SimpleStrategy",
					cluster.getConnectionManager().getActivePools().size(),
					new ArrayList<ColumnFamilyDefinition>());
			cluster.addKeyspace(ks_def, true);
		}
		// 客户端幻影
		return HFactory.createKeyspace(keyspace, cluster);
	}

	public void ensureColumnFamily(String family) {
		List<ColumnFamilyDefinition> list = cluster.describeKeyspace(keyspace)
				.getCfDefs();
		boolean exists = false;
		for (ColumnFamilyDefinition col : list) {
			if (family.equals(col.getName())) {
				exists = true;
				break;
			}
		}
		if (!exists) {
			ColumnFamilyDefinition cfDef = HFactory
					.createColumnFamilyDefinition(keyspace, family);
			cluster.addColumnFamily(cfDef, true);
		}
	}

	public <K> void insert(K key, Object value, String column, String family,
			Serializer<K> keySerializer, Serializer valueSerializer) {
		HFactory.createMutator(keyspaceObj, keySerializer).insert(
				key,
				family,
				HFactory.createColumn(column, value, nameSerializer,
						valueSerializer));
	}

	public <K> void insertMulti(Map<K, Object> keyValues, String column,
			String family, Serializer<K> keySerializer,
			Serializer valueSerializer) {
		Mutator<K> m = HFactory.createMutator(keyspaceObj, keySerializer);
		for (Map.Entry<K, Object> keyValue : keyValues.entrySet()) {
			m.addInsertion(
					keyValue.getKey(),
					family,
					HFactory.createColumn(column, keyValue.getValue(),
							keyspaceObj.createClock(), nameSerializer,
							valueSerializer));
		}
		m.execute();
	}

	public <K> Object get(final K key, String column, String family,
			Serializer<K> keySerializer, Serializer valueSerializer)
			throws HectorException {
		ColumnQuery<K, String, Object> q = HFactory.createColumnQuery(
				keyspaceObj, keySerializer, nameSerializer, valueSerializer);
		QueryResult<HColumn<String, Object>> r = q.setKey(key).setName(column)
				.setColumnFamily(family).execute();
		HColumn<String, Object> c = r.get();
		return c == null ? null : c.getValue();
	}

	public <K> Map<K, Object> getMulti(String column, String family,
			Serializer<K> keySerializer, Serializer valueSerializer, K... keys) {
		MultigetSliceQuery<K, String, Object> q = HFactory
				.createMultigetSliceQuery(keyspaceObj, keySerializer,
						nameSerializer, valueSerializer);
		q.setColumnFamily(family);
		q.setKeys(keys);
		q.setColumnNames(column);
		QueryResult<Rows<K, String, Object>> r = q.execute();
		Rows<K, String, Object> rows = r.get();
		Map<K, Object> ret = new HashMap<K, Object>(keys.length);
		for (K k : keys) {
			HColumn<String, Object> c = rows.getByKey(k).getColumnSlice()
					.getColumnByName(column);
			if (c != null && c.getValue() != null) {
				ret.put(k, c.getValue());
			}
		}
		return ret;
	}

	public <K> void delete(String column, String family,
			Serializer<K> keySerializer, K... keys) {
		Mutator<K> m = HFactory.createMutator(keyspaceObj, keySerializer);
		for (K key : keys) {
			m.addDeletion(key, family, column, nameSerializer);
		}
		m.execute();
	}

	public <K> Iterator<K> keyIterator(String family,
			AbstractSerializer<K> serializer) {
		return new KeyIterator(keyspaceObj, family, serializer).iterator();
	}

	public Keyspace getKeyspace() {
		return keyspaceObj;
	}

	@Override
	public String toString() {
		return name;
	}

	public static void main(String[] args) {
		CassandraHectorGateWay ch = new CassandraHectorGateWay("myKeyspace",
				"localhost:9160");
		String family = "myFamily";
		ch.ensureColumnFamily(family);

		ch.insert("keyAAA", "valueAAA" + new Date(), "ColumnAAA", family,
				StringSerializer.get(), StringSerializer.get());
		ch.insert("key1", "value1" + new Date(), "Column1", family,
				StringSerializer.get(), StringSerializer.get());
		ch.insert("key1", "value##1", "Column##1", family,
				StringSerializer.get(), StringSerializer.get());
		System.out.println(ch.get("key1", "Column1", family,
				StringSerializer.get(), StringSerializer.get()));
		System.out.println(ch.get("key1", "Column##1", family,
				StringSerializer.get(), StringSerializer.get()));
		System.out.println("列出所有key:");
		for (Iterator<String> iter = ch.keyIterator(family,
				StringSerializer.get()); iter.hasNext();) {
			System.out.println(iter.next());
		}
	}
}

查询比较麻烦，不想折腾。

常用的做法是查询部分属性存放在关系数据表，大值存放于cassandra，自定义key保持关联逻辑。

【资源】
apache-cassandra-1.0.7
bin
http://mirror.bit.edu.cn/apache//cassandra/1.0.7/apache-cassandra-1.0.7-bin.tar.gz
src
http://labs.mop.com/apache-mirror//cassandra/1.0.7/apache-cassandra-1.0.7-src.tar.gz
配置参数说明
http://www.cnblogs.com/gpcuster/archive/2010/11/12/1875388.html

hector1.03
bin
https://github.com/rantav/hector/downloads
src
https://nodeload.github.com/rantav/hector/zipball/master
doc
http://www.datastax.com/sites/default/files/hector-v2-client-doc.pdf

cassandra集群管理器：datastax-community
http://downloads.datastax.com/community/datastax-community-64bit.msi