标签: requestfactory

我Long在我的实体中使用id,不仅要将它们存储在数据存储区中,还要引用其他实体.现在,我正在使用RequestFactory在客户端上创建()对象并持久化它们,但我需要一种方法来确定服务器生成的id.

这是我认为需要两次旅行的一种方式:

final OrganizationProxy proxy = context.create(OrganizationProxy.class);
context.persist().using(proxy).fire(new Receiver<Void>(){

    public void onSuccess(Void response)
    {
        requestFactory.find(proxy.stableId()).fire(new Receiver<OrganizationProxy>()
        {
            public void onSuccess(OrganizationProxy response)
            {
                //hey, now response has the server-generated id in it, along with any other values the server populated
            }
        });
    }
});

但似乎必须有一种方法来获得持久的id而没有第二次旅行.似乎requestFactory.find()首先需要持久性id才能工作.

如何在没有第二次请求的情况下获取持久性ID？

======= =======更新

它最终发生在我身上(在tbroyer 告诉我之后 ;))我可以Long从RequestContext中的persist()方法返回id.这不会从中检索持久性ID EntityProxyId,但它确实在单个请求中获得了新对象的持久性ID.

我将这个问题保持开放 - 我仍然有兴趣从EntityProxyId中获取持久性id.

我是RequestFactory的新手,但在Thomas Broyer的慷慨帮助下,在审阅了下面的文档后,它变得更好:)

• RequestFactory入门
• 要求工厂搬运零件
• GWT 2.4中的RequestFactory更改

但是,请你解释为什么Locator<>.find()经常被不必要地(在我看来)被召唤？

在我的示例项目中,我有两个维护父子关系的实体Organization和Person.当我获取组织Objectify时自动获取子Person.我还在服务层中创建了两个方法findOrganizationById,saveOrganization即加载和持久化对象.

现在考虑两种情况:

当我findOrganizationById在客户端呼叫后,在服务器端发生呼叫:

OrderDao.findOrganizationById(1)
PojoLocator.getId(Key<?>(Organization(1)))
PojoLocator.getId(Key<?>(Organization(1)/Person(2)))
PojoLocator.getId(Key<?>(Organization(1)))
PojoLocator.find(Key<?>(Organization(1)))
PojoLocator.getId(Key<?>(Organization(1)/Person(2)))
PojoLocator.find(Key<?>(Organization(1)/Person(2)))

通过调用OrderDao.findOrganizationById我已经收到完整的对象图.为什么.find除此之外还要打两次电话？数据存储的额外负载花了我钱.当然我会缓存它,但修复它会很好.如何避免这些额外的通话？

当我通过saveOrganization在客户端中调用来保存对象时,会发生类似的事情.以下调用发生在服务器端:

PojoLocator.find(Key<?>(Organization(1)))
PojoLocator.find(Key<?>(Organization(1)/Person(2)))
OrderDao.saveOrganization(1)
PojoLocator.getId(Key<?>(Organization(1)))
PojoLocator.find(Key<?>(Organization(1)))
PojoLocator.getId(Key<?>(Organization(1)/Person(2)))
PojoLocator.find(Key<?>(Organization(1)/Person(2)))

我可以理解在更新之前需要从DataStore中获取两个对象.RequestFactory将增量发送到服务器,因此在持久化之前需要拥有整个对象.自从我一次加载完整的图表后,不再进行第二次调用会很好PojoLocator.find(Key<?>(Organization(1)/Person(2))).在坚持不懈之后,我真的无法理解.find()呼叫的需要.

想法？

我的代理人

@ProxyFor(value = Organization.class, locator = PojoLocator.class)
public interface OrganizationProxy extends EntityProxy
{
    public String getName();
    public void setName(String name);
    public String …

我一直在用GWT 2.4开发一个项目,并寻找一种方法来验证(JSR 303)我的客户端(代理)类,而无需重新创建来自我的域类(服务器端)的注释.我知道有一个使用GWT中继代码(验证)的例子,但它不使用RequestFactory,它使用RPC.

是否可以从客户端的域类中获取验证？它是最好的策略与客户端代码共享我的域模型？

据我所知,GWT团队正在研究2.3和2.4的这个功能.它已经完成,还是我应该等待GWT 2.5？

这已经发布在GWT论坛上,但仍然没有答案.

https://groups.google.com/forum/#!msg/google-web-toolkit/au_GCy_9WZQ/6296p5TcWdoJ

谢谢.

编辑:这是如何在客户端验证(未测试)...

@UiHandler("save")
void onSave(ClickEvent event) {
    Modulo modulo = new Modulo(); //domain class
    Validator validator = Validation.buildDefaultValidatorFactory().getValidator();
    Set<ConstraintViolation<Modulo>> violations = validator.validate(modulo, Default.class);
    delegate.saveClicked();
}

RequestFactory如果可能的话,我想将GWT 用于所有客户端 - 服务器通信.我的理解是你必须映射/gwtServlet到RequestFactoryServlet你的web.xml,然后使用@Service注释来告诉RequestFactoryServlet如何将客户端请求映射到适当的服务.

有人可以在客户端和服务器端提供此过程的完整代码示例吗？我想Widget从客户端向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);
        } …

