• Home
• me.prettyprint
• hector-object-mapper
• 3.0-02
• source code
• HectorObjectMapper.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

me.prettyprint.hom.HectorObjectMapper Maven / Gradle / Ivy

package me.prettyprint.hom;


import java.beans.PropertyDescriptor;
import java.io.Serializable;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

import javax.persistence.DiscriminatorType;
import javax.persistence.Id;

import me.prettyprint.cassandra.serializers.BytesArraySerializer;
import me.prettyprint.cassandra.serializers.IntegerSerializer;
import me.prettyprint.cassandra.serializers.SerializerTypeInferer;
import me.prettyprint.cassandra.serializers.StringSerializer;
import me.prettyprint.hector.api.Keyspace;
import me.prettyprint.hector.api.Serializer;
import me.prettyprint.hector.api.beans.ColumnSlice;
import me.prettyprint.hector.api.beans.HColumn;
import me.prettyprint.hector.api.factory.HFactory;
import me.prettyprint.hector.api.mutation.Mutator;
import me.prettyprint.hector.api.query.QueryResult;
import me.prettyprint.hector.api.query.SliceQuery;
import me.prettyprint.hom.annotations.Column;
import me.prettyprint.hom.cache.HectorObjectMapperException;
import me.prettyprint.hom.converters.Converter;
import me.prettyprint.hom.converters.DefaultConverter;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * Maps a slice of HColumns to an object's
 * properties. See {@link #createObject(Object, ColumnSlice)} for more details.
 * 

 * As mentioned above all column names must be Strings - doesn't
 * really make sense to have other types when mapping to object properties.
 * 
 * @param 
 *          Type of object mapping to cassandra row
 * 
 * @author Todd Burruss
 */
public class HectorObjectMapper {
  private static Logger logger = LoggerFactory.getLogger(HectorObjectMapper.class);

  private static final int MAX_NUM_COLUMNS = 100;

  private int maxNumColumns = MAX_NUM_COLUMNS;
  private ClassCacheMgr cacheMgr;
  private KeyConcatenationStrategy keyConcatStrategy = new KeyConcatenationDelimiterStrategyImpl();
  private CollectionMapperHelper collMapperHelper = new CollectionMapperHelper();
  private ReflectionHelper reflectionHelper = new ReflectionHelper();

  public HectorObjectMapper(ClassCacheMgr cacheMgr) {
    this.cacheMgr = cacheMgr;
  }

  /**
   * Retrieve columns from cassandra keyspace and column family, instantiate a
   * new object of required type, and then map them to the object's properties.
   * 
   * @param 
   * 
   * @param keyspace
   * @param colFamName
   * @param pkObj
   * @return
   */
  public  T getObject(Keyspace keyspace, String colFamName, Object pkObj) {
    if (null == pkObj) {
      throw new IllegalArgumentException("object ID cannot be null or empty");
    }

    CFMappingDef cfMapDef = cacheMgr.getCfMapDef(colFamName, true);

    byte[] colFamKey = generateColumnFamilyKeyFromPkObj(cfMapDef, pkObj);

    SliceQuery q = HFactory.createSliceQuery(keyspace,
        BytesArraySerializer.get(), StringSerializer.get(), BytesArraySerializer.get());
    q.setColumnFamily(colFamName);
    q.setKey(colFamKey);

    // if no anonymous handler then use specific columns
    if (cfMapDef.isColumnSliceRequired()) {
      q.setColumnNames(cfMapDef.getSliceColumnNameArr());
    } else {
      q.setRange("", "", false, maxNumColumns);
    }

    QueryResult> result = q.execute();
    if (null == result || null == result.get()) {
      return null;
    }

    T obj = createObject(cfMapDef, pkObj, result.get());
    return obj;
  }

  /**
   * 
   * @param keyspace
   * @param obj
   * @return
   */
  public  T saveObj(Keyspace keyspace, T obj) {
    if (null == obj) {
      throw new IllegalArgumentException("object cannot be null");
    }
    Mutator m = HFactory.createMutator(keyspace, BytesArraySerializer.get());
    saveObj(keyspace, m, obj);
    m.execute();
    return obj;
  }

  /**
   * Persists the object collection using a single batch mutate. It is up to the
   * client to partition large collections appropriately so not to cause timeout
   * or buffer overflow issues. The objects can be heterogenous (mapping to
   * multiple column families, etc.)
   * 
   * @param keyspace
   * @param objColl
   * @return
   */
  public Collection saveObjCollection(Keyspace keyspace, Collection objColl) {
    Mutator m = HFactory.createMutator(keyspace, BytesArraySerializer.get());
    Collection retColl = saveObjCollection(keyspace, objColl, m);
    m.execute();
    return retColl;
  }

  public Collection saveObjCollection(Keyspace keyspace, Collection objColl, Mutator m) {
    if (null == objColl) {
      throw new IllegalArgumentException("object cannot be null");
    }
    if (objColl.isEmpty()) {
      return objColl;
    }

    for (Object obj : objColl) {
      saveObj(keyspace, m, obj);
    }
    return objColl;
  }

  private void saveObj(Keyspace keyspace, Mutator m, Object obj) {
    if (null == obj) {
      throw new IllegalArgumentException("object cannot be null");
    }

    @SuppressWarnings("unchecked")
    CFMappingDef