Arquivo

Arquivo da Categoria ‘java’

Spring Boot – Persistindo dados

22, dezembro, 2014 Sem comentários

Hoje mostrarei um exemplo de como gerenciar informações em bancos de dados.
Antes de mais nada atualize seu Spring Boot CLI (hoje a versão 1.2).


gvm i springboot

crie um novo projeto com o auxilio do Spring Boot CLI


spring init --packageName=br.com.dados --type=gradle-project --dependencies=web,data-jpa dadosProject

O comando


spring init --list

mostra todas as opções para esse comando.

Certifique-se de que seu arquivo build.gradle se parece com esse:


buildscript {
    ext {
        springBootVersion = '1.2.0.RELEASE'
    }
    repositories {
        mavenCentral()
    }
    dependencies {
        classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
    }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'idea'
apply plugin: 'spring-boot' 

jar {
    baseName = 'demo'
    version = '0.0.1-SNAPSHOT'
}
sourceCompatibility = 1.7
targetCompatibility = 1.7

repositories {
    mavenCentral()
}


dependencies {
    compile("org.springframework.boot:spring-boot-starter-web")
    compile("org.springframework.boot:spring-boot-starter-data-jpa")
    testCompile("org.springframework.boot:spring-boot-starter-test")
    compile("org.hsqldb:hsqldb")
}

Crie um simples entity:


package demo.domain;

import ...

@Entity
public class Banco implements Serializable {
    @Id
    @GeneratedValue
    private Long id;

    @Column(nullable = false)
    private String codigo;

    @Column(nullable = false)
    private String nome;

    public Banco() {
        super();
    }

    public Banco(String codigo, String nome) {
        this.codigo = codigo;
        this.nome = nome;
    }

    ...
    

}

crie uma interface para o repositório


package demo.domain;

import org.springframework.data.repository.CrudRepository;

public interface BancoRepository extends CrudRepository {
    Banco findByCodigo(String codigo);
}

E por fim uma classe de testes:


package demo;

import ...

@RunWith(SpringJUnit4ClassRunner.class)
@SpringApplicationConfiguration(classes = Application.class)
@WebAppConfiguration
public class ApplicationTests {
    @Autowired
    private BancoRepository bancoRepository;

    @Test
    public void bancoTest() {

        // create
        Banco banco = new Banco("001", "Banco do Brasil SA");
        bancoRepository.save(banco);
        Assert.assertTrue("registros encontrados = 0", bancoRepository.count() > 0);

        // read
        Banco bancoSaved = bancoRepository.findByCodigo("001");
        Assert.assertNotNull("registros nao encontrado", bancoSaved);

        // update
        bancoSaved.setNome("Banco Brasileiro SA");
        bancoRepository.save(bancoSaved);
        Banco bancoUptodate = bancoRepository.findByCodigo("001");
        Assert.assertFalse("nome nao atualizado", bancoUptodate.getNome().equalsIgnoreCase("Banco do Brasil SA"));

        // delete
        bancoRepository.delete(bancoUptodate);
        Banco bancoDeleted = bancoRepository.findByCodigo("001");
        Assert.assertTrue("entity nao apagado", bancoDeleted == null);

    }

}

Execute o teste e verá que todos passaram.

Ao analizar o código, a primeira pergunta que surge é onde os dados foram persistidos? Qual DataSource foi usado?
Observe que adicionamos ao arquivo build.gradle a dependência do banco HyperSQL DataBase (hsqldb). Isso foi suficiente para que o Spring Boot criasse automaticamente um datasource em memória e disponibilizasse para que usássemos.

Isso é legal mas não parece muito útil. Edite o arquivo application.properties adicionando as linhas abaixo que farão com que o banco de dados seja gerenciado em arquivo.


spring.jpa.hibernate.ddl-auto=update

spring.datasource.url=jdbc:hsqldb:file:banco_db

ou essas para utilizar o MySQL:


spring.jpa.hibernate.ddl-auto=update

spring.datasource.url=jdbc:mysql://localhost:3306/banco_db
spring.datasource.username=dbuser
spring.datasource.password=dbpass
spring.datasource.driver-class-name=com.mysql.jdbc.Driver

veja aqui mais opções de configuração para esse arquivo.

Categories: Spring Boot, Springframework Tags:

Spring Boot CLI

11, dezembro, 2014 Sem comentários

Hoje mostrarei a utilização básica do Spring Boot CLI.
O Spring Boot CLI é uma ferramenta de linha de comando que auxilia na criação rápida de artefatos Spring escritos em Groovy, facilitando assim a prototipação de suas aplicações.

Instalação

Você pode instala-lo a partir dos binários ou utilizar o GVM que é uma ferramenta multiplataforma utilizada pela comunidade Groovy para gerenciar a instalação de várias ferramentas. O GVM roda em plataformas Linux, Solaris, Mac OSX, BSD, porém no Windows apenas via Cygwin. Se você usa o Windows, aconselho que baixe o Spring Boot CLI diretamente dos binários.

Instale o GVM da seguinte forma:


curl -s get.gvmtool.net | bash

em seguida a instalação do Spring Boot CLI:


gvm install springboot

digitando :


spring --version

para verificar a versão instalada.
Opcionamente você poderá configurar o Command-Line completion para obter sugestões de parâmetros e argumentos durante a utilização.
Adicione em seu arquivo de configurações de ambiente (.bash_profile por exemplo) a linha


source '~/.gvm/springboot/current/shell-completion/bash/spring'

Esse path considera que você usou o GVM, altere se necessário para apontar para pasta onde seu Spring Boot CLI foi instalado.
Na linha de commando experimente:


spring 

grab  help  jar  run  test  version

Opcionamente você poderia usar o instalador disponibilizado pela equipe do Spring:


curl http://start.spring.io/install.sh | sh

Na prática não haverá difenças no resultado, mas a primeira opção constitui um modelo padronizado para gerenciamento desta e demais ferramentas utilizadas.

Crie o arquivo Groovy SampleController.groovy


@RestController
class SampleController {

  @RequestMapping("/")
  String home() {
    "Hello World!"
  }

}

Na linha de comando digite:


spring run SampleController.groovy

Observe que essa é uma classe Groovy e portanto se beneficia da simplicidade que a linguagem oferece. O resultado, mais uma vez será o mesmo observado nos posts anteriores

Categories: geral, Spring Boot, Springframework Tags:

Serializador Json personalizado para Enum


Estou trabalhando num projeto com Springframework mvc onde os serviços rest são transportados em json.
Por padrão, a serialização para json é feita pelo framework Jackson que é muito bom diga-se de passagem, já que é bastante flexivel.
No meu problema de hoje precisei personalizar a serialização dos enums pois por padrão ele retorna o name do enum. É possivel por exemplo, adicionar a anotação @JsonValue para definir qual método retornará o valor desejado. No meu caso porém, eu precisava retornar o enum numa estrutura de pojo e não:


{
"name" : { "first" : "Joe", "last" : "Sixpack" },
"gender" : "MALE",
"verified" : false,
"userImage" : "Rm9vYmFyIQ=="
}

Para isso criei um serializador personalizado:


public class SimpleEnumSerializer extends JsonSerializer> {

@Override
public void serialize(Enum< ?> value, JsonGenerator jgen, SerializerProvider provider) throws IOException,
JsonProcessingException {
jgen.writeStartObject();
jgen.writeFieldName("ordinal");
jgen.writeNumber(value.ordinal());
jgen.writeFieldName("name");
jgen.writeString(value.name());
jgen.writeEndObject();
}
}

public class User {
private Gender _gender;
private Name _name;
private boolean _isVerified;
private byte[] _userImage;

@JsonSerialize(using = SimpleEnumSerializer.class)
public Gender getGender() { return _gender; }
}

com isso o resultado passa para:

{
"name" : { "first" : "Joe", "last" : "Sixpack" },
"gender" {"ordinal":0, "name":"MALE"},
"verified" : false,
"userImage" : "Rm9vYmFyIQ=="
}

GWT – basico, mas funcional

2, setembro, 2008 Sem comentários

O GWT é um tecnologia extraordinária. Ela possibilita que aplicações sejam criadas em java e após compilado, transformado em JavaScript gerando assim uma aplicação dinâmica e bastante flexível.
A internet está cheia de tutorias e o próprio site do GWT somado ao grupo oficial de usuário é uma fonte excelente de informação para tirar dúvidas e melhorar o conhecimento.

Um problema que é muito comum nos vários tutoriais que vemos pela internet é que eles não são completos o suficientes para o usuário mais iniciante ter um compreensão da tecnologia e muitas vezes até desmotiva a continuidade em busca de um maior entendimento ante os primeiros desafios.

Para quem está iniciando uma boa alternativa é utilizar o Netbeans com seu plugin gwt4nb para GWT pois ele permite criar uma aplicação completa inclusive fazer deploy para seu servidor de aplicação.
Para o Eclipse, entretanto, não existe nenhuma boa alternativa livre (que eu conheça) para se trabalhar com o GWT, mas isso pode ser contornado de forma simples. Vamos lá:

Faça o download:
wget http://google-web-toolkit.googlecode.com/files/gwt-linux-1.5.2.tar.bz2
veja opções para outras plataformas em http://code.google.com/webtoolkit/versions.html

Descompacte o arquivo:
tar -xjvf gwt-linux-1.5.2.tar.bz2

download

Edite suas variáveis de ambiente criando a variavel para GWT_HOME e atualizando a variável PATH.
Em sistemas no padrão Linux basta editar o arquivo oculto chamando .profile em sua pasta pessoal adicionando as seguintes linhas

export GWT_HOME=/home/paulo/gwt-linux-1.5.2
export PATH=$PATH:$GWT_HOME

Lógico que você precisará substituir /home/paulo/gwt-linux-1.5.2 pela pasta onde você descompactou o gwt.
Em sistemas Windows o procedimento é realizado editando-se as propriedades do sistema conforme imagem abaixo:

variaveisWin

Criando um projeto para teste

O objetivo do nosso teste é apenas criar um esqueleto de uma aplicação padrão, acrescentando a ela uma serviço RPC e por
fim fazer o deploy num conteiner web, no nosso caso, para simplificar, o Tomcat, mas não é preciso nenhuma mudança para que este rode no Glassfish

no console digite:

cd workspace/
applicationCreator -out gwtWebMode -eclipse gwtWebMode br.com.sample.client.GwtWebMode

o gwt criou uma estrutura básica para trabalharmos. Normalmente usaríamos um outro recurso do gwt que é criar um projeto para o eclipse, com o comando projectCreator importando-o em seguida mas não vamos fazê-lo pois o projeto criado não gera os artefatos para uma aplicação web coisa que uma aplicação gwt é por natureza.

applicationCreator

O que vamos fazer é pedir para o Eclipse criar um novo projeto web justamente na pasta recém criada, isso aproveitará os arquivos criados pelo applicationCreator e nos dará os artefatos adicionais.

Abra o Eclipse e escolha File/New/Other/Dynamic Web Project
newProject

Digite o nome do projeto igual ao nome ao informado ao applicationCreator.
nameApplication

Sua aplicação já deverá funcionar em hosted mode. Experimente executar GwtWebMode-shell (está na pasta recém criada).

hostmode

O hostmoded é uma opção rápida para utilização durante a fase de desenvolvimento, mas nem todos os recursos que sua aplicação irá precisar são suportados.

Executando em WebMode

O que vamos fazer é criar um mecanismo capaz de compilar nossa aplicação e fazer o deploy dela em nosso servidor web. A melhor opção ainda é utilizar um script Ant

salve o arquivo abaixo na raiz de seu projeto com o nome build.xml

< ?xml version="1.0" encoding="UTF-8"?>


	
	

	
		
		
		
		
		
		
			
		

	

	
		
		
		
		

		
	

	
		
	

	
		
		
	

	
		
		
			
			
			
		
		
			
		
	

	
		
	

	
		
			
			
			
		
	

	
		
		
		
	

	
		
		
			
			
			
			
				
			
			
		
		
			
			
		
		
			
		




		
			
		
	

	
		
	

	
		
	

	
		
		
		

			
			
			
			
			

			
				
				
				
			

			
			
			
			
			
		
	


salve também esse arquivo de propriedades na mesma pasta com o nome build.properties

gwt.dir=/home/paulo/gwt
web.dir=${basedir}/WebContent
module=GwtWebMode
package=br.com.sample
url=http://localhost:8080/${ant.project.name}/${package}.${module}/${module}.html
war=${ant.project.name}.war

app.server.dir = /home/paulo/bin/apache-tomcat
app.server.deploy.dir = ${app.server.dir}/webapps
app.server.lib.dir = ${app.server.dir}/lib
gwt-security=OBFUSCATE

Não vou entrar nos detalhes dos arquivos.
O Eclipse deve está se “queixando” que não conhece as classes do GWT. Para resolver este problema copie os arquivos
$GWT_HOME/gwt-user.jar
$GWT_HOME/gwt-dev-linux.jar
$GWT_HOME/gwt-servlet.jar

para a pasta: gwtWebMode/WebContent/WEB-INF/lib e dê um refresh em seu projeto.

Certifique-se que o Tomcat esteja instalado e em execução.
Abra o arquivo build.properties e altere as variáveis gwt.dir e app.server.dir para refletir sua instalação
gwt.dir=/home/paulo/gwt-linux-1.5.2
app.server.dir = /home/paulo/bin/apache-tomcat

Edite seu arquivo web.xml modificando a tag welcome-file

welcome

Clique com botão direito no arquivo build.xml e escolha Run As/Ant Build. Após concluindo abra o browse no seguinte endereço:

http://localhost:8080/gwtWebMode/

webmode

Incluindo um Serviço RPC

Um outro importante recurso do GWT é a possibilidade de executar serviços remotos. Esses serviços são servlets especiais que fazem ponte entre o javascript gerado e a parte servidora, possibilitando assim um completa integração com outras aplicações e os mais variados frameworks que somos dependentes.

O nosso serviço apenas receberá uma String e retornará a quantidade de caracteres deste.
inicie criando a interface StringLengthService. Ela precisa estender a interface RemoteService.

interface

package br.com.sample.client;

import com.google.gwt.user.client.rpc.RemoteService;

public interface StringLengthService extends RemoteService {
	  public Integer length(String string);
}




Em seguida você precisa de uma outra interface que permitirá invocar os serviços de forma assíncrona, ou seja ele será executado em background e comunicado assim que houver uma “resposta” da execução do serviço.


package br.com.sample.client;

import com.google.gwt.user.client.rpc.AsyncCallback;

public interface StringLengthServiceAsync {
	  void length(String string, AsyncCallback async);
}

Por fim criaremos a classe responsável por implementar o serviço: Ela deve estender RemoteServiceServlet, implementar a interface StringLengthService anteriormente criada e deve ficar no

package br.com.sample.server

serviceimpl


package br.com.sample.server;

import br.com.sample.client.StringLengthService;

import com.google.gwt.user.server.rpc.RemoteServiceServlet;

public class StringLengthServiceImpl extends RemoteServiceServlet implements
		StringLengthService {

	@Override
	public Integer length(String string) {
		if (string != null)
			return string.length();
		return 0;
	}

}

Declando os Serviços

Aqui está um ponto crucial na execução de serviços RPC. Caso seu interese seja apenas executar seu serviço em hosted mode basta editar o arquivo GwtWebMode.gwt.xml declando nele seu serviço:

    	

Só que não bastará isto para utiliza-lo em webmode. Você precisará declara-lo no arquivo web.xml como se faz com qualquer servlet.

servletmap

Utilizando o Serviço

Por fim faremos agora a utilização do serviço. Crie uma referência ao serviço da seguinte forma:

		this.lengthService = (StringLengthServiceAsync) GWT.create(StringLengthService.class);
		((ServiceDefTarget) lengthService).setServiceEntryPoint(GWT.getModuleBaseURL()+ "/StringLength/StringLengthService");

Veja o código completo: GwtWebMode.java

package br.com.sample.client;

import com.google.gwt.core.client.EntryPoint;
import com.google.gwt.core.client.GWT;
import com.google.gwt.user.client.rpc.AsyncCallback;
import com.google.gwt.user.client.rpc.ServiceDefTarget;
import com.google.gwt.user.client.ui.Button;
import com.google.gwt.user.client.ui.ClickListener;
import com.google.gwt.user.client.ui.DialogBox;
import com.google.gwt.user.client.ui.Image;
import com.google.gwt.user.client.ui.Label;
import com.google.gwt.user.client.ui.RootPanel;
import com.google.gwt.user.client.ui.TextBox;
import com.google.gwt.user.client.ui.VerticalPanel;
import com.google.gwt.user.client.ui.Widget;

/**
 * Entry point classes define onModuleLoad().
 */
public class GwtWebMode implements EntryPoint {

	private StringLengthServiceAsync lengthService;

	/**
	 * This is the entry point method.
	 */
	public void onModuleLoad() {

		// prepara o serviço
		this.lengthService = (StringLengthServiceAsync) GWT.create(StringLengthService.class);
		((ServiceDefTarget) lengthService).setServiceEntryPoint(GWT.getModuleBaseURL()+ "/StringLength/StringLengthService");

		Image img = new Image("http://code.google.com/webtoolkit/logo-185x175.png");
		Button button = new Button("length");
		img.getElement().setId("pc-template-img");

		final TextBox textBox = new TextBox();
		final Label lengthLabel = new Label();

		VerticalPanel vPanel = new VerticalPanel();
		vPanel.setWidth("100%");
		vPanel.setHorizontalAlignment(VerticalPanel.ALIGN_CENTER);
		vPanel.add(img);
		vPanel.add(textBox);
		vPanel.add(button);
		vPanel.add(lengthLabel);

		// Add image and button to the RootPanel
		RootPanel.get().add(vPanel);

		button.addClickListener(new ClickListener() {
			public void onClick(Widget sender) {
				lengthService.length(textBox.getText(),
						new AsyncCallback() {

							public void onFailure(Throwable arg0) {
								lengthLabel.setText("foi mal! deu erro!");
							}

							public void onSuccess(Integer arg0) {
								lengthLabel.setText("length = "	+ arg0.toString());
							}
						}

				);
			}
		});
	}
}

final

Se deseja faça o download dos fontes gwtWebMode.zip

Categories: AJAX Tags:

ICEFaces, Ajax e JSF 1.2

O pessoal da ICESoft anunciou o release 1.6 do ICEFaces. O ICEFaces é um conjunto de componentes ricos para desenvolvimento web com JSF e AJAX.

Há alguns meses atrás tentei usa-lo em um novo projeto, mas desisti ao perceber que não poderia usa-lo junto com o glassfish. Essa incompatibilidade deve-se ao fato de o glassfish usar o JSF 1.2 por padrão e o ICEFaces a versão 1.1. Agora essa incompatibilidade acaba pois uma das novidades dessa nova versão é justamente a compatibilização com o JSF 1.2. Além desta, outras melhorias foram feitas como integração ao JBoss Seam 1.2.1, Liferay Portal, Webtide Jetty, dentre outras.

Categories: AJAX Tags:

Recuperando um datasource no Glassfish a partir de um cliente desktop

No post anterior falei como recuperar um datasource no Glassfish a partir de um client web. Hoje faleremos como fazer a mesma coisa. só que a partir de um client desktop.

O processo consiste em iniciar o contexto com atributos adicionais que auxiliem a aplicação a procurar de forma correta e encontrar o recurso solicitado.

public javax.sql.DataSource getDataSource() {
try {
Properties props = new Properties();
props.setProperty(Context.INITIAL_CONTEXT_FACTORY, "com.sun.enterprise.naming.SerialInitContextFactory");
props.setProperty(Context.URL_PKG_PREFIXES, "com.sun.enterprise.naming");
props.setProperty(Context.STATE_FACTORIES, "com.sun.corba.ee.impl.presentation.rmi.JNDIStateFactoryImpl");
// servidor
props.setProperty("org.omg.CORBA.ORBInitialHost", "localhost");
// porta do servidor
props.setProperty("org.omg.CORBA.ORBInitialPort", "3700");
InitialContext initialContext = new InitialContext(props);
DataSource datasource = (DataSource) initialContext.lookup("jdbc/seuDataSource");
return datasource;
} catch (NamingException ex) {
ex.printStackTrace();
return null;
}
}

Os atributos:

props.setProperty("org.omg.CORBA.ORBInitialHost", "localhost");
props.setProperty("org.omg.CORBA.ORBInitialPort", "3700");

são opcionais e só precisam ser utilizados se o servidor estiver em um endereço diferente do cliente ou porta for diferente da padrão.

Algo que é importante observar é que é necessário que o classpath da aplicação client esteja configurado com os seguintes pacotes:

$GLASSFISH_HOME/lib/appserv-admin.jar
$GLASSFISH_HOME/lib/appserv-rt.jar
$GLASSFISH_HOME/lib/install/applications/jmsra/imqjmsra.jar
$GLASSFISH_HOME/lib/javaee.jar

além, é claro, do pacote com o driver JDBC para banco de dados que você está tentando acessar.

Categories: java Tags:

Recuperando um datasource no Glassfish

Quando se está trabalhando com um servidor de aplicações, é comum a necessidade de se acessar diretamente os recursos do banco de dados.

Mesmo quando se está usando frameworks de persistência como JPA ou mesmo Entities Beans pode-se haver a necessidade de fazer alguma consulta direta ao banco de dados. Nesse caso a melhor opção recuperar o datasource registrado no servidor.

Os passos são os seguintes:
No arquivo web.xml registre o recurso que deseja recuperar:


jdbc/seuDataSource
javax.sql.DataSource
Container
Shareable

Após isso só é necessário buscar no contexto seu datasource. Alguma coisa mais ou menos assim:

public javax.sql.DataSource getDataSource() {
InitialContext initialContext;
try {
initialContext = new InitialContext();
DataSource datasource = (DataSource) initialContext.lookup("java:comp/env/jdbc/seuDataSource");
return datasource;
} catch (NamingException e) {
e.printStackTrace();
}
return null;
}

e para usar a conexão basta:

datasource.getConnection()
Categories: java Tags: