Introdução ao EntityManager

Na nova Java Persistence specification, o EntityManager é o serviço central para todas as ações de persistência. Entidades são objetos de Java claros que são alocados como qualquer outro objeto Java. Eles não ficam persistentes explicitamente até seu código interagir com o EntityManager para os fazer persistente. O EntityManager administra o O/R que o mapea entre uma classe de entidade e uma fonte de dados subjacente. O EntityManager provê APIs para criar consultas, buscando objetos, sincronizando objetos, e inserindo objetos no banco de dados. Também pode prover caching e pode administrar a interação entre uma entidade e serviços transacionais em um ambiente Java EE como JTA. O EntityManager é firmemente integrado com Java EE e EJB mas não é limitado a estes ambientes;  pode ser usado em programas de Java SE.

 

Persistence Contexts

Começaremos através de uma introdução das condições do core do JPA. Uma unidade de persistência ou persistence-unit é uma configuração nomeada de classes de entidade. Um contexto de persistência é um gerenciamento de Entidades onde, todo contexto de persistência é associado com uma unidade de persistência. Entendendo o contexto de persistência é a chave para entender o EntityManager. Uma inclusão de entidade ou exclusão de um contexto de persistência, determinarão no resultado de qualquer operações persistentes nisto.

 

Se o contexto de persistência participa em uma transação, que está na memória,

o estado das entidades gerenciadas será sincronizado ao banco de dados. Ainda apesar do papel importante que faz, o contexto de persistência nunca é realmente visível à aplicação. Sempre é acessado indiretamente pelo entity manager e assumido que estar lá quando nós precisarmos dele.

 

Persistence Unit

Um EntityManager mapea um conjunto de classes a um banco de dados particular. Este conjunto de classes é chamado de persistence unit (unidade de persistência).

 

Antes de você poder pensar até mesmo em criar ou consultar entidades com um entity manager, você tem que aprender a empacotar uma unidade de persistência para uso, dentro de um ambiente  Java SE ou Java EE.

 

Uma unidade de persistência está definida em um arquivo chamado persistence.xml. Este arquivo é um descriptor de desenvolvimento exigido no JPA. Um arquivo de persistence.xml pode definir um ou mais unidades de persistência. Este arquivo fica situado no diretório META-INF em:

 

Ambientes SE, esta pasta fica no classpath da aplicação. Em uma aplicação web, este diretório fica localizado nas pasta WEB-INF\classes\META-INF

 

Segue um exemplo de um arquivo persistence.xml:


Listagem 01.

<?xml version=”1.0″ encoding=”UTF-8″?>

<persistence version=”1.0″ xmlns=”http://java.sun.com/xml/ns/persistence&#8221; xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance&#8221; xsi:schemaLocation=”http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd”&gt;

  <persistence-unit name=”novoExemploPU” transaction-type=”RESOURCE_LOCAL”>

    <provider>oracle.toplink.essentials.ejb.cmp3.EntityManagerFactoryProvider

    </provider>

    <class>teste.Empresas</class>

    <class>teste.Cartoes</class>

    <properties>

      <property name=”toplink.jdbc.url” value=”jdbc:mysql://localhost:3306/devmedia”/>

      <property name=”toplink.jdbc.user” value=”root”/>

      <property name=”toplink.jdbc.driver” value=”com.mysql.jdbc.Driver”/>

      <property name=”toplink.jdbc.password” value=”123456″/>

    </properties>

  </persistence-unit>

</persistence>

 

Você deve especificar suas classes de Entidades dentro no arquivo persistence.xml(persistence unit). Como mostradado na listagem 01 em negrito.

 

Vamos analizar como obter acesso de um EntityManager,  para poder inserir, atualizar,  remover e consultar um bean de entidade no seu bancos de dados. Embora você possa usar uma interface de fábrica em Java EE, esta plataforma provê algumas características adicionais que fazem isto mais fácil e menos áduo de administrar instancias de EntityManager.

EntityManagerFactory

EntityManagers podem ser criado ou podem ser obtidos de um EntityManagerFactory. Em uma aplicação Java  SE, você tem que usar um EntityManagerFactory para criar instancias de um EntityManager. Usar o factory não é uma exigência em um ambiente Java EE.

 

Obtendo um EntityManagerFactory em um ambiente Java SE.

Em um ambiente Java SE, a classe javax.persistence.Persistence é responsável por amarrar um EntityManagerFactory.


Listagem 02.

public class Persistence {

   public static EntityManagerFactory createEntityManagerFactory(

           String unitName

   );

