Question

如果我有以下内容：

public interface GetItemRequest<T extends FooBase>
{
    public long getId();
}

public class GetFooRequest implements GetItemRequest<Foo>
{
  //snip..
}

public interface GetService extends RemoteService
{
   public <T extends FooBase> T get( GetItemRequest<T> request );
}

在服务器上，我有以下执行方法，它通过GWT-RPC执行请求：

public class GetServiceImpl<T extends FooBase>
          extends RemoteServiceServlet
          implements GetSerice<T>

{
   public T get( GetItemRequest<T> request)
   { 
     //snip
   }
}

这不起作用，它给出了错误：

例外： com.google.gwt.user.client.rpc.IncompatibleRemoteServiceException： com.xxx.GetFooRequest
的类型签名无效

但是，如果我将GetItemRequest更改为抽象类而不是接口，即：

public abstract class GetItemRequest<T extends FooBase>
{
    public abstract long getId();
}

让GetFooRequest从GetItemRequest<Foo>而不是implement延伸，然后请求就可以了。

然而，奇怪的是，GetFooRequest必须是完全抽象的才能使其发挥作用。如果我尝试实施任何方法，例如getId()而不是GetItemRequest中的GetFooRequest，我会得到相同的例外。

有人知道这种奇怪行为背后的原因吗？

Answer 1

我已经尝试过您的代码，并且只需稍作修改即可正常工作。

您的代码中也存在一些编译错误，可能是由于拼写错误，例如：

GetItemRequest<T extends FooBase>

public class GetServiceImpl<T extends FooBase> extends RemoteServiceServlet implements GetService

请从以下代码中再次验证：

<强>共享：

public abstract class GetItemRequest<T extends FooBase> {
    public abstract long getId();
}

import com.google.gwt.user.client.rpc.IsSerializable;
public class GetFooRequest  extends GetItemRequest<Foo> implements IsSerializable {
    @Override
    public long getId() {
        return 0;
    }
}

import com.google.gwt.user.client.rpc.IsSerializable;
public class FooBase implements IsSerializable{
    ...
}

public class Foo extends FooBase{
    ...
}

<强>客户端：

import com.google.gwt.user.client.rpc.RemoteService;
import com.google.gwt.user.client.rpc.RemoteServiceRelativePath;
import com.gwt.test.shared.FooBase;
import com.gwt.test.shared.GetItemRequest;
@RemoteServiceRelativePath("get")
public interface GetService extends RemoteService {
    public <T extends FooBase> T get(GetItemRequest<T> request);
}

import com.google.gwt.user.client.rpc.AsyncCallback;
import com.gwt.test.shared.FooBase;
import com.gwt.test.shared.GetItemRequest;
public interface GetServiceAsync {
    void get(GetItemRequest request, AsyncCallback<FooBase> callback);
}

public void onModuleLoad() {

    GetServiceAsync getService = GWT.create(GetService.class);

    getService.get(new GetFooRequest(), new AsyncCallback<FooBase>() {

        @Override
        public void onFailure(Throwable caught) {
            System.out.println("failure");
        }

        @Override
        public void onSuccess(FooBase result) {
            System.out.println("success");
        }

    });

    ...
}

服务器

import com.google.gwt.user.server.rpc.RemoteServiceServlet; import com.gwt.test.client.GetService; import com.gwt.test.shared.Foo; import com.gwt.test.shared.FooBase; import com.gwt.test.shared.GetItemRequest; public class GetServiceImpl<T extends FooBase> extends RemoteServiceServlet implements GetService { @Override public <T extends FooBase> T get(GetItemRequest<T> request) { ... } }

<强>的web.xml：

<servlet> <servlet-name>getServlet</servlet-name> <servlet-class>com.x.y.z.server.GetServiceImpl</servlet-class> </servlet> <servlet-mapping> <servlet-name>getServlet</servlet-name> <url-pattern>/context_root/get</url-pattern> </servlet-mapping>

Answer 2

如果您的代码发生了一些变化，它将开始工作：

实现IsSerializable。

import com.google.gwt.user.client.rpc.IsSerializable;
public class GetFooRequest implements GetItemRequest<Foo>,IsSerializable
{
  //snip..
}

更改退货类型。

public class GetServiceImpl<T extends FooBase>
         extends RemoteServiceServlet
         implements GetSerice<T>
  {
     public <T extends FooBase> get( GetItemRequest<T> request)
     { 
       //snip
     }
  }

GWT无法实例化接口，但可以实例化一个抽象类？

2 个答案: