Fatal编程技术网
  • java/
  • Java GWT使用RequestFactory命中HTTP servlet

Java GWT使用RequestFactory命中HTTP servlet

java gwt servlets

Java GWT使用RequestFactory命中HTTP servlet,java,gwt,servlets,requestfactory,Java,Gwt,Servlets,Requestfactory,如果可能的话，我想将GWT的RequestFactory用于所有客户机-服务器通信。我的理解是，您必须在web.xml中将/gwtServlet映射到RequestFactoryServlet，然后使用@Service注释告诉RequestFactoryServlet如何将客户端请求映射到相应的服务 有人能在客户端和服务器端提供此过程的完整代码示例吗？我想将小部件对象从客户端发送到服务器端的WidgetProcessor服务： public class Widget { // This

如果可能的话，我想将GWT的
RequestFactory
用于所有客户机-服务器通信。我的理解是，您必须在
web.xml
中将
/gwtServlet
映射到
RequestFactoryServlet
，然后使用
@Service
注释告诉
RequestFactoryServlet
如何将客户端请求映射到相应的服务

有人能在客户端和服务器端提供此过程的完整代码示例吗？我想将
小部件
对象从客户端发送到服务器端的
WidgetProcessor
服务：

public class Widget {
    // This is a domain object (POJO).
}

public class WidgetProcessor {
    public void processWidget(Widget w) {
        // Inspect the Widget. If certain properties contain certain
        // values, place it on a queue. Else "process" the Widget
        // and persist it to a DB.

        if(w.containsSpecialValues())
            QueueManager.sendToQueue(w);
        else {
            // Process widget...

            WidgetDAO.save(w);
        }
    }
}
在非GWT上下文中，我只需定义一个
WidgetProcessorServlet
，将其映射到
/processWidget
，并使其看起来像：

@Override
public void doGet(HttpServletRequest request, HttpServletResponse response) {
    WidgetProcessor widgetProcessor = new WidgetProcessor();
    widgetProcessor.processWidget(getWidgetFromRequest(request));
}
这在
RequestFactory
-land中是如何工作的？提前感谢。

您对RequestFactory场景有点困惑

你需要从这里开始-

浏览示例RequestFactory demo@DynatableRF代码-

下载示例RequestFactory demo@DynatableRF代码-

编辑-
RequestFactory示例与MVP、活动和编辑器框架纠缠在一起。需要花费大量的精力才能得出您的场景需要哪些RF、编辑器、MVP和活动的组合。

您的小部件类将位于服务器端。在客户端，您将使用一个接口来表示小部件；此接口将是实际小部件对象的代理。您可以使用@ProxyFor注释将代理接口与类相关联。例如，如果服务器上有Widget类，则客户端上可以有WidgetProxy接口：

@ProxyFor(value = Widget.class)
public interface WidgetProxy extends EntityProxy {
}
代理包含实体属性的getter和setter，这些getter和setter在服务器上的类中镜像。请求工厂还需要一种方法来定位代理所关联的类，为此我使用了一个“定位器”类（尽管还有其他方法）。定位器也在@Proxy注释中指定：

@ProxyFor(value = Widget.class, locator = WidgetLocator.class)
WidgetLocator类也在服务器端。对于要插入或更新的每个小部件，需要创建RequestContext。RequestContext标识将对实体进行操作的方法。这些方法的实际实现还是在服务器端。。。您可以引入包含这些方法的单独类，也可以将它们添加到实体类（在您的示例中是小部件）。我更喜欢将它们划分为一个“DAO”类，将实体类（即小部件）限制为一个简单的bean。（您的DAO类名为WidgetProcessor）。客户端的RequestContext是扩展RequestContext接口的接口。RequestContext接口告诉请求工厂在服务器上的何处找到DAO，这就是您使用@Service注释的地方

看看Thomas Broyer的博客，可以得到一个很好的介绍：。我还发现《GWT在行动》（第二版）是一本有用的资源。我根据自己的学习经验创建了一个示例，这可能对您也很有用：；同样，这可能有用，也可能无用

这在RequestFactorys中是可能的，但在GWT-RPC中也是可能的。我更喜欢工厂

您将拥有以下类和接口：

在服务器上：

  • 小部件（Servlet）
  • WidgetProcessor
    • 在客户端：

  • WidgetProxy
  • WidgetRequest
  • WidgetRequestFactory
  • WidgetPresenter
    • WidgetServlet

    package com.foo.bar.server;
public class Widget {
   //Your methods
    public void yourInstanceMethod(){
       //foo
    }
    public static void yourStaticMethod(){
       //bar
    }
    public static void processWidget(Widget w){
       WidgetProcessor widgetProcessor = new WidgetProcessor();
       widgetProcessor.processWidget(getWidgetFromRequest(request));
    }
}
    WidgetProcessor

    package com.foo.bar.server;
public class WidgetProcessor {
    public void processWidget(Widget w) {
        // Inspect the Widget. If certain properties contain certain
        // values, place it on a queue. Else "process" the Widget
        // and persist it to a DB.

        if(w.containsSpecialValues())
            QueueManager.sendToQueue(w);
        else {
            // Process widget...

            WidgetDAO.save(w);
        }
    }
}
    WidgetProxy

    package com.foo.bar.server;
import com.foo.bar.server.Widget;
@ProxyFor(value = Widget.class)
public interface WidgetProxy extends EntityProxy{
    //Your getter and Setter methods
}
    WidgetRequest

    package com.foo.bar.client;
import com.foo.bar.server.Widget;
@Service(value = Widget.class)
public interface WidgetRequest extends RequestContext{
    InstanceRequest<WidgetProxy, Void> yourInstanceMethod();
    Request<Void> yourStaticMethod();
    Request<Void> widgetProcessor(WidgetProxy widget);
}
    WidgetPresenter

    package com.foo.bar.client;
public class WidgetPresenter {
    private final WidgetRequestFactory rf = GWT.create(WidgetRequestFactory.class);
    public WidgetPresenter() {
        rf.initialize(new EventBus());
        rf.widgetRequest().widgetProcessor().fire(new Receiver<Void>() {
            @Override
            public void onSuccess() {

                //Do what you want to confirm to user...
            }
        });
    }
}

    package com.foo.bar.client；
公共类WidgetPresenter{
私有最终WidgetRequestFactory rf=GWT.create（WidgetRequestFactory.class）；
公共WidgetPresenter（）{
初始化（neweventbus（））；
rf.widgetRequest（）.widgetProcessor（）.fire（新接收器（）{
@凌驾
成功时的公共无效（）{
//执行您要向用户确认的操作。。。
}
});
}
}
    另外： 如果您再次将处理后的小部件回复给用户，您会这样做：

    @Service(value = Widget.class)
