To install it, before you’ll need to have git (if you already don’t have git installed ).
So, below you can see how to install it.

git clone git://github.com/AndyA/htop-osx.git
cd htop-osx
git checkout -b osx origin/osx
export CFLAGS="-m32"
./autogen.sh
./configure
make
sudo make install

To run it, just execute htop in your terminal.

In this post I gathered some tips to customize/adjust it.

• How to add terminal applications to launcher

For example, if you want to add the Eclipse IDE into your launcher, you need to create a file with “.desktop” extension and add the following content:

#Eclipse.desktop
[Desktop Entry]
Version=3.6
Name=Eclipse
Comment=
Exec=/home/rodrigo/Programs/eclipse/eclipse
StartupWMClass=
Terminal=false
X-MultipleArgs=false
Type=Application
Icon=/home/rodrigo/Programs/eclipse/icon.xpm
StartupNotify=true

Then, drag and drop this file into the launcher.

• How to show all icons in the system tray

By default, only a few icons are displayed in the tray. To show all icons, you need to open your terminal and type:

gsettings set com.canonical.Unity.Panel systray-whitelist "['all']"

Then, restart Ubuntu.

• How to remove the launcher auto-hide behavior

For it, you need to install the Advanced Desktop Effects Settings (ccsm)

sudo apt-get install compizconfig-settings-manager

Then, use Alt+F2 shortcut key to open the “Run a command” dialog, type about:config and run it, change the property Hide Launcher to Never.

• How to change the launcher icon size

Here, you also need install the Advanced Desktop Effects Settings (ccsm).

In the same window you used above, change the property Laucher icon size to another value.

• How to add a CPU/memory monitor int the system tray

Just type in your terminal:

sudo add-apt-repository ppa:alexeftimie/ppa
sudo apt-get update
sudo apt-get install indicator-sysmonitor
indicator-sysmonitor

You can put it (incidator-sysmonitor) in your Startup Application Preferences.

1. Fraise: não sei se todos sabem mas o aplicativo opensouce Smultron foi descontinuado (parece que agora ele voltou a ser atualizado e inclusive está a venda na Mac App Store), e isto só não se tornou um perda enorme porque um fork do projeto chamado Fraise apareceu. O Fraise seria algo similar ao notepad++ ou gedit. Simples mas funcional.




2. Sparrow: no começo eu usava o Mail.app como cliente de emails, depois que centralizei todas as minhas contas de email no GMail passei a utilizar apenas o GMail através do Fluid (escrevi um post sobre isso). Mas agora estou utilizando o Sparrow como cliente de email do GMail e estou gostando da interface simples dele e do seu consumo de memória que é bem menor que a do aplicativo que criei pelo Fluid.




3. YoruFukurou: Ok, esse nome é péssimo! Mas depois de muito tempo utilizando o Tweetie e aguardando atualizações que nunca aconteciam, resolvi testar outros clientes para twitter até que encontrei este e foi o que mais gostei até o momento. E Sim, já testei o Twitter for Mac, mas por enquanto ainda prefiro o YoruFukurou.




4. Reeder: Um ótimo cliente para Google Reader com uma interface bem elegante.




5. PS3 Media Server: Esse aqui é para quem tem Playstation 3 e quer compartilhar fotos, músicas e vídeos com o PS3 via rede Wifi ou por cabo mesmo.




6. Better Touch Tool: Só quem já experimentou o Multi-touch do trackpad de algum Macbook sabe como é. Mas mesmo o trackpad possuindo várias opções de toques e configurações, ainda assim você pode querer criar seus próprios toques e é aí que entra em cena o Better Touch Tool. Com ele você aumenta a quantidade de toques possíveis para o Trackpad, Magic Mouse e Magic Trackpad.




7. CyberDuck: Um bom cliente de FTP/SFTP. Antes utilizava o FileZilla mas comecei a ter alguns probleminhas com ele e por isso comecei a usar o CyberDuck.




8. Google Chrome: Usei durante um bom tempo o Safari e gostava bastante, mas passei a usar o Chrome como browser padrão depois que vi alguns recursos como a sincronização de bookmasks e plugins instalados.




9. Sequential: Se você costuma ler gibi, quadrinhos ou mangá pelo computador, esse aplicativo é para você.




