viernes, 25 de octubre de 2013

J2EE. Comunicación entre JSP y Servlets


He visto que en muchos casos, algo tan básico como el manejo de JSP y Servlets, causa problemas a muchos programadores que están empezando a introducirse en este mundillo del desarrollo de aplicaciones web en Java.


Es por eso que voy a hacer un pequeño resumen de algunas acciones que pueden resultar prácticas si os estáis iniciando en tareas de comunicación entre estos dos elementos. Se trata de casos muy prácticos en los que no voy a explicar teoría, pero es recomendable que os documentéis sobre toda la arquitectura y sepáis lo que estáis haciendo en cada momento.


Pasaré por alto que es un jsp y que es un servlet, porque entiendo que si has llegado hasta aquí ya sabes de lo que estoy hablando.


Una de las comunicaciones mas simples puede resultar la creación de un formulario en la parte cliente, y la respuesta generada por el servlet al ser llamado por la acción de este formulario, así tendríamos que :


JSP :

<FORM action="ServletDestino" method="get">
<INPUT type="text" name="nombre" id="nombre">
<INPUT type="text" name="apellido" id="apellido">
<INPUT type="submit" value="Enviar">
</FORM>


ServletDestino.java :




protected void doGet(HttpServletRequest req, HttpServletResponse resp)

throws ServletException, IOException {


String nombre = req.getParameter("nombre")
String apellido= req.getParameter("apellido");

PrintWriter out = resp.getWriter();
out.println("<html>");
out.println("<body>");
out.println("El nombre es " + nombre);
out.println("El nombre es " + apellido);
out.println("</body>");
out.println("</html>");

}


Este ejemplo es bien sencillo, un jsp ( o html en este caso ya que se trata de una página completamente estática) que envía una petición a un servlet pasandole parámetros vía get, este ServletDestino recoge los parámetros y realiza una respuesta en forma de página web una vez ha tratado los datos que llegan des de la petición.


Esta es una comunicación muy sencilla pero poco eficiente por varios motivos, el principal de todos es que la respuesta del servidor se realiza mediante la escritura de una página web en el mismo servlet. Si consideramos que las páginas actuales no suelen ser tan sencillas y que incluyen css, javascript y mil cosas mas escribir una respuesta de este tipo puede resultar un infierno por no hablar de la ineficiencia que supone.


En muchos casos, podemos querer llamar a otra página web des de el servlet para que esta sea la respuesta de la petición que nos han hecho, y así ahorrarnos generar la página con ouy.println en este caso deberíamos incluir estas lineas:

req.setAttribute(“nombre_del_parametro”,valorDelParametro);
req.getRequestDispacher(“/PaginaSecundaria.jsp”).forward(req,resp);


Y en la pagina jsp de destino podríamos añadir java incrustado mediante los tags <% %> :


p=reqt.getAttribute(“nombre_del_parametro”);


Y recuperar el parámetro que nos interesa. Luego setearlo en algún sitio del <body> para preparar alguna salida deseada mediante <%!=p%>, un ejemplo bien sencillo :


<body>


<p>El valor de los atributos es: <%!=p%> </p>


</body>



Pensemos que hay muchas formas de comunicarse con un servlet des de la parte de cliente, tambien podriamos hacer un href pasandole como destino un servlet y sus parametros al estilo :


<a href=”ServletDestino?id=1″>Go to Servlet</a>


Visto todo esto, vamos a hablar ahora de las tendencias actuales en la web.
Antiguamente, todas las webs se recargaban enteramente su contenido para mostrar una respuesta del servidor. Actualmente esto se hace cada vez menos (por fortuna, ya que de esta manera se dota de agilidad a la web) y se emplean llamadas asíncronas al servidor mediante el uso de AJAX, dando como resultado una web mucho mas dinámica. La librería JQuery de javascript nos facilitan mucho la vida a la hora de realizar estas llamadas ajax y el posterior tratado de los datos y actualización de ciertos elementos de nuestra página. 


Todas las lineas que escribo a continuación son bajo el supuesto de que la página tiene incluida la librería jQuery y por tanto haré uso de ella.


Pongamos por caso, una web donde tenemos los siguientes elementos :


<input type="text" name="firstname" id="txt">


<button type="button" onclick="enviaPeticion()">Ok</button>


<div id="Respuesta"></div>


en el momento de clickar en ok, llamamos a una función javascript, que podria ser, por ejemplo :


function enviaPeticion(){

//recuperamos el valor del textField

var texto = $("#txt").val();

var rc="";

$.ajax({
url:'ServletDestino?Texto='+texto+',
type:'post',
dataType: 'json',
success: function(data){
$.each(data, function(key, val) {
rc=val;
}
});

$("#txt").text(rc);

}


Cosas a comentar, al enviarse la petición ajax con la función $.ajax creamos la función para la respuesta en el servidor, definimos que la respuesta vendrá en formato json, y lo que hacemos con la función $.each es iterar por cada pareja clave-valor del json resultante que nos devuelva el servidor. Si conocemos la clave a la que queremos acceder, no haría falta patearse toda la respuesta del servidor, bastaria con obtenerla haciendo :

data['nombreDeLaClave']


Una vez evaluados todos los resultados actualizaremos el div contenido en la página con esa respuesta mediante jQuery.


La única diferencia tener en cuenta a la hora de hacer el servlet en comparación con los ejemplos anteriores, es que la respuesta debe ser de tipo JSON, por lo que yo suelo usar una librería externa en mis proyectos y genero una instancia de JSONObject.


JSONObject json = new JSONObject();

hago las inserciones necesarias:

json.put(key, value);

y se lo devuelvo a la parte cliente :


PrintWriter out = response.getWriter();
out.print(json);
out.flush();
out.close();







Navigation Timing




Recientemente he escrito un artículo para el blog corporativo de NexTret.

Trata sobre la extracción de métricas en la navegación de páginas web mediante la api navigation timing. Tiempos de dns, respuesta de servidor, maquetación de la página...

Podéis consultarlo en el blog de Layer 8

Si estáis interesados en ampliar conocimientos sobre el tema podeis pasaros por la página con la documentación oficial

 https://dvcs.w3.org/hg/webperf/raw-file/tip/specs/NavigationTiming/Overview.html

Saludos!

lunes, 7 de octubre de 2013

Hibernate: Creación de la clase DAO

Vamos a profundizar un poco mas en la creación de clase DAO. Estas clases se crean con el objetivo de dotar a la aplicación de una capa que se encargue del acceso a la BD proporcionando así abstracción e independencia del resto de las capas de servicio de negocio de la aplicación.

La clase DAO (Data Acces Object) será la encargada de realizar las acciones que necesitemos sobre la Base de Datos (Insterts, updates, deletes...)

En el post anterior ya realizamos una clase DAO, ahora vamos a ver como aplicar los criterios de diversas formas a nuestra consulta.

En primer lugar hablaremos de Criteria. Criteria es una clase incluida en el paquete de hibernate que nos permitirá realizar nuestra consulta de una forma sencilla.

Instanciamos el objeto criteria pasando la clase donde se aplicaran las restricciones como atributo:

Criteria criteria = sesion.createCriteria(DWH_DIA.class);

Recordar que previamente hemos creado el objeto sesion mediante :

sesion = HibernateUtil.getSessionFactory().openSession();

Una vez hecho esto, podemos empezar a añadirle condiciones a nuestro objeto criteria, por ejemplo decirle que id queremos buscar en nuestra consulta :

criteria.add(Restrictions.eq("idTest", 120));

o incluso marcarle un order by:

criteria.addOrder(Order.asc("Fecha"));

Una vez aplicados todos los criterios necesarios a nuestra consulta, bastará con listarla:

listaDatos=criteria.list();

Otro metodo interesante es aplicar varios valores a un mismo campo como criterio de consulta, en este caso :

Disjunction disjunction = Restrictions.disjunction();
disjunction.add(Restrictions.eq("id", 120));
disjunction.add(Restrictions.eq("id", 121));


Finalmente se aplica el objecto disjunction a nuestro criterio de selección:

criteria.add(disjunction);


De esta manera se aplicarían los valores 120 y 121 al campo id de nuestra consulta como criterio de selección.


Otra opción para realizar la consulta seria aplicar una consulta SQL creada mediante el típico String en java, en este caso, una vez escrita la consulta, haremos :

Query query = sesion.createQuery(sql);

Y posteriormente iteraremos sobre los resultados que se produzcan para tratarlos de la forma que nos convenga, por ejemplo los recogeremos en un Objet[]

for(Iterator it=query.iterate();it.hasNext();){
Object[] row = (Object[]) it.next();
}


miércoles, 4 de septiembre de 2013

Hibernate: Primeros Pasos. Ejemplo

Hibernate es un framework open source que nos facilitara mucho la tarea de realizar una capa de persistencia de datos en nuestra aplicacion mediante el mapeo de clases de una base de datos relacional.

En este tutorial mostraremos un mix entre realizar el esqueleto mediante el asistente hibernate tool y la creacion de ciertos componentes a mano, evidentemente cada uno puede utilizar luego un metodo u otro, pero en este caso, y a mi criterio, considero que esta es la mejor manera de realizar el desarrollo.

En primer lugar vamos a bajarnos hibernate tool en nuestro eclipse, en mi caso se trata de una versión juno, por lo que deberemos ir a la pestaña Help --> Eclipse marketplace y en el buscador poner Hibernate.
Hibernate tool forma parte de el paquete de herramientas JBoss en su versión para eclipse juno por lo que seleccionaremos este.


Una vez se despleguen todos los paquetes seleccionamos el que nos interesa


Nos pedirá reiniciar eclipse y ya tendremos nuestro asistente de Hibernate instalado.

El ejemplo lo desarrollaremos en un proyecto para J2EE, por lo que  crearemos uno "Dinamic Web Project" de ejemplo.

Una vez creado añadiremos los jars necesarios para hibernate, una vez descargado el zip con todos los jars de Hibernate veremos que los jars necesarios los encontraremos en lib/requiered. Todos ellos los añadiremos a WEB-INF/lib y luego al classpath del proyecto.

Antes de continuar necesitamos tener el jar para la conexion a la BD y añadirlo a nuestro classpath. En mi caso voy a conectarme a una BD Sql Server remota y voy a utilizar  JTDS.



Seguidamente vamos a crear el archivo de configuración de Hibernate con el asistente que acabamos de bajar, para ello, click derecho sobre nuestro proyecto New --> Hibernate configuration File


Seleccionamos que se guarde en la raíz de la carpeta src de nuestro proyecto, y seguidamente rellenamos los campos necesarios, en este caso se puede ver en la imagen como los he rellenado para mi proyecto (recordemos que utilizo una BD SQL server en remoto para este ejemplo). Seleccionamos tambien Create a console configuration

En la siguiente pantalla se puede configurar todo lo relacionado con nuestro hibernate (version, conexión a base de datos...) yo lo dejo todo por defecto pero me aseguro que en la ventana del classpath este incluido mi jar jstd, si no estuviese, fallaría al intentar conectarse.

Una vez terminado, veremos como se nos ha generado el archivo de configuración de hibernate, si queremos curiosear veremos que se trata de una estructura clásica de xml con todos los datos necesarios.

En el siguiente apartado vamos a mapear una tabla de la base de datos, esto se puede hacer a mano o con el asistente, en mi caso voy a proceder a mano a partir de aquí porque quiero tener un control total sobre el código que se genere, cada uno puede escoger la opción que mejor le convenga.

La tabla a mapear es una llamada Telefons que tiene la siguiente estructura :




En primer lugar, y por comodidad de tenerlo todo ordenado, creo un package llamado mapeos donde pondré todas las clases mapeadas, a continuación creo una clase y la escribo usando la convención de nombres Java Beans para getters y setters y visibilidad privada para sus atributos. No es obligatorio hacerlo así pero si recomendable.






De esta manera, la clase queda así:

public class Telefons implements Serializable{

private int id;
private String movil;
private String nom;
private String descripcio;
private String dataAlta;
private String dataModificacio;
private boolean bsms;

public Telefons() {

}

public Telefons(String movil, String nom, String descripcio,

String dataAlta, String dataModificacio, boolean bsms) {
this.movil = movil;
this.nom = nom;
this.descripcio = descripcio;
this.dataAlta = dataAlta;

this.dataModificacio = dataModificacio;
this.bsms = bsms;
}

public int getId() {
return this.id;
}

private void setId(int id) {
this.id = id;
}

public String getMovil() {
return this.movil;
}

public void setMovil(String movil) {
this.movil = movil;
}


public String getNom() {
return this.nom;
}

public void setNom(String nom) {
this.nom = nom;
}

public String getDescripcio() {
return this.descripcio;
}

public void setDescripcio(String descripcio) {
this.descripcio = descripcio;
}

public String getDataAlta() {

return this.dataAlta;

}
public void setDataAlta(String dataAlta) {
this.dataAlta = dataAlta;
}

public String getDataModificacio() {
return this.dataModificacio;
}

public void setDataModificacio(String dataModificacio) {
this.dataModificacio = dataModificacio;
}

public boolean isBsms() {
return this.bsms;
}

public void setBsms(boolean bsms) {
this.bsms = bsms;
}
}


A destacar tenemos que se debe crear un constructor sin argumentos, esto es obligatorio ya que Hibernate creará instancias de esta clase por reflexión.

A continuación vamos a crear el archivo de mapeo, para ello click derecho new--> othres--> y crearemos un Hibernate XML Mapping file asociado a nuestra clase Telefons. El archivo debe quedar de esta manera :

<hibernate-mapping>
    <class name="mapeo.Telefons" table="TELEFONS">
        <id name="id" type="int">
            <column name="ID" />
            <generator class="increment" />
        </id>
        <property name="movil" type="java.lang.String">
            <column name="MOVIL" />
        </property>
        <property name="nom" type="java.lang.String">
            <column name="NOM" />
        </property>
        <property name="descripcio" type="java.lang.String">
            <column name="DESCRIPCIO" />
        </property>
        <property name="dataAlta" type="java.lang.String">
            <column name="DATAALTA" />
        </property>
        <property name="dataModificacio" type="java.lang.String">
            <column name="DATAMODIFICACIO" />
        </property>
        <property name="bsms" type="boolean">
            <column name="BSMS" />
        </property>
    </class>
</hibernate-mapping>


El tag <generator> como increment hará que Hibernate nos genere los id de forma automática e incremental. Si la base de datos tiene el campo id definido como clave primaria, ella será la encargada de generar esos id para el campo si es que vamos a insertar un nuevo objeto. Por lo tanto, en vez de poner "incremental" en el campo "generator", pondremos "native" para que podamos realizar los inserts


Ahora nos dirigimos a nuestro archivo de configuración .cfg y le decimos que hemos creado un nuevo mapeo, esto se hace colocando el tag :


<mapping resource="mapeo/Telefons.hbm.xml"/>


Dentro de la etiqueta : <session-factory>


Otra cosa que puede ser interesante indicar en este archivo de propiedades es el pool de conexiones, con el tag <property name="connection.pool_size">1</property>, pero de momento no es imprescindible.


Hasta aquí ya tenemos el trabajo hecho, evidentemente esto se puede hacer extensible a tantas tablas como queramos, hasta tener la base de datos completamente mapeada.


Ahora vamos a empezar con el manejo de los objetos Telefons con nuestra base de datos.


Antes de nada, debemos incorporar al classpath de nuestro proyecto los jars de hibernate, que es algo que todavía no habíamos hecho, para ello nos dirigimos a su página y descargamos el zip de la última versión, a día de hoy es este. Abrimos el zip y buscamos en la carpeta lib una llamada required, cogemos todos estos jars y los añadimos al classpath de nuestro proyecto.


Ahroa ya podemos realizar la implementación de nuestra interficie DAO entre nuestra aplicación y la base de datos.

En primer lugar, crearemos una clase común a todos nuestras DAO's(en este caso solo uno) que llamaremos HibernateUtil, tendrá esta pinta :


public class HibernateUtil {
private static final SessionFactory sessionFactory;   

    static 
    { 
        try { 
          sessionFactory = new Configuration().configure().buildSessionFactory(); 
        } catch (HibernateException he) { 
           System.err.println("Ocurrió un error en la inicialización de la SessionFactory: " + he); 
           throw new ExceptionInInitializerError(he); 
        } 
    }  

    public static SessionFactory getSessionFactory() 
    { 
        return sessionFactory; 
    } 

}


Apunte : en la versión 4 de hibernate, el método .buildSessionFactory() esta deprecated, la alternativa la podemos obtener de StackOverFlow


Una vez hecho esto, creamos otra llamada TelefonsDAO, que sera la encargada de realizar las acciones propiamente dichas. En este caso vamos a hacer métodos para guardar, actualizar, borrar y obtener uno a todos los elementos de la tabla. La clase quedará así :



public class TelefonsDAO {

private Session sesion;
private Transaction tx;

private void iniciaOperacion() throws HibernateException{
   sesion = HibernateUtil.getSessionFactory().openSession();
   tx = sesion.beginTransaction();
}

private void manejaExcepcion(HibernateException he) throws HibernateException{
   tx.rollback();
   throw new HibernateException("Ocurrió un error en la capa de acceso a datos", he);
}

public int guardaTelefono(Telefons telefons){ 
   int id = 0;  
   try { 
       iniciaOperacion(); 
       id = (Integer)sesion.save(telefons); 
       tx.commit(); 
   }catch(HibernateException he) { 
       manejaExcepcion(he);
       throw he; 
   }finally { 
       sesion.close(); 
   }  
   return id; 
}

public void actualizaTelefono(Telefons telefons) throws HibernateException { 
   try{ 
       iniciaOperacion(); 
       sesion.update(telefons); 
       tx.commit(); 
   }catch (HibernateException he) { 
       manejaExcepcion(he); 
       throw he; 
   }finally { 
       sesion.close(); 
   } 
}

public void eliminaTelefons(Telefons telefons) throws HibernateException { 
   try { 
       iniciaOperacion(); 
       sesion.delete(telefons); 
       tx.commit(); 
   } catch (HibernateException he){ 
       manejaExcepcion(he); 
       throw he; 
   }finally { 
       sesion.close(); 
   } 
}

public Telefons obtenTelefonsPorID(int idTelefon) throws HibernateException{ 
Telefons tlf = null;  
   try { 
       iniciaOperacion(); 
       tlf = (Telefons) sesion.get(Telefons.class, idTelefon); 
   } finally { 
       sesion.close(); 
   }  
   return tlf; 
}

public List<Telefons> obtenTodosTelefons() throws HibernateException { 
   List<Telefons> listaTelefons = null;  
   try { 
       iniciaOperacion(); 
       listaTelefons = sesion.createQuery("from Telefons").list(); 
   }finally { 
       sesion.close(); 
   }  

   return listaTelefons; 
}
}

El package de mi proyecto queda de esta manera :





Con esto ya tendremos preparada nuestra capa de acceso a los datos. Ahora solo hemos deinstanciar objetos Telefons y pasárselo a los métodos de la clase TelefonsDAO






En próximos posts iré ampliando mas información sobre Hibernate

lunes, 19 de agosto de 2013

Multiidioma de JSP con JSTL

Para implementar un jsp recuperando los literales de un fichero de propiedades y de esta manera internacionalizar nuestra web utilizaremos las librerias de JSTL (JSP Tag Library) que es un componente dentro de la especificación J2EE.

En primer descargaremos los jars de aquí, necesitaremos los llamados jstl-api-x.x.jar y jstl-impl-x.x-jar.

Los añadiremos al directorio WEB-INF/lib de nuestro proyecto.

Ahora en la página jsp objeto de nuestra implementación añadimos los tag libs antes de la etiqueta
<html>

<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>  
<%@ taglib uri="http://java.sun.com/jsp/jstl/fmt" prefix="fmt"%>



Los ficheros de lenguas los pondremos en WEB-INF/classes/bundle/ y tendrán la nomenclatura :
lang_es.propertieslang_es.properties por ejemplo para el caso de dos ficheros uno en español y otro en inglés.

Se tratan de ficheros clásicos de propiedades en estructura de clave - valor.


Antes de la etiqueta <head> de nuestra página incluimos este código :


<c:if test="${param.locale!=null}">
      <fmt:setLocale value="${param.locale}" scope="session"/>
</c:if>

<fmt:setBundle basename="bundle.lang"/>

Será el encargado de comprobar si nos llega un parámetro de una pagina previa correspondiente a la variable locale que nos indicara la lengua seleccionada, en caso afirmativo le setearemos la variable a nivel de session para que durante toda la navegación tengamos el idioma seleccionado, en caso contrario, que no nos llegue ningún idioma predeterminado previamente, cogeremos por defecto el que esté configurado en el navegador.
Mediante setBundle le indicamos donde están estos ficheros de idiomas.

Ahora es tan fácil como, en vez de hardcodear los literales en nuestro código,  hagamos referencia a ellos mediante el tag :


<fmt:message key="saludo"/>

Donde saludo se refiere a la clave que contiene el valor saludo, en este caso es bastante lógico que se trate de "Hello" o "Hola".

Una pequeña ayuda en el caso que tengamos funciones javascript que contengan también literales y sea externa a nuestra página, si decidimos tener un solo método para internacionalizar nuestra pagina, podemos recuperar los valores de nuestros literales de la misma manera mencionada anteriormente y recogerlos en variables globales de javascript que luego utilizaremos desde cualquier función que las requiera, por ejemplo :


<script type="text/javascript">

var lun="<fmt:message key="Fecha.Lunes"/>";
</script>


La variable lun ya contendrá el valor adecuado según nuestro mecanismo de selección de idioma y se generará de forma dinámica al aplicar cualquier cambio.

martes, 13 de agosto de 2013

Selenium : Grabación y ejecución de un test


Para crear un nuevo test tenemos dos opciones, escribirlo desde 0 o utilizar el ide de selenium y luego exportarlo. Vamos a escoger la segunda opción por su sencillez y rapidez.

 Descargamos el plugin para Firefox de la pagina de selenium y lo instalamos. Selenium IDE

Una vez volvamos a abrir Firefox ya tendremos el IDE disponible, el funcionamiento es el mismo que al instalar cualquier otro plugin en este navegador, si no lo vemos por defecto, podemos activarlo en la pestaña Ver -> Panel Lateral -> Selenium IDE.

Esta es la apariencia y su funcionamiento es muy intuitivo: 



Al apretar el botón "rec" e ir haciendo acciones sobre nuestro navegador, estas se irán grabando automáticamente, podemos modificar estas acciones manualmente desde la pestaña Table o Source según nos sea mas cómodo.

Una vez grabado un test, haremos Archivo -> Export Test Case As.. -> Java/JUnit4/WebDriver



Es importante recordar que el archivo debe tratarse de un .java

Ahora ya podemos copiar nuestro test en nuestro proyecto de Eclipse ( La explicación de como crear un proyecto para ejecutar Selenium la tenemos en el post anterior) y ejecutarlo es tan sencillo como hacer click derecho Run as -> JUnit Test

Si miramos con detenimiento el código java que se nos ha generado veremos que es relativamente sencillo de entender y por tanto es sencillo de modificar si queremos completarlo, como por ejemplo, algo útil que se puede necesitar es asignarle un TimeOut a la carga de las páginas, para ello a la instancia de WebDriver que se nos ha creado podemos llamar a su método pageLoadTime y pasar como parámetro los segundos máximos en los que queremos que se nos cargue, por ejemplo: 

driver.manage().timeouts().pageLoadTimeout(20, TimeUnit.SECONDS);

Y puede ser buena idea try catchear el bloque de código que ejecuta el test para controlar en caso de que falle por Time Out.


Otra cosa que puede resultar útil a la hora de automatizar una serie de test diferentes puede ser la creación de una clase principal que lance y controle nuestras pruebas, en este caso, recordar que para ejecutar una clase como si fuese un test de JUnit desde java se puede recurrir a crear una instancia de JUnitCore:

JUnitCore junit = new JUnitCore();

y luego llamar a su metodo run y recoger los resultados en una instancia de la clase Result

junit.run(NombreDeLaClase.class);

sábado, 10 de agosto de 2013

Selenium : Primeros Pasos


Vamos a preparar nuestro entorno de desarrollo para crear y ejecutar nuestros test de automatización web en selenium. En el ejemplo hemos escogido Eclipse como IDE

Lo primero que debemos hacer es descargar los archivos selenium-server-standalone-x.xx.x y selenium-java-x.xx.x de la pagina de selenium. Jars Selenium

Tambien vamos a necesitar el jar de junit que se puede bajar de aquí

Una vez lo tenemos todo, creamos un nuevo Java Project en Eclipse y añadimos los jars bajados a nuestro classpath, hay varias formas de hacer esto, yo voy a poner un ejemplo para incluirlos en nuestro proyecto y no tener dependencias de ubicaciones externas.

Creamos una nueva carpeta llamada lib en el primer nivel de nuestro proyecto y copiamos allí los jars bajados.





Ahora hacemos click derecho en cada uno de ellos y seleccionamos Build path -> Add to Build Path.

Veremos como una vez hecho esto, se ha creado en nuestro proyecto unas nuevas librerías bajo el nombre de Referenced Libraries, para asegurarnos que no estan corruptas y tienen contenido podemos desplegarlas y asegurarnos que contienen los packages con sus clases.

De esta manera se pueden ejecutar test grabados desde el ide Selenium en Firefox ejecutados como test JUnit o escribir a mano los propios casos de pruebas en Java.

En siguientes post, entraremos en materia y haremos varios ejemplos de circuitos ejecutandose