Re: [jersey-dev] [External] : client lifecycle question

[Jan Supol <jan.supol@xxxxxxxxxx>]

Hi John,

>From the top of my head, I'd say closing the client at point A nor B will work. The client should not be closed before the response is read, closing the client will drop Jersey runtime classes required to read the response properly. So closing it at point A or B could work or might not work, depending on whether the garbage collection took place or when the thread invoking the InvocationCallback will process it.

Note that the client does not need to be closed after a response, it could be reused for a new request.

The client itself is a lightweight object, but it keeps WeakReferences to heavy runtime objects. Closing the client makes sure the heavy runtime objects are released. However, Jersey tries to release the heavy objects on its own, when not needed (garbage collected). In some cases, however, the users keep references to Jersey internal objects, such as ClientResponse which prevents the proper garbage collection (and resource release). The client is better to be closed, then. In an ideal situation not closing the client should not cause leaking. I have seen more issues caused by not closing the Response.

HTH,

Jan

---

From: jersey-dev <jersey-dev-bounces@xxxxxxxxxxx> on behalf of John Calcote <john.calcote@xxxxxxxxx>
Sent: Saturday, May 21, 2022 1:25 AM
To: jersey-dev@xxxxxxxxxxx <jersey-dev@xxxxxxxxxxx>
Subject: [External] : [jersey-dev] client lifecycle question

 

Hello Jersey developers,

I have a question regarding when a client may be closed:

Client client = ClientBuilder.newBuilder()...<setup additional attributes>...build();

...

client.target(baseUri)
   .path(OSVS_CGC).path(sessionId.toString()).path(UNLOCK)
   .request()
   .async()
   .put(Entity.entity(req, MediaType.APPLICATION_JSON), new InvocationCallback<Response>() {

       @Override
       public void completed(Response response) {
           client.close();                   <---- B
           response.getStatus();
           SomeClass sc = response.readEntity(SomeClass.class);
           // process response
           ...
           client.close();                   <---- C
       }

       @Override
       public void failed(Throwable t) {
           client.close();                   <---- B
           // handle failure
           ...
           client.close();                   <---- C
       }
});

client.close();                              <---- A

Please, please, please do not rake me over the coals for closing my client right after using it once. That is not the point of this question. (I've already been through that ringer with some jackass over on stackoverflow - I finally had to delete my question over there because he hijacked it for his own selfish prideful purposes.)

This example is simplistic on purpose. In reality my code doesn't call close(), but rather, merely reduces the reference count on the client. The client cache also has a reference that keeps it alive for the life of the process. When the cache finally shuts down, it releases its reference, and if anyone is using the client at that moment, their reference keeps it open until the last guy is done using it.

The main point is this: Do the jersey client code authors expect me to drop my reference to (and potentially close) the client at point A, point B, or point C?

My rationale for asking this question is simple: I want to do things right so as not to close it prematurely. Yes, I could play it safe and always just close it a point C - that would always work. However, if any code in completed or failed threw an exception, I'd have to catch that and close in a finally clause to make sure I actually closed the resource.

Thanks in advance,

John Calcote