Translate

Mostrando las entradas con la etiqueta jboss. Mostrar todas las entradas
Mostrando las entradas con la etiqueta jboss. Mostrar todas las entradas

jueves, 13 de febrero de 2020

Libros de Java Code Geeks

Download IT Guides!


Drools supports the JSR-94 standard for its business rule engine and enterprise framework for the construction, maintenance, and enforcement of business policies in an organization,...

In the following sections we will discuss about object-oriented programming and its characteristics, general questions regarding Java and its functionality, collections in Java, garbage...

We are going to explain what reflection is in general and how can be used in Java. Real uses cases about different reflection uses are listed in the next chapters.

The principle is sometimes stated as a recommendation to the programmer, but sometimes stated as requirement of the programming language, assuming it is self-understood why abstractions...

miércoles, 12 de febrero de 2014

Liberado WildFly 8 !!

WildFly para el que no sabe es JBoss. Nuestro querido servidor de aplicaciones JBoss cambio de nombre a WildFly. Dado que según la gente de Red Hat el nombre JBoss, daba a confusión el producto comercial JBoss con el JBoss de la comunidad. Y la gente de Red Hat decidió cambiar el JBoss de la comunidad.  A mi ver las cosas fue una mala pasada pero bueno es mi opinión.

WildFly 8 es la nueva versión del servidor de Aplicaciones, y además del cambio de nombre; trae las siguiente novedades:

Mejora en la compatibilidad con Java 8
Java EE7 Certificado
Mejora en la performance
Mejora en Web service y rest
etc...

Dejo link:
http://www.wildfly.org/
http://wildfly.org/downloads/
http://wildfly.org/news/2014/02/11/WildFly8-Final-Released/

jueves, 13 de diciembre de 2012

No estamos grande para jugar a la lucha Spring vs JEE??


A raíz de un articulo de InfoQ  me quede pensando, cuanto cuesta que spring respete el estándar JEE? Recordemos que Spring nació como un framework que proveía un montón de características para no utilizar JEE.  Spring se ha popularizado en la comunidad de programadores en Java al ser considerado como una alternativa y sustituto del modelo de Enterprise JavaBeans. Por su diseño el framework ofrece mucha libertad a los desarrolladores y soluciones muy bien documentadas y fáciles de usar para las prácticas comunes en la industria.

Pero JEE aprendió de sus desaciertos fue acercándose a un modelo más flexible. Y yo veo que con el tiempo se fue springizando. EL GAP que existía entre Spring y JEE es cada vez más pequeño. Cuesta mucho hacerlo nulo? O optar por hacer Spring JEE y otro no JEE?

Si, ya se la respuesta es: "A mi me gusta solo usar tomcat o jety y no quiero usar JBoss o Glashfish". Creo que se puede modularizar y en los servidores solo cargar lo que usamos. Por ejemplo si solo necesito servicios web, jetty. Si necesito servicios web y un servicio como JMS uso jetty + modulo de ActiveQ o el que sea. Hoy en día es como que no existe punto medio o jetty o tomcat o JBoss  o otro servidor JEE. Algo super liviano o algo pesado. Por esto también aplaudo a soluciones como TomEE que implementa Java EE 6 Web Profile.

Que opinan matamos a JEE como un estándar cerrado y lo rompemos en cajitas modulares? Hacemos que spring respete ese orden y cumpla el estándar? No estamos grande para jugar a la lucha Spring vs JEE?

sábado, 6 de octubre de 2012

VOTE!!! Give JBoss Application Server a new name!


Me llego un mail de la gente de Red Hat al parecer van a cambiar el nombre de su producto estrella JBoss y quieren consultar a la comunidad cual es el mejor nombre para el servidor Open Source. Ojo van a cambiar el nombre de su servidor pero la versión de la comunidad; el servidor comercial va seguir llamándose JBoss.

Creo que Red Hat esta haciendo el mismo movimiento que hizo con Red Hat en su momento, tener una versión para la comunidad Fedora y otra para facturar Red Hat.

Vamos a ver como sigue esta historia, por ahora a votar el mejor nombre!

