gwt-2.8.2下载_GWT 2 Spring 3 JPA 2 Hibernate 3.5教程

gwt-2.8.2下载

本分步指南将介绍如何使用以下方法开发简单的Web应用程序 Google的网络工具包 （GWT）用于富客户端，而Spring作为后端服务器端框架。 该示例Web应用程序将提供对数据库执行CRUD（创建检索更新删除）操作的功能。 对于数据访问层，我们将在Hibernate上使用JPA ，对于数据库，我们将使用Hypersonic 。 当然，您可以更改配置并使用所需的任何内容。 我们将Web应用程序部署到Apache – Tomcat实例。

我们首选的开发环境是Eclipse ，因此，前提条件是必须安装具有GWT支持的Eclipse 。 用于Eclipse的GWT插件的安装不在本教程的讨论范围之内，因此不再讨论。 但是，您将需要以下组件：

1. 从这里 蚀
2. 从这里开始 ，Eclipse的GWT插件
3. 从这里发布Spring框架
4. Hibernate持久性框架从这里发布
5. 来自这里的 Hypersonic数据库
6. 从这里开始 Apache Commons-Logging库
7. 来自这里的 AOP Alliance （Java / J2EE AOP标准）库
8. 从这里开始 SLF4J库
9. 来自这里的 Apache log4j库
10. 最后但并非最不重要的一点，从此处下载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版。

聊够了，让我们动手吧！

1. 创建一个新的GWT项目，转到File？ 新的Web应用程序项目
2. 我们将项目命名为GWTSpring。 基本软件包为com.javacodegeeks.gwtspring，也仅使用Google Web Toolkit，因此在向导窗口中取消选中“ Use Google App Engine ”。

让我们回顾一下有关GWT项目结构的一些事情

1. / 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上下文，

  
   org.springframework.web.context.ContextLoaderListener
  

  在Servlet部分，包括

  
   springGwtRemoteServiceServlet
   org.spring4gwt.server.SpringGwtRemoteServiceServlet
  

  在servlet映射部分中，供spring4gwt拦截RPC调用。

  
   springGwtRemoteServiceServlet
   /gwtspring/springGwtServices/*
  

  这里要注意的事情：

  1. 应该将springGwtRemoteServiceServlet servlet的servlet-mapping元素的url-pattern子元素更改为您的GWT模块名称，例如{module_name} / springGwtServices / *，该模块名称在{project_name} .gwt.xml文件中定义（此处为GWTSpring.gwt.xml）位于/ src文件夹下项目基本软件包的根目录
  2. 您可以将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

  
  
      
          org.hibernate.ejb.HibernatePersistence
  
          
              
              
              
              
              
              
              
  
              
              
              
              
              
          
  
      
  
  

  这里要注意的事情：

  1. 如果您打算将Web应用程序部署到支持JTA事务（例如JBoss）的J2EE应用服务器或使用其他数据库（例如Oracle ， MySQL等），请参阅此处的 “ JBoss Spring JPA Hibernate教程”以了解替代配置。

  现在让我们创建将驱动Spring容器的applicationContext.xml文件。 在/ war / WEB-INF目录下创建文件。 下面显示了一个示例applicationContext.xml

  这里要注意的事情：

  1. 将context：component-scan元素的base-package属性更改为项目的基本包，以便对其进行Spring组件（服务，DAO等）的扫描。
  2. 根据persistence.xml文件中的指示，将entityManagerFactory bean的persistentUnitName属性的value属性更改为您的持久单元的名称
  3. 如果您打算将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 {
      
      @Autowired
      EntityManagerFactory entityManagerFactory;
      
      @PostConstruct
      public 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 extends JpaDaoSupport { 
      protected Class entityClass; 
  
      @SuppressWarnings("unchecked") 
      public JpaDAO() { 
          ParameterizedType genericSuperclass = (ParameterizedType) getClass() 
                  .getGenericSuperclass(); 
          this.entityClass = (Class) 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 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) 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;
      
  }

  这里要注意的事情：

  1. GWT客户端必须能够对服务器端服务进行异步远程过程调用（RPC）。 因此，服务接口必须扩展RemoteService接口。 还必须提供指定接口的异步对应项以启用异步通信（请参见下文）
  2. 我们对接口进行注释，以定义可访问该服务的URL。 由于该服务是Spring服务，因此我们希望spring4gwt拦截RPC调用并执行Spring服务调用。 为此，我们定义了一个相对路径，该相对路径将由在web.xml中声明的“ springGwtRemoteServiceServlet”处理，如上所示。
  3. 在“ 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 callback);
  
      void findEmployee(long employeeId, AsyncCallback callback);
  
      void saveEmployee(long employeeId, String name, String surname,
              String jobDescription, AsyncCallback callback);
  
      void saveOrUpdateEmployee(long employeeId, String name, String surname,
              String jobDescription, AsyncCallback callback);
  
      void updateEmployee(long employeeId, String name, String surname,
              String jobDescription, AsyncCallback 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); 
          
      } 
  
  }

  这里要注意的事情：

  1. 我们使用@Service（“ employeeService”）构造型注释，以便声明该类以名称“ exampleService”表示Spring服务。 Spring容器将在启动时实例化所有服务。
  2. 我们使用@Autowire批注将DAO类的实例注入“ employeeService”。 为了正确地实例化服务， Spring容器必须首先解析服务中所有可能的引用，因此实例化DAO类并将实例注入到“ employeeService”的适当字段–“ employeeDAO”字段。 如果您想知道，依赖项注入是根据类型（类）完成的，如果不满足则是根据名称完成的，这意味着如果我们定义了多个相同类型（类）的服务，则注入的服务将是名称相同的服务作为指定字段。
  3. 我们使用Java批注@PostConstruct和@PreDestroy来声明在初始化（完成所有依赖项注入）和服务的先前销毁后Spring容器将调用的方法。
  4. 对于需要对数据库执行更新操作的所有方法（INSERT，UPDATE，DELETE），我们使用@Transactional批注
  5. 我们不要在对数据库执行检索（FIND）操作的方法上使用@Transactional批注（包含延迟初始化的引用的对象除外-请参见下文），和/或不执行数据库操作。 那是因为每次您调用一个注解为事务性的方法时， Spring容器都会涉及到调用JPA的实体管理器以及结果平台的事务管理器，从而定义了将要应用的事务行为，特别是引入了明显的性能损失。适用于低延迟/高吞吐量应用
  6. 对于对包含延迟初始化的引用的对象执行检索（FIND）操作的方法，应使用@Transactional批注，指定“ NESTED”传播类型，以使Spring可以为整个方法调用保持Hibernate会话打开
  7. 事务处理行为仅应用于对服务的客户端调用。 事务处理行为不适用于内部操作调用。 例如，如果客户端调用未注释为事务性的操作，而后者的实现将对同一服务的另一个操作的调用引入了注释为事务性的调用，则对于合并的操作，将不会应用任何事务行为

  我们几乎完成了！，我们必须开发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 onModuleLoad().
   */
  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 widgets
          saveOrUpdateButton.addStyleName("sendButton");
          retrieveButton.addStyleName("sendButton");
  
          // Add the nameField and sendButton to the RootPanel
          // Use RootPanel.get() to get the entire body element
          RootPanel.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 loads
          employeeInfoField.setFocus(true);
          employeeInfoField.selectAll();
  
          // Create the popup dialog box
          final 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 Element
          closeButton.getElement().setId("closeButton");
          final Label textToServerLabel = new Label();
          final HTML serverResponseLabel = new HTML();
          VerticalPanel dialogVPanel = new VerticalPanel();
          dialogVPanel.addStyleName("dialogVPanel");
          dialogVPanel.add(new HTML("Sending request to the server:"));
          dialogVPanel.add(textToServerLabel);
          dialogVPanel.add(new HTML("
  Server replies:"));
          dialogVPanel.add(serverResponseLabel);
          dialogVPanel.setHorizontalAlignment(VerticalPanel.ALIGN_RIGHT);
          dialogVPanel.add(closeButton);
          dialogBox.setWidget(dialogVPanel);
  
          // Add a handler to close the DialogBox
          closeButton.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 employeeInfoField
          class 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() {
                              public void onFailure(Throwable caught) {
                                  // Show the RPC error message to the user
                                  dialogBox
                                          .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 employeeIdField
          class 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() {
                              public void onFailure(Throwable caught) {
                                  // Show the RPC error message to the user
                                  dialogBox
                                          .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());
                                  else
                                      serverResponseLabel.setHTML("No employee with the specified id found");
                                  dialogBox.center();
                                  closeButton.setFocus(true);
                              }
                          });
              }
          }
  
          // Add a handler to send the employee info to the server
          SaveOrUpdateEmployeeHandler saveOrUpdateEmployeehandler = new SaveOrUpdateEmployeeHandler();
          saveOrUpdateButton.addClickHandler(saveOrUpdateEmployeehandler);
          employeeInfoField.addKeyUpHandler(saveOrUpdateEmployeehandler);
          
          // Add a handler to send the employee id to the server
          RetrieveEmployeeHandler retrieveEmployeehandler = new RetrieveEmployeeHandler();
          retrieveButton.addClickHandler(retrieveEmployeehandler);
          employeeIdField.addKeyUpHandler(retrieveEmployeehandler);
      }
  }

  如您所见，对客户端透明地执行Spring服务调用，就像执行经典GWT服务调用一样。

  最后找到您的项目的主页。 该文件的名称应为{project_name} .html，在我们的情况下为GWTSpring.html，位于我们项目的/ war文件夹下。 更改主网页，如下所示

  
  
  
  
  
  
  
  
    
      
  
      
      
      
      
  
      
      
      
      
      
      
      
      
      
      
      
    
  
    
    
    
    
    
    
  
      
      
      
      
      
  
      
  Spring GWT Web Application Starter Project
  
      
  
        
  
          
  Please enter employee info (id name surname job):
          
        
        
  
          
  
          
  
        
        
  
        
  
          
  Please enter employee id:
          
        
        
  
          
  
          
  
        
        
  
          
  
        
      
    
  

  要编译应用程序，请右键单击项目名称，然后选择“运行方式？”。 编译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下载