java - Spring Data Rest 多对多 POST

coder 2024-03-20 原文

首先，让我解释一下我的用例。这很简单。有一个用户实体和一个服务实体。我使用 UserService 作为连接实体(连接表)在用户和服务之间建立了多对多关联。最初，会有一些用户集和一些服务集。用户可以随时订阅任何服务。在这种情况下，将向 UserService 添加一个条目。但是，当我尝试创建新的 UserService 关联时出现空指针异常。我可以单独创建用户和服务。

我的实体是: 用户.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());
    }

}

最后是加入实体

用户服务.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
  }
}

有没有人使用 Spring-data-rest 成功实现了 ManyToMany 关联。如果是这样，请在这方面帮助我

最佳答案

我弄清楚了问题并使其正常工作。

以前，我的请求正文是:

{
    "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 的空约束。我在db中发现，服务的主键列是service_id。尽管我有正确的实体映射(服务实体中的我的 Id 属性正确映射到数据库中的 service_id)，但它不起作用，我必须将列名称更改为 id 才能使其正常工作。

Spring-Data-Rest 应该取决于 Id 的实体映射，对吗？如果是这样，那么仍然存在错误。

谢谢，维维克

关于java - Spring Data Rest 多对多 POST，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/22380599/

Spring java 34 annotations hibernate spring-data-jpa spring-data-rest

有关java - Spring Data Rest 多对多 POST的更多相关文章

ruby - 如何模拟 Net::HTTP::Post？ - 2
是的，我知道最好使用webmock，但我想知道如何在RSpec中模拟此方法:defmethod_to_testurl=URI.parseurireq=Net::HTTP::Post.newurl.pathres=Net::HTTP.start(url.host,url.port)do|http|http.requestreq,foo:1endresend这是RSpec:let(:uri){'http://example.com'}specify'HTTPcall'dohttp=mock:httpNet::HTTP.stub!(:start).and_yieldhttphttp.shou
ruby-on-rails - rails : How to make a form post to another controller action - 2
我知道您通常应该在Rails中使用新建/创建和编辑/更新之间的链接，但我有一个情况需要其他东西。无论如何我可以实现同样的连接吗？我有一个模型表单，我希望它发布数据(类似于新View如何发布到创建操作)。这是我的表格prohibitedthisjobfrombeingsaved: 最佳答案使用:url选项。=form_for@job,:url=>company_path,:html=>{:method=>:post/:put} 关于ruby-on-rails-rails:Howtomak
java - 等价于 Java 中的 Ruby Hash - 2
我真的很习惯使用Ruby编写以下代码:my_hash={}my_hash['test']=1Java中对应的数据结构是什么？最佳答案 HashMapmap=newHashMap();map.put("test",1);我假设？关于java-等价于Java中的RubyHash，我们在StackOverflow上找到一个类似的问题： https://stackoverflow.com/questions/22737685/
ruby - 有人可以帮助解释类创建的 post_initialize 回调吗 (Sandi Metz) - 2
我正在阅读SandiMetz的POODR，并且遇到了一个我不太了解的编码原则。这是代码:classBicycleattr_reader:size,:chain,:tire_sizedefinitialize(args={})@size=args[:size]||1@chain=args[:chain]||2@tire_size=args[:tire_size]||3post_initialize(args)endendclassMountainBike此代码将为其各自的属性输出1,2,3,4,5。我不明白的是查找方法。当一辆山地自行车被实例化时，因为它没有自己的initialize方法
jquery - 我的 jquery AJAX POST 请求无需发送 Authenticity Token (Rails) - 2
rails中是否有任何规定允许站点的所有AJAXPOST请求在没有authenticity_token的情况下通过？我有一个调用Controller方法的JqueryPOSTajax调用，但我没有在其中放置任何真实性代码，但调用成功。我的ApplicationController确实有'request_forgery_protection'并且我已经改变了config.action_controller.consider_all_requests_local在我的environments/development.rb中为false我还搜索了我的代码以确保我没有重载ajaxSend来发送
java - 从 JRuby 调用 Java 类的问题 - 2
我正在尝试使用boilerpipe来自JRuby。我看过guide从JRuby调用Java，并成功地将它与另一个Java包一起使用，但无法弄清楚为什么同样的东西不能用于boilerpipe。我正在尝试基本上从JRuby中执行与此Java等效的操作:URLurl=newURL("http://www.example.com/some-location/index.html");Stringtext=ArticleExtractor.INSTANCE.getText(url);在JRuby中试过这个:require'java'url=java.net.URL.new("http://www
java - 我的模型类或其他类中应该有逻辑吗 - 2
我只想对我一直在思考的这个问题有其他意见，例如我有classuser_controller和classuserclassUserattr_accessor:name,:usernameendclassUserController//dosomethingaboutanythingaboutusersend问题是我的User类中是否应该有逻辑user=User.newuser.do_something(user1)oritshouldbeuser_controller=UserController.newuser_controller.do_something(user1,user2)我
java - 什么相当于 ruby 的 rack 或 python 的 Java wsgi？ - 2
什么是ruby的rack或python的Java的wsgi？还有一个路由库。最佳答案来自Python标准PEP333:Bycontrast,althoughJavahasjustasmanywebapplicationframeworksavailable,Java's"servlet"APImakesitpossibleforapplicationswrittenwithanyJavawebapplicationframeworktoruninanywebserverthatsupportstheservletAPI.ht
ruby - 我如何添加二进制数据来遏制 POST - 2
我正在尝试使用Curbgem执行以下POST以解析云curl-XPOST\-H"X-Parse-Application-Id:PARSE_APP_ID"\-H"X-Parse-REST-API-Key:PARSE_API_KEY"\-H"Content-Type:image/jpeg"\--data-binary'@myPicture.jpg'\https://api.parse.com/1/files/pic.jpg用这个:curl=Curl::Easy.new("https://api.parse.com/1/files/lion.jpg")curl.multipart_form_
Observability：从零开始创建 Java 微服务并监控它（二） - 2
这篇文章是继上一篇文章“Observability：从零开始创建Java微服务并监控它（一）”的续篇。在上一篇文章中，我们讲述了如何创建一个Javaweb应用，并使用Filebeat来收集应用所生成的日志。在今天的文章中，我来详述如何收集应用的指标，使用APM来监控应用并监督web服务的在线情况。源码可以在地址 https://github.com/liu-xiao-guo/java_observability 进行下载。摄入指标指标被视为可以随时更改的时间点值。当前请求的数量可以改变任何毫秒。你可能有1000个请求的峰值，然后一切都回到一个请求。这也意味着这些指标可能不准确，你还想提取最小/

java - Spring Data Rest 多对多 POST

有关java - Spring Data Rest 多对多 POST的更多相关文章

随机推荐