▷ Curso de JAVA: Cómo crear un Login? (Con conexión a base de datos MVC)

En este nuevo capítulo nos adentraremos a una parte esencial de este curso, cuando se trata de desarrollar una aplicación surge la necesidad de validar el ingreso a nuestro sistema, esto lo hacemos a través de una validación de usuario. Donde el administrador del sistema ingresa digitando un usuario y una contraseña en la cual los datos de acceso se encuentran previamente almacenados en una base de datos, lo que nosotros hacemos simplemente es validar la información ingresada con la información o datos de acceso que ya tenemos en nuestra base de datos.
Para el desarrollo de este ejemplo aplicaremos el patrón de diseño Modelo Vista Controlador (MVC), aplicando este patrón de diseño básicamente lo que haremos es separar la parte lógica de nuestra aplicación con la parte gráfica, este concepto  será ampliado en el transcurso de este tutorial.
Te recomiendo los siguientes POST para ampliar conceptos que estaremos tratando en el desarrollo de este ejemplo.
Cómo hacer un Pool de Conexiones?
Cómo hacer un proyecto, un paquete y un formulario?

Explicación por Videotutorial:

Parte 1 Modelo

Parte 2 Controlador

Parte 3 Vista

Explicación por Foto-Tutorial: 

Antes de adentrarnos en el desarrollo de nuestro  ejemplo, explicare el concepto del patrón de diseño modelo-vista-controlador (MVC). Este será la base de nuestra aplicación.

Según Wikipedia el MVC se define como: 

"Un patrón de arquitectura de software, que separa los datos y la lógica de negocio de una aplicación de su representación y el módulo encargado de gestionar los eventos y las comunicaciones. Para ello MVC propone la construcción de tres componentes distintos que son el modelo, la vista y el controlador, es decir, por un lado define componentes para la representación de la información, y por otro lado para la interacción del usuario."

En resumidas cuentas lo que logramos bajo esta arquitectura es dividir nuestro código de aplicación en tres capas la parte de la vista podemos definirla como la sección de nuestra aplicación donde están todos lo componentes gráficos de esta, la cual podrá interactuar con el administrador o usuario que maneje el sistema.
La sección del modelo se encuentra  toda la parte lógica de nuestra aplicación, para el ejemplo que desarrollaremos en la sección del modelo, irán los métodos y clases que nos permitirán acceder a la base de datos.
La sección del controlador será él puente de comunicación entre la vista y el modelo en esta se identificaran los eventos que accione el administrador del sistema, aplicado a nuestro ejemplo; cuando el administrador del sistema ingrese los datos de acceso y este oprima el botón de inicio de sesión, se activara un evento en la clase controlador, la cual se comunicara con el la clase modelo que realizara la consulta a la base de datos y esta arrojara los resultados, donde validaremos si el usuario y contraseña coinciden con los almacenados en la base de datos. 

NOTA: Si tienes dificultad o quieres reforzar conceptos de base de datos te invito a que visites nuestro curso de MySQL

1.  Trabajaremos con una base de datos a la cual hemos llamado "ejemplousuarios", la cual contara con una tabla que lleva la siguiente estructura:

Base de datos "ejemplousuarios"

Una vez creada la base de datos creamos una tabla la cual contiene 3 campos, el primer campo (id) es de tipo entero esta será la Primary key o Llave primaria de la tabla. El segundo campo (User) tipo VARCHAR en el cual guardaremos los respectivos nombres de usuarios, por ultimo tenemos el campo Pass es un campo de tipo LONGBLOB, en el cual almacenaremos las respectivas contraseñas.

NOTA: Es recomendable trabajar con campos tipo BLOB (
LONGBLOB), cuando de almacenar contraseñas se trate para tener mayor seguridad en estas.
Estos temas pueden interesarte.
Cómo crear una Base de datos con phpMyAdmin y MySQL Workbench?
Cómo crear una tabla con phpMyAdmin y Workbench?