在一个应用程序中,我有一个包含其他实体列表的实体(假设一个事件包含已分配员工的列表)

使用objectify - 我需要找到特定员工所分配的所有事件.

是否有一种过滤查询的基本方法,如果它包含参数 - 与查询相反的类型

...快速伪代码

findAll(Employee employee) {
  ...
  return ofy.query(Event.class).filter("employees.contains", employee).list();
}

任何帮助将不胜感激

在看到这个http://groups.google.com/group/objectify-appengine/browse_thread/thread/77ba676192c08e20之后,我尝试过做过滤器("员工",员工)- 不幸的是,这会给我一个空列表

目前我正在做一些非常低效的事情 - 通过每个事件,遍历员工并将它们添加到新列表中,如果它包含给定员工只是为了让某些东西有效 - 我知道这不是正确的

让我添加一件事,

上面的查询实际上并不是什么,我只是使用它,因为我不认为这会有所作为.

Employee和Events与Business作为父级位于同一实体组中

我正在使用的实际查询如下

ofy.query(Event.class).ancestor(businessKey).filter("employees", employee).list();

不幸的是,这仍然是一个空列表 - 确实有祖先(键)在那里弄乱过滤器？

解决方案,员工字段未正确索引.

我添加了数据存储索引文件来创建一个复合索引,但最初测试的是我在员工字段编入索引之前添加的值,这是我做的愚蠢 - 只需在"业务"字段上创建一个索引"员工"领域修复了一切.数据存储索引文件似乎没有必要,删除后再次尝试一切正常.

是否可以重新发送RequestFactory传输？我想做相同的事情:如何在使用RequestFactory时重新发送GWT RPC请求.从先前的请求重新发送相同的有效负载相当简单,但我还需要调用相同的方法.这是我的RequestTransport类,我希望在处理用户登录凭据的请求之后,只需"重新启动"原始请求:

package org.greatlogic.rfexample2.client;

import com.google.gwt.http.client.Request;
import com.google.gwt.http.client.RequestBuilder;
import com.google.gwt.http.client.RequestCallback;
import com.google.gwt.http.client.Response;
import com.google.web.bindery.requestfactory.gwt.client.DefaultRequestTransport;
/**
 * Every request factory transmission will pass through the single instance of this class. This can
 * be used to ensure that when a response is received any global conditions (e.g., the user is no
 * longer logged in) can be handled in a consistent manner.
 */
public class RFERequestTransport extends DefaultRequestTransport {
//--------------------------------------------------------------------------------------------------
private IClientFactory _clientFactory;
//==================================================================================================
private final class …

有没有办法使用RequestFactory在单个请求中创建两个实体？我试过了:

    EmployeeRequest request = requestFactory.employeeRequest();
    EmployeeProxy newEmployee = request.create(EmployeeProxy.class);
    newEmployee.setName("Joe!");

    Request<Void> createReq = request.persist().using(newEmployee);
    createReq.fire();

    EmployeeProxy newEmployee2 = request.create(EmployeeProxy.class);
    newEmployee2.setName("Sam!");

    Request<Void> createReq2 = request.persist().using(newEmployee2);
    createReq2.fire();

但是我收到一个错误,表明请求已在进行中.当我做两个单独的EmployeeRequests时:

    EmployeeRequest request = requestFactory.employeeRequest();
    EmployeeProxy newEmployee = request.create(EmployeeProxy.class);
    newEmployee.setName("Joe!");

    Request<Void> createReq = request.persist().using(newEmployee);
    createReq.fire();

    EmployeeRequest request2 = requestFactory.employeeRequest();
    EmployeeProxy newEmployee2 = request2.create(EmployeeProxy.class);
    newEmployee2.setName("Sam!");

