[INFO] Unable to find resource 'com.oracle:ojdbc14:jar:10.2.0.3.0' in repository central
(http://repo1.maven.org/maven2)

[INFO] ------------------------------------------------------------------------
[ERROR] BUILD ERROR
[INFO] ------------------------------------------------------------------------
[INFO] Failed to resolve artifact.

Missing:
----------
1) com.oracle:ojdbc14:jar:10.2.0.3.0

 Try downloading the file manually from the project website.

 Then, install it using the command:
 mvn install:install-file -DgroupId=com.oracle -DartifactId=ojdbc14
-Dversion=10.2.0.3.0 -Dpackaging=jar -Dfile=/path/to/file

 Alternatively, if you host your own repository you can deploy the file there:
 mvn deploy:deploy-file -DgroupId=com.oracle -DartifactId=ojdbc14
-Dversion=10.2.0.3.0 -Dpackaging=jar -Dfile=/path/to/file -
Durl=[url] -DrepositoryId=[id]

 Path to dependency:
 1) br.com.ninecon.core:isupport:war:0.0.1-SNAPSHOT
 2) com.oracle:ojdbc14:jar:10.2.0.3.0

É possível configurar o repositório do Maven, utilizando a biblioteca localmente, ou seja, se você já tem o arquivo .jar em seu computador, pode corrigir o problema adicionando este arquivo ao repositório.

No meu caso foi simples, pois eu já tinha o banco de dados Oracle instalado localmente, mas caso você não tenha, faça o download library OJDBC.

Acesse o diretório onde esta o arquivo jar.

C:\Users\luciano>cd %ORACLE_HOME%/jdbc/lib

Execute o comando de instalação da library conforme abaixo passando os parametros necessários. No exemplo o banco utilizado é o 10.2.0.3.0.

c:\oracle\product\10.2.0\db_1\jdbc\lib>mvn install:install-file -Dfile=ojdbc14.jar -DgroupId=com.oracle -DartifactId=oracle -Dversion=10.2.0.3.0 -Dpackaging=jar -DgeneratePom=true

[INFO] Scanning for projects...
[INFO] Searching repository for plugin with prefix: 'install'.
[INFO] org.apache.maven.plugins: checking for updates from central
[INFO] org.codehaus.mojo: checking for updates from central
[INFO] ------------------------------------------------------------------------
[INFO] Building Maven Default Project
[INFO]    task-segment: [install:install-file] (aggregator-style)
[INFO] ------------------------------------------------------------------------
[INFO] [install:install-file {execution: default-cli}]
[INFO] Installing c:\oracle\product\10.2.0\db_1\jdbc\lib\ojdbc14.jar to C:\Users\luciano\.m2\repository\com\oracle\oracle\10.2.0.3
.0\oracle-10.2.0.3.0.jar
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESSFUL
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 3 seconds
[INFO] Finished at: Wed Jun 09 20:32:02 BRT 2010
[INFO] Final Memory: 3M/15M
[INFO] ------------------------------------------------------------------------
'cmd' is not recognized as an internal or external command,
operable program or batch file.
c:\oracle\product\10.2.0\db_1\jdbc\lib>

Perceba que o artifactId esta como oracle, portanto o seu pom.xml deve ser modificado também.

Com este simples comando você resolverá um problemão chato! ;)

No exemplo anterior além de obter o Customer Key e Secret, você irá precisar do Usuário e Senha do Twitter, para assim obter a comunicação devida. Bem, nem todo mundo sente-se disposto a oferecer seus dados confidênciais para um software ou site qualquer. Portanto, este novo exemplo mostrará como você deve comunicar com o Twitter deixando a autenticação por parte do micro-blog e autorização por parte do próprio usuário.

Dando sequência ao assunto, inicialmente você precisará registrar uma aplicação no Twitter caso ainda não a tenha, guarde os dados Consumer Key e Secret. Existem dois tipos de aplicações a Client (Desktop) e Browser (Web), sendo que a segunda precisará de uma url que receberá o Token de autenticação.

Infelizmente, este post foi prejudicado pela falta de um web hosting que suporte Java, a Locaweb (atual host deste blog) cobra valores mensais absurdos, que inviabiliza blogs com intuito simplesmente acadêmico, como este, de realizar testes utilizando a linguagem Java.

Consegui descobrir lendo aqui, aqui e aqui que é possível configurar o seu localhost como Callback URL no Twitter, assim não será necessário ter um site publicado na internet para seus testes.

Web Autenticação

Durante o registro você irá informar o tipo de aplicação Browser e uma Callback URL, é para onde o navegador será redirecionado após a autorização do usuário. Já o campo Application Website, é a origem da sua aplicação web, ou seja, serão aceitas as chamadas feitas apenas a partir deste site.

O código abaixo irá fazer iniciar o processo de autenticação, o navegador vai ser redirecionado para a página de login do Twitter.

 final String CALLBACK_URL     = "http://127.0.0.1:8080/BlogTwitt4u/"; // a mesma configurada na aplicação
 final String CUSTOMER_KEY     = "6MWotGxvuNVGfK4lDqAqhg";
 final String CUSTOMER_SEC     = "oRH0YviLum2Rrii25ePj0DEk6VnmNjoTG0ESUpqSY";

 OAuthConsumer consumer         = new DefaultOAuthConsumer(CUSTOMER_KEY, CUSTOMER_SEC);
 OAuthProvider provider         = new DefaultOAuthProvider( "https://twitter.com/oauth/request_token",
 "https://twitter.com/oauth/access_token",
 "https://twitter.com/oauth/authorize" );

 //
 // Solicita a autorização
 //
 String authUrl = provider.retrieveRequestToken(consumer, CALLBACK_URL);
 session.setAttribute("token",         consumer.getToken());
 session.setAttribute("tokenSecret", consumer.getTokenSecret());

 //
 //
 // Redireciona para  o Twitter solicitar o Usuário e Senha, e Autorização para a aplicação
 // Em seguida será redirecionado para a callback url
 response.sendRedirect(authUrl);

Após fazer o login e autorizar a sua aplicação, o navegador será redirecionado novamente para o seu site, com dois parâmetros preenchidos, como esta abaixo:

http://127.0.0.1:8080/BlogTwitt4u/?oauth_token=RQVPENBxDbQuI1bJ1rjELuVSyZhMYqr8Fcs5eqyZw&oauth_verifier=a8FuEeitfdCR2IfgisfsHopMAUevs4cDyRWkbZz4

Pronto, ai você já pode colher as informações que desejar, veja:

 if( oauthVerifier!=null && !oauthVerifier.trim().equals("") ){

 String token            = (String) session.getAttribute("token");
 String tokenSecret        = (String) session.getAttribute("tokenSecret");

 //
 consumer.setTokenWithSecret(token, tokenSecret);

 //
 //
 provider.setOAuth10a(true);
 provider.retrieveAccessToken(consumer, oauthVerifier);

 out.println("<h1>AUTORIZADO!</h1>");
 out.println("<pre>");
 out.println("token:\t\t" + consumer.getToken());
 out.println("tokenSecret:\t\t" + consumer.getTokenSecret());
 out.println("oauthVerifier:\t\t" + oauthVerifier);
 out.println("oauthToken:\t\t" + oauthToken);

 //
 //
 URL url                         = new URL("http://twitter.com/statuses/mentions.json");
 HttpURLConnection urlConnection = (HttpURLConnection) url.openConnection();
 consumer.sign( urlConnection );
 urlConnection.connect();

 BufferedReader in    = new BufferedReader(new InputStreamReader(urlConnection.getInputStream()) );
 String inputLine     = "";
 String content       = "";
 while ((inputLine = in.readLine()) != null){
     content += inputLine;
 }// while end
 in.close();

 int statusCode = urlConnection.getResponseCode();
 out.println("statusCode: " + statusCode);
 out.println("</pre>");

 JSONArray json = JSONArray.fromObject( content );

 out.println("<hr>");
 out.println("<h3>Mentions</h3>");
 out.println("<pre>");
 for(int i=0; i<json.size(); i++){

 JSONObject obj = (JSONObject) json.get(i);
 if( obj!=null ){
   // JSONString str = (JSONString) obj.get("text");
   out.println(obj.getString("text"));
 }

 }// for end
 out.println("</pre>");

 }

Desktop Autenticação

Este é um exemplo comum, muito conhecido em qualquer pesquisa no Google, para utiliza-lo você deve ter uma aplicação do tipo Client.

O código pede para que o usuário abra o navegador, acesse uma determinada URL e depois informe o código númerico no programa, nada eficaz né? Muitos programadores utilizam uma maneira nada elegante que é a de “hackear” esta página e pegar o código automáticamente, facilitando a vida de todo mundo. Faça isto por sua conta e risco. Perceba que quando comparado ao código de autenticação Web a única mudança é a utilização do código PIN, que não necessário informar na web.

<pre>
<pre><pre>// Lembre-se de modificar estes valores para os seus
//
final String CUSTOMER_KEY = "6MWotGxvuNVGfK4lDq";
final String CUSTOMER_SEC = "oRH0YviLum2Rrii25ePj0DEk6VnmNjoTG0ESUp";

try {
HttpURLConnection request = null;
URL url = null;
OAuthConsumer consumer = new DefaultOAuthConsumer(CUSTOMER_KEY, CUSTOMER_SEC);

OAuthProvider provider = new DefaultOAuthProvider( <a href="https://twitter.com/oauth/request_token">https://twitter.com/oauth/request_token</a>,
"https://twitter.com/oauth/access_token",
"https://twitter.com/oauth/authorize");

String authUrl = provider.retrieveRequestToken(consumer, OAuth.OUT_OF_BAND);
//
// URL Que irá retornar o PIN, necessário para formar o Token
System.out.println(authUrl);

String pinCode = JOptionPane.showInputDialog("Acesse o endereço:\n" + authUrl + "\nE Informe o PIN:");
System.out.println("PIN Code: " + pinCode);

//
provider.retrieveAccessToken(consumer, pinCode);

String tokenKey = consumer.getToken();
String tokenSec = consumer.getTokenSecret();

System.out.println("Token Key : " + tokenKey);
System.out.println("Token Sec : " + tokenSec);

consumer.setTokenWithSecret(tokenKey, tokenSec);

url  = new URL(<a href="http://twitter.com/statuses/mentions.xml">http://twitter.com/statuses/mentions.xml</a>);
 request = (HttpURLConnection) url.openConnection();
// sign the request
consumer.sign(request);

// send the request
request.connect();

// response status should be 200 OK
int statusCode = request.getResponseCode();
System.out.println("Status Code : " + statusCode);

} catch (OAuthMessageSignerException e) {
e.printStackTrace();
} catch (OAuthNotAuthorizedException e) {
e.printStackTrace();
} catch (OAuthExpectationFailedException e) {
e.printStackTrace();
} catch (OAuthCommunicationException e) {
e.printStackTrace();
} catch (MalformedURLException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}

Foram utilizadas as seguintes bibliotecas:
Apache Commons BeansUtil 1.8
Apache Commons Codec 1.4
Apache Http Client 3.1
Apache Commons Lang 2.4
ezmorph 1.0.6
json-lib 2.3

Faça download do projeto, que contêm ambos exemplos de autenticação.

Além de um database music, o LastFm é uma rede social e grande parte de suas informações são públicas e podem ser acessadas facilmente através de sua API.
Vamos dar inicio a um exemplo de como consumir os dados utilizando a library para Java lastfm-java. Antes de tudo, se você não tiver uma conta no LastFm, crie-a agora e depois obtenha a API Key. Neste mesmo link você encontrará a documentação da API, que detalha claramente a funcionalidade de cada método disponível e como é o seu acesso e se necessita ou não de autenticação.

Em nosso primeiro exemplo vamos fazer uma página web que irá listar as últimas faixas ouvidas e a lista de amigos de um usuário específico, com isto, você perceberá que nenhuma autenticação é necessária pois os dados são públicos.

Criei a classe LastFmClient, para facilitar os casts necessários e centralizar as chamadas da API.

public class LastFmClient {
// altere para a sua api key
 private static final String APIKEY = "XyZaBc001";
 private String uName = null;

/**
 *
 * @param uName
 */
 public LastFmClient(String uName){
 this.uName = uName;
 }

/**
 *
 * @return User/Friends List
 */
 public ArrayList<User> getFriends(){
 return (ArrayList<User>) User.getFriends(uName, APIKEY);
 }

 /**
 *
 * @return Tracks List
 */
 public ArrayList<Track> getTracks(){
 return (ArrayList<Track>) User.getRecentTracks(uName, APIKEY);
 }
}

Isto é o suficiente para você montar a lista como descrito acima, veja:

 String userName = request.getParameter("username");
 if( userName!=null && !userName.trim().equals("") ){
 // instancia a classe de backend
 LastFmClient client = new LastFmClient(userName);

 // seu código aqui
 }

Ouvidas recentemente.

<table border="0" cellpadding="2" cellspacing="1">
<% for(Track t : tracks){ %>
<tr>
 <td valign="top" align="left">
 <br/><strong><%=t.getAlbum() %></strong>
 <br/><em><%=t.getArtist() %></em>
 </td>
</tr>
<% }// for end tracks %>
</table>

Lista de amigos.

<table border="0" cellpadding="2" cellspacing="1">
<tr>
<%
 ArrayList<User> friends = client.getFriends();
 int count = 1;
 for(User f : friends){
%>
 <td valign="top" align="center">
 <% if( f.getImageURL()!=null ){ %><img src="<%= f.getImageURL() %>"><% } %>
 <br><strong><%=f.getName() %></strong>
 <br><a href="<%= f.getUrl() %>"><%= f.getUrl() %></a>
 <br/>
 </td>
<%
 if( count%5==0 ) out.print("</tr><tr>");
 count++;

 }// for end friends

}//
%>

Faça download do código completo.

Pronto, você conseguiu acessar dados do LastFm, usando o caminho correto e fácil, sem autenticação. Mas alguns dados são restritos e necessitam da autorização do usuário, informações básicas como a quantidade de músicas ouvidas, data de cadastro, nome, etc. são de acesso restrito.

1. Oracle

Primeiramente vamos fazer o processo para gravar um arquivo qualquer no banco de dados.
Criação da tabela que será utilizada para armazenar os arquivos.

CREATE TABLE ARQUIVOS(
ID     NUMBER(4)      NOT NULL,
TIPO   VARCHAR2(20)   NULL,
ARQ    BLOB           DEFAULT EMPTY_BLOB() NOT NULL,
CONSTRAINT PKARQ PRIMARY KEY(ID)
)

Perceba que o campo ARQ que irá guardar o binário, tem como valor default a propriedade EMPTY_BLOB() – Retorna um LOB vazio, para ser usado como um indicador para INSERT ou UPDATE.

No geral, o processo para inserir um campo LOB (BLOB ou CLOB) no Oracle é um pouco burocrático, feito em duas etapas. Primeiro deve-se inserir o registro setando o campo BLOB como EMPTY_BLOB, no em seguida finalizamos com um SELECT FOR UPDATE no campo “LOB” especifico para que o byte[] seja gravado.

// Inserindo o empty_blob
//
String sql  = "INSERT INTO arquivos(id, tipo, arq) VALUES(1, ?, EMPTY_BLOB())";
conn   = ConnOracle.getInstance().getConn();
pstmt1   = conn.prepareStatement(sql);
pstmt1.setString(1, "TEXT");
pstmt1.execute();

Este passo irá fazer com que um arquivo seja armazenado no banco.

// Faz o select como for update
// Inserir o binário
//
String ins  = "SELECT arq FROM arquivos WHERE id = 1 FOR UPDATE";
pstmt2  = conn.prepareStatement(ins);
rset  = pstmt2.executeQuery(ins);
while( rset.next() ){
Blob blob   = rset.getBlob(1);
// filePath eh a String com o caminho do arquivo a ser gravado

File file    = new File( filePath );
byte[] bbuf   = new byte[1024];
InputStream bin  = new FileInputStream( file );
// Realiza o cast especifico para o driver Oracle
OutputStream bout  = ((BLOB) blob).getBinaryOutputStream();

int bytesRead   = 0;
while( (bytesRead = bin.read(bbuf))!=-1 ){
bout.write(bbuf, 0, bytesRead);
}//

if( bout!=null ) bout.close();

}// end while
conn.commit();

2. MySQL

A estrutura da tabela muda pouco, o mais importante é que o campo para armazenar o arquivo é do tipo LONGBLOB, veja:

CREATE TABLE ARQUIVOS(
ID     INT(4)        NOT NULL,
TIPO   VARCHAR(20)   NULL,
ARQ    LONGBLOB      NOT NULL,
PRIMARY KEY(ID)
);

Gravar um campo LONGBLOB no MySQL, é tão fácil quando gravar um int ou uma String, e eu não estou falando no sentido figurado.

   File file    = new File( filePath );
byte[] bytes  = getBytesFromFile( file );</pre>
// Inserindo o longblob
//
String sql  = "INSERT INTO arquivos(id, tipo, arq) VALUES(1, ?, ?)";
conn   = ConnMysql.getInstance().getConn();
pstmt   = conn.prepareStatement(sql);
pstmt.setString(1, "TEXT");
pstmt.setBytes(2, bytes);
pstmt.execute();

O método getBytesFromFile() é uma função genérica para converter o File em byte[], e somente este último é necessário para gravar, fácil assim.

Não posso deixar de indicar este artigo completo e bem detalhado, escrito por Giovane Kuhn do JavaFree.

Espero que estes simples códigos sejam proveitosos, abaixo estão as duas classes utilizadas para este post.

Faça download das classes.

Uma lista de destinatários formatada normalmente assim:

 Luciano <luciano@lucianosilva.com>, Grupos <grupos@lucianosilva.com>, Futebol <futebol@cfb.com.br> 

Este é o nosso problema, o Oracle não irá conseguir trabalhar com a String formatada dessa maneira, e irá lançar o erro:

ORA-29279: SMTP permanent error: 501 Bad address syntax

Enfim, para conseguir solucionar o problema do envio de e-mail para multiplos destinatários, utilize a função abaixo, ela irá devolver apenas o endereço de e-mail.

