GWT 2 Spring 3 JPA 2 Hibernate 3.5 教程

这个入门教材将教你如何实现一个简单的 web 应用程序，这个程序用 Google's Web Toolkit (GWT) 作为前台富客户端，用 spring 作为后台的服务器框架。这个例子将实现对数据库的增删改查，即CRUD (Create Retrieve Update Delete) 的功能。我们将使用以 hibernate 实现的 jpa 作为数据访问层，用 Hypersonic 作为数据库。当然，你也可以通过修改配置来选择你喜欢的数据访问层和数据库。我们将会把这个应用程序部署到 Apache – Tomcat 上。

 

　　我们首选的开发环境是 Eclipse ，因此，作为先决条件，你需要有一个安装了 GWT 插件的 Eclipse 。关于GWT plugin for Eclipse 不在我们这个教程的讨论范围内。下面列出开发时需要用到的组件：

1. Eclipse 从 这里下载
2. GWT Plugin for Eclipse 在 这里下载
3. Spring 框架从 这里下载
4. Hibernate 持久层从 这里下载
5. Hypersonic 数据库从 这里下载
6. Apache commons-logging 包从 这里下载
7. AOP Alliance (Java/J2EE AOP Standard) 包从 这里下载
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 → New Web Application Project
2. 我们将我们的工程命名为 GWTSpring。基本的包名是 com.javacodegeeks.gwtspring。因为我们仅仅使用了Google Web Toolkit ，因此在工程向导窗口中不要选择“Use Google App Engine ”。

　　现在我们简单介绍一下这个工程的目录结构：

1. /src 文件夹中包含了这个程序的全部的源文件
   
   • {包名}.client 子包，包含了全部仅在客户端使用的源文件
   • {包名}.server 子包，包含了全部仅在服务器端使用的源文件
   • {包名}.shared 子包，包含了全部的同时在客户端和服务器端都使用的源文件
2. /test 文件夹包含了全部的单元测试源文件
3. /war 文件夹包含了建立一个web应用而必须包含的基本文件

　　为了正确地集成 Spring 和 GWT ，我们必须为web工程提供全部的必须的库文件。因此，复制下面列表中的文件到 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

　　从 Hypersonic 中复制：

• /lib/hsqldb.jar

　　从 Apache Commons Logging 中复制：

• commons-logging-1.1.1.jar

　　从 AOP Alliance (Java/J2EE AOP Standard) 中复制：

• aopalliance.jar

　　从 SLF4J 中复制：

• slf4j-log4j12-1.5.8.jar

　　从 Apache log4j 中复制：

• log4j-1.2.16.jar

　　从 sping4gwt 中复制：

• spring4gwt-0.0.1.jar

　　我们要注意我们 Eclipse 工程的依赖库. 下列的 jar 库将被包含到工程的构建路径中：

• 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工程进行配置，使得web工程启动时把 Spring 容器加载进来，同时也使得 spring4gwt 的客户端和服务器端能正常地通讯，客户端发出远程调用能正确地传递给服务器端的 Spring 服务。

 

　　打开在 /war/WEB-INF 下的 web.xml 文件并添加下列内容：

 

　　配置服务器启动时加载 Spring 容器

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

 

　　在 servlets 那节中添加：

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

 

　　在 servlet-mapping 那节中添加一些 spring4gwt 的远程调用：

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

 

　　这里有些需要注意的地方：

