DESARROLLAR LA ARQUITECTURA DE SOFTWARE DE ACUERDO AL
PATRÓN DE DISEÑO SELECCIONADO
APRENDICES:
ALISON YULIET OSPINA CORTES
ALEXANDER OROZCO
LUIS ANDRÉS RÍOS NOREÑA
LUIS DAVID RINCÓN GÓMEZ
LILIANA TAMARA CAPERA
INSTRUCTOR:
MANUEL ENRIQUE SAAVEDRA MELO
ANÁLISIS Y DESARROLLO DE SOFTWARE
SERVICIO NACIONAL DE APRENDIZAJE
SENA
2023
1. Tabla de contenido.
2. Introducción....................................................................................................................... 3
3. Diseño de patrones:...........................................................................................................4
3.1. Patrones comportamentales....................................................................................... 4
3.2. Patrón estructurales.................................................................................................... 6
3.3. Patrones creacionales.................................................................................................7
4. La vista de componentes para visualizar el software:................................................... 8
5. La vista de despliegue del software:................................................................................9
6. Conclusión........................................................................................................................10
7. Biografía:.......................................................................................................................... 10
2. Introducción
La arquitectura de software es un diseño de alto nivel que define los componentes
principales de un sistema de software y la forma en que se relacionan entre sí. La
arquitectura de software es esencial para el éxito de cualquier proyecto de
desarrollo de software, ya que permite una comprensión clara y estructurada del
sistema y guía la implementación de componentes y servicios del software.
Aborda cuestiones clave como la escalabilidad, la seguridad, el rendimiento y la
usabilidad, y proporciona un marco para la organización y el mantenimiento del
software a largo plazo. También es importante para la colaboración y la
comunicación entre los miembros del equipo de desarrollo y para la comprensión y
documentación del sistema para futuras referencias, es una parte fundamental de
cualquier proyecto de desarrollo de software y debe ser cuidadosamente diseñada
para garantizar la calidad, eficiencia y mantenibilidad del sistema.
En el siguiente documento, conoceremos algunos diseños de patrones de software
y analizaremos a profundidad sus características.
3. Diseño de patrones:
Los patrones generalmente hacen referencia al uso de interfaces, clases y objetos
que deben ser ajustados de acuerdo con la solución concreta a desarrollar. Son una
solución general, reutilizable y aplicable a diferentes problemas de diseño de
software. Se trata de plantillas que identifican problemas en el sistema y
proporcionan soluciones apropiadas a problemas generales a los que se han
enfrentado los desarrolladores durante un largo periodo de tiempo, a través de
prueba y error.
Los patrones de diseños se utilizan para representar soluciones concretas, los
cuales son aplicados para resolver problemas reales, son especificaciones técnicas
basadas en los principios de la programación, favorecen la implementación de las
características de la programación orientada a objetos como la encapsulación, las
jerarquías y el polimorfismo, hay que tener en cuenta que no necesariamente el uso
de un patrón implica el uso de palabras claves, reservadas o de librerías
especializadas.
Debemos tener en cuenta que los patrones suelen clasificarse en grandes grupos
los cuales estaremos viendo con mayor profundidad son:
● Patrones comportamentales.
● Patrones creacionales.
● Patrones estructurales.
3.1. Patrones comportamentales.
Se centran en definir la manera en que los objetos interactúan entre ellos, por medio de
mensajes.
Estos son los patrones comportamentales:
● Chain of responsibility
El patrón de diseño Chain of Responsibility es un patrón de comportamiento que
evita acoplar el emisor de una petición a su receptor dando a más de un objeto la
posibilidad de responder a una petición.
● Command
Convierte una solicitud en un objeto independiente que contiene toda la información
sobre la solicitud. Esta transformación permite parametrizar métodos con diferentes
solicitudes, retrasar o poner en cola la ejecución de una solicitud y respaldar
operaciones que no se pueden deshacer.
● Interpreter
Se utiliza para evaluar el lenguaje o la expresión al crear una interfaz que indique el
contexto para la interpretación.
● Iterator
Su utilidad es proporcionar acceso secuencial a un número de elementos presentes
dentro de un objeto de colección sin realizar ningún intercambio de información
relevante.
● Mediator
Este patrón proporciona una comunicación fácil a través de su clase que permite la
comunicación para varias clases.
● Memento
El patrón Memento permite recorrer elementos de una colección sin exponer su
representación subyacente.
● Observer
Permite definir un mecanismo de suscripción para notificar a varios objetos sobre
cualquier evento que le suceda al objeto que está siendo observado.
● State
En el patrón state, el comportamiento de una clase varía con su estado y, por lo
tanto, está representado por el objeto de contexto.
● Strategy
Permite definir una familia de algoritmos, poner cada uno de ellos en una clase
separada y hacer que sus objetos sean intercambiables.
● Template method
Se usa con componentes que tienen similitud donde se puede implementar una
plantilla del código para probar ambos componentes. El código se puede cambiar
con pequeñas modificaciones.
● Visitor
El propósito de un patrón Visitor es definir una nueva operación sin introducir las
modificaciones a una estructura de objeto existente.
3.2. Patrón estructurales.
Se define como un patrón de comportamiento, que permite encapsular un conjunto de
algoritmos, de manera que pueden ser seleccionados dinámicamente para su ejecución,
también facilitan soluciones y estándares eficientes con respecto a las composiciones de
clase y las estructuras de objetos. El concepto de herencia se utiliza para componer
interfaces y definir formas de componer objetos para obtener nuevas funcionalidades.
Tratan la manera en que los objetos se conectan con otros objetos, para asegurar
que los cambios del sistema no requieren cambiar esas conexiones, también
facilitan las soluciones y estándares eficientes con respecto a las composiciones de
clase y las estructuras de objetos. El concepto de herencia se utiliza para componer
interfaces y definir formas de componer objetos para obtener nuevas
funcionalidades.
Estos son los patrones de estructura:
● Adapter.
Nos ayuda a definir una clase intermedia que sirve para que dos clases con
diferentes interfaces puedan comunicarse. Esta clase actúa como mediador,
haciendo que la clase A pueda ejecutar métodos de la clase B sin conocer
detalles de su implementación. También se conoce como Wrapper.
● Decorator.
Permite añadir funcionalidad extra a un objeto (decora el objeto) sin modificar
el comportamiento del resto de instancias.
● Facade.
Una fachada es un objeto que crea una interfaz simplificada para tratar con
otra parte del código más compleja.
● Bridge.
En este patrón hay una alteración estructural en las clases principales y de
implementador de interfaz sin tener ningún efecto entre ellas. Estas dos
clases pueden desarrollarse de manera independiente y solo se conectan
utilizando una interfaz como puente.
● Composite.
Se usa para agrupar objetos como un solo objeto. Permite componer objetos
en estructuras de árbol y luego trabajar con estas estructuras como si fueran
objetos individuales.
● Flyweight.
El patrón Flyweight se usa para reducir el uso de memoria y mejorar el
rendimiento al reducir la creación de objetos. El patrón busca objetos
similares que ya existen para poderlos reutilizar en lugar de crear otros
nuevos que sean similares.
● Proxy.
Se utiliza para crear objetos que pueden representar funciones de otras
clases u objetos y la interfaz se utiliza para acceder a estas funcionalidades
3.3. Patrones creacionales.
Los patrones de creación proporcionan diversos mecanismos de creación de
objetos, que aumentan la flexibilidad y la reutilización del código existente de una
manera adecuada a la situación. Esto le da al programa más flexibilidad para decidir
qué objetos deben crearse para un caso de uso dado.
Estos son los patrones creacionales:
● Abstract Factory
En este patrón, una interfaz crea conjuntos o familias de objetos relacionados sin
especificar el nombre de la clase.
● Builder Patterns
Permite producir diferentes tipos y representaciones de un objeto utilizando el
mismo código de construcción. Se utiliza para la creación etapa por etapa de un
objeto complejo combinando objetos simples. La creación final de objetos depende
de las etapas del proceso creativo, pero es independiente de otros objetos.
● Factory Method
Proporciona una interfaz para crear objetos en una superclase, pero permite que las
subclases alteren el tipo de objetos que se crearán. Proporciona instanciación de
objetos implícita a través de interfaces comunes
● Prototype
Permite copiar objetos existentes sin hacer que su código dependa de sus clases.
Se utiliza para restringir las operaciones de memoria / base de datos manteniendo la
modificación al mínimo utilizando copias de objetos.
● Singleton
Este patrón de diseño restringe la creación de instancias de una clase a un único
objeto.
4. La vista de componentes para visualizar el software:
Los diagramas de componentes, por ejemplo, permiten visualizar de forma clara qué
bloques modulares se pueden utilizar varias veces en varios puntos de una
arquitectura. Así, los sistemas se pueden diseñar para optimizar la reutilización de
los componentes y su interacción.
A Continuación estaremos presentado el diagrama de componente:
5. La vista de despliegue del software:
El Diagrama de Despliegue es un tipo de diagrama del Lenguaje Unificado de
Modelado que se utiliza para modelar la disposición física de los artefactos software
en nodos.Muestra la arquitectura del sistema como el despliegue de los artefactos
de software a los objetivos de despliegue.
A Continuación estaremos presentando el diagrama de despliegue:
6. Conclusión.
Para concluir, pudimos observar que los diseños de patrones se refiere a el uso de
interfaces, clases y objetos la cual son ajustados con la solución concreta del
desarrollo, los cuales se clasifican en los patrones de comportamiento, creacionales
y estructurales, por lo tanto cumplen con ciertas funciones y objetivos. Se vio la vista
de componentes que varía en un diagrama que permite la mejor y clara
visualización de los bloques de módulos, con su respectivo diagrama, desarrollado
basándonos en el proyecto que estamos realizando, también se relata la
visualización de despliegue el cual nos da a entender que es un diagrama de
lenguaje unificado de modelo, el cual moldea la disposición física del artefacto del
software, también con su respectivo diagrama.
7. Biografía:
https://profile.es/blog/patrones-de-diseno-de-software/
https://es.wikipedia.org/wiki/Archivo:Strategy_Pattern.jpg
https://profile.es/blog/patrones-de-diseno-de-software/#Patrones_creacionales
