Jetty com JSF2, JPA2 e Weld

Seguindo aquele experimento (post) de utilizar o jetty para desenvolver um aplicativo com JSF e JPA, também surgiu a necessidade de ver como fazer para uilizar o Weld, o framework de injeção de dependência. Basicamente, para poder utilizar o Weld no jetty deve-se seguir os seguintes passos:

1) No web.xml criamos um listener para o weld, como mostrado nas linhas em destaque abaixo:

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" version="2.5">
  <welcome-file-list>
    <welcome-file>index.html</welcome-file>
  </welcome-file-list>
  <context-param>
    <param-name>facelets.DEVELOPMENT</param-name>
    <param-value>true</param-value>
  </context-param>
  <servlet>
    <servlet-name>Faces Servlet</servlet-name>
    <servlet-class>javax.faces.webapp.FacesServlet</servlet-class>
    <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
    <servlet-name>Faces Servlet</servlet-name>
    <url-pattern>*.jsf</url-pattern>
  </servlet-mapping>
  <listener>
    <listener-class>org.jboss.weld.environment.servlet.Listener</listener-class>
  </listener>
  
   <listener>
    <listener-class>com.sun.faces.config.ConfigureListener</listener-class>
  </listener>
  
  <resource-env-ref>
    <description>Object factory for the CDI Bean Manager</description>
    <resource-env-ref-name>BeanManager</resource-env-ref-name>
    <resource-env-ref-type>javax.enterprise.inject.spi.BeanManager</resource-env-ref-type>
  </resource-env-ref>
  
   <context-param>
<param-name>primefaces.THEME</param-name>
<param-value>bootstrap</param-value>
</context-param>
  
<!-- <context-param> -->
<!-- <param-name>primefaces.skin</param-name> -->
<!-- <param-value>none</param-value> -->
<!-- </context-param> -->
  
</web-app>

e adicionar o arquivo jetty-env.xml no WEB-INF com o seguinte conteúdo:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE Configure PUBLIC "-//Mort Bay Consulting//DTD Configure//EN" "http://jetty.mortbay.org/configure.dtd">
<Configure id="webAppCtx" class="org.mortbay.jetty.webapp.WebAppContext">
<New id="beanManager" class="org.mortbay.jetty.plus.naming.Resource">
   <Arg>
     <Ref id="webAppCtx" />
   </Arg>
  <Arg>BeanManager</Arg>
  <Arg>
    <New class="javax.naming.Reference">
      <Arg>javax.enterprise.inject.spi.BeanManager</Arg>
      <Arg>org.jboss.weld.resources.ManagerObjectFactory</Arg>
     <Arg />
    </New>
</Arg>
</New>
</Configure>

Um projeto completo está disponível aqui.

para rodar basta entrar no diretório e digitar:

mvn jetty:run

depois, acesse o link: http://localhost:8080/contactlist/list.jsf

A diferença de projeto para o anteior, que não usava o weld, é que este usa o hibernate e o sqlite como banco de dados. Então pra quem quer usar o jetty com essas duas tecnologias vale a pena dar uma olhada no pom.xml.

Advertisements

Usando JSF2 e JPA2 com Jetty

Trabalhar com java para web muitas vezes é um exercício de paciência enorme, principalmente para fazer alguma coisa bem simples. Você pode gastar muito tempo para configurar direito o maven (praticamente nunca trabalhei em projeto que usasse maven ou ant), isso quando não se perde mais de um dia pra isso. Outro detalhe é o servidor de aplicação (jboss por exemplo) que entre vários restarts para fazer deploy toma muito tempo, por que até hoje não vi nenhum desses servidores de aplicação java que, mesmo com hot-deploy habilitado não dê um PermGem exception depois de seguidos re-deploys.

Resolvi tentar o jetty, que me parecia bem rápido e é utilizado de forma embarcada, em aplicativo como o Solr, que tem uma boa performance.