Dejo el link:
https://sso.jboss.org/login?service=https%3A%2F%2Fwww.jboss.org%2Frename.html

jueves, 6 de septiembre de 2012

JBoss Developer Framework


Recientemente Jboss ha liberado JBoss Developer Framework o JDF para los amigos.  El Framework en realidad es un centro de documentación central para todas las tecnologías relacionadas con JBoss y JBoss AS. Este esfuerzo de consolidación permite a los desarrolladores centrarse en un recurso único de documentos en lugar de tomar varias guías individuales de las diferentes tecnologías de JBoss (por ejemplo, una guía de Hibernate y otra para Seam).

JDF incluye más de 50 quickstarts  que son proyectos Maven que se generan con archetypes. Lo interesante es que la mayoría de los quickstarts generan los proyectos con varias capas,  Estos pueden servir ya sea como tutoriales o como la base para las aplicaciones más complicadas. Algunas de las tecnologías que incluyen: EJB, JAX-RS, JPA, JSF, CDI, HTML5, JTA, Apache Wicket...

Dejo links:
http://in.relation.to/Bloggers/AnnouncingJdfJBossDeveloperFramework
http://www.jboss.org/jdf/news/2012/06/05/welcome/

miércoles, 6 de junio de 2012

The Jboss Way

Jboss abri un portal el que cuenta con tutoriales, ejemplos y 50 quickstarts para aprender a utilizar JBoss. Se puede también suscribir. El objetivo es poder sumar gente y hacer comunidad.


Me parece una excelente idea; dejo el link:

http://www.jboss.org/developer

jueves, 24 de mayo de 2012

AeroGear, desarrollo movile con Jboss


AeroGear es un proyecto para desarrollo movile de todo tipo utilizando JBoss; se puede desarrollar  para plataformas nativas y también con HTML 5. Su documentación es amplia pero un poco desordenada; se integra con varios proyectos de JBoss, como Arquillian, QUnit, TorqueBox, DeltaSpike y también esta integrado a OpenShift.

Las formas de desarrollar son HTML 5, nativas y también híbridas.  Se puede desarrollar aplicaciones moviles basadas en HTML 5 con Ruby on Rails escrita en JRuby sobre JBoss gracias a TorqueBox. Además esta totalmente integrado con Maven.

Además define POH5 (Plain Old HTML5) Applications; que es POH5 Applications? La revolución de HTML5 hace pensar diferente acerca de su estructura general, con más de JavaScript y CSS del lado del cliente y REST del lado del servidor. Sin embargo, la web no ha cambiado sólo ha conseguido ser mejor y más abierta.



Y es open source!!

Dejo Links:
http://www.jboss.org/aerogear
https://community.jboss.org/en/aerogear
https://community.jboss.org/wiki/GetStartedWithTheMobileWeb

Dejo un video:



TorqueBox



TorqueBox es una plataforma para desarrollo con JRuby que integra tecnologías populares en Ruby como Ruby on Rails con JBoss proveyendo mensajes asíncronos,  caching, scheduled jobs, clustering, daemons y más y más!!

TorqueBox provee un entorno todo en uno, construyendo aplicaciones bajo la plataforma JBoss AS.

Como deciamos entre las caracteristica encontramos:


  • Rack: TorqueBox soporta Rack, incluyendo Rails 2.3.x, Rails 3.x, Sinatra, y otros.
  •  JDBC
  • Daemons
  • Scheduled Jobs
  • Messaging
  • Asynchronous Tasks


Veamos el gráfico:

Para más info dejo el link:
http://torquebox.org/



Immutant

Immutant es una aplicación servidora para Clojure que integra este a la plataforma JBoss 7 proveyendo mensajes asíncronos,  caching, scheduled jobs, clustering, daemons y más y más!!



Dejo el link:
http://immutant.org/
http://immutant.org/documentation/

domingo, 20 de noviembre de 2011

EJB 3 + Maven 2 + JBoss 6 + Eclipse

Vamos a crear un proyecto Jee con maven y que use como servidor Jboss con la siguiente estructura:

