Spring Data Rest ManytoMany POST

Во-первых, позвольте мне объяснить мой вариант использования. Это довольно прямолинейно. Существует сущность «Пользователь» и сущность «Служба». У меня есть связь ManytoMany между пользователем и службой, использующая UserService в качестве присоединяемой сущности (присоединенной таблицы). Первоначально будет некоторый набор пользователей и некоторый набор служб. Пользователи могут подписаться на любую услугу в любой момент времени. В этом случае запись будет добавлена ​​в UserService. Но я получаю исключение нулевого указателя, когда пытаюсь создать новую ассоциацию UserService. Я мог бы создать пользователя и сервис по отдельности.

Мои сущности: User.java

package dao.models;

import java.io.Serializable;
import javax.persistence.*;

import com.fasterxml.jackson.annotation.JsonBackReference;
@Entity
@org.hibernate.annotations.Proxy(lazy=false)
@Table(name="`user`", schema="emm")
public class User implements Serializable {
    public User() {
    }

    @Column(name="id", nullable=false, unique=true) 
    @Id 
    @GeneratedValue(generator="EMM_USER_ID_GENERATOR")  
    @org.hibernate.annotations.GenericGenerator(name="EMM_USER_ID_GENERATOR", strategy="native")    
    private long id;


    @ManyToOne(targetEntity=dao.models.Tenant.class, fetch=FetchType.LAZY)  
    @org.hibernate.annotations.Cascade({org.hibernate.annotations.CascadeType.LOCK})    
    @JoinColumns({ @JoinColumn(name="tenant_id", referencedColumnName="id", nullable=false) })  
    @org.hibernate.annotations.LazyToOne(value=org.hibernate.annotations.LazyToOneOption.NO_PROXY)  
    private dao.models.Tenant tenant;

    @OneToOne(targetEntity=dao.models.Person.class, fetch=FetchType.LAZY)   
    @org.hibernate.annotations.Cascade({org.hibernate.annotations.CascadeType.SAVE_UPDATE, org.hibernate.annotations.CascadeType.LOCK}) 
    @JoinColumns({ @JoinColumn(name="Person_id", nullable=false) }) 
    @org.hibernate.annotations.LazyToOne(value=org.hibernate.annotations.LazyToOneOption.NO_PROXY)  
    private dao.models.Person person;

    @Column(name="password", nullable=true, length=255) 
    private String password;

    @Column(name="email", nullable=false, length=255)   
    private String email;

    @Column(name="status", nullable=true, length=255)   
    private String status;

    @ManyToMany(mappedBy="user", targetEntity=dao.models.TenantGroup.class) 
    @org.hibernate.annotations.Cascade({org.hibernate.annotations.CascadeType.SAVE_UPDATE, org.hibernate.annotations.CascadeType.LOCK}) 
    @org.hibernate.annotations.LazyCollection(org.hibernate.annotations.LazyCollectionOption.TRUE)  
    private java.util.List<dao.models.TenantGroup> group = new java.util.ArrayList<dao.models.TenantGroup>();

    @OneToMany(mappedBy="user", targetEntity=dao.models.UserService.class)  
    @org.hibernate.annotations.Cascade({org.hibernate.annotations.CascadeType.SAVE_UPDATE, org.hibernate.annotations.CascadeType.LOCK}) 
    @org.hibernate.annotations.LazyCollection(org.hibernate.annotations.LazyCollectionOption.TRUE)  
    private java.util.List<dao.models.UserService> userService = new java.util.ArrayList<dao.models.UserService>();

    public void setId(long value) {
        this.id = value;
    }

    public long getId() {
        return id;
    }



    public void setPassword(String value) {
        this.password = value;
    }

    public String getPassword() {
        return password;
    }

    public void setEmail(String value) {
        this.email = value;
    }

    public String getEmail() {
        return email;
    }

    public void setStatus(String value) {
        this.status = value;
    }

    public String getStatus() {
        return status;
    }

    public void setTenant(dao.models.Tenant value) {
        this.tenant = value;
    }

    public dao.models.Tenant getTenant() {
        return tenant;
    }

    public void setPerson(dao.models.Person value) {
        this.person = value;
    }

    public dao.models.Person getPerson() {
        return person;
    }

    public void setGroup(java.util.List<dao.models.TenantGroup> value) {
        this.group = value;
    }

