Redireccionar

La nueva ola del emprendedorismo

La economía del siglo XXI, con un coste de varios billones de dólares, ha permitido que la tecnología tenga una mayor apertura. Esta ha sido impulsada por tendencias que han cambiado la naturaleza de los empresarios; especialmente, cómo estos serán caracterizados en un futuro. Asimismo, serán los ejecutivos industriales con potencial en el ámbito tecnológico, los más demandados por startups emergentes.

Ver mas

https://www.toptal.com/it/la-nueva-ola-de-la-empresarialidad/es

Instalacion de Apache

- Instalación del "Eclipse IDE for Java EE Developers" y el servidor "Apache Tomcat"

"Eclipse IDE for Java EE Developers"

Para desarrollar aplicaciones que se ejecuten en un servidor web debemos utilizar la versión de Eclipse que viene con todos los complementos que facilitan el desarrollo.
La versión que debemos descargar es Eclipse IDE for Java EE Developers, como podemos ver el tamaños es mayor que la versión que hemos utilizado hasta este momento (Eclipse IDE for Java Developers)
Podemos crear otra carpeta con otro nombre para no perder la versión de Eclipse que hemos utilizado para el desarrollo de aplicaciones de escritorio (swing)
Creemos la carpeta eclipsej2ee y dentro de la misma descomprimamos el entorno de Eclipse que acabamos de descargar "Eclipse IDE for Java EE Developers".
Cuando ejecutamos el Eclipse nos pide seleccionar la carpeta donde se almacenarán los proyectos que crearemos y aparece el siguiente entorno (como podemos ver prácticamente igual que la versión "Java Developers" con un título distinto):

Pero si ingresamos al menú de opciones File -> New veremos que nos permite crear una serie de proyectos muy distintos a la otra versión de Eclipse:

"Apache Tomcat"

Ahora pasaremos a instalar un servidor web "Apache Tomcat" que nos permitirá ejecutar servlet y páginas dinámicas.

Podemos descargar el "Apache Tomcat" de aquí (descargar el archivo Binary Distributions Core 32-bit Windows zip) y descomprimirlo en una carpeta.
Una vez descomprimido procedemos a registrarlo en Eclipse. Desde el menú de opciones seleccionamos Window -> Preferences y en el diálogo que aparece debemos seleccionar Server -> Runtimes Environments y presionar el botón "Add...":

En el nuevo diálogo que aparece seleccionamos de la carpeta "Apache" la versión 7 que es la que acabamos de descargar y descomprimir en una carpeta de nuestro disco duro:

En el último diálogo que aparece debemos seleccionar la carpeta donde hemos descomprimido el "Apache Tomcat" y presionar el botón "Finish:

Ahora debemos iniciar los servicios del servidos "Apache Tomcat" para podes hacer aplicaciones que hagan peticiones.
Para arrancar el Tomcat debemos presionar el botón derecho del mouse sobre la ventana "Server", si no parece esta ventana podemos activarla desde el menú (Window -> Show View -> Servers) y seguidamente seleccionar del menú contextual la opción New -> Server:

En este diálogo seleccionamos "Apache" Tomcat V7.0 y presionamos el botón "Finish":

Como podemos ver ya tenemos el "Tomcat" listo para poderlo utilizar en los distintos proyectos que implementaremos:

Mi primera aplicación - JSP y Servlets

Mi primera aplicación - JSP y Servlets

En esta primera aplicación desarrollaremos un pequeño sistema para dar mantenimiento a una tabla de base de datos. Como la utilizaremos para ponernos al día e ir entrando en calor, será lo más sencillo posible.

1. Ambiente de desarrollo
- JDK v1.6.0.27
- Netbeans v7.1.2
- Apache Tomcat v7.0.22
- MySql v5.1.61


2. Arquitectura de solución

Para ir de acuerdo a las buenas prácticas y acercarnos a un posible ambiente real, la arquitectura que emplearemos será de 3 capas lógicas. También emplearemos Interfaces e Implementaciones de las interfaces.

En este gráfico se aprecia que la capa de negocio y la capa de datos están en servidores separados. Esto es únicamente para representar el modelo de 3 capas a emplear, pueden estar en el mismo servidor o en diferentes.

3. Tecnologías de desarrollo
- JSP / Servlets
- JDBC


4. Manos a la obra

4.1. Como mencioné al inicio de este post, la aplicación que crearemos será para darle mantenimiento a una tabla de base de datos: tabla de clientes.

