Cone Xi Ones Web

CONEXIONES WEB EN ASP.
NET, PHP Y SERVLETS

CON MICROSOFT SQL SERVER 2008, MYSQL 5.0 Y
POSTGRESQL 8.2
Por:
Domínguez Geniz Amalio Javier
Geniz & Margen Software 2008.

Todos los derechos reservados.
Los logotipos y marcas utilizadas son marcas registradas de sus respectivas empresas.
Por: Domínguez Geniz A. Javier Geniz SWF && MSS 1

Introducción
El presente trabajo pretende dar a conocer los métodos principales y mas utilizados dentro de las
aplicaciones web, en este caso se dará una pequeña pero muy practica introducción a la conexión de
las bases de datos con lenguajes web y también la forma de manipular código SQL que nos permitirá
manipular a la base de datos desde una aplicación web.
En primer lugar empezaremos con uno de los lenguajes que han tenido mucho auge en los últimos
años, que además es una tecnología de software libre y que utiliza como lo lenguaje de programación
a JAVA junto con todo su potencial, por supuesto nos referimos a los Servlets y paginas JSP. En este
primer apartado aprenderá a conectar una base de datos de PostgreSQL 8.2 mediante Java
DataBase Connectivity.
Después de haber logrado el primer ejercicio veremos como de manera análoga se conecta una base
de datos del reconocido y mas famosos gestor de Base de Datos de Código Abierto, denominado
MySQL. Utilizaremos un script de PHP y las instrucciones principales que utiliza este tipo de
lenguajes también Open Source.
Para finalizar realizaremos una conexión entre software propietario utilizando la plataforma
Microsoft.NET, en este ultimo apartado la conexión estará realizada por SQL Server y C#, mediante
ADO.Net y aprenderos porque ASP.Net ha sido una de las tecnologías mas importantes y utilizadas
desde hace ya tiempo atrás.
Nota: Estos códigos fueron compilados por IDE’s, para la aplicación de JAVA (Servlet y JSP) se
utilizará Sun Java Studio Enterprise, para PHP utilizaremos NetBeans Early Access for PHP y para
ASP.Net será Microsoft Visual Web Developer.

Base de datos.
Antes de empezar a codificar directamente sobre alguno de los lenguajes antes mencionados,
empezaremos por crear nuestras tres bases de datos en nuestros SGBD. Cada una de ellas será
creada por el DDL. Por el momento no se preocupe por las relaciones ni por otra cuestión de diseño,
solo utilizaremos una tabla a manera de ejemplo y con una llave primaria tan solo para conservar la
integridad. Si desea aprender SQL Avanzado le recomiendo leer mi manual titulado “Aprendiendo
SQL en N Diapositivas”.
POSTGRESQL MySQL
create database diplomado; create database diplomado;
use diplomado;
CREATE TABLE usuarios
( create table usuarios(
id serial NOT NULL PRIMARY KEY, id int not null PRIMARY KEY
nombre character varying(35), auto_increment,
edad character varying(10), nombre varchar(35),
direccion character varying(35), correo varchar(35),
correo character varying(35) edad varchar(10),
) direccion varchar(35));
WITHOUT OIDS;
ALTER TABLE usuarios OWNER TO
postgres;
SQL Server
create database diplomado;
use diplomado;
create table usuarios(

id int not null PRIMARY KEY identity(1,1),
nombre varchar(35),
correo varchar(35),
edad varchar(10),
direccion varchar(35));
Como podemos observar las tres bases de datos son casi iguales, la diferencia radica en el tipo de
dato de la llave primaria que en todas ellas es un valor auto numérico, pero que se define de diferente
manera para cada una de ellas.

Conexión JSP y Servlets de JAVA con
PostgreSQL 8.2

/* Esta primera página llamada Index.jsp va a ser nuestra pagina inicial, ya que en toda aplicación web
siempre iniciara con un índice(index), esta pagina al ser ejecutada solo mostrará texto plano y un link que nos
vinculara a la siguiente página que realmente son las páginas que realizarán todo el trabajo. */
Index.jsp
/* Las siguientes líneas de código son solo Comentarios generados por el IDE */
<%--
Document : index
Created on : 04-oct-2008, 13:56:21
Author : Geniz
--%>
/* Para iniciar, incluiremos directivas de página (<%@ %>)) que en este caso se encargarán de la codificación
de nuestra pagina JSP */
<%@page contentType="text/html" pageEncoding="UTF-8"%>
/*
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
/* El código restante es solo HTML estándar.*/
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Curriculum JSP</title>
</head>
<body background="Fondojsp.png">
<center><h1>Bienvenido a mi Curriculum en JAVA</h1>
<h2> Autor:Geniz</h2></center> <br /><hr />
<h3>Detalles:<br />
Lenguaje de Programacion: JAVA<br>
Base de Datos: PostgreSQL 8.2<br />
Servidor: GlassFish v2<br />
Puerto: 8080<br />
Path: http://localhost:8081/Curriculem_Servlet_JSP/index.jsp<br /></h3>
<br><br>
<center><a href="Nuevo.jsp">Continuar</a></center>
</body>
</html>

