Example: Java App Engine standard environment

This example is an App Engine application, written in Java, that writes some "hello world" greetings to a Bigtable table and reads them back. The application runs on Google Cloud in the App Engine standard environment. The application uses the Java 8 runtime. The code for this application is in the GitHub repository GoogleCloudPlatform/java-docs-samples, in the directory appengine-java8/bigtable.

Overview of the code sample

The code sample includes the following classes:

BigtableHelper, which provides a connection to Bigtable.
BigtableHelloWorld, which writes to and reads from Bigtable.

BigtableHelper

BigtableHelper provides a method to create a connection to Bigtable. It also caches the connection and provides a method that will retrieve the cached connection if it exists. Creating a connection is a relatively expensive operation, so as a best practice you should always create a single connection and reuse it.

publicstaticvoidconnect()throwsIOException{
if(PROJECT_ID==null||INSTANCE_ID==null){
if(sc!=null){
sc.log("environment variables BIGTABLE_PROJECT, and BIGTABLE_INSTANCE need to be defined.");
}
return;
}
connection=BigtableConfiguration.connect(PROJECT_ID,INSTANCE_ID);
}
/**
 * Get the shared connection to Cloud Bigtable.
 *
 * @return the connection
 */
publicstaticConnectiongetConnection(){
if(connection==null){
try{
connect();
}catch(IOExceptione){
if(sc!=null){
sc.log("connect ",e);
}
}
}
if(connection==null){
if(sc!=null){
sc.log("BigtableHelper-No Connection");
}
}
returnconnection;
}

BigtableHelloWorld

BigtableHelloWorld is used to write a series of greetings to Bigtable, read the greetings, and then display them. The class gets a Bigtable connection from BigtableHelper, uses the connection to get a Table object, which lets you to read and write values, then uses the Table object to write to and read from the table.


/**
 * A minimal application that connects to Cloud Bigtable using the native HBase API and performs
 * some basic operations.
 */
publicclass BigtableHelloWorld{
// Refer to table metadata names by byte array in the HBase API
privatestaticfinalbyte[]TABLE_NAME=Bytes.toBytes("Hello-Bigtable");
privatestaticfinalbyte[]COLUMN_FAMILY_NAME=Bytes.toBytes("cf1");
privatestaticfinalbyte[]COLUMN_NAME=Bytes.toBytes("greeting");
// Write some friendly greetings to Cloud Bigtable
privatestaticfinalString[]GREETINGS={
"Hello World!","Hello Cloud Bigtable!","Hello HBase!"
};
/**
 * Create a table -- first time only.
 *
 * @param connection to Bigtable
 * @return the status
 */
publicstaticStringcreate(Connectionconnection){
try{
// The admin API lets us create, manage and delete tables
Adminadmin=connection.getAdmin();
// Create a table with a single column family
HTableDescriptordescriptor=newHTableDescriptor(TableName.valueOf(TABLE_NAME));
descriptor.addFamily(newHColumnDescriptor(COLUMN_FAMILY_NAME));
admin.createTable(descriptor);
}catch(IOExceptione){
return"Table exists.";
}
return"Create table "+Bytes.toString(TABLE_NAME);
}
/** Connects to Cloud Bigtable, runs some basic operations and prints the results. */
publicstaticStringdoHelloWorld(){
StringBuilderresult=newStringBuilder();
// Create the Bigtable connection, use try-with-resources to make sure it gets closed
Connectionconnection=BigtableHelper.getConnection();
result.append(create(connection));
result.append("<br><br>");
try(Tabletable=connection.getTable(TableName.valueOf(TABLE_NAME))){
// Retrieve the table we just created so we can do some reads and writes
// Write some rows to the table
result.append("Write some greetings to the table<br>");
for(inti=0;i < GREETINGS.length;i++){
// Each row has a unique row key.
//
// Note: This example uses sequential numeric IDs for simplicity, but
// this can result in poor performance in a production application.
// Since rows are stored in sorted order by key, sequential keys can
// result in poor distribution of operations across nodes.
//
// For more information about how to design a Bigtable schema for the
// best performance, see the documentation:
//
// https://cloud.google.com/bigtable/docs/schema-design
StringrowKey="greeting"+i;
// Put a single row into the table. We could also pass a list of Puts to write a batch.
Putput=newPut(Bytes.toBytes(rowKey));
put.addColumn(COLUMN_FAMILY_NAME,COLUMN_NAME,Bytes.toBytes(GREETINGS[i]));
table.put(put);
}
// Get the first greeting by row key
StringrowKey="greeting0";
ResultgetResult=table.get(newGet(Bytes.toBytes(rowKey)));
Stringgreeting=Bytes.toString(getResult.getValue(COLUMN_FAMILY_NAME,COLUMN_NAME));
result.append("Get a single greeting by row key<br>");
result.append(" ");
result.append(rowKey);
result.append("= ");
result.append(greeting);
result.append("<br>");
// Now scan across all rows.
Scanscan=newScan();
result.append("Scan for all greetings:");
ResultScannerscanner=table.getScanner(scan);
for(Resultrow:scanner){
byte[]valueBytes=row.getValue(COLUMN_FAMILY_NAME,COLUMN_NAME);
result.append(" ");
result.append(Bytes.toString(valueBytes));
result.append("<br>");
}
}catch(IOExceptione){
result.append("Exception while running HelloWorld: "+e.getMessage()+"<br>");
result.append(e.toString());
returnresult.toString();
}
returnresult.toString();
}
}