Estou tendo dificuldades para entender o Padrão de Repositório.

Existem muitas opiniões sobre esse tópico, como emPadrão de repositório feito corretamente mas também outras coisas comoRepositório é o novo Singleton ou novamente como emNão use DAO use Repository ou apenas pegueDados JPA do Spring + Hibernate + MySQL + MAVEN onde, de alguma forma, um Repositório parece ser o mesmo que um objeto DAO.

Estou cansado de ler essas coisas, pois, no caso, isso não pode ser uma coisa tão difícil quanto é exibida em muitos artigos.

Eu vejo assim: Parece que o que eu quero é algo assim:

         ------------------------------------------------------------------------
         |                            Server                                    |
         ------------------------------------------------------------------------
         |                    |                        |                        |
Client <-|-> Service Layer  <-|->  Repository Layer  <-|-> ORM / Database Layer |
         |                    |                        |                        |  
         ------------------------------------------------------------------------

oService Layer leva*DTOobjetos e os passa para oRepository Layer que basicamente nada mais é do que "o cara" que sabequão uma entidade pode ser armazenada.

Por exemplo, suponha que você tenha uma composição de algumas ferramentas (por favor note que este é apenas pseudo-código)

@Entity
class ToolSet {
  @Id
  public Long id;
  @OneToOne
  public Tool tool1;
  @OneToOne
  public Tool tool2;
}

@Entity
class Tool {
  @Id
  public Long id;
  @OneToMany
  public ToolDescription toolDescription;
}

@Entity
class ToolDescription {
  @Id
  public Long id;
  @NotNull
  @OneToOne
  public Language language

  public String name;
  public String details;
}

O que não estou conseguindo é a parte em que estou conseguindo umToolSetDTO objeto do cliente.

Pelo que entendi até agora, eu poderia escrever umToolSetRepository com um métodoToolSetRepository.save(ToolSetDTO toolSetDto) que "sabe guardar" umaToolSetDTO. Mas quase todo tutorial não passa no*DTO mas oEntity em vez de.

O que está me incomodando aqui é que, se você pegar minhaToolSet exemplo acima, eu teria que executar as seguintes etapas:

TomatoolSetDto e verifique se nãonullPara cadatool*Dto possuído portoolSetDto
a) Se tiver um ID válido, convertaDTO paraEntity caso contrário, crie uma nova entrada de banco de dados
b)toolDescriptionDto e converta / salve-o no banco de dados ou crie uma nova entradaDepois de verificar aqueles acima instanciarToolSet (entidade) e configure-o para persistir no banco de dados

Tudo isso é muito complexo para simplesmente deixar a função de serviço (interface para o cliente) lidar com isso.

O que eu estava pensando era criar, por exemplo, umaToolSetRepository mas a questão aqui é

É preciso umToolSet objeto de entidade ou usa umDTO objeto?De qualquer forma: é o*Repository permitidousar outros objetos de repositório? Como quando eu quero salvarToolSet mas eu tenho que guardarTool eToolDescription primeiro - eu usariaToolRepository eToolDescriptionRepository dentroToolSetRepository?
Se sim: Por que não quebra o Padrão do Repositório? Se esse padrão é basicamente uma camada entre o serviço e minha estrutura ORM, simplesmente "não parece certo" adicionar dependências a outras*Repository classes devido a razões de dependência.

Não sei por que não consigo entender isso. Não soaeste complicado, mas ainda há ajuda lá fora, comoSpring Data. Outra coisa que está me incomodando, porque eu realmente não vejo como isso fazqualquer coisa Mais fácil. Especialmente porque eu já estou usando o Hibernate - não vejo o benefício (mas talvez essa seja outra pergunta).

Então .. eu sei que essa é uma pergunta longa, mas eu já coloquei alguns dias de pesquisa nela. Já existe um código no qual estou trabalhando, que começa a se tornar uma bagunça, porque simplesmente não consigo ver esse padrão.

Espero que alguém possa me dar uma imagem maior do que a maioria dos artigos e tutoriais que não vão além da implementação de um exemplo muito, muito simples de Padrão de Repositório.