Jak odsłonić niestandardowe repozytorium crud z repozytorium danych Spring REST?

Question

Nie chcę ujawniać moich klas modeli (jednostek jpa), a raczej różnych podzbiorów ich atrybutów za pomocą różnych obiektów transportu danych (DTO). Pomysł to DTO CrudRepository <-> JpaRepository <-> entities, a ja chcę udostępnić poprzez Spring Data REST DTO CrudRepository.

przykład:

jednostki:

@Entity 
@Table(name = "groups") 
public class Group { 

    private Long id; 
    private String name; 
    private Set<User> users; 
    // other attributes 

    @Id 
    @GeneratedValue 
    @Column(name = "group_id") 
    public Long getId() { 
     return id; 
    } 

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

    @Column(name = "name", nullable = false) 
    public String getName() { 
     return name; 
    } 

    public void setName(String name) { 
     this.name = name; 
    } 

    @OneToMany(mappedBy = "group") 
    public Set<User> getUsers() { 
     return users; 
    } 

    public void setUsers(Set<User> users) { 
     this.users = users; 
    } 

    // other getters and setters 

} 

JpaRepository:

@RepositoryRestResource(exported = false) 
public interface GroupDao extends JpaRepository<Group, Long> { 
} 

DTO:

public class GroupWithoutRelationsDto { 

    private Long id; 
    private String name; 

    public Long getId() { 
     return id; 
    } 

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

    @NotBlank 
    public String getName() { 
     return name; 
    } 

    public void setName(String name) { 
     this.name = name; 
    } 

} 

DTO CrudRepository:

public interface GroupDtoDao extends CrudRepository<GroupWithoutRelationsDto, Long> { 
} 

Realizacja:

@Repository 
public class GroupDtoDaoImpl extends GenericDtoDao<GroupWithoutRelationsDto, Group, Long> implements GroupDtoDao { 

    @Autowired 
    private GroupDao groupDao; 

    @Override 
    protected CrudRepository<Group, Long> getModelDao() { 
     return groupDao; 
    } 

    @Override 
    protected <S extends GroupWithoutRelationsDto> Long getDtoId(S dto) { 
     return dto.getId(); 
    } 

    @Override 
    protected Long getModelId(Group model) { 
     return model.getId(); 
    } 

    @Override 
    protected <S extends GroupWithoutRelationsDto> S modelToDto(Group model, S dto) { 
     dto.setId(model.getId()); 
     dto.setName(model.getName()); 
     return dto; 
    } 

    @Override 
    protected <S extends GroupWithoutRelationsDto> Group dtoToModel(S dto, Group model) { 
     model.setId(dto.getId()); 
     model.setName(dto.getName()); 
     return model; 
    } 

    @Override 
    protected Group newModel() { 
     return new Group(); 
    } 

    @Override 
    protected GroupWithoutRelationsDto newDto() { 
     return new GroupWithoutRelationsDto(); 
    } 

} 

GenericDtoDao:

@NoRepositoryBean 
public abstract class GenericDtoDao<D, M, ID extends Serializable> implements CrudRepository<D, ID> { 

    protected abstract CrudRepository<M, ID> getModelDao(); 

    protected abstract <S extends D> ID getDtoId(S dto); 

    protected abstract ID getModelId(M model); 

    protected abstract <S extends D> S modelToDto(M model, S dto); 

    protected abstract <S extends D> M dtoToModel(S dto, M model); 

    protected abstract M newModel(); 

    protected abstract D newDto(); 

    @Override 
    public D findOne(ID id) { 
     return modelToDto(getModelDao().findOne(id), newDto()); 
    } 

    @Override 
    public <S extends D> S save(S entity) { 
     Assert.notNull(entity, "The entity must not be null!"); 
     if (getDtoId(entity) == null) { 
      return create(entity); 
     } 
     return update(entity); 
    } 

    protected <S extends D> S create(S entity) { 
     Assert.notNull(entity, "The entity must not be null!"); 
     if (getDtoId(entity) != null) { 
      Assert.isTrue(!exists(getDtoId(entity)), "The entity ID must be null or not exist!"); 
     } 
     return modelToDto(getModelDao().save(dtoToModel(entity, newModel())), entity); 
    } 

    protected <S extends D> S update(S entity) { 
     Assert.notNull(entity, "The entity must not be null!"); 
     M model = getModelDao().findOne(getDtoId(entity)); 
     Assert.notNull(model, "The entity must exist!"); 
     return modelToDto(getModelDao().save(dtoToModel(entity, model)), entity); 
    } 

    // other CrudRepository methods 

} 

W tym przykładzie chcę narażać GroupDtoDao danych z wiosennej resztę.

W innych komponentach mogę autowirować zarówno GroupDao, jak i GroupDtoDao, więc obie są zarządzane przez kontekst Springa. Jeśli nie dodaję adnotacji GroupDao z @RepositoryRestResource(exported = false), JpaRepository zostanie ujawniony jako usługa REST, więc przypuszczam, że REST danych sprężystych jest dobrze skonfigurowany.

Jak mogę powiedzieć, aby odsłonić mój własny CrudRepository?

Answer 1

Istnieje a JIRA issue, aby wyjaśnić, jak to zrobić.

Na razie zespół SDR mówi: "Zasadniczo zalecamy używanie tylko miksów Jacksona do przechwytywania niestandardowych serializerów, dostosowywania wyników itd. Zobacz przykład na temat Spring RESTBucks".