JavaOne 2008 - Apresentações disponíveis no site

sexta-feira, 30 de maio de 2008



A Sun disponibilizou ontem (29/05/2008) todas as apresentações das Technical Sessions no seu site, até o presente momento ainda não foram disponibilizados as apresentações em multimídia, mas com certeza em breve já deve estar aparecendo, essa é uma ótima oportunidade para quem não esteve no evento, como eu por exemplo, de ver o que aconteceu na maior festa de Java do Mundo...

Parabéns para os meus amigos Mauricio "Maltron" Leal e Vinicius Senger que apresentaram a TS-6258 , ensinando dicas e truques para interfaces 3D para aparelhos celular e M3G !!!

O link é o http://developers.sun.com/learning/javaoneonline/


Diversão Garantida !!!

NetBeans Platform na Mundo Java nº 29

sábado, 17 de maio de 2008


Este mês saiu nas bancas a revista Mundo Java nº29, um artigo meu sobre a plataforma NetBeans, expliquei as principais classes e funcionalidades, e no final apresentei um tutorial prático de como extender o NetBeans e criar poderosos plugins..
Ainda nesta edição na seção "Eu uso" teve a participação mais que especial do Tim Boudreau, um dos engenheiros e pioneiro na criação das primeiras versões do IDE e do nosso querido Bruno Souza o JavaMan..
Eu mesmo traduzi o artigo do Tim, espero que quem leu tenha gostado.
Com a autorização do Tim, vou publicar o artigo dele na seção "Eu uso", claro, em inglês !!!

I work on the NetBeans Platform. Probably the most gratifying thing about that work is to see how it is used - anybody who creates software wants to see it used - it is what gives our work meaning. In the simplest view, what the NetBeans Platform does is solve problems. I believe in writing software that can be finished. That is, you write something that is solid and right and works and then you can leave it alone and move on to the next problem. The modular nature of NetBeans - indeed, the module system itself - makes it easier to build software out of a lot of libraries each of which does one thing well - and guarantee system integrity at runtime. It solves the DLL hell problem for once and for all, and in the process creates design patterns that are ideal for distributed development - how do you build software created by a large community and minimize the risks that changes to one part of the system will break another? The core beauty of NetBeans is the module system.

But what amazes me more is what people do on top of it. Let's take one case-in-point: Nokia. If you are a mobile service provider, such as Tim in Brazil (no relation :-)), and you buy your hardware from Nokia (your transmitters, the things that make a mobile phone network work), you will need some software to manage that network. If you are buying that hardware from Nokia, you get an application for managing your network. But it's not just one applications - it is many applications and one at the same time. They have used the NetBeans Platform plus Java WebStart technology together in an incredibly innovative way - and because Nokia contributed WebStart support to NetBeans, you can do the same thing for your applications.

Java WebStart is a technology that lets you launch a Java desktop application by clicking a URL. Anybody who has installed Sun's Java has Java WebStart. It's not wildly popular yet, but it is an incredible technology for improving the experience people have with internet-based applications. Why? Because there is only one copy of the software. I once visited a company - actually a software development organization for a state in the U.S. They asked us: "Can you please release new versions less often? Every time you have a new version, some guy has to walk around with a CD-ROM and visit 350 workstations and install it!"

That's crazy, and Java WebStart offers the solution. You click a URL and a desktop application starts - all the benefits of centralized management that you get from web applications, but it's a real desktop application. And when you download a new version, you don't download all the bits - only a diff between what was and what is. It's a darned cool technology.

Now put that together with a modular system like NetBeans, where an application discovers its parts during startup.

With Nokia's NetBeans-based software, it works like this: Imagine you work for a telecom in the mobile phone space. There are a lot of different jobs you might be doing: Some people monitor the network for problems. Some people dispatch physical repair trucks to go fix things. So, if you are using this software, well, you start it by clicking a link on the web. And to even see the link, you had to log in, so the system knows who you are and what you need.

So what happens? You click the link. The server knows who you are and what your job is. The result is that you start up one application - but it is an application with many faces. The server gives you an application which contains those modules you need to do your job - it will be a different set of modules depending on what you do and what you need access to.

