使用Spring Data Projections获取一对多属性的一部分

Question

我想返回Parent.id字段和List<Child.id>的元组。

---

Parent：

import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.OneToMany;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

@Entity
public class Parent implements Serializable {

    private static final long serialVersionUID = 1L;

    @Id
    @GeneratedValue
    @Column(name = "id")
    private Long parentId;

    //we actually use Set and override hashcode&equals
    @OneToMany(mappedBy = "parent", cascade = CascadeType.ALL)
    private List<Child> children = new ArrayList<>();

    public void addChild(Child child) {

        child.setParent(this);
        children.add(child);
    }

    public void removeChild(Child child) {

        child.setParent(null);
        children.remove(child);
    }

    public Long getParentId() {

        return id;
    }

    public List<Child> getReadOnlyChildren() {

        return Collections.unmodifiableList(children);
    }
}

Child：

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import java.io.Serializable;

@Entity
public class Child implements Serializable {

    private static final long serialVersionUID = 1L;

    @Id
    @GeneratedValue
    @Column(name = "id")
    private Long childId;

    @ManyToOne
    @JoinColumn(name = "id")
    private Parent parent;

    public Long getChildId() {

        return id;
    }

    public Parent getParent() {

        return parent;
    }

    /**
     * Only for usage in {@link Parent}
     */
    void setParent(final Parent parent) {

        this.parent = parent;
    }
}

Spring数据投影：

import java.util.List;

interface IdAndChildrenIds {

    Long getParentId();

    List<ChildId> getChildren();
}

interface ChildId {

    Long getChildId();
}

ParentRepository这是问题开始的地方：

import org.springframework.data.repository.CrudRepository;

public interface ParentRepository extends CrudRepository<Parent, Long> {

    IdAndChildrenIds findIdAndChildrenIdsById(Long id);
}

但是那不起作用，因为该属性不符合JavaBean标准（用getReadOnlyChildren代替getChildren来获取，所以我将ObjectMapper配置为可以识别私有字段：

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.http.converter.json.Jackson2ObjectMapperBuilder;
import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;

import java.util.List;

@Configuration
@EnableWebMvc
public class HibernateConfiguration extends WebMvcConfigurerAdapter {

    @Override
    public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {

        ObjectMapper mapper = new Jackson2ObjectMapperBuilder().build();
        mapper.setVisibility(PropertyAccessor.FIELD, JsonAutoDetect.Visibility.ANY);

        converters.add(new MappingJackson2HttpMessageConverter(mapper));
    }
}

然后，它仍然不起作用，因为该属性已初始化LAZY，并且无法在事务外部获取（并且因为这是一种更好的做法，所以我在spring.jpa.open-in-view=false中写了application.properties）。因此，我必须使用查询指定显式join，还必须使用别名，以便Spring Data可以识别属性：

import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.CrudRepository;
import org.springframework.data.repository.query.Param;

public interface ParentRepository extends CrudRepository<Parent, Long> {

    @Query("select " +
           "    c.parent.parentId   as parentId, " +
           "    c.childId as childId" +
           "from Child c inner join a.parent p " +
           "where p.parentId=:id")
    IdAndChildrenIds findIdAndChildrenIdsById(@Param("id") long id);
}

但是这再次无法使用javax.persistence.NonUniqueResultException: result returns more than one elements，因为指定的select给出了一个元组列表：List<{parentId, childId}>，而我想要一个{parentId, List<childId>}的元组。

因此，关于this答案，我在@Value("#{target.parentId}")上添加了Long getParentId();。但这对我的情况没有任何影响。我仍然得到NonUniqueResultException。

然后，我尝试将方法的返回值从IdAndChildrenIds更改为IdAndChildrenIds，以查看错误是否消失，即使该解决方案无济于事。但这也不起作用：

无法编写JSON：找不到类org.springframework.aop.framework.DefaultAdvisorChainFactory的序列化程序，也没有发现用于创建BeanSerializer的属性

正如我所说，字段可见性已经设置为ANY。

---

版本：

-Spring Boot 1.5.9.RELEASE-Spring Boot Starter数据JPA-Spring Boot Starter网站-春季HATEOAS

Answer 1

现在来看，很奇怪，我已经想要知道父ID了，但是我想要父ID和它的子ID。

interface ChildRepo{

  @org.spring...Query(value = "select id from children where parent_id = :parentId", nativeQuery = true)
  List<Long> findIdsByParentId(Long parentId);
}

@lombok.Value
class IdsDto{
  Long parentId;
  List<Long> childrenIds;

}

public IdsDto createTupleThing(Long parentId){
  return new IdsDto(parentId, childRepo.findIdsByParentId(parentId);
}