O Jetty é um servidor web feito em java muito leve. Apesar de ser um container servlet podemos estendê-lo para também ser um container EJB, por exemplo. Ele não vem com toda a stack do JEE, mas pesquisando um pouquinho na internet, consegui criar um pom.xml que permite usar JSF 2 (primefaces) e JPA 2 (Ebean, mas dá para usar o hibernate, simplesmente adicionando no pom as dependências).

A principal vantagem do jetty é a rapidez do deploy já que no boot ele não tem tanta coisa pedurada como o Jboss, que leva quase 8 segundos bootando na minha máquina.

Abaixo listo o pom.xml para um projeto baseado no Jetty, JSF e JPA:

 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
http://maven.apache.org/maven-v4_0_0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>sh.app.sample-projects</groupId>
<artifactId>jsf2-jetty-maven</artifactId>
<version>SNAPSHOT</version>
<name>JSF 2, JPA 2, Jetty and Maven together</name>

<dependencies>
<dependency>
<groupId>com.sun.faces</groupId>
<artifactId>jsf-api</artifactId>
<version>${com.sun.faces.version}</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>com.sun.faces</groupId>
<artifactId>jsf-impl</artifactId>
<version>${com.sun.faces.version}</version>
<scope>runtime</scope>
</dependency>

<dependency>
<groupId>commons-fileupload</groupId>
<artifactId> commons-fileupload</artifactId>
<version>1.2.1</version>
</dependency>
<dependency>
<groupId>commons-io</groupId>
<artifactId> commons-io</artifactId>
<version>2.1</version>
</dependency>

<dependency>
<groupId>org.xerial</groupId>
<artifactId>sqlite-jdbc</artifactId>
<version>3.7.2</version>
</dependency>

<dependency>
<groupId>org.avaje</groupId>
<artifactId>ebean-spring</artifactId>
<version>2.7.7</version>
</dependency>

<dependency>
<groupId>postgresql</groupId>
<artifactId>postgresql</artifactId>
<version>9.1-901.jdbc4</version>
</dependency>
    
     <!-- primefaces -->
<dependency>
<groupId>org.primefaces</groupId>
<artifactId>primefaces</artifactId>
<version>3.4.2</version>
</dependency>

<dependency>
<groupId>org.hsqldb</groupId>
<artifactId>hsqldb</artifactId>
<version>2.2.8</version>
<scope>compile</scope>
</dependency>

<dependency>
<groupId>javax.validation</groupId>
<artifactId>validation-api</artifactId>
<version>1.0.0.GA</version>
<scope>compile</scope>
</dependency>

<dependency>
<groupId>commons-logging</groupId>
<artifactId>commons-logging</artifactId>
<version>1.1.1</version>
</dependency>

<dependency>
<groupId>commons-collections</groupId>
<artifactId>commons-collections</artifactId>
<version>3.2.1</version>
</dependency>

<dependency>
<groupId>dom4j</groupId>
<artifactId>dom4j</artifactId>
<version>1.6.1</version>
</dependency>

<dependency>
<groupId>cglib</groupId>
<artifactId>cglib</artifactId>
<version>2.2</version>
</dependency>

<dependency>
<groupId>asm</groupId>
<artifactId>asm</artifactId>
<version>3.1</version>
</dependency>

<dependency>
<groupId>javax.transaction</groupId>
<artifactId>jta</artifactId>
<version>1.1</version>
</dependency>

  <!-- SQLite database JDBC -->
<dependency>
<groupId>org.xerial</groupId>
<artifactId>sqlite-jdbc</artifactId>
<version>3.6.0</version>
</dependency>

</dependencies>


<repositories>
<repository>
<id>prime-repo</id>
<name>PrimeFaces Maven Repository</name>
<url>http://repository.primefaces.org</url>
<layout>default</layout>
</repository>
<repository>
<id>JBoss repository</id>
<url>http://repository.jboss.com/maven2/</url>
</repository>
</repositories>

