Code refactoring

Question

Hell code refactoring!
I inhirite a Java application that was written 15 years ago with millions lines of code
The code has many problems, including some very basic stuff like comparing object using ==. But somehow, it works and the company keeps using it
The problem we are facing is the code doesn't support debugging. ALL of the methods have very limited number of variables. The coders writting something like this all over places
if(getA().getB().getC().getD().getE().getM().equals(getA().getB().getC().getD().getE().getN()){
     getA().getB().getC().getD().getE().getM().setZ(getA().getB().getC().getD().getE().getN().getZ());
int num = getA().getB().getC().getD().getE().getM().getList().size();
for(int i = 0; i<num; i++){
    getA().getB().getC().getD().getE().getM().getList().get(i).setSomething();;
It is unbelievable but it is real. Some of them have more than 10 get() on the same line
I try to refactor it, adding local variables into the methods, so we can resuse the objects instead of using lines of get()
It also help debugging the code possible because there are many recursive calls plus the above style make it almost impossible now. Whenever something happens, it took me days to figure out what is wrong
I am going to break the get() chains but since the code base is huge, I don't know if we have some tools availble.
If someone has solved similar problem, please give me some advice.
Thank you very much

Answer 1

2/ The code has many problems, not a single one. but I feel most important is debuggable.
Well so far you haven't mentioned a single problem with the code. Further, the code sample you posted is 'debuggable'. But, again, you don't need to 'debug' code that works correctly.
The below is a real function of the code that I renamed all the terms
What is it about that code that makes you think it is not 'debuggable'?
You have to pick your battles. You can't try to rewrite/refactor code just because you don't like the way it was written. That is NOT productive.
Assuming you even have a need to refactor anything the first step is to identify the CRITICAL code sections/elements/classes/methods. Critical either because they are performance issues or critical because they are what keeps breaking.
There are almost no comments in the code,
Then, as I already mentioned, the FIRST step is to analyze the code and DOCUMENT IT. You posted a code snippet and said ABSOLUTELY NOTHING about what that method is supposed to be doing. Why not? Why didn't you post a comment? Have you 'analyzed' that code you posted? If not, why not?
Your analysis should START with the method signature; the parameters and return type. Have you look at that for the sample you posted? If not, why not?
Do you see anything unusual about it? I do.
private Double returnCRValue(TsTRatingOperation aetnRatingOperation, String id) throws Exception {  
Throws Exception? Almost any coded might throw an exception so why does this method just mention a generic exception instead of a specific one.
The signature declares that the method returns an instance of Double. Does it actually do that?
BigDecimal dbvalue = null;
return dbvalue == null ? null : new Double(dbvalue.doubleValue());  
Why does the method use BigDecimal in the body but then convert the value to a Double for the return? What if that BigDecimal value can't be converted properly to a Double without losing precision? Why isn't the method returning a BigDecimal? Then the caller can perform any conversions that might be necessary.
The SECOND place to look for issues is the logic flow of the method. Does every IF statement have an ELSE? If not then why not. A common source of bugs is missing ELSE statements that cause code to fall through and work wrong when the IF condition isn't met. Same with CASE/SWITCH statements; big problem with fall through execution if a BREAK statement is missing when it is needed.
Do you see any logic issues with that code you posted? I do.
        int nPolModTotal = 0;  
        if (aetnRatingOperation.getTsTRatingPASOperationTerm().get(0).getOperationCRs() != null) {  
            nPolModTotal = aetnRatingOperation.getTsTRatingPASOperationTerm().get(0).getOperationCRs().size();  
        //loop CRs  
        for (int n = 0; n < nPolModTotal; n++) {  
            String sid = aetnRatingOperation.getTsTRatingPASOperationTerm().get(0).getOperationCRs().get(n).getCRTypeReferenceCode().trim();  
            if (sid.equals(id.trim())) {  
                dbvalue = aetnRatingOperation.getTsTRatingPASOperationTerm().get(0).getOperationCRs().get(n).getModFactorValue();  
.. even more, possibly disastrous processing follows
The value of 'nPolModTotal' is set to zero.
Then there is an IF statement that MIGHT SET it to a real non-zero value.
But WHAT IF IT DOESN'T? The rest of the code in the method will still execute. That for loop will escape ok because of its initialization statements but the next FOR loop will still execute. Is that the correct behaviour? I have no way of knowing. But it is certainly suspicious code for the second part to execute and compute a return value when the first part failed to execute.
I would want to know why the code works that way and if it is correct or a bug waiting to happen.
Loops of all kinds are also problematic: wrong initialization, wrong termination, unnecessary code within the loop instead of before the loop. Do you see any of the problems in the method you posted? I do.
//loop CRs    
        for (int n = 0; n < nPolModTotal; n++) {  
            String sid = aetnRatingOperation.getTsTRatingPASOperationTerm().get(0).getOperationCRs().get(n).getCRTypeReferenceCode().trim();  
            if (sid.equals(id.trim())) {  
                dbvalue = aetnRatingOperation.getTsTRatingPASOperationTerm().get(0).getOperationCRs().get(n).getModFactorValue();  
Why does EVERY iteration potentially set (and overwrite) the value of 'dbvalue'?
If the code is looking for a single match then it should EXIT the loop when it finds it. Why iterate through hundreds or thousands of entries (depending on the value of 'nPolModTotal') if you found your 'sid' on the very first match?
What if there are two matches for that IF statement above? The value of 'dbvalue' will be set to the LAST ONE found. Is that the correct behaviour?
There is nothing inherently wrong with those concatenated 'get' operations.  I'm assuming by your comments that you want to 'refactor' this line of code
aetnRatingOperation.getTsTRatingPASOperationTerm().get(0).getOperationCRs()
by creating an instance variable and capturing that value and then using that instance variable in the following loop?
myOperationsCRs = aetnRatingOperation.getTsTRatingPASOperationTerm().get(0).getOperationCRs() ;
for (int n = 0; n < nPolModTotal; n++) {    
            String sid = myOperationsCRs.get(n).getCRTypeReferenceCode().trim();
  Why? Why do you think you should 'refactor' that code and use an instance variable for the intermediate result?
As I said before if I were you I would forget refactoring the code and focus on:
1. analyzing what it does
2. adding appropriate comments and annotations (e.g. for the parameters and return type
3. identifying any logic issues (as I did above)
4. researching those logic issues with a possible plan to fix them