Java - Auto add method call when developer instantiates an object

Question

I am wondering if it is possible for a developer to write a class so that when some other developer instantiates an object of the aforementioned class, a call on a specific method of the class gets added to his code.

Let me be more specific. Let's say that I create a class named A with the following structure:

public class A {

    public A() {
        // Some instantiations
    }

    // Code class

    // Method that always should be added
    public void method() {
        // Code
    }
}

I wrap this class into a package and some other developer instantiates class A in a new object. When he does that, a call on method() is added right after the instantiation, probably with a comment right above it:

// Code
A myA = new A();
// Do some operations on A

// You should always wrap up with a call on method
myA.method();

// Code

This is just to inform the developer not to forget to call it at a specific place in his code.

The reason I am asking this is because I have created a class that contains a queuing mechanism that will be used in a large project as also as in future projects. I need to force every future developer to reference a method called close() at the end of his code, to terminate the connection to the queuing system. If he forgets to do that (and there is very high possibility that he/she does that), the connections will be open, adding a huge overhead to the total project.

If there is no way to implement this (and to my knowledge, I can't think of anything), what's the logic behind to not include something like this in standard JDK by Oracle? I can think of examples of JDK's own libraries that could be benefited by this (e.g. closing a PrintWriter when you are finished writing to a file), so I don't think that this is a misunderstanding from my side of Java's principles.

UPDATE

Because I think I accidentally started a flame war...

I do think that a good API is written in a way that does procedures like this automatically. Instantiate an object/call a method and the rest are done automatically. But for my case, I need something like C++'s destructors: a way to force or otherways warn the developer to close the connection to the queuing system he created.

UPDATE 2

The project is unfortunately written in JDK 7 that does not support lambda functions.

UPDATE 3

As it turns out my assumption was true and there is no standard Java feature (except maybe of the lambda functions) that can be leveraged. Can I add at least a warning on the other developer's class that he forgot to close the connection?

Answer 1

You should leverage the try-with-resouce feature which was introduced in Java7.

Your aforementioned class A should implement the Interface AutoClosable then:

public class A implements AutoClosable {
    public void close() {
        // Do closing
    }
}

Using instances of A should happen in a try-with resource block:

try(A a = new A()) {
    // Do something
}

This ensures the close method is called after reaching the end of the try block.

Finally at least the eclipse-compiler can mark forgetting using A in a try-with-resource block as an error.

Answer 2

What you probably want to implement is a sort of "Use with" pattern, where you only expose a single public method on your class that will accemp a "Use strategy" for your object, while giving you as an author full control over instantiation and destruction of your resource object.

Consider this resource class:

public class ExpensiveResource {
  private ExpensiveResource() {} // private so only we can get an instance

  public void destroy() { // a method we always want to call after we're done
    <...>
  }

  <...more operations with resource here...>

  // This is the only actual entry point where anyone can access instances of your resource.
  // As you can see, destroy() is always called no matter what.
  public static void use(UsageStrategy strategy) {
    ExpensiveResource resource = new ExpensiveResource();
    try {
      strategy.useResource(resource);
    }
    finally {
      resource.destroy();
    }
  }

  public static interface UsageStrategy extends Consumer<ExpensiveResource> {
    @Override
    default void accept(ExpensiveResource arg0) {
      useResource(arg0);
    }

    void useResource(ExpensiveResource resource);
  }
}

And anyone who wants to use your resource will need to call it like this:

ExpensiveResource.use(resource -> {
  var a = resource.operation1();
  resource.operation2();
  resource.operation3(a);
  <... etc. ...>
});

If you are using Java7 still, all you need for it to work is to make an anonymous class:

ExpensiveResource.use(new UsageStrategy() {
  public void useResource(ExpensiveResource resource) {
    resource.operation1();
    <... etc. ...>
  }
});

It is far less elegant due to boilerplate syntax, but the basic idea is the same, and you can start enjoying the benefits of Java8 as soon as you upgrade.

(Note that I extended UsageStrategy from java.util.function.Consumer above. Java 7 will not have this class, but you can just remove extends and default a method).

Answer 3

You are going down the wrong rabbit hole here. Meaning: good APIs are easy to be used correctly, and hard to be used the wrong way.

If you want that new A() is followed by some doSomething() then the solution goes like this:

• make that constructor private
• put a static helper method into A that does

this:

public static A makeA() {
   A result = new A();
   doSomething();
   return result;
}

Or something alike. In other words: don't strive for complicated, non-standard, dirty-hackishly looking workarounds. Instead: make it impossible to do the wrong thing.

Answer 4

There is no such feature in any IDE that I know, but most of them have plugins. you can write your own plugin to implement this.

Other option is redesign your API like this

class Main {
    public static void main(String[] arg) {

        String res = QueueService.doWithQueue(q -> q.someMethod());

    }
}

class QueueService {
    public static <T> T doWithQueue(DoWithQueue<T> m) {
        MyQueue myQueue = new MyQueue();
        T t = m.method(myQueue);
        myQueue.close();
        return t;
    }
}

interface DoWithQueue<T> {
    T method(MyQueue m);
}

class MyQueue {
    public void close() {
    }

    public String someMethod() {
        return "something";
    }
}

And do not let to create MyQueue other way tan thru QueueService