   public static EntityManagerFactory createEntityManagerFactory(

           String unitName,

           java.util.Map

 properties

   );

A classe javax.persistence.Persistence procura descriptors da distribuição  persistence.xml dentro de seu classpath de Java. O parâmetro do unitName que você passa dentro permitirá que a execução da persistencia encontre um EntityManagerFactory que combine o nome dado.

 

EntityManagerFactory factory = Persistence.createEntityManagerFactory(“novoExemploPU”);

factory.close( );

 

Em Java EE, obter um EntityManagerFactory. Pode ser injetado diretamente em um campo ou em um método setter do seu EJBs usando a anotação @javax.persistence.PersistenceUnit

 

Listagem 03.
import javax.persistence.*;

import javax.ejb.*;

 

@Stateless

public MyBean implements MyBusinessInterface {

 

   @PersistenceUnit(unitName=”novoExamploPU”)

   private EntityManagerFactory factory;

 

   private EntityManagerFactory factory2;

 

   @PersistenceUnit(unitName=”novoExemploOutroDB”)

   public void setFactory2(EntityManagerFactory f) {

      this.factory2 = f;

   }

 

Conclusões
Fizemos uma breve introdução a alguns conceitos dentro do JPA como tecnologia utilizada na camada de persistência. Nos próximos artigos irei falar mais sobre mais funcionalidades do framework. Bom, é isso ! Qualquer dúvida fique a vontade para fazer contato e trocar algumas idéias 😉

 

Referências

Enterprise JavaBeans 3.0 5ª Edição – http://www.oreilly.com/catalog/entjbeans5/

Autor:

Wendell Miranda Sacramento (wendellmiranda@gmail.com) Trabalha desde 2003 com Java tendo como experiência desenvolvimento de sistemas web na plataforma Java EE. Atualmente trabalha no desenvolvimento de soluções para a segurança pública do estado do Amapá no Processamento de Dados do Amapá – PRODAP.

Arquitetura MVC em PHP

Olá Pessoal,

Bem, hoje neste primeiro artigo falaremos sobre um assunto que ainda falta na maioria dos programadores PHP, eu mesmo já passei pela situação, não por querer, mas acredito que por falta de informação e por falta de procura por parte de nós.

Uma coisa que percebo em muitos programadores PHP é a falta de preocupação quanto a questões de padrões e organização de código, esses quesitos são essencias para uma aplicação sólida e com grande escalabilidade (facilidade de expansão). Acredito que isso se deve ao fato de o PHP ser uma linguagem muito “livre” que permite que os programadores não se preocupem com questões que um programador Java já tem no sangue, por exemplo.

Enfim, sem mais ladainhas, falaremos hoje sobre a arquitetura MVC. Este artigo terá uma visão mais conceitual do que prática, contudo tentarei exemplificar os fatos com alguns códigos e algumas indicações. Gostaria de acrescentar que se faz por necessário um conhecimento, mesmo que básico, de OO.

O conceito MVC (Model View Controller) na tradução é: Modelo, Visão e Controle.

Alguns devem estar se perguntando: Mas que diabos é Modelo, Visão e Controle?

Vamos lá…

Visão: É a camada de visualização da sua aplicação, onde ela apenas apresenta o que foi obtido através do controle. Eu diria que seria que é o que chega ao usuário final, a parte visual, de interface. A visão não deve ter nenhuma lógica de código, apenas a exibição dos dados.

Controle: É onde serão processadas todas as requisições feitas através da interface (Visão). O controle também acessa o Modelo afim de obter determinadas informações. Toda lógica da aplicação (validações, atribuições, etc) é feita no Controle. Eu diria que o controlle é o gerenciador da sua aplicação.

Modelo: É o modelo da sua aplicação, onde são definidos propriedades e atributos dos seus personagens. Na maioria dos casos existe ainda uma camada de persistência dos dados (DAO usa isso, falaremos sobre DAO nos próximos artigos), mas excepcionalmente neste artigo a nossa persistência será feita no Modelo.

Após explicado quem é quem nesse tal de MVC, vamos através de exemplos práticos ilustrar algumas situações.

Imagem o seguinte cenário: Uma aplicação que deva fazer a inserção, edição, remoção e listagem de usuários.

Algo bem simples, mas que servirã para exemplificar como poderíamos usar o MVC.

Então vamos a a nossa camada de visualização (View) para listagem de usuários:

View.php

<?php require_once("Controller.php"); ?>

<?php $c = new Controller();   ?><h3>Listagem de Usuários</h3>

<br><br>

<table cellspacing="0" cellpadding="0" border="0">

    <tr>

      <td width="100">ID</td>

      <td width="200">Nome</td>

      <td width="200">sobrenome</td>

      <td width="200">Email</td>

    </tr>

<?php

for ($i = 0; $i < count($c->users); $i++) {

?>

<tr>

      <td width="100"><?php echo $c->users[$i]->id;?></td>

      <td width="200"><?php echo $c->users[$i]->name;?></td>

      <td width="200"><?php echo $c->users[$i]->lastname;?></td>

      <td width="200"><?php echo $c->users[$i]->email;?></td>

</tr>

<?php

}

?>

</table>

Agora vamos para a nossa classe de controle. A mesma tera apenas o trabalho de carregar os usuários para a nossa classe de visualização através do nosso modelo de usuários.

Controller.php

<?php

require_once("UsersModel.php");

require_once("ConnectDB.php");Class Controller

{

 var $users;

function Controller ($action = null) {

 	if (empty($action)) {

    		$this->users = new Users();

 		$this->users = $this->users->loadAll();

    		}

   		}

}

?>

Agora vamos a nossa classe Modelo, teremos um modelo de usuários (personagem em questão). Poderíamos ter um modelo de carros, aviões, animais, etc.

UsersModel.php

<?php

Class Users {

  var $id;

  var $name;

  var $lastname;

  var $email;function getId () {

    return $this->id;

  }

function setId ($id) {

    $this->id = $id;

  }

function getName () {

    return $this->name;

  }

function setName ($name) {

    $this->name = $name;

  }

function getLastname () {

    return $this->lastname;

  }

function setLastname ($lastname) {

    $this->lastname = $lastname;

  }

function getEmail () {

    return $this->email;

  }

function setEmail ($email) {

    $this->email = $email;

  }

function loadAll () {

   $query = "SELECT *

 	  	      FROM users

 	 	        ORDER BY name ASC";

   $result = pg_query($query);

while ($array = pg_fetch_array($result)) {

 		$user = new Users();

 	  $user->setId($array['uid']);

 	  $user->setName($array['name']);

 	  $user->setLastname($array['lastname']);

 	  $user->setEmail($array['mail']);

 	  $userArr[] = $user;

   }

return $userArr;

  }

}

?>

Bem, como vocês viram, o que a metodologia MVC sugere é justamente organização, onde camada fica responsável pelo que ela realmente deve fazer.

No próximo artigo, tratarei a inserção de usuários usando estes mesmos controles e modelos.

Aproveitando também para indicar alguns links:

MVC (Wikipedia) – http://pt.wikipedia.org/wiki/MVC
Code Igniter (Excelente framework MVC/PHP) – http://www.codeigniter.com

Espera que tenham gostado, caso tenha dúvidas, entre em contato

Autor:

Marcus Cavalcanti

Professional PHP que atua no desenvolvimento avançado de aplicações de web há 5 anos. Atualmente também trabalhando com Java na plataforma JEE.

Tutorial de JSP

1 – Instalação do TomCat.

A instalação do TomCat e bastante simples, basta clicar em Next…..Next…..Next…finish e tudo estará pronto. Suponho que você já tenha instalado o JDK em sua maquina.

2 – Configurando as variáveis de ambiente.

Configure as variáveis de ambiente.

É necessário que estas 4 variáveis de ambiente estejam corretamente inseridas. Onde :

Após sua instalação vá no menu iniciar e start o mesmo ou vá em “C:\Arquivos de programas\Apache Tomcat 4.0\bin\startup.exe” este caminho esta no meu computador. Teste o mesmo, onde deve aparecer a seguinte tela.

image002.gif

3 – Criando uma pasta virtual.

Crie uma pasta virtual para que nosso exemplo seja testado.

No explorer, crie uma pasta denominada: C:\testeJSP é nesta pasta que vai estar o arquivo jsp. Pode estar em vários locais, o mais usual e deixar “dentro” do TomCat, mas a titulo de exemplo ficará com estas configurações.

4 – Editando o arquivo server.xml

Este arquivo é utilizado para que possamos “dizer” para o TomCat onde estará nossa aplicação. A sua localização é: C:\Arquivos de programas\Apache Tomcat

image004.gif

@ CLASSPATH tem em seu final a adição do local de instalação do TomCat até o arquivo “servlet.jar”.

@ CATALINA_HOME tem a localização até a pasta “Apache Tomcat 4.0.

@ JAVA_HOME localização do jdk.

PATH = C:\j2sdk1.4.2_06;C:\j2sdk1.4.2_06\lib;C:\j2sdk1.4.2_06\bin;.;%PATH%

CLASSPATH = C:\j2sdk1.4.2_06;C:\j2sdk1.4.2_06\lib;C:\j2sdk1.4.2_06\bin;.;C:\Arquivos de programas\Apache Tomcat 4.0\common\lib\servlet.jar

CATALINA_HOME = C:\Arquivos de programas\Apache Tomcat 4.0

JAVA_HOME = C:\j2sdk1.4.2_06


Portal Java Tutorial: JSP e Tomcat Step-by-step porWilhans C. Silva

4.0\conf\server.xml abra este arquivo e vá acima da linha

5 – Escrevendo um Arquivo Ola.jsp

Vamos escrever o arquivo jsp que será apresentado pelo browser através do TomCat.

Vá ao bloco de notas ou no Eclipse……ou qualquer outro e edite o código jsp abaixo.

<%@page contentType=”text/html; charset=ISO-8859-1″%>

<html>

<head><title>Ola JSP </title></head>

<body>

Ola Mundo!

</body>

</html>

 

Salve com o nome de Ola.jsp (não precisa compilar) na pasta “c:\testeJSP”

Depois vá no browser e digite http://localhost:8080/teste/Ola.jsp e terá a seguinte resposta.

 

image006.gif

Tutorial de instalação do Apache/PHP em Windows

por Davi Shibayama

1. Introdução
Este breve tutorial tem por finalidade mostrar os passos para instalação e configuração do servidor Web Apache e da linguagem PHP em ambientes Windows 95/98/ME/XP, para desenvolvimento local. A maior parte dos procedimentos apresentados aqui são válidos também para sistemas Windows NT/2000, sendo que a única diferença está na maneira como o Apache é inicializado.
Muitos dos detalhes sobre as configurações destas duas ferramentas foram, propositalmente, omitidos, a fim de facilitar a compreensão.
É importante lembrar que, apesar do PHP/Apache executarem de maneira satisfatória em ambientes Windows, é recomendável que esta plataforma seja usada apenas para desenvolvimento, simulando o ambiente Unix/Linux original onde essas ferramentas devem realmente residir.2. Apache

2.1. Obtendo o Apache
O arquivo de instalação do Apache para Windows está disponível em três formatos: .ZIP, .EXE e .MSI. Trabalharemos aqui com este último, que está no formato de pacote do Windows Installer. Primeiramente, efetue o download do arquivo de instalação do Apache no seguinte endereço:

http://www.apache.org/dist/httpd/binaries/win32
.

Baixe o arquivo com extensão .msi. O arquivo deverá estar com o seguinte nome: apache_x.x.xx-win32-x86.msi, onde x.x.xx é a versão do software. Note que este arquivo é do tipo .msi (Microsoft Installer).
É recomendável baixar o arquivo de instalação neste formato pois ele, além de ser menor, é mais fácil de instalar e configurar. Atualmente (Abr/2002), a última versão do servidor Apache disponível no formato .msi é a 1.3.24. Para maiores informações sobre os arquivos de instalação do Apache, consulte a página de download citada acima.

Atenção usuários do Windows95!
Os usuários do Windows95 precisam primeiro baixar a atualização do Winsock para Windows, caso contrário, o Apache não funcionará. Esta atualização poderá ser obtida a partir do site da Microsoft, no seguinte endereço:

http://www.microsoft.com/windows/downloads/bin/W95ws2setup.exe

2.2. Instalando o Apache
Para efetuar a instalação a partir deste tipo de arquivo .msi, você deverá ter o utilitário Microsoft Windows Installer instalado no seu sistema. Os usuários do Windows2000, WindowsME e WindowsXP já possuem este utilitário instalado. Os usuário de outras versões do Windows deverão baixá-lo a partir do site da Microsoft, nos seguintes links:

  • Windows Installer v1.10 para Windows NT 4.0
  • Windows Installer v1.10 para Windows 95 e 98Após ter instalado o utilitário Microsoft Windows Installer, clique duas vezes no arquivo de instalação do Apache. Uma tela como esta deverá aparecer:


    Prossiga clicando no botão “Next”, aceitando os termos da licença de uso e, na tela de Informações do Servidor (“Server Information”), onde é solicitado “Network Domain“, “Server Name” e “Administrator’s Email Address“, informe, respectivamente: “localdomain“, “localhost” e o seu endereço de e-mail. Deixe também selecionado a opção “Run as a service for All users“, como indicado abaixo:


    Prossiga selecionando a instalação completa (“Complete”) e finalize a instalação.

    2.3. Iniciando e parando o Apache (somente em Windows95/98/ME/XP)
    Para INICIAR o servidor Web Apache, vá no botão Iniciar->Programas->Apache HTTP Server e clique em Start Apache in Console. Uma janela como esta deverá aparecer, indicando que o Apache está em execução:


    Para PARAR o Apache, não é aconselhável que se feche esta janela diretamente. Ao invés disso, vá em Iniciar->Programas->Apache HTTP Server e clique em Stop Apache. Isso dará inicio ao processo de shutdown do servidor Web, o que fará com que a janela acima se feche.

    Atenção usuários do Windows NT/2000!
    O Apache é instalado como um serviço em sistemas Windows NT e 2000 e, por isso, os procedimentos descritos acima, para iniciar e parar o Apache, NÃO se aplicam a essas plataformas. Use o gerenciador de serviços do Windows NT/2000, localizado no painel de controle, para controlar a execução do Apache.

    2.4. Testando a instalação do Apache
    Para testar a instalação, primeiramente, certifique-se de que o Apache esteja em execução. Abra o seu navegador favorito e digite o seguinte endereço: http://localhost. Este é o endereço do seu servidor web local.
    Uma página como esta abaixo deverá aparecer, indicando que você instalou e configurou corretamente o servidor Web Apache em seu sistema.

    IMPORTANTE: Se você não tiver alterado a pasta padrão de instalação do Apache, a pasta raiz do seu servidor web se encontra no seguinte caminho no seu disco:

    C:\Arquivos de programas\Apache Group\Apache\htdocs

    É nesta pasta que você deve colocar todos os arquivos que serão acessados através do seu servidor Web local, incluindo páginas HTML, scripts em PHP, arquivos de imagens, etc.

    3. PHP

    3.1. Obtendo o PHP
    Efetue o download do pacote com os arquivos do PHP para Windows, no seguinte endereço:

    http://www.php.net/downloads.php

    Baixe o arquivo no formato .ZIP, o qual já contém todas as extensões da linguagem. Atualmente (Abr/2002), a versão mais recente do PHP disponível para Windows é a 4.1.2 e o tamanho do seu pacote .ZIP está em torno de 5MB. Este arquivo zipado deverá ter o seguinte nome: php-x.x.x-Win32.zip, onde x.x.x é a versão da linguagem.
    Descompacte este pacote para uma pasta qualquer no seu disco. Vamos considerar que a pasta de destino dos arquivos seja C:\PHP.
    Após a descompactação, a estrutura de diretórios do PHP deve ficar como indicado na figura abaixo:

    3.2. Configurando o PHP
    Copie o arquivo php.ini-dist, que se encontra na pasta C:\PHP, para a pasta do Windows (geralmente C:\Windows). Renomeie-o para php.ini e em seguida abra-o. Localize o seguinte texto dentro deste arquivo: “extension_dir” e altere o valor desta entrada para o nome da pasta com os arquivos das extensões do PHP, que no nosso caso é “c:\php\extensions”. Após a alteração, esta seção do arquivo deverá parecer como a seguir:

    Salve e feche este arquivo.
    Copie também o arquivo php4ts.dll, que se encontra na pasta C:\PHP, para a pasta C:\Windows\System, no caso de Windows95/98/ME/XP, ou para a pasta C:\WINNT\System32, no caso de WindowsNT/2000.

    3.3. Configurando o Apache para trabalhar com o PHP
    Para que o servidor Web Apache possa reconhecer o PHP e redirecionar as páginas escritas nesta linguagem para o seu interpretador, precisaremos adicionar algumas configurações no arquivo de configuração do Apache, o httpd.conf, que está localizado na pasta \conf deste servidor Web. Se você não tiver alterado a localização padrão dos arquivos do servidor Web Apache durante a instalação, o caminho completo para este arquivo é o seguinte:

    C:\Arquivos de programas\Apache Group\Apache\conf\httpd.conf

    Adicione as seguintes linhas NO FINAL deste arquivo:

    AddType application/x-httpd-php .php
    LoadModule php4_module c:/php/sapi/php4apache.dll

    Salve este arquivo e, em seguida, pare e re-inicie o Apache. Na janela do Apache, deverá aparecer uma string indicando que o PHP foi carregado juntamente com o servidor Web, como indicado abaixo:


    Em plataformas Windows NT/2000, vá para a janela do gerenciador de serviços e pare e re-inicie o serviço do Apache. Nesta janela, no item correspondente à descrição do serviço do Apache, deverá ser exibido uma descrição semelhante a da indicada na figura acima.

    3.4. Testando a instalação do PHP
    Para testar a instalação do PHP, crie um arquivo qualquer com extensão .php (info.php, por exemplo) na pasta base do seu servidor Web Apache (htdocs) e, dentro dele digite o seguinte código:

    <? phpinfo(); ?>

    Salve-o e em seguida acesse-o através do servidor Web local, digitando o seguinte endereco no seu navegador (certifique-se de que o servidor Apache esteja em execução):

    http://localhost/info.php

    Uma tela com informações sobre a configuração do PHP deverá ser exibida, como indicado abaixo:


    Feito isto, a instalação e configuração básica do Apache e do PHP no Windows terá sido finalizada.

    4. Considerações Finais

    É extremamente aconselhável a leitura da sessão do manual do PHP que trata sobre a instalação e configuração, em:

    http://www.php.net/manual/en/installation.php

    Lá poderemos encontrar detalhes importantes, não citados aqui, acerca desse tema, não só em ambientes Windows, mas também em Unix, Linux, etc.
    Maiores informações poderão ser encontradas também nos sites oficiais destas ferramentas:

  • Apachehttp://httpd.apache.org/
  • PHPhttp://www.php.net/
  • Integrando JSF e CSS

    Felizmente, nós da comunidade Java, nos últimos anos temos sido presenteados com excelentes soluções para implementação do padrão MVC (Model View Cotroller), dentre essas soluções, podemos citar os framework’s: JSF, Struts, WebWork e Spring MVC cada um, com suas peculiaridades, fornecem com maestria, recursos que atendem às camadas específicas do próprio MVC.

     

    Neste pequeno artigo, iremos estudar alguns detalhes básicos da formatação da camada de visualização do JSF (Java Server Faces), pois iremos entender como aplicar folhas de estilos CSS (Cascading Style Sheets) em códigos com os renderizadores html do JSF, é importante que você veja nessa dobradinha, uma verdadeira oportunidade para maximizar a produtividade em seu projeto web, pois, como é mostrado na figura 01, através das folhas de estilos, ganhamos uma melhor organização e reusabilidade das definições visuais do projeto.   

     

    mpijsfcssfig01.JPG

    Figura 01. Exemplo de reusabilidade de um arquivo CSS.

     

    Um pouco de JSF

    Se você está lendo esse artigo, é porque talvez já tenha alguma familiaridade inicial com o JSF, portanto, verá que estamos usando, algumas taglib’s dos pacotes html e core, como mostrado na tabela 01:

     

    Pacote

    Tag

    Função

    Core

    <f:view>  </f:view>

    Container para todas as  tags core e tags de ações customizadas do JSF.

    Tabela 01.  TagLib’s usadas nesse artigo.

     

    Um pouco de CSS

    Para que você melhor entenda nosso exemplo, vamos fazer um breve passeio sobre o funcionamento do CSS, primeiro, lembre-se que essa tecnologia é uma linguagem de estilos, usada para descrever a apresentação de um documento padrão  web, escrito em uma linguagem de marcação como HTML, XHTML, ou XML, fazendo com que tais documentos web ganhem formatos visuais mais elegantes, reusáveis e  sistêmicos.

     

    O principal mecanismo de funcionamento do CSS, são as Rules-Sets, que definem os possíveis estilos  de um conteúdo.

     

    Uma Rule-Set,  é  composta um seletor  e um bloco de declaração entre um par de  chaves {….},  ambos representados  conforme a sintaxe da listagem 01:

     

    seletor {

            propriedade:  valor;

    }

    Listagem 01 – Exemplo de Rule-Set

     

    Tipos de seletores CSS

    Conforme mostra a Tabela 02, existem várias formas de especificar esses seletores, cada um, tem sua importância e aplicação, não é obrigatório o uso de todos esses seletores, portanto, atente para quando será mais indicado o uso de cada tipo de seletor.

     

    Tipo de Seletor

    Descrição

    Sintaxe

    Elemento

    Especifica o nome de um elemento HTML que receberá o estilo e questão.

    elemento {

        Bloco de declaração;

    }

    Elementos Múltiplos

    Define o nome de vários elementos HTML que receberão as informações de estilo.

    elemento1,elemento2 {

       Bloco de declaração;

    }

    Universal

    Através de um asterisco, determina que  todos os elementos de um documento receberão as definições.

    * {

       Bloco de declaração;

    }

    Elementos adjacentes

    Seleciona um elemento somente quando estiver imediatamente após o outro.

    elemento1+elemento2{

       Bloco de declaração;

    }

    Elementos-filho

    Elementos contidos em outros elementos

    elemento1>elemento2{

       Bloco de declaração;

    }

    Classes

    Será definido no atributo CLASS de um elemento HTML. Para isso ocorrer, basta criar um CLASS nas definições de estilo, e depois associar essa classe a um elemento.

    .nome da classe {

         Bloco de declaração;

    }

    ID

    Deve ser semelhante ao atributo ID de um elemento HTML,  para isso, basta em um elemento HTML, colocar seu ID como mesmo nome do elemento CSS. 

    #ID do elemento {

         Bloco de declaração;

    }

