Archive

Archive for the ‘NetBeans’ Category

PushServer + Jetty + Primefaces + WebSockets = PrimePush

abril 10, 2012 6 comentarios

Después de haber recorrido internet buscando a una solución para implementar AjaxPush con el framework para JSF de Primefaces 3, pues al fin lo he logrado, como nos comentan los creadores de primefaces dentro de la documentación oficial, para hacer este tipo de implementaciones es necesario crear un servidor paralelo a nuestra aplicación, este va ser un servidor de Push y se va a encargar exclusivamente de ese trabajo, conservando nuestro proyecto mucho más modular y escalable. Actualmente nos dicen que solo existe soporte para el servidor push implementado con las librerías de jetty, así que para comprobarlo he realizado unas cuantas pruebas obteneniendo un resultado excelente. Como se realizó esto lo voy a mostrar ahora:

  1. Lo primero que debemos hacer es descargar la librería de Jetty, en este casó la última versión que he podido encontrar es Jetty 8.1.2.
  2. Luego voy a crear un proyecto java estándar como los de escritorio o de consola en Netbeans 7.1.
  3. Agregar estas librerías al proyecto.
    jetty-websocket-8.1.2.v20120308.jar
    servlet-api-3.0.jar
    jetty-server-8.1.2.v20120308.jar
    jetty-servlet-8.1.2.v20120308.jar
    jetty-annotations-8.1.2.v20120308.jar
    jetty-io-8.1.2.v20120308.jar
    jetty-util-8.1.2.v20120308.jar
    jetty-http-8.1.2.v20120308.jar
    jetty-security-8.1.2.v20120308.jar
    jetty-continuation-8.1.2.v20120308.jar
  1. Creamos una clase principal con un método main como está.
import org.eclipse.jetty.server.Server;
import org.eclipse.jetty.servlet.ServletContextHandler;
import org.eclipse.jetty.servlet.ServletHolder;
import servlet.PushServlet;

/**
* @author christmo
*/
public class JettyServerPush {

    public static void main(String[] args) throws Exception {
        Server server = new Server(8081);

        ServletContextHandler context = new ServletContextHandler(ServletContextHandler.SESSIONS);
        context.setContextPath("/");
        server.setHandler(context);

        context.addServlet(new ServletHolder(new PushServlet()), "/*");

        server.start();
        server.join();
    }
}

Luego lo que queda es agregar la clase PushServlet que se tiene que desplegar con el servicio de websockets, esta clase la podemos encontrar íntegra en el código de primefaces, yo he hecho un par de modificaciones para hacer las pruebas pero uds la pueden personalizar como gusten.

import java.io.IOException;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CopyOnWriteArraySet;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import org.eclipse.jetty.websocket.WebSocket;
import org.eclipse.jetty.websocket.WebSocketServlet;

public class PushServlet extends WebSocketServlet {

    private static final long serialVersionUID = 1L;

    private final Map<String,Set> connectedClients = new ConcurrentHashMap>();

    @Override
    public void init() throws ServletException {
        super.init();
        String[] channels = {"chat","counter"};

        for(String channel : channels) {
            this.connectedClients.put(channel, new CopyOnWriteArraySet());
        }
    }

    @Override
    public WebSocket doWebSocketConnect(HttpServletRequest request, String protocol) {
        String channel = request.getRequestURI().split("/prime-push/")[1];
        System.out.println("Canal:"+channel);
        return new PrimeWebSocket(channel);
    }

    private class PrimeWebSocket implements WebSocket, WebSocket.OnTextMessage {
        Connection connection;
        String channel;

        public PrimeWebSocket(String channel) {
            this.channel = channel;
        }

        public void onClose(int closeCode, String message) {
            connectedClients.get(this.channel).remove(this);
        }

        public void onOpen(Connection connection) {
            this.connection = connection;
            connectedClients.get(this.channel).add(this);
        }

        public void onMessage(String message) {
            System.out.println(message);
            try {
                for(PrimeWebSocket ws : connectedClients.get(this.channel)) {
                    ws.connection.sendMessage(message);
                }
            }catch(IOException e) {
                System.out.println(e);
            }
        }
    }
}

Finalmente ejecutamos nuestro servidor Jetty el cual ya es un servidor de PUSH, este está corriendo en el puerto 8081, podemos hacer pruebas rápidamente a través de esta página http://websocket.org/echo.html donde tenemos un cliente de websockets.

Lo que debemos poner para probar es está ruta ws://localhost:8081/prime-push/counter y conectar, si nos aparece el mensaje conectado pues todo ha salido muy bien y el servidor está listo, podemos hacer pruebas con este enviando algo desde allí y abriendo esa página en más pestañas.