    Request<Void> createReq2 = request2.persist().using(newEmployee2);
    createReq2.fire();

然后从浏览器发出两个单独的请求.我希望RequestFactory中的某些东西可以合并多个请求 - 我必须一次创建数百个实体,而且我不想发出数百个请求!

我的GWT应用程序有十种不同的实体.现在我使用普通的旧DTO并通过GWT-RPC传输它们.这适用于启动等情况 - 我可以将它们全部打包到一个请求中.

我正在寻找切换到RequestFactory,因为在我需要更新一种类型的实体时,应用程序的整个生命周期中有很多次(平均30分钟),并且RequestFactory的统一/带宽保存功能很吸引人.但是:我没有看到在应用加载时在单个请求中下载所有初始化数据的方法.我不想要为我的十种实体类型提取十个请求来获取所有init数据.

有没有办法制作GeneralRequestContext,还是什么？我甚至对以下解决方案感到满意:

public interface InitDataProxy extends EntityProxy
{
    public UserProxy getInitUsers();
    public OrganizationProxy getInitOrganizations();
    ...
}

public interface GeneralRequestContext extends RequestContext
{
    Request<InitDataProxy> getInitData();
}

但是这不起作用,因为我不想用任何东西实际支持InitDataProxy,我只想用它在一个请求中组合一堆不同类型的代理.

那么:有没有办法EntityProxy在单个请求中接收多个不相关的类型？

我也很乐意为这个数据制作一个普通的gwt-rpc请求到RequestFactory之外,但是我不想在RequestFactory的代理旁边实现重复的DTO,并编写自定义代码来将DTO复制到他们!

我刚刚开始将我的GWT-RPC代码移植到新RequestFactory机制.

为了防止跨站点请求伪造(CSRF),我的GWT-RPC代码获取了存储在cookie中的会话ID,并将其包含在请求的有效负载中.这有可能RequestFactory吗？

据我所知,有四种强制定位器方法,包括findEntity(id_type id):所以我在想:哦,亲爱的:我在哪里提出我的会话ID？

以下线程[实体无法转换为javassist.util.proxy.Proxy,我现在有一个服务器端错误(tks thomas)我无法面对我的应用程序中的真正问题.

java.lang.ClassCastException: org.nit.persistance.entities.Manufacturers_.$$_javassist_3 cannot be cast to javassist.util.proxy.Proxy
    at org.hibernate.proxy.pojo.javassist.JavassistLazyInitializer.getProxy(JavassistLazyInitializer.java:148)
    at org.hibernate.proxy.pojo.javassist.JavassistProxyFactory.getProxy(JavassistProxyFactory.java:73)
    at org.hibernate.tuple.entity.AbstractEntityTuplizer.createProxy(AbstractEntityTuplizer.java:758)
    at org.hibernate.persister.entity.AbstractEntityPersister.createProxy(AbstractEntityPersister.java:4419)
    at org.hibernate.event.internal.DefaultLoadEventListener.createProxyIfNecessary(DefaultLoadEventListener.java:333)
    at org.hibernate.event.internal.DefaultLoadEventListener.proxyOrLoad(DefaultLoadEventListener.java:259)
    at org.hibernate.event.internal.DefaultLoadEventListener.onLoad(DefaultLoadEventListener.java:151)
    at org.hibernate.internal.SessionImpl.fireLoad(SessionImpl.java:1017)
    at org.hibernate.internal.SessionImpl.internalLoad(SessionImpl.java:944)
    at org.hibernate.type.EntityType.resolveIdentifier(EntityType.java:671)
    at org.hibernate.type.EntityType.resolve(EntityType.java:489)
    at org.hibernate.engine.internal.TwoPhaseLoad.doInitializeEntity(TwoPhaseLoad.java:168)
    at org.hibernate.engine.internal.TwoPhaseLoad.initializeEntity(TwoPhaseLoad.java:137)
    at org.hibernate.loader.Loader.initializeEntitiesAndCollections(Loader.java:1112)
    at org.hibernate.loader.Loader.processResultSet(Loader.java:969)
    at org.hibernate.loader.Loader.doQuery(Loader.java:917)
    at org.hibernate.loader.Loader.doQueryAndInitializeNonLazyCollections(Loader.java:348)
    at org.hibernate.loader.Loader.doQueryAndInitializeNonLazyCollections(Loader.java:318)
    at org.hibernate.loader.Loader.loadEntity(Loader.java:2143)
    at org.hibernate.loader.entity.AbstractEntityLoader.load(AbstractEntityLoader.java:82)
    at org.hibernate.loader.entity.AbstractEntityLoader.load(AbstractEntityLoader.java:72)
    at org.hibernate.persister.entity.AbstractEntityPersister.load(AbstractEntityPersister.java:3939)
    at org.hibernate.event.internal.DefaultLoadEventListener.loadFromDatasource(DefaultLoadEventListener.java:461)
    at org.hibernate.event.internal.DefaultLoadEventListener.doLoad(DefaultLoadEventListener.java:430)
    at org.hibernate.event.internal.DefaultLoadEventListener.load(DefaultLoadEventListener.java:207)
    at org.hibernate.event.internal.DefaultLoadEventListener.proxyOrLoad(DefaultLoadEventListener.java:263)
    at org.hibernate.event.internal.DefaultLoadEventListener.onLoad(DefaultLoadEventListener.java:151)
    at org.hibernate.internal.SessionImpl.fireLoad(SessionImpl.java:1017)
    at org.hibernate.internal.SessionImpl.access$2000(SessionImpl.java:173)
    at org.hibernate.internal.SessionImpl$IdentifierLoadAccessImpl.load(SessionImpl.java:2413)
    at org.hibernate.internal.SessionImpl.get(SessionImpl.java:913)
    at org.nit.persistance.dao.impl.FichesImpl.readbyPK(FichesImpl.java:24)
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at sun.reflect.NativeMethodAccessorImpl.invoke(Unknown Source)
    at …