    Tabela 2.

     

    Aplicação Exemplo

    Agora, criaremos um projeto WEB, onde conterá uma página JSF, e um arquivo CSS devidamente distribuídos conforme mostra a figura 02.

     

    mpijsfcssfig02.JPG 

    Figura 02 – Estrutura de Projeto e o local do arquivo CSS.

     

    Como você pode observar, dentro do diretório css, há um arquivo chamado estilos.css, nele, conforme mostra a listagem 02, temos as definições de folhas de estilos que iremos usar em nosso código JSF.

     

    *{

        /*Define  que todos os elementos da página, ficarão em negrito e com a fonte arial */

        font-weight: bold;

        font-family: arial;

        /*Define a tamanho da fonte para todos os elementos */

        font-size: 10px;

    }

     

     

    .edit {

        /*Define a borda do elemento, com um efeito de baixo-relevo menor que o padrão */

        border: 1px inset;

        /*Especifica a cor cinza, como pano de fundo do elemento */

        background-color: #D3D3D3;

        /*Especifica como preta a  cor da fonte do elemento */

        color: #000000;

    }

     

     

    .botoes {

        /*Especifica a cor chocolate, como pano de fundo do elemento */

        background-color: #D2691E;

        /*Especifica como preta a cor da fonte do elemento */

        color: #FFFFFF;

        /*Define a borda do elemento, com um efeito de alto-relevo menor que o padrão */

        border: 1px outset;

    }

     