/* Conexiones.java es el archivo pilar de nuestra primera aplicación, en el esta definida una clase de java
llamada conexiones que contiene los métodos principales para la conexión y manipulación de la base de datos.
*/
Conexiones.java
/*
* @author MSS
*/
/* Importamos las bibliotecas de java a utilizar, import javax.swing nos servirá para el envío de mensajes,
import java.sql es una librería especial que contiene los objetos para realizar la conexión y por ultimo
importamos el nombre de nuestro Driver JDBC para postgresql. */
import javax.swing.*;
import java.sql.*;
import org.postgresql.Driver;
/* Iniciamos la superclase, recuerde que debe ser nombrada con el mismo nombre que con el que guardará el
archivo. */
public class Conexiones {
/* En las siguientes tres líneas de código definimos objetos, el primero es un objeto Connection el cual guardara
nuestra ruta, nombre de usuario y contraseña de la base de datos, el objeto Statement será el encargado de
ejecutar las consultas mientras que ResultSet almacenará los datos que fueron solicitados por Statement. No
olvide importar la librería SQL ya que estos objetos están dentro de ella y de no importarla estos serán
marcados como errores. */
static Connection conexion;

static Statement sentencia;
static ResultSet resultado;
/* Iniciamos nuestro método llamado conecta, que será el encargado de establecer la conexión, controlados por
un bloque try que nos avisara cuando la conexión se haya establecido o si algo ha fallado. */
public static void conecta(){
try
{
/* Cargamos el controlador jdbc de postgres a través de class.forName, el controlador deberá estar registrado
en la classpath */
Class.forName( "org.postgresql.Driver" );
} catch( Exception e )
{
// Avisamos que el puente no se ha podido cargar en caso de que esto suceda
JOptionPane.showMessageDialog(null,"No se pudo cargar el puente JDBC-ODBC." );

return;
}try{
/* Establecemos la conexión a través de la clase DriverManager y de su propiedad getConnection, aquí
debemos seguir el formato que nos establece el driver, en primer lugar pondremos la ruta especificando el
puerto y el nombre de la BD, el 2º parámetro es el nombre de usuario y por ultimo la contraseña del mismo.
Todos ellos deberán ser datos de tipo cadena.*/
conexion=DriverManager.getConnection( "jdbc:postgresql://127.0.0.1:5432/diplomado", "postgres", "

*********** " );
/* Una vez establecida la conexión invocaremos al método createStatement de Connection, el cual nos
devolverá un objeto Statement. */
sentencia=conexion.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,ResultSet.CONCUR_
READ_ONLY );
/* En las siguientes líneas enviaremos mensajes para avisar que la conexión se estableció o en caso contrario
mostraremos las posibles fallas, para ello el código se encuentra en un bloque try. */
JOptionPane.showMessageDialog (null, "Conexión establecida");

} catch (Exception er){JOptionPane.showMessageDialog (null, "Error de
conexion" ); }
}
/* Por ultimo construiremos un método denominado alta al que pasaremos como parámetro una cadena de
texto, utilizará la conexión activa y un objeto Statement para ejecutar consultas del tipo DML. En caso de
utilizar DDL o DCL utilizaremos el método executeUpdate de Statement. */
public static void alta(String cadena) {
// Verificamos que haya conexión activa, en caso contrario se realizara una nueva conexión.
if (conexion==null) { conecta(); }
try{
// Ejecutamos la consulta recibida

sentencia.execute(cadena);
} catch(Exception er){
/* Atraparemos la excepción lanzada por java en caso de que no se haya ejecutado la consulta y se la
mostraremos al usuario. */
JOptionPane.showMessageDialog(null, "Lo sentimos su operación
solicitada no se pudo realizar debido a un error de "+er);
}
}
}
/* El siguiente archivo será el encargado de recoger los datos introducidos por el usuario, en el crearemos un
objeto form que invocará al Servlet guardar a través de una petición POST de HTTP, aunque podríamos
también utilizar al método GET de HTT P , en caso de no especificar ninguna acción al botón ejecutará un
retorno de formulario. Aquí es importante recordar la propiedad name de los objetos ya que será utilizado por
el Servlet para almacenar los valores. Además observaremos que todo el código es solo HTML lo cual nos
indica que nuestra pagina también puede ser creada con HTML y tener esta extensión por ejemplo: Nuevo.html
*/
Nuevo.jsp
<%--
Document : Nuevo
Created on : 04-oct-2008, 14:23:11
Author : Geniz
--%>
<%@page contentType="text/html" pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Nuevo Registro</title>
</head>
<body background="Fondojsp.png">
<h2>Por Favor llene los siguientes datos:</h2>
/*No olvide indicar la acción y el método, en caso de no ponerlo se ejecutará un retorno de formulario como
acción y el tipo de petición será GET. Note que para invocar a un Servlet solo se deberá poner el nombre del
archivo sin ninguna extensión. También recuerde que debe escribirse tal y como esta nombrado distinguiendo
mayúsculas y minúsculas, también trate de usar solo rutas relativas y no absolutas */
<form name="f1" action="Guardar" method="POST">

<table border="0">
<tbody>
<tr>
<td> Nombre:</td>
<td>Edad</td>
<td>Direccion:</td>

<td>Correo electronico:</td>
</tr><tr>
<td> <input type="text" name="nombre" value="" /></td>
<td> <input type="text" name="edad" value="" /></td>
<td><input type="text" name="direccion" value="" /></td>
<td> <input type="text" name="correo" value="" /></td>
</tr></tbody></table>
<input type="submit" value="Guardar" name="b1" />
</form>
</body>
</html>
/* Otra posible manera de hacer la interfaz seria utilizando Servlets como lo muestra el siguiente código fuente:
*/
try {
String formulario[]={"<html><head><title>Nuevo Usuario</title></head><body>",
"<form id=\"form1\" name=\"form1\" method=\"post\" action=\"SaveUser\">",
"Nombre: <input type=\"text\" name=\"nombre\" value=\"\"><br>",
"Correo: <input type=\"text\" name=\"correo\" value=\"\"><br>",
"Edad: <input type=\"text\" name=\"edad\" value=\"\"><br>",
"Direccion: <input type=\"text\" name=\"direccion\" value=\"\"><br>",
"<input type=\"submit\” value=\"guardar\"><br>",
"</form></body></html>"};

/* Como podemos observar en el código fuente, el formulario se encuentra dentro de un arreglo de cadenas de
texto y después por medio de un bucle y utilizando el método lenght que nos devolverá un tipo int con el tamaño
del arreglo imprimiremos los controles por medio del método println de nuestro flujo de salida (out). */
for(int i=0; i<=formulario.lenght;i++){

out.println(formulario[i]);
}
/* Guardar.java es el Servlet encargado de recoger los datos de Nuevo.jsp, almacenarlos y enviarlos a la

consulta que será ejecutada por Statement. Nótese que un Servlet no contiene a una clase principal como
alguna aplicación JAVA ya que estos son invocados por peticiones de HTTP. */
Guardar.java
/*
* @author Geniz
*/
/* Importamos las bibliotecas de java, java.io manipulará los flujos de entrada y salida, mientras que
javax.servlet y javax.servlet.http utilizarán la API de los Servlet para utilizar sus atributos y métodos, además
de las peticiones HTTP ya sea POST, GET u otra. */
import java.io.*;
import java.sql.*;
import javax.servlet.*;
import javax.servlet.http.*;
//Definimos nuestro Servlet y heredamos los atributos de HttpServlet
public class Guardar extends HttpServlet {
/* Creamos un método llamado processRequest, que recibe como argumentos a un objeto HttpServletRequest y
otro HttpServletResponse, el primero se encargara de recoger y almacenar los datos que se encuentren en
Nuevo.jsp, mientras que response se encargara de devolver una respuesta a la petición, en este caso devolverá
una página HTML, este tipo de métodos tendrá que estar protegido forzosamente contra posibles excepciones
mediante la palabra reservada throws. */
protected void processRequest(HttpServletRequest request, HttpServletResponse response)

throws ServletException, IOException {
/* Le diremos al objeto response el tipo de respuesta y el juego de caracteres que devolverá en este caso texto y
contenido HTML con el juego de caracteres UTF-8 que se refiere al juego UNICODE ligeramente modificado,
aunque también puede devolver CSS y XML. */
response.setContentType("text/html;charset=UTF-8");
/* Crearemos un flujo de salida out el cual escribirá el contenido de la respuesta (página HTML), para ello
utilizaremos el método getWriter del objeto response y se lo asignaremos a nuestro flujo de salida out que es de
la clase PrintWriter. */

PrintWriter out = response.getWriter();
/* Ahora almacenaremos el contenido de los input text en cadenas mediante el objeto request e invocando a su
metodo getParameter, el cual recibe como argumento el nombre de nuestros cuadros de textos de HTML, debido
a que en la BD los datos son de tipo cadena no es necesaria conversión alguna, pero si por ejemplo
almacenáramos un ID que son números tendríamos que invocar al método parseInt de la clase Integer, por
ejemplo: int id = Integer.parseInt(request.getParameter("id")); y con esta línea de código obtendríamos
el id de nuestra tabla. */
try {
String nombre=request.getParameter("nombre");
String edad=request.getParameter("edad");
String direccion=request.getParameter("direccion");
String correo=request.getParameter("correo");
/* Una vez almacenados los datos en variables enviaremos una consulta DML a nuestro método Alta de nuestra
clase Conexiones que contiene un objeto Statement que será el encargado de ejecutarla, podemos ver que las
variables van encerradas entre comillas simples y dobles, las primeras son para especificar a postgres (o
cualquier otro SGBD) que se trata de una cadena de texto y las segundas indican lo mismo, pero ahora a JAVA.
Para la inserción de números solo restaría omitir las comillas simples. Además también especificamos los
campos en los que vamos a realizar la inserción de datos, como pudo notar cuando definimos la tabla algunos
campos están en diferente orden y además tenemos un campo llamado id que es auto numérico y es por ello que
no necesitaremos insertar algún dato en el, así que en esta consulta definimos el orden de los campos y de su
manipulación.*/
String consulta = "INSERT INTO usuarios (nombre, edad, direccion, correo) VALUES
('"+nombre+"','"+edad+"','"+direccion+"','"+correo+"')";
//Enviamos la consulta al método alta
Conexiones.alta(consulta);
/* Imprimimos la respuesta, mostrando dos links uno para ver los registros y otro para insertar uno nuevo */
out.println("<h2><center><br>Alta Registrada");
out.println("<br><br><a href=Listar>Ver Usuarios</a><br><br>");
out.println("<a href=Nuevo.jsp>Nuevo Usuario</a><br><br>");
/* Cerramos el flujo out a través de close, encerrado en un bloque finally para indicar que pase lo que pase este
tendrá que ser cerrado*/
} finally {
out.close();
}
}

/* Finalmente invocamos al metodo processRequest a traves de una peticion POST de HTTP, esto lo haremos
mediante doPost, de forma análoga podríamos invocar al método GET con doGet y de igual manera podríamos
invocar a cualquier tipo de petición HTTP como doTrace, doPut, etc. También es posible invocar a varios
métodos en el mismo código y ya será el Servlet el encargado de elegir la mejor opción. Recuerde pasar los
parámetros response y request.*/
protected void doPost(HttpServletRequest request, HttpServletResponse response)

processRequest(request, response);
}
/* En este ultimo archivo, la mayoría de las instrucciones ya fueron explicadas anteriormente solo fijaremos
nuestra atención en las instrucciones nuevas. Listar.java será el responsable de mostrar lo datos de la tabla
mediante el objeto ResulSet */

Listar.java
import java.io.*;
import java.net.*;
import java.sql.*;
import javax.servlet.*;
import javax.servlet.http.*;
import javax.swing.*;
/**
*
* @author Geniz
*/
public class Listar extends HttpServlet {
static Connection conexion=null;

static Statement sentencia=null;
static ResultSet rs=null;
protected void processRequest(HttpServletRequest request, HttpServletResponse response)

response.setContentType("text/html;charset=UTF-8");
PrintWriter out = response.getWriter();
try {
Class.forName( " org.postgresql.Driver ").newInstance();
JOptionPane.showMessageDialog(null,"No se pudo cargar el puente JDBC-ODBC." );
//return;
conexion = Conexiones.conexion;
sentencia = Conexiones.conexion.createStatement();
JOptionPane.showMessageDialog(null,"Conexion establecida");
}
catch(Exception er){
JOptionPane.showMessageDialog(null,"Error de conexion" );
}
try{
/* Almacenamos la consulta en una cadena, después se la enviamos al objeto llamado sentencia de la clase
Conexiones para que la ejecute a través del método executeQuery, que funciona igual que su método execute, y
los resultados recibidos los almacenaremos en el ResulSet */
String consulta="select * from usuarios";

rs = Conexiones.sentencia.executeQuery(consulta);

/* Después utilizando al método next de ResulSet, procederemos a extraer los datos mediante el atributo
getString de este objeto, el cual devuelve una cadena, podemos especificar el nombre del campo como en el
ejemplo o también podríamos especificar el índice por ejemplo: rs.getString(0); o en un caso mas especifico
utilizar getInt, getBoolean, getDate, preste especial atención si utiliza alguno de estos métodos ya que debe
tener en cuenta que deberá utilizar tipos de datos especiales. */
while(rs.next()){
out.println(rs.getString("nombre"));
out.println(rs.getString("edad"));
out.println(rs.getString("direccion"));
out.println(rs.getString("correo"));
out.println("<br><hr>");
}
out.println("<a href=Nuevo.jsp>Agregar Nuevo</a>");
} catch(Exception er){
JOptionPane.showMessageDialog(null,"Error de conexion" );
}
protected void doPost(HttpServletRequest request, HttpServletResponse response)
processRequest(request, response);
}
}

Conexión PHP con MySQL 5.0

/* Index.php al igual que el index.jsp fungirá como la pagina inicial y solo mostrara texto plano y un link que nos
vinculara a la pagina que será la encargada de almacenar los datos, php es un lenguaje tipo script del lado del
servidor y este al igual que JSP nos dará la libertad de mezclar PHP con HTML. Recuerde que el código de
PHP deberá estar entre <?php y ?>. */
Index.php
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">

<html>
<head>
<title>Curriculum PHP</title>
</head>
<body background="fondophp.png">
<?php
echo("<center><h1>Bienvenido a mi curriculum en PHP</h1></center>");
?>
Autor:Geniz<br ><hr>
Detalles:<br >
Languaje: PHP<br>
Base de Datos: MySQL 5<br >
Servidor: Apache 2.2, PLataforma Lampp (XAMPP 1.6)<br >
Puerto: 80<br >
Path: http://localhost/phpproject/index.php<br >
<br><br>
<center><a href="Datos.html">Continuar</a></center>
</body>
</html>

/* Conexiones.php es un archivo que solo contiene una lista de variables inicializadas, las cuales contienen las
principales referencias a utilizar para la conexión con la base de datos. */
Conexiones.php
<?php
$servidor="127.0.0.1";
$usuario="root";
$password="";
$conexion=mysql_connect($servidor,$usuario,$password);
$basedatos="diplomado";
$consultaver="select * from usuarios";
?>
/*La siguiente pagina es la interfaz en la que el usuario escribirá sus datos, Ahora notara que es solo una pagina
HTML, y como podrá recordar en la parte de Servlet y JSP mencionamos que JAVA también podría ocupar un
archivo HTML con lo que podremos decir que esta pagina también nos serviría para JAVA. */
Datos.html
<html>
<head> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Nuevo Registro</title></head>
<br><br><h2 align="center">Por Favor llene los siguientes datos:</h2>
<form name="f1" action="insertar.php" method="POST">
<div align="center"> <table width="200" border="0">
<tr>
<td>Nombre:</td>
<td><input type="text" name="nombre" value="" /></td>
</tr> <tr>
<td>Edad</td>
<td><input type="text" name="edad" value="" /></td>
</tr> <tr>
<td>Direccion:</td>
<td><input type="text" name="direccion" value="" /></td>
</tr> <tr>
<td>Correo Electronico: </td>
<td><input type="text" name="correo" value="" /></td>
</tr>
</table> </div>
<p align="center"> </p>
<div align="center">
<input type="submit" value="Guardar" name="b1" />
</div>
</form></body>
</html>

/* Insertar.php es el script que hará la consulta SQL a MySQL, para ello seguirá el siguiente procedimiento: 1.
Recogerá los datos del archivo Datos.html, 2. Guardará los valores a través de request en variables, 3.
Realizará la conexión a MySQL y por ultimo enviará la consulta al Manejador de BD. */
Insertar.php
<html>
<head>
<title>insertarndo...</title>
</head>
//Iniciamos nuestro script a través de <?php y ?>
<?php
/* Solicitamos los campos pedidos en Datos.html, además incluiremos el archivo conexiones.php que contiene
las variables con los datos para la conexión, lo incluiremos a través de la función require_once, aunque
también pudimos usar include. No olvide que PHP distingue caracteres así que recuerde poner bien
mayúsculas y minúsculas, además de que cada línea debe terminar con ; */
require_once("Conexiones.php");
$nombre=$_REQUEST["nombre"];
$edad=$_REQUEST["edad"];
$direccion=$_REQUEST["direccion"];
$correo=$_REQUEST["correo"];
/* A través de la función mysql_connect estableceremos el enlace con mysql, para ello no necesitara instalar
un conector especial ya que viene incluido en PHP por medio de la plataforma LAMP que además contiene al
servidor apache. */

mysql_connect($servidor,$usuario,$password);
/* Una ves establecida la conexión procederemos a ejecutar la consulta invocando a la función

mysql_db_query que recibe como parámetros el nombre de la base de datos y después la consulta */
mysql_db_query($basedatos,"insert into usuarios(nombre,edad,direccion,correo)

values('$nombre','$edad','$direccion','$correo')");
$debug=true;
/* La siguiente condición servirá de manera análoga a un bloque try. Se encargará de hacernos saber si algo
fallo en el proceso de conexión o de ejecutar la consulta invocando a la función mysql_error */
if(sdebug)
{
echo"<p>--GENIZ SOFTWARE FOUNDATION && MARGEN SOFTWARE SOLUTIONS--
</p>".mysql_error();
}
?>
<div align=center>
<h2><font color="green">TU </font><b><font color="green" size="5">Registro se ha grabado en la
BD</font></b></h2>
</div><br>
<br>
/* Una vez pasado el proceso anterior mostraremos dos links al usuario para que puedad ver la información de
la tabla o si lo prefiere agregar mas datos */
<div align=center><font color=green size=3><a href=leer.php>Visualizar el contenido de la tabla

</div>
<div align=center><font color=green size=3><a href=Nuevo.php>Agregar otro registro</div>

</body>
</html>

/* Para concluir con PHP y MySQL crearemos una pagina que se encargar de hacer una consulta a la base de
datos con la finalidad de mostrar los registros que hay en la tabla. Por supuesto que de eso se encargara
leer.php */
Leer.php
<html>
<head><title>leer.php</title></head>
<body >
<center>
<b><font color="green" size="5">DATOS ALMACENADOS <BR>
</font></b><b><font color="green" size="5"><BR> </font></b>
<center>
<table cellspacing=3 cellpadding=3 border=0>
<tr><td><TR><TD><TD>
/* Creamos nuestro formulario, le asignamos un tipo de petición HTTP y le escribimos una acción a realizar. No
olvide que sino escribe estos parámetros el formulario hará un retorno de formulario y utilizara a GET por
default*/
<form method=post action=Datos.html>

<input type=submit value=Agregar_Registro>
</form></TD>
// Iniciamos nuestro script e incluimos el fichero Conexiones.php
<?php
require_once("Conexiones.php");
mysql_connect($servidor,$usuario,$password);
/* Ejecución y asignación de la consulta SQL a la variable $result, recuerde que las variables que estamos
utilizando se encuentran en el fichero Conexiones.php */
$result=mysql_db_query($basedatos,$consultaver);
?>
/*Ahora utilizando código puramente HTML creamos un formato para mostrar los registros, para ello
utilizaremos una tabla de HTML */
<table align=center border=1 cellspacing=4 cellpadding=4>

<tr>
<td><b><font color=RED size=3>Nombre:</td>
<td><b><font color=RED size=3>Edad:</td>
<td><b><font color=RED size=3>Direccion:</td>
<td><b><font color=RED size=3>Correo:</td>
</TR>
<?php
/* En otro script PHP mostraremos los registros con la función mysql_fetch_array que creara un arreglo con los
valores que solicitamos en la consulta que se encuentra almacenada en la variable $result. Como se podrá dar
cuenta lo estamos haciendo de forma análoga a JAVA y de igual manera utilizando un bucle while para la iterar
entre cada uno de los datos */
while($row=mysql_fetch_array($result))
{
/* ¿Recuerda el flujo de salida out utilizado por los servlets? Si su respuesta es afirmativa, notara que
imprimiremos los registros de igual manera en PHP pero claro utilizando una de sus funciones de impresión en
pantalla, y por supuesto será la función echo que de igual forma que nuestro flujo out (del tipo PrintWriter)
imprime texto plano y etiquetas HTML .*/
echo '<tr>
<td>'.$row["nombre"].'</td>';
echo '<td>'.$row["edad"].'</td>';
echo '<td>'.$row["direccion"].'</td>';
echo '<td>'.$row["correo"].'</td>';
'</tr>';
}
mysql_free_result($result);
/* Para finalizar con PHP solo nos resta invocar a mysql_close que será la responsable de cerrar la conexión */
mysql_close();
?>
</center></table><br></body>
</html>

Conexión de ASP.Net (C#) con SQL
Server 2008

/* En cuanto a ASP.NET implementaremos Microsoft Visual C#.Net como lenguaje de programación y
ADO.Net para la conexión con SQL Server, Con diferencia a los lenguajes antes ya explicados ASP.Net no
recogerá los datos de algún fichero externo, sino que lo construirá en el mismo de forma dinámica. Esta primera
pagina al igual que JAVA y PHP es la pagina inicial y solo muestra información plana, lo cabe resaltar es la
estructura, que será explicada en c/u del resto de las paginas */
Default.aspx
<%@ Page Language="C#" AutoEventWireup="true" CodeBehind="Default.aspx.cs"

Inherits="Curriculum_ASP.Net._Default" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"

"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" >

<head runat="server">
<title>Curriculum en ASP.Net</title>
</head>
<body background="fondoasp.jpg">
<center><h1>Bienvenido a mi Curriculum en ASP.Net</h1></center>
Autor:Geniz<br /><hr />
Detalles:<br />
Lenguaje de Programacion: C# <br />
Base de Datos: SQL Server 2008<br />
Servidor: ASP.NET Development Server<br />
Puerto: 1509<br />
Path: http://localhost:1509/Default.aspx<br />
</br></br>
<center><a href="Insertar.aspx">Continuar</a></center>
<form id="form1" runat="server">
</form>
</body>
</html>

/* Como fue mencionado anteriormente en este primer fichero llamado insertar.aspx ejecutara la consulta SQL
al mismo tiempo que construirá la forma dinámica que recogerá los datos */
Insertar.aspx
/* Como podemos observar la pagina se encuentra dividida en dos partes importantes, la primera el bloque de
declaración de código y la segunda que es el bloque proveedor de Código */
/* Empezaremos por decirle a ASP.Net el lenguaje de programación que vamos a utilizar por medio de la
directiva <%@ Page language="C#" %> , en este caso C#, aunque también podríamos haber utilizado
Visual Basic.Net, VB Script ,J++ Script, etc. */
<%@ Page language="C#" %>
/* A continuación importaremos espacios de Nombres los cuales contienen métodos y objetos que
implementaremos en la conexión y que son parte de ADO.Net */
<%@ Import Namespace="System.Data" %>

<%@ Import Namespace="System.Data.SqlClient" %>
/* Inicia el bloque de declaración de código, nótese que abrimos un script y que este a su vez contiene el
atributo runat=”server”, esto indica a ASP.Net que se quiere llevar un control en el servidor y que a la hora de
ser ejecutado lo mantendrá vigilado por si se llegará a modificar o sufrir cambio alguno avisara lo que ocurre en
el cliente, si no se lo pusiéramos el objeto será ejecutado solo como código HTML estándar y esto a su vez
funciona igual para todos los objetos que lo contienen. */
<script runat="server">
/* Iniciamos un método y le pasamos como argumento las variables del sistema */
void Alta(Object sender, EventArgs args){
/* Crearemos un objeto del tipo SqlConnection que esta hecho especialmente para SQL Server y esto a su vez
implica que no da soporte a ODBC debido a que es solo para el , aunque también podríamos haber utilizado un
OleDbConnection para otros SGBD, ahora se preguntarán ¿OleDbConnection da soporte a SQL Server? , la
respuesta es Si y siguiendo la misma estructura.*/
/* Al igual que en los otros lenguajes ADO.Net requiere de los mismos tres parámetros, solo que ahora después
de especificar el nombre del servidor SQL tendremos que especificar una instancia del mismo. En el ejemplo el
servidor se llama GENIZ-1188AE9D3 y la instancia SQLSERVER2008 con // antes del nombre ya que si
solo ponemos /, C# lanzara un error por ser un carácter no valido. */
SqlConnection conexion =new SqlConnection ("server=GENIZ-

1188AE9D3\\SQLSERVER2008;database=diplomado;uid=sa;pwd=************");
/* Pues bien, el siguiente paso consiste en crear una consulta DML para hacer la inserción de los datos y como
en los lenguajes pasados, también será almacenada en una cadena. La diferencia consiste en que ahora los
datos son enviados en variables de la forma SQL, (precedidos por una arroba)*/
String sentencia="INSERT into usuarios (nombre,edad,direccion,correo)

"+"VALUES(@nombre,@edad,@direccion,@correo)";

/* Definiremos a continuación un objeto SqlCommand que ejecutara la consulta al igual que el Statement de
JAVA, solo que este recibe primero la consulta y después la conexión. */
SqlCommand comando=new SqlCommand (sentencia,conexion);
/* Definiremos una variable tipo entero que será la encargada del total del numero de consultas ejecutadas por
SQL Server */
int resultado;
/* Procederemos a abrir la conexión, como podrá ver encerramos el código en un bloque try al igual que en
java con la finalidad de saber cuando se conectó o por si hubo algún error */
try{
//Abrimos la conexion invocando al metodo open del objeto SqlConnection
conexion.Open();
/* Ahora extraeremos los datos de cada objeto construido en la forma dinámica, en este caso de los objetos
TextBox, mediante su propiedad Text y utilizaremos la propiedad add del método Parameters del Objeto
SqlCommand, de la manera siguiente: primero especificaremos el nombre de la variable SQL, este deberá ser
igual que lo coloco en la consulta y precedido por @, después indicamos el tipo de datos SQL y la longitud */
comando.Parameters.Add(new SqlParameter("@nombre",SqlDbType.NVarChar, 10));
/* Enseguida a través de la propiedad value de la variable asignaremos el contenido de nuestro objeto

TextBox, el mismo procedimiento se sigue para los restantes parámetros */
comando.Parameters["@nombre"].Value = nombre.Text;
comando.Parameters.Add(new SqlParameter("@edad",SqlDbType.NVarChar, 20));

comando.Parameters["@edad"].Value = edad.Text;
comando.Parameters.Add(new SqlParameter("@direccion", SqlDbType.NVarChar, 20));

comando.Parameters["@direccion"].Value = direccion.Text;
comando.Parameters.Add(new SqlParameter("@correo", SqlDbType.NVarChar, 20));

comando.Parameters["@correo"].Value = correo.Text;
/*Una vez enviada la consulta utilizando el método ExecuteNonQuery de SqlCommand almacenaremos en la

variable resultado el numero de consultas ejecutadas. */
resultado=comando.ExecuteNonQuery();
/* Después utilizando el método Write del objeto Response (hace lo mismo que el response de JAVA)
mostraremos el valor devuelto por ExecuteNonQuery de SqlCommand y también un link a la siguiente
pagina que mostrará los registros */
Response.Write("Se ha añadido "+resultado+" registro "+"<a href=Mostra_Grid.aspx>Ver

Usuarios</a>");
Response.Write("<br><br>");

/* Utilizando el metodo Close de SqlConnection cerramos la conexión */
conexion.Close();
}catch(SqlException e){
Response.Write("se ha producido una excepción: "+e);

}
/* fin del script (Bloque de declaración de código) */
</script>
/* Para la segunda parte de esta pagina (Bloque proveedor de código) construiremos la forma dinámica de la
pagina (Web Form) que es solo la arte grafica de los objetos HTML con la diferencia que ahora utilizaran
propiedades y métodos especiales de ASP.Net */
<html>
<head><title>Insertar Nuevo Registro</title></head>
<body>
/* Iniciamos el formulario que contiene a lo componentes, nótese que contiene el atributo runat=server y que no
especificamos método HTTP al que tiene que responder, ya que por default responderá al método GET.
¿Recuerda el termino RETORNO DE FORMULARIO? Pues bien, esto se refiere a que el formulario regresara
si mismo y ejecutara los scripts que contiene en el. Note que en la definición de nuestro WebForm no incluimos
esos atributos por lo que hará un retorno. */
<form runat="server" id="formulario">
/* Construimos nuestro primer objeto incluyendo el atributo runat=server para crear un control en el servidor,
después en la propiedad ID especificamos su nombre y la propiedad text sirve para mostrar un texto, ponga
atención y fíjese que antes de poner el nombre del tipo de objeto esta el prefijo asp: , este sirve para acceder a
métodos y propiedades especiales de .Net en caso de no ponerlo seria tratado como un objeto HTML.
Nuevamente si es observador se hará otra pregunta. Si en ASP.Net se puede poner el prefijo asp:, entonces
¿se podrá también en JAVA y PHP(que de forma análoga seria algo como jsp: ó php:)? La respuesta para
el primer caso es afirmativa, por supuesto que JSP también tiene sus controles, en este caso no fueron
mostrados ya que utilizamos Servlet y ese tipo de objetos son utilizamos frecuentemente solo en paginas JSP o
en las JAVA SERVER FACES. Para el segundo caso la respuesta es no. PHP utiliza sus scriptles para el
control de sus objetos. */
<asp:Label Runat="server" ID="textoNombre" text="Nombre"/>

<asp:TextBox Runat="server" ID="nombre"/><br/>
<asp:Label Runat="server" ID="textoEdad" text="Edad"/>

<asp:TextBox Runat="server" ID="edad"/><br/>
<asp:Label Runat="server" ID="Label1" text="direccion"/>

<asp:TextBox Runat="server" ID="direccion"/><br/>
<asp:Label Runat="server" ID="Label2" text="correo"/>

<asp:TextBox Runat="server" ID="correo"/><br/>

/* Por ultimo crearemos el botón que desencadenara al evento y ejecutara el método Alta, para ello utilizaremos
el evento OnClick del objeto button. No olvide poner runat=server*/
<asp:Button OnClick="Alta" Runat="server" ID="boton" Text="Añadir"/>

</form></body></html>
/* En este ultimo archivo mostraremos los registros en una tabla, pero ¿podríamos utilizar una sentencia de
repetición (while) para acceder a los campos de la tabla?, nuevamente la respuesta es Si, pero por ahora
utilizaremos un componente llamado DataGrid o rejilla de datos, hecho especialmente para mostrar la tabla
completa y no registro por registro, es una de la funcionalidades y beneficios que trae .Net.
Nota: La mayoría de código ya fue explicada anteriormente y solo me limitare a explicar funciones nuevas */
Mostrar_Grid.aspx
<%@ Page language="C#"%>

<%@ Import Namespace="System.Data" %>
<%@ Import Namespace="System.Data.SqlClient" %>
<script runat="server">
void Page_Load(Object sender, EventArgs e) {
SqlConnection conexion = new SqlConnection("server=GENIZ-
1188AE9D3\\SQLSERVER2008;database=diplomado;uid=sa;pwd=**************");
/* Declaramos un objeto SqlDataAdapter que será el puente entre el almacén de los datos y el DataSet, nos va
a permitir cargar el DataSet desde el origen de los datos y a actualizar los datos en el origen de datos con los
del DataSet */
SqlDataAdapter adapter = new SqlDataAdapter( "select * from usuarios", conexion);
/* Definimos un objeto DataSet que pertenece a los objetos comunes de ADO .NET, es decir, es la misma clase
para todo tipo de proveedores .NET, no se distingue entre SqlClient y OleDb es el almacén de datos en ADO
.NET. Representa una base de datos desconectada del proveedor de datos. Almacena tablas y sus relaciones */
DataSet ds = new DataSet();

try{
conexion.Open();
adapter.Fill(ds, "usuarios");
/* Accedemos a las tablas almacenadas en el DataSet a través de su propiedad tables, después a su propiedad
DefaultView que devuelve un objeto de la clase DataView, que ofrece una vista de los datos de la tabla para
que podamos recorrer los datos, por ultimo los almacenamos en el DataGrid a través de DataSource que
indica la fuente de datos*/
tabla.DataSource = ds.Tables["usuarios"].DefaultView;
/* Databind ofrece mayor compatibilidad con todo los navegadores, Mediante este mecanismo podemos
asociar unos datos con un control del interfaz de usuario correspondiente. Además muestra la información de
manera automática en controles como el DataGrid */
tabla.DataBind();
conexion.Close();
}
catch(SqlException ex){
Response.Write("se ha producido una excepción: "+ex);
}}
</script>
<html>
<head><title>Usuarios</title></head>
<body><center><br /><br />
/* Declaracion del objeto Datagrid, especificamos el nombre, los bordes y el encabezado. */
<asp:DataGrid id="tabla" runat="server" BorderWidth="1" GridLines="Both"

HeaderStyle-Font-Bold="True" HeaderStyle-BackColor="red">
</asp:DataGrid></center>
</body>
</html>

Notas finales
Como se pudo dar cuenta en el transcurso del desarrollo del presente manual solo me limite
a hacer altas de nuevos registro y a establecer una conexión. Entonces si quisiéramos hacer
modificaciones o eliminar los registros. ¿Qué debemos hacer? La respuesta es sencilla,
recuerda que al inicio en la creación de la BD incluimos un campo llamado “id” pues es hora
de utilizarlo. Lo único que tendrá que realizar será crear una interfaz que recoja los datos
utilizando HTML, deberá pedir el “id” y antes de enviarlo a la consulta tendrá hacer una
conversión a tipo entero solo para JAVA y C#, ya que los tipos de datos en PHP se realizan
en la asignación de las variables. La conversión se hace de la sig. Forma:
JAVA
int id= Integer.parseInt(request.getParameter("id"));
C#
int id=Int.Parse(“campo id”);
y las consultas podrían quedar así:
String consBorrar=”Delete * from usuarios where id=”+id;

String consAct=”Update usuarios set nombre=’“ +nombre+ ”’where id=”+id;
No olvide que los tres lenguajes utilizados son sensibles a mayúsculas y minúsculas, y que
además deben terminar con un fin de línea “;”.
También es importante mencionar que el proceso seguido por cada tipo de aplicación para
realizar la conexión y el alta se pueden hacer en los tres, es decir, podemos utilizar un
formulario HTML para recoger los datos o crear la forma dinámica, conexión y la inserción en
un solo fichero. Además cabe recalcar que los gestores de bases de datos también pueden
ser conectados con otro diferente lenguaje de programación. Por ejemplo podemos conectar
a SQL Server con JAVA mediante JDBC u ODBC, MySQL con ASP.Net mediante ODBC o
MySQL Conector NET, y a PostgreSQL con PHP.
Ya para finalizar aclarare que todo este trabajo se realizo con los IDE’s previamente
mencionados, pero es importante saber que de igual manera se puede realizar sin ellos, tan
solo podríamos haber utilizado una herramienta como el bloc de notas, necesitaríamos un
servidor apache para PHP, Tomcat o WebSphere para JAVA e Internet Information Service
para ASP.NET, además de .Net Framework y la Java Virtual Machine junto con la API Servlet
2.5.

Cone Xi Ones Web

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Cone Xi Ones Web

Uploaded by

Copyright:

Available Formats

CONEXIONES WEB EN ASP.

NET, PHP Y SERVLETS

Geniz & Margen Software 2008.

Por: Domínguez Geniz A. Javier Geniz SWF && MSS 1

Por: Domínguez Geniz A. Javier Geniz SWF && MSS 2

create table usuarios(

Por: Domínguez Geniz A. Javier Geniz SWF && MSS 3

Por: Domínguez Geniz A. Javier Geniz SWF && MSS 4

<%@page contentType="text/html" pageEncoding="UTF-8"%>

/* El código restante es solo HTML estándar.*/

Por: Domínguez Geniz A. Javier Geniz SWF && MSS 5

public class Conexiones {

static Connection conexion;

JOptionPane.showMessageDialog(null,"No se pudo cargar el puente JDBC-ODBC." );

conexion=DriverManager.getConnection( "jdbc:postgresql://127.0.0.1:5432/diplomado", "postgres", "

JOptionPane.showMessageDialog (null, "Conexión establecida");

public static void alta(String cadena) {

// Ejecutamos la consulta recibida

<form name="f1" action="Guardar" method="POST">

Por: Domínguez Geniz A. Javier Geniz SWF && MSS 8

Por: Domínguez Geniz A. Javier Geniz SWF && MSS 9

for(int i=0; i<=formulario.lenght;i++){

/* Guardar.java es el Servlet encargado de recoger los datos de Nuevo.jsp, almacenarlos y enviarlos a la

//Definimos nuestro Servlet y heredamos los atributos de HttpServlet

public class Guardar extends HttpServlet {

protected void processRequest(HttpServletRequest request, HttpServletResponse response)

Por: Domínguez Geniz A. Javier Geniz SWF && MSS 10

//Enviamos la consulta al método alta

Por: Domínguez Geniz A. Javier Geniz SWF && MSS 11

protected void doPost(HttpServletRequest request, HttpServletResponse response)

Por: Domínguez Geniz A. Javier Geniz SWF && MSS 12

public class Listar extends HttpServlet {

static Connection conexion=null;

protected void processRequest(HttpServletRequest request, HttpServletResponse response)

String consulta="select * from usuarios";

Por: Domínguez Geniz A. Javier Geniz SWF && MSS 13

Por: Domínguez Geniz A. Javier Geniz SWF && MSS 14

Por: Domínguez Geniz A. Javier Geniz SWF && MSS 15

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">

Por: Domínguez Geniz A. Javier Geniz SWF && MSS 16

Por: Domínguez Geniz A. Javier Geniz SWF && MSS 17

//Iniciamos nuestro script a través de <?php y ?>

Por: Domínguez Geniz A. Javier Geniz SWF && MSS 18

/* Una ves establecida la conexión procederemos a ejecutar la consulta invocando a la función

mysql_db_query($basedatos,"insert into usuarios(nombre,edad,direccion,correo)

<div align=center><font color=green size=3><a href=leer.php>Visualizar el contenido de la tabla

<div align=center><font color=green size=3><a href=Nuevo.php>Agregar otro registro</div>

Por: Domínguez Geniz A. Javier Geniz SWF && MSS 19

<form method=post action=Datos.html>

// Iniciamos nuestro script e incluimos el fichero Conexiones.php

<table align=center border=1 cellspacing=4 cellpadding=4>

Por: Domínguez Geniz A. Javier Geniz SWF && MSS 21

Por: Domínguez Geniz A. Javier Geniz SWF && MSS 22

<%@ Page Language="C#" AutoEventWireup="true" CodeBehind="Default.aspx.cs"

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"

<html xmlns="http://www.w3.org/1999/xhtml" >

Por: Domínguez Geniz A. Javier Geniz SWF && MSS 23

<%@ Page language="C#" %>

<%@ Import Namespace="System.Data" %>

/* Iniciamos un método y le pasamos como argumento las variables del sistema */

void Alta(Object sender, EventArgs args){

SqlConnection conexion =new SqlConnection ("server=GENIZ-

String sentencia="INSERT into usuarios (nombre,edad,direccion,correo)

Por: Domínguez Geniz A. Javier Geniz SWF && MSS 24