स्प्रिंग डेटा REST के साथ कस्टम डीटीओ क्रूड रिपोजिटरी का खुलासा कैसे करें?

Question

मैं अपने मॉडल वर्गों (जेपीए इकाइयों) को अलग-अलग डेटा ट्रांसपोर्ट ऑब्जेक्ट्स (डीटीओ) के साथ अपने विशेषताओं के अलग-अलग सबसेट का खुलासा नहीं करना चाहता हूं। विचार DTO CrudRepository <-> JpaRepository <-> entities है, और मैं DTO CrudRepository पर स्प्रिंग डेटा REST के माध्यम से खुलासा करना चाहता हूं।

उदाहरण:

निकाय:

@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> { 
} 

डीटीओ:

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; 
    } 

} 

डीटीओ CrudRepository:

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

कार्यान्वयन:

@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 

} 

इस उदाहरण मैं वसंत डेटा बाकी के साथ GroupDtoDao बेनकाब करने के लिए चाहते हैं।

अन्य बीन्स में मैं समूहडाओ और ग्रुपडाटोडाओ दोनों को स्वत: कर सकता हूं, इसलिए दोनों वसंत के संदर्भ में प्रबंधित होते हैं। अगर मैं GroupDao को @RepositoryRestResource(exported = false) के साथ एनोटेट नहीं करता हूं तो जेपीए रिपोजिटरी को आरईएसटी सेवा के रूप में उजागर किया जाता है, इसलिए मुझे लगता है कि स्प्रिंग डेटा आरईएसटी अच्छी तरह से कॉन्फ़िगर किया गया है।

मैं अपने कस्टम क्रूड रिपोजिटरी का पर्दाफाश करने के लिए कैसे कह सकता हूं?

Answer 1

यह सुनिश्चित करने के लिए a JIRA issue है।

अभी के लिए, एसडीआर टीम का कहना है, "हम आमतौर पर कस्टम सीरियलाइज़र में हुक करने के लिए जैक्सन मिश्रणों का उपयोग करने की सलाह देते हैं, उत्पादन को अनुकूलित करते हैं। उदाहरण के लिए Spring RESTBucks देखें।"