如何在并发环境（是否有静态变量）中设计与数据库的http连接

Question

I am using dynamodb from amazon web services as my database. The client providd by AWS uses http to make the requests to the database. This code will be on a server which will accept requests from users and send it over to dynamodb. I had a few questions how to design this then.

Since this is a server accepting many requests I am using the async client http://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/dynamodbv2/AmazonDynamoDBAsyncClient.html instead of the sync because I don't want for every request to block and instead I will wait for a future to return (better performance). Is it best to make this client static?

public class Connection {

    AmazonDynamoDBAsyncClient client;
    static DynamoDB dynamoDB;

    public Connection(){

        client = new AmazonDynamoDBAsyncClient(new ProfileCredentialsProvider());
        dynamoDB = null;

    }

    public void setConnection(String endpoint){
        client.setEndpoint(endpoint);
        dynamoDB = new DynamoDB(client);
    }


    public DynamoDB getConnection(){
        return dynamoDB;
    }

}

Then to call this static variable from main:

public class Main{

    Connection c;
    DynamoDB con;

            public  Main() throws Exception {

                try {
          c = new Connection();
          c.setConnection("http://dynamodbserver:8000");
          con = c.getConnection(); 
          //Do stuff with the connection now
                    } catch (Exception e) {
                     System.err.println("Program failed:");
                     System.err.println(e.getMessage());
                 }

Is this a good approach? What will happen if two users are requesting to use the static variable at the same time (I am using a framework called vertx so this program will run on a single thread, but there will be multiple instances of this program)?

Answer 1

You should not set the connection as static member, Also the way you are setting endpoints of your connection is:

• not thread safe
• may lead to race condition

Endpoints should be setup at the time of AmazonDynamoDBAsyncClient construction and then this Async client should be used in the DynamoDB construction. Please also refer to the documentation .

Why don't you use the SDK provided with AWS for dynamoDb ? It will take care of connection management for you in a thread safe manner.

On a side note, If you still want to roll out your own solution for connection management, I would recommend that you use a Dependecy Injection framework. I would highly recommend google-guice .

Here is the sample code of DI through guice.

public class DynamoDBProvider implements Provider<DynamoDB> {
  // Notice that endpoint is set at the time of client construction and the
  // get() method provides an instance of DynamoDb.
  // In another configuration class, we define that DynamoDb will be
  // served under singleton scope, so you will have a single instance.
  private final AmazonDynamoDBAsyncClient asyncClient;

  @Inject
  public DatabaseTransactionLogProvider(
      ProfileCredentialsProvider creds,
      @Named("Endpoint") String endpoint) { 
    this.asyncClient = new AmazonDynamoDBAsyncClient(creds);
    // endpoint is a configuration so it must also be injected to the provider.
    this.setEndpoint(endPoint);
  }

  public DynamoDb get() {
    return new DynamoDB(asyncClient);
  }
}

This is how you ensure your connection instance is served as singleton.

public class DynamoDBModule extends AbstractModule {

    protected void configure() {
       bind(Dynamodb.class).toProvider(DynamoDbProvider.class).in(Singleton.class);
    }
}

Learning DI through guice or any other framework will require some effort but it will go aa long way in making your code maintainable and unit testable. Please be aware to utilize the benefits of DI, you will have to refactor your project so that all depedencies are injected.

Answer 2

static would be good since it is shared by all connection instance. but you can further improve the code by introducing singleton design pattern for connection class so that only one connection instance will be created and used for serve all the requests.