Mostrando postagens com marcador NetBeans. Mostrar todas as postagens
Mostrando postagens com marcador NetBeans. Mostrar todas as postagens

quarta-feira, 2 de outubro de 2013

Atualizando DataTables dinamicamente (I)

Nesta nova série de posts vou mostrar como utilizar JSF, JPA, Spring e Primefaces para criar um mecanismo que atualiza os dados de DataTables de uma mesma aplicação automaticamente, mesmo que estejam executando em máquinas diferentes (ou seja, em sessões de navegadores diferentes). Confira a série toda aqui: Primefaces

Como pré-requisito, toda a estrutura em camadas que foi mostrada na série anterior (vejam neste link: Spring + JPA).

Começaremos com a lista de bibliotecas que eu usei no projeto:

antlr-2.7.7.jar
aopalliance-1.0.jar
asm-attrs.jar
asm.jar
cglib-2.1.3.jar
commons-beanutils-1.8.2.jar
commons-collections-3.2.1.jar
commons-digester-1.7.jar
commons-fileupload-1.2.2.jar
commons-io-2.0.1.jar
commons-javaflow-20060411.jar
commons-lang-2.6.jar
commons-lang3-3.1.jar
commons-logging-1.1.jar
commons-logging.jar
dom4j-1.6.1.jar
groovy-all-2.0.1.jar
hibernate-commons-annotations-4.0.1.Final.jar
hibernate-core-4.1.8.Final.jar
hibernate-entitymanager-4.1.8.Final.jar
hibernate-jpa-2.0-api-1.0.1.Final.jar
iText-2.1.7.jar
jasperreports-4.5.1.jar
javassist-3.15.0-GA.jar
javax.faces-2.1.4.jar
jaxb-api-2.1.jar
jaxb-impl-2.1.3.jar
jboss-logging-3.1.0.GA.jar
jboss-transaction-api_1.1_spec-1.0.0.Final.jar
joda-time-2.1.jar
jstl.jar
jxl-2.6.10.jar
log4j-1.2.16.jar
mysql-connector-java-5.1.6-bin.jar
org.springframework.aop-3.1.2.RELEASE.jar
org.springframework.asm-3.1.2.RELEASE.jar
org.springframework.aspects-3.1.2.RELEASE.jar
org.springframework.beans-3.1.2.RELEASE.jar
org.springframework.context-3.1.2.RELEASE.jar
org.springframework.context.support-3.1.2.RELEASE.jar
org.springframework.core-3.1.2.RELEASE.jar
org.springframework.expression-3.1.2.RELEASE.jar
org.springframework.instrument-3.1.2.RELEASE.jar
org.springframework.instrument.tomcat-3.1.2.RELEASE.jar
org.springframework.jdbc-3.1.2.RELEASE.jar
org.springframework.jms-3.1.2.RELEASE.jar
org.springframework.orm-3.1.2.RELEASE.jar
org.springframework.oxm-3.1.2.RELEASE.jar
org.springframework.test-3.1.2.RELEASE.jar
org.springframework.transaction-3.1.2.RELEASE.jar
org.springframework.web-3.1.2.RELEASE.jar
org.springframework.web.portlet-3.1.2.RELEASE.jar
org.springframework.web.servlet-3.1.2.RELEASE.jar
org.springframework.web.struts-3.1.2.RELEASE.jar
poi-3.7-20101029.jar
postgresql-9.2-1000.jdbc4.jar
primefaces-3.6-20130315.085445-6.jar
primefaces-extensions-0.7.0.jar
redmond-1.0.10.jar
spring-ldap-1.3.1.RELEASE-all.jar
spring-security-3.0.0.RELEASE.zip
spring-security-acl-3.1.2.RELEASE.jar
spring-security-aspects-3.1.2.RELEASE.jar
spring-security-cas-3.1.2.RELEASE.jar
spring-security-config-3.1.2.RELEASE.jar
spring-security-core-3.1.2.RELEASE.jar
spring-security-crypto-3.1.2.RELEASE.jar
spring-security-ldap-3.1.2.RELEASE.jar
spring-security-openid-3.1.2.RELEASE.jar
spring-security-remoting-3.1.2.RELEASE.jar
spring-security-taglibs-3.1.2.RELEASE.jar
spring-security-web-3.1.2.RELEASE.jar
standard.jar
xstream-1.3.1.jar

É claro que nem todas serão necessárias no momento, mas é o que eu uso com mais frequência e vou deixar a lista assim, porque com todos esses arquivos o funcionamento é garantido. Algumas versões já são um pouco antigas, e provavelmente uma migração exija alguns ajustes.