Cliente Primefaces – PrimePush

Para hacer la misma prueba desde un proyecto con primefaces debemos crear un proyecto web, descargar la librería de primefaces añadirla al proyecto que estamos creando y haremos lo siguiente:

Crearemos un archivo JSF con el nombre de index.xhtml y pondremos lo que se muestra a continuación.

<?xml version='1.0' encoding='UTF-8' ?>
<!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"
      xmlns:h="http://java.sun.com/jsf/html"
      xmlns:p="http://primefaces.org/ui" >
    <h:head>
        <title>Facelet Title</title>
        <style type="text/css">
            .display {
                font-size: 36px !important;
            }
        </style>

        <script type="text/javascript">
            //<![CDATA[
            function handleMessage(evt, data) {
                $('.display').html(data);
            }
            //]]>
        </script>
    </h:head>
    <h:body>
        <h:form>
            <h:outputText value="#{beanPush.count}" styleClass="ui-widget display" />

            <br />

            <p:commandButton value="Click" actionListener="#{beanPush.increment}" />
        </h:form>

        <p:push onmessage="handleMessage" channel="counter" />

    </h:body>
</html>

Luego crearemos una clase dentro de código que maneje la lógica de la aplicación en este caso un contador, este va ser nuestro manejador de bean.

package bean;

import java.io.Serializable;
import javax.faces.bean.ApplicationScoped;
import javax.faces.bean.ManagedBean;
import org.primefaces.context.RequestContext;

/**
 * @author christmo
 */
@ManagedBean
@ApplicationScoped
public class BeanPush implements Serializable {

    private int count;

    public int getCount() {
        return count;
    }

    public void setCount(int count) {
        this.count = count;
    }

    public void increment() {
        count++;
        RequestContext.getCurrentInstance().push("counter", count);
    }
}

Finalmente necesitamos hacer que la aplicación apunte a nuestro servidor de Push creado anteriormente eso lo debemos hacer añadiendo lo siguiente dentro del archivo web.xml

    <context-param>
        <param-name>primefaces.PUSH_SERVER_URL</param-name>
        <param-value>ws://localhost:8081/</param-value>
    </context-param>

Y eso es todo espero que les funcione, si todo lo que escribí por aquí sonó a chino aquí les dejo los proyectos para que los revisen…

Proyectos 😉

Saludos

Christian Mora

@christmo

Categorías:glassfish, Java, JSF, Linux, NetBeans, Web 2.0 Etiquetas:

Leer archivo properties desde el path donde se ejecuta el *.jar

abril 29, 2011 4 comentarios

Hola retomando las publicaciones por cuestiones de tiempo, he querido poner esto ya que es bastante útil al momento de realizar una aplicación que requiera parámetros de configuración que sean obtenidos de alguna fuente externa como un archivo de propiedades (*.properties), este método que se presenta más abajo hace la lectura de las propiedades de una archivo de este tipo *.properties que se encuentre junto al .*jar ejecutable de nuestra aplicación, esto quiere decir que los dos archivos tienen que estar dentro del mismo directorio. A mi me ha funcionado muy bien con este método lo que tendrían que hacer es ponerlo en una clase genérica y de allí si referenciarlo cada vez que sea necesario, este recibe el nombre del archivo de propiedades que queremos leer.

    public static Properties obtenerArchivoPropiedades(String arc) throws FileNotFoundException {
        Properties prop = null;
        try {
            CodeSource codeSource = funcionesUtilidad.class.getProtectionDomain().getCodeSource();
            File jarFile = new File(codeSource.getLocation().toURI().getPath());
            File jarDir = jarFile.getParentFile();

            if (jarDir != null && jarDir.isDirectory()) {
                File propFile = new File(jarDir, arc);
                prop = new Properties();
                prop.load(new BufferedReader(new FileReader(propFile.getAbsoluteFile())));
            }
        } catch (URISyntaxException ex) {
            Logger.getLogger(funcionesUtilidad.class.getName()).log(Level.SEVERE, null, ex);
        } catch (FileNotFoundException ex) {
            //System.err.println("No se encuentra el archivo: " + ex.getMessage());
            throw new FileNotFoundException("No se econtró el archivo de propiedades...");
        } catch (IOException ex) {
            Logger.getLogger(funcionesUtilidad.class.getName()).log(Level.SEVERE, null, ex);
        }
        return prop;
    }

Saludos

Christian Mora
@christmo

