Google app engine 与谷歌应用引擎的实体关系

我正在用GAE和Java为大学做一个web应用程序。我创建了两个实体：用户和汽车。每个用户可以拥有一辆以上的汽车。因此，我创建了一个关系实体，其中car

car=new实体（“car”，plate.hashCode（），user.getKey（））我的问题是按钥匙搜索汽车。我该怎么做？因为我的代码
Entity car=getSingleCar（车牌）返回总是空的。这是我的用户代码：

public static void createOrUpdateCustomer(String name, String surname,
        String phone, String address, String city, String state,
        String zip, String email, String username, String password) {
    Entity customer = getSingleUser(username);
    if (customer == null) {
        customer = new Entity("User", username.hashCode());
        customer.setProperty("name", name);
        customer.setProperty("surname", surname);
        customer.setProperty("phone", phone);
        customer.setProperty("address", address);
        customer.setProperty("city", city);
        customer.setProperty("state", state);
        customer.setProperty("zip", zip);
        customer.setProperty("email", email);
        customer.setProperty("username", username);
        customer.setProperty("password", password);
    } else {
        System.out.println("esiste già");
        if (name != null && !"".equals(name)) {
            customer.setProperty("firstName", name);
        }
        if (surname != null && !"".equals(surname)) {
            customer.setProperty("lastName", surname);
        }
        if (phone != null && !"".equals(phone)) {
            customer.setProperty("phone", phone);
        }
        if (address != null && !"".equals(address)) {
            customer.setProperty("address", address);
        }
        if (city != null && !"".equals(city)) {
            customer.setProperty("city", city);
        }
        if (state != null && !"".equals(state)) {
            customer.setProperty("state", state);
        }
        if (zip != null && !"".equals(zip)) {
            customer.setProperty("zip", zip);
        }
        if (email != null && !"".equals(email)) {
            customer.setProperty("email", email);
        }
        if (username != null && !"".equals(username)) {
            customer.setProperty("username", username);
        }
        if (password != null && !"".equals(password)) {
            customer.setProperty("password", password);
        }
    }
    Util.persistEntity(customer);
}

public static Entity getSingleUser(String username) {
    Key key = KeyFactory.createKey("User", username.hashCode());
    return Util.findEntity(key);
}

public static Iterable<Entity> getUser(String username) {
    Iterable<Entity> entities = Util.listEntities("User", "username", username);
    return entities;
}

public static Iterable<Entity> getUserById(String id) {
    Iterable<Entity> entities = Util.listEntities("User", "ID", id);
    return entities;
}


public static Iterable<Entity> getAllUsers() {
    Iterable<Entity> entities = Util.listEntities("User", null, null);
    return entities;
}

public static void createOrUpdateCustomer（字符串名称、字符串姓氏、，
字符串电话、字符串地址、字符串城市、字符串州、，
字符串zip、字符串电子邮件、字符串用户名、字符串密码）{
实体客户=getSingleUser（用户名）；
如果（客户==null）{
customer=新实体（“User”，username.hashCode（））；
customer.setProperty（“名称”，名称）；
客户。setProperty（“姓氏”，姓氏）；
customer.setProperty（“电话”，电话）；
customer.setProperty（“地址”，address）；
客户。setProperty（“城市”，城市）；
customer.setProperty（“state”，state）；
customer.setProperty（“zip”，zip）；
customer.setProperty（“电子邮件”，email）；
customer.setProperty（“用户名”，用户名）；
customer.setProperty（“密码”，password）；
}否则{
System.out.println（“esiste giá”）；
如果（name！=null&&！“.equals（name））{
customer.setProperty（“firstName”，name）；
}
如果（姓氏！=null&&！“.equals（姓氏））{
customer.setProperty（“姓氏”）；
}
if（phone！=null&&！“.equals（phone））{
customer.setProperty（“电话”，电话）；
}
如果（地址！=null&&！“.equals（地址））{
customer.setProperty（“地址”，address）；
}
如果（城市！=null&&！“.equals（城市））{
客户。setProperty（“城市”，城市）；
}
如果（状态！=null&&！“.equals（状态））{
customer.setProperty（“state”，state）；
}
如果（zip！=null&&！“.equals（zip））{
customer.setProperty（“zip”，zip）；
}
如果（email！=null&！“.equals（email））{
customer.setProperty（“电子邮件”，email）；
}
如果（用户名！=null&&！“.equals（用户名））{
customer.setProperty（“用户名”，用户名）；
}
如果（密码！=null&&！“.equals（密码））{
customer.setProperty（“密码”，password）；
}
}
Util.实体（客户）；
}
公共静态实体getSingleUser（字符串用户名）{
Key=KeyFactory.createKey（“User”，username.hashCode（））；
返回Util.findEntity（键）；
}
公共静态Iterable getUser（字符串用户名）{
Iterable entities=Util.listenties（“用户”、“用户名”、用户名）；
返回实体；
}
公共静态Iterable getUserById（字符串id）{
Iterable entities=Util.listenties（“用户”、“ID”、ID）；
返回实体；
}
公共静态Iterable getAllUsers（）{
Iterable entities=Util.listenties（“用户”，null，null）；
返回实体；
}

