00:00:00
E aí
00:00:00
[Música]
00:00:07
o Olá eu sou o professor Marcelo
00:00:10
Fantinato Essa é a disciplina de
00:00:12
engenharia de software E hoje nós vamos
00:00:15
falar sobre componentes de software essa
00:00:18
aula ela encerra um grupo de aulas é a
00:00:22
sobre reuso de software eu já em aulas
00:00:27
anteriores havia mencionado que uma das
00:00:29
abordagens para reuso de software é usar
00:00:34
componentes de software e hoje então nós
00:00:36
vamos falar sobre esses componentes de
00:00:39
software causar os componentes de
00:00:42
software nós temos o que é chamado de
00:00:45
engenharia de software baseada em
00:00:48
Componentes a O que é essa engenharia de
00:00:52
software baseada em Componentes é quando
00:00:55
você tem uma abordagem
00:00:57
e para sistematizar o reuso de
00:01:01
componentes então a em vez de você
00:01:04
basicamente
00:01:06
simplesmente sair usando componentes de
00:01:09
software de qualquer forma da forma como
00:01:12
você achar melhor não você segue uma
00:01:16
abordagem sistemática para fazer isso da
00:01:19
melhor forma possível para que nesse
00:01:21
caso nós estamos falando necessariamente
00:01:23
de
00:01:24
desenvolvimento de software orientado a
00:01:27
objetos porque componentes softer a por
00:01:30
definição Ele só faz sentido se a gente
00:01:32
tiver falando em
00:01:34
orientação ao objeto então nós estamos
00:01:38
falando né do processo de definir
00:01:40
implementar e integrar ou compor a os
00:01:44
componentes que são independentes e
00:01:48
fracamente acoplados
00:01:50
e é isso então é o que a gente chama de
00:01:52
engenharia de software baseada em
00:01:55
Componentes Mas afinal o que é um
00:01:56
componente de software um componente de
00:02:00
software ele é uma o que nós chamamos né
00:02:04
de uma abstração né é uma abstração de
00:02:07
um nível mais alto que o objeto ou seja
00:02:09
é é uma é um agrupamento de objetos
00:02:12
então novamente estamos falando de
00:02:15
orientação objetos né nós desenvolvemos
00:02:17
o softer de uma forma é organizada por
00:02:22
meio de classes as quartas tem os seus
00:02:25
métodos seus atributos e quando essas
00:02:28
classes elas são instanciados elas
00:02:30
formam os objetos porque na verdade os
00:02:33
componentes são formados por um grupo de
00:02:37
objetos Claro objetos inter-relacionados
00:02:41
é e também as interfaces as interfaces é
00:02:46
desses objetos a fazem parte então os
00:02:50
componentes eles são então maiores do
00:02:53
que os objetos individuais e os detalhes
00:02:57
da implementação de cada um dos seus
00:02:59
desses objetos eles vão ficar escondidos
00:03:01
né Nós encapsulamos um componente e
00:03:05
vamos apenas ter a interface do
00:03:07
componente como usar esse componente os
00:03:11
detalhes de implementação eles ficam
00:03:14
escondidos e aí então nós podemos usar
00:03:17
esse componente em diferentes sistemas
00:03:20
que estão sendo desenvolvidos por isso
00:03:22
que é uma abordagem de reuso
00:03:25
nós temos alguns fundamentos da
00:03:29
engenharia de software baseada em
00:03:31
Componentes que aí está representado
00:03:33
pela sigla CBF e a seguir em inglês
00:03:37
component-based software Engineering a
00:03:41
esses componentes eles são
00:03:44
independentes né Você pode acoplar o sol
00:03:48
o componente de um sistema é acoplar
00:03:51
acoplar no outro porque porque eles são
00:03:53
independentes Pensa num componente que
00:03:55
ele é é por si só ele existe Claro que
00:03:59
ele tem interface você envia dados para
00:04:02
ele você obtém dados dele mas você pode
00:04:05
Em algum momento retirar colocar no
00:04:07
outro sistema e ele continua funcionando
00:04:10
e aí para isso ele tem que ser bem
00:04:14
especificado por meio de suas
00:04:16
componentes de suas interfaces para isso
00:04:19
a gente tem que usar padrões que define
00:04:23
as interfaces
00:04:24
ao desenvolver esses componentes nós
00:04:27
devemos seguir padrões todos os sistemas
00:04:30
eles devem saber conversar com esses
00:04:32
componentes de uma forma padronizada
00:04:34
porque senão a gente vai pegar um
00:04:36
componente colocar dentro de um sistema
00:04:37
que não sabe conversar com aquele
00:04:39
componente não segue o padrão de
00:04:42
conversa é como você colocar uma pessoa
00:04:45
que fala inglês dentro de um país que
00:04:47
fala português eles não vão saber de
00:04:50
fato a precisamos também de me dor é que
00:04:54
é uma tecnologia para poder fazer a dar
00:04:58
o suporte a esta comunicação né como é
00:05:01
que um sistema vai poder fazer
00:05:05
cor se comunicar com os componentes como
00:05:07
é que vale os componentes dentro de um
00:05:10
sistema se comunicam novamente os
00:05:12
componentes inclusive estão distribuídos
00:05:15
pensando em Sistemas distribuídos alguns
00:05:18
componentes que formam o sistema rodando
00:05:20
no computador outros componentes rodando
00:05:23
num outro computador no outro servidores
00:05:25
isso é a são os líderes que permitem
00:05:29
isso e precisamos então de um processo
00:05:31
de desenvolvimento direcionado né que é
00:05:34
a engenharia de software baseada em
00:05:36
Componentes um processo de
00:05:38
desenvolvimento que permita
00:05:39
desenvolver sistemas usando
00:05:44
usando o reuso de componentes né e
00:05:47
usando componentes e e a bom aqui ó a
00:05:51
gente tem uma figura ilustrativa
00:05:54
usando um diagrama é um um elemento da o
00:05:57
ML e representa um componente Então
00:06:00
dentro da o ML e vocês já devem conhecer
00:06:03
a esse essa é a figura que representa um
00:06:06
componente então percebam que o
00:06:08
componente ele é representado por um
00:06:10
retângulo
00:06:11
é com esse desenho aí a
00:06:15
no canto superior a esquerdo é é aquele
00:06:22
aquele aquele desenho aquele ícone
00:06:24
representa o desenho de um componente e
00:06:27
esse dentro desse componente então nós
00:06:30
temos uma integração de objetos né os
00:06:32
objetos ficam ali dentro escondidos a
00:06:34
gente não sabe quais os objetos quantos
00:06:37
objetos quais objetos que estão ali
00:06:39
dentro e o que a gente sabe é qual é a
00:06:41
interface desse componente que está
00:06:43
representado por esses desenhos do lado
00:06:47
esquerdo e do lado direito do componente
00:06:49
nós o prefácio é de chamada aqui que
00:06:54
recebem algum algum dado para o
00:06:57
componente funcionar e algumas
00:06:59
interfaces que é o wiiware é e a
00:07:04
interface provides que a interface que o
00:07:06
componente fornece algum algum dado né
00:07:10
então o componente ele pode receber
00:07:13
informações e pode fornecer informações
00:07:16
e aí a interface ela tem esses dois
00:07:20
desenhos esses dois símbolos diferentes
00:07:23
e a esses componentes Eles são passíveis
00:07:27
de composição você pode juntar um
00:07:30
componente com outro com outro e formar
00:07:32
um grande componente então certo é eles
00:07:35
são implantar implantáveis que a ideia
00:07:37
que eu já tinha falado antes você pega
00:07:39
um componente coloca dentro de um
00:07:41
sistema
00:07:42
implanta aquele componente dentro de um
00:07:44
sistema são bem documentados eles a
00:07:47
gente espera que um documento um
00:07:49
componente seja bem documentado para que
00:07:52
alguém possa te usar aquele componente
00:07:55
senão a pessoa não entende né um
00:07:58
engenheiro de software não vai entender
00:07:59
como usar aquele componente são
00:08:01
independentes que eu já havia comentado
00:08:04
o e padronizados também eu já havia
00:08:07
comentado a bola para aqui a engenharia
00:08:12
de software baseada em Componentes
00:08:13
funcione nós precisamos um modelo bem
00:08:16
definido que defina todas essas regras
00:08:19
esse modelo ele está ilustrado nessa
00:08:21
imagem certo cada um ela é dividida esse
00:08:25
modelo de três partes como a interface
00:08:29
do componente deve funcionar nós temos
00:08:32
que ter uma definição
00:08:34
e a nós temos que ter uma definição da
00:08:38
interface podemos fazer composição de
00:08:40
componentes é como o componente pode ser
00:08:44
usado e como há o componente pode ser
00:08:48
implantado e para tudo isso existem aqui
00:08:52
subir partes desse modelo certo ah
00:08:56
é uma uma abordagem de engenharia de
00:09:01
software baseada em Componentes ela deve
00:09:03
seguir esse modelo Ah não coloquei a
00:09:07
figura aqui apenas para ilustrar para
00:09:08
mostrar para vocês que existem regras
00:09:10
que devem ser seguidas para usar
00:09:12
componentes e é o material de o
00:09:18
texto-base da disciplina ele traz os
00:09:21
detalhes de cada um desses itens eu
00:09:23
convido vocês a lerem para entender um
00:09:26
pouco mais o que significa cada um
00:09:28
desses modelos
00:09:30
e é aliás cada um dos componentes dos
00:09:34
itens das partes desses modelos ia falar
00:09:36
cada um dos componentes desse modelo até
00:09:38
porque componente é uma palavra que a
00:09:40
gente usa no dia a dia em outros em
00:09:43
outros contextos não só no componente
00:09:45
como componente de software né Ah bom
00:09:49
Aqui também mais uma parte da desse
00:09:52
modelo também trouxe aqui apenas como
00:09:54
uma ilustração e nós temos serviços de
00:09:58
suporte e serviços de plataforma para
00:10:01
dar apoio a ao desenvolvimento a
00:10:04
implantação ou a comunicação dos
00:10:07
componentes é mais uma coisa
00:10:09
interessante é que eu já havia
00:10:12
mencionado em algum uma um slide ali
00:10:15
atrás que os componentes Eles são
00:10:17
passíveis de composição então eu posso
00:10:20
poder eu deveria poder é compor
00:10:24
componentes para formar um componente
00:10:27
maior existem diferentes formas de
00:10:29
compor Oi gente como ilustrado aqui
00:10:31
nessa segura eu posso fazer composições
00:10:34
sequenciais virar dicas e aditivas isso
00:10:38
vai depender de quais são os componentes
00:10:41
que eu vou
00:10:43
das características dos componentes que
00:10:45
estão sendo compostos e o que eu quero
00:10:48
fazer né então por exemplo nesse
00:10:50
primeiro caso aqui olha notem que esse
00:10:53
componente aqui ele tem uma interface
00:10:55
apenas para prover dados e esse aqui
00:10:59
também uma Interface para prover dados
00:11:02
então ambos os componentes eles pro
00:11:06
vendados como é que eu faço uma
00:11:08
composição de dois componentes que
00:11:10
provêm dados eu preciso criar um
00:11:12
adaptador que vai ter uma interface que
00:11:16
consome dados de um e uma interface que
00:11:19
consome dados do outro né então percebam
00:11:22
que eu preciso fazer uma conexão aqui de
00:11:26
esse esse É como se eu fosse tivesse um
00:11:29
componente ok o alfa aqui né eu ia falar
00:11:32
fake Mas enfim falsa a e consome os
00:11:37
dados desse componente e consome os
00:11:39
dados desse componente E aí Isso aqui
00:11:41
vira um novo componente um componente
00:11:44
grandão aqui tá claro que esse é
00:11:48
esse adaptador AC Muito provavelmente eu
00:11:51
vou a querer fazer uma outra interface
00:11:53
dele é para prover um a também para
00:11:58
prover dados então eu estaria provendo
00:12:00
os dados desses dois componentes aqui de
00:12:02
uma forma integrada já a composição
00:12:05
desses dois componentes aqui olha é um
00:12:09
pro ver e o outro com fome então a
00:12:11
composição é diretas esse componente é
00:12:14
que ele está consumindo os dados desse
00:12:18
componente a está consumindo os dados do
00:12:22
componente B certo a e aqui existe uma
00:12:26
composição mais complexa que é e eu
00:12:30
tenho o componente a que com que tem os
00:12:37
dois tipos de interface que é invocado e
00:12:40
produz e o componente B também né os
00:12:43
dois tipos de interface o provar das e o
00:12:45
record então eu tenho um tipo de
00:12:49
adaptador AC para a
00:12:54
é a que produz algum tipo de informação
00:12:57
que o ar e o bebê requer e um outro o
00:13:01
adaptador aqui que consome a informação
00:13:04
que o ar e o b produz de forma que eu
00:13:08
vou ter um grande componente maior aqui
00:13:10
que a
00:13:12
produz informação do componente grande
00:13:16
aqui e requer a informação do componente
00:13:19
grande aqui não tá dando para ver
00:13:21
Exatamente porque a figura cortou bem
00:13:23
aqui mas essas duas interfaces aqui de
00:13:25
cima são do tipo requer Tá mas de
00:13:28
qualquer forma são formas são apenas
00:13:30
figuras ilustrativas de exemplos de
00:13:33
composições Aqui nós temos um exemplo um
00:13:36
pouco mais é
00:13:39
real que são já é
00:13:43
componentes que que alguém alguma vez
00:13:47
criou mesmo né componente aqui
00:13:49
biblioteca de fotos é interface com
00:13:52
usuário
00:13:54
as imagens e as que sim um componente
00:13:56
adaptador então um componente que é
00:14:00
consome dados do biblioteca de fotos
00:14:03
consome dados do gerenciador de imagens
00:14:05
e consome dados do
00:14:07
interface com o usuário Além disso
00:14:10
biblioteca de fotos ainda tem outras
00:14:12
duas interfaces que não está sendo usada
00:14:14
aqui tá aqui também nós temos o um
00:14:18
exemplo aqui de cima o
00:14:21
componente sensor que tem três
00:14:24
interfaces que produz dados O componente
00:14:28
coletor de dados que tem várias
00:14:31
interfaces que produz dados mas que tem
00:14:34
duas interfaces que consome dados Então
00:14:36
veja que interessante o coletor de dados
00:14:39
tem duas interfaces pedindo dados só que
00:14:43
o sensor tem três produzindo então foi
00:14:46
criado um adaptador aqui que pega as
00:14:49
duas interfaces é que requer dados
00:14:53
e do coletor de dados e conforme os
00:14:58
dados do sensor através por meio de três
00:15:01
outras interfaces em São Claro que aqui
00:15:03
dentro desse adaptador vai existir um
00:15:05
código vai existir uma inteligência para
00:15:07
poder fazer essa interface aqui essa
00:15:10
adaptação de o corredor de dados em
00:15:13
algum momento vai usar uma dessas
00:15:16
interfaces E aí o adaptador vai saber
00:15:19
qual das interfaces ou até mesmo duas ou
00:15:21
três ao mesmo tempo é do sensor certo
00:15:25
bom E aí a nós temos Finalmente né um
00:15:30
modelo de processo um exemplo uma
00:15:32
sugestão aqui de um modelo de processo
00:15:34
Qual o processo você deveria seguir para
00:15:38
desenvolver um software baseada em
00:15:40
Componentes e e tem semelhanças com
00:15:43
modelos de processos que nós já vimos em
00:15:45
aulas anteriores mas perceba que em
00:15:48
algum momento você precisa por exemplo
00:15:51
adquirir componentes você precisa
00:15:55
gerenciar os componentes então a ideia
00:15:59
que esse processo é ter atividades
00:16:02
voltadas para
00:16:04
reusar os componentes criar componentes
00:16:07
encontrar componentes usar esses
00:16:10
componentes certo né o bom é isso então
00:16:15
a a essa aula o material foi feito
00:16:19
baseado no livro do sommerville
00:16:21
engenharia de software décima edição de
00:16:23
2018 espero que com isso vocês tenham
00:16:27
tido uma boa ideia do que são os
00:16:30
componentes de software e da engenharia
00:16:32
de software baseada em Componentes
00:16:34
obrigado a
00:16:39
E aí
00:16:42
[Música]
00:16:48
E aí
00:16:51
E aí
00:16:57
E aí
00:17:02
E aí
00:17:08
[Música]