Curso de Java Básico

marzo 6, 2010 Los comentarios están cerrados

Cursos vacacionales de Java…

Temario del Curso de Java

Clase 1:

Clase 2

Clase 3

Clase 4

Clase 5

Saludos a todos, aquí  se irán poniendo las presentaciones del cursos vacacional de JAVA…

Christian Mora

Categorías:IEEE, informatica, Java, NetBeans, UTPL Etiquetas:

Cursos Vacacionales de JAVA!!!…

marzo 3, 2010 Los comentarios están cerrados

Cursos Vacacionales

Cursos Vacacionales

Ver temario del curso…


Categorías:IEEE, informatica, Java, Loja, NetBeans, UTPL Etiquetas: , , , ,

Conexión a Servidor LDAP desde JAVA

mayo 26, 2009 14 comentarios

Hola en en trabajo me pidieron realizar una conexión a un servidor LDAP desde una aplicación java, esto me pareció algo difícil en un principio ya que no tenía idea de como realizar algo parecido, con algunas sugerencias de parte de mi jefe decidimos usar la librería de novell para java jLDAP, esta librería es muy completa y permite realizar todas las posibles transacciones dentro de un servidor LDAP, novell también tiene bien documentado esto hasta con ejemplos todo el API esta aquí, una ves que te familiarizas con el código vas a ver que todo es muy fácil, pero es esta serie de posts vamos a ejemplificar como se podría hacer un CRUD dentro de nuestro servidor.

Para realizar la conexión aremos lo siguiente:


package conexionldap;
import com.novell.ldap.LDAPConnection;
import com.novell.ldap.LDAPException;
import java.io.UnsupportedEncodingException;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
* @author christian
* Clase de Conexion Servidor LDAP
*/

public class Conexion {

     private int ldapPort;
     private int ldapVersion;
     private LDAPConnection lc;
     private String login;
     private String ldapHost = "172.16.30.162";

     public Conexion() {
     }

     /**
     * Este método permite realizar la conexión al servidor de LDAP
     * Para el usuario manager
     * @param strManager
     * @param strPassword
     */

     public LDAPConnection ConexionManager(String strManager, String strPassword) {
          login = "cn=" + strManager + ",o=utpl,c=ec";
          System.out.println("" + login);
          ldapPort = LDAPConnection.DEFAULT_PORT;
          System.out.println("puerto: " + ldapPort);
          ldapVersion = LDAPConnection.LDAP_V3;
          System.out.println("Vesion: " + ldapVersion);
          System.out.println("HOST: " + ldapHost);
          try {
               lc = new LDAPConnection();
               lc.connect(ldapHost, ldapPort);
               System.out.println("====Conectado al Servidor LDAP====");
               lc.bind(ldapVersion, login, strPassword.getBytes("UTF8"));
               System.out.println("Autenticado en el servidor....");
          } catch (UnsupportedEncodingException ex) {
               Logger.getLogger(Conexion.class.getName()).log(Level.SEVERE,null, ex);
          } catch (LDAPException ex) {
               Logger.getLogger(Conexion.class.getName()).log(Level.SEVERE,null, ex);
          }
          return lc;
     }

     /**
     * Este metodo permite realizar la conexion al servidor de LDAP
     * Para el usuario manager
     * @param strUser
     * @param strPassword
     */

     public LDAPConnection ConexionUser(String strUser, String strPassword) {
          login = "uid=" + strUser + ",ou=People,o=utpl,c=ec";
          System.out.println("" + login);
          ldapPort = LDAPConnection.DEFAULT_PORT;
          System.out.println("puerto: " + ldapPort);
          ldapVersion = LDAPConnection.LDAP_V3;
          System.out.println("Vesion: " + ldapVersion);
          System.out.println("HOST: " + ldapHost);
          try {
               lc = new LDAPConnection();
               lc.connect(ldapHost, ldapPort);
               System.out.println("====Conectado al Servidor LDAP====");
               lc.bind(ldapVersion, login, strPassword.getBytes("UTF8"));
          } catch (UnsupportedEncodingException ex) {
               Logger.getLogger(Conexion.class.getName()).log(Level.SEVERE,null, ex);
          } catch (LDAPException ex) {
               Logger.getLogger(Conexion.class.getName()).log(Level.SEVERE,null, ex);
          }
          return lc;
     }

     public void CerrarConLDAP(LDAPConnection lc) {
          try {
               lc.disconnect();
               System.out.println("Conexion Cerrada Correctamente...");
          } catch (LDAPException ex) {
               Logger.getLogger(Conexion.class.getName()).log(Level.SEVERE,null, ex);
          }

     }

}