    public java.util.List<dao.models.TenantGroup> getGroup() {
        return group;
    }




    public java.util.List<dao.models.UserService> getUserService() {
        return userService;
    }

    public void setUserService(
            java.util.List<dao.models.UserService> userService) {
        this.userService = userService;
    }

    public String toString() {
        return String.valueOf(getId());
    }

}

Сервисная организация

package dao.models;

import java.io.Serializable;
import javax.persistence.*;

import com.fasterxml.jackson.annotation.JsonBackReference;
@Entity
@org.hibernate.annotations.Proxy(lazy=false)
@Table(name="service", schema="emm")
public class Service implements Serializable {
    public Service() {
    }

    @Column(name="service_id", nullable=false, unique=true) 
    @Id 
    @GeneratedValue(generator="EMM_SERVICE_SERVICE_ID_GENERATOR")   
    @org.hibernate.annotations.GenericGenerator(name="EMM_SERVICE_SERVICE_ID_GENERATOR", strategy="native") 
    private long id;

    @Column(name="service_name", nullable=false, length=255)    
    @org.hibernate.annotations.Index(name="service_service_name")   
    private String serviceName;

    @Column(name="description", nullable=true, length=255)  
    private String description;

    @Column(name="app_key", nullable=false, length=255) 
    private String appKey;

    @Column(name="app_token", nullable=false, length=255)   
    private String appToken;

    @Column(name="learnmoreurl",  length=255)   
    private String learnMoreURL;

    @Column(name="trialurl",  length=255)   
    private String trialURL;

    @ManyToMany(mappedBy="service", targetEntity=dao.models.Device.class)   
    @org.hibernate.annotations.Cascade({org.hibernate.annotations.CascadeType.SAVE_UPDATE, org.hibernate.annotations.CascadeType.LOCK}) 
    @org.hibernate.annotations.LazyCollection(org.hibernate.annotations.LazyCollectionOption.TRUE)  
    private java.util.List<dao.models.Device> device = new java.util.ArrayList<dao.models.Device>();

    @OneToMany(mappedBy="service", targetEntity=dao.models.ServiceParam.class)  
    @org.hibernate.annotations.Cascade({org.hibernate.annotations.CascadeType.SAVE_UPDATE, org.hibernate.annotations.CascadeType.DELETE})   
    @org.hibernate.annotations.LazyCollection(org.hibernate.annotations.LazyCollectionOption.TRUE)  
    private java.util.List<dao.models.ServiceParam> serviceParams = new java.util.ArrayList<dao.models.ServiceParam>();

    @OneToMany(mappedBy="service", targetEntity=dao.models.TenantService.class) 
    @org.hibernate.annotations.Cascade({org.hibernate.annotations.CascadeType.PERSIST, org.hibernate.annotations.CascadeType.MERGE,
                                        org.hibernate.annotations.CascadeType.SAVE_UPDATE, org.hibernate.annotations.CascadeType.DELETE_ORPHAN})    
    @org.hibernate.annotations.LazyCollection(org.hibernate.annotations.LazyCollectionOption.TRUE)  
    private java.util.List<dao.models.TenantService> tenantService = new java.util.ArrayList<dao.models.TenantService>();

    @OneToMany(mappedBy="service", targetEntity=dao.models.UserService.class)   
    @org.hibernate.annotations.Cascade({org.hibernate.annotations.CascadeType.SAVE_UPDATE, org.hibernate.annotations.CascadeType.DELETE})   
    @org.hibernate.annotations.LazyCollection(org.hibernate.annotations.LazyCollectionOption.TRUE)  
    private java.util.List<dao.models.UserService> userService = new java.util.ArrayList<dao.models.UserService>();

    public long getId() {
        return id;
    }

    public void setId(long id) {
        this.id = id;
    }

    public String getServiceName() {
        return serviceName;
    }