FUNCTION FORMAT_ADDRESS(ADDR_LIST IN OUT VARCHAR2) RETURN VARCHAR2 IS
    ---
    ADDR VARCHAR2(256);
    I    PLS_INTEGER;
    ---
    FUNCTION LOOKUP_UNQUOTED_CHAR(STR IN VARCHAR2, CHRS IN VARCHAR2)
      RETURN PLS_INTEGER AS
      C            VARCHAR2(5);
      I            PLS_INTEGER;
      LEN          PLS_INTEGER;
      INSIDE_QUOTE BOOLEAN;
      ---
    BEGIN
      INSIDE_QUOTE := FALSE;
      I            := 1;
      LEN          := LENGTH(STR);
      WHILE (I <= LEN) LOOP
        C := SUBSTR(STR, I, 1);
        IF (INSIDE_QUOTE) THEN
          IF (C = '"') THEN
            INSIDE_QUOTE := FALSE;
          ELSIF (C = '\') THEN
            I := I + 1; -- Skip the quote character
          END IF;
          GOTO NEXT_CHAR;
        END IF;
        IF (C = '"') THEN
          INSIDE_QUOTE := TRUE;
          GOTO NEXT_CHAR;
        END IF;
        IF (INSTR(CHRS, C) >= 1) THEN
          RETURN I;
        END IF;
        <<NEXT_CHAR>>
        I := I + 1;
      END LOOP;
      RETURN 0;
    END;
  BEGIN
    ADDR_LIST := LTRIM(ADDR_LIST);
    I         := LOOKUP_UNQUOTED_CHAR(ADDR_LIST, ',;');
    IF (I >= 1) THEN
      ADDR      := SUBSTR(ADDR_LIST, 1, I - 1);
      ADDR_LIST := SUBSTR(ADDR_LIST, I + 1);
    ELSE
      ADDR      := ADDR_LIST;
      ADDR_LIST := '';
    END IF;
    I := LOOKUP_UNQUOTED_CHAR(ADDR, '<');
    IF (I >= 1) THEN
      ADDR := SUBSTR(ADDR, I + 1);
      I    := INSTR(ADDR, '>');
      IF (I >= 1) THEN
        ADDR := SUBSTR(ADDR, 1, I - 1);
      END IF;
    END IF;
    RETURN ADDR;
  END FORMAT_ADDRESS;

A mudança do código anterior não é tão drástica, já que o parâmetro é entrada/saída, você pode fazer um looping na lista de endereços para adicionar um-a-um.

UTL_SMTP.MAIL(MAIL_CONN, V_FROM );
    WHILE( V_LIST_ADDRESS IS NOT NULL )LOOP
           UTL_SMTP.RCPT(MAIL_CONN, FORMAT_ADDRESS(V_LIST_ADDRESS) );   
    END LOOP;

Veja que é uma modificação simples, porém, ganha-se muito quando é necessário deixar o programa o mais abrangente possível
Enjoy!

Vamos lá, para o envio de e-mails é necessário que o pacote UTL_MAIL esteja instalado.

Conectando como sysdba na instância ORCL.

C:\>set oracle_sid=orcl
C:\>sqlplus sys/oracle as sysdba

Instalando o pacote UTL_MAIL. Isto não é nenhuma novidade, mas a variável de ambiente %ORACLE_HOME% indica o caminho a qual o banco de dados foi instalado, neste caso, foi utilizada a versão 10.2.0 – C:\oracle\product\10.2.0\db_1. Os sub-diretórios, contém os pacotes necessários para o UTL_MAIL funcionar.

SQL> set serveroutput on
SQL> @%ORACLE_HOME%/rdbms/admin/utlmail.sql
SQL> @%ORACLE_HOME%/rdbms/admin/prvtmail.plb
SQL> show errors;

Pronto, isto é o suficiente para o nosso próximo passo, a criação da procedure de envio de e-mails.

Crie uma package para agrupar todas as funcionalidades que podem ser comuns a diversos projetos, e reutilize o código quando necessário.

create or replace package PKG_BLOG_UTIL is

-- Author  : LUCIANO
-- Created : 05/07/2009

PROCEDURE enviar_email_auth(p_USUARIO   IN VARCHAR2,
p_SENHA     IN VARCHAR2,
p_TO        IN VARCHAR2,
p_COPIA     IN VARCHAR2,
p_SUBJECT   IN VARCHAR2,
p_MESSAGE   IN VARCHAR2);
end PKG_BLOG_UTIL;

Veja agora a versão 1.0 desta implementação:

CREATE OR REPLACE PACKAGE BODY PKG_BLOG_UTIL IS

PROCEDURE ENVIAR_EMAIL_AUTH(P_HOST    IN VARCHAR2,
P_USUARIO IN VARCHAR2,
P_SENHA   IN VARCHAR2,
P_TO      IN VARCHAR2,
P_COPIA   IN VARCHAR2,
P_SUBJECT IN VARCHAR2,
P_MESSAGE IN VARCHAR2)
IS

MAIL_CONN   UTL_SMTP.CONNECTION;
V_HEADER    VARCHAR2(4000);
CRLF        VARCHAR2(2) := CHR(13) || CHR(10); -- quebra de linha

BEGIN

-- Abre a conexão
MAIL_CONN   := UTL_SMTP.OPEN_CONNECTION(P_HOST, 25);
UTL_SMTP.HELO(MAIL_CONN, P_HOST);

-- Faz a autenticação para envio de mensagem
UTL_SMTP.COMMAND(MAIL_CONN, 'AUTH LOGIN');
UTL_SMTP.COMMAND(MAIL_CONN, UTL_RAW.CAST_TO_VARCHAR2(UTL_ENCODE.BASE64_ENCODE(UTL_RAW.CAST_TO_RAW(P_USUARIO))));
UTL_SMTP.COMMAND(MAIL_CONN, UTL_RAW.CAST_TO_VARCHAR2(UTL_ENCODE.BASE64_ENCODE(UTL_RAW.CAST_TO_RAW(P_SENHA))));

-- Prepara o cabeçalho de
V_HEADER := 'Date:'    || TO_CHAR(SYSDATE, 'dd Mon yy hh24:mi:ss') || CRLF ||
'From:'    || p_USUARIO || CRLF ||
'Subject:' || p_SUBJECT || CRLF ||
'To:'      || p_TO      || CRLF ||
'Cc:'      || p_COPIA   || CRLF ||
CRLF || CRLF ||
p_MESSAGE;

--
UTL_SMTP.MAIL(MAIL_CONN, '<' || P_USUARIO || '>');
UTL_SMTP.RCPT(MAIL_CONN, '<' || P_TO || '>');
UTL_SMTP.DATA(MAIL_CONN, V_HEADER);

-- Fecha a conexão
UTL_SMTP.QUIT(MAIL_CONN);

END ENVIAR_EMAIL_AUTH;
END PKG_BLOG_UTIL;

Algumas coisas podem ser melhoradas como, separar o corpo da mensagem do cabeçalho e utilizar o UTL_TCP.CRLF como separador de linhas no lugar da variável CRLF, veja como o código fica mais organizado:

/* APENAS UM TRECHO DO CÓDIGO */
UTL_SMTP.MAIL(MAIL_CONN, '<' || P_USUARIO || '>');
UTL_SMTP.RCPT(MAIL_CONN, '<' || P_TO || '>');

UTL_SMTP.open_data(MAIL_CONN);

-- Prepara o cabeçalho
UTL_SMTP.write_data(MAIL_CONN, 'From'    || ': ' || p_USUARIO || UTL_TCP.CRLF);
UTL_SMTP.write_data(MAIL_CONN, 'To'      || ': ' || p_TO      || UTL_TCP.CRLF);
UTL_SMTP.write_data(MAIL_CONN, 'Cc'      || ': ' || p_COPIA   || UTL_TCP.CRLF);
UTL_SMTP.write_data(MAIL_CONN, 'Subject' || ': ' || P_SUBJECT || UTL_TCP.CRLF);

-- Escreve a mensagem
UTL_SMTP.write_data(MAIL_CONN, UTL_TCP.CRLF || p_message);
UTL_SMTP.close_data(MAIL_CONN);

Eu preferi adotar este segundo código como o mais recomendável, mesmo assim, alguns detalhes podem ser adaptados a sua realidade, por exemplo, criar uma constante para o Mail Host, e indicando que o envio de e-mails sempre será a partir daquele servidor ou fazer a sobrecarga da procedure – a reutilização é uma benção.

Veja que a assinatura da procedure abaixo é um overload do que foi mostrado acima, isto é um conceito de Orientação-a-Objetos suportado pelo PLSQL, permite que um método seja escrito com diversas assinaturas diferentes, e reaproveitando o código de maneira eficaz.

PROCEDURE ENVIAR_EMAIL_AUTH(P_USUARIO IN VARCHAR2,
P_SENHA   IN VARCHAR2,
P_TO      IN VARCHAR2,
P_COPIA   IN VARCHAR2,
P_SUBJECT IN VARCHAR2,
P_MESSAGE IN VARCHAR2)
IS
V_MAILHOST CONSTANT VARCHAR2(100) := 'pop.xxxx.com.br';
BEGIN

enviar_email_auth(P_HOST    => v_mailhost,
P_USUARIO => P_USUARIO,
P_SENHA   => P_SENHA,
P_TO      => P_TO,
P_COPIA   => P_COPIA,
P_SUBJECT => P_SUBJECT,
P_MESSAGE => P_MESSAGE);
END ENVIAR_EMAIL_AUTH;

A package completa, está disponível aqui para download.

Não envie spam!

Aqui está a interface para a anotação, o melhor seria utilizar o Target como FIELD, porém, como falei vamos exibir os atributos com base nos métodos públicos Getters.

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface NoToString{}

Na classe ToStringUtil foi apenas acrescentado uma regra para não exibir os métodos marcados com a anotação @NoToString, sendo:

// Nao exibir os métodos que estejam com a Annotação NoToString
boolean isNotAnnotation = m.isAnnotationPresent(NoToString.class);

Realizei alguns testes com tipos complexos e funcionou, talvez você tenha alguma sugestão para melhorar este tipo de tratamento.

Baixe aqui a versão 1.0.2.

Namastê!

Pensando nisso resolvi criar uma classe útil que mostre todos os atributos Privates da sua classe juntamente com seus respectivos valores. Veja o código abaixo, em um bean eu reescrevi o método toString() fazendo um looping em todos os atributos:

public class Equipamento implements Serializable {
private String modelo;
private String marca;
private String descricao;
private Date fabricacao;

/*** getters/setters ocultados **/

public String toString(){
StringBuffer b = new StringBuffer();
// Obtem todos os atributos da classe
Field[] fields = this.getClass().getDeclaredFields();
b.append( this.getClass().getName() );
b.append( " { \n" );
for (int i = 0; i < fields.length; i++) {
try {

Field field = fields[i];
b.append( field.getName() );
b.append( " = " );
b.append( field.get(this) );
b.append("\n");

} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}
b.append( " } " );
return b.toString();
}
}

A reescrita do método acima resolve parcialmente o nosso problema, além de não atender aos tipos de dados complexos, você terá que fazer o famoso copy-paste para todas as classes que forem implementa-lo.

Voltamos então para nossa idéia inicial, então criaremos uma classe útil para que a automatização do toString(), sendo assim, qualquer classe poderá utiliza-la. Saiba que não iremos ter acesso aos atributos assinados com o modificador Private da classe que deseja utilizar o toString customizado, para resolver tal problema utilizaremos os Métodos públicos, ignorando os métodos da classe Object e aproveitando apenas os métodos acessores.

public final class ToStringUtil{
/*** ocultado ***/

public static String getText(Object object){
StringBuffer buffer = new StringBuffer("");
Method[] methods = object.getClass().getMethods();

for( Method method : methods ){
//
// verifica se o método é um Getter de attributo da classe
//
if( isGetterFieldMethod(method, object.getClass()) ){
buffer.append( getResumeNameMethod( method.getName() ) );
buffer.append("   = ");
buffer.append( getMethodReturnValue(object, method) );
buffer.append( NEW_LINE );
}

}// for each end

return buffer.toString();
}

/*** ocultado ***/
}

Esta versão ainda continua com o problema de tipos complexos, assim que eu for melhorando vou disponibilizar por aqui.

Download
Versão completa ToStringUtil 1.0.1.

Referência
Reflection

Mas… você já tentou montar seu cliente de email? “Pra quê, cara? Eu uso o Gmail” – você irônicamente me responderia, e na tréplica eu diria: Ué! Pra quê o Gmail, se você pode fazer melhor meu rapaz! (sarcástico, não?) Mãos a obra!

O pacote javax.mail.* fornece uma série de recursos para protocolos de internet, utilizando-o como uma receita de bolo o sucesso é garantido. Basicamente vamos criar um programa que monitore a caixa de entrada de um determinado endereço POP3.

Coloque os dados de acesso ao mail em um arquivo config.properties, assim:

pop.hst=pop.lucianosilva.com.br
pop.usr=boss@lucianosilva.com.br
pop.pwd=ABC123#XYZ

A classe abaixo se encarregará de obter estes dados de conexão:

public class PropertiesMail extends Properties{
private static final String ARQUIVO_CONFIGURACAO = "C:\\config.properties";

public PropertiesMail(){
try{
FileInputStream file = new FileInputStream( ARQUIVO_CONFIGURACAO);
this.load( file );

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

public String getHost(){
return this.getProperty("pop.hst");
}

public String getAccountUser(){
return this.getProperty("pop.usr");
}

public String getAccountPassword(){
return this.getProperty("pop.pwd");
}

}

Agora, a caixa de correios. Veja que o processo abaixo básicamente segue um roteiro, mas é óbvio que isto é feito apenas para a leitura.

public class Inbox{

public Inbox(){
try {
init();
} catch (MessagingException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}

private void init() throws MessagingException, IOException{
// Instância das Propriedades de Conexão
PropertiesMail ppm = new PropertiesMail();
// Seta o endereço do host
Properties pp        = System.getProperties();
pp.put("mail.pop3.host", ppm.getHost());

// Se o servidor exigir autenticação segura
Authenticator auth = new PopAuthentication();
Session session    = Session.getDefaultInstance(pp, auth);

Store store           = session.getStore("pop3");
// Dados básicos de conexão
store.connect(ppm.getHost(), ppm.getAccountUser(), ppm.getAccountPassword());

// Obtem o diretório (INBOX)
Folder folder       = store.getFolder("INBOX");
folder.open(Folder.READ_ONLY);

// ler as mensagens do diretório
Message message[] = folder.getMessages();

processMessage(message);

// Close connection
folder.close(false);
store.close();
}

private void processMessage( Message[] message ) throws MessagingException, IOException{
if( message == null || message.length==0 ){
System.out.println("Nenhuma mensagem encontrada");
}else{
for (int i=0, n=message.length; i
System.out.println(i + ": " + message[i].getFrom()[0] + "\t" + message[i].getSubject());
String content = message[i].getContent().toString();
System.out.print(content);
}// for end
}
}

public static void main(String[] args){
Inbox inbox = new Inbox();
}
}

Muito fácil não? Mas este é um exemplo simples mesmo, saiba que é possível fazer todo o controle de um cliente de e-mail não só Ler, como Escrever, Apagar, Mover, etc.

Downloads

Projeto utilizado para este post.
JavaMail API

Veja mais sobre JavaMail

JavaMail API
jGuru: Fundamentals of the JavaMail API
WebMail in Java: Reading E-mail
Have a fun!

O BPEL é uma linguagem que descrita em XML, que básicamente é utilizada para desenhar processo de negócio seguindo como base o BPM, destaca-se pela simplicidade da criação de um processo e pela amigável interface, proporcionando uma sensação agradável no momento do design. O utilizador de BPEL não necessita de conhecimentos em linguagem de programação, porém, o programador poderá obter mais recursos da ferramenta.

Para apresentar o BPEL escolhi algo um pouco mais além do famoso “Hello Word”, vamos trabalhar em um cenário de integração de softwares, aonde o legado irá disponibilizar um arquivo TXT no padrão CVS posicional diáriamente, o processo deverá interpretar o conteúdo deste arquivo e gravar no banco.

Pré-Requisitos

JDeveloper 10.1.3.4 (com suporte a SOA).

SOA Suite 10.1.3.1.0 (Com Windows Vista, talvez vc tenha problemas, baixe o patch).

MySQL.

Parte 1 – Criando o Projeto

Crie um projeto do tipo BPEL Project em File -> New -> Projects -> BPEL Process Project (certifique-se de que está filtrando por todas as tecnologias). Em seguida, dê um nome ao projeto e na opção template opte por Empty BPEL Process.

Parte 2 – Usando o Adapter File

O Adapter File é um recurso do BPEL para manipulação de arquivos, oferece três opções Leitura, Escrita e Sincronização (Read, Writer e Synchronous Read), além dele existe o Adapter FTP (autoexplicativo), porém iremos falar sobre ele depois. Continuando com nosso projeto, vamos utiliza a opção Read para o arquivo texto que estará disponível no diretório c:\interface_dir, haverá um pooling a cada 1 minuto, obviamente que isto é apenas para testes você deve adequar o intervalo de tempo de acordo com sua necessidade, veja a seguir o passo-a-passo do Adapter File.

Veja aqui os screenshot do passo-a-passo para configurar o File Adapter.

Até este passo fizemos apenas configurações básicas da funcionalidade do Adapter, porém, agora é necessário definir um o mapeamento das colunas posicional (fixo), utililzando um Schema XSD, veja a seguir como é simples:

Screenshots para criar o Schema XSD.

Parte 3 – Criando o Adapter Database

Crie um banco de dados no MySQL ou em qualquer outro SGDB, em seguida crie a tabela pais que irá receber os dados contidos no arquivo texto. Antes de utilizar o Adapter Database certifique-se que sua conexão com o banco está feita pelo JDeveloper, ela será necessária para os passos a seguir, portando vá até a aba Connection, se não existir crie-a.

Com a tabela criada e a conexão feita, agora vamos utilizar o componente Database Adapter que será o responsável por executar instruções SQL. Os passos aqui são tão simples quanto a criação da conexão, porém, é importante destacar que no Passo 4 escolha a opção Execute Custom SQL, e no quinto e último passo coloque a instrução de inserção da tabela pais, não se preocupe com o XSD ele será criado automáticamente, veja como fica:

Passo 4 – While e Variáveis

Para cada campo do arquivo TXT, mapeado pelo Schema XSD, devemos criar uma variável que irá armazenar o valor dos campos, então vá até a aba Structure e crie as variáveis.

Depois de todas as variáveis criadas precisamos associa-las aos campos do XSD e inicializa-las, mas para isto devo esclarecer uma coisa, sabemos que o arquivo texto poderá ter uma ou mais linhas de registro, portanto é necessária uma instrução de repetição. Utilizaremos o componente WHILE, a partir de uma variável contadora (índice).

O While cria um novo escopo aonde devemos arrastar os componentes de assinatura das variáveis e chamada da procedure, ou seja, para cada registro iremos fazer a inicialização da variáveis e a chamada da procedure para gravar no banco de dados, finalizando o nosso processo BPEL.

O processo é simples mas o dominio do ambiente BPEL é excencial, saber criar as variáveis, inicializá-las, passagem de valores, etc. Abaixo está disponível o fonte do projeto criado no JDeveloper.

Clique aqui para baixar o fonte.

]]> http://www.lucianosilva.com/2009/02/13/apresentando-o-bpel-com-o-adapter-file/feed/ 1 http://www.lucianosilva.com/2009/01/21/conhecendo-a-api-do-twitter/ http://www.lucianosilva.com/2009/01/21/conhecendo-a-api-do-twitter/#comments Wed, 21 Jan 2009 12:32:38 +0000 Luciano http://www.lucianosilva.com/?p=122 Incentivado por este post do Blog do Élcio que demonstrou a utilização da API do Twitter no ubuntu de uma maneira muito fácil e simples, então procurei saber um pouco mais sobre ela.

Existem algumas bibliotecas prontas para diversas linguagens, escolhi pela Twitter4j antes de mexer na API do Twitter mesmo, e não me arrependi com algumas poucas linhas de código é possível atualizar seu status e até receber as últimas atualizações, veja como é simples.

import twitter4j.Status;
import twitter4j.Twitter;
import twitter4j.TwitterException;

public class Twittando {

public static void main(String[] args) {
// usuário e senha do twitter
String usr = "lucianosilva";
String pwd = "ABCDEFGHIJKL";

try {

Twitter twitter = new Twitter(usr, pwd);
// atualizando o status do twitter
Status status   = twitter.update("Twitter4J, muuito fácil de usar, recomendo!");
System.out.println("Result: " + status.getText() );

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

Não esqueça de fazer o download da biblioteca Twitter4j aqui. E se você for uma pessoa “caprichosa” assim como o Elcio, criaria um UPBox, mas… no meu caso fiz um exemplo mais simples para demonstrar a lista de updates, veja o scriptlet:

<style type="text/css">
#box{
font-family:tahoma,arial;
font-size:10px;
border:1px #000000 solid;
background-color:#ffffff;
width: 300px;
height: 400px;
overflow: auto;
}
</style>
...
<div id="box">
<%
Twitter twitter = new Twitter();
twitter.setUserId("lucianosilva");
twitter.setPassword("ABCDEFGHIJKL");

ArrayList<status> listUpdates = (ArrayList<status>) twitter.getFriendsTimeline();
for(Status status : listUpdates){
User user = status.getUser();
%>
<p><img src="<%= user.getProfileImageURL() %>" border=2/>
&amp;amp;amp;amp;nbsp;:&amp;amp;amp;amp;nbsp;<%= status.getText() %></p>
<%
}// for each end
%>
</div>

Bacana né? Divirta-se.

Maravilha, eu só tinha o IP e então conseguiu saber o País daquele endereço de IP, não satisfeito consegui mais dados sobre ele, então surgiu o Estado, Cidade, Latitude e Longitude, e talvez o CEP, o Código de Área internacional, quem sabe?

É mais uma vez eu não estou satisfeito e agora vou fazer com que estes dados sejam exibidos no mapa, usando o Google Maps API. =) E provarei que é tão fácil quanto foram os outros exemplos.

Nós já sabemos o que ter em “mãos” para API GeoLite.

Já para utilizar o Google Maps API você deve obter uma chave que permitirá fazer as consultas, veja mais aqui. O código descrito abaixo exibira uma mapa simples com alguns markets-point, mas é possível demonstrar o mapa de diversas maneiras, sabia mais.

<?php
require("geoipregionvars.php");
require("geoipcity.inc");

// Obtem o IP
$vIP     = $_SERVER['REMOTE_ADDR'];

// Abre o arquivo dat com o banco de dados
$giCity  = geoip_open("GeoLiteCity.dat",GEOIP_STANDARD);

echo $vIP;

// obtem o registro do
$record  = geoip_record_by_addr($giCity, $vIP);
?>

Perceba que no JavaScript abaixo a url do maps solicita através do parâmetro key o código gerado para sua conta, eu substitui o valor por <COLOQUE-SUA-KEY-AQUI>.

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="content-type" content="text/html; charset=utf-8"/>
<title>Google Maps JavaScript API Example</title>
<!---// Mude o Key //-->
<script src="http://maps.google.com/maps?file=api&amp;amp;amp;amp;amp;amp;v=2&amp;amp;amp;amp;amp;amp;key=<coloque-SUA-KEY-AQUI>"
type="text/javascript"></script>
<script type="text/javascript">

function initialize() {
if (GBrowserIsCompatible()) {
var map = new GMap2(document.getElementById("mapaGeoIP"));

// ---
// Aqui informamos a Latitude e Longitude do IP
//
map.setCenter(new GLatLng(<?= $record->latitude ?>, <?= $record->longitude ?>), 13);

// Adicionado 10 lugares (markets) randômicos próximo a localidade
var bounds = map.getBounds();
var southWest = bounds.getSouthWest();
var northEast = bounds.getNorthEast();
var lngSpan = northEast.lng() - southWest.lng();
var latSpan = northEast.lat() - southWest.lat();
for (var i = 0; i < 15; i++) {
var point = new GLatLng(southWest.lat() + latSpan * Math.random(),
southWest.lng() + lngSpan * Math.random());
map.addOverlay(new GMarker(point));
}
}
}
</script>
</head>
<body onload="initialize()" onunload="GUnload()">
<div id="mapaGeoIP" style="width: 600px; height: 400px"></div>
</body>
</html>

Este é um exercício muito interessante, veja que legal alterando o endereço de IP, para isto vá ao prompt de comando no Windows e digite, por exemplo:

ping bb.com
ping google.com
ping cnn.com

Namastê.

Este código complementa o mesmo utilizado em GeoLite Country, porém, utiliza um objeto com as caracteristicas de localização.

Faça o download do arquivo dat, copie o geoipcity.inc também, crie o arquivo – geoipregionvars.php – com as variáveis e constantes necessárias como este, certifique-se que o arquivo geoip.inc esteja na sua estrutura de arquivos, que deverá ficar assim:

Vamos ao código! O seu arquivo index.php deverá centralizar a obtenção do IP e chamar as funções para decodificar e exibir os dados sobre ele, veja:

<?php

// Includes da API
require("geoipregionvars.php");
require("geoipcity.inc");

// Obtem o IP
$vIP     = $_SERVER['REMOTE_ADDR'];

// Abre o arquivo dat com o banco de dados
$giCity  = geoip_open("GeoLiteCity.dat",GEOIP_STANDARD);

// obtem o registro do
$record  = geoip_record_by_addr($giCity, $vIP);
?>

Até aqui conseguimos identificar o IP e obter as informações sobre de localização que está na variável $record, a seguir esta a camada de visualização dos dados.

<?
// obtem o registro do
$record  = geoip_record_by_addr($giCity, $vIP);
if( !empty($record) ){?>
<table border="0" cellpadding="2" cellspacing="1">
<tr>
<th colspan="2">Informações sobre o IP
<em>"<?= $vIP ?>"</em></th>
</tr>
<tr>
<td width="35%">País</td>
<td width="65%"><?= $record->country_name ?></td>
</tr>
<tr>
<td>Estado</td>
<td>
<?=$GEOIP_REGION_NAME[$record->country_code][$record->region] ?>

</td>
</tr>
<tr>
<td>Cidade</td>
<td><?= $record->city ?></td>
</tr>
<?    if(!empty($record->postal_code)){ ?>
<tr>
<td>CEP</td>
<td><?= $record->postal_code ?></td>
</tr>
<? } ?>
<tr>
<td>Latitude</td>
<td><?= $record->latitude ?></td>
</tr>
<tr>
<td>Longitude</td>
<td><?= $record->longitude ?></td>
</tr>
</table>
<?
}
?>

Have a fun.

Portanto, resolvi fazer este post para demonstrar uma facilidade muito interessante e pouco utilizado em sites nacionais, como os de operadora de telefônia, que preferem perguntar qual a sua cidade ao invés de identificar seu IP e redirecioná-lo aos serviços prestados em sua região e, fornecer uma opção para mudar de região quando quiser.

Talvez você encontre diversos outros bancos de dados de IPs na internet, porém, o mais popular é da Maxmind, que disponibiliza um bom serviço e gratuíto e também um serviço mais amplo por alguns dólares. A versão free é chamada de GeoLite e fornece além dos dados em CSV e DAT, incluí uma série de APIs para as linguagens de programação mais populares e alguns tutoriais de como utilizá-las, aqui utilizaremos PHP.

Vamos lá, faça o download do arquivo dat do GeoLite Country, e depois baixe as funções para manipulação do arquivo dat. Não será necessária nenhuma configuração no servidor tão menos no PHP, veja como é simples a identificação de pais utilizando os recursos do GeoLite Country.

<?php

// Inclui as funções do GeoIP Country
require("geoip.inc");

// Abre o arquivo .dat (banco de dados)
// especificando o caminho fisico do mesmo.
$gi = geoip_open("GeoIP.dat", GEOIP_STANDARD);
// recebendo o IP
$vIP = $_SERVER['REMOTE_ADDR'];
echo "Endereço de IP identificado: " . $vIP . "<br/>";
// Exibe a sigla e o nome do País
echo geoip_country_code_by_addr($gi, $vIP);
echo geoip_country_name_by_addr($gi, $vIP);

// fecha a conexão com o banco de dados
geoip_close($gi);
?>

Uma informação básica como esta, permite aos sites de serviços fornecerem funcionalidades, customizações, atrações no geral para que seu visitante sinta-se mais confortável se isto é possível.

Vou dar sequência a esta sessão de post, aprofundando as funcionalidades do GeoLite.

Namastê.

Atualmente a versão da SCJP é a 6, porém ainda é possível fazer a 5, existem cursos específico preparatórios para a certificação, mas eu ainda prefiro seguir o bom e velho livro da Kathy Sierra, e os mocks que são diversas opções pela internet.

Abaixo vou listar alguns links úteis para auxiliar nos estudos.

Mocks
http://www.javabeat.net/javabeat/scjp5/index.php
http://www.wickedlysmart.com/SCJPStudyGuide/Java_5_SCJPquestions.html
http://www.javabeat.net/javabeat/scjp5/mocks/index.php

Perguntas Frequêntes no JavaRanch
http://faq.javaranch.com/java/ScjpFaq

Guia de Estudos e Dicas
http://java.boot.by/scjp-tiger/
http://camilolopes.wordpress.com/2008/03/31/falando-um-pouco-sobre-o-exame-310-055-scjp/

Livro da Kathy Sierra
Submarino
Amazon

Twitter da Kathy
http://twitter.com/KathySierra

Detalhes da Certificação
http://www.sun.com/training/catalog/courses/CX-310-055.xml

Boa Sorte!

Existem diversas formas de distribuir serviços na internet e a o número de ferramentas para tornar isto cada vez mais fácil aumentam constantemente. Pesquisando sobre conceitos e maneiras práticas para desenvolvimento encontrei no Blog dos Desenvolvedores da Caelum um jeito simples para criação de Web Services utilizando a especificação JSR-181 e JSR-224, achei interessantíssimo e não perdi tempo em fazer os testes.

A especificação permite que você crie serviços utilizando apenas Annotations.

import javax.jws.WebMethod;
import javax.jws.WebService;
import tucano.bean.Pessoa;

@WebService
public class PessoaWS {
private Pessoa[] list = new Pessoa[5];

public PessoaWS() {
list[0] = new Pessoa("M", "Luciano", "Silva");
list[1] = new Pessoa("F", "Priscila", "Carmo");
list[2] = new Pessoa("F", "Maria", "Conceição");
list[3] = new Pessoa("F", "Lucia", "Felix");
list[4] = new Pessoa("M", "Cristino", "José");
}

@WebMethod
public Pessoa[] listAll(){
return list;
}
}

Perceba que este Web Service foi criado de maneira extremamente simples apenas para demonstração, porém, o método retorna um tipo de dado complexo, isto para sair da monotonia.

Ainda o que os caras da Caelum, vamos fazer a publicação/ativação do serviço utilizando o XFire projeto relacionado ao Apache CXF

<!-- // X-Fire //--->
<servlet>
<servlet-name>XFireServlet</servlet-name>
<display-name>XFire Servlet</display-name>
<servlet-class>org.codehaus.xfire.transport.http.XFireConfigurableServlet</servlet-class>
<init-param>
<param-name>config</param-name>
<param-value>services.xml</param-value>
</init-param>
</servlet>

<servlet-mapping>
<servlet-name>XFireServlet</servlet-name>
<url-pattern>/servlet/XFireServlet/*</url-pattern>
</servlet-mapping>

<servlet-mapping>
<servlet-name>XFireServlet</servlet-name>
<url-pattern>/services/*</url-pattern>
</servlet-mapping>
<!-- // //--->

Se você for seguir o site do projeto X-Fire, irá perceber que é sugerido a criação do arquivo no caminho META-INF/xfire/services.xml, isto não deu muito certo comigo, tentei diversas configurações e até percebi que é um bug em aberto para o projeto.

Para resolver o problema opite por colocar o arquivo de configuração services.xml na raíz do source [src/services.xml].

<beans xmlns="http://xfire.codehaus.org/config/1.0">
<service>
<name>PessoaService</name>
<namespace>http://xfire.codehaus.org/PessoaService</namespace>
<serviceClass>tucano.ws.PessoaWS</serviceClass>
</service>
</beans>

Básicamente a configuração se resume em um nome para o Serviço e a Classe que implementa-o. Após fazer deploy do projeto no seu container JEE você poderá acessar o serviço da seguinte maneira http://localhost/<CONTEXTO>/services/<SERVICE_NAME>?wsdl, então, http://localhost/Tucano/services/PessoaService?wsdl.

Você pode fazer o download dos fontes aqui.

É prático, fácil e rápido, vale ser estudado e em alguns casos sugerido como solução, mesmo assim eu estou cansado de ver configurações em arquivo XMLs fora do contexto, não sou muito adepto a esta solução, de qualquer maneira tá dado o recado. =)

O RichFaces é interessante e muito completo, oferece diversos recursos para web que até então o HTML estava limitado, como o combobox (leia-se também dropdown) com área aberta para localização de textos – <rich:comboBox/>. Ao contrário deste alguns outros componentes apresentam problemas sérios de incompatibilidade com o Apache MyFaces (Tomahawk), por exemplo, o <rich:fileUpload/>.

Estudando esses componentes observei suas vantagens e falhas, decidi então criar este exemplo de um recurso tão comum em formulários e simples com JSF, que são os combobox dependentes ou alinhados.
Vamos continuar com o esquema de Países e Estados, um combobox para cada, sendo que ao modificar o Pais através do AJAX os estados relacionados serão carregados.

A configuração básica do Faces e RichFaces no web.xml será ocultada, porém você poderá fazer o download do projeto no fim deste post.
O projeto está estruturado da seguinte maneira:

No Manager Bean destacam-se os métodos getPaises() e actionCarregarEstados(), o primeiro retorna um array de itens – SelectItem[] – tipo de dado complexo que será tratado pelo componente JSF, já o actionCarregarEstados() é responsável por carregar os estados relacionados ao pais.

public class UirapuruManagerBean {
private Pessoa pessoa = new Pessoa();
private SelectItem[] estados;

/* getters e setters ocultados */

/* carrega os paises */
public SelectItem[] getPaises(){
List<pais> lp = regiaoDao.getAllPais();
List<selectItem> itens = new ArrayList<selectItem>(lp.size());

for( Pais p : lp ){
itens.add( new SelectItem(p.getId_pais(), p.getNm_pais()) );
}// for end
return itens.toArray( new SelectItem[itens.size()] );
}

/* carrega os estados */
public SelectItem[] getEstadosByPais(int id_pais){
List<estado> estados   = regiaoDao.getEstadosDoPais(id_pais);
List<selectItem> itens = new ArrayList<selectItem>(estados.size());

for( Estado e : estados ){
itens.add( new SelectItem(e.getId_estado(), e.getNm_estado()) );
}// for end
return itens.toArray( new SelectItem[itens.size()] );
}

/*  */
public String actionCarregarEstados(){
this.estados = getEstadosByPais(getPessoa().getPais().getId_pais());
return "SUCCESS";
}

}

Uma observação importante antes de seguirmos: os beans Pessoa, Pais e Estado são simples e foram criados apenas para uma interpretação melhor, é importante e somente assim este exemplo irá funcionar perfeitamente se no bean Pessoa, os atributos pais e estado sejam inicializados. Já que não estamos trabalhando com Spring o Faces não irá fazer este entendimento e uma exceção NullPointerException será lançada, para evitar tal faça isto:

public class Pessoa implements Serializable {
private int id;
private String nome;

// criando os objetos
private Pais pais = new Pais();
private Estado estado = new Estado();

/* getters e setters ocultados */
}

Okay. Feita a observação vamos para a parte final, a montagem do JSP.

<%@ taglib prefix="f"  uri="http://java.sun.com/jsf/core"%>
<%@ taglib prefix="h"  uri="http://java.sun.com/jsf/html"%>
<%@ taglib prefix="a4j" uri="http://richfaces.org/a4j"%>

Não esqueça que qualquer página JSF deve ser elaborada dentro da tag <f:view/> e, que sem a definição do formulário <h:form/> o AJAX não irá funcionar.

<f:view>
<h:form>
<h:panelGrid border="0" columns="2" width="500" cellpadding="1" cellspacing="2">

<h:outputLabel value="Pais" for="pais"/>
<h:selectOneMenu id="pais"
value="#{umb.pessoa.pais.id_pais}"
rendered="true">
<f:selectItems value="#{umb.paises}"/>
<a4j:support event="onchange"
ajaxSingle="true"
action="#{umb.actionCarregarEstados}"
reRender="pais,estado"/>
</h:selectOneMenu>

<h:outputLabel value="Estado" for="estado"/>
<h:selectOneMenu id="estado"
value="#{umb.pessoa.estado.id_estado}"
rendered="true">
<f:selectItems value="#{umb.estados}"/>
</h:selectOneMenu>

</h:panelGrid>
</h:form>
</f:view>

Na tag <h:selectOneMenu/> deve-se colocar na propriedade VALUE o atributo que irá receber o valor selecionado no combobox, outras propriedades excenciais são o ID que identifica o componente e RENDERED que indica a renderização. A tag <f:selectItems/> invoca o método – umb.getPaises() – que contém os itens do combobox.

Até o momento utilizamos apenas JSF puro, o RichFaces é representado na tag <a4j:support/> responsável por identificar quando um evento do tipo OnChange é feito e fazer a ação definida no método umb.actionCarregarEstados, e por fim na propriedade reRender estão separados por vírgulas os componentes que serão renderizados.

Seguindo esta linha de raciocínio você conseguirá fazer vários níveis de dependência facilmente, o componente <rich:combobox/> também permite este tipo de interação, com alguns recursos a mais.

Faça aqui o download do projeto.

Você já sabe o que é um WebServices e também como é simples publicá-lo utilizando Axis, mas nem todos seus serviços irão trabalhar apenas com tipos de dados primitivos, provavelmente será necessário retornar uma lista de Pessoas, Enderecos, ou qualquer outro tipo de dado complexo.

Nosso cenário é um projeto cujo o objetivo é fornecer consultas de Países e seus respectivos Estados, acessados através de serviços, a definição de Beans, DAOs e qualquer outras classes serão ocultadas, porém, no final deste post você poderá baixar a versão completa do projeto.

Bem como já foi demonstrado aqui precisamos de uma classe para que seja a base do serviço, neste caso será a harpia.region.services.Region, veja:

package harpia.region.services;

/* imports ocultados */

public class Region {
private RegionDAO rdao = new RegionDAO();

/**
*
* @param Nome do Pais
* @return Todos os países encontrados
*/
public Pais[] find(String nmPais){
ArrayList<pais> list = rdao.getAllPais( nmPais );
Pais[] paises    = new Pais[list.size()];
list.toArray(paises);

return paises;
}
}

Criando o WSDL
Crie um novo objeto chamado Web Service (File > New > Others > Web Service). Após selecionar Web Service clique em Next.

Clique em Browse e selecione a classe responsável por implementar o serviço, ou seja, harpia.region.services.Region. Veja que o tipo deve ser Bottom up Java Web Service.

Na sequência serão exibidos os métodos disponibilizados pelo serviço, caso você não queira publicar basta desmarcar.

E por fim a caixa de dialogo informa que o servidor Apache está down é que será necessário fazer o startup para concluir a criação e publicação do WSDL, utilize esta mesma tela para iniciar o servidor e concluir o passo-a-passo.

Veja que um novo arquivo foi criado em projeto, agora existe o wsdl/Region.wsdl.

O WSDL (Web Service Description Language) nada mais é do que um Schema XML cujo está descrito o serviço de internet. Você poderá acessar este serviço em http://localhost/Harpia/wsdl/Region.wsdl ou também http://localhost/Harpia/services/Region?wsdl.

Criando o Client

Nosso serviço foi criado em Java 1.5, porem, neste momento poderiamos fazer uma solicitação a partir de qualquer linguagem que saiba interpretar o WSDL. Vamos continuar no Java por enquanto e fazer a chamada do nosso Web Service.
Já que a intensão é mostrar como a IDE facilita a criação de Web Services, aqui vai mais um wizard de como fazer o Web Service Client no eclipse.

Hey Client! Chamaí o serviço pow!

import java.rmi.RemoteException;
import javax.xml.rpc.ServiceException;
import harpia.region.bean.Pais;
import harpia.region.services.RegionServiceLocator;

public class HarpiaClient {

public static void main(String[] args) throws RemoteException, ServiceException {
// obter o nome do pais para pesquisa
String nome = JOptionPane.showInputDialog(null, "Qual é o pais?", "Unido");

RegionServiceLocator locator = new RegionServiceLocator(); // localizando ...
Pais[] paises = locator.getRegion().find(nome); // procurando ...
for (int i = 0; i < paises.length; i++) { // exibindo
Pais pais = paises[i];

System.out.println("["+i+"] " + pais.getNome() + " | ID: " + pais.getId_pais());
}
// Simples assim
}

}

E para aqueles que ainda dizem por aí que tudo isso aqui é conversa fiada, se é que existe algum maluco pra dizer isto, tomaí! PHP consumindo o Web Service feito em Java.

<?
$client = new SoapClient(null, array('location' => 'http://localhost/Harpia/services/Region?wsdl',
'uri' => 'http://localhost/Harpia/services/Region?wsdl',
'trace' => '1'));

$result = $client->find('ale');

if(  is_soap_fault($result) ){
echo "Ocorreu algum erro.<br/>";
}else{

print_r($result);
}

unset($client);
?>

Faça download dos fontes aqui.

That’s all.

A criação de webservices com Apache Axis é muito simples, veja a classe abaixo:

public class Calculo {
/**
*
* @param n1
* @param n2
* @return Resultado da Soma
*/
public double soma(double n1, double n2){
return (n1 + n2);
}
}

Após criar essa simples classe composta pelo método soma, cujo retorna um tipo primitivo, para que esta classe seja publicada como um serviço basta copiá-la para a aplicação do Axis ($TOMCAT_HOME\webapps\axis) em seguida renomeá-la para Calculo.jws. Acesse o serviço como http://localhost:8080/axis/Calculo.jws?wsdl, isto é tudo.

Simples assim, criar o Client que irá utilizar o serviço é tão simples quanto.

import org.apache.axis.client.Call;
import org.apache.axis.client.Service;

public class CalculoClient {

/**
* @param args
*/
public static void main(String[] args) throws Exception{
String url = "<a href="http://localhost/axis/Calculo.jws?wsdl">http://localhost/axis/Calculo.jws?wsdl</a>";
Service service = new Service();
Call call       = (Call) service.createCall();
call.setTargetEndpointAddress( url );
call.setOperationName("soma"); // método do webservices

Double[] param  = {15.0, 15.0}; // parâmetros
Double result   = (Double) call.invoke( param ); // chamada
System.out.println("Resultado : " + result );
}
}

Exemplos iguais a este devem existir centenas de milhares na internet, simples utilizando tipos primitivos, básico mesmo. Mas cansado de saber disto vou demonstrar um exemplo mais completo utilizando tipo de dados complexos!

Veja mais esses artigos excelentes:
http://www.javafree.org/content/view.jf?idContent=4
http://www.guj.com.br/java.tutorial.artigo.180.1.guj
http://www.guj.com.br/java.tutorial.artigo.132.1.guj

Web Services nada mais é do que um serviço remoto descrito utilizando a WSDL – Web Service Description Language – e acessado utilizando um protocolo (SOAP) totalmente abstrato.

As grandes do mercado Microsoft, Oracle, IBM, Sun, HP entre outos, estão a frente do WS-I, orgão responsável por manter e garantir o funcionamento dos webservices em qualquer plataforma.

Simples assim…

O popular SOAP nada mais é do que um schema descrito em XML, definindo o serviço e sua localização, para que o cliente faça a conexão.

Essa é a minha versão do InitCap em Java.

private static final String SEPARADOR[] = {"do","da","de","e","dos","das"};

/**
* @author lsilva
* @param in
* @return
*/
public static String initCap( String in ){
String out    = null;
String[] part = in.split(" ");
StringBuffer temp = new StringBuffer();

for (int i = 0; i<part.length; i++){

if( i>0 ) temp.append(" ");
if( ehSeparador( part[i] ) ){
temp.append( part[i].toLowerCase() );
}else{
temp.append( part[i].substring(0, 1).toUpperCase() );
temp.append( part[i].toLowerCase().substring(1, part[i].length()) );
}
}// for end

out = temp.toString();
return out;
}

/**
* @author lsilva
* @param sep
* @return
*/
private static boolean ehSeparador(String sep){
boolean r = false;
for (int i = 0; i < SEPARADOR.length; i++){

if( sep.equalsIgnoreCase( SEPARADOR[i] ) ){
r = true;
break;
}else{
r = false;
}
}
return r;
}

Depois de algumas discussões e muita zuação, meu amigo Orlando disse: “Muita firula pra pouca coisa, faz assim cara:

/**
* @author oneto
* @param n
* @return
*/
public static String initCap( String n ){
String[] x                      = n.split(" ");
StringBuffer r  = new StringBuffer();
String e                        = " de , da , des , da ";

for (int i = 0;i<x.length;i++){
if(e.indexOf(x[i].trim().toLowerCase())< 0){
r.append(x[i].substring(0,1).toUpperCase() + x[i].substring(1,x[i].length()).toLowerCase() + " " );
}else{
r.append(x[i].toLowerCase() + " ");
}
}
return r.toString().trim();
}

Essa função pode ser feita de diversas outras maneiras, aqui foram apenas sugeridas algumas. Muitas vezes você não precisará criar basta pesquisar sobre a linguagem utilizada, por exemplo, em PHP a função nativa para isto é o ucwords.

That’s all.

A utilização de frameworks é uma mão-na-roda, tanto no sentido de diminuir muito a reconstrução de funcionalidades básicas, tão quanto para padronizar componentes. O JavaServer Faces há tempos é uma base de desenvolvimento segura, padronizada e rica em componentes web 2.0, seguindo este padrão o pessoal do JBoss criou o RichFaces, que futuramente foi chamado de Ajax4Jsf, nada mais é que um pacote de componentes pré-definidos para construção de aplicativos utilizando AJAX. No wikipedia você encontra uma descrição mais detalhada sobre JSF e RichFaces.

Em seguida vou demonstrar um desafio feito por mim mesmo, veja aqui, construindo um auto-completar utilizando JSF com Richfaces.

Os conceitos de JSF e RichFaces não serão discutidos, ou seja, apenas vou demonstrar como criar a aplicação sem detalhar a configuração feita no web.xml e no faces-config.xml, futuramente dedicarei um post sobre essas configurações.

Em seguida será demonstrado como construit um auto-completar cujo conteúdo será o nome de países, portanto, a estrutura básica das classes é esta:

O arquivo web.xml está configurado básicamente para trabalhar com os framewroks JSF e RichFaces.

<?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"
id="WebApp_ID" version="2.5">
<display-name>ClubesRich</display-name>
<!-- RichFaces Config -->
<context-param>
<param-name>org.richfaces.SKIN</param-name>
<param-value>blueSky</param-value>
</context-param>
<context-param>
<param-name>javax.faces.STATE_SAVING_METHOD</param-name>
<param-value>server</param-value>
</context-param>
<filter>
<display-name>RichFaces Filter</display-name>
<filter-name>richfaces</filter-name>
<filter-class>org.ajax4jsf.Filter</filter-class>
</filter>
<filter-mapping>
<filter-name>richfaces</filter-name>
<servlet-name>Faces Servlet</servlet-name>
<dispatcher>REQUEST</dispatcher>
<dispatcher>FORWARD</dispatcher>
<dispatcher>INCLUDE</dispatcher>
</filter-mapping>

<!-- Faces Config -->
<servlet>
<servlet-name>Faces Servlet</servlet-name>
<servlet-class>javax.faces.webapp.FacesServlet</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>

<!-- Faces Mapping -->
<servlet-mapping>
<servlet-name>Faces Servlet</servlet-name>
<url-pattern>*.jsf</url-pattern>
</servlet-mapping>

<!-- Database Config -->
<resource-ref>
<description>DB Connection</description>
<res-ref-name>jdbc/Clubes</res-ref-name>
<res-type>javax.sql.DataSource</res-type>
<res-auth>Container</res-auth>
</resource-ref>
<!--  -->
<welcome-file-list>
<welcome-file>index.html</welcome-file>
<welcome-file>index.htm</welcome-file>
<welcome-file>index.jsf</welcome-file>
</welcome-file-list>
</web-app>

Já o ManagerBean está assim configurado no faces-config.xml:

<?xml version="1.0" encoding="UTF-8"?>
<faces-config version="1.2" xmlns="http://java.sun.com/xml/ns/javaee"
xmlns:xi="http://www.w3.org/2001/XInclude"
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-facesconfig_1_2.xsd">
<managed-bean>
<managed-bean-name>regiaoControl</managed-bean-name>
<managed-bean-class>com.clubs.control.RegiaoControl</managed-bean-class>
<managed-bean-scope>request</managed-bean-scope>
</managed-bean>
<navigation-rule>
<display-name>autocomplete</display-name>
<from-view-id>/autocomplete.jsp</from-view-id>

</navigation-rule></faces-config>

Veja abaixo o manager bean terá um método chamado autoCompletePais que receberá um parametro do tipo Object e retorna um ArrayList do tipo Pais.

public ArrayList<pais> autoCompletePais(Object o){
return rdao.getAllPais( o.toString() );
}

E por fim, o arquivo autocomplete.jsp, que foi mapeado no faces-config, mostrará como é simples utilizar o recurso SuggestionBox do pacote RichFaces e fazer um auto-completar com diversos recursos, acima de tudo bonito e eficaz no dia-a-dia, veja:

<%@ taglib uri="http://java.sun.com/jsf/html" prefix="h"%>
<%@ taglib uri="http://java.sun.com/jsf/core" prefix="f"%>
<%@ taglib uri="http://richfaces.org/a4j" prefix="a4j"%>
<%@ taglib uri="http://richfaces.org/rich" prefix="rich"%>

<f:view>
<h:form>
<rich:panel>
<f:facet name="header"><h:outputText value="Digite o Pais:"/></f:facet>
<h:inputText value="#{regiaoControl.pais.nome}" id="campo" />
<rich:suggestionbox height="150"
width="150"
for="campo"
fetchValue="#{campo.nome}"
suggestionAction="#{regiaoControl.autoCompletePais}"
var="campo">
<h:column>
<h:outputText value="#{campo.id_pais}"/>
</h:column>
<h:column>
<h:outputText value="#{campo.nome}"/>
</h:column>
</rich:suggestionbox>
</rich:panel>
</h:form>
</f:view>

Veja o resultado final, tornando a utilização do software mais agradável.

AJAX (Asynchronous JavaScript and XML) é uma técnica simples aplicada em ambiente de internet que utiliza apenas JavaScript e XML, possibilitando ao desenvolvedor criar funcionalidades mais ricas, daí o famoso RIA (Rich Internet Application). É possível usar AJAX em qualquer linguagem dinâmica de internet que suporte XML, como PHP, ASP, J2EE, .NET, etc.  A diferença realmente está nos navegadores de internet, que utilizam o componente chave XMLHttpRequest cada um a sua maneira.

O processo é feito de maneira simples, o XMLHttpRequest  faz uma chamada assíncrona por XML a uma outra página oculta aos olhos do usuário. Esta página oculta por sua vez devolve as informações processadas ao XMLHttpRequest, também via XML, e utilizando JavaScript é feito o parse do XML e exibido o resultado na página principal, que originou a chamada.

Para obter o XMLHttpRequest, eh comum a utilização deste bloco JavaScript

if( window.XMLHttpRequest ){ // Firefox, Safári, etc.
xmlReq= new XMLHttpRequest();
}else  if( window.ActiveXObject ){ // Se for IE – ActiveX version
xmlReq = new ActiveXObject(“Microsoft.XMLHTTP”);
}

Existem outras maneiras para obter o componente, cada programador decide pelo mais conveniente, veja este outro exemplo:

try{
xmlReq = new ActiveXObject(“Microsoft.XMLHTTP”); // IE
}catch(e){   // Falhou, para os normais
xmlReq = new XMLHttpRequest();
}

Após obter o XMLHttpRequest, vamos fazer a comunicação com um XML e exibir seu conteúdo, e tudo isso usando apenas JavaScript.

// faz a chamada no servidor da página dinâmica, responsavel por devolver o XML response
// o primeiro parametro indica se a chamada será via GET ou POST
// o segundo informa qual é a página, e por último se será uma chamada assíncrona
xmlReq.open(“GET”, “http://localhost/ajax/response.php”, true);

xmlReq.onreadystatechange=function(){
if( xmlReq.readyState < 4 ){
// Enquanto é aguardado o retorno, pode-se exibir uma mensagem
}else{
if( xmlReq.readyState == 4 ){
// Aqui é colocado o processo de parser do XMLResponse.
}
}
}// end OnReadyStateChange
xmlReq.send(null); // transporte

Vejam que a primeira ação é chamar a página “oculta”, responsável por retornar o XML com os dados necessário.

O readyState indica qual o nível do processamento, esses são os estados: 1 – Sendo enviado; 2 – Processando; 3 – Armazenando e 4 – Pronto. É possível utilizar a propriedade status do XMLHttpResponse, esta por sua vez indica o status da página que foi chamada, ou seja, se ocorreu algum erro ou não.

That`s all! Simples não? É assim que funciona o famoso AJAX, nada mais além disso, os recursos de JavaScript são utilizados ao extremo. Atualmente existem recursos extremamente avançados e mais seguros que este exemplo, mesmo assim é válido o entendimento do mecanismo utilizado nesses frameworks e esclarecer o funcionamento do AJAX.

Você pode fazer aqui o download de um exemplo simples, porém muito útil em formulários de cadastro, onde três dropdowns (País, Estado e Cidade) interdependentes, que ao fazer o reload da página para carregá-los é muito cansativo. Vale ressaltar que utilizei PHP para a construção deste pequeno tutorial, acabando como mito de que AJAX está vinculado a Java/.Net.

Ambiente

PHP 5 e MySQL 5, rodando em Windows XP, IE 6 e 7 e Firefox 2.

Desafio

Talvez você tenha idéia melhores para aplicar o AJAX depois de entendê-lo e, eu não me surpreenderia com isto, então faço aqui um desafio para estimular o aprendizado: crie um Auto-Completar! Você é capaz?!

Eu aprendi um pouco com esta história, aprendi que as empresas muitas vezes não estão preocupadas quão bom será o seu código, ou ainda qual o seu nível de conhecimento sobre a plataforma de desenvolvimento utilizada. Conhecer o ambiente, quais as possibilidades de evolução dele, a aceitação de mercado, e vou mais afundo a portabildiade, segurança e velocidade consideradas por especialistas são de extrema importância para um desenvolvedor, e não apenas “Leia e Faça”.

Calma lá, ou muita calma nessa hora! :)
Não quero ser polêmico e chato neste primeiro post, portanto deixaremos minhas opiniões a parte e vamos ao que interessa.

Muitas pessoas quando iniciam seus estudos no mundo Java ficam espantados com a quantidade de siglas, e realmente é uma sopa de letrinhas quase que inesgotável, mas como estamos aqui para esclarecer e não complicar ainda mais, vamos lá. Abaixo listei algumas siglas junto a um breve resumo.

JVM – Java Virtual Machine
Máquina Virtual Java, responsável por carregar os programas e fazer a conversão do bytecodes em Linguagem de Máquina, definida para cada estrutura de Sistema Operacional. Aqui está um dos grandes diferenciais do Java comparado a outros linguagens, o programa não se limita ao SO já que a JVM faz a conversão.

JRE – Java Runtime Environment
Composto pela JVM e Bibliotecas Java para execução de programas em tempo real.

JSE – Java Standard Edition
Ambiente com a estrutura básica necessária para criação de programas Java, contém a JVM, o compilador e as bibliotecas Java necessárias.

JEE – Java Enterprise Edition
Assim como JSE, o JEE é uma edição do ambiente Java para desenvolvimento de programas, porém, com número de recursos superior, permitindo o desenvolvimento em multicamadas, componentes distribuídos, ambientes de internet, etc.

JME – Java Micro Edition
Edição do Java voltado para dispositivos capacidade de memória compacta, tais como: Celulares, PDAs, e muitos outros dispositivos.

JSDK – Java Standard Development Kit
Contém o JRE, JSE, os fontes das classes Java e o JavaDoc, com isto, fornecendo o ambiente para desenvolvimento e execução de programas Java.

JAVA_HOME
É o nome da variável de sistema operacional que contém o caminho de instalação do JSDK. Uma boa prática que deve ser seguidas por todos bons programadores.

CLASSPATH
É o nome da variável de sistema operacional que contém o caminho das bibliotecas nativas do Java ou de terceiros para a compilação e execução de programas Java.

EJB
Enterprise JavaBeans, componente JEE que fica no container do Servidor de Aplicação, auxilia no desenvolvimento de aplicações distribuídas, transacionais de forma segura e ágil.

Obviamente que foram listados pouquissimos termos aqui talvez você tenha ouvido falar em Design Pattern, JSF, JFX, Tomcat, JBoss, e nem saiba que raios isto significa!Fique tranquilo ao longo do tempo iremos discutir mais sobre eles.

Data Access Object é um padrão da camada de integração para recuperação de dados, independente da fonte, ou seja, podem ser utilizadas vários data sources da mesma forma deixando totalmente transparente para a aplicação.

Abstração é ponto importante do pattern, algumas pessoas acabam complicando, fazendo com que sejam criadas muitas classes sem necessidade, o próprio site da Sun não é muito didático.

Enfim, o embasamento deste post refere-se ao Blog do Beyond e no artigo do Davi Lucas no JavaFree.