    .rotulos {

        /*Especifica preta a cor da fonte do elemento */

        color: #000000;

    }

     

     

    legend{

        /*Define a tamanho da fonte para a legenda do FieldSet */

        font-size: 12px

    }

    Listagem 01   Conteúdo do arquivo estilos.css

     

    Como você observou, na listagem 01, temos  vários seletores do tipo classe,  que serão referenciados no atributo styleClass, das tags JSF, dessa forma, estaremos vinculando as definições de estilos, aos elementos pertencentes à página web do projeto,  portanto conforme você viu acima na figura 02, precisamos em nosso exemplo de um arquivo chamado exemploFormulario.jsp, que contém o pequeno exemplo de código JSF trabalhando com CSS.

     

    <%@page contentType=”text/html”%>

    <%@page pageEncoding=”UTF-8″%>

     

    <%@taglib prefix=”f” uri=”http://java.sun.com/jsf/core”%&gt;

    <%@taglib prefix=”h” uri=”http://java.sun.com/jsf/html”%&gt;

     

    <!DOCTYPE HTML PUBLIC “-//W3C//DTD HTML 4.01 Transitional//EN”

    http://www.w3.org/TR/html4/loose.dtd”&gt;

    <html>

        <head>

            <meta http-equiv=”Content-Type” content=”text/html; charset=UTF-8″>