O ambiente é o JBoss as 7.1.1, NetBeans 7.3.1, Java 7, Hibernate 4, JPA 2, MySQL ou PostgreSQL, Primefaces 3.6 ou superior.

Devemos começar configurando o JBoss:
  1. Para instalar a versão 7.1.1, basta fazer o download, descompactar, e copiar os arquivos jar do MySQL e/ou do PostgreSQL para a pasta <pasta_do_JBoss>/standalone/deployments e o próprio servidor se encarregará de instalar os módulos.
  2. Há um script na pasta bin do JBoss chamado add-user.sh (ou add-user.bat, para Windows). É necessário executar esse script e seguir as indicações para cadastrar um usuário e senha de administrador.
  3. Em seguida, instalar o JBoss no NetBeans (a versão 7.1.1 do JBoss só é suportada a partir da versão 7.3.1 do NetBeans).
  4. Depois de iniciar o JBoss pelo NetBeans, é preciso acessar o Console Admin (em serviços - botão direito do mouse sobre o JBoss, escolher Visualizar Console Admin ou entrando pelo endereço localhost:9990, geralmente).
  5. Já na tela de administração,é preciso configurar um datasource:
  • No canto direito superior escolher Profile, em seguida no menu à esquerda escolher Datasources, e na tela central escolher add.
  • Preencher Name e JNDI Name, lembrando que o JNDI Name deve coincidir com o jndi-name usado no jboss-web.xml (no meu caso, java:/fonteDeDados).
  • Na tela seguinte escolher o banco de dados (MySQL, PostgreSQL).
  • Na tela seguinte preencher com os dados da conexão (jdbc:postgresql://meuServidor:5432/meuBancoDeDados, usuário e senha do banco).
  • Quando a configuração voltar para a lista de Datasources, é preciso selecionar o Datasource que acabou de ser instalado e clicar em enable para habilitar. Se acontecer algum erro, é só remover e fazer tudo novamente.
Depois do JBoss configurado, a estrutura mostrada na série de posts anterior vai se conectar ao datasource fonteDeDados, e qualquer alteração de servidor ou tecnologia de banco de dados será feita diretamente no console admin do JBoss. Ou seja: para a aplicação, a configuração da conexão com um banco de dados é totalmente delegada ao datasource.


Neste ponto, já é possível executar o aplicativo, fazer a autenticação e visualizar a página index.xhtml padrão criada pelo NetBeans. É claro que todos os passos da configuração do Spring e Spring Security mostradas anteriormente devem ser seguidos.

No próximo post, a configuração do Primefaces e a criação da primeira página do projeto.

sábado, 21 de setembro de 2013

Configurando fontes de dados com o JBoss (I)

Este post faz parte de uma série sobre Spring, JPA e JSF. Caso algum assunto abordado aqui não esteja claro, consulte este link: Spring + JPA.

Pra começo de conversa, por que usar o JBoss?

O JBoss é um robusto servidor de aplicações, baseado na mesma arquitetura do Apache TomCat, e suporta muito bem o gerenciamento de transações. Já o TomCat não pode ser chamado de servidor de aplicações - seria apenas um "container web". Um ambiente ideal seria desenvolver usando o TomCat e distribuir usando o JBoss. O TomCat não deve ser utilizado em produção, mas pode perfeitamente ser utilizado durante o desenvolvimento, já que é bem mais fácil de configurar e bem mais rápido para efetuar os testes. Mas as coisas não acontecem da mesma maneira no TomCat e no Jboss... Como o TomCat precisa de bibliotecas de terceiros para suportar transações, já tive bastante dor de cabeça para ajustar um sistema inteiro depois de simplesmente mudar de TomCat para Jboss, e depois dessas experiências, agora faço os testes no JBoss, também. Mesmo que seja mais demorado, tenho a garantia de distribuir imediatamente meu projeto assim que os testes terminam.

Depois de baixar o JBoss (eu uso nestes exemplos a versão 6.1.0.Final), é importante editar o arquivo /jboss-6.1.0.Final/bin/run.conf e fazer a modificação a seguir:

#
# Specify options to pass to the Java VM.
#
if [ "x$JAVA_OPTS" = "x" ]; then
   JAVA_OPTS="-Xms2G -Xmx6G -XX:MaxPermSize=2G -Dorg.jboss.resolver.warning=true -Dsun.rmi.dgc.client.gcInterval=36000 -Dsun.rmi.dgc.server.gcInterval=36000"
fi

Os valores que aparecem na frente dos Xms, Xmx e MaxPermSize devem ser os mais altos que a memória do seu servidor comportar (faça quantos testes forem necessários, vale a pena). Quanto mais altos estes valores, menos o servidor irá travar e menos problemas de "Permgen" surgirão. E isto não é uma característica do JBoss, não. Ao implantar/desimplantar um projeto várias vezes, seja no TomCat, no Glassfish, etc., sempre chega um momento em que o servidor não consegue gerenciar mais a memória que lhe foi reservada, e aí, só reiniciando.

No caso de usar o NetBeans, como eu, pode ser necessário fazer a alteração nas propriedades do servidor, como mostrado abaixo:

Depois do JBoss instalado e configurado, voltamos ao projeto. É necessário criar um arquivo que chamaremos de jboss-web.xml, na pasta WEB-INF:


O conteúdo deste arquivo é bastante simples:

<?xml version="1.0" encoding="UTF-8"?>
<!-- jboss-web.xml -->
<jboss-web>
  <context-root>/livraria</context-root>
  <resource-ref>
    <res-ref-name>jdbc/fonteDeDados</res-ref-name>
    <jndi-name>java:/fonteDeDados</jndi-name>
  </resource-ref>
</jboss-web>

O contexto, mostrado na linha 4, deve coincidir com o contexto do projeto. No NetBeans, para definir o contexto e o URL relativo, basta acessar as propriedades do projeto e a opção executar:

Percebemos, nas linhas 6 e 7, o famoso identificador "fonteDeDados" que apareceu nos arquivos de configuração do Spring. Esta fonte de dados deve ser referenciada nos arquivos de configuração do servidor JBoss (no TomCat não é necessário...), mais especificamente, em um arquivo da pasta /jboss-6.1.0.Final/server/default/deploy com sufixo "-ds". Uma boa prática é eliminar todos os arquivos desta pasta que tenham o sufixo "-ds" e centralizar em um único arquivo, por exemplo, "config-ds.xml", mostrado a seguir:

<datasources>  
  
   <local-tx-datasource>       
      <jndi-name>fonteDeDados</jndi-name>    
      <connection-url>jdbc:postgresql://meuServidor:5432/meuBancoDeDados</connection-url>   
      <driver-class>org.postgresql.Driver</driver-class>  
      <user-name>postgres</user-name>  
      <password>minhaSenha</password>  
      <min-pool-size>5</min-pool-size>  
      <max-pool-size>300</max-pool-size>  
      <idle-timeout-minutes>0</idle-timeout-minutes>    
   </local-tx-datasource>  
  
   <local-tx-datasource>          
      <jndi-name>outraFonteDeDados</jndi-name>    
      <connection-url>jdbc:postgresql://meuOutroServidor:5432/meuOutroBancoDeDados</connection-url>   
      <driver-class>org.postgresql.Driver</driver-class>  
      <user-name>postgres</user-name>  
      <password>minhaSenha</password>  
      <min-pool-size>5</min-pool-size>  
      <max-pool-size>300</max-pool-size>  
      <idle-timeout-minutes>0</idle-timeout-minutes>    
   </local-tx-datasource>  
  
</datasources> 

Podemos verificar que o arquivo é formado por uma coleção de "local-tx-datasource", e que o primeiro deles está associado com o famigerado identificador "fonteDeDados" (linha 4). As linhas 5, 7, e 8 mostram a configuração da conexão ao banco de dados, que no exemplo é PostgreSQL. Como já enfrentei alguns problemas relativos ao número máximo de conexões, deixo sempre um número alto em max-pool-size (linha 10). Lembrando que o servidor de aplicações (JBoss) e o servidor de banco de dados devem ser máquinas com boa quantidade de memória.

Percebemos que o segundo datasource pode se conectar a outro banco de dados totalmente diferente, e nem precisa ser a mesma tecnologia - pode ser MySQL, por exemplo.

Aqui termina a configuração do JBoss. No próximo post, a criação da unidade de persistência.

terça-feira, 17 de setembro de 2013

Configurando o Spring (I)

Este post faz parte de uma série sobre Spring, JPA e JSF. Caso algum assunto abordado aqui não esteja claro, consulte este link: Spring + JPA.

Eu uso o Spring há algum tempo, e tem sido muito útil. Me ajuda muito a manter a integridade de meus projetos, principalmente por causa do controle de transações, aliado a uma arquitetura em camadas.

Não é fácil compreender todo o funcionamento do Spring, nem é meu objetivo aqui. Acredito que outros desenvolvedores se beneficiarão mais dos exemplos funcionando, e para que isso aconteça, é preciso configurar cuidadosamente o ambiente de trabalho.

A IDE utilizada será o NetBeans.

1 - Obtendo as bibliotecas


Eu utilizo as seguintes bibliotecas:


É óbvio que versões mais recentes podem já estar disponíveis, mas ressalto novamente que esse é um modelo que funciona muito bem para as minhas necessidades.

2 - O arquivo web.xml

O trecho a seguir deve ser colocado no arquivo web.xml:

    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>
            /WEB-INF/classes/web-application-config.xml
        </param-value>
    </context-param>

    <listener>
        <listener-class>
            org.springframework.web.context.request.RequestContextListener
        </listener-class>
    </listener>

    <listener>
        <listener-class>
            org.springframework.web.context.ContextLoaderListener
        </listener-class>
    </listener>

    <filter>
        <filter-name>springSecurityFilterChain</filter-name>
        <filter-class> org.springframework.web.filter.DelegatingFilterProxy
        </filter-class>
    </filter>
  
    <filter-mapping>  
        <filter-name>springSecurityFilterChain</filter-name>  
        <url-pattern>/*</url-pattern>  
    </filter-mapping> 
 
    <resource-ref>
        <description>
            Resource reference to a factory for java.sql.Connection
            instances that may be used for talking to a particular
            database that is configured in the
            configurartion for the web application.
        </description>
        <res-ref-name>jdbc/fonteDeDados</res-ref-name>
        <res-type>javax.sql.DataSource</res-type>
        <res-auth>Container</res-auth>
    </resource-ref>

Algumas observações importantes:

  1.  Esta configuração será sempre assim, já tenho vários projetos que usam o mesmo trecho de código.
  2.  Há um arquivo adicional que vamos criar em seguida, como se pode observar na linha 4.
  3.  Uma fonte de dados será configurada posteriormente, como se pode observar na linha 38.

Compreender o restante do código fica por conta do leitor. São muitas horas de leitura sobre o Spring que não podem ser resumidas aqui.

No próximo post vou mostrar o arquivo web-application-config.xml.

terça-feira, 30 de março de 2010

Conexão com um banco de dados

A janela Services tem todas as funcionalidades para gerenciar as conexões com os bancos de dados. O item Drivers mostra os já instalados, mas um clique com o botão direito sobre ele permite localizar um arquivo .jar que contenha um novo driver, caso necessário.

O driver para o banco de dados que se pretende utilizar é absolutamente imprescindível. É preciso adicioná-lo aqui para que a conexão seja estabelecida e as outras etapas sejam bem sucedidas.

Uma nova conexão pode ser feita rapidamente, bastando clicar com o botão direito sobre o driver desejado e escolher "Conectar usando", e preencher os campos adequadamente.

No nosso exemplo, vamos utilizar o banco Travel, que na figura já aparece conectado. Para conectar, basta clicar com o botão direito sobre a conexão desejada e escolher Conectar.

Voltar para DataTables básico

segunda-feira, 29 de março de 2010

Instalando IceFaces no NetBeans 6.8

Para instalar o plugin do IceFaces no NetBeans 6.8, basta baixar os arquivos nos links abaixo:


arquivo 1 (12Mb)


arquivo 2 (95Kb)


Depois de salvá-los em qualquer local de sua preferência, no NetBeans escolha Ferramentas->Plugins->Baixados->Adicionar. Em seguida localize e selecione os arquivos, e siga as instruções do NetBeans para terminar a instalação. É recomendável que o NetBeans seja reiniciado após a instalação.

Agora o ambiente de trabalho está pronto. Próximo passo: estrutura dos bancos de dados.

domingo, 28 de março de 2010

Web + Java. É viável?

Aplicações web construídas com auxílio de java são viáveis? Sim, desde que as aplicações ofereçam ao internauta recursos que há algum tempo não eram muito exigidos.

Exemplos: calendários, validação, abas deslizantes, objetos reposicionáveis, etc. E todos em tempo real (AJAX?), sem recarregar as páginas.

Para consolidar este tema, vamos investigar o uso do framework Icefaces para criar uma aplicação clássica de controle de biblioteca, utilizando inicialmente as tecnologias:

  • IDE Netbeans
  • Banco de dados Firebird
  • Persistência de dados com Hibernate
  • IceFaces
  • Javaserver Faces

As abordagens irão desde a criação do banco de dados, até a utilização da aplicação com usuários e documentos reais.