Quais são as vantagens da cadeia de responsabilidade vs. listas de classes?

Recentemente, eu estava discutindo com outro programador a melhor maneira de refatorar um método enorme (1000 linhas) cheio de instruções "if".

O código está escrito em Java, mas acho que esse problema pode acontecer em outros idiomas, como C # também.

Para resolver esse problema, ele sugeriu usar um padrão de cadeia de responsabilidade. Ele propôs ter uma classe base "Handler". Então, "Handler1", "Handler2", etc. estenderiam "Handler".
Em seguida, os manipuladores teriam um método "getSuccessor", que retornaria null (se fosse o último da cadeia) ou o próximo manipulador da cadeia.
Então, uma função "handleRequest (Request)" poderia lidar com o Request, ou passá-lo para o próximo da cadeia e, se nenhuma das soluções anteriores funcionasse, ele retornaria apenas null ou lançaria uma exceção.
Para adicionar um novo Manipulador à cadeia, o codificador iria até o último elemento da cadeia e informaria que havia um novo elemento. Para fazer algo, ele apenas chamaria handleRequest no primeiro elemento da cadeia.

Para resolver esse problema, sugeri usar uma abordagem diferente.
Eu também teria uma classe "Handler" básica, com "Handler1", "Handler2", assim como o método anterior mencionado.
No entanto, não haveria o método "getSuccessor". Em vez disso, eu teria uma classe Collection com uma lista de manipuladores (Vector, ArrayList ou o que for melhor neste caso).
A função handleRequest ainda existiria, mas não propagaria a chamada para os próximos manipuladores. Apenas processaria o pedido ou retornaria null.
Para lidar com um pedido, alguém usaria

for(Handler handle : handlers){
    result = handle.handleRequest(request);
    if(result!=null) return result;
}
throw new CouldNotParseRequestException(); //just like in the other approach

Ou, para evitar a duplicação de código, um método "parseRequest (request)" poderia ser adicionado à classe de coleção. Para adicionar um novo manipulador, um iria para o construtor de coleção (ou static {} block, ou algo equivalente) e simplesmente adicionaria o código "addHandler (new Handler3 ());".

Exatamente quais as vantagens da cadeia de responsabilidade que estou perdendo com essa abordagem? Qual método é o melhor (assumindo láé melhor método)? Por quê? Quais bugs e problemas potenciais cada método de design pode causar?

Para aqueles que precisam de contexto, aqui está como era o código original:

if(x instanceof Type1)
{
//doSomething1
} else if(x instanceof Type2)
{
//doSomething2
}
//etc.