Continuar:

Busqueda de usuarios en el servidor LDAP

CRUD de usuarios en el servidor LDAP

Descargar Proyecto JAVA – Netbeans

Categorías:Java, ldap, Linux, NetBeans Etiquetas: , ,

Levantar Glassfish por consola en UBUNTU

abril 7, 2009 5 comentarios

Vamos ha ver como se hace para levantar un proyecto web, en el servidor de aplicaciones Glassfish desde la consola, regularmente como desarrolladores nos hemos encontrado con paquetes *.war, los cuales son el empaquetado de toda la aplicación web lista para funcionar, cuando instalamos netbeans también se instala glassfish pero a veces es demasiado pesado arrancar primero el IDE y después levantar el servidor de aplicaciones, para se cuenta con uno practico comando para solo levantar el servidor.

Debemos ir primero a la carpeta donde tenemos instalado glassfish y a bin, algunos lo podemos tener instalado por defecto en esta ruta:

$ cd glassfish-v2ur2/bin/

o

$ cd /usr/local/glassfish/bin/

Allí ponemos:

$ ./asadmin start-domain domain1

y esperamos un momento y ya está:

Ahora solo nos toca abrir un navegador y poner:

http://localhost:4848/

para entrar a la interfaz de administración de glassfish recuerda que cuando se instaló netbeans nos pidió un user y un password allí van, por defecto son “user: admin” y “password: adminadmin”, desde allí ya podremos gestionar todos los proyectos *.war que tengamos.

Para detener Glassfish pondremos los mismo solo que con la palabra stop:

$ ./asadmin stop-domain domain1

Eso es todo, por cierto este mismo comando lo podemos usar en Window$ solo debemos ponerlo en la consola dentro de la carpeta bin de glassfish de archivos de programa, espero que les sirva tanto como a mi.

Saludos…

christmo

Categorías:glassfish, Java, JSF, Linux, NetBeans Etiquetas:

Leer un archivo properties desde un proyecto web + JSF

agosto 15, 2008 6 comentarios

Hola en este post voy a mostrar como se debe hacer para leer un archivo *.properties de java, puesto dentro de un proyecto web JSF, es interesante mencionar que la forma de llamar a estos archivos difiere un poco de como se lo hace comúnmente en un proyecto swing de escritorio común y corriente,  ya que en este solo se pone el path relativo desde el pack del proyecto y ya, pero en un proyecto web no funciona así, por eso he decidido mostrarlo a continuación, esta es la forma que descubrí para hacerlo y me funcionó, pero si existe una forma mejor o más optima de realizarlo res ruego comentarlo para así aprender todos algo más.

Dentro de nuestro proyecto web se nos crean comunmente las páginas jsp, y su contraparte en código java dentro de un paquete en la carpeta Source Packages, dentro de ese paquete vamos a colocar el archivo .properties, teniendo en cuenta que este se va a llamar igual que la clase que lo va a leer, (por ejemplo: En mi paquete tengo una clase llamada Reportes.java, dentro del mismo paquete pondré un archivo de propiedades llamado reportes.properties), el código para ller este archivo quedaria así:

  String nombrePROP = Reportes.class.getSimpleName().toLowerCase() + ".properties";
  Properties props = new Properties();
  props.load(Reportes.class.getResourceAsStream(nombrePROP));
  String strPathOrigen = props.getProperty("pathORI");
  String strPathXLS = props.getProperty("pathXLS");

Con esto ya podriamos leer las propiesades que se tenga dentro de nuestro archivo properties.

Ahora para poder poner las propiedades sacadas del archivos en variables globales, tendremos que hacer lo siguiente, fuera de cualquier método y dentro de la clase vamos a poner esto, como un método más.

 private static String strPathOrigen;
 private static String strPathXLS;

 static {
      try {
          String nombrePROP = Reportes.class.getSimpleName().toLowerCase() + ".properties";
          Properties props = new Properties();
          props.load(Reportes.class.getResourceAsStream(nombrePROP));
          strPathOrigen = props.getProperty("pathORI");
          strPathXLS = props.getProperty("pathXLS");
      } catch (IOException ex) {
          Logger.getLogger(Reportes.class.getName()).log(Level.SEVERE, null, ex);
      }
 }

Así todo lo que se saque del archivo properties se almacenará globalmente y se podrá usar dentro de toda la clase si es necesario.

Espero que les haya servido…

Saludos christmo…

Categorías:Java, JSF, NetBeans Etiquetas: ,