            <title>Formulário JSF com CSS</title>

            <!–Chamada ao arquivo CSS –>

            <link rel=”StyleSheet” type=”text/css” href=”css/estilos.css” media=”screen” >

        </head>

        <body>

            <f:view>

                <h:form>

                    <fieldset>

                        <legend>Dados</legend>

                        <!–Tag JSF, com o atributo styleClass referenciado o seletor CSS específico  –>                   

                        <h:outputText value=”Nome:” styleClass=”rotulos”/><br>

                        <h:inputText id=”edtNome” value=”” styleClass=”edit” size=”60″ /><br>

                        <h:outputText value=”RG:” styleClass=”rotulos”/><br>

                        <h:inputText id=”edtRG” value=”” styleClass=”edit” size=”20″ /><br>

                        <h:outputText value=”CPF:” styleClass=”rotulos”/><br>

                        <h:inputText id=”edtCPF” value=”” styleClass=”edit” size=”30″ /><br>

                        <h:outputText value=”E-mail:” styleClass=”rotulos”/><br>

                        <h:inputText id=”edtEmail” value=”” styleClass=”edit” size=”50″ /><br><br>

                        <hr>

                        <h:commandButton value=”Gravar” type=”submit” styleClass=”botoes”/>

                        <h:commandButton value=”Limpar” type=”reset” styleClass=”botoes”/>

                    </fieldset>

                    <br>

                </h:form>

            </f:view>

        </body>

    </html>

    Listagem 02.

     

    Perfeito, se tudo foi feito corretamente, e principalmente, seus arquivos web.xml e faces-config.xml estejam bem configurados, rode seu projeto pelo seu container (estou usando o TomCat 5.5.17)  e você terá uma página semelhante ao mostrado na figura 03, devidamente formatada visualmente pelo arquivo estilos.css.

     

    mpijsfcssfig03.JPG