    public void setServiceName(String serviceName) {
        this.serviceName = serviceName;
    }

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }

    public String getAppKey() {
        return appKey;
    }

    public void setAppKey(String appKey) {
        this.appKey = appKey;
    }

    public String getAppToken() {
        return appToken;
    }

    public void setAppToken(String appToken) {
        this.appToken = appToken;
    }

    public String getLearnMoreURL() {
        return learnMoreURL;
    }
    public void setLearnMoreURL(String learnMoreURL) {
        this.learnMoreURL = learnMoreURL;
    }

    public String getTrialURL() {
        return trialURL;
    }

    public void setTrialURL(String trialURL) {
        this.trialURL = trialURL;
    }

    public java.util.List<dao.models.Device> getDevice() {
        return device;
    }


    public void setDevice(java.util.List<dao.models.Device> device) {
        this.device = device;
    }

    public java.util.List<dao.models.ServiceParam> getServiceParams() {
        return serviceParams;
    }

    public void setServiceParams(
            java.util.List<dao.models.ServiceParam> serviceParams) {
        this.serviceParams = serviceParams;
    }

    public java.util.List<dao.models.TenantService> getTenantService() {
        return tenantService;
    }

    public void setTenantService(
            java.util.List<dao.models.TenantService> tenantService) {
        this.tenantService = tenantService;
    }

    public java.util.List<dao.models.UserService> getUserService() {
        return userService;
    }

    public void setUserService(
            java.util.List<dao.models.UserService> userService) {
        this.userService = userService;
    }
    public String toString() {
        return String.valueOf(getId());
    }

}

И, наконец, объект соединения

UserService.java

package dao.models;

import java.io.Serializable;
import javax.persistence.*;
@Entity
@org.hibernate.annotations.Proxy(lazy=false)
@Table(name="user_service" ,schema="emm")
public class UserService implements Serializable {
    public UserService() {
    }

    @Column(name="id", nullable=false, unique=true) 
    @Id 
    @GeneratedValue(generator="EMM_USER_SERVICE_ID_GENERATOR")  
    @org.hibernate.annotations.GenericGenerator(name="EMM_USER_SERVICE_ID_GENERATOR", strategy="native")    
    private long id;

    @ManyToOne(targetEntity=dao.models.User.class, fetch=FetchType.LAZY)    
    @org.hibernate.annotations.Cascade({org.hibernate.annotations.CascadeType.LOCK})    
    @JoinColumns({ @JoinColumn(name="user_id", referencedColumnName="id", nullable=false) })    
    @org.hibernate.annotations.LazyToOne(value=org.hibernate.annotations.LazyToOneOption.NO_PROXY)  
    private dao.models.User user;

    @ManyToOne(targetEntity=dao.models.Service.class, fetch=FetchType.LAZY) 
    @org.hibernate.annotations.Cascade({org.hibernate.annotations.CascadeType.LOCK})    
    @JoinColumns({ @JoinColumn(name="service_id", referencedColumnName="service_id", nullable=false) }) 
    @org.hibernate.annotations.LazyToOne(value=org.hibernate.annotations.LazyToOneOption.NO_PROXY)  
    private dao.models.Service service;

    @Column(name="param_name", nullable=false)  
    private String paramName;

    @Column(name="param_value", nullable=true)  
    private String paramValue;

    @OneToMany(mappedBy="userService", targetEntity=dao.models.UserServiceToken.class)  
    @org.hibernate.annotations.Cascade({org.hibernate.annotations.CascadeType.SAVE_UPDATE, org.hibernate.annotations.CascadeType.LOCK}) 
    @org.hibernate.annotations.LazyCollection(org.hibernate.annotations.LazyCollectionOption.TRUE)  
    private java.util.List<dao.models.UserServiceToken> userServiceToken = new java.util.ArrayList<dao.models.UserServiceToken>();



    public long getId() {
        return id;
    }



    public void setId(long id) {
        this.id = id;
    }



    public dao.models.User getUser() {
        return user;
    }



    public void setUser(dao.models.User user) {
        this.user = user;
    }



    public dao.models.Service getService() {
        return service;
    }



    public void setService(dao.models.Service service) {
        this.service = service;
    }



    public String getParamName() {
        return paramName;
    }



    public void setParamName(String paramName) {
        this.paramName = paramName;
    }



    public String getParamValue() {
        return paramValue;
    }



    public void setParamValue(String paramValue) {
        this.paramValue = paramValue;
    }



    public java.util.List<dao.models.UserServiceToken> getUserServiceToken() {
        return userServiceToken;
    }



    public void setUserServiceToken(
            java.util.List<dao.models.UserServiceToken> userServiceToken) {
        this.userServiceToken = userServiceToken;
    }



    public String toString() {
        return String.valueOf(getId());
    }

}

Теперь моя проблема, запросы GET работают правильно, но я получаю исключение нулевого указателя, когда пытаюсь создать новый UserService.

POST: http://localhost:8080/em/api/userServices/ Я пытаюсь связать пользователя 1 со службой 2. Запрос:

{
    "paramName": "p1",
    "paramValue": "v1",
    "service": {
        "href": `"http://localhost:8080/em/api/userServices/1/service/2"`
    },
    "user": {
        "href": `"http://localhost:8080/em/api/userServices/1/user/1"`
    }
}

Сообщение об ошибке:

{
    "cause": {
        "cause": {
            "cause": null,
            "message": null
        },
        "message": "(was java.lang.NullPointerException) (through reference chain: dao.models.UserService[\"service\"])"
    },
    "message": "Could not read JSON: (was java.lang.NullPointerException) (through reference chain: dao.models.UserService[\"service\"]); nested exception is com.fasterxml.jackson.databind.JsonMappingException: (was java.lang.NullPointerException) (through reference chain: dao.models.UserService[\"service\"])"
}

GET http://localhost:8080/em/api/userServices дает мне следующий вывод:

{
  "_links" : {
    "self" : {
      "href" : "http://localhost:8080/em/api/userServices{?page,size,sort}",
      "templated" : true
    }
  },
  "_embedded" : {
    "userServices" : [ {
      "paramName" : "p1",
      "paramValue" : "v1",
      "_links" : {
        "self" : {
          "href" : "http://localhost:8080/em/api/userServices/1"
        },
        "userServiceToken" : {
          "href" : "http://localhost:8080/em/api/userServices/1/userServiceToken"
        },
        "user" : {
          "href" : "http://localhost:8080/em/api/userServices/1/user"
        },
        "service" : {
          "href" : "http://localhost:8080/em/api/userServices/1/service"
        }
      }
    }, {
      "paramName" : "pone",
      "paramValue" : "vone",
      "_links" : {
        "self" : {
          "href" : "http://localhost:8080/em/api/userServices/2"
        },
        "userServiceToken" : {
          "href" : "http://localhost:8080/em/api/userServices/2/userServiceToken"
        },
        "user" : {
          "href" : "http://localhost:8080/em/api/userServices/2/user"
        },
        "service" : {
          "href" : "http://localhost:8080/em/api/userServices/2/service"
        }
      }
    } ]
  },
  "page" : {
    "size" : 20,
    "totalElements" : 2,
    "totalPages" : 1,
    "number" : 0
  }
}

Кто-нибудь успешно внедрил ассоциацию ManyToMany с использованием Spring-data-rest. Если это так, пожалуйста, помогите мне в этом отношении


java spring spring-data-jpa spring-data-rest
person user1917034    schedule 13.03.2014    source источник
comment
Во всем Интернете я вижу примеры GET, но нет примеров POST или PUT для ресурса с ассоциациями.   -  person user1917034    schedule 13.03.2014

Ответы (1)


arrow_upward
3
arrow_downward

Я разобрался с проблемой и заработал.

Раньше мое тело запроса было:

{
    "paramName": "p1",
    "paramValue": "v1",
    "service": {
        "href": "http://localhost:8080/em/api/userServices/1/service/2"
    },
    "user": {
        "href": "http://localhost:8080/em/api/userServices/1/user/1"
    }
}

Я понял, что должно быть так:

{
    "paramName": "p1",
    "paramValue": "v1",
    "service":  "http://localhost:8080/em/api/services/2",
    "user":  "http://localhost:8080/em/api/users/1"
 }

Я чувствую, что все еще есть проблема с spring-data-rest. Пожалуйста, поясните, если кто-то считает иначе. Даже с фиксированным запросом я получал нулевое ограничение для ServiceId. Я понял, что в БД столбец первичного ключа для службы был service_id. Несмотря на то, что у меня правильное сопоставление сущности (свойство My Id в Service Entity правильно сопоставляется с service_id в db), оно не работало, мне пришлось изменить имя столбца на id, чтобы это заработало.

Spring-Data-Rest должен зависеть от отображений Entity для Id, верно? Если так, то все же есть баг.

Спасибо, Вивек

person user1917034    schedule 14.03.2014
comment
Ваш вопрос об идентификаторе должен быть опубликован как отдельный вопрос. У вашего service_id была аннотация @Id? если нет, то, вероятно, это была ваша проблема. - person JBCP; 22.01.2015