Lectores como tú ayudan a apoyar a MUO. Cuando realiza una compra utilizando enlaces en nuestro sitio, podemos ganar una comisión de afiliado.
El patrón de diseño de método de plantilla le permite definir los pasos de un algoritmo dentro de un único método de una clase. Esto le permite restringir operaciones específicas de una aplicación a un solo método.
Cada paso del algoritmo que define el método de plantilla es un método interno. Sin embargo, el método de plantilla solo maneja la implementación de algunos de sus métodos internos. Las subclases generalmente implementan uno o más de los métodos internos del método de plantilla.
Una subclase puede implementar un método abstracto, pero no puede redefinir el algoritmo implementado por un método final.
Cómo funciona el método de la plantilla
Un patrón de método de plantilla típico tendrá la siguiente estructura:
finalvacíotemplateMethod(){
operaciónabstracta1();
operaciónabstracta2();operaciónconcreta1();
operaciónconcreta2();
gancho();
}
Lo primero que hay que tener en cuenta es que templateMethod() es definitivo, por lo que ninguna subclase puede anular este método. La otra cosa importante a tener en cuenta son los tres tipos de métodos que utiliza el patrón de método de plantilla: concreto, abstracto y gancho.
La clase abstracta que alberga el método plantilla implementa todos sus métodos concretos, mientras que las subclases concretas implementan sus métodos abstractos. El método de enlace generalmente no hace nada por defecto, pero una subclase tiene la capacidad de anular estos métodos cuando sea necesario.
Implementando el patrón del método de plantilla en Java
El patrón del método de plantilla actúa como un marco para una aplicación. Por lo tanto, a menudo verá este patrón en los marcos de software que proporcionan el modelo para el desarrollo de aplicaciones.
Por ejemplo, puede conectar su aplicación a uno de los muchos sistemas de bases de datos. Los pasos para conectarse y usar una base de datos siguen una plantilla similar:
públicoabstractoclaseBase de datos{
// método de plantilla
finalvacíoplantilla de base de datos(){
// métodos abstractos
setDBDriver();
establecer Credenciales();// método concreto
conectar();// métodos abstractos
crear DB();
establecerDatos();
leerDatos();// métodos de enganche
if (usuarioQuiereActualizar()) {
actualizar datos();
}if (usuarioQuiereEliminar()) {
borrar datos();
}// método concreto
conexión cercana();
}abstractovacíoestablecerDBDriver();
abstractovacíoestablecer credenciales();
abstractovacíocrear DB();
abstractovacíoestablecer datos();
abstractovacíoleer datos();
abstractovacíoactualizar datos();
abstractovacíoborrar datos();vacíoconectar(){
Sistema.fuera.println("Conectando a la base de datos...");
}vacíoconexión cercana(){
Sistema.fuera.println("Destruyendo la conexión de la base de datos...");
}booleanousuarioQuiereActualizar(){
devolverFALSO;
}
booleanousuarioQuiereEliminar(){
devolverFALSO;
}
}
Esta clase de base de datos de ejemplo usa el patrón del método de plantilla para crear una plantilla que puede usar con cualquier base de datos. Para usar una base de datos, su aplicación deberá conectarse a ella y luego destruir la conexión después de usarla. Estas actividades suelen ser las mismas para todas las bases de datos. Por lo tanto, la clase de base de datos abstracta puede implementar el conectar() y conexión cercana() métodos.
Los otros métodos en el método de plantilla diferirán según el tipo de base de datos. Por ejemplo, una base de datos MySQL almacena datos en tablas, mientras que una La base de datos MongoDB almacena datos en colecciones. Si desea utilizar un Base de datos MySQL en Java, simplemente cree una nueva clase de MySQL que amplíe la clase de base de datos:
públicoclasemysqlextiendeBase de datos{
@Anular
vacíoestablecerDBDriver(){
Sistema.fuera.println("Seleccionando controlador MySQL...");
}@Anular
vacíoestablecer credenciales(){
Sistema.fuera.println("Configuración de la credencial de la base de datos MySQL...");
}@Anular
vacíocrear DB(){
Sistema.fuera.println("Creando una nueva tabla...");
}@Anular
vacíoestablecer datos(){
Sistema.fuera.println("Insertando datos en la base de datos...");
}@Anular
vacíoleer datos(){
Sistema.fuera.println("Recuperando datos de la base de datos...");
}@Anular
vacíoactualizar datos(){
Sistema.fuera.println("Actualizando datos en la base de datos...");
}
@Anular
vacíoborrar datos(){
Sistema.fuera.println("Eliminando datos de la base de datos...");
}
}
La clase MySQL implementa todos los métodos abstractos de la clase Database. También puede anular algunos métodos concretos. Sin embargo, no puede tocar el plantilla de base de datos () método, que utiliza la palabra clave final.
públicoclasePrincipal{
públicoestáticovacíoprincipal(Cadena[] argumentos){
Base de datos mySQLDB = nuevo mysql();
mySQLDB.databaseTemplate();
}
}
Esta clase principal crea un nuevo objeto de base de datos MySQL y utiliza el método de plantilla para simular cómo se conectaría una aplicación a la base de datos. Ejecutar el método principal imprime el siguiente resultado en la consola:
En la salida, notará que la aplicación nunca llama al actualizar datos() y borrar datos() métodos. Esta es la razón por la cual los métodos de gancho son importantes. En una base de datos SQL, querrá crear nuevas tablas, insertar datos y ver sus datos. Sin embargo, es posible que no desee actualizar o eliminar datos. Por lo tanto, los métodos de enlace dan a las subclases la opción de controlar estos aspectos críticos del algoritmo.
@Anular
booleanousuarioQuiereActualizar(){
devolververdadero;
}Simplemente agregando el código anterior a la clase MySQL, la aplicación ahora actualiza los datos en la base de datos. Si vuelve a ejecutar la clase Main, mostrará el siguiente resultado actualizado:
Como puede ver, la aplicación ahora está actualizando los datos en la base de datos.
Los beneficios de usar el patrón de diseño del método de plantilla
Un beneficio importante del patrón del método de plantilla es que promueve la reutilización del software. Este patrón de diseño también admite una programación eficiente. Una subclase solo necesita implementar métodos que son únicos para su operación.
Además, una aplicación que utiliza el patrón de método de plantilla es más segura, ya que las clases externas no pueden alterar su estructura de operación.