    Figura 03.  Tela gerada pelo formulário JSF com CSS.

     

    Conclusões

    Neste pequeno artigo, estudamos o uso da tecnologia CSS  em projetos com o framework JSF, portanto, focamos o básico dessa integração,  claro, que suas possibilidades de aplicação  são muito maiores, portanto, em nosso próximo artigo sobre esse assunto, será abordado  o uso de folhas de estilos, em tags dataTables do JSF.

     

    Até a Próxima.

     

    Referências

    SACRAMENTO, Wendell Miranda,  Artigo JavaServer Faces a primeira vista

    http://www.devmedia.com.br/articles/viewcomp.asp?comp=4394&hl=JSF

     

    Excelente site sobre CSS e WebStandards

    http://www.maujor.com/

    Sobre o Autor:

    Manoel Pimentel Medeiros (manoelp@gmail.com), é engenheiro de software trabalha atualmente na Rhealeza Informática(SP) com projetos em Java, entre outras atividades, se dedica a Coordenação do Grupo de usuários de extreme programing da região norte – XPNorte e do NUG-BR(NetBeans Users Group – Brasil), além de ser colunista do portal e revista JavaMagazine. Possui as certificações: Scrum Master, Java e Delphi da Brainbench.

    JavaServer Faces a primeira vista

      Saudações Java!

     

    Talvez você já tenha ouvido falar em JavaServer Faces e ainda não tem nenhum contato com este Framework da Sun Microsystems. Neste artigo irei mostar como utilizar JSF através de uma configuração manual, ou seja, sem o uso de IDE. Assim, você saberá exatamente aonde está mexendo e que arquivo deve manipular, mas isto não lhe empede de utilizar alguma IDE como o NetBeans IDE, pois ele já faz isto de forma automática.

     

    JavaServer Faces (JSF), é uma tecnologia de Java do mundo EE(Enterprise Edition), é projetado para simplificar o desenvolvimento de aplicações Web. JSF é utilizado  para construir interface do usuário e páginas, e conectar esses componentes a objetos de negócio de forma mais elegante e fácil. Também automatiza o processo no uso de JavaBeans e navegação de páginas.

     

    Por que JavaServer Faces?

    No contexto de aplicações Web, a aparência é determinada pelas TAGS HTML que específicam o layout. A lógica de negócios é implementada no código Java, onde determina o comportamento da aplicação.

     

    Algumas tecnologias web, misturam HTML e código do negócio. Isto parece atraente por tornar fácil a produção de aplicações simples em um único arquivo, mas para aplicações sérias, misturar HTML e código, cria problemas consideráveis.

     

    Quando você utiliza JavaServer Faces, você já está usando um padrão muito famoso chamado Model-View-Controller onde Faces separa a lógica de negócios da visualização e requisição. O model sendo seus JavaBeans, a visualização ou apresentação seria as JSPs utilizando as EL expression language e por fim o Controlador sendo o seu sistema de navegação, onde a navegação entre suas páginas é toda mapeada.

     

    JavaBeans

    JavaBean é uma classe que expõe propriedades( atributos ) e eventos(métodos) a um ambiente como JSF.

     

    Uma propriedade é um valor nomeado de um determinado tipo que pode ser lido e/ou escrito. O modo mais simples para definir uma propriedade é usar uma convenção de nomeclatura padrão para leitura e escrita de métodos, isto é, a convenção de get/set.

     

    A primeira letra do nome da propriedade é mudada para maiúscula dentro nome do método.

     

    Ex:

    private String nome;

     

    public String getNome(){

    return nome;

    }

    public void setNome( String nome ){

    this.nome = nome;

    }

     

    JSF Pages

    Para a criação de páginas que utilizam JSF como framework, você deve utilizar páginas com a extenção .jsp e na chamada do navegador utilizar:

    http://localhost:8080/jsfapp/index.jsf

    http://localhost:8080/jsfapp/index.faces

    http://localhost:8080/jsfapp/faces/index.jsp

     

    Isto depende de como você irá configurar o web.xml de sua aplicação. Para o exemplo que irei mostrar, vou utilizar a configuração para acessar a aplicação com a extenção .jsf.

     

    Suas páginas devem iniciar com a declaração da biblioteca de tags.

    <%@ taglib uri=”http://java.sun.com/jsf/core&#8221; prefix=”f” %>

    <%@ taglib uri=”http://java.sun.com/jsf/html&#8221; prefix=”h” %>

     

    Você precisa do f:view  tag para renderizar suas páginas. E a HTML tag para inserir componentes html em sua página.

     

    Ex:

    <%@ taglib uri=”http://java.sun.com/jsf/core&#8221; prefix=”f” %>

    <%@ taglib uri=”http://java.sun.com/jsf/html&#8221; prefix=”h” %>

    <f:view>

    <h:outputText id=”hello” value=”Welcome !!!” />

    </f:view>

     

    Requerimento

    Ok, para começar a desenvolver aplicativos web com JSF, você precisa dos seguintes pacotes:

    Java SDK 1.4.1 ou posterior (http://java.sun.com/j2se).

    Um containter servlet: Apache Tomcat (http://jakarta.apache.org/tomcat/).  Você pode rodar aplicações JSF com qualquer container servlet que tem suporte especificações Servlet 2.3 e JSP 1.2.

    JavaServer Faces reference implementation (http://java.sun.com/j2ee/javaserverfaces )

     

    Assumiremos que você já instalou o Java SDK e que já está familiarizado com as ferramentas do SDK. Portanto, irei apenas repassar como instalar o Tomcat.

     

    Após ter baixado o tomcat, descompacte-o por exemplo em:

    C:\apache-tomcat

     

    Para inicializar o Tomcat, utilizando o windows execute o arquivo startup.bat localizado no diretório /bin do Apache Tomcat. Para testar se o tomcat está rodando, acesse: figura 01 http://localhost:8080

    jsfprimvistafig01.JPG

    Figura 01. Tela de inicialização do Tomcat

     

    Pronto! Para desligar o servidor basta você executar o arquivo shutdown.bat localizado no diretório /bin.

     

    Exemplo: Enviando E-mails com Autenticação de usuário com JavaServer Faces.

    Neste exemplo irei abordar algumas funcionalidades de JSF, utilizando o envio de e-mail onde você irá se autenticar no seu servidor de e-mail.

     

    Configurando a aplicação

    Dentro da pasta webapps do tomcat, crie uma pasta chamada jsfapp onde essa será o contexto da nossa aplicação.

     

    A estrutura do diretório vai ficar assim:

    C:\jakarta-tomcat\webapps\jsfapp -> NOSSA APLICAÇÃO, PAGES

    C:\jakarta-tomcat\webapps\jsfapp\WEB-INF -> NOSSOS ARQUIVOS DE CONFIGURAÇÃO

    C:\jakarta-tomcat\webapps\jsfapp\WEB-INF\classes -> NOSSAS CLASSES

    C:\jakarta-tomcat\webapps\jsfapp\ WEB-INF\lib -> NOSSA BIBLIOTECA DE TAGS

     

    Adicionaremos os seis JSF jar’s e os dois JSTL jar’s na pasta lib da nossa aplicação.

     

    commons-beanutils.jar, commons-collections.jar, commons-digester.jar, commons-logging.jar, jsf-api.jar, jsf-impl.jar, jstl.jar e standard.jar

     

    Também  precisaremos baixar algumas bibliotecas para a utilização do nosso sisteminha de email.

     

    Faça o download do JavaMail em:

    http://java.sun.com/products/javamail/downloads/index.html

    No pacote zipado você vai precisar dos jar’s:

    mail.jar

    dns.jar

    imap.jar

    mailapi.jar

    pop3.jar

    stmtp.jar

     

    JavaBeans Activation Framework – JAF em:

    http://java.sun.com/products/javabeans/jaf/downloads/index.html

    activation.jar

     

    Commons Mail da Apache Jakarta em:

    http://jakarta.apache.org/commons/email/

    commons-email-1.0.jar

     

    Para uma melhor organização, crie uma pasta em um diretório isolado onde você não irá alterar a existência dos arquivos e coloque-os lá:

    Ex: C:\Tools4J

     

    Não esqueça que esses jar’s devem ficar na pasta lib da aplicação jsfapp

     

    Agora vamos criar nossos objetos para representar nosso sistema de e-mail. Para fins didáticos iremos colocar nosso método de negócio dentro da mesmo JavaBean.

     

    Listagem 01 Email.java

    package mail;

    import org.apache.commons.mail.*;

    /**

    *

    * @author Wendell Miranda

    */

    public class Email {

     

    private final String SUCCESS = “success”;

    private final String FAILURE = “failure”;

     

    private static String host = “SMTP”;

    private static String from = “SEU_EMAIL”;

     

    private String nome;

    private String email;

    private String titulo;

    private String mensagem;

     

     

    /** Creates a new instance of Email */

    public Email() {

    }

     

    public String getNome() {

    return nome;

    }

     

    public void setNome(String nome) {w

    this.nome = nome;

    }

     

    public String getEmail() {

    return email;

    }

     

    public void setEmail(String email) {

    this.email = email;

    }

     

    public String getTitulo() {

    return titulo;

    }

     

    public void setTitulo(String titulo) {

    this.titulo = titulo;

    }

     

    public String getMensagem() {

    return mensagem;

    }

     

    public void setMensagem(String mensagem) {

    this.mensagem = mensagem;

    }

     

    /*Neste método, se enviar a mensagem, o usuário será direcionado para a página ok.jsp

    Ou, se ocorrer alguma exceção durante o envio, ele será redirecionado para a mesma, através do OUTCOME failure. Você poderia utilizar qualquer nome para o OUTCOME. */

     

    public String enviar()throws Exception  {

    try{

    HtmlEmail email = new HtmlEmail();

    email.setHostName( host );

    email.setAuthentication(“USUARIO_DO_EMAIL”,”SENHA”);

    email.addTo( getEmail() );

    email.setFrom( from ,”CONTATO: “+getNome());

    email.setSubject( getTitulo() );

    email.setHtmlMsg( getMensagem() );

    email.send();

    }catch( Exception e ){

    e.printStackTrace();

    return FAILURE;

    }

    return SUCCESS;

     

    }

    }

     

    Devemos configurar nosso arquivo de navegação chamado faces-config.xml onde iremos declarar nosso objeto e mapear nossa navegação. Nossas páginas devem ser declaradas com a extenção .jsp

     

    Listagem 02 faces-config.xml

    <?xml version=’1.0′ encoding=’UTF-8′?>

     

    <!DOCTYPE faces-config PUBLIC

    “-//Sun Microsystems, Inc.//DTD JavaServer Faces Config 1.1//EN”

    http://java.sun.com/dtd/web-facesconfig_1_1.dtd”&gt;

     

    <faces-config>

     

    <navigation-rule>

    <from-view-id>/envia.jsp</from-view-id>

    <navigation-case>

    <from-outcome>success</from-outcome>

    <to-view-id>/ok.jsp</to-view-id>

    </navigation-case>

    <navigation-case>

    <from-outcome>failure</from-outcome>

    <to-view-id>/envia.jsp</to-view-id>

    </navigation-case>

    </navigation-rule>

     

    <managed-bean>

    <managed-bean-name>mail</managed-bean-name>

    <managed-bean-class>mail.Email</managed-bean-class>

    <managed-bean-scope>request</managed-bean-scope>

    </managed-bean>

     

    </faces-config>

     

    Devemos criar nossas pages JSF para que possamos testar nossa aplicação. A página Envia.jsp contém elementos JSF( EL ) que vinculam suas propriedades através da configuração do managed-bean no faces-config . Note que o nome do managed-bean é mail, e suas propriedades são acessadas através do ponto(.)

     

    Nosso escopo é request, pois devemos definitivamente evitar o uso de escopo session. Se você utilizar o escopo session, todo o objeto requisitado vai ficar na sessão( Imagine muitos usuários acessando a sua aplicação ?!).

     

    Listagem 03 Envia.jsp

    <%@ taglib uri=”http://java.sun.com/jsf/core&#8221; prefix=”f” %>

    <%@ taglib uri=”http://java.sun.com/jsf/html&#8221; prefix=”h” %>

     

    <f:view>

    <h:form>

    NOME: <h:inputText id=”nome” value=”#{mail.nome}” /></br>

    E-MAIL: <h:inputText id=”email” value=”#{mail.email}” /></br>

    TITULO: <h:inputText id=”titulo” value=”#{mail.titulo}” /></br>

    MENSAGEM: <h:inputTextarea id=”mensagem” rows=”8″ cols=”40″ value=”#{mail.mensagem}” /></br></br>

    <h:commandButton value=”Enviar” action=”#{mail.enviar}” />

    </h:form>

    </f:view>

     

    Listagem 04 ok.jsp

    Nossa página de confirmação onde irá obter os valores informados pelo usuário, através do método get.

     

    <%@ taglib uri=”http://java.sun.com/jsf/core&#8221; prefix=”f” %>

    <%@ taglib uri=”http://java.sun.com/jsf/html&#8221; prefix=”h” %>

     

    <f:view>

    <h2>Mensagem Enviada!!!</h2>

    NOME: <h:outputText id=”nome” value=”#{mail.nome}” /></br>

    E-MAIL: <h:outputText id=”email” value=”#{mail.email}” /></br>

    TITULO: <h:outputText id=”titulo” value=”#{mail.titulo}” /></br>

    MENSAGEM: <h:outputText id=”mensagem” value=”#{mail.mensagem}” /></br></br>

    </f:view>

     

    Conclusões

    Nos próximos artigos irei falar mais sobre JSF e suas funcionalidades, como Eventos, Conversão e Validação. Também vou demonstrar a utilização do Netbeans IDE para a criação de aplicações web, utilizando Faces e JPA (Java Persistence API).

     

    Bom, é isso ! Espero que alguém que esteja começando a utilizar JavaServer Faces, esse tutorial lhe ajude a esclarecer alguma dúvida.  Qualquer dúvida fique a vontade para fazer contato e trocar algumas idéias 😉

     

    Segue o código fonte e o WAR da aplicação para você acompanhar o artigo.

     

    Referências

    Core JavaServer Faces – http://www.horstmann.com/corejsf/

    Planejar é o primeiro passo depois de uma boa idéia

    06 de abril de 2007, 23:25

    Criar e planejar: um roteiro básico para ajudar a organizar o brainstorm que ocorre quando se recebe um novo projeto, com uma pitada de marketing e organização.

    Por Daniel Rodrigo Bastreghi

    A internet anda cheia de boas idéias. Tantas que nem sempre é possivel administrá-las, colocá-las em um papel, separar o joio do trigo e tirar algum proveito das melhores. Um roteirinho básico, que une pequenos conceitos de UML (*) a alguns tópicos de marketing, pode ajudar a organizar o brainstorm que ocorre quando se recebe um novo projeto.

    O roteiro é simples, tem uma seqüência a ser respeitada e inversões dos tópicos não são recomendadas. Deve ser aplicado durante uma reunião curta, de no máximo duas horas.

    Para que a reunião seja produtiva, marque-a com no máximo três dias de antecedência, em horários quebrados (10:10 por exemplo) para estimular a pontualidade.

    Convide pessoas das diversas áreas envolvidas e deixe-as à vontade para participar. Envie antecipadamente perguntas sobre o projeto em questão, para que todos pensem a respeito e cheguem à reunião com idéias ao ponto.

    Durante a reunião, cada participante poderá se expressar livremente. O embate de idéias deve seguir até os 30 minutos finais, quando se deve chegar a um consenso.

    Discuta os seguintes tópicos abaixo:

    1) Qual a proposta do sistema ou website?

    Defina a razão da existência do site. Para alguns projetos a resposta pode parecer óbvia, mas para os mais vanguardistas é importante definir exatamente quais os objetivos que o sistema deve atingir, quais problemas visa solucionar ou reduzir, quais os processos a otimizar e quais os públicos a cativar. O objetivo é estabelecer e documentar um norte a ser seguido por todos da equipe

    Com a proposta redigida, descreva a finalidade de uso do site/sistema. Em estruturas mais convencionais isto pode ser uma etapa subentendida, mas em projetos mais ousados como o Orkut, You tube, Google Notebook, etc. definir a finalidade de uso do sistema não é uma tarefa tão fácil. Até porque as pessoas tendem a criar usos alternativos para o software, como por exemplo utilizar o Orkut para anúncios, o Google Notebook para anotar seus favoritos, o Webmail como driver virtual, etc.

    2) Quais as quatro características principais do software?

    Esta etapa consiste em definir o que é essencial para o projeto. Quanto mais características positivas o projeto tiver, melhor. Mas escolha as quatro principais e foque nelas. O objetivo é evitar aberrações comuns na internet, como webmails lentos, sistemas de ecommerce sem fotos nem descrições dos produtos, sites interativos mas nada intuitivos, etc.

    Segue abaixo lista de características aplicáveis:

    Velocidade do sistema. Sistemas que precisam de resposta rápida ao usuário, onde a beleza pode ser secundária.

    Facilidade de uso. Sistemas intuitivos, para leigos (Google Calendar)

    Segurança. Sistemas onde a confiança é um ponto importante (sites de bancos e e-commerces)

    Comunicação rica. Sistemas onde a forma como o conteúdo é apresentado é fundamental (site do FWA)

    Conteúdo rico. Sistemas onde a mensagem é o mais importante (Folha de São Paulo, Wikipédia)

    Interatividade. Sistemas onde a interação entre sistema e usuário é o foco central (sites de carros, onde a pessoa monta o seu veículo)

    Conteúdo animado. Sistemas onde o conteúdo central é veiculado por vídeos ou animações (You Tube)

    Conteúdo audível. Sistemas onde o conteúdo central é veiculado por som (Podcast)

    Relacionamento comunitário. Sistemas onde o relacionamento entre os usuário do site é essencial (Orkut, blogs, You Tube, Yahoo respostas, Wikipédia…)

    Facilidade de pagamento. Sistemas de compra online onde preço, parcelamento e meios de pagamento são itens importantes. (e-commerces)

    Facilidade de entrega. Sistemas onde a velocidade de entrega é importante (e-commerces).

    Sistemas como o Google Calendar precisam de facilidade de uso, segurança e velocidade no sistema. Já e-commerces precisam de facilidade de uso, segurança, facilidades de pagamento e entrega e conteúdo rico.

    Este já é um bom conteúdo para uma reunião. Cada um vai trazer uma perspectiva diferente do projeto, mas o que vale é justamente essa salada mista de idéias documentadas, organizadas e acessíveis a qualquer pessoa que entrar no projeto no meio do caminho.

    Em outra oportunidade vamos discutir a documentação dos atores dos sistemas – os usuários, suas restrições de acesso, habilidades e expectativas. E não se esqueçam: exerçam seu direitos de Users 2.0 e comentem o artigo. [Webinsider]

    ………………………………………………

    UML é uma linguagem para especificação, documentação, visualização e desenvolvimento de sistemas que facilita a comunicação entre as pessoas envolvidas no projeto.