pom parent _
                     |__ ejb
                     |__ war

Bueno creamos el proyecto parent:

mvn archetype:create -DgroupId=com.ejemplos -DartifactId=EjemploJEE

Y modificamos el pom para que quede de la siguiente manera:


  4.0.0

  org.assembly
  ExampleJEE
  1.0-SNAPSHOT
  pom

  ExampleJEE
  http://maven.apache.org

  
    UTF-8
  

   
  
   
   maven-compiler-plugin 
    
    1.6 
    1.6 
    
   
   
   org.apache.maven.plugins 
   maven-eclipse-plugin 
   2.7      
    
    2.0 
    true 
    
   
   
   org.apache.maven.plugins   
      maven-javadoc-plugin    
   
   
   org.apache.maven.plugins   
       maven-project-info-reports-plugin    
   
  
  

  
        
            jboss-repository
            JBoss Repository
            https://repository.jboss.org/nexus/content/groups/public/
            default
        
    


  
     
    
      jboss
      jboss-ejb-api
      4.2.0.GA
      provided
    

    
      junit
      junit
      4.10
      test
    

  





Creamos el proyecto ejb:

cd ExampleJEE
mvn archetype:create -DgroupId=org.assembly -DartifactId=ExampleEJB

Y cambiamos el pom de la siguiente manera:



  4.0.0

  
    ExampleJEE
    org.assembly
    1.0-SNAPSHOT
  

  org.assembly

  ExampleEJB

  1.0-SNAPSHOT

  ejb

  ExampleEAR

  http://maven.apache.org

  
   
       
            javax.persistence
            persistence-api
            1.0
            provided
           
        
  
  
  
    UTF-8
  

 
    
    
      
        org.apache.maven.plugins
        maven-ejb-plugin
        2.1
        
          3.0
        
      

    
  





Ahora vamos a generar el proyecto war siempre dentro de ExampleJEE:

mvn archetype:create -DarchetypeArtifactId=maven-archetype-webapp -DgroupId=org.assembly -DartifactId=ExampleWAR

Y cambiamos el pom de la siguiente manera:


  
  4.0.0
  
  
    ExampleJEE
    org.assembly
    1.0-SNAPSHOT
  
  
  org.assembly
  
  ExampleWAR

  1.0-SNAPSHOT

  war

  ExampleWAR Maven Webapp

  http://maven.apache.org

  
    ExampleWAR
  

  
 
   
            org.assembly
            ExampleEJB
            1.0-SNAPSHOT
            provided
        
 
     
            javax.servlet
            servlet-api
            2.5
            provided
        

  





Pongo la dependencia a ExampleEJB como provided dado que no quiero que maven agregue el jar dentro del war después hago deploy del proyecto EJB y del WAR.

Ahora mvn clean install parados en el proyecto parent (ExampleJEE) y mvn eclipse:eclipse (si usan eclipse).

Bueno ahora importamos el proyecto a eclipse: file-> import-> Existing Projects into Workspace … Elegimos el path donde se encuentra el proyecto ExampleJEE y importamos.

Vamos a crear las siguientes clases en ExampleEJB:

La interfaz del servicio:

package org.assembly.service.api;

import javax.ejb.Remote;

@Remote
public interface HolaMundo {
 
 String decirHola();

}



La implementación :

package org.assembly.service.impl;

import javax.ejb.Stateless;

import org.assembly.service.api.HolaMundo;

@Stateless
public class HolaMundoImpl implements HolaMundo {

 /* (non-Javadoc)
  * @see org.assembly.service.api.HolaMundo#decirHola()
  */
 @Override
 public String decirHola() {
  return "Hola";

 }

}




Además agregamos este archivo en src/main/resources (si no existe la carpeta la crean) y lo nombramos jndi.properties

java.naming.factory.initial=org.jnp.interfaces.NamingContextFactory
java.naming.factory.url.pkgs=org.jboss.naming:org.jnp.interfaces
java.naming.provider.url=localhost:1099



Y en el Proyecto web agregamos este servlet:

