hbase 0.20 client编程

import java.io.IOException;

import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.KeyValue;
import org.apache.hadoop.hbase.client.Get;
import org.apache.hadoop.hbase.client.HTable;
import org.apache.hadoop.hbase.client.Put;
import org.apache.hadoop.hbase.client.Result;
import org.apache.hadoop.hbase.client.ResultScanner;
import org.apache.hadoop.hbase.client.Scan;
import org.apache.hadoop.hbase.io.Cell;
import org.apache.hadoop.hbase.util.Bytes;

// Class that has nothing but a main.
// Does a Put, Get and a Scan against an hbase table.
public class MyClient {

    public static void main(String[] args) throws IOException {
        // You need a configuration object to tell the client where to connect.
        // When you create a HBaseConfiguration, it reads in whatever you've set
        // into your hbase-site.xml and in hbase-default.xml, as long as these can
        // be found on the CLASSPATH
        HBaseConfiguration config = new HBaseConfiguration();
        /*
         *  <name>hbase.zookeeper.property.clientPort</name>
        > > <value>2222</value>
         *   <name>hbase.rootdir</name>
        <value>hdfs://localhost:9000/hbase</value>
         */
        config.set("hbase.zookeeper.property.clientPort", "2181");
        //config.set("hbase.rootdir", "hdfs://localhost:9000/hbase");
        // This instantiates an HTable object that connects you to
        // the "myLittleHBaseTable" table.
        HTable table = new HTable(config, "url");

        // To add to a row, use Put.  A Put constructor takes the name of the row
        // you want to insert into as a byte array.  In HBase, the Bytes class has
        // utility for converting all kinds of java types to byte arrays.  In the
        // below, we are converting the String "myLittleRow" into a byte array to
        // use as a row key for our update. Once you have a Put instance, you can
        // adorn it by setting the names of columns you want to update on the row,
        // the timestamp to use in your update, etc.If no timestamp, the server
        // applies current time to the edits.
        table.setAutoFlush(true);
        Put p = new Put(Bytes.toBytes("sohu.com"));


        // To set the value you'd like to update in the row 'myRow', specify the
        // column family, column qualifier, and value of the table cell you'd like
        // to update.  The column family must already exist in your table schema.
        // The qualifier can be anything.  All must be specified as byte arrays as
        // hbase is all about byte arrays.  Lets pretend the table
        // 'myLittleHBaseTable' was created with a family 'myLittleFamily'.
        for(int i=0;i<100000;i++){
        p.add(Bytes.toBytes("sohu.com"), Bytes.toBytes("http://"+String.valueOf(i)+".sohu.com"),
                Bytes.toBytes("dataum"));
        }

        // Once you've adorned your Put instance with all the updates you want to
        // make, to commit it do the following (The HTable#put method takes the
        // Put instance you've been building and pushes the changes you made into
        // hbase)

        table.put(p);

        // Now, to retrieve the data we just wrote. The values that come back are
        // Result instances. Generally, a Result is an object that will package up
        // the hbase return into the form you find most palatable.
        Get g = new Get(Bytes.toBytes("host"));
        Result r = table.get(g);
        byte[] value = r.getValue(Bytes.toBytes("host:http://man.sohu.com"));
        // If we convert the value bytes, we should get back 'Some Value', the
        // value we inserted at this location.
        String valueStr = Bytes.toString(value);
        System.out.println("GET: " + valueStr);

        // Sometimes, you won't know the row you're looking for. In this case, you
        // use a Scanner. This will give you cursor-like interface to the contents
        // of the table.  To set up a Scanner, do like you did above making a Put
        // and a Get, create a Scan.  Adorn it with column names, etc.
        Scan s = new Scan();
        s.addColumn(Bytes.toBytes("sohu.com"));
        ResultScanner scanner = table.getScanner(s);
        try {
            // Scanners return Result instances.
            // Now, for the actual iteration. One way is to use a while loop like so:
            int i = 0;
            for (Result rr = scanner.next(); rr != null; rr = scanner.next()) {
                // print out the row we found and the columns we were looking for
                System.out.println(i++);

                rr.toString();
                for(KeyValue kv :rr.list()){
                    ///System.out.println("kv.getColumn()="+Bytes.toString(kv.getColumn()));
                    //System.out.println("kv.getFamily()="+Bytes.toString(kv.getFamily()));
                    System.out.print("kv.getQualifier()="+Bytes.toString(kv.getQualifier()));
                    //System.out.println("kv.getKey()="+Bytes.toString(kv.getKey()));
                    System.out.println(" value="+Bytes.toString(kv.getValue()));
                }
               // for (Cell cell : rr.getCellValues()) {
                //    System.out.println("Found row: " + Bytes.toString(cell.getValue())
               //             + Bytes.toString(cell.getValue()));
              //  }
            }

            // The other approach is to use a foreach loop. Scanners are iterable!
            // for (Result rr : scanner) {
            //   System.out.println("Found row: " + rr);
            // }
        } finally {
            // Make sure you close your scanners when you are done!
            // Thats why we have it inside a try/finally clause
            scanner.close();
        }
    }
}