2.  La estructura de nuestro proyecto en java, constara de cuatro paquetes, estos serán: 
paquete controlador; el cual contendrá la clase controlador.java. 
paquete imagenes; agregaremos los archivos externos(imágenes) que utilizara nuestra aplicación. 
paquete loginmvc; contendrá tres clases (Inicio.java, LoginMVC.java y login.java) aquí agregaremos nuestra clase principal y la interfaz gráfica que estaremos manejando.
paquete modelo;  contendrá tres clases(User.java, modelUser.java, pool.java) esta clases nos permitirán establecer la conexión con la base de datos e igualmente la validación de los datos de inicio de sesión de usuario.
Por ultimo agregaremos las librerías requeridas a nuestro proyecto, con el fin de poder usar los métodos y clases de estas.

NOTA: Las librerías utilizadas en este proyecto junto con el código fuente, puedes acceder a estos en la zona de descargas.

Estructura Proyecto java

3.  Iniciamos creando las clases del paquete modelo, la primera que crearemos  será la clase pool.java, la cual nos permitirá realizar las configuraciones requeridas para poder conectarnos con la base de datos (ejemplousuarios).
Entre las llaves {} de apertura y cierre de nuestra clase, creamos una serie de objetos y variables en los cuales almacenaremos los datos de conexión a la base de datos, por ejemplo:
En la variable db la cual será tipo String agregaremos el nombre de la base de datos.
En la variable url escribimos la dirección en la cual se encuentra la base de datos, nosotros la trabajaremos de manera local. 
En la variable user guardamos el usuario que tiene acceso a dicha base de datos, trabajaremos con el que viene por defecto (root).


Clase pool.java

package modelo;

import javax.sql.DataSource;
import org.apache.commons.dbcp.BasicDataSource;

/**
 *
 * @author jorgeluis
 */

public class pool {
    
    public DataSource dataSource;
    public String db = "ejemplousuarios";

    public String url = "jdbc:mysql://localhost/"+db";
    public String user = "root";
    public String pass = "";
    public pool(){

        inicializaDataSource();

    }

    private void inicializaDataSource(){


        BasicDataSource basicDataSource = new BasicDataSource();

        basicDataSource.setDriverClassName("com.mysql.jdbc.Driver");
        basicDataSource.setUsername(user);
        basicDataSource.setPassword(pass);
        basicDataSource.setUrl(url);
        basicDataSource.setMaxActive(50);

        dataSource = basicDataSource;

    }

    

    
}

NOTA: Te recomiendo el siguiente POST en el cual aprenderás a detalle Cómo hacer un Pool de Conexiones?

4.  El siguiente paso será crear la clase Usuario.java, esta clase tendrá unos componentes precisos, ya que a través de esta clase podemos asignar o mostrar los valores obtenidos de la base de datos.
Para esto debemos crear una serie de variables que harán referencia a los campos que contiene la tabla en nuestra base de datos. Por ejemplo:
Nuestra tabla usuarios, tiene un campo id, User y Pass, esto quiere decir que las variables que necesitaremos crear en nuestra clase serán dos, una hará referencia a User y otra a Pass.

Dentro de las llaves {} de apertura y cierre, creamos dos variables tipo String, la cual llamaremos User y Pass respectivamente, el modificador de acceso de estas variables será de tipo private. 
Seguido a esto creamos el método constructor e inicializamos las variables creadas con anterioridad (User y Pass).
Creamos los métodos get y set de las variables esto con el fin de obtener los valores de dichas variables, desde otra clase.

Clase Usuario.java

package modelo;
/** * * @author Software Galaxia */
public class Usuario {

private String User;
private String Pass;

public Usuario(){
User="";
Pass="";
}

public String getUser() {
return User;
}

public void setUser(String User) {
this.User = User;
}

public String getPass() {
return Pass;
}

public void setPass(String Pass) {
this.Pass = Pass;
}

}

5.  El siguiente paso será crear la clase metodosUsuario.java, esta clase tendrá los métodos que nos permitirán realizar la validación con los datos almacenados; en el cual verificaremos si lo datos ingresados por el usuario o administrador del sistema son válidos.

*Iniciamos importando las respectivas librerías que utilizaremos, para el correcto funcionamiento de nuestro código.

importamos las librerías requeridas

*Una vez importadas las librerías, dentro de las llaves {} de apertura y cierre de nuestra clase, creamos un objeto de tipo pool  llamado conexion, seguido a esto inicializamos nuestro objeto desde el método constructor de la clase.
Recordemos que la clase pool contiene los datos de acceso a la base de datos