1. 在为 springGwtRemoteServiceServlet 这个 servlet 进行的配置项里，即 servlet-mapping 的子项 url-pattern 的配置变量值：/gwtspring/springGwtServices/* 里的 gwtspring，必须改为你自己的web模块名，这个模块名定义在 web 工程的 /src 目录下的 {工程名}.gwt.xml 文件(这里是 GWTSpring.gwt.xml) 里
2. 你可以修改 spring4gwt servlet 的名字为你喜欢的 servlet 名(这里是 springGwtRemoteServiceServlet)

　　接下来将会建立用于 JPA 链接数据库的配置文件 persistence.xml。这个文件必须放在 META-INF 目录里，系统运行时将会去访问到它。要满足上述所说的要求，我们需要在工程的目录 /war/WEB-INF/classes 里建立 META-INF 文件夹。实际上要做的就是新建一个名为 “resources” 的源码目录，并在里面建立一个文件夹 META-INF 即可。最后，建立 persistence.xml 文件到 /resources/META-INF 文件夹里。下面是 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>

 

　　这里需要注意的是：如果你要把这个应用程序发布到一个提供 JTA 事务的 J2EE 应用服务器里，如 JBoss ，或者使用其他的数据库，如 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.xsd
            http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd
            http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.0.xsd
            http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
            http://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>

 

　　这里有几点需要注意的：

1. 把 context:component-scan 元素的属性 base-package 的属性值改成你自己项目的基本包名，这样 Spring的组件就可以被容器注入进来(services、DAOs 等)。
2. 修改 entityManagerFactory bean 的属性值为你在 persistence.xml 里定义的 persistence-unit 元素的名字。
3. 如果你要把这个应用程序发布到一个提供 JTA 事务的 J2EE 应用服务器里，如 JBoss ，或者使用其他的数据库，如 Oracle , MySQL 等，请参考 《JBoss Spring JPA Hibernate 教程》 里的配置文件。

　　接下来，我们将介绍用于传送服务器与客户端之间的数据的数据传输对象(DTO)，这种对象被用来访问数据库，并被 Spring 服务用它把数据传输给 GWT web 客户端来显示。

 

　　DTO 是能够同时被用于服务器和客户端的对象，因此你应该在 “shared” 包里建立一个 “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 (增删改查) 功能的对象。这是个服务器端组件，因此应该把这个对象放到工程的 “server” 子包里。现在建立一个 “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> {

    @Autowired
    EntityManagerFactory entityManagerFactory;

    @PostConstruct
    public void init() {
        super.setEntityManagerFactory(entityManagerFactory);
    }

}

 

　　正如你看到的那样，EmployeeDAO 继承子一个基本的 DAO 类(JpaDAO)。EmployeeDAO 对象可以包含一些关于 EmployeeDTO 的特定的查询，但全部 CRUD 操作都可以从基础类 DAO 类 (JpaDAO) 里调用。把 JpaDAO 类放到 EmployeeDAO 相同的子包 “dao” 中。以下是类 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 客户端访问的服务接口与实现类。这个服务接口将会被服务器端和客户端同时访问，因此我们把它放到我们工程的 “shared” 子包下。现在建立一个 “services” 子包，并准备在里面放置服务接口类。下面是该接口的例子代码：

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 客户端只能通过异步的远程过程(RPCs)调用来调用服务器端功能服务的。这个服务接口必须继承 RemoteService 接口. 这个接口的异步调用部分也必须能够提供异步通讯的功能(后面介绍)。
2. 我们通过给这个接口加入注解，以使得这个服务能够被访问。因为这个服务是一个 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<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);

}

 

　　这个服务实现类是一个服务器端组件，因此我们把它放到我们工程的 “server” 子包里。现在建立这个 “services” 子包，并把这个服务实现类放到里面。下面是这个服务实现类的代码：

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 实例注入到这个 employeeDAO 属性中。
3. 我们定义 @PostConstruct 这个注解在方法上，用来指示当Spring 容器初始化完后（全部的依赖注入完成）执行这个方法，定义 @PreDestroy 注解在方法上，指示 Spring 容器在销毁这个服务前执行这个方法。
4. 我们把 @Transactional 定义在所有需要进行数据库更新的方法上(插入、修改和删除)
5. 我们不应在对数据库对象查询和没有对数据库进行操作的方法中使用 @Transactional 注解(除非被查询的对象里有延迟加载的数据 - 参考后面的解释)。这是因为每当你调用一个被标注为启用事务的方法时，Spring 容器都会使用 JPA 的实体管理器进行事务管理，这会消耗一部分性能，从而导致性能降低。
6. 对于那些查询延迟加载数据的方法，你应该加上 @Transactional 注解，指示 Spring 维持 Hibernate 的  session 在整个方法调用中一直保持打开的状态。
7. 事务行为仅在客户端调用服务的时候提供，而在内部调用时不提供事务行为。例如，如果一个客户调用了一个没有用事务标注的操作，且在这个服务中，这个操作又调用了一个用事务标注的操作，那么整个联合的操作都是不提供事务的。

　　终于完成了！但我们还将要开发 GWT 用户接口来访问我们的 Spring 服务。 尽管事实上 GWT 的用户接口开发不属于我们这个教程的讨论范围，但我们还是提供了一个基本的用户接口来展示这些如何调用这些 Spring 服务。

　　先定位到你的 GWT 应用程序的入口点。这个文件应该这样命名：{工程名}.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 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("<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 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<Void>() {
                            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<EmployeeDTO>() {
                            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 服务那样调用。

　　最后，打开你工程的 web 主文件。这个文件应该象{工程名}.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 enabled
        in 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>

 

　　要编译这个应用，右键点击工程名并选择 Run As → Compile GWT Application。

　　要发布这个应用，只需复制这个 /war 目录到 Apache – Tomcat 的 “webapps” 目录下。你可以修改 war 这个目录名为你喜欢的任何名字，最好是把它命名为这个工程的名字，例如 GWTSpring。

　　在浏览器地址栏输入以下地址即可浏览这个应用：

http://localhost:8080/GWTSpring/

　　如果一切正常的话，你就可以看到这个应用的 web主页了，里面有两个文本框，每个文本框后面有一个按钮。在第一给文本框中，你可以保存或更新职员数据倒数据库中。录入一个 id、名字、姓氏和一个工作的描述，用一个空白符来分开。点击 “SaveOrUpdate” 按钮，提供的数据库就将被保存到数据库中。对应已经存在的职员数据(相同的 id)，将会执行更新。第二个文本框用于查询存在的职员数据。输入一个职员的 id 并点击 “Retrieve” 按钮，如果这个职员存在的话，你就可以看到这个职员的 id、名字、姓氏和工作描述。

　　哦，这真是一个大的教程！

　　你可以从 here 下载这个应用，前面所说的第三方库并没用包含在里面。


　　希望你喜欢这个教程。


　　Justin

 

译者注：这是我第一次翻译外文技术文章。让我感触较深的是，自己看懂这篇文章容易，但要翻译起来却要花费很多的时间。往往原文的一句话要翻译出来，必须对这句话进行多遍的阅读，并在阅读的过程中慢慢组织成我们的语言。但最后翻译完成后，还是有很多地方感觉很生涩。不得已，还把少量的不影响阅读和理解的段落进行了简化，如关于事务的介绍部分。如果你需要了解更多，或觉得这篇文章难以理解，请阅读原文，或给我留言，也欢迎您把我翻译错误的地方指出来。

 

而促使我翻译这篇文章的动机是，前些日子里，我在思考，为什么我的生活总过得很窘迫？（通俗点说就是为什么我总是没钱？）以一个程序员的思维，我反过来问自己，我凭什么有钱？我相信这个世界有一个真理，就是要有收获，就必须有付出。那么，我付出了什么？我付出了很多的时间去学习？但我为这个世界做了什么？为家人、为朋友、为认识和不认识的人做了什么？我答不上来。相反地，在思考过程中，我觉得我从这个世界里，获得了很多我想要的东西，比如知识、亲情、友情、爱情、食物、工作等等。那么，不管如何，我是不是该做点什么，不是为了自己，而是为别人而做的事情？我想，是的，我要为别人做点事，做点简单的事，做点力所能及的事。不为钱财名誉，不为个人利益，只为反哺这个世界。于是，就是有了这篇文章。感谢你阅读这篇文章，希望能给你一点帮助。当然，如果你愿意，希望你也能为这个世界的做点自己力所能及的事。谢谢。