public interface WidgetRequest extends RequestContext{
    ...
    Request<WidgetProxy> widgetProcessor(WidgetProxy widget);
}

public class Widget {
    ...
    public static void processWidget(Widget w){
       WidgetProcessor widgetProcessor = new WidgetProcessor();
       return widgetProcessor.processWidget(getWidgetFromRequest(request));
    }
}

public class WidgetProcessor {
    public Widget processWidget(Widget w) {
        // Inspect the Widget. If certain properties contain certain
        // values, place it on a queue. Else "process" the Widget
        // and persist it to a DB.

        if(w.containsSpecialValues())
            QueueManager.sendToQueue(w);
        else {
            // Process widget...

            WidgetDAO.save(w);
        }
        return w;
    }
}

public class WidgetPresenter {
    private final WidgetRequestFactory rf = GWT.create(WidgetRequestFactory.class);
    public WidgetPresenter() {
        rf.initialize(new EventBus());
        rf.widgetRequest().widgetProcessor().fire(new Receiver<WidgetProxy>() {
            @Override
            public void onSuccess(WidgetProxy response) {

                WidgetView v = new WidgedView(response);
                            RootPanel.get().add(view);
            }
        });
    }
}

package com.foo.bar.client;
public class WidgetView {


    public WidgetView(WidgetProxy widget) {

        //paint widget with widget
            // widget.getSomeProperty(); etc.

    }
}

    import com.google.gwt.user.client.rpc.RemoteService;
