UAM - Arquitetura de software - Unidade 2 - Pratique

Prévia do material em texto

UAM – Arquitetura de software – Unidade 2 – Pratique
Desenvolvimento baseado em componentes
Os sistemas de software modernos têm se tornado cada vez mais complexos e gerenciados de maneira a resultar em um alto custo de desenvolvimento, baixa produtividade, qualidade incontrolável de software e alto risco de atualização de tecnologia. Consequentemente, há uma demanda crescente na procura de uma solução para o paradigma do desenvolvimento de software , ou seja, o desenvolvimento de um software que apresente eficiência e seja econômico.
Atualmente, uma das soluções mais promissoras é a abordagem de desenvolvimento de software baseada em componentes. Essa abordagem é baseada na ideia de que os sistemas de software podem ser desenvolvidos selecionando componentes prontos para uso e montando-os com uma arquitetura de software bem definida. Essa abordagem de desenvolvimento de software é muito diferente da abordagem tradicional, na qual os sistemas só podem ser implementados do zero. Esses componentes comerciais fora da prateleira (COTS) podem ser desenvolvidos por diferentes desenvolvedores, usando idiomas e plataformas diferentes.
O desenvolvimento de software baseado em componentes (CBSD) pode reduzir significativamente o custo de desenvolvimento e o tempo de colocação no mercado, além de melhorar a manutenção, a confiabilidade e a qualidade geral dos sistemas de software. Essa abordagem suscitou interesse tanto na comunidade de pesquisa quanto na indústria de software. O ciclo de vida e o modelo de engenharia de software do CBSD são muito diferentes dos modelos tradicionais, isto é, a CBSE (Component-Based Software Engineering) é focada na utilização da engenharia para modelar esses softwares .
As tecnologias de componentes de software são uma tecnologia emergente, que está longe estar amadurecida. Não há padrões ou diretrizes existentes nesta nova área, nem sequer temos uma definição unificada do item principal, o "componente". No entanto, em geral, um componente tem três características principais: 1) ele é uma parte independente e substituível de um sistema que cumpre uma função clara; 2) um componente funciona no contexto de uma arquitetura bem definida; e 3) um componente se comunica com outros componentes por meio de suas interfaces. Para garantir que um sistema de software baseado em componentes possa funcionar de maneira adequada e eficaz, a arquitetura do sistema é o fator fundamental para esse processo.
A arquitetura de sistemas de software baseados em componentes deve ser uma arquitetura em camadas e modular. A primeira camada de arquitetura é o sistema de aplicativos que suporta um negócio. A segunda camada consiste em componentes envolvidos em apenas um domínio comercial ou um aplicativo específico, incluindo componentes utilizáveis em mais de um único aplicativo. A terceira camada são os componentes de middleware entre empresas, que consistem em software e interfaces comuns com outras entidades já estabelecidas. Finalmente, a camada mais baixa do sistema de componentes de software inclui componentes básicos que fazem interface com os sistemas operacionais e hardware subjacentes.
As tecnologias atuais de componentes têm sido usadas para implementar diferentes sistemas de software, como software de componente distribuído orientado à objetos e aplicativos corporativos baseados na Web. Ela fornece uma infraestrutura de objetos distribuídos reutilizáveis e um conjunto abundante de componentes de aplicativos para aplicativos desenvolvedores.
Nesse contexto, existe um grande desafio na arquitetura de software baseada em componentes: identificar quais componentes devem ser construídos, mantidos e, principalmente, como eles devem interagir.
Vamos Praticar
Baseado nos casos mencionados anteriormente, descreva como os componentes de software podem ser identificados, construídos e mantidos? Além disso, como seria a forma de relacionamento entre eles? Ao final, disponibilize seu trabalho no fórum da seção.
Resposta:
Com base nos casos mencionados e no contexto do desenvolvimento de software baseado em componentes (CBSD), vou descrever como os componentes de software podem ser identificados, construídos e mantidos, bem como a forma de relacionamento entre eles.
1. Identificação de Componentes:
A identificação de componentes é um processo crucial que envolve a análise do domínio do problema e dos requisitos do sistema. Algumas abordagens para identificar componentes incluem:
a) Análise de Domínio:
· Estudar o domínio do negócio para identificar funcionalidades comuns e reutilizáveis.
· Criar modelos de domínio que representem entidades, processos e regras de negócio.
b) Decomposição Funcional:
· Dividir o sistema em funções menores e mais gerenciáveis.
· Agrupar funções relacionadas em potenciais componentes.
c) Análise de Casos de Uso:
· Examinar os casos de uso do sistema para identificar funcionalidades que podem ser encapsuladas em componentes.
d) Padrões de Design:
· Utilizar padrões de design conhecidos para identificar componentes comuns (ex: Facade, Observer, Factory).
e) Análise de Sistemas Existentes:
· Estudar sistemas similares ou legados para identificar componentes potencialmente reutilizáveis.
2. Construção de Componentes:
Uma vez identificados, os componentes devem ser construídos seguindo princípios de design que promovam a reutilização e a manutenibilidade:
a) Encapsulamento:
· Ocultar a implementação interna do componente, expondo apenas interfaces bem definidas.
b) Coesão Alta:
· Garantir que cada componente tenha uma responsabilidade bem definida e única.
c) Acoplamento Baixo:
· Minimizar as dependências entre componentes para facilitar a reutilização e manutenção.
d) Interfaces Bem Definidas:
· Projetar interfaces claras e estáveis que especifiquem como o componente deve ser usado.
e) Versionamento:
· Implementar um sistema de versionamento para gerenciar diferentes versões do componente.
f) Documentação:
· Fornecer documentação detalhada sobre o uso, dependências e comportamento do componente.
g) Testes Unitários:
· Desenvolver testes unitários abrangentes para garantir a qualidade e facilitar a manutenção.
3. Manutenção de Componentes:
A manutenção de componentes é um processo contínuo que envolve:
a) Controle de Versão:
· Utilizar sistemas de controle de versão (ex: Git) para rastrear mudanças e gerenciar diferentes versões.
b) Refatoração:
· Melhorar continuamente o design e a implementação dos componentes sem alterar seu comportamento externo.
c) Gerenciamento de Dependências:
· Monitorar e atualizar as dependências dos componentes para garantir compatibilidade e segurança.
d) Testes de Regressão:
· Executar testes regularmente para garantir que as mudanças não introduzam novos bugs.
e) Documentação Atualizada:
· Manter a documentação do componente atualizada conforme ocorrem mudanças.
f) Feedback dos Usuários:
· Coletar e analisar feedback dos usuários do componente para orientar melhorias.
g) Análise de Métricas:
· Monitorar métricas de qualidade de código, desempenho e uso para identificar áreas de melhoria.
4. Relacionamento entre Componentes:
O relacionamento entre componentes é gerenciado através de:
a) Interfaces Bem Definidas:
· Componentes se comunicam através de interfaces públicas, ocultando detalhes de implementação.
b) Contratos:
· Estabelecer contratos claros que especifiquem as responsabilidades e expectativas de cada componente.
c) Eventos e Mensagens:
· Utilizar padrões de design como Observer ou sistemas de mensageria para comunicação assíncrona.
d) Injeção de Dependência:
· Usar técnicas de injeção de dependência para reduzir o acoplamento entre componentes.
e) Mediadores:
· Implementar componentes mediadores para gerenciar a comunicação entre grupos de componentes relacionados.
f) Camadas de Abstração:
· Utilizar camadas de abstração para separar componentes de baixo nível dos de alto nível.
g) Composição e Agregação:
· Construir componentes mais complexos através da composição de componentes mais simples.
h) Serviços:
· Expor funcionalidades como serviços,permitindo que componentes interajam de forma distribuída.
i) Configuração Declarativa:
· Usar arquivos de configuração ou anotações para definir como os componentes devem se relacionar.
Ao seguir essas práticas, é possível criar uma arquitetura de software baseada em componentes que seja flexível, manutenível e escalável. A chave está em manter um equilíbrio entre a granularidade dos componentes (nem muito grandes, nem muito pequenos) e garantir que eles sejam verdadeiramente reutilizáveis e independentes.
É importante notar que o processo de identificação, construção e manutenção de componentes é iterativo e deve ser continuamente refinado à medida que o sistema evolui e novos requisitos surgem. Além disso, o uso de ferramentas de automação, como sistemas de integração contínua e entrega contínua (CI/CD), pode ajudar significativamente na gestão do ciclo de vida dos componentes.
Por fim, é crucial estabelecer padrões e diretrizes claras dentro da organização para o desenvolvimento baseado em componentes, garantindo consistência e facilitando a colaboração entre diferentes equipes de desenvolvimento.