e创建汽车的代码：

public static Entity createOrUpdateCar(String username, String plate, String model, String revision, String service, String brand, String motor){
    Entity user= User.getSingleUser(username);
    System.out.println(user.getKey());
    Entity car= getSingleCar(plate);

    if(car==null && user!=null){
        System.out.println("è null");
        car= new Entity("Car",plate.hashCode(), user.getKey());
        car.setProperty("plate", plate);
        car.setProperty("user", username);
        car.setProperty("model", model);
        car.setProperty("revision", revision);
        car.setProperty("service", service);
        car.setProperty("mechanic", null);
        car.setProperty("brand", brand);
        car.setProperty("motor", motor);
        car.setProperty("riparazione", null);
    }else {
        System.out.println("id"+car.getProperty("plate"));
    }
    Util.persistEntity(car);
    return car;
}

public static Entity getSingleCar(String plate) {
    Key key = KeyFactory.createKey("Car", plate.hashCode());
    return Util.findEntity(key);
}

public static Entity getSingleCarByKey(Key key) {
    return Util.findEntity(key);
}

public static Iterable<Entity> getCar(String plate) {
    Iterable<Entity> entities = Util.listEntities("Car", "plate", plate);
    return entities;
}

public static Iterable<Entity> getAllCars() {
    Iterable<Entity> entities = Util.listEntities("Car", null, null);
    return entities;
}

公共静态实体createOrUpdateCar（字符串用户名、字符串铭牌、字符串模型、字符串修订、字符串服务、字符串品牌、字符串马达）{
实体用户=user.getSingleUser（用户名）；
System.out.println（user.getKey（））；
实体车=getSingleCar（车牌）；
if（car==null&&user！=null）{
System.out.println（“ènull”）；
car=新实体（“car”，plate.hashCode（），user.getKey（））；
汽车。设置属性（“车牌”，车牌）；
setProperty（“用户”，用户名）；
设置属性（“模型”，模型）；
car.setProperty（“修订版”，修订版）；
汽车。固定资产（“服务”，服务）；
car.setProperty（“机械师”，空）；
汽车。setProperty（“品牌”，品牌）；
汽车。设置属性（“电机”，电机）；
car.setProperty（“riparazione”，空）；
}否则{
System.out.println（“id”+car.getProperty（“plate”）；
}
实用实体（car）；
返回车；
}
公共静态实体getSingleCar（串板）{
Key=KeyFactory.createKey（“Car”，plate.hashCode（））；
返回Util.findEntity（键）；
}
公共静态实体getSingleCarByKey（Key）{
返回Util.findEntity（键）；
}
公共静电感应车（线板）{
Iterable entities=Util.listenties（“汽车”、“车牌”、“车牌”）；
返回实体；
}
公共静态Iterable getAllCars（）{
Iterable entities=Util.listenties（“Car”，null，null）；
返回实体；
}
看到您的代码后，我发现您的代码总是为空的原因
实体车=getSingleCar（plate）
；您使用了错误的键进行此查询

创建新的汽车实体时，使用键
（“Car”，plate.hashCode（），user.getKey（））包含3个部分-种类、id、祖先密钥

但是在查询car时，您没有添加祖先密钥，因此您最终使用了一个不匹配的密钥来查询
key key=KeyFactory.createKey（“car”，plate.hashCode（））

相反，您应该使用同样具有祖先密钥的密钥
key-key=KeyFactory.createKey（user.getKey（），“Car”，plate.hashCode（））
请更改您的查询方法以具有此属性。更好地理解实体构造函数细节和KeyFactory方法