package org.assembly.web;

import java.io.IOException;
import java.io.PrintWriter;

import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.assembly.service.api.HolaMundo;

public class HolaMundoServlet extends HttpServlet {

 private static final long serialVersionUID = 7819040755879233852L;

 private HolaMundo holaMundo = null;

 
 public HolaMundoServlet() {
  final Context context;
  try {
   context = new InitialContext();
   holaMundo = (HolaMundo) context.lookup("HolaMundoImpl/remote");

  } catch (NamingException e) {
   e.printStackTrace();
  }
 }


 @Override
 protected void doGet(HttpServletRequest req, HttpServletResponse resp)
   throws ServletException, IOException {
  final PrintWriter out = resp.getWriter();

  try {
   out.println(holaMundo.decirHola());
  } catch (Exception e) {
   out.println(e.getStackTrace().toString());
  }

 }

}



Por ultimo modificamos el web.xml para que escuche el servlet:


  Archetype Created Web Application
  
  
    
        hola
        org.assembly.web.HolaMundoServlet
    

    
        hola
        /hola.html
    
  
  





Ahora lo que hacemos es instalar el plugin Jboss Tools en eclipse lo podemos hacer desde el Marketplace de eclipse.



Ahora bajar Jboss 6 desde http://download.jboss.org/jbossas/6.1/jboss-as-distribution-6.1.0.Final.zip

Instalar el Jboss desde el panel de Servers menú contextual new. Luego importamos nuestros proyectos. Si todo fue bien debería verse el entorno así:



Corremos Jboss y en http://localhost:8080/ExampleWAR/hola.html deberíamos ver un “hola”

lunes, 31 de octubre de 2011

Netty

Netty es un framework de Jboss que provee un manejo asíncrono en aplicaciones web, un framework ideal para hacer comet.

Netty es un cliente NIO infraestructura de servidor que permite el desarrollo rápido y sencillo de aplicaciones de red, tales como servidores de protocolo y los clientes. Simplifica y agiliza la programación de la red tales como TCP y UDP socket servidor.

"Rápido y fácil" no significa que una aplicación resultante sufrirá un mantenimiento o un problema de rendimiento. Netty ha sido diseñado cuidadosamente con las experiencias obtenidos de la implementación de una gran cantidad de protocolos como FTP, SMTP, HTTP, etc.Como resultado, Netty ha logrado encontrar una forma de lograr la facilidad de desarrollo, rendimiento, estabilidad y flexibilidad sin compromiso.

Mas adelante vamos a probar este framework.

Dejo links:

http://www.jboss.org/netty
http://www.jboss.org/netty/documentation.html
http://docs.jboss.org/netty/3.2/guide/html_single/index.html

jueves, 14 de julio de 2011

JBoss Application Server 7 is here!


Hoy me llego un mail de la gente de DZone, por el release de JBoss 7.
Indican 7 ventajas de usar la nueva versión del servidor:
  1. El tiempo asombrosamente más rápido hasta 10 veces.
  2. Java EE 6 - entre las primeras implementaciones. No es cabeza ya que WebSphere V8, soporta Java EE 6.
  3. Muy ligero
  4. Modular - proporciona aislamiento de la aplicación real.
  5. Gestión Elegante - consola simplificada y APIs.
  6. Administración - administración servidores como grupos.
  7. Testeable - simplifica las pruebas a través del proyecto Arquillian.

Bueno es el momento de bajarlo, probarlo y ver si es verdad lo que dicen!

Dejo links:



domingo, 27 de febrero de 2011

Validacion por Hibernate Validator


La JSR 303 - Bean Validation propone un API de validación basada en un modelo de metadatos, además establece como principal método de definición las anotaciones, aunque estas también pueden ser especificadas y/o extendidas a través de archivos de configuración XML. Otra de las características interesantes de la JSR 303 es que su API no liga especificamente la ejecución de las validaciones a una capa en particular como podría ser la capa web o la de persistencia, sino que puede ser utilizada desde cualquier punto de la aplicación.
Hibernate Validator es la implementación de referencia de la JSR 303.