Para esto, primero creamos la base de datos y la tabla clientes mediante el siguiente script:

4.2. Luego de tener nuestra base de datos "swdefabrica" y la tabla clientes, vamos al Netbeans y creamos un nuevo proyecto web. Para esto, pulsamos las teclas CTRL + N, seleccionamos Java Web y Web Application, le asignamos un nombre y elegimos Apache Tomcat como nuestro servidor, finalizamos.

4.3. Agregamos las librerias que necesitemos, en este caso son las necesarias para conexión a base de datos (mysql) y para el rastreo a nuestro código (logger, mediante apache log4j). Para esto, damos clic derecho en el proyecto, properties; una vez se abre el pop up de properties, la tercera opción es libraries, a la derecha seleccionamos Add Jar / Folder (o agregar Jar).

4.4. Para poder configurar nuestro logger, creamos el archivo log4j.properties. Para esto damos clic derecho en Source Packages de nuestro proyecto, new (o nuevo, dependiendo del idioma instalado en el Netbeans), other (u otros), other otra vez y seleccionamos properties file (o archivo properties).

Creamos la estructura de paquetes y configuramos el archivo properties de la siguiente manera:

4.5. En el paquete com.clientes.util creamos la clase (clic derecho en el paquete, new, Java class) Conexion, para poder conectarnos con nuestra base de datos MySql.

4.6. Luego de esto creamos nuestro objeto ClienteBean (la clase cliente con todos los atributos necesarios) en el paquete com.clientes.bean. Para esto hacemos clic derecho en el paquete, new, Java class.

4.7. Luego de crear nuestra clase ClienteBean, y para manejar todos sus métodos (o acciones que podremos realizar sobre un cliente) creamos la interfaz ClienteDAO en el paquete com.clientes.dao (clic derecho en el paquete, new, Java interface) y la implementamos mediante la clase ClienteDAOImpl (en estas capas se realiza el trabajo con conexión a base de datos) que creamos en el paquete com.clientes.daoImpl (clic derecho en el paquete, new, Java class), como se ven en las siguientes imágenes:

4.8. Como podrán aver visto algunas sentencias que trabajan directamente sobre la base de datos (select ..., delete ...) y otras que hacen llamadas (call ...) a procedimientos de base de datos. Por lo que procederemos a crear los procedimientos almacenados necesarios (insertar y actualizar).

4.9. Una vez que tenemos completa la capa DAO de conexión a base de datos, procedemos a programar la capa de servicio (service) donde se maneja toda la lógica de negocio necesaria. Para esto, creamos la interfaz ClienteService en el paquete com.clientes.service (clic derecho en el paquete, new, Java interface) y la implementamos mediante la clase ClienteServiceImpl en el paquete com.clientes.serviceImpl (clic derecho en el paquete, new, Java class).

4.10. Luego de tener implementada la capa de servicio, pasamos a los Servlets. Los Servlets se atienden y responden las solicitudes realizadas por la vista o interfaz gráfica de usuario (IGU) a través de páginas JSP.

4.11. Luego de tener listo el Servlet, procedemos a crear las páginas JSP mencionadas anteriormente. Para esto se crearán 3 páginas: index - muestra un mensaje de bienvenida y un botón de ingreso; clienteLst - donde se listan los clientes creados y se tienen las opciones Buscar, Nuevo, Actualizar y Eliminar; clienteMnt - que es la interfaz donde se crean o actualizan los clientes.

index.jsp

clienteLst.jsp

clienteMnt.jsp

 

4.12. Finalmente al ejecutar nuestra aplicación tendremos la siguiente ventana de bienvenida.

JDBC: Conexión a Bases de datos Mysql

Buenas amigos, en este tutorial vamos a hablar de uno de los temas mas potentes que tiene java, y a los que a muchos nos interesa, una conexión a una base de datos mysql. Mencionar que aunque podríamos conectar  cualquier otro motor de base de datos (sqlite, oracle, access, sqlserver....) yo lo voy a realizar con mysql, más que nada porque ya lo tengo instalado. Así pues, explicaremos:

• Conectar nuestra aplicación java a la base de datos.
• Recorrer las tablas de la base de datos.

Bien, no voy a explicar en este tema como montar un servicio mysql, ya que me quedaría demasiado extenso, más adelante es posible que me anime, pero por el momento vamos a ver solamente el código necesario para conectarnos a nuestra base de datos y recorrer sus tablas. Podéis buscar en Google como montar un servicio mysql, hay tutoriales a patadas.

