Everywhere you look in a Java application, there are classes named SomethingManager. The account cache has an AccountCacheManager. The application properties have an ApplicationPropertiesManager. The user transaction is completed by a UserTransactionManager.
You probably named a class this way at some point.
Please go change it.
Manager is a meaningless suffix. Sure, you might argue that we need a thing to manage another thing, but what do you mean when you say that? You're giving code a manager? Is this a workplace? Do objects in your application need a boss?
Whenever I see "Manager" in a class name it's almost always redundant. I saw a class that managed the life cycle of another component recently. It was predictably named with the "LifeCycleManager" suffix. For sure this is a case where we need to name the class manager, right? After all, it manages the life cycle and that's what we actually say in the real world?
This class had
stop() methods. Let's assume the class it "managed" was called
MyComponent. It's actually clearer and more readable to just call the "manager" class,
MyComponentLifeCycle. The code where it's "managed" becomes
MyComponentLifeCycle.stop(). I can initialize or stop the life cycle directly, and when I do, I say what I mean and I mean what I say. I don't ask a manager to do it, I just do it.
This simple idea applies across most use cases where I've seen the
Manager suffix on a class. Just now, I opened up a code base and found a
ConnectionManager class. Some of the methods it exposes are
close(). Setting aside the fact that this class probably could be refactored into some other object that makes more sense, all its really doing is holding a
javax.sql.DataSource and providing some utility code around it, with the ultimate goal of providing a valid
java.sql.Connection to the application.
Can't this class just be called
DbConnection and change that
getConnection() method (which returns a
java.sql.Connection by the way) to just
get() or maybe
asSqlConnection()? Now instead of having a
ConnectionManager.getConnection() (which is totally redundant too by the way) you instead have
DbConnection.get(). Later you call
DbConnection.close(). No need for a "manager."
As you can see, clean code should have no managers. It's redundant and unnecessary. It tells you nothing about what the class actually does.
My goal is manager extinction. Who's with me?