public interface WidgetRPCInterface extends RemoteService
{
    public Widget widgetProcessRPC(Widget myWidget);
}

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

public interface WidgetRPCInterfaceAsync
{
    public void widgetProcessRPCWidget myWidget, AsyncCallback callback);
}

    @Service（value=Widget.class）
公共接口WidgetRequest扩展了RequestContext{
...
请求widgetProcessor（WidgetProxy小部件）；
}
公共类小部件{
...
公共静态void processWidget（Widget w）{
WidgetProcessor WidgetProcessor=新的WidgetProcessor（）；
返回widgetProcessor.processWidget（getWidgetFromRequest（request））；
}
}
公共类WidgetProcessor{
公共小部件processWidget（小部件w）{
//检查小部件。如果某些属性包含某些
//值，将其放置在队列中。否则“处理”小部件
//并将其保存到数据库中。
如果（w.包含特殊值（））
QueueManager.sendToQueue（w）；
否则{
//进程小部件。。。
保存（w）；
}
返回w；
}
}
公共类WidgetPresenter{
私有最终WidgetRequestFactory rf=GWT.create（WidgetRequestFactory.class）；
公共WidgetPresenter（）{
初始化（neweventbus（））；
rf.widgetRequest（）.widgetProcessor（）.fire（新接收器（）{
@凌驾
成功时公共无效（WidgetProxy响应）{
WidgetView v=新WidgedView（响应）；
RootPanel.get（）.add（视图）；
}
});
}
}
包com.foo.bar.client；
公共类WidgetView{
公共WidgetView（WidgetProxy小部件）{
//使用小部件绘制小部件
//getSomeProperty（）等。
}
}
    我认为没有必要为此对
    请求工厂进行头脑风暴
    
根据我的意见，使用
    Gwt-RPC
    可以非常简单
    
简而言之，简单的RPC结构如下所示：
    

    GWT Code <===> InterfaceAsync <===> Interface (Synchronous)<===> Server Code 

    
异步接口（Ke）

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

public interface WidgetRPCInterfaceAsync
{
    public void widgetProcessRPCWidget myWidget, AsyncCallback callback);
}

    

    public class WidgetRPCImpl extends RemoteServiceServlet implements RPCInterface
{
    private static final long serialVersionUID = 1L;

    public Widget widgetProcessRPCWidget myWidget)
    {
       //Process your widget  here (CRUD operations)
       //You can change return type and return what ever you want to client . 
    }

**you can override doget,doPost,doDelete....etc along with your methods 
}

    

         <servlet>
    <servlet-name>widgetrpc</servlet-name>
    <servlet-class>com.server.WidgetRPCImpl</servlet-class>
  </servlet>

  <servlet-mapping>
    <servlet-name>widgetrpc</servlet-name>
    <url-pattern>/widgetrpc</url-pattern>
  </servlet-mapping>

    

       private final WidgetRPCInterfaceAsync widgetService = 
        GWT.create(WidgetRPCInterface.class);
        ServiceDefTarget endpoint = (ServiceDefTarget) service;
        endpoint.setServiceEntryPoint('widgetrpc');

    

    widgetService.widgetProcessRPC(widgetFromClient, callback);
 AsyncCallback callback = new AsyncCallback()
    {
        public void onFailure(Throwable caught)
        {
           //Do on fail
        }

        public void onSuccess(Object result)
        {
           //Process successfully done with result (result is which you
           returned in impl class) .
        }
    };