Este artículo explica cómo realizar una operación JDBC utilizando un objeto Modelo y una clase de conexión Singleton desde una base de datos MySQL .
JDBC es una interfaz de programación de aplicaciones para Java que conecta una aplicación Java con una base de datos para realizar operaciones CRUD .
Requisito previo:
- JDK 7+ ( Haga clic aquí para descargar)
- Base de datos MySQL ( Haga clic aquí para descargar )
- MySQL J Connector ( Haga clic aquí para descargar )
- JDBC básico ( Haga clic aquí para aprender JDBC )
- Eclipse o cualquier otro IDE
Clase de modelo : la clase de modelo se usa mucho en el patrón MVC , donde funciona como un medio intermedio entre la lógica empresarial y la vista. Por lo general, un modelo contiene algunas variables y métodos de una entidad específica.
Clase Singleton : La clase Singleton es un patrón de diseño de software que garantiza que habrá una sola instancia de esa clase. Hay varias formas de lograr una clase singleton .
Enfoque: Vamos a crear una base de datos de Organización que contenga una tabla de Empleados. También crearemos una aplicación Java que se conectará con la base de datos de la Organización. La conexión se establecerá mediante una clase singleton que contendrá toda la información necesaria del controlador. Desde la aplicación Java, realizaremos algunas tareas de manipulación de datos como insertar, eliminar, actualizar y recuperar utilizando un objeto modelo de Empleado.
- Creando una base de datos MySQL y una tabla:
create database org; use org; create table employee( emp_id int auto_increment, emp_name varchar(400), emp_address varchar(400), primary key (emp_id) );
- Configuración del proyecto en eclipse:
- Crea un proyecto en eclipse llamado ‘jdbc’
- Cree una carpeta en ese proyecto llamada ‘jars’ y pegue MySQL J Connector en esa carpeta
- Agregar frascos a la ruta de compilación de Java
- Cree 4 paquetes: com.jdbc.util, com.jdbc.dao, com.jdbc.model y com.jdbc.main
- Conexión de base de datos: Cree una clase de conexión singleton DatabaseConnection en el paquete com.jdbc.util. Use su nombre de usuario y contraseña de MySQL en la variable usuario y pase. Mire cuidadosamente la última parte de la variable «url». Es obligatorio mantener el nombre igual que el nombre de la base de datos. El nombre de mi base de datos es «org», por eso puse «org» en la variable URL.
Clase de conexión de base de datos
package
com.jdbc.util;
import
java.sql.Connection;
import
java.sql.DriverManager;
import
java.sql.SQLException;
public
class
DatabaseConnection {
private
static
Connection con =
null
;
static
{
String user =
"root"
;
String pass =
"root"
;
try
{
Class.forName(
"com.mysql.jdbc.Driver"
);
con = DriverManager.getConnection(url, user, pass);
}
catch
(ClassNotFoundException | SQLException e) {
e.printStackTrace();
}
}
public
static
Connection getConnection()
{
return
con;
}
}
- Clase de modelo: cree una clase de modelo denominada Empleado en el paquete com.jdbc.model. Debe contener todos los atributos como variables.
Clase de modelo
package
com.jdbc.model;
public
class
Employee {
int
emp_id;
String emp_name;
String emp_address;
public
Employee() {}
public
Employee(String emp_name, String emp_address)
{
this
.emp_name = emp_name;
this
.emp_address = emp_address;
}
public
int
getEmp_id()
{
return
emp_id;
}
public
void
setEmp_id(
int
emp_id)
{
this
.emp_id = emp_id;
}
public
String getEmp_name()
{
return
emp_name;
}
public
void
setEmp_name(String emp_name)
{
this
.emp_name = emp_name;
}
public
String getEmp_address()
{
return
emp_address;
}
public
void
setEmp_address(String emp_address)
{
this
.emp_address = emp_address;
}
@Override
public
String toString()
{
return
"Employee [emp_id="
+ emp_id + ",
emp_name=
" + emp_name + "
,
emp_address=
" + emp_address + "
]";
}
}
- Objeto de acceso a la base de datos (DAO): crearemos una interfaz EmployeeDao y otra clase EmployeeDaoImplementation que implementa EmployeeDao. Esta clase implementada se utilizará como DAO para realizar operaciones CRUD. Usaremos PreparedStatement para ejecutar la consulta. PreparedStatement tiene 3 métodos especiales:
- executeQuery(): utilizado para recuperar datos
- executeUpdate(): se usa para insertar, actualizar, eliminar
- ejecutar(): utilizado para crear
Interfaz de EmployeeDao
package
com.jdbc.dao;
import
java.sql.SQLException;
import
java.util.List;
import
com.jdbc.model.Employee;
public
interface
EmployeeDao {
public
int
add(Employee emp)
throws
SQLException;
public
void
delete(
int
id)
throws
SQLException;
public
Employee getEmployee(
int
id)
throws
SQLException;
public
List<Employee> getEmployees()
throws
SQLException;
public
void
update(Employee emp)
throws
SQLException;
}
Clase de implementación EmployeeDao
package
com.jdbc.dao;
import
java.sql.Connection;
import
java.sql.PreparedStatement;
import
java.sql.ResultSet;
import
java.sql.SQLException;
import
java.util.ArrayList;
import
java.util.List;
import
com.jdbc.model.Employee;
import
com.jdbc.util.DatabaseConnection;
public
class
EmployeeDaoImplementation
implements
EmployeeDao {
static
Connection con
= DatabaseConnection.getConnection();
@Override
public
int
add(Employee emp)
throws
SQLException
{
String query
=
"insert into employee(emp_name, "
+
"emp_address) VALUES (?, ?)"
;
PreparedStatement ps
= con.prepareStatement(query);
ps.setString(
1
, emp.getEmp_name());
ps.setString(
2
, emp.getEmp_address());
int
n = ps.executeUpdate();
return
n;
}
@Override
public
void
delete(
int
id)
throws
SQLException
{
String query
=
"delete from employee where emp_id =?"
;
PreparedStatement ps
= con.prepareStatement(query);
ps.setInt(
1
, id);
ps.executeUpdate();
}
@Override
public
Employee getEmployee(
int
id)
throws
SQLException
{
String query
=
"select * from employee where emp_id= ?"
;
PreparedStatement ps
= con.prepareStatement(query);
ps.setInt(
1
, id);
Employee emp =
new
Employee();
ResultSet rs = ps.executeQuery();
boolean
check =
false
;
while
(rs.next()) {
check =
true
;
emp.setEmp_id(rs.getInt(
"emp_id"
));
emp.setEmp_name(rs.getString(
"emp_name"
));
emp.setEmp_address(rs.getString(
"emp_address"
));
}
if
(check ==
true
) {
return
emp;
}
else
return
null
;
}
@Override
public
List<Employee> getEmployees()
throws
SQLException
{
String query =
"select * from employee"
;
PreparedStatement ps
= con.prepareStatement(query);
ResultSet rs = ps.executeQuery();
List<Employee> ls =
new
ArrayList();
while
(rs.next()) {
Employee emp =
new
Employee();
emp.setEmp_id(rs.getInt(
"emp_id"
));
emp.setEmp_name(rs.getString(
"emp_name"
));
emp.setEmp_address(rs.getString(
"emp_address"
));
ls.add(emp);
}
return
ls;
}
@Override
public
void
update(Employee emp)
throws
SQLException
{
String query
=
"update employee set emp_name=?, "
+
" emp_address= ? where emp_id = ?"
;
PreparedStatement ps
= con.prepareStatement(query);
ps.setString(
1
, emp.getEmp_name());
ps.setString(
2
, emp.getEmp_address());
ps.setInt(
3
, emp.getEmp_id());
ps.executeUpdate();
}
}
- Pruebe la aplicación: finalmente, es hora de realizar la aplicación CRUD utilizando todos los métodos de EmployeeDaoImplementation. Cree una aplicación de clase en el paquete com.jdbc.main.
código de conductor
package
com.jdbc.main;
import
java.sql.SQLException;
import
java.util.List;
import
com.jdbc.dao.EmployeeDaoImplementation;
import
com.jdbc.model.Employee;
public
class
Application {
public
static
void
main(String[] args)
throws
SQLException
{
Employee emp =
new
Employee();
emp.setEmp_name(
"Haider"
);
emp.setEmp_address(
"Mars"
);
EmployeeDaoImplementation empDao
=
new
EmployeeDaoImplementation();
// add
empDao.add(emp);
// read
Employee e = empDao.getEmployee(
1
);
System.out.println(e.getEmp_id() +
" "
+ e.getEmp_name() +
" "
+ e.getEmp_address());
// read All
List<Employee> ls = empDao.getEmployees();
for
(Employee allEmp : ls) {
System.out.println(allEmp);
}
// update
Employee tempEmployee = empDao.getEmployee(
1
);
tempEmployee.setEmp_address(
"Asgard"
);
empDao.update(tempEmployee);
// delete
empDao.delete(
1
);
}
}
Producción:
- Para la operación de inserción , debe consultar su tabla de empleados en la base de datos de la organización.
- Para leer un elemento , use id para obtener datos e imprimirlos en la consola.
- Para mostrar todos los elementos , simplemente llame al método e imprímalo en la consola.
- La operación de actualización debe cambiar el valor actualizado en la base de datos.
- La operación de eliminación eliminará la información de esa identificación de la base de datos.
Publicación traducida automáticamente
Artículo escrito por aananda2802 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA