gwt-2.8.2下載

本分步指南將介紹如何使用以下方法開發簡單的Web應用程序 Google的網絡工具包 （GWT）用于富客戶端，而Spring作為后端服務器端框架。 該示例Web應用程序將提供對數據庫執行CRUD（創建檢索更新刪除）操作的功能。 對于數據訪問層，我們將在Hibernate上使用JPA ，對于數據庫，我們將使用Hypersonic 。 當然，您可以更改配置并使用所需的任何內容。 我們將Web應用程序部署到Apache – Tomcat實例。

我們首選的開發環境是Eclipse ，因此，前提條件是必須安裝具有GWT支持的Eclipse 。 用于Eclipse的GWT插件的安裝不在本教程的討論范圍之內，因此不再討論。 但是，您將需要以下組件：

從這里 蝕

從這里開始 ，Eclipse的GWT插件

從這里發布Spring框架

Hibernate持久性框架從這里發布

來自這里的 Hypersonic數據庫

從這里開始 Apache Commons-Logging庫

來自這里的 AOP Alliance （Java / J2EE AOP標準）庫

從這里開始 SLF4J庫

來自這里的 Apache log4j庫

最后但并非最不重要的一點，從此處下載GWT – Spring“膠水”庫spring4gwt

我們將使用Eclipse Galileo， GWT版本2.0.3， Spring版本3.0.1， Hibernate版本3.5.2， Hypersonic版本1.8.1.2， Apache Commons-logging版本1.1.1， AOP Alliance （Java / J2EE AOP Standard）版本本教程的1.0， SLF4J 1.5.8版， Apache log4j 1.2.16版和spring4gwt 0.0.1版。

聊夠了，讓我們動手吧！

創建一個新的GWT項目，轉到File？ 新的Web應用程序項目

我們將項目命名為GWTSpring。 基本軟件包為com.javacodegeeks.gwtspring，也僅使用Google Web Toolkit，因此在向導窗口中取消選中“ Use Google App Engine ”。

讓我們回顧一下有關GWT項目結構的一些事情

/ src文件夾包含應用程序的所有源文件

• {package_name} .client子軟件包包含僅適用于應用程序客戶端的所有源文件

• {package_name} .server子軟件包包含僅對應用程序的服務器端部分可用的所有源文件

• {package_name} .shared子包包含應用程序的客戶端和服務器端都可用的所有源文件

• / test文件夾包含用于單元測試的所有源文件
• / war文件夾包含用于創建有效的Web應用程序的基本文件

• 為了在運行時正確地將Spring與GWT集成，我們必須向Web應用程序提供所有必需的庫。 因此，復制下面在/ war / WEB-INF / lib下列出的文件（如果使用的是不同版本，請復制相關文件）

  從Spring發行

  • /dist/org.springframework.expression-3.0.1.RELEASE-A.jar
  • /dist/org.springframework.beans-3.0.1.RELEASE-A.jar
  • /dist/org.springframework.oxm-3.0.1.RELEASE-A.jar
  • /dist/org.springframework.jms-3.0.1.RELEASE-A.jar
  • /dist/org.springframework.jdbc-3.0.1.RELEASE-A.jar
  • /dist/org.springframework.core-3.0.1.RELEASE-A.jar
  • /dist/org.springframework.context-3.0.1.RELEASE-A.jar
  • /dist/org.springframework.asm-3.0.1.RELEASE-A.jar
  • /dist/org.springframework.aspects-3.0.1.RELEASE-A.jar
  • /dist/org.springframework.transaction-3.0.1.RELEASE-A.jar
  • /dist/org.springframework.context.support-3.0.1.RELEASE-A.jar
  • /dist/org.springframework.aop-3.0.1.RELEASE-A.jar
  • /dist/org.springframework.orm-3.0.1.RELEASE-A.jar
  • /dist/org.springframework.instrument-3.0.1.RELEASE-A.jar
  • /dist/org.springframework.instrument.tomcat-3.0.1.RELEASE-A.jar
  • /dist/org.springframework.test-3.0.1.RELEASE-A.jar
  • /dist/org.springframework.web-3.0.1.RELEASE-A.jar
  • /dist/org.springframework.web.portlet-3.0.1.RELEASE-A.jar
  • /dist/org.springframework.web.servlet-3.0.1.RELEASE-A.jar
  • /dist/org.springframework.web.struts-3.0.1.RELEASE-A.jar

  從Hibernate發行版

  • hibernate3.jar
  • /lib/required/antlr-2.7.6.jar
  • /lib/required/commons-collections-3.1.jar
  • /lib/required/dom4j-1.6.1.jar
  • /lib/required/javassist-3.9.0.GA.jar
  • /lib/required/jta-1.1.jar
  • /lib/required/slf4j-api-1.5.8.jar
  • /lib/jpa/hibernate-jpa-2.0-api-1.0.0.Final.jar
  • /lib/optional/c3p0/c3p0-0.9.1.jar

  從高超音速分布

  • /lib/hsqldb.jar

  從Apache Commons Logging發行版中

  • commons-logging-1.1.1.jar

  來自AOP聯盟 （Java / J2EE AOP標準）發行版

  • aopalliance.jar

  從SLF4J發行版

  • slf4j-log4j12-1.5.8.jar

  從Apache log4j發行版

  • log4j-1.2.16.jar

  sping4gwt庫

  • spring4gwt-0.0.1.jar

  現在，我們必須注意Eclipse項目的依賴性。 以下jars應該包含在項目的Java構建路徑中：

  • hibernate-jpa-2.0-api-1.0.0.Final.jar
  • org.springframework.beans-3.0.1.RELEASE-A.jar
  • org.springframework.context-3.0.1.RELEASE-A.jar
  • org.springframework.core-3.0.1.RELEASE-A.jar
  • org.springframework.orm-3.0.1.RELEASE-A.jar
  • org.springframework.transaction-3.0.1.RELEASE-A.jar

  下一步是為Web應用程序提供鉤子，以便在啟動時加載Spring上下文，并允許spring4gwt攔截客戶端和服務器之間的RPC調用，并將其轉換為Spring服務調用。

  在/ war / WEB-INF下找到web.xml文件，并添加以下內容：

  為了在啟動時加載Spring上下文，

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

  在Servlet部分，包括

  <servlet><servlet-name>springGwtRemoteServiceServlet</servlet-name><servlet-class>org.spring4gwt.server.SpringGwtRemoteServiceServlet</servlet-class> </servlet>

  在servlet映射部分中，供spring4gwt攔截RPC調用。

  <servlet-mapping><servlet-name>springGwtRemoteServiceServlet</servlet-name><url-pattern>/gwtspring/springGwtServices/*</url-pattern> </servlet-mapping>

  這里要注意的事情：

• 應該將springGwtRemoteServiceServlet servlet的servlet-mapping元素的url-pattern子元素更改為您的GWT模塊名稱，例如{module_name} / springGwtServices / *，該模塊名稱在{project_name} .gwt.xml文件中定義（此處為GWTSpring.gwt.xml）位于/ src文件夾下項目基本軟件包的根目錄
• 您可以將spring4gwt Servlet的名稱（此處為springGwtRemoteServiceServlet）更改為任意名稱

要繼續，我們必須創建persistence.xml文件，以描述使用JPA與數據庫的連接。 pesistence.xml文件必須位于META-INF目錄中，而該目錄又必須由Web應用程序在運行時（在類路徑上）訪問。 為了滿足上述要求，我們必須在項目的/ war / WEB-INF / classes文件夾下創建META-INF文件夾。 為此，我們以“ resources”為名稱創建一個新的源文件夾，并在其中創建META-INF文件夾。 最后，在/ resources / META-INF文件夾中創建persistence.xml文件。 下面顯示了一個示例persistence.xml

<persistence xmlns="http://java.sun.com/xml/ns/persistence"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd"version="2.0"><persistence-unit name="MyPersistenceUnit" transaction-type="RESOURCE_LOCAL"><provider>org.hibernate.ejb.HibernatePersistence</provider><properties><property name="hibernate.hbm2ddl.auto" value="update"/><property name="hibernate.show_sql" value="false"/><property name="hibernate.dialect" value="org.hibernate.dialect.HSQLDialect"/><property name="hibernate.connection.driver_class" value="org.hsqldb.jdbcDriver"/><property name="hibernate.connection.url" value="jdbc:hsqldb:mem:javacodegeeks"/><property name="hibernate.connection.username" value="sa"/><property name="hibernate.connection.password" value=""/><property name="hibernate.c3p0.min_size" value="5"/><property name="hibernate.c3p0.max_size" value="20"/><property name="hibernate.c3p0.timeout" value="300"/><property name="hibernate.c3p0.max_statements" value="50"/><property name="hibernate.c3p0.idle_test_period" value="3000"/></properties></persistence-unit></persistence>

這里要注意的事情：

• 如果您打算將Web應用程序部署到支持JTA事務（例如JBoss）的J2EE應用服務器或使用其他數據庫（例如Oracle ， MySQL等），請參閱此處的 “ JBoss Spring JPA Hibernate教程”以了解替代配置。

現在讓我們創建將驅動Spring容器的applicationContext.xml文件。 在/ war / WEB-INF目錄下創建文件。 下面顯示了一個示例applicationContext.xml

<beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"xmlns:aop="http://www.springframework.org/schema/aop" xmlns:context="http://www.springframework.org/schema/context"xmlns:jee="http://www.springframework.org/schema/jee" xmlns:tx="http://www.springframework.org/schema/tx"xmlns:task="http://www.springframework.org/schema/task"xsi:schemaLocation="http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsdhttp://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsdhttp://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsdhttp://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.0.xsdhttp://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsdhttp://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task-3.0.xsd"><context:component-scan base-package="com.javacodegeeks.gwtspring"/><task:annotation-driven executor="myExecutor" scheduler="myScheduler"/><task:executor id="myExecutor" pool-size="5"/><task:scheduler id="myScheduler" pool-size="10"/><tx:annotation-driven/><bean class="org.springframework.orm.jpa.LocalEntityManagerFactoryBean" id="entityManagerFactory"><property name="persistenceUnitName" value="MyPersistenceUnit"/></bean><bean class="org.springframework.orm.jpa.JpaTransactionManager" id="transactionManager"><property name="entityManagerFactory" ref="entityManagerFactory"/></bean></beans>

這里要注意的事情：

• 將context：component-scan元素的base-package屬性更改為項目的基本包，以便對其進行Spring組件（服務，DAO等）的掃描。
• 根據persistence.xml文件中的指示，將entityManagerFactory bean的persistentUnitName屬性的value屬性更改為您的持久單元的名稱
• 如果您打算將Web應用程序部署到支持JTA事務的J2EE應用程序服務器（例如JBoss），請參閱此處的 “ JBoss Sping JPA Hibernate教程”以了解替代配置。

在本教程的最后一部分中，我們將介紹用于在客戶端和服務器之間傳輸數據的數據傳輸對象（DTO），用于訪問數據庫的數據訪問對象（DAO）和用于公開功能的Spring服務。到GWT Web客戶端。

DTO是客戶端和服務器都可以使用的對象，因此您應該在“共享”程序包下創建一個“ dto”子程序包，然后將DTO放置在此位置。 我們將創建一個EmployeeDTO，其中包含有關員工的信息，如下所示

package com.javacodegeeks.gwtspring.shared.dto;import javax.persistence.Column; import javax.persistence.Entity; import javax.persistence.Id; import javax.persistence.Table;@Entity @Table(name = "EMPLOYEE") public class EmployeeDTO implements java.io.Serializable {private static final long serialVersionUID = 7440297955003302414L;@Id@Column(name="employee_id")private long employeeId;@Column(name="employee_name", nullable = false, length=30)private String employeeName;@Column(name="employee_surname", nullable = false, length=30)private String employeeSurname;@Column(name="job", length=50)private String job;public EmployeeDTO() {}public EmployeeDTO(int employeeId) {this.employeeId = employeeId; }public EmployeeDTO(long employeeId, String employeeName, String employeeSurname,String job) {this.employeeId = employeeId;this.employeeName = employeeName;this.employeeSurname = employeeSurname;this.job = job;}public long getEmployeeId() {return employeeId;}public void setEmployeeId(long employeeId) {this.employeeId = employeeId;}public String getEmployeeName() {return employeeName;}public void setEmployeeName(String employeeName) {this.employeeName = employeeName;}public String getEmployeeSurname() {return employeeSurname;}public void setEmployeeSurname(String employeeSurname) {this.employeeSurname = employeeSurname;}public String getJob() {return job;}public void setJob(String job) {this.job = job;}}

DAO對象將用于訪問數據庫并執行CRUD（創建檢索更新刪除）操作。 它是服務器端組件，因此應放置在我們項目的“服務器”子程序包下。 創建一個“ dao”子程序包，然后將DAO放在此處。 下面是一個示例DAO

package com.javacodegeeks.gwtspring.server.dao;import javax.annotation.PostConstruct; import javax.persistence.EntityManagerFactory;import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Repository;import com.javacodegeeks.gwtspring.shared.dto.EmployeeDTO;@Repository("employeeDAO") public class EmployeeDAO extends JpaDAO<Long, EmployeeDTO> {@AutowiredEntityManagerFactory entityManagerFactory;@PostConstructpublic void init() {super.setEntityManagerFactory(entityManagerFactory);}}

如您所見，EmployeeDAO類擴展了基本的DAO類（JpaDAO）。 EmployeeDAO類可以包含有關EmployeeDTO對象的特定查詢，但是所有CRUD操作都可以從基本DAO類（JpaDAO）處理。 在“ dao”子程序包下，將JpaDAO類與EmployeeDAO類放在同一級別。 下面我們介紹JpaDAO類

package com.javacodegeeks.gwtspring.server.dao; import java.lang.reflect.ParameterizedType; import java.util.List; import javax.persistence.EntityManager; import javax.persistence.PersistenceException; import javax.persistence.Query; import org.springframework.orm.jpa.JpaCallback; import org.springframework.orm.jpa.support.JpaDaoSupport; public abstract class JpaDAO<K, E> extends JpaDaoSupport { protected Class<E> entityClass; @SuppressWarnings("unchecked") public JpaDAO() { ParameterizedType genericSuperclass = (ParameterizedType) getClass() .getGenericSuperclass(); this.entityClass = (Class<E>) genericSuperclass .getActualTypeArguments()[1]; } public void persist(E entity) { getJpaTemplate().persist(entity); } public void remove(E entity) { getJpaTemplate().remove(entity); } public E merge(E entity) { return getJpaTemplate().merge(entity); } public void refresh(E entity) { getJpaTemplate().refresh(entity); } public E findById(K id) { return getJpaTemplate().find(entityClass, id); } public E flush(E entity) { getJpaTemplate().flush(); return entity; } @SuppressWarnings("unchecked") public List<E> findAll() { Object res = getJpaTemplate().execute(new JpaCallback() { public Object doInJpa(EntityManager em) throws PersistenceException { Query q = em.createQuery("SELECT h FROM " + entityClass.getName() + " h"); return q.getResultList(); } }); return (List<E>) res; } @SuppressWarnings("unchecked") public Integer removeAll() { return (Integer) getJpaTemplate().execute(new JpaCallback() { public Object doInJpa(EntityManager em) throws PersistenceException { Query q = em.createQuery("DELETE FROM " + entityClass.getName() + " h"); return q.executeUpdate(); } }); }}

最后，我們將為GWT客戶端創建服務接口和實現類。 客戶端和服務器都應可以訪問該服務接口，因此應將其放置在我們項目的“共享”子包下。 創建一個“服務”子程序包，并將服務接口放置在那里。 下面是一個示例接口類

package com.javacodegeeks.gwtspring.shared.services;import com.google.gwt.user.client.rpc.RemoteService; import com.google.gwt.user.client.rpc.RemoteServiceRelativePath;import com.javacodegeeks.gwtspring.shared.dto.EmployeeDTO;@RemoteServiceRelativePath("springGwtServices/employeeService") public interface EmployeeService extends RemoteService {public EmployeeDTO findEmployee(long employeeId);public void saveEmployee(long employeeId, String name, String surname, String jobDescription) throws Exception;public void updateEmployee(long employeeId, String name, String surname, String jobDescription) throws Exception;public void saveOrUpdateEmployee(long employeeId, String name, String surname, String jobDescription) throws Exception;public void deleteEmployee(long employeeId) throws Exception;}

這里要注意的事情：

• GWT客戶端必須能夠對服務器端服務進行異步遠程過程調用（RPC）。 因此，服務接口必須擴展RemoteService接口。 還必須提供指定接口的異步對應項以啟用異步通信（請參見下文）
• 我們對接口進行注釋，以定義可訪問該服務的URL。 由于該服務是Spring服務，因此我們希望spring4gwt攔截RPC調用并執行Spring服務調用。 為此，我們定義了一個相對路徑，該相對路徑將由在web.xml中聲明的“ springGwtRemoteServiceServlet”處理，如上所示。
• 在“ RemoteServiceRelativePath”注釋中聲明的服務名稱（此處為“ employeeService”）必須與Spring服務bean名稱匹配。 我們將在服務實現類中定義Spring服務bean名稱（請參見下文）

服務接口的異步計數器部分如下

package com.javacodegeeks.gwtspring.shared.services;import com.google.gwt.user.client.rpc.AsyncCallback; import com.javacodegeeks.gwtspring.shared.dto.EmployeeDTO;public interface EmployeeServiceAsync {void deleteEmployee(long employeeId, AsyncCallback<Void> callback);void findEmployee(long employeeId, AsyncCallback<EmployeeDTO> callback);void saveEmployee(long employeeId, String name, String surname,String jobDescription, AsyncCallback<Void> callback);void saveOrUpdateEmployee(long employeeId, String name, String surname,String jobDescription, AsyncCallback<Void> callback);void updateEmployee(long employeeId, String name, String surname,String jobDescription, AsyncCallback<Void> callback);}

服務實現類是服務器端組件，因此我們必須將其放置在項目的“服務器”子包下。 創建“服務”子包并將其放在那里。 下面提供了一個示例服務實現類

package com.javacodegeeks.gwtspring.server.services; import javax.annotation.PostConstruct; import javax.annotation.PreDestroy; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; import org.springframework.transaction.annotation.Propagation; import org.springframework.transaction.annotation.Transactional; import com.javacodegeeks.gwtspring.server.dao.EmployeeDAO; import com.javacodegeeks.gwtspring.shared.dto.EmployeeDTO; import com.javacodegeeks.gwtspring.shared.services.EmployeeService; @Service("employeeService") public class EmployeeServiceImpl implements EmployeeService { @Autowired private EmployeeDAO employeeDAO; @PostConstruct public void init() throws Exception { } @PreDestroy public void destroy() { } public EmployeeDTO findEmployee(long employeeId) { return employeeDAO.findById(employeeId); } @Transactional(propagation=Propagation.REQUIRED, rollbackFor=Exception.class) public void saveEmployee(long employeeId, String name, String surname, String jobDescription) throws Exception { EmployeeDTO employeeDTO = employeeDAO.findById(employeeId); if(employeeDTO == null) { employeeDTO = new EmployeeDTO(employeeId, name,surname, jobDescription); employeeDAO.persist(employeeDTO); } } @Transactional(propagation=Propagation.REQUIRED, rollbackFor=Exception.class) public void updateEmployee(long employeeId, String name, String surname, String jobDescription) throws Exception { EmployeeDTO employeeDTO = employeeDAO.findById(employeeId); if(employeeDTO != null) { employeeDTO.setEmployeeName(name); employeeDTO.setEmployeeSurname(surname); employeeDTO.setJob(jobDescription); } } @Transactional(propagation=Propagation.REQUIRED, rollbackFor=Exception.class) public void deleteEmployee(long employeeId) throws Exception { EmployeeDTO employeeDTO = employeeDAO.findById(employeeId); if(employeeDTO != null) employeeDAO.remove(employeeDTO); } @Transactional(propagation=Propagation.REQUIRED, rollbackFor=Exception.class) public void saveOrUpdateEmployee(long employeeId, String name, String surname, String jobDescription) throws Exception { EmployeeDTO employeeDTO = new EmployeeDTO(employeeId, name,surname, jobDescription); employeeDAO.merge(employeeDTO); } }

這里要注意的事情：

• 我們使用@Service（“ employeeService”）構造型注釋，以便聲明該類以名稱“ exampleService”表示Spring服務。 Spring容器將在啟動時實例化所有服務。
• 我們使用@Autowire批注將DAO類的實例注入“ employeeService”。 為了正確地實例化服務， Spring容器必須首先解析服務中所有可能的引用，因此實例化DAO類并將實例注入到“ employeeService”的適當字段–“ employeeDAO”字段。 如果您想知道，依賴項注入是根據類型（類）完成的，如果不滿足則是根據名稱完成的，這意味著如果我們定義了多個相同類型（類）的服務，則注入的服務將是名稱相同的服務作為指定字段。
• 我們使用Java批注@PostConstruct和@PreDestroy來聲明在初始化（完成所有依賴項注入）和服務的先前銷毀后Spring容器將調用的方法。
• 對于需要對數據庫執行更新操作的所有方法（INSERT，UPDATE，DELETE），我們使用@Transactional批注
• 我們不要在對數據庫執行檢索（FIND）操作的方法上使用@Transactional批注（包含延遲初始化的引用的對象除外-請參見下文），和/或不執行數據庫操作。 那是因為每次您調用一個注解為事務性的方法時， Spring容器都會涉及到調用JPA的實體管理器以及結果平臺的事務管理器，從而定義了將要應用的事務行為，特別是引入了明顯的性能損失。適用于低延遲/高吞吐量應用
• 對于對包含延遲初始化的引用的對象執行檢索（FIND）操作的方法，應使用@Transactional批注，指定“ NESTED”傳播類型，以使Spring可以為整個方法調用保持Hibernate會話打開
• 事務處理行為僅應用于對服務的客戶端調用。 事務處理行為不適用于內部操作調用。 例如，如果客戶端調用未注釋為事務性的操作，而后者的實現將對同一服務的另一個操作的調用引入了注釋為事務性的調用，則對于合并的操作，將不會應用任何事務行為

我們幾乎完成了！，我們必須開發GWT用戶界面才能訪問我們的Spring服務。 盡管GWT用戶界面開發不在本教程的討論范圍之內，我們還是將提供一個基本的用戶界面，以展示幾個Spring服務調用。

找到您的GWT應用程序的入口點。 該文件的名稱應類似于{project_name} .java（在我們的情況下為GWTSpring.java），并位于“ client”子包或主包下。 更改入口點類，如下所示

package com.javacodegeeks.gwtspring.client;import com.google.gwt.core.client.EntryPoint; import com.google.gwt.core.client.GWT; import com.google.gwt.event.dom.client.ClickEvent; import com.google.gwt.event.dom.client.ClickHandler; import com.google.gwt.event.dom.client.KeyCodes; import com.google.gwt.event.dom.client.KeyUpEvent; import com.google.gwt.event.dom.client.KeyUpHandler; import com.google.gwt.user.client.rpc.AsyncCallback; import com.google.gwt.user.client.ui.Button; import com.google.gwt.user.client.ui.DialogBox; import com.google.gwt.user.client.ui.HTML; 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.javacodegeeks.gwtspring.shared.dto.EmployeeDTO; import com.javacodegeeks.gwtspring.shared.services.EmployeeService; import com.javacodegeeks.gwtspring.shared.services.EmployeeServiceAsync;/*** Entry point classes define <code>onModuleLoad()</code>.*/ public class GWTSpring implements EntryPoint {/*** The message displayed to the user when the server cannot be reached or* returns an error.*/private static final String SERVER_ERROR = "An error occurred while "+ "attempting to contact the server. Please check your network "+ "connection and try again. The error is : ";/*** Create a remote service proxy to talk to the server-side Employee service.*/private final EmployeeServiceAsync employeeService = GWT.create(EmployeeService.class);/*** This is the entry point method.*/public void onModuleLoad() {final Button saveOrUpdateButton = new Button("SaveOrUpdate");final Button retrieveButton = new Button("Retrieve");final TextBox employeeInfoField = new TextBox();employeeInfoField.setText("Employee Info");final TextBox employeeIdField = new TextBox();final Label errorLabel = new Label();// We can add style names to widgetssaveOrUpdateButton.addStyleName("sendButton");retrieveButton.addStyleName("sendButton");// Add the nameField and sendButton to the RootPanel// Use RootPanel.get() to get the entire body elementRootPanel.get("employeeInfoFieldContainer").add(employeeInfoField);RootPanel.get("updateEmployeeButtonContainer").add(saveOrUpdateButton);RootPanel.get("employeeIdFieldContainer").add(employeeIdField);RootPanel.get("retrieveEmployeeButtonContainer").add(retrieveButton);RootPanel.get("errorLabelContainer").add(errorLabel);// Focus the cursor on the name field when the app loadsemployeeInfoField.setFocus(true);employeeInfoField.selectAll();// Create the popup dialog boxfinal DialogBox dialogBox = new DialogBox();dialogBox.setText("Remote Procedure Call");dialogBox.setAnimationEnabled(true);final Button closeButton = new Button("Close");// We can set the id of a widget by accessing its ElementcloseButton.getElement().setId("closeButton");final Label textToServerLabel = new Label();final HTML serverResponseLabel = new HTML();VerticalPanel dialogVPanel = new VerticalPanel();dialogVPanel.addStyleName("dialogVPanel");dialogVPanel.add(new HTML("<b>Sending request to the server:</b>"));dialogVPanel.add(textToServerLabel);dialogVPanel.add(new HTML(" <b>Server replies:</b>"));dialogVPanel.add(serverResponseLabel);dialogVPanel.setHorizontalAlignment(VerticalPanel.ALIGN_RIGHT);dialogVPanel.add(closeButton);dialogBox.setWidget(dialogVPanel);// Add a handler to close the DialogBoxcloseButton.addClickHandler(new ClickHandler() {public void onClick(ClickEvent event) {dialogBox.hide();saveOrUpdateButton.setEnabled(true);saveOrUpdateButton.setFocus(true);retrieveButton.setEnabled(true);}});// Create a handler for the saveOrUpdateButton and employeeInfoFieldclass SaveOrUpdateEmployeeHandler implements ClickHandler, KeyUpHandler {/*** Fired when the user clicks on the saveOrUpdateButton.*/public void onClick(ClickEvent event) {sendEmployeeInfoToServer();}/*** Fired when the user types in the employeeInfoField.*/public void onKeyUp(KeyUpEvent event) {if (event.getNativeKeyCode() == KeyCodes.KEY_ENTER) {sendEmployeeInfoToServer();}}/*** Send the employee info from the employeeInfoField to the server and wait for a response.*/private void sendEmployeeInfoToServer() {// First, we validate the input.errorLabel.setText("");String textToServer = employeeInfoField.getText();// Then, we send the input to the server.saveOrUpdateButton.setEnabled(false);textToServerLabel.setText(textToServer);serverResponseLabel.setText("");String[] employeeInfo = textToServer.split(" ");long employeeId = Long.parseLong(employeeInfo[0]);String employeeName = employeeInfo[1];String employeeSurname = employeeInfo[2];String employeeJobTitle = employeeInfo[3];employeeService.saveOrUpdateEmployee(employeeId, employeeName, employeeSurname, employeeJobTitle, new AsyncCallback<Void>() {public void onFailure(Throwable caught) {// Show the RPC error message to the userdialogBox.setText("Remote Procedure Call - Failure");serverResponseLabel.addStyleName("serverResponseLabelError");serverResponseLabel.setHTML(SERVER_ERROR + caught.toString());dialogBox.center();closeButton.setFocus(true);}public void onSuccess(Void noAnswer) {dialogBox.setText("Remote Procedure Call");serverResponseLabel.removeStyleName("serverResponseLabelError");serverResponseLabel.setHTML("OK");dialogBox.center();closeButton.setFocus(true);}});}}// Create a handler for the retrieveButton and employeeIdFieldclass RetrieveEmployeeHandler implements ClickHandler, KeyUpHandler {/*** Fired when the user clicks on the retrieveButton.*/public void onClick(ClickEvent event) {sendEmployeeIdToServer();}/*** Fired when the user types in the employeeIdField.*/public void onKeyUp(KeyUpEvent event) {if (event.getNativeKeyCode() == KeyCodes.KEY_ENTER) {sendEmployeeIdToServer();}}/*** Send the id from the employeeIdField to the server and wait for a response.*/private void sendEmployeeIdToServer() {// First, we validate the input.errorLabel.setText("");String textToServer = employeeIdField.getText();// Then, we send the input to the server.retrieveButton.setEnabled(false);textToServerLabel.setText(textToServer);serverResponseLabel.setText("");employeeService.findEmployee(Long.parseLong(textToServer), new AsyncCallback<EmployeeDTO>() {public void onFailure(Throwable caught) {// Show the RPC error message to the userdialogBox.setText("Remote Procedure Call - Failure");serverResponseLabel.addStyleName("serverResponseLabelError");serverResponseLabel.setHTML(SERVER_ERROR + caught.toString());dialogBox.center();closeButton.setFocus(true);}public void onSuccess(EmployeeDTO employeeDTO) {dialogBox.setText("Remote Procedure Call");serverResponseLabel.removeStyleName("serverResponseLabelError");if(employeeDTO != null)serverResponseLabel.setHTML("Employee Information Id : " + employeeDTO.getEmployeeId() + " Name : " + employeeDTO.getEmployeeName() + " Surname : " + employeeDTO.getEmployeeSurname() + " Job Title : " + employeeDTO.getJob());elseserverResponseLabel.setHTML("No employee with the specified id found");dialogBox.center();closeButton.setFocus(true);}});}}// Add a handler to send the employee info to the serverSaveOrUpdateEmployeeHandler saveOrUpdateEmployeehandler = new SaveOrUpdateEmployeeHandler();saveOrUpdateButton.addClickHandler(saveOrUpdateEmployeehandler);employeeInfoField.addKeyUpHandler(saveOrUpdateEmployeehandler);// Add a handler to send the employee id to the serverRetrieveEmployeeHandler retrieveEmployeehandler = new RetrieveEmployeeHandler();retrieveButton.addClickHandler(retrieveEmployeehandler);employeeIdField.addKeyUpHandler(retrieveEmployeehandler);} }

如您所見，對客戶端透明地執行Spring服務調用，就像執行經典GWT服務調用一樣。

最后找到您的項目的主頁。 該文件的名稱應為{project_name} .html，在我們的情況下為GWTSpring.html，位于我們項目的/ war文件夾下。 更改主網頁，如下所示

<!doctype html> <!-- The DOCTYPE declaration above will set the --> <!-- browser's rendering engine into --> <!-- "Standards Mode". Replacing this declaration --> <!-- with a "Quirks Mode" doctype may lead to some --> <!-- differences in layout. --><html><head><meta http-equiv="content-type" content="text/html; charset=UTF-8"><!-- --><!-- Consider inlining CSS to reduce the number of requested files --><!-- --><link type="text/css" rel="stylesheet" href="GWTSpring.css"><!-- --><!-- Any title is fine --><!-- --><title>Spring GWT Web Application Starter Project</title><!-- --><!-- This script loads your compiled module. --><!-- If you add any GWT meta tags, they must --><!-- be added before this line. --><!-- --><script type="text/javascript" language="javascript" src="gwtspring/gwtspring.nocache.js"></script></head><!-- --><!-- The body can have arbitrary html, or --><!-- you can leave the body empty if you want --><!-- to create a completely dynamic UI. --><!-- --><body><!-- OPTIONAL: include this if you want history support --><iframe src="javascript:''" id="__gwt_historyFrame" tabIndex='-1' style="position:absolute;width:0;height:0;border:0"></iframe><!-- RECOMMENDED if your web app will not function without JavaScript enabled --><noscript><div style="width: 22em; position: absolute; left: 50%; margin-left: -11em; color: red; background-color: white; border: 1px solid red; padding: 4px; font-family: sans-serif">Your web browser must have JavaScript enabledin order for this application to display correctly.</div></noscript><h1>Spring GWT Web Application Starter Project</h1><table align="center"><tr><td colspan="2" style="font-weight:bold;">Please enter employee info (id name surname job):</td> </tr><tr><td id="employeeInfoFieldContainer"></td><td id="updateEmployeeButtonContainer"></td></tr><tr><tr><td colspan="2" style="font-weight:bold;">Please enter employee id:</td> </tr><tr><td id="employeeIdFieldContainer"></td><td id="retrieveEmployeeButtonContainer"></td></tr><tr><td colspan="2" style="color:red;" id="errorLabelContainer"></td></tr></table></body> </html>

要編譯應用程序，請右鍵單擊項目名稱，然后選擇“運行方式？”。 編譯GWT應用程序

要部署Web應用程序，只需將/ war文件夾復制到Apache – Tomcat “ webapps”文件夾中。 您可以將war文件夾的名稱更改為您喜歡的名稱，最好在項目名稱之后將其重命名，例如GWTSpring

要啟動該應用程序，請將您的瀏覽器指向以下地址

http：// localhost：8080 / GWTSpring /

如果一切順利，您應該會看到您的主頁。 應顯示兩個文本框，每個文本框后跟一個按鈕。 在第一個文本框中，您可以將員工保存或更新到數據庫。 作為輸入，提供ID，名稱，姓氏和職位描述，并用空格字符分隔。 單擊“ SaveOrUpdate”按鈕，將提供的信息存儲到數據庫中。 對于現有員工條目（相同的ID），將執行更新。 第二個文本框用于檢索現有員工條目。 提供員工ID，然后單擊“檢索”按鈕。 如果該員工存在，則應該看到該員工的ID，姓名，姓氏和職位描述。

很少，那是一個很大的教程！

您可以從此處下載項目（不包括開頭所述的必需的第三方庫）

希望你喜歡

賈斯汀

相關文章 ：
• GWT Spring和Hibernate進入數據網格世界
• Spring 3 HornetQ 2.1集成教程
• Spring 3 RESTful Web服務
• GWT 2 Spring 3 JPA 2 Hibernate 3.5教程– Eclipse和Maven 2展示
• 具有Spring和Maven教程的JAX–WS
相關片段：
• 在Spring容器中聲明bean
• 使用JPA持久化對象
• JPA中的一對多雙向映射
• JPA CRUD示例
• 用Hibernate持久化對象

翻譯自: https://www.javacodegeeks.com/2010/05/gwt-2-spring-3-jpa-2-hibernate-35-2.html

gwt-2.8.2下載

創作挑戰賽新人創作獎勵來咯，堅持創作打卡瓜分現金大獎

總結

以上是生活随笔為你收集整理的gwt-2.8.2下载_GWT 2 Spring 3 JPA 2 Hibernate 3.5教程的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。