避免模​​块之间的依赖

Question

For the sake of the question let's say I have a cryptographic module opensslCryptographicModule that have the following methods:

public String encrypt(String content, String key);
public String decrypt(String encrypted, String key);

And an other module, let's call it MainModule that needs a cryptographic module to work.

Since the cryptographic module used in MainModule may change I created an interface as follow:

public interface CryptographicModule {
    public String encrypt(String content, String key);
    public String decrypt(String encrypted, String key);
}

And the MainModule takes a CryptographicModule in its constructor.

My question is how do I keep the cryptographic module totally independant ?

If I put the interface in the MainModule then the opensslCryptographicModule will need to implements an interface declared in an other project and therefore will become dependant of that project.

But if I put the interface in the opensslCryptographicModule then the other cryptographic modules will need opensslCryptographicModule to get the interface.

---

The only solution that I can see is a third module that will make the link between both of the modules.

It will implements the interface (that will be in the MainModule) using the adapter pattern to provides the functionalities of the cryptographic module:

public class OpenSSLCryptographicModuleAdapter implements CryptographicModule  {

    private OpensslCryptographicModule module;    

    public OpenSSLCryptographicModuleAdapter(OpensslCryptographicModule module) {
        this.module = module 
    }

    @Override
    public String encrypt(String content, String key) {
        //...
    }

    @Override
    public String decrypt(String encrypted, String key) {
        //...
    }
}

And the MainModule will rely on this third module to work.

But I find it a bit overkill especially when we have control of all the modules. This design pattern is great when using a third party library or if we want to works with some old code, but not when the whole project is been written.

Answer 1

Your analysis is correct, including the part where you state this might be overkill. This is a fundamental piece of "design patterns" that people often miss. Sometimes, the benefit of applying a pattern (decoupling, etc.) does not outweigh the cost (which is often "complexity"). Part of engineering is figuring out whether the tradeoff is worth it.
Three modules might be a good idea, or it might be overkill for your case; it really depends on the specifics of your project. It might be a good idea to start with a simpler setup, then factor interfaces out later, as you discover where the appropriate abstractions are. It's impossible to give a general rule for something like this.

Answer 2

You could make OpenSSLCryptographicModule and abstract class, and make encrypt and decrypt abstract methods. Then you'll only have one base abstract class, and another concrete class for each implementation.