Archive for category Java
Mapeando Arrays de Objetos Oracle no Java
Posted by Diego Ferreira da Silva in Java, Oracle on 11 de janeiro de 2010
Fala pessoal,
Este tutorial explica como fazer binding de objetos/arrays de objetos java para objetos declarados em procedures no oracle.
Existe um ótimo artigo neste link que explica como fazer estes mapeamentos, gostaria apenas de complementar este artigo pois ele aborda como criar os objetos no oracle/java, como recuperar os arrays destes objetos, porem ficou faltando mostrar como passar os arrays como parametro para as procedures.
A única coisa que muda para passar um array como parâmetro é o seguinte
public static void proSelectClass2(TypeClass[] classQry, Connection conn) {
//vc tem que obter um OracleCallableStatement
OracleCallableStatement cs = null;
try {
conn.getTypeMap().put(TypeClass.ORACLE_CLASS_ARRAY_NAME, TypeClass[].class);
conn.getTypeMap().put(TypeUser.ORACLE_USER_ARRAY_NAME, TypeUser[].class);
//aqui obtém o OracleCallableStatement fazendo um cast
cs = (OracleCallableStatement) conn.prepareCall("{call PAC_BEAN.PRO_SELECT_CLASS2(?)}");
//Vc cria um array descriptor
ArrayDescriptor descriptor = ArrayDescriptor.createDescriptor(TypeClass.ORACLE_CLASS_ARRAY_NAME, conn);
//cria um array do oracle utilizando o arraydescriptor criado acima
oracle.sql.ARRAY array = new ARRAY(descriptor, conn, classQry);
//apos isto seta o array criado na posicao em que é passado o array na procedure, obs: este método setARRAY(maíusculo) só está disponível no OracleCallableStatement
cs.setARRAY(1, array);
//aqui esta registrando um array de saida, mas isso é igual ao tutorial passado no link
cs.registerOutParameter(1, OracleTypes.ARRAY, TypeClass.ORACLE_CLASS_ARRAY_NAME);
cs.execute();
É isso ai, qualquer dúvida podem entrar em contato comigo.
abraço.
Hello World RichFaces
Posted by Diego Ferreira da Silva in Java EE on 1 de maio de 2009
E ai pessoal, hoje famos fazer um exemplo passo a passo de uma aplicação Hello World utilizando o RichFaces.
Para quem não conhece o RichFaces ele é uma biblioteca de componentes para aplicações web que utilizam o framework JSF. Os componentes desta biblioteca possuem um incrível suporte AJAX, e ela, pode ser considerada uma extensão do Ajax4jsf com inúmeros componentes com Ajax “embutido” e com um suporte a Skins que podem deixar as interfaces da sua aplicação com um visual padronizado.
O ambiente que utilizamos neste post é o seguinte:
- Eclipse Ganymede
- Tomcat 6.0
- RichFaces 3.3.0
Vamos por a mão na massa, primeiro criamos um projeto web no eclipse e damos o nome a ele de HelloRichFaces.
Efetue o download do arquivo richfaces-ui-3.3.0.GA-bin.zip no seguinte link . Descompacte o arquivo e copie os arquivos richfaces-api-3.3.0.GA.jar, richfaces-impl-3.3.0.GA.jar, richfaces-ui-3.3.0.GA.jar para do diretório WEB-INF/lib da nossa aplicação.
Precisamos também copiar os seguintes jars para o diretório WEB-INF/lib da nossa aplicação:
jsf-api.jar, jsf-impl.jar(Jar’s do framework JSF).
jstl.jar, standard.jar.
commons-beanutils-1.8.0.jar, commons-collections-3.2.1.jar, commons-digester-1.8.jar, commons-logging-1.1.1.jar.
Vamos criar agora dentro da nossa pasta WEB-INF um arquivo com o nome faces-config.xml, neste arquivo ficará nossas configurações referente ao JSF(Managed beans, Regras de navegação, etc…).
Agora criaremos dentro da pasta WebContent uma página jsp com o nome: helloWorldRichFaces.jsp
Vamos criar um pacote dentro da pasta src do nosso projeto com o seguinte nome br.com.diegosilva.helloworld
Pronto, nossa estrutura para o helloWorld já está criada, se você chegou até aqui veja abaixo como deve ficar a estrutura de seu projeto.
Imagem-01
Agora que já temos nossa estrutura do projeto pronta, vamos criar um simples managed bean dentro do pacote br.com.diegosilva.helloworld como o nome de Bean.
Abaixo o código da classe Bean:
package br.com.diegosilva.helloworld;
public class Bean {
private String text;
public Bean() {
}
public String getText() {
return text;
}
public void setText(String text) {
this.text = text;
}
}
O managed bean criado acima será utilizado na nossa página JSF, mas para que possamos utilizá-lo precisamos confirar nosso arquivo faces-config.xml inserindo as confirações necessárias para que nosso manage bean seja reconhecido pela nossa página.
Segue abaixo a configuração do nosso faces-config.xml do nosso exemplo:
<?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>bean</managed-bean-name> <managed-bean-class>br.com.diegosilva.helloworld.Bean</managed-bean-class> <managed-bean-scope>request</managed-bean-scope> <managed-property> <property-name>text</property-name> <value/> </managed-property> </managed-bean> </faces-config>
O arquivo acima está informando ao JSF que estamos criando um managed bean, que seu nome será bean que a classe será a que está no caminho br.com.diegosilva.helloworld.Bean que o escopo utilizado será como atributo de request e que este bean tem uma propriedade que se chama text.
Agora vamos criar nossa página que utilizará nosso managed bean criado.
<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
pageEncoding="ISO-8859-1"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<%@ taglib uri="http://richfaces.org/a4j" prefix="a4j"%>
<%@ taglib uri="http://richfaces.org/rich" prefix="rich"%>
<%@ taglib uri="http://java.sun.com/jsf/html" prefix="h"%>
<%@ taglib uri="http://java.sun.com/jsf/core" prefix="f"%>
<html>
<head>
<title>Hello World RichFaces</title>
</head>
<body>
<f:view>
<h:form>
<rich:panel header="Simples Impressão">
<h:inputText size="50" value="#{bean.text}">
<a4j:support event="onkeyup" reRender="rep" />
</h:inputText>
<h:outputText value="#{bean.text}" id="rep" />
</rich:panel>
</h:form>
</f:view>
</body>
</html>
Na nossa página acima primeiramente fazemos os imports das taglibs utilizadas pelo JSF e RichFaces, dentro ta tag <body> criamos um <f:view>, todos os componentes JSF devem vir dentro de uma tag <f:view>, dentro da nossa tag <f:view> criamos um formulário e dentro desse formulário um painel no qual terá o título de Simples Impressão, dentro desse painel temos um input que irá setar a propriedade text do nosso bean com o valor digitado no input, nesse input adicionamos um evento onkeyup utilizando a api de ajax que o richfaces utiliza, neste evento setamos o atributo reRender=”rep”, no qual rep é o id do nosso outputText declarado logo abaixo, o nosso outputText recebe o valor da propriedade text do nosso bean. O que acontece aqui é que a cada evento de onkeyup nosso bean recebe o valor e o componente de id rep e recebe a atualização desse valor sem refresh na página, totalmente ajax.
Não podemos esquecer de configurar o arquivo web.xml do nosso projeto para que tudo funcione belezinha tem que ser feito algumas configurações neste arquivo.
Segue abaixo nosso arquivo web.xml
<?xml version="1.0" encoding="UTF-8"?> <web-app id="WebApp_ID" version="2.5" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"> <display-name>HelloRichFaces</display-name> <!-- Rich Faces --> <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> <listener> <listener-class>com.sun.faces.config.ConfigureListener</listener-class> </listener> <!-- Java SErver Faces --> <servlet> <servlet-name>Faces Servlet</servlet-name> <servlet-class>javax.faces.webapp.FacesServlet</servlet-class> <load-on-startup>0</load-on-startup> </servlet> <!-- Faces Servlet Mapping --> <servlet-mapping> <servlet-name>Faces Servlet</servlet-name> <url-pattern>*.faces</url-pattern> </servlet-mapping> <welcome-file-list> <welcome-file>helloWorldRichFaces.faces</welcome-file> </welcome-file-list> </web-app>
Imagem 2
Download do projeto(Sem os Jars).
Bom pessoal é isso ai espero que tenham gostado deste post, e qualquer dúvida é só entrarem em contato.
Abraço.
Classe Properties
Posted by Diego Ferreira da Silva in Java, Java SE on 28 de março de 2009
Veremos neste post como pode ser útil a utilização da classe Properties para ler arquivos de configuração.
A classe
A classe java.util.Properties, presente desde a versão 1.0 do JDK, é filha (extende) da classe java.util.Hashtable e, por consequência, implementa a interface Map. Ela armazena pares de valores, assim como a Hashtable, com uma diferença: ambos os valores (chave e valor) são Strings.
Para quem nunca usou nenhum Map, é interessante saber que um Map associa dois objetos: dado uma chave, pego um valor. Um exemplo de Mapa que poderia ser representado em java:
| norte = tesouro sul = pirata oeste = pirata leste = oasis |
Como podemos ver, um Map é um conjunto de pares chave->valor associados. Uma chave só tem um valor, mas podem existir várias chaves que tem o mesmo valor. No nosso caso, sul e oeste tem o mesmo valor.
O Properties é um mapa especial, pois não associa dois objetos, e sim duas Strings.
Alguns dos métodos da classe Properties:
//retorna null caso não exista um objeto na coleção em que a chave
// tenha o valor "nome" no nosso caso, retornaria "tesouro"
String nome = props.getProperty("norte");
// caso não exista chave com o valor "sudoeste",
// em vez de retornar null, retorna sempre o valor "vazio"
String nome2 = props.getProperty("sudoeste", "vazio");
// adiciona ao mapa a chave "extremoSul", com valor
// "caverna". Caso já exista um elemento na coleção
// com esta chave, o valor na coleção é alterado para este último
props.setProperty("extremoSul", "caverna");
// retorna um Enumeration, sem ordem definida, com as chaves das propriedades
Enumeration enum = props.propertyNames();
// lê os dados de um determinado InputStream
// veremos neste tutorial o formato que este arquivo deve ter
props.load(InputStream in);
// o head representa a comentário que será inserido no começo do arquivo,
// junto com a hora em que os dados foram armazenados.
props.store(OutputStream out, String head);
O método save(OutputStream out, String header) está depreciado (deprecated) porque ele não gera uma IOException caso aconteça algum problema.
Os métodos put() e get(), herdados da classe Hashtable, podem ser utilizados ao invés de setProperty() e getProperty(), desde que os objetos inseridos sejam Strings, caso contrário será gerada uma ClassCastException no momento em que for feita a leitura dos valores presentes na coleção, em razão do tipo dos objetos inseridos não serem Strings.
Estratégia
É possível ler pares de valores armazenados em arquivos texto, a partir do método load(), desde que seja declarado um par de valores por linha no arquivo e que a chave seja separada do valor pelo caracter igual (=). Exemplo: O arquivo mail.properties possui as seguintes configurações:
| #Configurações do arquivo mail.properties mail.pop3.host=pop.dot.com mail.debug=false mail.from=from_user@mail.dot.com mail.user=to_user mail.smtp.host=smtp.dot.com mail.store.protocol=pop3 |
Para inserir um comentário de uma linha no arquivo, utilize a cerquilha (#). Se houver gravação no arquivo, o conteúdo anterior será apagado inclusive os comentários.
Convencionou-se colocar a terminação .properties a esses arquivos textos de configurações utilizados pelo java, assim como existem os arquivos .ini no windows. É possível encontrar os arquivos .properties no JBoss, Tomcat e em outros projetos.
Atenção: os dados do arquivo .properties serão utilizados na aplicação de acordo com as regras da classe String, por exemplo, user é diferente de User.
Utilizando Properties, não é possível garantir a ordem em que os dados serão armazenados, quer dizer, se vocês armazenarem a coleção do mesmo objeto properties em momentos diferentes da aplicação, o conteúdo do arquivo poderá estar em ordens diferentes. Se a ordem for importante, veja a classe LinkedHashMap, que foi adicionada ao jdk1.4. Ela devolve um iterator com os valores ordenados pela ordem de inserção na HashMap.
Lendo um arquivo .properties
Para ler um arquivo, é necessário criar um InputStream a ser lido e um objeto da classe Properties. O passo seguinte é chamar o método load() da classe Properties para ler os dados que estão no arquivo.
// o arquivo encontra-se no mesmo diretório
//da aplicação
File file = new File("mail.properties");
Properties props = new Properties();
FileInputStream fis = null;
try {
fis = new FileOutputStream(file);
//lê os dados que estão no arquivo
props.load(fis);
fis.close(0;
}
catch (IOException ex) {
System.out.println(ex.getMessage());
ex.printStackTrace();
}
Agora é possível manipular os dados que foram lidos do arquivo.
String user = props.getProperty("mail.user");
String from = props.getProperty("mail.from");
String smtp = props.getProperty("mail.smtp.host");
String pop3 = props.getProperty("mail.pop3.host");
String protocol = props.getProperty("mail.store.protocol");
String debug = props.getProperty("mail.debug");
Para alterar o valor de user no objeto props, utilize o método setProperty():
String user = "guj";
props.setProperty("mail.user", user);
Notem que o valor anterior de “mail.user” foi perdido.
A sequência a seguir mostra como persistir os dados do objeto props em um arquivo diferente:
//o arquivo encontra-se no mesmo diretório da aplicação
File file = new File("mail2.properties");
FileInputStream fos = null;
try {
fos = new FileOutputStream(file);
//grava os dados no arquivo
props.store(fos,"Configurações do arquivo mail.properties");
fos.close();
}
catch (IOException ex) {
System.out.println(ex.getMessage());
ex.printStackTrace();
}
Conclusão
A utilização da classe Properties com um arquivo de configurações permite mais facilidade para manter a aplicação sem a necessidade de recompilar o código fonte a cada mudança nas configurações. Basta alterar o arquivo com as configurações e reiniciar a aplicação. Existem formas de atualizar o conteúdo do objeto properties sem reiniciar a aplicação e serão abordadas em um outro post.
-
You are currently browsing the archives for the Java category.