10. iChm: Leitor de arquivo CHM. Costumo evitar sempre que posso arquivos nesse formato, mas nem sempre é possível.




11. iStat Menus: Este aplicativo é muito útil, com ele consigo ter várias informações no Menu Bar como: Memória usada/livre, atividade de rede, sensor de temperatura e consumo de cpu.




12. Time Machine: Só quem já perdeu um ou mais arquivos importantes sabe o quanto fazer backup é necessário e embora este aplicativo já venha instalado por padrão no Mac OS resolvi citá-lo, pois considero a melhor ferramenta de backup que já usei para Mac.




13. Dropbox: Uma outra ótima opcão de backup, mas online. Além de uma forma simples e rápida de compartilhar arquivos com outros computadores, smartphones e pessoas.

Então é isso, #fikdik desses aplicativos!

Porém o fato de ter que reserver uma aba do browser para o GMail me incomodava e também sentia falta de um ícone no Dock com a quantidade de emails não lidos.

Isso me motivou a procurar uma solução e foi aí que encontrei o aplicativo Fluid.

Com o Fuild, você consegue criar um aplicativo nativo para o Mac (.app) a partir de uma URL qualquer, adicioná-lo ao Dock e até mesmo exibir labels com informações (como a quantidade de emails não lidos do GMail).

Seu uso é bem simples, basta informar uma URL, um nome qualquer, local onde o aplicativo será criado e um ícone (no Google Images existem diversos ícones para GMail ).

Uma desvantagem ao usar essa abordagem é que se perde o recurso de pesquisa nos emails via Spotlight, porém raramente precisei usar o spotlight para fazer alguma busca nos meus emails, então não considero um alto preço a se pagar.

Então é isso, fica a dica a todos usuários do GMail e Mac OS!

Embora o nome da certificação tenha mudado, o seu conteúdo cobrado na prova continua o mesmo.

A prova em si é bem abrangente com muitas perguntas de enunciados grandes e muitas com duas ou três alternativas corretas para selecionar. Tiveram poucas (3 ou 4) alternativas de drag-and-drop.

Um dos pontos que sempre vejo comentarem é sobre o tempo da prova (02:15) que é pouco e realmente é verdade, quando terminei a prova tive pouco mais de 10 minutos para rever as questões que tinha marcado para revisão.

O material de estudo que utilizei foi:

Bom, agora vou descansar um pouco e começar a pensar na próxima etapa.

Antes de começar efetivamente este post, irei recomendar a leitura do post do Fábio Akita sobre RVM, nesse post ele mostra como instalar, configurar e utilizar o RVM. Eu recomendo muito utilizar o RVM, pois ele facilita bastante o gerenciamento e utilização de várias versões do ruby, rails e gems.

Nesse post irei utilizar as seguintes tecnologias:

OS: Mac OS 10.6.4/Linux Ubuntu 10.04
RVM: 1.0.1
JRuby: 1.5.2
Rails: 3.0.0
MySQL Server: 5.1.45

O exemplo completo do post pode ser visto no github: http://github.com/rlazoti/jruby-on-rails-3-example

Agora voltando ao post, vou começar instalando a versão atual do JRuby disponível no RVM que é a jruby-1.5.2, para instalar esta versão basta executar o comando a seguir (depois de ter instalado o RVM):

rvm install jruby

Agora vou definir o JRuby como a versão Ruby corrente no RVM através do comando:

rvm use jruby

Feito isso já posso instalar as gems necessárias para desenvolver com o Rails 3, inicialmente vou instalar apenas o Rails, pois as outras gem serão definidas na própria aplicação e instaladas pelo Bundler:

gem install rails

Com o MySQL, RVM, JRuby e Rails instalados já tenho um ambiente pronto para iniciar o desenvolvimento da aplicação.

A aplicação será criada quase que da mesma forma que uma aplicação em rails 3, onde informarei o nome da aplicação, qual o banco de dados ela usará e um parâmetro adicional que define o template para criar a aplicação (repare que esse template serve para definir a base da aplicação como JRuby já baseado na versão 3 do framework Rails).

rails new contacts -d mysql -m http://jruby.org/rails3.rb

