Pergunta

O que é um objeto de transferência de dados?

Em MVC são as classes de modelo DTO, e se não, quais são as diferenças e que precisamos de ambos?

Foi útil?

Solução

A transferência de dados de objeto é um objeto que é usado para dados de encapsular, e enviá-lo de um subsistema de uma aplicação para outra.

DTO são mais comumente usado pela camada de Serviços em uma aplicação de N-camada para transferência de dados entre si e a camada de interface. A principal vantagem aqui é que ela reduz a quantidade de dados que precisa ser enviado através do fio em aplicações distribuídas. Eles também fazer grandes modelos no padrão MVC.

Outro uso para DTOs pode ser a parâmetros Encapsular para chamadas de método. Isso pode ser útil se um método preciso mais do que 4 ou 5 parâmetros.

Ao usar o padrão DTO, você também faria uso de montadores DTO. As montadoras são usados ??para criar DTOs de objetos de domínio, e vice-versa.

A conversão do objeto de domínio para DTO e de volta pode ser um processo caro. Se você não está criando um aplicativo distribuído, você provavelmente não vai ver qualquer grandes benefícios do padrão, como Martin Fowler explica aqui

Outras dicas

A definição para DTO pode ser encontrada no Martin Fowler local . DTOs são usados ??para transferir parâmetros para métodos e como tipos de retorno. Um monte de pessoas usam aqueles na interface do usuário, mas objetos outros domínio inflar a partir deles.

Um DTO é um objeto muda - ele só possui propriedades e tem getters e setters, mas nenhuma outra lógica de qualquer significado (excepto talvez um comparar () ou igual () implementação)

.

aulas Normalmente modelo em MVC (assumindo .NET MVC aqui) são DTOs, ou coleções / agregados de DTOs

Em geral Valor Objetos deve ser imutável. Como Integer ou string objetos em Java. Podemos usá-los para transferir dados entre camadas de software. Se as camadas de software ou serviços em execução em diferentes nós remotos como em um ambiente microservices ou em um legado Java Enterprise App. Devemos fazer cópias quase exatas de duas classes. Esta é a onde nos encontramos DTOs.

|-----------|                                                   |--------------|
| SERVICE 1 |--> Credentials DTO >--------> Credentials DTO >-- | AUTH SERVICE |
|-----------|                                                   |--------------|

Em legado Java Enterprise Sistemas DTOs pode ter várias coisas EJB nele.

Eu não sei que isso é uma prática recomendada ou não, mas eu pessoalmente uso Valor Objetos em meus Spring MVC Projetos / boot como este:

        |------------|         |------------------|                             |------------|
-> Form |            | -> Form |                  | -> Entity                   |            |
        | Controller |         | Service / Facade |                             | Repository |
<- View |            | <- View |                  | <- Entity / Projection View |            |
        |------------|         |------------------|                             |------------|

Controlador camada não sabe quais são as entidades são. Ele se comunica com Form e Exibição Valor Objetos . Form Objects tem anotações JSR 303 Validação (por exemplo @NotNull) e Exibição Valor Objetos tem Jackson Anotações para serialização personalizada. (Por exemplo @JsonIgnore)

comunica camada

Serviços com camada de repositório através de usar objetos de entidade. objetos de entidade tem anotações JPA / Hibernate / Dados da Primavera sobre ele. Cada camada se comunica apenas com a camada inferior. A comunicação inter-camada é proibida por causa de circular dependência / cíclico.

User Service ----> XX CANNOT CALL XX ----> Order Service

Alguns ORM fortes estruturas têm a capacidade de projecção através de usar interfaces ou classes adicionais. Então repositórios pode retornar Ver objetos diretamente. Lá para você não precisa de uma transformação adicional.

Por exemplo esta é a nossa entidade de usuário:

@Entity
public final class User {
    private String id;
    private String firstname;
    private String lastname;
    private String phone;
    private String fax;
    private String address;
    // Accessors ...
}

Mas você deve retornar uma lista paginada de usuários que apenas incluem id, nome, sobrenome. Em seguida, você pode criar um objeto de exibição Valor para projeção ORM.

public final class UserListItemView {
    private String id;
    private String firstname;
    private String lastname;
    // Accessors ...
}

Você pode facilmente obter o resultado paginado da camada de repositório. Graças a primavera, você também pode usar interfaces apenas para projeções.

List<UserListItemView> find(Pageable pageable);

Não se preocupe para outro método de operações de conversão BeanUtils.copy funciona muito bem.

  1. Para mim, a melhor resposta para a pergunta o que é um DTO é que do DTO são objetos simples que não deve conter qualquer lógica de negócios ou métodos de implementação que faria requerem testes .
  2. Normalmente o seu modelo (usando o padrão MVC) são modelos inteligentes, e eles podem conter um monte de / alguns métodos que fazem algumas operações diferentes para esse modelo especificamente (e não a lógica de negócios, este deve ser para os controladores). No entanto, quando você transferir dados (por exemplo. Chamando um repouso (GET whatever) endpoint / POST / de algum lugar, ou consumir um webservice usando SOA, etc ...) você não quer para transmitir o objeto de grande porte com o código que não é necessário para o endpoint, vai consumir dados, e retardar a transferência.

Com objetos de transferência de dados MVC são muitas vezes utilizados para mapear modelos de domínio para objetos mais simples, que acabará por se apresentadas com a vista.

A partir Wikipedia :

objecto de transfercia de dados (DTO), anteriormente conhecida como objectos de valor ou VO, é um padrão de design usado para transferir dados entre a aplicação software subsistemas. DTOs são muitas vezes utilizados em conjunto com acesso a dados objetos para recuperar dados de um banco de dados.

Licenciado em: CC-BY-SA com atribuição
Não afiliado a StackOverflow
scroll top