<build>
<finalName>contactlist</finalName>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<source>${java.source.level}</source>
<target>${java.source.level}</target>
</configuration>
</plugin>
<plugin>
<groupId>org.mortbay.jetty</groupId>
<artifactId>jetty-maven-plugin</artifactId>
<version>${jetty-maven-plugin.version}</version>
<configuration>
    <webApp>
     <contextPath>/contactlist</contextPath>
   </webApp>
   </configuration>
</plugin>
      
     <!-- Tomcat plugin for embedded tomcat -->
<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>tomcat-maven-plugin</artifactId>
<configuration>
<path>/contactlist</path>
</configuration>
</plugin>

</plugins>
</build>

<properties>
<encoding>UTF-8</encoding>

<java.source.level>1.6</java.source.level>
<spring.version>3.1.3.RELEASE</spring.version>
<com.sun.faces.version>2.1.7</com.sun.faces.version>
<jetty-maven-plugin.version>8.1.2.v20120308</jetty-maven-plugin.version>
<org.slf4j.version>1.6.5</org.slf4j.version>
<junit.version>4.10</junit.version>
</properties>

</project>

Um exemplo de projeto pode ser encontrado aqui

Para rodar entre no diretório do projeto e digite:

mvn jetty:run

e depois acessar a url:

http://localhost:8080/contactlist/list.jsf

CDI Alguns conceitos

Abaixo uma apresentação, também disponível no slideshare, sobre os conceitos do CDI (Contexts and Dependency Injection for Java EE).

Enviando Mensagem Jabber via Ruby ou Python

Esses dias eu queria enviar de alguma maneira por jabber, uma vez que estou 90% com um cliente jabber rodando no meu micro, mensagens me informando de eventos de alguma coisa que me interesse que ocorra em algum servidor ou mesmo no meu micro. Depois de tentar algumas libs em python e java, acabei conseguindo fazer um pequeno script em ruby (e python), simplesmente muito fácil, que atendeu totalmente o que eu queria.

Sem muito bla bla bla, pois o que interessa é mostrar funcionando, listo abaixo como instalar a gem (eu uso ruby 1.9) e um exemplo de como enviar a mensagem.
Instalando:

gem install xmpp4r

Eis os script que envia a mensagem:

require 'xmpp4r'
include Jabber

CLIENT_ID = 'cliente@jabber.org'
PASSWORD = ''

SEND_TO = 'destinatario@gmail.com'
JABBER_SERVER='jabber.org'   #para enviar a partir de um servidor jabber 
GTALK_SERVER='talk.google.com' #para enviar usando o google

Client.new(JID.new CLIENT_ID).instance_eval do
  connect JABBER_SERVER
  auth PASSWORD
  send Message.new(SEND_TO, 'enviando uma mensagem via ruby').tap{|m| m.type = :chat}
  close
end

Mas mesmo assim, pra quem gosta de programar em Python, baixe o xmmpy, descompacte e entre no diretório, para em seguida:

python setup.py install

Pronto, a biblioteca já está instalada. Abaixo um exemplo de como enviar a mensagem por Jabber:

import sys
import xmpp

# Google Talk constants
FROM_GMAIL_ID = "remente@gmail.com"
GMAIL_PASS = "senha_do_remente"
GTALK_SERVER = "talk.google.com"
TO_GMAIL_ID = "destinatario@gmail.com"

jid=xmpp.protocol.JID(FROM_GMAIL_ID)
cl=xmpp.Client(jid.getDomain(),debug=[])

if not cl.connect((GTALK_SERVER,5222)):
   raise IOError('Can not connect to server.')
if not cl.auth(jid.getNode(),GMAIL_PASS):
   raise IOError('Can not auth with server.')

cl.send( xmpp.Message(TO_GMAIL_ID ,"Fala meu bruxo!" ) )
cl.disconnect()

É isso galera, bem simples enviar mensagens para o seu cliente Jabber usando essas duas dicas. Detalhe: vc não precisa ter duas contas no Gtalk, basta enviar de vc para vc mesmo. Nerds carentes devem evitar esses scripts ehhehe.