El propósito de este tutorial es usar una capa separada escrita en Java para acceder a tablas en una base de datos. Esta capa generalmente se llama la capa de acceso a datos (DAL)
El mayor beneficio de usar DAL es que simplifica la operación de acceso de la base de datos utilizando directamente algunos métodos como Insert () y Find (), en lugar de siempre hacer enlaces primero y luego ejecutar algunas consultas.
Esta capa maneja todas las llamadas y consultas relacionadas con la base de datos dentro de ella.
Crear una base de datos
Queremos crear una tabla simple para el usuario, podemos usar estos campos para crear
ID int
Nombre Varchar (200)
Contraseña Varchar (200)
edad int
Objeto de transferencia de datos
Esta capa debe contener una clase simple llamada objeto de transferencia de datos (DTO). Esta clase es solo un mapa simple correspondiente a la tabla en la base de datos, y cada columna en la tabla corresponde a una variable miembro de la clase.
Nuestro objetivo es usar objetos Java simples, en lugar de procesar declaraciones SQL y otros comandos relacionados con la base de datos para agregar, eliminar, modificar y verificar la base de datos.
Si queremos mapear la tabla en el código Java, solo necesitamos crear una clase (frijol) que contenga los mismos campos.
Para encapsular mejor, además de los constructores, debemos declarar todas las variables de campo como privadas, crear accesorios (getters y setters), uno de los cuales es el constructor predeterminado.
Usuario de clase pública {ID de entero privado; nombre de cadena privada; pase de cadena privada; edad de entero privado;}Para mapear los campos correctamente, debemos considerar el valor nulo en la base de datos. Para los valores predeterminados originales de Java, como el tipo int, su valor predeterminado es 0, por lo que debemos proporcionar un nuevo tipo de datos que pueda acomodar valores nulos. Podemos reemplazar INT utilizando una clase de encapsulación de tipo especial, como Integer.
Finalmente, nuestra clase debería verse así:
Usuario de clase pública {ID de entero privado; nombre de cadena privada; pase de cadena privada; edad de entero privado; Public User () {} Public User (String Name, String Pass, Integer Age) {this.name = name; this.pass = pass; this.age = edad; } Usuario público (ID de entero, nombre de cadena, pase de cadena, edad entero) {this.id = id; this.name = name; this.pass = pass; this.age = edad; } public Integer GetAge () {return Age; } public void setAge (edad entera) {this.age = edad; } public integer getId () {return id; } public void setid (ID de entero) {this.id = id; } public String getName () {nombre de retorno; } public void setName (nombre de cadena) {this.name = name; } public String getPass () {return pass; } public void setpass (string pass) {this.pass = pass; }}Una buena práctica es proporcionar el constructor vacío predeterminado, un constructor completo y un constructor completo sin parámetros de identificación.
Conectarse a la base de datos
Podemos usar una clase intermedia para facilitar la conexión a la base de datos. En esta clase, proporcionaremos los parámetros de conexión de la base de datos, como la base de datos JDBC, URL, nombre de usuario y contraseña, y definiremos estas variables como finales (será mejor obtener estos datos de propiedades o archivos de configuración XML)
Proporciona un método para devolver un objeto de conexión o devolver un nulo cuando la conexión falla o lanza una excepción de tiempo de ejecución.
public static final String url = "jdbc: mysql: // localhost: 3306/testdb"; public static final string user = "testUser"; public static final string pass = "testpass";/*** get conexión objeto* @return objeto*/public static conexión getConnection () {intit {drivermanager.registerdriver (new conduct (new Driver ()); return drivermanager.getConnection (url, usuario, pase); } Catch (SQLException ex) {Throw New RuntimeException ("Error conectándose a la base de datos", ex); }}También podemos incluir un método principal en la clase para probar la conexión. La clase completa se ve así:
import com.mysql.jdbc.driver; import java.sql.connection; import java.sql.drivermanager; import java.sql.sqlexception;/** * Conéctese a la base de datos * @author Hany.sad */publicidad de clases pública {cadena final estatica pública URL = "JDBC: mysql: // localhost: 3306/testdb"; Public static final String user = "testUser"; public static final String pass = "testPass"; / ** * Obtenga una conexión a la base de datos * @return Object de conexión */ Public Static Connection getConnection () {try {drivermanager.registerdriver (nuevo controlador ()); return drivermanager.getConnection (url, usuario, pase); } Catch (SQLException ex) {Throw New RuntimeException ("Error conectándose a la base de datos", ex); }} / ** * Test Connection * / public static void main (string [] args) {Connection Connection = ConnectionFactory.getConnection (); }}Objeto de acceso a datos
La capa DAO puede realizar operaciones CRUD. Puede agregar, eliminar, modificar y verificar nuestras tablas.
Nuestra interfaz de capa DAO debería verse así:
interfaz pública userdao {user getUser (); Establecer <Ser User> GetAllusers (); Usuario getUserByUsernameSeandPassword (); Boolean Insertuser (); Boolean UpdateUser (); boolean deleteuser ();}Encontrar usuarios
Los usuarios pueden consultar a través de cualquier campo único como ID, nombre o correo electrónico. En este ejemplo, usamos ID para encontrar al usuario. El primer paso es crear una conexión a través de la clase de conector y luego ejecutar la instrucción SELECT para obtener el usuario con su ID 7. Podemos usar esta declaración para consultar al usuario:
Seleccione * del usuario donde id = 7
Es aquí donde hacemos una declaración dinámica para obtener la identificación de los parámetros.
Al ejecutar esta consulta, se obtiene un conjunto de resultados, donde se guarda el usuario o el nulo. Podemos usar el método Next () de ResultSet para detectar si hay un valor. Si se devuelve verdadero, continuaremos utilizando los obtentadores de datos para obtener datos del usuario del resultado de resultados. Cuando encapsulamos todos los datos en el usuario, los devolvemos. Si un usuario con esta ID no existe o se produce ninguna otra excepción (como una declaración SQL no válida), este método devolverá NULL.
Public User GetUser (int id) {Connection Connection = ConnectionFactory.getConnection (); intente {Declaración stmt = Connection.CreateStatement (); ResultSet rs = stmt.executeQuery ("Seleccionar * del usuario donde id =" + id); if (rs.next ()) {user user = new User (); user.setId (rs.getInt ("id")); user.setName (rs.getString ("nombre")); user.setPass (rs.getString ("pase")); user.setage (rs.getInt ("edad")); devolver el usuario; }} Catch (Sqlexception ex) {ex.printStackTrace (); } return null;}Será más conveniente usar un método separado para extraer datos del conjunto de resultados, porque en muchos métodos lo llamaremos.
Este nuevo método lanzará una SQLException y, en aras de las limitaciones, debería ser privado:
El usuario privado ExtractuserFromResultSet (ResultSet RS) lanza SQLException {user user = new User (); user.setId (rs.getInt ("id")); user.setName (rs.getString ("nombre")); user.setPass (rs.getString ("pase")); user.setage (rs.getInt ("edad")); devolver el usuario;}Nuestro método anterior debe modificarse en un nuevo método:
Public User GetUser (int id) {Connection Connection = ConnectionFactory.getConnection (); intente {Declaración stmt = Connection.CreateStatement (); ResultSet rs = stmt.executeQuery ("Seleccionar * del usuario donde id =" + id); if (rs.next ()) {return extractUserFromResultSet (rs); }} Catch (Sqlexception ex) {ex.printStackTrace (); } return null;}Método de inicio de sesión
La operación de inicio de sesión es similar. Queremos proporcionar ID de alternativos de usuario y contraseña, que no afectarán la lista de parámetros y las declaraciones de consulta. Si el nombre de usuario y la contraseña son correctos, este método devuelve un usuario válido, de lo contrario nulo. Debido a que hay muchos parámetros, el uso de preparates será más útil.
Usuario público getUserByUsernameSeandPassword (String User, String Pass) {Connector Connector = new Connector (); Conexión Connection = conector.getConnection (); Pruebe {preparado PS = Connection.PrepareStatement ("Seleccione * de usuario donde user =? y pase =?"); Ps.SetString (1, usuario); Ps.Setstring (2, pase); ResultSet rs = Ps.ExecuteQuery (); if (rs.next ()) {return extractUserFromResultSet (rs); }} Catch (Sqlexception ex) {ex.printStackTrace (); } return null;}Cómo consultar a todos los usuarios
Este método devolverá a todos los usuarios, por lo que debemos devolverlos en un contenedor similar a una matriz. Pero porque no sabemos cuántos registros hay. Sería mejor usar una colección como Set o List:
set public getAllusers () {conector conector = nuevo conector (); Conexión Connection = conector.getConnection (); intente {Declaración stmt = Connection.CreateStatement (); ResultSet rs = stmt.ExecuteQuery ("Seleccionar * del usuario"); Establecer users = new Hashset (); while (rs.next ()) {user user = ExtractUserFromResultSet (rs); ussers.add (usuario); } Devuelve usuarios; } catch (Sqlexception ex) {Ex.PrintStackTrace (); } return null;}Insertar método
El método de inserción tomará al usuario como parámetro y usará el objeto Preparado para ejecutar la instrucción de actualización SQL. El método EjecutarUpdate devuelve el número de filas afectadas. Si agregamos una sola línea, significa que el método debe devolver 1, si es así, devolvemos verdadero, de lo contrario, devolvemos falso
Public Boolean Insertuser (usuario de usuario) {conector conector = nuevo conector (); Conexión Connection = conector.getConnection (); Pruebe {preparado PS = Connection.PrepareStatement ("Inserte en valores del usuario (nulo,?,?,?)"); Ps.SetString (1, user.getName ()); Ps.SetString (2, user.getPass ()); Ps.SetInt (3, user.getage ()); int i = ps.ExecuteUpdate (); if (i == 1) {return true; }} Catch (Sqlexception ex) {ex.printStackTrace (); } return false;}Método de actualización
El método de actualización es similar al método de inserción. El único cambio es la declaración SQL
public Boolean UpdateUser (usuario de usuario) {conector conector = nuevo conector (); Conexión Connection = conector.getConnection (); Pruebe {PrepareStatement PS = Connection.PrepareStatement ("Actualizar el user set Name =?, pass =?, edad =? donde id =?"); Ps.SetString (1, user.getName ()); Ps.SetString (2, user.getPass ()); Ps.SetInt (3, user.getage ()); Ps.SetInt (4, user.getID ()); int i = ps.ExecuteUpdate (); if (i == 1) {return true; }} Catch (Sqlexception ex) {ex.printStackTrace (); } return false;}Método Eliminar
El método para eliminar es usar una consulta simple como
Eliminar del usuario donde id = 7
Enviar la consulta con el parámetro ID eliminará este registro. Si se elimina con éxito, se devolverá 1
public boolean DeleteUser (int id) {conector conector = nuevo conector (); Conexión Connection = conector.getConnection (); intente {Declaración stmt = Connection.CreateStatement (); int i = stmt.executeUpdate ("Eliminar del usuario donde id =" + id); if (i == 1) {return true; }} Catch (Sqlexception ex) {ex.printStackTrace (); } return false;}Gracias por leer, espero que pueda ayudarte. ¡Gracias por su apoyo para este sitio!