Clase modelUser.java

*Lo que haremos será crear una función, que nos devolverá un elemento de tipo ArrayList  nuestro ArrayList sera de tipo Usuario (clase), recordemos que esta es la clase que creamos en el paso anterior (paso 4), la estructura de nuestra función será de acceso public (public ArrayList<Usuario>) llevara dos parámetros tipo String que harán referencia al usuario y contraseña.(public ArrayList<Usuario> login(String user, String clave){}).

* Debemos crear 5 objetos de suma importancia para este método:
   1- objeto tipo Conection (conectar) el cual nos permitirá administrar la             conexión obtenida con la base de datos.
   2- objeto tipo PreparedStatement (pst) el cual principalmente nos                   permitirá cargar y ejecutar la sentencia sql que estaremos creando.
  3-  objeto tipo ResultSet (rs) el cual nos permitirá obtener los resultados             que arroje la consulta sql que estaremos realizando.
  4- objeto tipo Usuario (cuenta), este objeto almacenara los resultados              obtenidos de la base de datos, posteriormente serán asignados a un              ArrayList.
   5- objeto tipo ArrayList (list) agregaremos cada elemento obtenido de               manera ordenada. 

método login

*  Creamos un bloque de tipo try-catch-finally, en la sección del try iniciamos obteniendo la conexión con la base de datos, el resultado obtenido lo asignaremos al objeto conectar (tipo Connection). Seguido a esto verificamos si conectar es diferente de null.

establecer conexión con la base de datos

*  Nos posicionamos en la sección donde realizamos la consulta a la base de datos, la cual consta de la siguiente estructura.

Select User, Pass From usuarios

En la primera sección de la sentencia, iniciamos con la palabra clave Select la cual es utilizada cuando queremos obtener información de la base de datos, seguido  a esto seleccionamos los campos a los cuales deseamos acceder, en este caso será: el campo User y Pass, igualmente seleccionamos la tabla a la cual deseamos acceder en este caso es la tabla usuarios.

WHERE User=? AND Pass=AES_ENCRYPT(?, 'key')

La segunda sección de nuestra sentencia es la parte de las condiciones requeridas para la búsqueda, hacemos uso de la palabra clave WHERE, en la cual necesitaremos verificar si el usuario y contraseña coinciden con la información almacenada en la base de datos, debemos hacer uso de una función propia de MySQL, la cual es AES_ENCRYPT, la cual nos permitirá encriptar la contraseña ingresada y así compararla con el campo de la base de datos.
Consta de dos parámetros (?, 'key'), el primero hará referencia a la contraseña ingresada para este ejemplo es "1234", el segundo parámetro será la llave que nos permitirá acceder a esta, nuestra llave será 'key'.

sentencia SQL y parametros

* Una vez pasado los respectivos parámetros de consulta y una vez ejecutada la misma, debemos obtener dicho resultados esto lo haremos con las siguientes líneas de código:
                 

Verificamos Resultados de consulta SQL

Clase metodosUsuario.java

package modelo;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import javax.swing.JOptionPane;

public class metodosUsuario {
    

  private final pool conexion;
    
  public metodosUsuario(){
    conexion=new pool();


  }

    public ArrayList<Usuario> login(String user, String clave){
     
           Connection conectar=null;
           PreparedStatement pst;
           ResultSet rs ;
           Usuario cuenta ;
           ArrayList list = new ArrayList();
       
          try{
               // obtenemos la conexion con la base de datos
               conectar = conexion.dataSource.getConnection(); 
           
               if(conectar != null){

                   String sql ="SELECT User, Pass FROM usuarios WHERE User =? AND Pass=AES_ENCRYPT(?, 'key')";
                   pst = conectar.prepareStatement(sql);
                   pst.setString(1, user);
                   pst.setString(2, clave);
                   rs = pst.executeQuery();
               
                   if(rs.next()){
                   
                        cuenta = new Usuario();
                        cuenta.setUser(rs.getString("User"));
                        cuenta.setPass(rs.getString("Pass"));                                       
                        list.add(cuenta);
                  }
           
             }else{
             
                 JOptionPane.showMessageDialog(null, "Hubo un error al realizar la operación, intente mas tarde","ERROR",JOptionPane.ERROR_MESSAGE);
             }
       
         }catch(SQLException e){
     
             JOptionPane.showMessageDialog(null, e , " .::Error En la Operacion::.", JOptionPane.ERROR_MESSAGE);
       
        }finally{
            try{
              conectar.close();
            }catch(SQLException ex){
               System.out.println("error "+ex);
            }
         }
 
    return list;
    }

}   

