Desenvolvendo aplicações Java com os frameworks GWT e GXT

package br.com.client.domain;
import java.io.Serializable;
import com.extjs.gxt.ui.client.data.BaseModel;

public class PersonG extends BaseModel implements Serializable {

	private static final long serialVersionUID = 1L;
	private Integer code;
	private String name;
	private String phone;
	private String cell;
	private String email;

	public Integer getCode() {
		return get("code");
	}

	public void setCode(Integer code) {
		set("code", code);
	}

	public String getName() {
		return get("name");
	}

	public void setName(String name) {
		set("name", name);
	}

	public String getPhone() {
		return get("phone");
	}

	public void setPhone(String phone) {
		set("phone", phone);
	}

	public String getCell() {
		return get("cell");
	}

	public void setCell(String cell) {
		set("cell", cell);
	}

	public String getEmail() {
		return get("email");
	}

	public void setEmail(String email) {
		set("email", email);
	}

}

package br.com.client.application;

import br.com.client.domain.PersonG;

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

@RemoteServiceRelativePath ("personController")
public interface PersonApplication extends RemoteService{

	public void save(PersonG person);
	public void update(PersonG person);
	public PersonG findById(int id);
	public void delete(PersonG person);
}

package br.com.client.application;

import br.com.client.domain.PersonG;

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

public interface PersonApplicationAsync {

	void save(PersonG person, AsyncCallback<Void> callback);

	void update(PersonG person, AsyncCallback<Void> callback);

	void delete(PersonG person, AsyncCallback<Void> callback);

	void findById(int id, AsyncCallback<PersonG> callback);

}

package br.com.client.converter;
import br.com.client.domain.PersonG;
import br.com.domain.Person;

public class PersonConverter {

	private Person person;
	private PersonG personG;

	public Person personConverterG(PersonG personG){
		person = new Person();
		person.setCode(personG.getCode());
		person.setName(personG.getName());
		person.setEmail(personG.getEmail());
		person.setPhone(personG.getPhone());
		person.setCell(personG.getCell());
		return person;
	}

	public PersonG personConverter(Person person){
		personG = new PersonG();

		personG.setCode(person.getCode());
		personG.setName(person.getName());
		personG.setPhone(person.getPhone());
		personG.setCell(person.getCell());
		personG.setEmail(person.getEmail());
		return personG;
	}
}

package br.com.server;
import br.com.client.application.PersonApplication;
import br.com.client.converter.PersonConverter;
import br.com.client.domain.PersonG;
import br.com.database.impl.PersonRepositoryImpl;
import br.com.domain.Person;
import br.com.domain.PersonRepository;

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

