Chain of Responsibility

Loading...

Do curso por Instituto Tecnológico de Aeronáutica

Desenvolvimento Ágil com Padrões de Projeto

40 ratings

Instituto Tecnológico de Aeronáutica

Desenvolvimento Ágil com Padrões de Projeto

40 ratings

Neste curso, assumimos que você já sabe projetar e desenvolver programas mais complexos em Java, graças às boas práticas e princípios exercitados nos cursos anteriores; mas você talvez não se sinta ainda confortável em lidar com cenários mais complexos, onde é difícil desenvolver software com código de qualidade com flexibilidade suficiente para facilitar a implementação de mudanças repentinas de requisitos. O objetivo deste curso é oferecer a você um aprofundamento em técnicas de programação orientadas a objetos pelo uso de padrões de projeto no contexto de desenvolvimento ágil. Os seguintes conceitos são apresentados neste curso: • Revisão de conceitos de orientação a objetos: abstração de dados, encapsulamento, herança e polimorfismo • Reúso por meio de herança: padrões Null Object, Template Method e Factory Method • Delegando comportamento com composição: padrões Strategy, Bridge, State e Observer • Composição recursiva: padrões Composite e Chain of Responsibility • Envolvendo objetos: padrões Proxy, Decorator e Adapter • Estratégias para criar objetos: padrões Static Fabric Methods, Singleton e Builder • Modularidade: padrão Dependency Injection Ao final deste curso, você terá amadurecido de tal modo suas habilidades de programação que será capaz de implementar partes da aplicação Web final com o componente de gamificação enriquecido constantes do Trabalho de Conclusão da Especialização, aplicando onde apropriado alguns dos padrões apresentados neste curso durante a refatoração na prática TDD.

Na lição

Semana 3

Olá, bem-vindo ao Curso 5 – Desenvolvimento Ágil com Padrões de Projeto! Neste módulo você aprofundará seus conhecimentos sobre composição recursiva, bem como com os padrões Composite e Chain of Responsibility, nos quais se emprega a composição recursiva. Você será exposto aos padrões Proxy, Decorator e Adapter, em cujas estruturas se faz uso do encapsulamento. Ao final, você aprenderá como criar classes em que se pode instanciar apenas um único objeto, na forma do padrão Singleton.

O Que é Composição Recursiva?5:47

Composição Recursiva com Polimorfismo4:00

Padrão Composite5:24

Hands-on: Padrão Composite16:41

Chain of Responsibility8:15

Conheça os instrutores

Clovis Fernandes
Professor Titular in Portuguese
Ciência da Computação
Eduardo Guerra
Professor Colaborador

[MÚSICA]

[MÚSICA] Olá a todos.

Meu nome é Eduardo Guerra.

Este é o curso de Desenvolvimento Ágil com Padrões de Projeto e nesta aula eu vou

falar sobre o Chain of Responsibility.

Na última aula a gente falou sobre o composite,

que é dos padrões que utilizam composição recursiva.

Hoje vamos falar do Chain of Responsibility,

que utiliza a composição recursiva de jeito diferente do composite.

Então acompanhe aí, tá?

Bom, eu gosto de fazer uma analogia com este padrão, às

vezes quando você chega num lugar e pede para alguém fazer alguma coisa para você.

Aí a pessoa vira e fala assim: hum, espera aí que isto aí não é da minha área.

Deixa eu falar com fulano.

Aí o cara chega para o fulano e fala: ih, não vai rolar.

Deixa eu passar para o próximo.

Aí chega lá para o próximo: e aí, como é que é?

Consegue resolver esta parada?

Hum, eu não, será que o próximo não sabe?

O cara vai e passa para alguém.

Aí o cara fala assim: opa, isto aqui é comigo mesmo.

Pode deixar que eu vou resolver.

A pessoa vai e resolve e devolve,

ele passa de volta e chega na pessoa que está lá.

A pessoa que seria a próxima nem fica sabendo que teve algum problema.

Daí como conhece também às vezes quando acontece problema,

se for problema simples o cara resolve; se é mais complicado ele joga para cima.

A mesma coisa, se está na alçada da pessoa ela resolve; se não, ela joga para cima.

Então a ideia deste padrão é representar este tipo de coisa.

Como se fosse uma cadeia de responsabilidades.

Ou seja, o primeiro objeto, a primeira classe que está ali,

vai verificar se ela sabe resolver aquele problema,

ou se ela tem como contribuir na resolução daquele problema.

Se tiver, ela contribui.

Se não, ela passa para o próximo e assim vai indo até chegar

alguém que vai saber resolver.

Então, normalmente este tipo de padrão,

ele é aplicável quando você tem vários passos,

como se fosse uma dança para processar uma requisição.

Normalmente quando você tem processo.

Então falar assim: por exemplo, eu vou processar uma ordem de compra.

Então falar assim: primeiro verifica, sei lá, se é para a cidade,

depois verifica se é para o estado, verifica se tem o produto no estoque.

Então as vezes você tem objeto que sabe lidar com cada situação desta.

Então ele sempre pega, verifica se é ele quem precisa resolver.

Se ele não sabe,

ele passa para o próximo que talvez vai ter a lógica para aquele caso.

As vezes isto evita de você ter que fazer uma lógica imensa ali de incluir

monte de coisa.

Você quebra isto daí e encadeia.

Uma coisa bacana, é que por exemplo, às vezes você quer trocar os passos de lugar.

Isto aí faz a diferença.

Imagina, por exemplo, que você está fazendo processamento arquivo,

você precisa criptografar e você precisa compactar.

Você criptografar, encriptar.

Criptografar, encriptar é o vampiro, desculpa.

Mas, você precisa,

voltando, você precisa criptografar e compactar.

É diferente de você compactar e criptografar.

A ordem aí importa.

Então se eu tenho estes dois passos,

às vezes pode ser que algum caso eu queira trocar a ordem ali.

Então, se eu separei isto passos dentro desta cadeia, fica fácil de fazer isto.

Uma outra coisa que é bem comum é que as vezes eu preciso inserir novo passo ali.

Por exemplo, eu vou criptografar e eu vou compactar arquivo, mas por exemplo,

eu percebo que antes disto eu preciso verificar a integridade dele.

Então eu consigo, por exemplo,

ir lá e inserir aquele novo passo sem afetar o que já está acontecendo.

Sendo que cada vai fazer a sua parte e passa para o próximo.

Então o padrão chain of responsibility

ele implementa uma estrutura que possibilita isto daí.

Onde você sempre, o elemento vai executar e vai chamar o próximo.

Então ele executa e chama o próximo.

Alguns casos, esta execução é simplesmente ele verificar se ele

precisa fazer alguma coisa, se ele não sabe resolver aquele problema,

ou não está no escopo daquele objeto, ele simplesmente passa para o próximo.

Então o padrão chain of responsibility tem esta estrutura aí.

Diferente do composite, que a composiçao recursiva fica ali na subclasse,

aqui no chain of responsibility fica na superclasse,

porque assim eu posso ter várias subclasses.

Cada uma sabe processar tipo de coisa diferente,

mas todas elas tem esta característica comum de que sempre vai ter o próximo.

Então ele sempre vai, ele vai implementar ali a sua lógica, que é

o executar elemento e quando ele terminar ele vai chamar ali a execução da cadeia.

Ele vai chamar o próximo elemento que está ali.

Obviamente, se não tem próximo elemento, chegou no final do processamento.

Pode até ser que ele procure alguém e não ache ninguém que saiba resolver e se não

tem, chega no final da cadeia ele dá erro.

É alguns casos.

Então, como eu falei, o padrão é uma ideia.

Então tem várias formas de você implementar esta cadeia

de processamento, certo?

Imagina o seguinte: que eu tenho que calcular,

por exemplo, valor de uma entrega.

Então primeiro, por exemplo, eu verifico se é uma entrega local.

Na mesma cidade do meu tempo de distribuição.

Se for, eu vou executar aquilo ali.

Se não, eu chamo o próximo.

O próximo, talvez seja ali uma entrega intermunicipal, ou seja,

eu vou ter que ir para outra cidade, ou outro estado.

Se não for nada disto, se for para outro país, por exemplo,

eu vou chamar o próximo para ver se ele sabe resolver.

O último ali, por exemplo, seria uma entrega internacional.

Então cada destes, por exemplo,

teria cálculo de entrega completamente diferente.

Então, por isto eu fiz este encadeamento.

Vamos supor que no meio ali,

surja ali tipo novo de entrega entre estados, por exemplo, certo?

Ou que, por exemplo, a própria pessoa vá buscar algum lugar.

Então eu posso, por exemplo,

estar incluindo novo passo para o meio desta cadeia.

Então, lembrando que estes passos da cadeia,

acaba que eles podem ser facilmente reutilizados outras funcionalidades.

Então fica fácil, por exemplo,

você reestruturar aquela cadeia para atender uma outra necessidade.

Então lembrando que, por exemplo,

do jeito que eu falei aqui parece que a cadeia é fixa, mas não.

Pode ter caso que eu falo assim: eu preciso processar este tipo de compra.

Eu vou lá, vejo quais os tipos de classe que se encaixam com aquele

tipo de compra e eu monto uma cadeia específica para aquilo ali.

Então eu mesmo já utilizei o padrão chain of responsibility desta forma.

Eu não tinha uma cadeia prontinha que servia para todos os casos.

Mas eu voltava a cadeia de acordo com o que eu precisava processar.

Então é padrão bem legal, que lhe dá bastante flexibilidade para fazer,

principalmente se você quer representar processo,

o processo que pode ter passos variáveis.

O chain of responsibility é padrão bem legal para você representar

isto e ter a flexibilidade que a gente precisa nestes casos, certo?

Mais uma vez muito obrigado por assistir e não deixe de continuar nosso

próximo módulo.

[MÚSICA] [MÚSICA]

Explore nosso catálogo

Registre-se gratuitamente e obtenha recomendações, atualizações e ofertas personalizadas.

O Coursera proporciona acesso universal à melhor educação do mundo fazendo parcerias com as melhores universidades e organizações para oferecer cursos on-line.

© 2018 Coursera Inc. Todos os direitos reservados.

Baixar na App Store

Baixar no Google Play