6.  Una vez creada las clases del paquete modelo, procedemos a crear la clase controlador.java; la cual tendrá la siguiente estructura.

Imports Clase controlador.java

*Iniciamos realizando las respectivas importaciones de librerías y clases con las cuales vamos a trabajar.

Linea inicial controlador.java

*Creamos nuestra clase la cual llamaremos controlador.java, hacemos uso de la palabra clave implements, y de estas manera llamar la interfaz ActionListener, la cual la utilizaremos para accionar los eventos que vamos a trabajar en este ejemplo, estos eventos se ejecutaran cuando presionemos el botón de inicio de sesión o el botón salir.

Objetos pertenecientes a la vista y modelo

*Lo siguiente que haremos será crear tres objetos, recordemos que esta clase es la que comunicara las clases de la vista y el modelo; por lo tanto creamos un objeto tipo login la cual contiene los elementos de la interfaz gráfica(vista). Creamos un objeto tipo metodosUsuarios, recordemos que esta clase contiene el método que nos permitirá validar la información ingresada con la que tenemos almacenada en base de datos.
Creamos un objeto tipo inicio, el cual contiene una vista de inicio que mostraremos si el usuario y contraseña son correctos.

Agregamos los eventos al controlador

* Creamos un método (eventos), en el cual asignaremos eventos a los respectivos componentes de la vista, recordemos que; para acceder a los componentes de otra clase, debemos hacer uso de un objeto (view) de esta, seguido del nombre del componente y por ultimo llamamos el método addActionListener.

método constructor

* Lo siguiente que haremos será crear el método constructor de la clase, 
el cual llevará un parámetro de tipo login(vista), inicializamos el objeto view que creamos( this.view=vista;) e igualmente agregamos el método eventos, de esta manera pasaremos a la sección mas importante de nuestro código que es el control de los eventos.

método actionPerformed

*Al utilizar la palabra clave implements seguido de actionListener al inicio de nuestra clase, esto nos permitirá acceder a su método actionPerformed, dentro de este método irán todas las acciones que deseamos que se ejecuten, la cual debemos controlar a través de condicionales.

La variable la cual controlara los eventos que se accionen será evt, en el primer condicional verificamos si se ha oprimido el botón de inicio de sesión(if(evt.equals(view.btn_enter))), seguido a esto debemos verificar si el campo usuario(txt_user) y el campo contraseña(txt_pass) tienen información valida.

* De esta manera nace nuestro primer condicional, en el cual verificamos si el campo txt_user o el campo txt_pass están vació; si la condición se cumple, imprimimos un mensaje de advertencia. 

Condicional

* En la sección del sino (else{}) iniciamos creando una variable tipo String, la cual le asignaremos la información contenida en el campo txt_user haciendo uso del método getText(). Seguido a esto creamos un objeto tipo ArrayList y este sera de tipo Usuario (ArrayList<Usuario> list), recordemos que la función que se encuentra en la clase metodosUsuario devuelve un valor de este tipo. Por ultimo llamamos la función login haciendo uso del objeto modelo el resultado que obtengamos lo asignaremos al ArrayList(list) llevara dos parámetros los cuales serán los valores ingresados en los campos de texto(user, pass).

clase controlador.java

* El siguiente paso es verificar si se obtuvo resultado de dicha consulta, verificamos si la longitud del ArrayList es mayor que cero, haciendo uso del método size ().

Si es mayor que cero mostraremos un mensaje de bienvenida; cerraremos la ventana actual, haciendo uso del método dispose () y haremos visible la nueva ventana haciendo uso del método setVisible el cual le pasamos como parámetro true.

Sino mostraremos un mensaje y denegamos el acceso a nuestro sistema.
        

clase controlador.java

* Trabajaremos los eventos restantes los cuales se activaran cuando se presione el botón salir(btn_exit) y cuando activemos el checkbox que nos permitirán desenmascara y enmascarar la contraseña

Eventos Controlador.java

Clase Controlador.java             

package controlador;

import iniciosesionmvc.Inicio;
import iniciosesionmvc.login;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;
import javax.swing.JOptionPane;
import modelo.Usuario;
import modelo.metodosUsuario;

public class controlador implements ActionListener{
    
    private login view;
    private metodosUsuario modelo = new metodosUsuario();
    Inicio inicio = new Inicio();
    
    public void eventos(){
        view.btn_enter.addActionListener(this);
        view.btn_exit.addActionListener(this);
        view.checkviewpass.addActionListener(this);
    }
    
    public controlador(login vista){
        this.view=vista;
        eventos();
    }

    @Override
    public void actionPerformed(ActionEvent e) {

        Object evt = e.getSource();
        
        if(evt.equals(view.btn_enter)){
            
            char p [] =view.txt_pass.getPassword();
            String pass = new String(p);
            
            if(view.txt_user.getText().isEmpty() || pass.isEmpty()){
                
                JOptionPane.showMessageDialog(null, "Debe digitar un Usuario y una Contraseña", "Error en la Operación", JOptionPane.ERROR_MESSAGE);                
                
            }else{
                
                String user=view.txt_user.getText();
                ArrayList<Usuario> list;
                list = modelo.login(user, pass);
                
                if(list.size()>0){
                    
                    JOptionPane.showMessageDialog(null, "Bienvenido al sistema");
                    view.dispose();
                    inicio.setVisible(true);
                    
                }else{
                    JOptionPane.showMessageDialog(null, "Acceso Denegado", "Error", JOptionPane.ERROR_MESSAGE);
                }
                
                
                
            }
            
        }else if(evt.equals(view.btn_exit)){
            
            int confirmar = JOptionPane.showConfirmDialog(null, "Esta seguro que desea salir del sistema?");
            
            if(confirmar==JOptionPane.YES_OPTION){
                System.exit(0);
            }
            
        }else if(evt.equals(view.checkviewpass)){
            if(view.checkviewpass.isSelected()){
                view.txt_pass.setEchoChar((char) 0);
            }else{
                view.txt_pass.setEchoChar('*'); 
            }
        }
        
    }
    
}

7.  Una vez terminada la creación de la clase controlador.java nos posicionaremos en el paquete de la  vista(loginmvc) y crearemos la clase login.java, debemos conectar la vista con el controlador para esto creamos un objeto de la clase controlador.java en el método constructor inicializamos el objeto creado al cual le pasaremos el parámetro de nuestra vista(controlador=new controlador(this)), una vez hecho esto tendremos nuestro proyecto debidamente conectado.

8.  Vista inicial interfaz gráfica login.

Inicio de sesión login

datos de inicio sesión incorrectos

Activar evento desenmascarar contraseña

Acceso concedido segunda vista

Con esto hemos concluido con el desarrollo de nuestro proyecto, es recomendable tener conocimientos previos relacionado a los temas de base de datos y programación orientada objetos.

Espero este corto tutorial te haya sido de gran ayuda y pronto estaremos tratando otros temas interesantes relacionados

Si tienes alguna  otra forma de implementar esta ejemplo no dudes en compartirla, y así poder compartir opiniones sobre el tema.

Si deseas descargar el código fuente del presente tema, sólo debes dirigirte a nuestra Zona de Descargas, y dar clic sobre el icono "Curso de JAVA Parte 23".

¿Quieres aprender a realizar aún más cosas y personalizar tus programas hechos en el lenguaje de programación JAVA?, si tu respuesta es "Sí", puedes acceder a todos los tips de JAVA que hemos estado publicando en este blog, dando clic aquí.
 

Suscríbete a nuestro blog, vía Email o RSS; además puedes seguirnos a través de nuestras redes sociales como: Facebook, Twitter, YouTube y Google+. 

Si te fue de gran ayuda este material, no olvides compartirlo con tus amigos. 
Si tienes dudas o sugerencias al respecto; puedes dejarnos tus comentarios.

Bendiciones...