¿Cómo conectar Java y MYSQL?
Importar Java.SQL.connection;
Importar Java.SQL.driver manager;
Importar Java.SQL.sentencia preparada;
Importar Java.SQL.resultset;
Importar excepción Java.SQL.SQL;
Importar Java.SQL.statement;
Importar org.Apache . struts . util . recursos de mensajes;
Clase pública DBconnection {
Cadena privada driveName = null
Cadena privada userName = null
Cadena privada contraseña = nula
Cadena privada url = nula
Conexión privada con = nula
Declaración privada sta = nula
privada preparada declaración pre = null;
Resultado del conjunto de resultados privado = null
/* *Crear un constructor de base de datos sin parámetros.
*
*
*/
Conexión de base de datos pública(){
construts();
vincular base de datos();
}
Conexión de base de datos pública (control de conexión){
this.con = con
}
/* *Métodos llamados al crear instancias de objetos
*
*Recursos de mensajes
*/
Constructor vacío privado(){
recursos de mensajes mensaje = recursos de mensajes . getmessageresources(" recursos . aplicación ");
nombredeunidad = mensaje .
URL = mensaje . getmessage(" URL ");
nombre de usuario = mensaje . getmessage(" nombre de usuario "); contraseña ");
}
/* *Cargar controlador de base de datos {
Comando
*
*
*/
Private void linkDataBase() {
Prueba {
class para nombre(driveName
);} catch(ClassNotFoundException e){
System.out.println("¡Error al conectarse a la base de datos!");
}
}
/* *Crear un objeto de conexión.
*
*
*/
Conexión pública createConnection() {
Probar {
con = administrador de controladores . getconnection(URL, nombre de usuario, contraseña);
Devolver con
} catch (SQLException e) {
System . out.println("¡¡Error al abrir la conexión!!");
e printstacktrace();
}
Devolver nulo
. }
/* *Crear un objeto de declaración.
*
*
*/
public void createNormalStatement(){
Probar{
sta = con . crear declaración();
} catch (SQLException e) {
e .printstacktrace(); println("¡¡Error al abrir la declaración normal!!");
}
}
/* *Establezca el objeto precompilado.
*
* @param Declaración precompilada de inicialización de SQL.
*/
public void createPreparedStatement(String sql) {
Pruebe {
pre = con prepare declaración(SQL);
} catch (SQLException e) {
system . println("¡¡Error al abrir la declaración preparada!!");
}
}
/* *Crea un objeto ResultSet para la declaración SQL especificada.
*
* @param sql Declaración SQL de consulta ordinaria,
*/
public void setResultSet(string sql) {
Pruebe {
resultado = sta . ejecutar consulta(SQL);
} catch (SQLException e) {
e . ;
System.out.println("¡No se pudo obtener el conjunto de resultados normal!");
}
}
/ * *Ejecutar una consulta SQL preparada y devolver la vulnerabilidad SQL para esa consulta.
*
*
*/
public void setpreparedstatementsetresultset(){
Probar{
resultado = pre . ejecutar consulta();
} catch (SQLException e) {
e .printstacktrace(); println("¡El conjunto de resultados de la declaración preparada falla!");
}
}
/* *Determina si hay un resultado establecido en el resultado actual. objeto y si devuelve verdadero.
*
* @return¿Hay otro registro?
*/
Público booleano haveMoreResult() {
Probar {
Devolver resultado next();
} catch (SQLException e) {
System.out.println("Hay un error en el resultado del siguiente bloque");
Devuelve falso
}
}
/* *Cerrar el objeto de declaración del objeto actual.
*
*
*/
public void closeNormalStatement(){
Probar{
sta . close();
} captura (SQLException e) {
e . printstacktrace();
sistema. "¡Error al cerrar la declaración normal!");
}
}
/* *Cerrar el objeto actualmente preparado.
*
*
*/
public void closePreparedStatement(){
Probar{
pre . close();
} captura (SQLException e) {
e . printstacktrace();
sistema. "¡Error en el cierre de la declaración preparada!");
}
}
/* *Cerrar el objeto ResulrSet actual.
*
*
*/
public void closeResultSet() {
Probar{
resultado . close();
} catch (SQLException e) {
e . printstacktrace(); "¡Error al cerrar el resultado!");
}
}
/* *Cierre el objeto de conexión y verifique si ResultSet, Statement y PrepardStage están vacíos.
*Cerrar si no está vacío y finalmente cerrar la conexión.
*
*
*/
public void closeConnection() {
Probar {
if (resultado!= nulo) {
resultado close();
}
if (sta!= nulo) { p>
sta .cerrar();
}
si (pre!= null) {
precerrar();
}
con . close();
} captura (SQLException e) {
e . >
System.out.println("¡Error al cerrar la conexión!");
}
}
/* *Establecer soporte para transacciones de objetos de conexión .
*
* @param bool open variable
*/
public void set auto commit(Boolean bool){
Pruebe {
con . set auto commit(bool);
} catch (SQLException e) {
e . /p>
}
}
/* *Obtiene el valor de la cadena en ResultSet a través de un número entero.
*
* El número @param especifica el índice de la columna en el conjunto de resultados.
* @return obtiene el valor.
*/
Cadena pública getResultSetValueByNumber(int número){
Pruebe {
Devolver resultado.getString(número);< / p>
} catch (SQLException e) {
e . printstacktrace();
}
Devuelve nulo
.
/* *Obtiene el valor de cadena de la columna especificada por ResultSet por nombre.
*
El nombre de la columna del conjunto de resultados especificada por * @param columnName.
* @return obtiene el valor.
*/
Cadena pública getResultSetValueByColumn(nombre de columna de cadena){
Intenta {
Devolver resultado getstring(nombre de columna);
} catch (SQLException e) {
e . printstacktrace();
}
Devuelve nulo
< p. >}/* *Obtiene el valor entero en ResultSet a través de un número entero.
*
* El número @param especifica el índice de la columna en el conjunto de resultados.
* @return obtiene el valor.
*/
public int getResultSetIntValueByNumber(int número){
Pruebe {
Devolver resultado.getInt(número);
p>
} catch (SQLException e) {
e .printstacktrace();
}
return-1; /p>
}
/* *Obtiene el valor entero de la columna especificada por ResultSet por nombre.
*
El nombre de la columna del conjunto de resultados especificada por * @param columnName.
* @return obtiene el valor.
*/
public int getResultSetIntValueByColumn(nombre de columna de cadena){
Intenta {
Devolver resultado getint(nombre de columna);
} catch (SQLException e) {
e . printstacktrace();
}
return-1;
}
/* * ¿Establecer el valor de la columna numérica especificada de la declaración preparada? Valor de cadena
*
* ¿Número @param en la declaración preparada? Índice
* @param valor El valor correspondiente que se pasará.
* @return¿Se ha configurado correctamente?
*/
público booleano setPreparedStatementStringValue(int número, valor de cadena) {
Pruebe {
pre.setString(número, valor );
Devuelve verdadero
} catch (SQLException e) {
e . printstacktrace(); (" setPreparedStatementStringValue fallido "
+número);
}
Devuelve falso
}
/* *¿Establecer el valor de la columna numérica especificada de la declaración preparada? Valor int
*
* ¿Número @param en la declaración preparada? Índice
* @param valor El valor correspondiente que se pasará.
*/
public void setPreparedStatementIntValue(int número, int valor) {
Pruebe {
pre.setInt(número, valor );
} catch (SQLException e) {
e . printstacktrace();
system out .
}
}
/* *Enviar la declaración preparada de transacciones de múltiples tablas.
*
* @return¿Enviaste el extracto correctamente?
*/
actualización previa booleana pública(){
Pruebe {
preejecutar actualización();
devuelve verdadero
} catch (SQLException e) {
e . printstacktrace();
}
devuelve falso<. /p>
}
/* *Enviar cosas (enviar varios SQL al mismo tiempo)
*
*
* /
public void conCommit() {
Pruebe {
con .
} catch (SQLException e. ) {
e. printstacktrace();
System.out.println("¡Error en la transmisión!");
}Finalmente {
cerrar conexión();
}
}
/* *Revertir cuando la transacción de la base de datos no tiene éxito.
*
*
*/
public void conRollback() {
Probar {
con . roll back();
System.out.println("Retroceso de la base de datos");
} catch (SQLException e) {
e. printstacktrace();
}Finalmente {
cerrar conexión();
}
}
/* *Ejecutar declaraciones ordinarias de inserción, actualización y eliminación.
*
* @param sql insertar, actualizar y eliminar declaraciones ordinarias
* @Return ¿operación exitosa?
*/
insertUpdateDelete(String sql) público booleano {
Prueba {
sta ejecutar update(SQL);
p>
Devuelve verdadero
} catch (SQLException e) {
e . printstacktrace();
}
Devuelve. false
}
//Programa de prueba
//public static void main(String[]args){
// db conexión db = nueva conexión db();
//db crear conexión();
//db createnormalstatement();
// Cadena. SQL = " seleccionar * del libro _ información;";
//db
// if (db.haveMoreResult()) {
//sistema . println(db . getresultsetvaluebynumber(1));
//sistema .println(db . getresultsetvaluebynumber(2)); //sistema . println(db . getresultsetvaluebynumber(3));
//sistema . salida . println(db. getresultsetvaluebynumber(5));
//system salida .
// }
}Esto es jdbc, hay un grupo de conexiones en el mar.
MySQl instala la versión de instalación con una interfaz gráfica.