Java线程环境中的解耦

Question

I am facing this decoupling problem. Let me explain this with example:

Say i have different classes that uses some JAR. Now this JAR keeps on getting updated and we also need to update our system along with this too. Now if there is a slight change in this JAR i have to make changes to every class, so we decided to decouple it. But these classes call the JAR classes in such a way that they make an object of it, set some flag and on the basis of that derive results. Hence every object has its own importance in every method.

Let me explain this with simple example.

Say i have a class X

class X {
  Base base;
  public int getCalResult(int a, int b) {
     base = new Base();
     base.setA(a);
     base.setB(b);
     return base.getResult();
  }

  public int getCalResult2(int a, int b, int c) {
     base = new Base();
     base.setA(a);
     base.setB(b);
     base.setC(c);
     return base.getResult();
  }
}

class Base { This is some legacy class inside JAR so can't change this
  int a, b, c, d;
  public setA(int a) {
    this.a = a;
  }
  public getResult() {
    return a + b + c + d;
  }
}

How to decouple this sort of structure and make it thread safe at the same time. Any pointers ? Any design patterns ?

I want that all the calls to JAR must be maintained in a single class, so that in case if there is change in JAR i only have to deal with single class and not all of them

What i did is

Introduced BaseProxy

public class BaseProxy {
  Base b;
  public static newInstance() {
    b = new Base();
  }

  public static setABCD(int a, int b) {
    b.setA(a);
    b.setB(b);
  }
}

class X {
      public int getCalResult(int a, int b) {
         BaseProxy.newInstance();
         BaseProxy.setAB(a,b);
         return BaseProxy.getResult();
 }

  public int getCalResult2(int a, int b, int c) {
     BaseProxy.newInstance();
     BaseProxy.setABC(a,b,c);
     return BaseProxy.getResult();
  }
}

This would have worked in single threaded env but not in mutli. I need suggestion on this. Any other better design, i am sure there is.

Answer 1

Few things not clear (or not ideal) 1. When you say, the legacy class in jar get updated, does it change the existing prototype or adds new functionality ? If they keep updating the definition then you are in trouble.

To get around this , one way is to extract an interface out of the legacy class and define a delegate implementing it (place it outside your calling code) and use it in calling code to reduce direct dependency. Now your delegate should talk to legacy class.

Also, whenever your legacy class changes, its only the delegate side you will need to update (unless there is complete turnaround in called functions)