Problema de pothenot
jueves, 10 de octubre de 2024
jueves, 3 de octubre de 2024
.jpg){kind=spacer}
domingo, 11 de agosto de 2024
lunes, 27 de mayo de 2024
Capítulo
Nº 6
Cómo
hacer el diálogo usuario
y
contraseña en Java
Toda aplicación debe contar con una función que permita ingresar con seguridad al sistema y cuidar de que usuarios no autorizados puedan ingresar a la misma. Por eso es típico implementar la muy conocida caja de diálogo donde se exija ingresar con un usuario y contraseña.
En esta sección se ilustrará con detalle cómo construir una ventana o caja de diálogo donde el usuario deba colocar su nombre de usuario y una contraseña para poder ingresar al sistema.
Para mostrar en pantalla la ventana o diálogo, como se muestra en la figura mostrada abajo, es necesario construir una clase llamada "Password.java" y utilizar algunos métodos como setBounds, setResizable y setLayout.
setResizable: Para manejar si la ventana se puede maximizar o no.
setBounds (x,y,Largo,Ancho): Para ubicar los elementos en el formulario.
setLayout: Para anular el gestor de diseño por defecto.
Password.java
//***************************************************************************************
//**** Universidad Nacional Sistema de Inscripción Regular (UNSIR
3.0.0) ****
//****
****
//**** CLASE: Password (Para crear el diálogo que sirve para ingresar
usuario y ****
//**** contraseña de acceso)
****
//**** ****
//**** AUTOR: CARLOS CÓRDOVA - CC DESARROLLO DE SOFTWARE 2007-2024 ****
//***************************************************************************************
//***************************************************************************************
// Paquetes de la librería estándar de clases de Java que se usarán en
esta clase
//***************************************************************************************
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
//***************************************************************************************
// Inicio Clase Password (Clase principal)
//***************************************************************************************
public
class Password extends JFrame implements ActionListener
{
//*** Se asigna a la variable
curDir la ruta actual de nuestra carpeta de trabajo
String curDir =
System.getProperty("user.dir");
ImageIcon imagen = new
ImageIcon(curDir+"/Usuarios.gif");
//*** Se asignan a los objetos la imagen, etiquetas, cajas de texto y botones
JLabel EtiquetaInUsuario = new JLabel("Usuario :");
static TextField CajaTextoInUsuario = new
TextField(11);
JLabel EtiquetaInContrasena = new JLabel("Contraseña :");
static TextField CajaTextoInContrasena = new
TextField(11);
JButton BotonAceptar = new JButton("Aceptar");
JButton BotonCancelar = new
JButton("Cancelar");
//*** Se define el método principal "main" de la Clase Password
//*** Se define el aspecto
de ventanas propio del sistema operativo (windows, Mac, Linux, etc.)
{
UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
}
catch (Exception e)
{
e.printStackTrace();
}
new Password();
}
{
//*** Se define el título y
tamaño de la ventana
setTitle("Usuario y contraseña");
setBounds( 0, 0, 280, 210 );
setResizable(false);
//*** Se cambia el icono de la ventana por el archivo "UN.gif" que está en nuestra carpeta de trabajo
setIconImage (new ImageIcon(curDir+"/UN.gif").getImage());
//*** y botones del diálogo
o ventana
CajaTextoInUsuario.setText("");
CajaTextoInContrasena.setEchoChar('*');
BotonAceptar.setToolTipText("Ingresar usuario...");
BotonCancelar.setToolTipText("Cancelar y salir");
// 2.- Ubicar el elemento
-> elemento.setBounds (x,y,a,b)
// 3.- Agregar al formulario
o dialogo el elemento -> add.(elemento)
//*** Anulamos el Gestor de Diseño
setLayout(null);
add(EtiquetaImagen);
add(EtiquetaInUsuario);
add(CajaTextoInUsuario);
add(EtiquetaInContrasena);
add(CajaTextoInContrasena);
add(BotonAceptar);
add(BotonCancelar);
Dimension pantalla, cuadro;
pantalla =
Toolkit.getDefaultToolkit().getScreenSize();cuadro = this.getSize();
this.setLocation(((pantalla.width -
cuadro.width)/2),(pantalla.height - cuadro.height)/2);
setVisible(true);
//*** Eventos producidos por los botones de la ventana
addWindowListener(new WindowAdapter()
{
public void windowClosing(WindowEvent
e)
{
//*** Se ejecuta el
método CierraVentana
CierraVentana();
}
});
{
public void actionPerformed(ActionEvent
evt)
{
//*** Aquí se coloca la
función que produzca el evento luego de pulsar el botón
"Aceptar"
}
});
{
public void actionPerformed(ActionEvent
evt)
{
//*** Se ejecuta el
método CierraVentana
CierraVentana();
}
});
}
{
Object s = e.getSource();
}
{
JRootPane rootPane = new JRootPane();
KeyStroke stroke1 =
KeyStroke.getKeyStroke("ESCAPE");
KeyStroke stroke2 =
KeyStroke.getKeyStroke("ENTER");
//*** Acción para cerrar la ventana pulsando la tecla "ESC"
{
public void actionPerformed(ActionEvent
actionEvent)
{
CierraVentana();
}
} ;
InputMap inputMap =
rootPane.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW);
inputMap.put(stroke1,
"ESCAPE");
rootPane.getActionMap().put("ESCAPE", SalirEscape);
{
public void actionPerformed(ActionEvent
actionEvent)
{
if(getFocusOwner() instanceof
JButton)
{
Component boton =
getFocusOwner();
((JButton)boton).doClick();
}
else if(getFocusOwner() instanceof
TextField)
{
getFocusOwner().transferFocus();
}
}
} ;
InputMap inputMap2 =
rootPane.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW);
inputMap2.put(stroke2,
"ENTER");
rootPane.getActionMap().put("ENTER", EnterFoco);
return rootPane;
}
{
setVisible(false);
dispose();
System.exit(0);
}
}
//***************************************************************************************
// Fin Clase Password (Clase principal)
//***************************************************************************************
Al compilar y
ejecutar esta clase en Java, se mostrará por pantalla lo siguiente:
jueves, 25 de abril de 2024
miércoles, 29 de noviembre de 2023
¿Ha Muerto Visual Basic 6.0?
Han pasado más de 30 años desde que se publicó la primera versión de Visual Basic. Fue por muchos años el lenguaje de programación más popular, son muchas las aplicaciones desarrolladas con este entorno que aún funcionan, incluso en Windows 10.
Mucho se ha escrito sobre su obsolescencia, fue desincorporado por Microsoft de su suite de herramientas de programación, y sustitutído por otros que prometían cubrir por más, las deficiencias de este popular lenguaje.
Visual Basic 6.0 fue la última versión conocida, y desde entonces (esto lo afirman muchos programadores de la vieja escuela en artículos publicados en la web), son muchas las pequeñas compañías, empresas o como se le llame, que aún prefieren seguir usando sus viejas aplicaciones desarrolladas en Visual Basic motivados por la vieja premisa: "De que si algo sigue funcionado, por qué cambiarlo".
En el caso del uso hoy, de Visual Basic y sus antiguas aplicaciones, de seguro una de las razones de peso debe ser que migrar a nuevas tecnologías tiene un costo considerable, además al parecer la tecnología COM (Component Object Model) es la tecnología básica para las tecnologías OLE (Object Linking and Embedding), la cual sigue usando Microsoft en su Suite Office. Esto último, será en realidad la razón de porque las viejas aplicaciones de 32 bits desarrolladas en Visual Basic 6.0 siguen funcionando en sistemas como Windows 10.
Microsoft terminó el soporte oficial para Visual Basic 6.0 en 2008, pero hoy se especula que las aplicaciones desarrolladas en Visual Basic 6.0 seguiran funcionando hasta el 2024, a ciencia cierta no se sabe con absoluta seguridad que esto sea así. Lo cierto es que hasta ahora, y esto es fácilmente demostrable, que un programador, haga modificaciones al viejo código de una aplicación hecha en Visual Basic, lo compile, y el ejecutable resultante (.EXE) funcione perfectamente en un sistema Windows 8, 8.1 ó 10 de 32-63 bits.
Por esto, habría que preguntarse ¿Ha muerto Visual Basic 6.0?.
lunes, 6 de febrero de 2023
Capítulo
Nº 5
Conectar
con bases de datos en Java
5.1.
BASES DE DATOS EN JAVA
Una base de datos en cualquier sistema de información, está formado por una colección ordenada de datos. Administrar una base de datos significa almacenar y organizar de forma consistente esos datos, y para eso existen sistemas para tal fin.
El más conocido entre los sistemas de bases de datos es el Sistema de Base de Datos Relacionales (RDBMS), el cual se puede considerar como el sistema estándar o universal. Entre los RDBMS más conocidos están Microsoft SQL Server, Oracle, Sybase, DB2, Informix, MySQL, etc.
Para fines de este Curso Práctico, se usará una conexión a través del puente JDBC-ODBC, que a pesar de no contar con más soporte en las versiones de Java más recientes, será de utilidad práctica para la versión de Java que se está utilizando en este curso en el manejo de la base de datos UNSIR300.mdb.
5.2. CREACIÓN DEL ORIGEN DE DATOS
Para utilizar la base de datos "UNSIR300.mdb" y hacer las transacciones propias de la funcionalidad básica como agregar, modificar y eliminar registros, es necesario crear el origen de datos. El origen de datos permite hacer la conexión entre la base de datos y la aplicación base a través del puente JDBC-ODBC.
5.2.1. Qué es JDBC
JDBC (Java DataBase Conectivity), es una interfaz de programación que permite a los programas Java ejecutar sentencias SQL.
JDBC ya viene incorporado en el JDK (Java Development Kit o Kit de desarrollo de Java). En este caso se está utilizando el JDK 1.7.0.
Con la tecnología JDBC se puede acceder a DBMS como Oracle, SQL Server, etc., y existe un driver para cada uno de estos DBMS.
Nota: JDBC ya no está disponible en las versiones más recientes de Java. Para versiones superiores a JDK 1.7.0, se necesita de aplicaciones de terceros para conectar con JDBC Microsoft Access, como UCanAccess 5.0.1.
5.2.2. El puente JDBC-ODBC (Open DataBase Conectivity)
Este puente proporciona acceso JDBC API vía uno o más drivers ODBC. Implementa operaciones JDBC traduciéndolas a ODBC, ODBC las recibe como las operaciones de un programa aplicativo normal y las implementa en cualquier base de datos para la cual exista un driver ODBC disponible. En este caso se implementa sobre una base de datos Microsoft Access 2003.
Gráficamente sería algo como esto:
Para crear el origen de datos ODBC, se puede hacer de 2 formas distintas:
Primera forma:
1.- Se puede crear a través del Origen de datos de Windows.
2.- Primero en "Panel de Control" se abre la opción "Herramientas administrativas".
3.- Luego se abre la opción "Orígenes de datos (ODBC)".
4.- Se selecciona la pestaña "DSN de sistema" y se pulsa el botón "Agregar".
5.- Se selecciona Microsoft Access Drives (*.mdb) y se pulsa el botón "Finalizar".
6- Se crea el nombre del origen de datos "UNSIR300".
7.- Se pulsa el botón "Seleccionar" para ubicar la base de datos en la carpeta
C:\Curso Práctico De Java\UNSIR300.mdb.
Para finalizar y crear el origen de datos "UNSIR300" se pulsa el botón ACEPTAR.
Segunda forma (recomendada):
La segunda forma para crear el origen de datos ODBC, es creando una clase, en este caso se llamará "ConexionODBC.java”, para cargar el driver "sun.jdbc.odbc.JdbcOdbcDriver" que soporta esta versión de java. Es a través de este driver y usando líneas de código como se logra conectar con la base de datos UNSIR300.mdb.
1.- Se define el constructor llamado "ConexionODBC" para usar el
driver "sun.jdbc.odbc.JdbcOdbcDriver".
Driver)Class.forName("sun.jdbc.odbc.JdbcOdbcDriver").
getDeclaredConstructor(newInstance();
2.- Se define un método llamado "HacerConexion()" para crear el origen de datos.
String myDB ="jdbc:odbc:Driver=
{Microsoft Access Driver
(*.mdb)};DBQ="+curDir+"/UNSIR300.mdb";
nConecta = DriverManager.getConnection(myDB,"","");
ConexionODBC.java
//***************************************************************************
//****
Universidad Nacional Sistema de Inscripción Regular (UNSIR 3.0.0)
//****
//**** CLASE:
ConexionODBC (Carga el driver y hace la conexión con el origen
//**** datos
"UNSIR300" a través de un puente JDBC-ODBC)
//****
//**** AUTOR:
CARLOS CÓRDOVA - CC DESARROLLO DE SOFTWARE 2007-2022
//***************************************************************************
//***************************************************************************
// Paquetes de
la librería estándar de clases de Java que se usarán
//***************************************************************************
import java.sql.*;
//**************************************************************************
// Inicio Clase
ConexionODBC
//***************************************************************************
public class ConexionODBC
{
//*** Se declaran las variables
Connection nConecta = null;
String curDir = System.getProperty("user.dir");
//*** Se define el método principal "main" de la Clase ConexionODBC
public static void main(String[] args)
{
//*** Se ejecuta el constructor
ConexionODBC de la clase ConexionODBC,
//*** esta clase simplemente carga el
driver JDBC y hace la conexión
//*** el origen de datos
"UNSIR300" a través de un puente JDBC-ODBC
new ConexionODBC();
}
//*** Se define el constructor ConexionODBC para cargar el driver
//***
"sun.jdbc.odbc.JdbcOdbcDriver"
ConexionODBC()
{
try
{
Driver d =
(Driver)Class.forName("sun.jdbc.odbc.JdbcOdbcDriver").getDeclaredConstructor().newInstance();
}
catch (Exception e)
{
System.out.println("Se ha
producido un error : " + e.toString());
}
}
//*** Se define el método HacerConexion para crear la conexión
//*** de datos "UNSIR300"
public Connection HacerConexion()
{
Connection nConecta = null;
try
{
//*** Con estas dos línes de código no
hace falta crear el origen de datos DNS
String myDB ="jdbc:odbc:Driver={Microsoft Access Driver (*.mdb)};DBQ="+curDir+"/UNSIR300.mdb";
nConecta = DriverManager.getConnection(myDB,"","");
}
catch (Exception e)
{
System.out.println("Se ha
producido un error : " + e.toString());
}
return nConecta;
}
}
//**************************************************************************
// Fin Clase
ConexionODBC
//***************************************************************************
NOTA: Al compilar y ejecutar esta clase a nivel de cónsola, no se mostrará nada en pantalla. Para poder apreciar algún resultado, se debe crear otra clase que haga uso de ésta, por ejemplo una clase que muestre en pantalla un listado de los alumnos.
Por ejemplo, se creará una clase llamada "ListaEstudiantes.java" que hará uso (instanciará) a la clase "ConexionODBC.java" para mostrar por pantalla un listado de los nombres de los estudiantes.
ListaEstudiantes.java
//***************************************************************************
//**** Listado
de Estudiantes
****
//***************************************************************************
//***************************************************************************
// Paquetes de
la librería de clases estándar de Java
//***************************************************************************
import java.io.*;
import
java.sql.*;
//***************************************************************************
// Inicio Clase
ListaEstudiantes
//***************************************************************************
public class ListaEstudiantes
{
//*** Se define el método principal
"main" de la Clase ListaEstudiantes
public static void main(String[] args)
{
///*** Se crea el objeto
"programa" de la clase "ListaEstudiantes"
ListaEstudiantes programa = new
ListaEstudiantes();
programa.procesa();
}
///*** Método "procesa"
public void procesa()
{
//*** Se declara una variable y se crean
dos objetos para gestionar el manejo
//*** del origen de datos de la clase
ConexionODBC
InputStream nInp = System.in;
InputStreamReader nControl = new
InputStreamReader(nInp);
BufferedReader nBuffer = new
BufferedReader(nControl);
//*** Se crea una instancia nConexion de la clase ConexionODBC para utilizar
//*** los métodos de esta clase, que
hacen el puente JDBC-ODBC
ConexionODBC nConexion = new ConexionODBC();
Connection nConectaB = null;
//*** Se hace la conexión con la base de datos "UNSIR300.mdb", se ordena el listado por el
//*** número de cédula y se muestra el
listado de estudiantes
try
{
nConectaB = nConexion.HacerConexion();
String sql = "SELECT * FROM
ESTUDIANTES ORDER BY CedulaEstudiante";
PreparedStatement ps =
nConectaB.prepareStatement(sql);
ResultSet rs = ps.executeQuery();
while (rs.next())
{
System.out.println(rs.getString("NombreEstudiante"));
}
//*** Cerrar la conexión
rs.close();
nConectaB.close();
}
catch (Exception e)
{
System.out.println("Se ha
producido un error : "+ e.toString());
}
}
///*** Fin del método "procesa"
}
//*** Fin de la clase TablaEstudiantes
//***************************************************************************
// Fin Clase
ListaEstudiantes
//***************************************************************************
Al compilar y ejecutar esta clase en Java, se mostrará por pantalla lo siguiente:
Suscribirse a:
Entradas (Atom)