Now think about what this does for the people who write this software! In a modular system, you usually do UI in one module and back-end logic in another. The result of all this is that the users have a better experience - they get a UI tailored for their job; and the developers get a better experience: 1. They can write back end logic once and share it for all possible cases, and 2. They don't have to write multiple applications that do variations on the same thing, and that saves a lot of time.

Anybody who is doing a large-scale desktop application should consider the NetBeans Platform; anybody who is considering a suite of related programs that share some logic and diverge in UI would be insane not to consider using it.

I am, of course, biased - I have worked on the NetBeans Platform. The criteria for people who could benefit from it are clear and hard to argue with:
- Anybody doing a multi-window desktop application
- Anybody writing a desktop application that needs to save state on shutdown
- Anybody writing an application with a concept of selection that determines action enablement or similar
- Particularly anybody writing several related applications that share some logic

We've worked very hard to make it easy to try the NetBeans Platform for your application. If you fit, even remotely, into any of the categories above, you could save time, money and effort with it - give it a look.

-Tim Boudreau, 16/12/07

Um agradecimento especial para o Bruno Souza por ter aceitado o convite, para o Tim Boudreau, para o Guapo e o Eduardo Guerra da Mundo Java que vem lutando para manter esta revista com um alto padrão, e claro para você leitor !!!

Se você se interessa por aplicações desktop e tem interesse em saber como funciona a arquitetura por trás do IDE NetBeans, compre essa revista, além deste artigo você vai encontrar nesta edição os seguintes temas..

  • Desenvolvendo aplicações desktop ricas na Plataforma NetBeans.
  • Animações 2D em JavaFX na prática.
  • Binding, Componentes, Customizados e Template de Telas no SwingBeans 1.2.
  • Click Framework.
  • Acesso a Serviços Multimídia em Java ME com SIP-API e IMS.
  • Tendências em foco: Java e o Mundo Web.
  • RSS dinâmico, rápido e fácil com ROME e STRUTS 2
  • Escolhendo uma ferramenta Case Gratuita para modelagem UML.
  • Modelando Transações de Facade a AspectJ.
  • De olho no mercado: Educação continuada de um Desenvolvedor
  • Mundo OO: O Ciclo Ágil de um Dia
E mais , você leva de graça um Poster Mundo Java: Resumão SCJP- Parte III

Diversão Garantida !!!

Sai resultado da competição de Blog do NetBeans

quarta-feira, 14 de maio de 2008


A lista do vencedores saiu no dia 12 deste mês, foram aproximadamente 300 blogs de vários países competindo entre si, e para a minha felicidade acabei sendo um dos ganhadores, na verdade o único do Brazil, ou pelo menos o único que blogou em português, agora é só ver o que posso fazer com os U$500,00 dólares em vale presente e ir para o abraço.

Países que participaram

Australia, Canada, China, Denmark, France, Germany, India, Indonesia, Israel, Italy, Japan, Korea, Mexico, Poland, Russia, Spain, Sweden, Switzerland, Thailand, the United Kingdom, Taiwan, Argentina, Finland, Norway, Malaysia, South Africa, Bulgaria, Hungary, Chile, Turkey, Sri Lanka, Peru, Romania, Austria, New Zealand, Egypt, Panama, Brazil and the United States.

Segue a lista dos vencedores:

Winners of $500 American Express Gift Certificates

Name Language Blog Entry
Matthew Nuzum
English Netbeans 6.1 spanks Eclipse and challenges Visual Studio
Patrick Julien
English NetBeans 6.1: The Best just got Better
Ding Liang
Chinese About NetBeans
Diego Silva
Spanish JavaScript en NetBeans 6.1
Wagner Roberto dos Santos
Portuguese O que podemos esperar do NetBeans 6.1 ?
Pat Coleman English Can NetBeans create a code-less P2P app?
James Eliyezar
English Subversion and NetBeans - A quick start guide
Junji Takakura Japanese NetBeans 6.1 RC to use PHP
Jacek Laskowski
Polish NetBeans IDE 6.1 - Spring Framework Support
Joshua van Aalst English NetBeans 6.1 A Delight To Use

Um agradecimento especial para a equipe de tradução, ao SOUJava, a Janice Campbell e a você leitor do blog.


A lista completa dos competidores você acha aqui http://www.netbeans.org/competition/blog-contest-posts.html

[EJB 3.1] Novidades na especificação - Parte 2

sexta-feira, 2 de maio de 2008

Continuando o artigo sobre as novidades na Especificação EJB 3.1, nesta segunda parte vamos abordar o invoções assíncronas e EJB sem interface.

Na nova especificação um cliente pode invocar um session bean de maneira síncrona ou assíncrona. Invocações assíncronas que é a novidade nos permite efetuar uma chamada a um método remoto (assíncrono) e não precisamos esperar o seu retorno, neste caso a assinatura do método deve ser void, ou o método pode retornar um objeto Future que retorna o resultado para o cliente após o processamento, o que permite verificar as exceções ou até mesmo cancelar a invocação ao método no meio da execução.


Exemplo:

@Asynchronous
public Future executarMetodo() {
String resultado = "Executando Método";
return new AsyncResult(resultado);
}

Outra novidade é o que todos já esperavam "O Fim das Interfaces", ou pelo menos agora elas são opcionais. Antes que alguém se empolgue é bom deixar claro que isso só funciona para objetos LOCAIS, ou seja, o cliente que irá chamar o método deve estar na mesma JVM. :-(Na verdade um session bean sem interface é uma variação do EJB local, mas expõe os métodos públicos da classe bean sem utilizar uma interface de negócio separada.
A referência para o Bean sem interface pode ser passada como um parâmetro, como valor de retorno de qualquer interface de negócio local ou como método de uma classe ejb sem interface.
A implementação do contêiner para Beans sem interface é o mesmo que nós fazemos quando acessamos um método qualquer de uma classe qualquer pela referência, o método de negócio da instancia do session bean e seus interceptors são invocados conforme a necessidade.
Somente os métodos públicos da classe bean (e qualquer super-classe) pode ser invocado através do Bean sem interface. Qualquer tentativa de invocação a métodos com modificadores de acessos diferente de público, irá lançar um javax.ejb.EJBException.
Vejamos a evolução da especificação EJB, dando o mesmo exemplo nas versões 2.1, 3.0 e finalmente 3.1.

Versão 2.*

Até a versão 2.* a comunidade reclamava muito da complexidade dos EJBs, para a criação de um método simples era preciso criar as interfaces (remota e local), a interface home e finalmente a classe de negócio...

Interface Local

import javax.ejb.EJBLocalObject;

public interface SayHelloRemote extends EJBLocalObject{
public void hello();
}

Interface Home

import javax.ejb.CreateException;
import javax.ejb.EJBLocalHome;

public interface SayHelloHome extends EJBLocalHome {
SayHello create() throws CreateException;
}

Session Bean

import javax.ejb.SessionBean;
import javax.ejb.SessionContext;

public class SayHelloBean implements SessionBean {
public void sayHello() {
System.out.println("Hello");
}

public SayHelloBean() {}
public void ejbCreate() {}
public void ejbRemove() {}
public void ejbActivate() {}
public void ejbPassivate() {}
public void setSessionContext(SessionContext sc) {}
}


Cliente Session Bean 2.1

import javax.naming.Context;
import javax.naming.InitialContext;
import javax.rmi.PortableRemoteObject;

public class SayHelloClient {

public static void main(String[] args) {
try {
Context initial = new InitialContext();
Context myEnv = (Context)initial.lookup("java:comp/env");
Object objref = myEnv.lookup("ejb/SayHello");
SayHelloHome home = (SayHelloHome) PortableRemoteObject.narrow(objref,
SayHelloHome.class);
SayHello papagaio = home.create();
papagaio.sayHello();
papagaio.remove();
System.exit(0);
} catch (Exception ex) {
ex.printStackTrace();
}
}
}
Versão 3.0

Vemos que até a versão 2.1 era muito trabalho criar um simples Hello World com EJB, a Sun vendo que o EJB estava perdendo espaço para frameworks comunitários, como Hibernate para persistência e outras alternativas para Session Beans, decidiu fazer uma mudança radical na especificação, descontinuando os Entity Beans e apresentando o JPA, e tirando a obrigatoriedade de criar a classe Home, eliminando a criação de deployment descriptors, usando e abusando da IoC com o uso extensivo de annotations. A especificação facilitou muito o desenvolvimento e a especificação EJB voltou a ser o supra sumo do Java, vejamos um exemplo

Interface de Negócio Local

import javax.ejb.Local;

@Local
public interface SayHelloLocal {
void hello();
}

Session Bean

import javax.ejb.Stateless;

@Stateless
public class SayHelloBean implements SayHelloRemote, SayHelloLocal{
public void hello() {
System.out.println("Hello");
}
}

Cliente que executa o EJB

public class SayHelloClient {
private static Properties prop = new Properties();
private static Context c;
public SayHelloClient(){
prop.put("java.naming.factory.initial", "org.jnp.interfaces.NamingContextFactory");
prop.put("java.naming.factory.url.pkgs", "org.jboss.naming:org.jnp.interfaces");
prop.put("java.naming.provider.url","localhost");
}
public static void main(String[] args) {
SayHelloClient main = new SayHelloClient();
SayHelloRemote remote = main.lookupSayHelloBean();
remote.sayHello();
}
private SayHelloRemote lookupSayHelloBean() {
try {
c = new InitialContext(prop);
return (SayHelloRemote) c.lookup("SayHelloBean/remote");
} catch (NamingException ne) {
throw new RuntimeException(ne);
}
}
}

Versão 3.1 Draft

Com a eliminação da classe home não precisamos mais fazer o narrow no código cliente. Agora basta efetuar um lookup na classe Bean.

Classe de implementação de negócio
// Sem Interfaces Remota ou Local
import javax.ejb.Stateless;

@Stateless
public class SayHelloBean implements SayHelloRemote, SayHelloLocal{
public void hello() {
System.out.println("Hello");
}
}

Cliente que executa o EJB

public class SayHelloClient {
// Se o cliente estiver no conteiner, Injeção nele !!!
// Veja que estamos referenciando ao session bean
// SayHelloBean e não SayHelloRemote.

@EJB SayHelloBean falaAi;
@Resource SessionContext c;
public SayHelloClient(){}
public static void main(String[] args) {
falaAi.hello();
SayHelloClient main = new SayHelloClient();
SayHelloBean sayAgain = main.lookupSayHelloBean();
sayAgain.hello();
}

// Ou podemos fazer via JNDI
private SayHelloRemote lookupSayHelloBean() {
try {
return (SayHelloBean) c.lookup("sayHello");
} catch (NamingException ne) {
throw new RuntimeException(ne);
}
}
}

Podemos observar que esta muito mais simples criar EJBs, sem as interfaces o código fica muito mais limpo e temos uma programação muito próximo de objetos POJO, entretanto, por motivos já conhecidos não é possível instanciar um objeto com o operador new, somente via injeção ou jndi. Para a especificação 2.1 por exemplo, tínhamos que criar 4 objetos para um simples hello world (local), na especificação 3.0 não é obrigatório implementar a interface SessionBean na classe session bean ou a interface Serializable, assim como as classes Interceptors. Viva a injeção de dependência !!!
Veja que ainda precisamos de 3 objetos (sai a interface home) mas o processo já simplifica com a entrada das annotations. Agora na versão 3.1 foi eliminada a necessidade de interfaces (lembre-se, apenas para objetos locais)..
Para criar um EJB sem utilizar a interface, ela deve seguir algumas seguintes regras, ela deve expor os métodos sem interface via definição de classe ou pelo deployment descriptor. E ... :
  • Se o bean não expor nenhuma outra interface(s) e não implementar nenhuma interface, então o bean define uma EJB sem interface.
  • As seguintes interfaces são excluídas quando implementamos um EJB sem interface : java.io.Serializable, java.io.Externalizable; E qualquer outra interface definida no pacote javax.ejb.
  • Todos os métodos da classe bean e qualquer superclasse são expostos como métodos de negócios através de um bean sem interface. E isto inclui os métodos de callback (muito cuidado !!!).
  • Os métodos expostos da classe bean sem interface não devem lançar a exceção java.rmi.RemoteException.

Ainda tem várias coisas legais para discutir, provavelmente será possível rodar EJB no TomCat :D, com o pacote light do EJB, no próximo post vou cobrir o calendário para o Timer e concorrência !!!