Lo primero de todo es descargarnos la librería o conector para poder trabajar con mysql:

[descargar conector]

Es imprescindible para poder conectar nuestra base de datos. Así pues, para cada tipo de motor de base de datos necesitaremos su librería o conector, lo cual, normalmente, se ofrece en la página principal del fabricante que utilicemos. Es algo muy común.

una vez descargado el conector, lo agregamos en nuestro proyecto, para ello hacemos lo siguiente:

• Pulsamos sobre nuestro proyecto con el botón derecho del ratón y pulsamos, al final de la lista desplegable, en propiedades.

• Una vez hecho esto se nos abrirá una ventana donde elegiremos la opción "vía de construcción":

• En la siguiente ventana que se nos abre, elegiremos la pestaña "Biblioteca" y pulsaremos sobre la opción "Añadir JAR externo...", donde nos permitirá elegir nuestro conector descargado:

• Una vez elegido nuestro conector, se nos mostrará en la vía de construcción  y habremos agregado a nuestro proyecto una nueva librería.

Bien, ya tenemos nuestra librería dentro de nuestro proyecto. Antes de nada me gustaría agregar que voy a trabajar sobre una base de datos llamada empresa con una tabla llamada empleados. Dicha tabla constara de 3 columnas:

• ID
• Nombre
• Departamento

Bueno, ahora lo que nos toca crear es una clase capaz de establecer una conexión. Esta clase constará de 4 atributos:

• private static String servidor: Aquí colocaremos la ruta de nuestra base de datos.
• private static String user: El nombre de usuario de mysql
• private static String pass: La clave de usuario de mysql
• private static String driver: Nuestra librería mysql.

Y crearemos un objeto de la clase Connection del paquete java.sql para crear la conexión:

• private static Connection conexion: Nos devuelve la conexión.

Como veis, establezco la ruta del servidor, utilizo el usuario y el pass que viene por defecto en mysql, indico la posición del driver y creo el objeto Connection.

En el constructor levantaremos la conexión y la obtendremos, para ello seguiremos 2 sencillos pasos:

1. Levantar el driver.
2. Establecer la conexión.

Bien, con el método estático de la clase "class" levanto el driver que le paso por argumentos:

• Class.forName(driver);

Con el objeto Conecction obtengo la conexión por medio del método estático getConnection de la clase DriverManager, pasándole por argumentos el servidor, el usuario y el pass:

• conexion=DriverManager.getConnection(servidor,user,pass);

Finalmente creamos un método para obtener el objeto de la clase Connection con la conexión establecida:

Aquí os dejo la clase entera.

Bien, esta clase establece la conexión, ahora vamos a crear otra clase que se encargue de:

• Insertar valores
• Seleccionar valores
• Borrar valores
• Modificar valores

Nuestra clase tendrá 5 atributos:

1. Un objeto de la clase escaner para leer desde teclado.
2. Un objeto Connection para obtener la conexión a la base de datos.
3. Un objeto tipo String para el nombre.
4. Un objeto de tipo String para el departamento.
5. Una variable de tipo int para las opciones del menú.

Bueno, ahora crearemos una sentencia condicional switch, dentro de un bucle do/while, para que vaya dándonos las opciones que queramos realizar hasta salir de la aplicación, y todo esto, dentro del método MAIN:

Bueno, aquí podéis ver las opciones que tendrá nuestro menú:

• Insertar
• Modificar
• Eliminar
• Mostrar
• Salir

En el blucle do/while establecemos que no se saldrá del menú hasta que la opción 5 sea elegida. Ahora vamos a ir explicando los métodos realizados para completar todas las funciones del menú:

INSERTAR:

Por pasos:

• Cargamos nuestra conexión.
• conexion=new Conexion();
• Pasamos al objeto Connection de esta clase la conexión de la clase "Conexion" por medio de nuestro método getConnection():
• Connection con=conexion.getConnection();
• Creamos un objeto de la clase Statement, la cual será la encargada de procesar la sentencia sql que le pasemos e interactuar con nuestra base de datos.
• Statement st;
• Pedimos los datos por pantalla y por medio del objeto teclado de la clase Scanner, leemos los datos que deseemos agregar. Una cosa antes de continuar, es que, aunque mi tabla consta de 3 campos, yo tengo establecido el primero (ID) como primary key, y he establecido que se auto-incremente, por lo tanto no tengo que introducirselo.
• Una vez introducido los datos, creamos la sentencia sql para insertarlos en nuestra base de datos.
• String sql="insert into empleados(nombre,departamento) values ('"+nombre+"','+departamento+"')";
• Hay que darse cuenta que los "values" que le pasamos han de estar entre comillas simples ''.
• Establecemos la comunicación entre nuestra aplicación java y la base de datos:
• st=con.createStatement();
• Le indicamos que ejecute la actualización de la tabla y le pasamos por argumentos nuestra sentencia sql:
• st.executeUpdate(sql);
• Cerramos las conexiones, en orden inverso a su apertura:
• st.close();
• con.close();