Com o comando executado com sucesso, o passo seguinte é definir as gems que a aplicação precisa para ser executada, a definição das gem é feita no arquivo Gemfile.

cd contacts
vi Gemfile

O conteúdo do arquivo Gemfile já com as gems necessárias para a aplicação é o seguinte:

source 'http://rubygems.org'

gem 'rails', '3.0.0'

# Bundle edge Rails instead:
# gem 'rails', :git => 'git://github.com/rails/rails.git'

if defined?(JRUBY_VERSION)
  gem 'activerecord-jdbc-adapter'
  gem 'activerecord-jdbcmysql-adapter'
  gem 'jdbc-mysql'
  gem 'jruby-openssl'
  gem 'trinidad'
else
  gem 'mysql2'
end

# Use unicorn as the web server
# gem 'unicorn'

# Deploy with Capistrano
# gem 'capistrano'

# To use debugger
# gem 'ruby-debug'

# Bundle the extra gems:
# gem 'bj'
# gem 'nokogiri'
# gem 'sqlite3-ruby', :require => 'sqlite3'
# gem 'aws-s3', :require => 'aws/s3'

# Bundle gems for the local environment. Make sure to
# put test-only gems in this group so their generators
# and rake tasks are available in development mode:
# group :development, :test do
#   gem 'webrat'
# end

A gem Trinidad serve para rodar a aplicação em uma versão embedded do Apache Tomcat, existe também a possibilidade de usar a gem Warbler que serve para empacotar a aplicação em um arquivo WAR para que posteriormente o deploy seja feito em um web container ou application server java. As outras gem são necessárias para conexão JDBC com o MySQL.

Repare também que o arquivo Gemfile utiliza a variável de ambiente JRUBY_VERSION mas essa variável não é definida pelo RVM, então para que esse arquivo funcione de forma correta é necessário definí-la.

O RVM configura uma variável de ambiente chamada RUBY_VERSION, com isso fica fácil definir a variável que preciso conforme o comando a seguir:

JRUBY_VERSION=$RUBY_VERSION

Ok, as gems foram definidas na aplicação mas ainda não foram instaladas. Esta tarefa é feita pelo Bundler utilizando o comando:

bundle install

O arquivo config/database.yml contém a configuração com o bando de dados MySQL, e por padrão é definido o usuario root e uma senha vazia. Caso você tenha um usuário ou senha diferente é precisa editar esse arquivo.

Embora o uso de scaffold não seja recomendado, irei utilizá-lo para encurtar o post.
O passo seguinte é criar o banco de dados, criar um scaffold para contact e gerar a tabela no MySQL conforme comandos abaixo:

rake db:create
rails g scaffold contact name:string email:string birthdate:date bio:text
rake db:migrate

Pronto!
A aplicação já pode ser executada e para isso vou usar a gem Trinidad e subir um Tomcat já com a aplicação inclusa.

trinidad

Para acessar a aplicação basta abrir a url http://localhost:3000/contacts no browser.

Com isso finalizo esse post que demonstra como utilizar JRuby com Rails 3.

Sim é verdade, faz tempo que não escrevo nada para o blog. Infelizmente tenho andado bem ocupado com estudos, trabalho e família, mas hoje trago nesse post uma boa notícia.

Hoje a revista Java Magazine publicou a versão digital da edição 79 e muito em breve deverá publicar também a sua versão impressa.

Estou escrevendo este post no meu blog sobre esta revista e principalmente sobre esta edição, porque ela contém meu primeiro artigo para esta revista.

O artigo aborda de uma forma teórica e prática o uso do Spring Roo que é classificado como uma ferramenta para desenvolvimento ágil de aplições web utilizando a linguagem Java.

Infelizmente não vou colocar todo o conteúdo do artigo aqui , então por favor, leiam a revista para conferir o artigo completo e depois me mandem suas opiniões, críticas e sugestões para que os próximos artigos sejam melhores.

Para ver o site da revista, clique na imagem da capa da revista e para ver a revista no formato digital, clique no link a seguir:

Clique aqui para acessar a revista online

Veja abaixo um resumo do que você vai encontrar no artigo:

Neste artigo você vai entender o que é o Spring Roo, sua arquitetura, como ele funciona para proporcionar mais agilidade no desenvolvimento, suas principais características e funcionalidades, e como utilizá-lo para desenvolver aplicativos de forma mais rápida e sem perder qualidade.

O exemplo prático desse artigo, embora simples, utilizará frameworks como Spring IOC/DI e MVC, Hibernate, Tiles e Bean Validation, envolverá também testes de integração baseados em JUnit, internacionalização, rotinas em AspectJ e controle de dependências via Maven.

Vale ressaltar que a utilização da maioria destes frameworks/ferramentas acontecerá de forma transparente para o desenvolvedor, e não se espante ao ver que o exemplo será gerado com a execução de aproximadamente 15 linhas.

Esta nova versão já oferece suporte ao novo iPad mas para isto é preciso ter instalado o SDK 3.2 beta que possui o simulador para iPad.

Aqui você pode ver o post original sobre a nova versão:

http://www.cocos2d-iphone.org/archives/598

E aqui você pode ver tudo que mudou nessa nova versão:

http://www.cocos2d-iphone.org/wiki/doku.php/release_notes:0_99_0

Nesta primeira parte do artigo irei falar um pouco sobre o framework cocos2d e como utilizá-lo no XCode. Na segunda parte do artigo tentarei mostrar em um pequeno exemplo como explorar este framework para criar jogos em 2D para o iPhone SDK.

O cocos2d é um framework open source para desenvolvimento de jogos 2d baseado no OpenGL ES 1.1 e ele suporta gerenciamento de cenas, transição entre cenas, sprites, actions (comportamentos), menus e botões, renderização de textura, suporta a sons e muitas outras opções.

O primeiro passo é ter o XCode instalado no seu mac, para este tutorial estou utilizando a versao 3.2.1.

Continuando, seguirei para o site do cocos2d e farei o download da versão 0.8.2 do framework. Apos o arquivo ser baixado vamos instalá-lo para utilizarmos ele dentro do XCode.

Começarei descompactando o arquivo, depois abra o Terminal.app e va ao diretório do framework descompactado, lá tera um arquivo chamado install_template.sh e este deve ser executado para instalar os templates do cocos2d no XCode. Então ainda no Terminal e na pasta citada anteriormente execute o arquivo da seguinte forma:

./install_template.sh

Pronto, com isso o cocos2d já pode ser utilizado dentro do XCode. Abra o XCode e veja que agora existem templates disponíveis para criar aplicativos para iPhone SDK utilizando cocos2d.

Agora crie uma cocos2d Application, esse template irá criar uma pequena aplicação de demonstração (hello world) do framework. Basta executá-la no simulador e ver o resultado.

No próximo artigo iremos explorar alguns recursos do cocos2d e criar uma aplicação de exemplo.
Até o próximo artigo!

Blog em português: http://feeds.feedburner.com/RodrigoLazotiBlog

Blog em inglês: http://feeds.feedburner.com/RodrigoLazotiBlog2

Fiz algumas mudanças no meu blog e agora ele está dividido em três partes, sendo um com o blog em português, uma outra com o blog em inglês e uma para meus aplicativos para iphone/ipod touch disponíveis na apple app store.

As urls ficaram assim:

http://www.rodrigolazoti.com.br/pt/
http://www.rodrigolazoti.com.br/en/
http://www.rodrigolazoti.com.br/iphone/

Também criei um página inicial para que o usuário possa escolher entre uma das três possibilidades. Esta página pode ser vista em:

http://www.rodrigolazoti.com.br/

Agradeço a compreensão de todos e que venha 2010.

Glassfish v3
Eclipse Galileo JEE Edition

Depois de instalá-los, vou criar um Dynamic Web Project no Eclipse chamado de FirstProjectJEE6:

Agora vou substituir o conteúdo do arquivo web.xml por este abaixo:

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
	version="3.0">
	<welcome-file-list>
		<welcome-file>index.html</welcome-file>
		<welcome-file>index.htm</welcome-file>
		<welcome-file>index.jsp</welcome-file>
	</welcome-file-list>
</web-app>

Para compilar nosso projeto, precisamos adicionar um jar externo chamado javaee.jar ao projeto (Build Path), o arquivo jar pode ser encontrado em [glassfish_directory]/glassfish/lib/javaee.jar

Criei também um script ant para fazer o deploy da nossa aplicação diretamente no glassfish. Este script deve ser salvo na raiz do projeto, salvei ele com o nome de build.xml. A seguir segue seu conteúdo:

<?xml version="1.0" encoding="UTF-8"?>
<project name="FirstProject JavaEE 6" basedir="." default="deploy">
	<property name="warfile" value="FirstProject" />
	<target name="create">
		<war destfile="${warfile}.war" webxml="WebContent/WEB-INF/web.xml" update="true">
			<classes dir="build/classes" />
			<fileset dir="WebContent">
				<exclude name="WEB-INF/web.xml" />
			</fileset>
		</war>
	</target>
	<target name="copy">
		<copy todir="/Users/rodrigolazoti/Programs/glassfishv3/glassfish/domains/domain1/autodeploy" overwrite="true">
			<fileset dir=".">
				<include name="*.war" />
			</fileset>
		</copy>
	</target>
	<target name="deploy">
		<antcall target="create" />
		<antcall target="copy" />
	</target>
</project>

Note que esse local:
/Users/rodrigolazoti/Programs/glassfishv3/glassfish/domains/domain1/autodeploy
Deve ser substituído por:
[your glassfish]/glassfish/domains/domain1/autodeploy

Agora, vamos codificar um pouco, primeiro vamos criar dois EJB’s usando um pouco da nova especificação.
Vou criar um EJB Stateless e um EJB Staleful, o stateful servirá apenas para representar o número de requisições feitas e o stateless servirá para retornar alguma mensagem para o usuário.

Esse é o código do EJB Stateless:

package br.com.rodrigolazoti.firstproject.service;

import javax.ejb.Stateless;

@Stateless
public class MyStatelessSessionBean {

	public String createMessage( String username ) {
		String message = "Hello World, ";

		if ( username != null && !"".equals( username.trim() ) ) {
			message += username + "!";
		}
		else {
			message += "stranger!";
		}

		return message;
	}

}

E este é o código do EJB Stateful:

package br.com.rodrigolazoti.firstproject.service;

import javax.ejb.Stateful;

@Stateful
public class MyStatefulSessionBean {

	private int amountOfrequests = 0;

	public int getAmountOfrequests() {
		return ++amountOfrequests;
	}

}

Note que em ambos EJB’s, não foi necessário criar interfaces locais ou remotas.

Com nossos EJB’s prontos, vamos criar um servlet para responder ao seguintes métodos http GET e POST.

package br.com.rodrigolazoti.firstproject.controller;

import java.io.IOException;

import javax.ejb.EJB;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import br.com.rodrigolazoti.firstproject.service.MyStatefulSessionBean;
import br.com.rodrigolazoti.firstproject.service.MyStatelessSessionBean;

@WebServlet( name = "MyServlet", urlPatterns = { "/hello" } )
public class MyServlet extends HttpServlet {

	private static final long serialVersionUID = -2206981309178199835L;

	@EJB
	private MyStatefulSessionBean myStatefulSessionBean;

	@EJB
	private MyStatelessSessionBean myStatelessSessionBean;

	@Override
	protected void doGet( HttpServletRequest request, HttpServletResponse response )
			throws ServletException, IOException {
		String message = myStatelessSessionBean.createMessage( null );
		request.setAttribute( "message", message );

		int amountOfRequests = myStatefulSessionBean.getAmountOfrequests();
		request.setAttribute( "amountOfRequests", amountOfRequests );

		request.getRequestDispatcher( "/hello.jsp" ).forward( request, response );
	}

	@Override
	protected void doPost( HttpServletRequest request, HttpServletResponse response )
			throws ServletException, IOException {
		String username = request.getParameter( "username" );
		String message = myStatelessSessionBean.createMessage( username );
		request.setAttribute( "message", message );

		int amountOfRequests = myStatefulSessionBean.getAmountOfrequests();
		request.setAttribute( "amountOfRequests", amountOfRequests );

		request.getRequestDispatcher( "/hello.jsp" ).forward( request, response );
	}

}

E finalmente, vamos criar os arquivos jsp. O arquivo index.jsp servirá pra fazer as chamados ao servlet e o arquivo hello.jsp irá mostrar o resultado do servlet.

Conteúdo do arquivo index.jsp:

<?xml version="1.0" encoding="ISO-8859-1" ?>
<%@ page language="java" contentType="text/html; charset=ISO-8859-1" pageEncoding="ISO-8859-1"%>
<!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">
<head>
  <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
  <meta name="author" content="Rodrigo Lazoti"/>
  <title>First Java EE 6 Example</title>
</head>
<body>
  <p><a href="hello">Execute Servlet (GET)</a></p>

  <hr width="100%" noshade="noshade"/>

  <form action="hello" method="post">
    <p>Name:<input type="text" name="username"/></p>
    <p><button type="submit">Execute Servlet (POST)</button></p>
  </form>
</body>
</html>

E o conteúdo do arquivo hello.jsp:

<?xml version="1.0" encoding="ISO-8859-1" ?>
<%@ page language="java" contentType="text/html; charset=ISO-8859-1" pageEncoding="ISO-8859-1"%>
<!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">
<head>
  <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
  <meta name="author" content="Rodrigo Lazoti"/>
  <title>First Java EE 6 Example</title>
</head>
<body>
  <h2>Result: ${requestScope.message}</h2><br/>
  <h3>This servlet was executed ${requestScope.amountOfRequests} time(s).</h3><br/>
  <hr width="100%" noshade="noshade"/>
  <h4><a href="index.jsp">Back to main page</a></h4>
</body>
</html>

Pronto, nosso exemplo já esta pronto e pode ser testado. Com vimos algumas novidades como:

• Interface local e remota são opcionais no EJB 3.1.
• No EJB 3.1, vôce pode empacotar seus EJB’s em arquivos WAR junto com componentes da camada web. Você não precisa ter sua classes EJB definidas em um arquivo ejb-jar.
• Agora as annotations podem ser usadas em mais tipos de componentes Java EE e o conjunto de anotações usados para injeção de dependência foi padronizada.
• Ao invés de criar deployment descriptors, você pode anotar as classes para especificar que ela é um servlet.

Este exemplo criado está disponível no github: http://github.com/rlazoti/tutorial-javaee6-first-project

Glassfish v3
Eclipse Galileo JEE Edition

After install them, we go create a dynamic web project in the Eclipse called FirstProjectJEE6:

Now, I’ll replace the contents of the web.xml file for this:

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
	version="3.0">
	<welcome-file-list>
		<welcome-file>index.html</welcome-file>
		<welcome-file>index.htm</welcome-file>
		<welcome-file>index.jsp</welcome-file>
	</welcome-file-list>
</web-app>

To compile our project, we need to add a external jar (javaee.jar) to the project, the jar file is in the path [glassfish_directory]/glassfish/lib/javaee.jar

I’ll create a ant script to make the deploy of our application in glassfish. It must be saved in the project root and should be called build.xml

<?xml version="1.0" encoding="UTF-8"?>
<project name="FirstProject JavaEE 6" basedir="." default="deploy">
	<property name="warfile" value="FirstProject" />
	<target name="create">
		<war destfile="${warfile}.war" webxml="WebContent/WEB-INF/web.xml" update="true">
			<classes dir="build/classes" />
			<fileset dir="WebContent">
				<exclude name="WEB-INF/web.xml" />
			</fileset>
		</war>
	</target>
	<target name="copy">
		<copy todir="/Users/rodrigolazoti/Programs/glassfishv3/glassfish/domains/domain1/autodeploy" overwrite="true">
			<fileset dir=".">
				<include name="*.war" />
			</fileset>
		</copy>
	</target>
	<target name="deploy">
		<antcall target="create" />
		<antcall target="copy" />
	</target>
</project>

Note that this path:
/Users/rodrigolazoti/Programs/glassfishv3/glassfish/domains/domain1/autodeploy
Should be replaced by the:
[your glassfish]/glassfish/domains/domain1/autodeploy

Now, we let’s code a little, first we let’s create two EJB using the new specification.
I’ll create one stateless and one staleful EJB, the stateful ejb will serve only to represent the number of requests and the stateless will serve to return a message to the User.

The code of stateless ejb:

package br.com.rodrigolazoti.firstproject.service;

import javax.ejb.Stateless;

@Stateless
public class MyStatelessSessionBean {

