Chain of Responsibility

Em Orientação a Objetos, Chain of Responsibility é um padrão GOF cuja principal função é evitar a dependência entre um objeto receptor e um objeto solicitante. Consiste em uma série de objetos receptores e de objetos de solicitação, onde cada objetos de solicitação possui uma lógica interna que separa quais são tipos de objetos receptores que podem ser manipulados. O restante é passado para o próximo objetos de solicitação da cadeia.

Devido a isso, é um padrão que utiliza a ideia de baixo acoplamento por permitir que outros objetos da cadeia tenham a oportunidade de tratar uma solicitação.

Estrutura

Passo-a-passo

• A base mantém um ponteiro como "próximo";
• Cada classe derivada implementa sua própria contribuição para manusear o pedido (request);
• Se o pedido precisa ser passado para outra classe, então a classe derivada "chama de volta" à classe padrão, delegando um novo ponteiro;
• O cliente (terceirizado ou não) cria e encadeia a cadeia, a qual pode incluir uma ligação do último nó até o nó da raiz;
• O cliente lança e deixa cada request com a raiz da cadeia;
• As delegações recursivas produzem um efeito de ilusão;

Situações de Uso

• Mais de um objeto pode tratar uma solicitação e o objeto que a tratará não é conhecido a priori;
• O objeto que trata a solicitação deve ser escolhido automaticamente;
• Deve-se emitir uma solicitação para um dentre vários objetos, sem especificar explicitamente o receptor;
• O conjunto de objetos que pode tratar uma solicitação deveria ser especificado dinamicamente.

Em um sistema orientado a objetos esses interagem entre si através de mensagens, e o sistema necessita de determinar qual o objeto que irá tratar a requisição. O padrão de projeto Chain of Responsibility permite determinar quem será o objeto que irá tratar a requisição durante a execução. Cada objeto pode tratar ou passar a mensagem para o próximo na cascata.

Em um escritório, por exemplo, onde se tem 4 linhas telefônicas, a primeira linha é o primeiro objeto, a segunda linha é o segundo, e assim sucessivamente até a gravação automática que é o quinto objeto. Se a primeira linha estiver disponível ela irá tratar a ligação, se não ela passa a tarefa para o próximo objeto, que é a segunda linha. Se essa estiver ocupada ela passa a tarefa para a próxima e assim sucessivamente até que um objeto possa tratar a tarefa.

Nesse caso, se todas as linhas estiverem ocupadas o último objeto, que é a gravação automática, tratará da tarefa.

Exemplo

Java

Abaixo está um exemplo do padrão na linguagem de programação Java. Neste exemplo, temos atores diferentes, cada um estabelecendo um limite de compras à seu sucessor. Toda vez que um ator recebe um pedido de compra que exceda seu limite, o pedido é passado ao seu sucessor.

A classe abstrata PurchasePower com o método abstrato processRequest:

abstract class PurchasePower
{
    protected static final double BASE = 500;
    protected PurchasePower successor;

    abstract protected double getAllowable();

    abstract protected String getRole();

    public void setSuccessor(PurchasePower successor)
    {
        this.successor = successor;

    }

    public void processRequest(PurchaseRequest request)
    {
        if (request.getAmount() < this.getAllowable())
        {
            System.out.println(this.getRole() + " will approve $" + request.getAmount());
        }
        else if (successor != null)
        {
            successor.processRequest(request);
        }
    }
}

Temos quatro implementações da classe abstrata acima: Manager (Gerente), Director (Diretor), Vice President (Vice Presidente) e President (Presidente), cada uma multiplicando seu poder de compra:

class ManagerPPower extends PurchasePower
{
    protected double getAllowable()
    {
        return BASE*10;
    }

    protected String getRole()
    {
        return "Manager";
    }
}

class DirectorPPower extends PurchasePower
{
    protected double getAllowable()
    {
        return BASE*20;
    }

    protected String getRole()
    {
        return "Director";
    }
}

class VicePresidentPPower extends PurchasePower
{
    protected double getAllowable()
    {
        return BASE*40;
    }

    protected String getRole()
    {
        return "Vice President";
    }
}

class PresidentPPower extends PurchasePower
{
    protected double getAllowable()
    {
        return BASE*60;
    }

    protected String getRole()
    {
        return "President";
    }
}

O código abaixo define que a classe PurchaseRequest mantenha os dados em uma outra classe, como neste exemplo:

class PurchaseRequest
{

    private double amount;
    private String purpose;

    public PurchaseRequest(double amount, String purpose)
    {
        this.amount = amount;
        this.purpose = purpose;
    }

    public double getAmount()
    {
        return amount;
    }

    public void setAmount(double amt)
    {
        amount = amt;
    }

    public String getPurpose()
    {
        return purpose;
    }

    public void setPurpose(String reason)
    {
        purpose = reason;
    }
}

No uso que fizemos deste exemplo, temos a devida ordem (do menor poder de compra para o maior): Manager -> Director -> Vice President -> President

class CheckAuthority
{
    public static void main(String[] args)
    {
        ManagerPPower manager = new ManagerPPower();
        DirectorPPower director = new DirectorPPower();
        VicePresidentPPower vp = new VicePresidentPPower();
        PresidentPPower president = new PresidentPPower();
        manager.setSuccessor(director);
        director.setSuccessor(vp);
        vp.setSuccessor(president);

        // Press Ctrl+C to end.
        try
        {
            while (true)
            {
                System.out.println("Enter the amount to check who should approve your expenditure.");
                System.out.print(">");
                double d = Double.parseDouble(new BufferedReader(new InputStreamReader(System.in)).readLine());
                manager.processRequest(new PurchaseRequest(d, "General"));
            }
        } catch (Exception e)
        {
            System.exit(1);
        }
    }
}

Regras Importantes

• Chain of Responsibility, Command, Mediator, e Observer são como endereços, podendo ser separados entre remetentes e destinatários, mas com consequências diferentes. O Chain of Responsibility passa um pedido ao remetente junto com uma cadeia de potenciais destinatários.
• Chain of Responsibility pode usar o padrão Command para representar pedidos como objetos.
• Chain of Responsibility é frequentemente aplicado em conjunto com o padrão Composite. Os componentes da classe-mãe podem ser usados para a classe-filha também.