Cuando validamos datos es posible que la validación sea puesta en la capa de presentación. Poniendo la validación en la capa de presentación corremos el riesgo de replicarla cuantas pantallas se puedan cargar los datos o si por ejemplo hay que exponer una funcionalidad por un web service o mecanismo remoto. El mejor lugar para las validaciones es la capa de presentación y hibernate validator nos ayuda a escribir estas validaciones por medio de anotaciones o xml.

Hibernate validator permite:
  • Definir validaciones usando XML y/o anotaciones
  • Validación completa y recursiva de objetos
  • Definición a medida de constraints y validadores
  • Personalización de mensajes de error

Las anotaciones más útiles son:

@Length(min=, max=): Chequea si el largo del string se encuentra en el rango indicado.
@Max(value=): Chequea que el valor sea menor o igual que el valor indicado.
@Min(value=): Chequea que el valor sea mayor o igual que el valor indicado.
@NotNull: Chequea que el valor no sea nulo
@Email: Chequea que el valor sea un mail valido.
@Range(min=, max=): Chequea que el valor se encuentre entre el rango especificado.
@Future: Chequea que el valor sea una fecha futura.
@Past: Chequea que el valor sea una fecha pasada.
@Pattern(regex="regexp", flag=): Cheque a que la propiedad machea con la expresión regular, given a match flag (see java.util.regex.Pattern for more information)
@Patterns( {@Pattern(...)} ): Como @Pattern, pero con multiples expresiones regulares.

Veamos un ejemplo de una clase validada por medio de Hibernate Validator:




package org.assembly.fenrir.model.student;

import java.util.Calendar;
import java.util.Date;

import org.hibernate.validator.NotNull;
import org.hibernate.validator.Past;


/**
* class that represents a student
*
* @author emanuel
*
*/
public class Student {

private static final int COUNT_MONTH_IN_YEAR = 12;

private String name;

private String lastName;

private Date birthDate;

private String comment;

public Student(String name, String lastName, Date birthDate){
this.name = name;
this.lastName = lastName;
this.birthDate = birthDate;
}

public Student() { }


@NotNull
public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

@NotNull
public String getLastName() {
return lastName;
}

public void setLastName(String lastName) {
this.lastName = lastName;
}

@NotNull
@Past
public Date getBirthDate() {
return birthDate;
}

public void setBirthDate(Date birthDate) {
this.birthDate = birthDate;
}

public String getComment() {
return comment;
}

public void setComment(String comment) {
this.comment = comment;
}


}




Pero como es que se valida? En cualquier punto de la aplicación se puede validar si los datos son correctos en cualquier capa de la aplicación, pero por ejemplo utilizando en la capa de presentación richfaces; este ya hace las validaciones atravez de las anotaciones o xml.

Si utilizas maven y quieres agregar este framework, aca va la dependencia del pom:





org.hibernate

hibernate-validator

3.1.0.GA





Como siempre dejo link:


domingo, 1 de noviembre de 2009

RESTEasy

Es un proyecto de jboss que provee una implementación a jsr 311. Este proyecto contiene un conjunto de frameworks que nos facilitan el desarrollo con web services rest.

Jsr 311 nos permite desarrollar y publicar web services rest con anotaciones, vean que fácil es:

@Path("/library")

public class Library {

@GET

@Path("/books")

public String getBooks() {...}

@GET

@Path("/book/{isbn}")

public String getBook(@PathParam("isbn") String id) {

// search my database and get a string representation and return it

}

@PUT

@Path("/book/{isbn}")

public void addBook(@PathParam("isbn") String id, @QueryParam("name") String name) {...}

@DELETE

@Path("/book/{id}")

public void removeBook(@PathParam("id") String id {...}

}

Recuerden que los web services rest no tienen un descriptor wsdl como los soap, sino que lo que describe a los servicios rest en la url y el método por donde se aceden.

@PUT, @DELETE, @GET, etc decimos el método y con @Path indicamos el path donde esta publicado.

RESTeasy puede ejecutarse sobre cualquier contenedor web.