public class PersonApplicationImpl extends RemoteServiceServlet
implements PersonApplication{

	private static final long serialVersionUID = 1L;
	private PersonConverter pConverter;
	private PersonRepository pRep;
	private Person person;

	public PersonApplicationImpl() {
		pConverter = new PersonConverter();
		pRep = new PersonRepositoryImpl();
	}

	@Override
	public void save(PersonG personG) {
		person = pConverter.personConverterG(personG);
		pRep.save(person);
	}

	@Override
	public void update(PersonG person) {
		// TODO Auto-generated method stub
	}

	@Override
	public PersonG findById(int id) {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public void delete(PersonG person) {
		// TODO Auto-generated method stub
	}
}

package br.com.domain;

import java.io.Serializable;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.SequenceGenerator;
@Entity (name="tb_person")
public class Person implements Serializable {

	private static final long serialVersionUID = 1L;

	@Id
	@SequenceGenerator (initialValue = 1, allocationSize=1,
	sequenceName="person_seq", name="person_seq")
	@GeneratedValue (generator="person_seq", strategy=GenerationType.AUTO)
	@Column (nullable=false)
	private Integer code;
	private String name;
	private String email;
	private String phone;
	private String cell;

	public Integer getCode() {
		return code;
	}

	public void setCode(Integer code) {
		this.code = code;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getEmail() {
		return email;
	}

	public void setEmail(String email) {
		this.email = email;
	}

	public String getPhone() {
		return phone;
	}

	public void setPhone(String phone) {
		this.phone = phone;
	}

	public String getCell() {
		return cell;
	}

	public void setCell(String cell) {
		this.cell = cell;
	}
}

package br.com.domain;
public interface PersonRepository {
	public void save(Person person);
	public void update(Person person);
	public Person findById(int id);
	public void delete(Person person);
}

package br.com.database;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import org.hibernate.Session;

public class ConnectionFactory {
	private static EntityManagerFactory emf = Persistence
			.createEntityManagerFactory("JPAUnit");
	private static EntityManager entityManager;

	public static EntityManager getEntityManager() {
		entityManager = emf.createEntityManager();
		return entityManager;
	}

	public static Session getSession() {
		return (Session) entityManager.getDelegate();
	}
}

package br.com.database.impl;

import javax.persistence.EntityManager;
import br.com.database.ConnectionFactory;
import br.com.domain.Person;
import br.com.domain.PersonRepository;

public class PersonRepositoryImpl implements PersonRepository{

	private EntityManager em;

	public PersonRepositoryImpl() {
		em = ConnectionFactory.getEntityManager();
	}

	@Override
	public void save(Person person) {
		em.getTransaction().begin();
		em.persist(person);
		em.getTransaction().commit();
		em.close();
	}

	@Override
	public void update(Person person) {
		// TODO Auto-generated method stub
	}
	@Override
	public Person findById(int id) {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public void delete(Person person) {
		// TODO Auto-generated method stub
	}
}

package br.com.client;

import com.google.gwt.core.client.EntryPoint;
import com.google.gwt.user.client.ui.RootPanel;

/**
 * Entry point classes define <code>onModuleLoad()</code>.
 */
public class GWTProj implements EntryPoint {

	@Override
	public void onModuleLoad() {
		RootPanel.get().add(new PessoaView());
	}
}

package br.com.client;

import br.com.client.application.PersonApplication;
import br.com.client.application.PersonApplicationAsync;
import br.com.client.domain.PersonG;
import com.extjs.gxt.ui.client.event.ButtonEvent;
import com.extjs.gxt.ui.client.event.Events;
import com.extjs.gxt.ui.client.event.Listener;
import com.extjs.gxt.ui.client.widget.Info;
import com.extjs.gxt.ui.client.widget.Window;
import com.extjs.gxt.ui.client.widget.button.Button;
import com.extjs.gxt.ui.client.widget.form.FormPanel;
import com.extjs.gxt.ui.client.widget.form.TextField;
import com.google.gwt.core.client.GWT;
import com.google.gwt.user.client.rpc.AsyncCallback;

public class PessoaView extends Window{

	private PersonApplicationAsync app = GWT.create(PersonApplication.class);

	private TextField<String> fieldName = new TextField<String>();
	private TextField<String> fieldEmail = new TextField<String>();
	private TextField<String> fieldPhone = new TextField<String>();
	private TextField<String> fieldCell = new TextField<String>();

	private PersonG person;

	private Button btSave = new Button("Salvar");

	private FormPanel fp = new FormPanel();
	public PessoaView() {
		setHeading("Incluir Pessoa");
		setMinimizable(false);
		setSize(350, 175);
		configure();
		configureBtSave();
	}

	private void configure(){
		fp.setHeaderVisible(false);
		fieldName.setFieldLabel("Nome");
		fp.add(fieldName);

		fieldEmail.setFieldLabel("Email");
		fp.add(fieldEmail);

		fieldPhone.setFieldLabel("Fixo");
		fp.add(fieldPhone);

		fieldCell.setFieldLabel("Celular");
		fp.add(fieldCell);
		add(fp);

		fp.add(btSave);
		add(fp);
		layout();
	}

	private PersonG getPerson(){
		person = new PersonG();

		person.setName(fieldName.getValue());
		person.setEmail(fieldEmail.getValue());
		person.setPhone(fieldPhone.getValue());
		person.setCell(fieldCell.getValue());
		return person;
	}

	private void configureBtSave(){
		btSave.addListener(Events.OnClick, new Listener<ButtonEvent>() {

			@Override
			public void handleEvent(ButtonEvent be) {
				app.save(getPerson(), new AsyncCallback<Void>() {

					@Override
					public void onSuccess(Void result) {
						Info.display("Sucesso","");
					}

					@Override
					public void onFailure(Throwable caught) {
						Info.display("Falha","");
					}
				});
			}
		});
	}
}