	public String createMessage( String username ) {
		String message = "Hello World, ";

		if ( username != null && !"".equals( username.trim() ) ) {
			message += username + "!";
		}
		else {
			message += "stranger!";
		}

		return message;
	}

}

And the code of the stateful ejb:

package br.com.rodrigolazoti.firstproject.service;

import javax.ejb.Stateful;

@Stateful
public class MyStatefulSessionBean {

	private int amountOfrequests = 0;

	public int getAmountOfrequests() {
		return ++amountOfrequests;
	}

}

Note that in both ejb, was not necessary to create a local or remote interface.

With our EJBs ready, we’ll create a servlet to respond to http methods: GET and POST.

package br.com.rodrigolazoti.firstproject.controller;

import java.io.IOException;

import javax.ejb.EJB;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import br.com.rodrigolazoti.firstproject.service.MyStatefulSessionBean;
import br.com.rodrigolazoti.firstproject.service.MyStatelessSessionBean;

@WebServlet( name = "MyServlet", urlPatterns = { "/hello" } )
public class MyServlet extends HttpServlet {

	private static final long serialVersionUID = -2206981309178199835L;

	@EJB
	private MyStatefulSessionBean myStatefulSessionBean;

	@EJB
	private MyStatelessSessionBean myStatelessSessionBean;

	@Override
	protected void doGet( HttpServletRequest request, HttpServletResponse response )
			throws ServletException, IOException {
		String message = myStatelessSessionBean.createMessage( null );
		request.setAttribute( "message", message );

		int amountOfRequests = myStatefulSessionBean.getAmountOfrequests();
		request.setAttribute( "amountOfRequests", amountOfRequests );

		request.getRequestDispatcher( "/hello.jsp" ).forward( request, response );
	}

	@Override
	protected void doPost( HttpServletRequest request, HttpServletResponse response )
			throws ServletException, IOException {
		String username = request.getParameter( "username" );
		String message = myStatelessSessionBean.createMessage( username );
		request.setAttribute( "message", message );

		int amountOfRequests = myStatefulSessionBean.getAmountOfrequests();
		request.setAttribute( "amountOfRequests", amountOfRequests );

		request.getRequestDispatcher( "/hello.jsp" ).forward( request, response );
	}

}

And finally, we’ll create our jsp files. The index.jsp file will make the calls to the servlet and the hello.jsp file will show the result of calls.

The index.jsp file:

<?xml version="1.0" encoding="ISO-8859-1" ?>
<%@ page language="java" contentType="text/html; charset=ISO-8859-1" pageEncoding="ISO-8859-1"%>
<!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">
<head>
  <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
  <meta name="author" content="Rodrigo Lazoti"/>
  <title>First Java EE 6 Example</title>
</head>
<body>
  <p><a href="hello">Execute Servlet (GET)</a></p>

  <hr width="100%" noshade="noshade"/>

  <form action="hello" method="post">
    <p>Name:<input type="text" name="username"/></p>
    <p><button type="submit">Execute Servlet (POST)</button></p>
  </form>
</body>
</html>

And the hello.jsp file:

<?xml version="1.0" encoding="ISO-8859-1" ?>
<%@ page language="java" contentType="text/html; charset=ISO-8859-1" pageEncoding="ISO-8859-1"%>
<!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">
<head>
  <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
  <meta name="author" content="Rodrigo Lazoti"/>
  <title>First Java EE 6 Example</title>
</head>
<body>
  <h2>Result: ${requestScope.message}</h2><br/>
  <h3>This servlet was executed ${requestScope.amountOfRequests} time(s).</h3><br/>
  <hr width="100%" noshade="noshade"/>
  <h4><a href="index.jsp">Back to main page</a></h4>
</body>
</html>

Some news that I used this example:

• Local business interfaces are optional in EJB 3.1.
• In EJB 3.1, you can place enterprise bean classes in the .war file along with web tier components. You don’t have to put EJB classes in the ejb-jar file.
• Annotations can now be used in more types of Java EE components. And the set of annotations used for dependency injection has been standardized.
• Instead of creating deployment descriptors, you can annotate classes to specify servlet-related deployment information.

This example is available at github: http://github.com/rlazoti/tutorial-javaee6-first-project