Estou estudando o GWT, esperando usar ele com Hibernate + Vraptor para fazer uma AGENDA, logo não sei se da para usar a salada, a ideia e esta.
Pelo que googlei, eu tenho que escrever um HTML com as tags que serão usadas pelo javascript que era java - risos- no Vraptor
/ (VRAPTOR)
|
| HibernateUtil (logica para configurar o hibernate) ----> hibernate.cfg.xml
| |
| |
| | |-------->Dao<T>(para não precisar construir varios Daos)
| | |-------->ClassisLogic (Logica para action)
| | | |
| | | |-------->Intereceptor (cria um DaoFactory e injeta na classe.)
| | | | |
| | | | |-------->UsuarioDao (em casos especiais.)
| | | |
| |-----------|--------------->DaoFactory (Construtor de Daos/Transações.)
| |
| |Classes com get e set etc…, (entidades)
|
GWT :
|
|
|
|
|ServiceDefTarget/RemoteService/RemoteServiceServlet (Importado pelo Framework classes)
|
|
|
|ServiceAsync/Service/SErviceImpl (Escrito pelo programador)
|
|
|
|
|
Service (Automatico)
No Hibernate é Assim:
ALGUÉM TEM UMA LUZ ?
[code]
package agenda.server;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import agenda.client.CompromissoBean;
import agenda.client.GreetingService;
import agenda.client.RecadoBean;
import com.google.gwt.user.server.rpc.RemoteServiceServlet;
/**
- The server side implementation of the RPC service.
*/
@SuppressWarnings("serial")
public class GreetingServiceImpl extends RemoteServiceServlet implements
GreetingService {
public Connection getConexao(){
Connection conn=null;
try {
Class.forName("com.mysql.jdbc.Driver").newInstance();
conn = DriverManager.getConnection("jdbc:mysql://localhost/nomebanco", "root", "");
} catch (Exception e) {
e.printStackTrace();
}
return conn;
}
public boolean login(String campoNome, String campoSenha) {
try{
Connection c = getConexao();
String sql = "select * from usuario";
Statement ps=null;
try {
ps = c.createStatement();
ResultSet rs = ps.executeQuery(sql);
boolean logado=false;
while(rs.next()){
String nome = rs.getString("nome");
String senha = rs.getString("senha");
if(nome.equalsIgnoreCase(campoNome) && senha.equals(campoSenha)){
logado=true;
}
}
if (logado==true){
return true;
}
else{
return false;
}
} finally{
c.close();
}
}catch (SQLException e) {
e.printStackTrace();
}
return false;
}
}
trocaria por : hibernate.cfg.xml, olha so que coisa linda em 30 linhas !!!
1. <!DOCTYPE hibernate-configuration PUBLIC
2. "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
3. "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
4.
5. <hibernate-configuration>
6. <session-factory>
7. <property name="hibernate.dialect">org.hibernate.dialect.HSQLDialect</property>
8. <property name="hibernate.connection.url">jdbc:hsqldb:file:mydvdsDB</property>
9. <property name="hibernate.connection.driver_class">org.hsqldb.jdbcDriver</property>
10. <property name="hibernate.connection.username">sa</property>
11. <property name="hibernate.connection.password"></property>
12. <!-- JDBC connection pool (use the built-in) -->
13. <property name="connection.pool_size">1</property>
14. <!-- SQL dialect
15. <property name="dialect">org.hibernate.dialect.PostgreSQLDialect</property>-->
16. <!-- Enable Hibernate's automatic session context management -->
17. <property name="current_session_context_class">thread</property>
18. <!-- Disable the second-level cache -->
19. <property name="cache.provider_class">org.hibernate.cache.NoCacheProvider</property>
20. <!-- Echo all executed SQL to stdout -->
21. <property name="show_sql">true</property>
22. <!-- Drop and re-create the database schema on startup
23. tem que deixar essa propriedade ativa apos alguma modificação nas
24. tabelas ou no mapeamento, e depois comentar novamente, pois ela apaga
25. o que tem na tabela -->
26. <property name="hbm2ddl.auto">update</property>
27. <mapping class="hiberapp0.Shinigami"/>
28. <mapping class="hiberapp0.Evento"/>
29. </session-factory>
30. </hibernate-configuration>
package agenda.client;
import java.util.ArrayList;
import com.google.gwt.user.client.rpc.RemoteService;
import com.google.gwt.user.client.rpc.RemoteServiceRelativePath;
/**
* The client side stub for the RPC service.
*/
@RemoteServiceRelativePath("greet")
public interface GreetingService extends RemoteService {
boolean login(String campoNome, String campoSenha);
}
package agenda.client;
import java.util.ArrayList;
import com.google.gwt.user.client.rpc.AsyncCallback;
/**
* The async counterpart of <code>GreetingService</code>.
*/
public interface GreetingServiceAsync {
void login(String campoNome, String campoSenha, AsyncCallback<Boolean> callback);
}
package agenda.client;
import com.google.gwt.user.client.rpc.AsyncCallback;
import com.google.gwt.user.client.ui.RootPanel;
import com.gwtext.client.core.EventObject;
import com.gwtext.client.widgets.Button;
import com.gwtext.client.widgets.MessageBox;
import com.gwtext.client.widgets.Panel;
import com.gwtext.client.widgets.event.ButtonListenerAdapter;
import com.gwtext.client.widgets.form.FormPanel;
import com.gwtext.client.widgets.form.Label;
import com.gwtext.client.widgets.form.TextField;
public class TelaLogin extends Agenda{
public void onModuleLoad() {
//Login
final Panel pnLogin = new Panel();
pnLogin.setBorder(false);
pnLogin.setPaddings(15);
final FormPanel frmPanelLogin = new FormPanel();
frmPanelLogin.setFrame(true);
frmPanelLogin.setTitle("TITULO FICA AQUI");
frmPanelLogin.setWidth(250);
frmPanelLogin.setLabelWidth(75);
Label label = new Label();
label.setCls("simple-form-label");
label.setWidth(350);
label.setHeight(20);
final TextField tfLogin = new TextField("Login", "login",150);
frmPanelLogin.add(tfLogin);
final TextField tfSenha = new TextField("Senha", "senha", 150);
tfSenha.setPassword(true);
frmPanelLogin.add(tfSenha);
Button btEntrar = new Button("Entrar", new ButtonListenerAdapter() {
public void onClick(Button btEntrar, EventObject e) {
GetService.getService.login(tfLogin.getValueAsString(), tfSenha.getValueAsString(), new AsyncCallback<Boolean>(){
//TelaMenu tm = new TelaMenu();
public void onSuccess(Boolean result) {
if(result){
RootPanel.get("meioM").clear();
TelaMenu tm = new TelaMenu();
tm.onModuleLoad();
}
else{
MessageBox.alert("Usuário e/ou senha inválido(s)!");
}
}
public void onFailure(Throwable caught) {
MessageBox.alert("Falha na conexão!");
}
});
}
});
frmPanelLogin.add(btEntrar);
pnLogin.add(frmPanelLogin);
RootPanel.get("meioM").add(pnLogin);
}
}
recebir um email :
Utilizando o Hibernate no GWT
Olá amiguinhos.
Vou mostrar um simples exemplo de como fazer um cadastro no GWT utilizando Hibernate. Eu achei muito trabalhoso pelo fato de não poder utilizar os recursos do Java 5. Mas em breve teremos a possibilidade de utilizar o Java 5 no GWT.
Primeiro, vamos fazer uma interface bem tosca, só com os campos necessários para nosso teste. Detalhe, esse esquema também funciona com o MyGWT, basta mudar os componentes. Vou evitar falar sobre a configuração do Hibernate, eu utilizo xml ainda, então não vou entrar em tantos detalhes.
Crie o projeto do GWT e crie uma classe chamada Principal, como segue abaixo:
package org.cadastrogwt.client;
public class Principal implements EntryPoint {
public void onModuleLoad() {
// Cria o formulario para cadastro
final FormPanel form = new FormPanel();
final VerticalPanel p = new VerticalPanel();
form.setWidget(p);
final Label lbNome = new Label("Nome");
p.add(lbNome);
final TextBox txtNome = new TextBox();
txtNome.setName("txtNome");
p.add(txtNome);
final Label lbCidade = new Label("Cidade");
p.add(lbCidade);
final TextBox txtCidade = new TextBox();
txtCidade.setName("txtCidade");
p.add(txtCidade);
// Cria um botao e define um evento para ele
Button btCadastrar = new Button("Cadastrar");
p.add(btCadastrar);
RootPanel.get().add(form);
}
}
Lembrando que eu não estou me preocupando muito com a aparência, e essa vai ficar muito feia hehe. Após isso, temos que criar as interfaces que vão controlar os dados e trabalhar RPC e a classe de "entidade". Devido ao problema do código do GWT ser compatível com o Java 1.4, vamos ter que duplicar essa classe de entidade no lado do server, com suas devidas annotations. Criamos então a classe Cadastro:
package org.cadastrogwt.client;
import com.google.gwt.user.client.rpc.IsSerializable;
public class Cadastro implements IsSerializable {
private String nome;
private String cidade;
private String estado;
public String getNome() {
return nome;
}
public void setNome(String nome) {
this.nome = nome;
}
public String getCidade() {
return cidade;
}
public void setCidade(String cidade) {
this.cidade = cidade;
}
public String getEstado() {
return estado;
}
public void setEstado(String estado) {
this.estado = estado;
}
}
Depois criamos duas interfaces, uma para o método que retornará alguma coisa do servidor e outra que enviará alguma coisa para o servidor. Simples não? Criamos a interface CadastroService:
package org.cadastrogwt.client;
import com.google.gwt.user.client.rpc.RemoteService;
public interface CadastroService extends RemoteService {
public String cadastrar(Cadastro c);
}
E a interface CadastroServiceAsync:
package org.cadastrogwt.client;
import com.google.gwt.user.client.rpc.AsyncCallback;
public interface CadastroServiceAsync {
public void cadastrar(Cadastro c, AsyncCallback callback);
}
Um detalhe muito importante e que é regra no GWT, apanhei muito no começo pra descobrir isso hehe. Essas duas interfaces, precisam obrigatóriamente conter Service e ServiceAsync nos nomes delas. Então crie um padrão, por exemplo, eu quero trabalhar com a classe Cidadao com o RPC, então eu vou criar as interfaces CidadaoService e CidadaoServiceAsync.
Bom, está quase pronto, agora precisamos criar um pacote no mesmo nível dos pacotes org.cadastrogwt.client e org.cadastrogwt.public. Crie um pacote chamado org.cadastrogwt.server. Tudo que ficar neste pacote é livre pra usar qualquer recurso do Java, Hibernate, Struts, tudo mesmo, pois ele será executado no servidor e não no cliente. Então criamos uma classe chamada CadastroServiceImpl (Mesma regra das interfaces também):
package org.cadastrogwt.server;
import org.cadastrogwt.client.Cadastro;
import org.cadastrogwt.client.CadastroService;
import com.google.gwt.user.server.rpc.RemoteServiceServlet;
public class CadastroServiceImpl extends RemoteServiceServlet
implements CadastroService {
private static final long serialVersionUID = 1L;
public String cadastrar(Cadastro c) {
// Valores definidos pelo cliente
String nome = c.getNome();
String cidade = c.getCidade();
String estado = c.getEstado();
String retorno = null;
// Hibernate
CadastroServerDao cdao = new CadastroServerDao();
cdao.insert(nome, cidade, estado);
retorno = "Cadastro efetuado com sucesso!!!";
return retorno;
}
}
Esta classe pega tudo que foi setado na classe Cadastro e passa para o Dao. Se pudesse usar annotations, eu poderia pegar o objeto c e já mandar para o Dao, mas vamos aguardar a versão 1.5 :)
Bom, agora para dar certo, vamos criar uma classe igual a classe Cadastro, mas mapeando-a. Criamos a classe CadastroServer:
package org.cadastrogwt.server;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;
@Entity
@Table(name = "cadastro")
public class CadastroServer {
@Id
@Column(name = "id_cadastro")
private int id;
@Column(length = 100)
private String nome;
@Column(length = 50)
private String cidade;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getNome() {
return nome;
}
public void setNome(String nome) {
this.nome = nome;
}
public String getCidade() {
return cidade;
}
public void setCidade(String cidade) {
this.cidade = cidade;
}
}
Beleza, agora é só criar o Dao. Criamos a classe CadastroServerDao:
package org.cadastrogwt.server;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.AnnotationConfiguration;
import org.hibernate.cfg.Configuration;
public class CadastroServerDao {
private Session session;
private Transaction tx;
public CadastroServerDao() {
Configuration cfg = new AnnotationConfiguration();
cfg.configure("/org/cadastrogwt/server/hibernate.cfg.xml");
SessionFactory sf = cfg.buildSessionFactory();
session = sf.openSession();
tx = session.beginTransaction();
}
public void insert(String nome, String cidade, String estado) {
CadastroServer cad = new CadastroServer();
cad.setCidade(cidade);
cad.setEstado(estado);
cad.setNome(nome);
session.save(cad);
tx.commit();
session.close();
}
}
Fica a critério de cada um como usar o Configuration. Pronto, a parte do server está pronta. Agora vamos voltar para a parte do client novamente, para preparar a classe Principal para trabalhar com o AsyncCallback que faz a mesma coisa que o Ajax. Modifique a classe Principal para que fique com a mesma aparência que esta:
package org.cadastrogwt.client;
import *****;
public class Principal implements EntryPoint, AsyncCallback {
private CadastroServiceAsync service;
private void asyncCadastro(Cadastro c) {
this.service.cadastrar(c, this);
}
public void onModuleLoad() {
// Inicia a sincronizacao com o servlet
service = (CadastroServiceAsync)
GWT.create(CadastroService.class);
ServiceDefTarget target = (ServiceDefTarget) service;
target.setServiceEntryPoint(GWT.getModuleBaseURL() +
"cadastro");
// Cria o formulario para cadastro
final FormPanel form = new FormPanel();
final VerticalPanel p = new VerticalPanel();
form.setWidget(p);
final Label lbNome = new Label("Nome");
p.add(lbNome);
final TextBox txtNome = new TextBox();
txtNome.setName("txtNome");
p.add(txtNome);
final Label lbCidade = new Label("Cidade");
p.add(lbCidade);
final TextBox txtCidade = new TextBox();
txtCidade.setName("txtCidade");
p.add(txtCidade);
// Cria um botao e define um evento para ele
Button btCadastrar = new Button("Cadastrar",
new ClickListener() {
public void onClick(Widget sender) {
Cadastro cad = new Cadastro();
cad.setCidade(txtCidade.getText());
cad.setNome(txtNome.getText());
asyncCadastro(cad);
}
});
p.add(btCadastrar);
RootPanel.get().add(form);
}
public void onFailure(Throwable caught) {
// Joga uma mensagem de erro caso ocorra
Window.alert(caught.getMessage());
}
public void onSuccess(Object result) {
// Retorna a resposta do servidor
Window.alert(result.toString());
}
}
Pronto, agora antes de testar, é necessário criar uma linha no xml do projeto GWT, que seria Principal.gwt.xml. Adicione depois da tag entry-point:
<servlet path="/cadastro"
class="org.cadastrogwt.server.CadastroServiceImpl" />
Pronto, rode o projeto e tente fazer um cadastro e depois olhe no banco de dados se foi corretamente. Eu não vou explicar como faz a listagem, porque seria legal se desse pra retornar do servidor um ArrayList mas não consegui, vou fazer mais testes. Mas fica ae pra diversão de vocês. Usei como base os exemplos que vem no pacote do GWT, lá tem o pacote DynamTable que usa recursos do RPC.
FONTES: http://andersonajx.blogspot.com/2008/06/utilizando-o-hibernate-no-gwt.html