CODEWITHSUNDEEP
javamongodbservlets
and_apo
and_apo

Reputation: 1297

Using MongoDb with Java Servlet

I am facing an issue with using Mongo DB on a Java servlet.

My servlet has many methods(~20) of accessing the database for retrieving and adding data. A very brief example of one :

public static String getSomething(String s) {
  String json = "[]";
  JSONArray jsonArray = new JSONArray();
  DBCollection table;

  try {
    Mongo mongo = new Mongo("localhost", 27017);
    DB db = mongo.getDB( "myDb" );  
        BasicDBObject quoteQuery = new BasicDBObject("abc", abc);
    DBCursor cursor = table.find(quoteQuery);

    try {
      while(cursor.hasNext()) {
        jsonArray.put(cursor.next());
      }
    } finally {
      cursor.close();
    }

// ...

Now the problem is when this Java servlet is deployed in the linux server, it works fine for 10 days or so.

After that it crashes.

When I go to mongodb.log in my var/log directory I get the following repetitive output:

"connection refused because too many open connections"

I am not sure on where to edit things now or how to deal with this. I have tried to grow the limit of open connections in the server but still have the same results.

Any suggestions?

Upvotes: 2

Views: 5374

Answers (6)

Panky031
Panky031

Reputation: 443

As per above mentioned issue, its like you are creating the Mongo Object for every request.I will suggest to use the single Object through out your application.FOr this you can find the "MongoClient and connection pooling". MongoClient will handle connection pooling for you automatically.

mongoClient = new MongoClient(URI, connectionOptions);

Here the mongoClient object holds your connection pool, and will give your app connections as needed. You should strive to create this object once as your application initializes and re-use this object throughout your application to talk to your database. The most common connection pooling problem we see results from applications that create a MongoClient object way too often, sometimes on each database request. If you do this you will not be using your connection pool as each MongoClient object maintains a separate pool that is not being reused by your application.

Upvotes: -1

jarry_dk
jarry_dk

Reputation: 161

Arun Gupta ‏@arungupta

New sample shows how to use Mongo within a #JavaEE7 app: New sample to show basic usage of Mongo in a Java EE application

Upvotes: 0

Jhanvi
Jhanvi

Reputation: 5139

Your are creating connections in MongoDB, but you are not closing connections. For any database, it is very very important to close a connection, otherwise it will reach to its maximum limit and you wont be able to execute your program properly. Following code will be helpful i hope:

        public static String getSomething(String s) {
    String json = "[]";
    JSONArray jsonArray = new JSONArray();

    try {

        MongoClient mongoClient = new MongoClient("localhost", 27017);
        DB db = mongoClient.getDB("myDb");
        DBCollection collection = db.getCollection("NAME OF YOUR COLLECTION");
        BasicDBObject quoteQuery = new BasicDBObject("abc", "VARIABLE THAT YOU WANT TO FIND");

        DBCursor cursor = collection.find(quoteQuery);
        try {
            while (cursor.hasNext()) {
                jsonArray.put(cursor.next());
            }
        } finally {
            cursor.close();
        }
        mongoClient.close();
    } catch (Exception e) {
    }
    return jsonArray.toString();
}

In this code, 'MongoClient' is closed after its purpose is over.

Upvotes: 1

fvu
fvu

Reputation: 32953

You should create Mongo objects very sparingly, ideally even only one per classloader at any time. To reduce the number of Mongo objects you could create it in the servlet's init method and re-use that instance on every call.

EDIT: just had a look at our code, we manage the Mongo instance using a classic singleton class (and always fetch a Mongo using that class's getInstance() method) because if you have multiple servlets / entrypoints in your app just using init() will still generate one instance per servlet, and still won't satisfy the manual section cited by @FredClose

Upvotes: 3

hevi
hevi

Reputation: 2716

You may create the mongo object for once instead of creating it on each getSomething call.

public SomeClass{
static Mongo mongo = new Mongo("localhost", 27017);
static DB db = mongo.getDB( "myDb" );  

public static String getSomething(String s) {
String json = "[]";
JSONArray jsonArray = new JSONArray();
DBCollection table;
try {

BasicDBObject quoteQuery = new BasicDBObject("abc", abc);
DBCursor cursor = table.find(quoteQuery);

while(cursor.hasNext()) {
  jsonArray.put(cursor.next());

}

}

Actually the ideal case is not using static access at all and inject DB object from a central controller.

Upvotes: 1

Frederic Close
Frederic Close

Reputation: 9639

from the API doc : http://api.mongodb.org/java/2.11.3/

public class Mongo extends Object

A database connection with internal connection pooling. For most applications, you should have one Mongo instance for the entire JVM.

Upvotes: 11

Related Questions