Con esto ya podremos insertar filas en nuestra base de datos.

Modificar:

Por pasos:

• Cargamos nuestra conexión.
• conexion=new Conexion();
• Pasamos al objeto Connection de esta clase la conexión de la clase "Conexion" por medio de nuestro método getConnection():
• Connection con=conexion.getConnection();
• Creamos un objeto de la clase Statement, la cual será la encargada de procesar la sentencia sql que le pasemos e interactuar con nuestra base de datos.
• Statement st;
• Pedimos por teclado el número de ID del registro a modificar y se lo asignamos a una variable tipo int llamada "n", posteriormente volvemos a pedir el nombre y el departamento para modificarlos.
• Creamos nuestra sentencia sql:
• String sql="update empleados set nombre='"+nombre+"', departamento='"+departamento+"' where id="+n;
• Establecemos la comunicación entre nuestra aplicación java y la base de datos:
• st=con.createStatement();
• Le indicamos que ejecute la actualización de la tabla y le pasamos por argumentos nuestra sentencia sql:
• st.executeUpdate(sql);
• Cerramos las conexiones, en orden inverso a su apertura:
• st.close();
• con.close();

Esta vez le he puesto una sentencia "if" para que me avise de si se modifico con éxito o no. Con esto podremos modificar nuestros registros.

Eliminar:

Lo mismo que anteriormente:

• Cargamos nuestra conexión.
• conexion=new Conexion();
• Pasamos al objeto Connection de esta clase la conexión de la clase "Conexion" por medio de nuestro método getConnection():
• Connection con=conexion.getConnection();
• Creamos un objeto de la clase Statement, la cual será la encargada de procesar la sentencia sql que le pasemos e interactuar con nuestra base de datos.
• Statement st;
• Introducimos por teclado el registro a eliminar.
• Creamos nuestra sentencia sql:
• String sql="delete from empleados where id="+n;
• Establecemos la comunicación entre nuestra aplicación java y la base de datos:
• st=con.createStatement();
• Le indicamos que ejecute la actualización de la tabla y le pasamos por argumentos nuestra sentencia sql:
• st.executeUpdate(sql);
• Cerramos las conexiones, en orden inverso a su apertura:
• st.close();
• con.close();

Llegados a este punto, ya te deberías de dar cuenta de que lo único que cambio es la sentencia sql, el resto es un copy/paste, para que veas que no es tan complicado como parece.

Mostrar:

Esta varía un poco con respecto a las otras:

• Cargamos nuestra conexión.
• conexion=new Conexion();
• Pasamos al objeto Connection de esta clase la conexión de la clase "Conexion" por medio de nuestro método getConnection():
• Connection con=conexion.getConnection();
• Creamos un objeto de la clase Statement, la cual será la encargada de procesar la sentencia sql que le pasemos e interactuar con nuestra base de datos.
• Statement st;
• Creamos un objeto de la clase ResultSet que será la encargada de devolvernos los resultados de los registros:
• ResultSet rs;
• Creamos nuestra sentencia sql:
• String sql="select * from empleados";
• Establecemos la comunicación entre nuestra aplicación java y la base de datos:
• st=con.createStatement();
• Le pasamos al objeto de ResultSet el resultado de ejecutar la sentencia sql:
• rs=st.executeQuery(sql);
• En este caso no actualizamos la tabla (executeUpdate()), sino que realizamos una consulta (executeQuery());
• Por medio de un bucle while vamos recorriendo valores mientras existan (rs.next()) y por medio de los métodos getInt y getString obtenemos los valores de las diferentes columnas, tened en cuenta de que le tenemos que pasar el número de columna:
• while (rs.next){
• System.out.println("ID:"+rs.getInt(1));
• System.out.println("Nombre: "+rs.getString(2));
• System.out.println("Departamento: "+rs.getString(3));
• System.out.println("**************************");
• }
• Cerramos las conexiones, en orden inverso a su apertura:
• rs.close();
• st.close();
• con.close();