Desenvolvendo aplicativos da Web ASP.NET Core MVC

Duração do treinamento: 5 dias - 40 horas

O grupo é formado assim que as inscrições são recebidas.

Objetivo do curso - Fornecer aos alunos o conhecimento e as habilidades necessárias para desenvolver aplicativos ASP.NET Core MVC usando o .NET Core. O foco principal é melhorar o desempenho do código, o que aumenta o desempenho de um aplicativo da web.

A audiência

Este curso é destinado a desenvolvedores web profissionais que usam o Microsoft Visual Studio interessados \u200b\u200bem desenvolver aplicativos web avançados e que desejam usar HTML de uma maneira complexa e criar sites com uma diferenciação de módulos de interface de usuário, acesso a dados e lógica de aplicativo.

• Descreva a pilha de tecnologia da Web da Microsoft e selecione a tecnologia apropriada ao desenvolver aplicativos;
• Projetar a arquitetura e implementar aplicativos da web que atenderão a um conjunto de requisitos funcionais, requisitos de interface de usuário e modelo de negócios;
• Criar modelos MVC e escrever código que implemente a lógica de negócios no método, propriedade e modelo de evento;
• Configure o pipeline para aplicativos da Web ASP.NET Core usando Middleware e use injeção de dependência em um aplicativo MVC.
• Adicione controladores ao seu aplicativo MVC para controlar a interação do usuário, atualizar modelos, selecionar e recuperar visualizações;
• Desenvolva um aplicativo da Web que use o mecanismo de roteamento ASP.NET Core para apresentar URLs amigáveis \u200b\u200be uma hierarquia de navegação lógica aos usuários.
• Crie visualizações em um aplicativo MVC para exibir e editar dados e interagir com modelos e controladores;
• Crie modelos MVC e escreva código de lógica de negócios nos métodos, propriedades e eventos do modelo.
• Conecte um aplicativo ASP.NET Core a um banco de dados usando o Entity Framework Core.
• Gere código JavaScript do lado do cliente que usa a biblioteca de scripts jQuery para otimizar a capacidade de resposta de um aplicativo da web MVC.
• Adicione pacotes de clientes e configure os executores de tarefas.
• Execute testes de unidade e depure um aplicativo da web no Visual Studio 2017.
• Desenvolva um aplicativo MVC que autentica e autoriza usuários usando Identity.
• Crie um aplicativo MVC que resista a ataques.
• Use o cache para acelerar as respostas às solicitações do usuário.
• Use SignalR para fornecer comunicação bidirecional entre cliente e servidor.
• Descreva o que é uma API da web e por que os desenvolvedores podem adicionar uma API da web a um aplicativo.
• Construir e implantar aplicativos da Web ASP.NET Core MVC de uma máquina de desenvolvimento para um servidor da Web.

Exames de certificação

• 70-486 Próximo: Desenvolvendo Aplicativos da Web ASP.NET MVC

Preparação necessária

• Experiência com Visual Studio 2017.
• Experiência com programação C # e tal conhecimento de expressões lambda, LINQ e tipos anônimos.
• Experiência no uso do .NET Framework.
• Experiência com HTML, CSS e JavaScript.
• Experiência em consultar e manipular dados com ADO.NET.
• Conhecimento de XML e JSON.

Materiais do ouvinte

Os trainees recebem um guia de estudo proprietário e outros materiais necessários para o treinamento.

Módulo 1: Visão geral do ASP.NET Core MVC

Este módulo apresenta a tecnologia de aplicativo da Web ASP.NET Core MVC, que é uma estrutura de plataforma cruzada de código aberto que oferece suporte a um ciclo de desenvolvimento ágil e orientado a testes e aproveita os padrões HTML mais recentes e estruturas de Front-End como Angular, React e outras.

Tópicos

• Visão geral das tecnologias da Web da Microsoft
• Visão geral do ASP.NET 4.x
• Apresentando ASP.NET Core MVC

Laboratório: Visão geral do ASP.NET Core MVC

• Explorando o aplicativo Razor Pages
• Explorando aplicativos de API da Web
• Explorando um aplicativo MVC

• Descreva a pilha de tecnologia da Web da Microsoft;
• Descrever modelos diferentes programação disponível para desenvolvedores em ASP.NET;
• Escolha entre ASP.NET Core e ASP.NET 4.x;
• Descreva a função do ASP.NET Core MVC na pilha de tecnologia da web e use o ASP.NET Core MVC para construir aplicativos da web.
• Distinguir modelos MVC, controladores MVC e visualizações MVC.

Módulo 2: Projetando aplicativos da Web ASP.NET Core MVC

Este módulo descreve como definir um conjunto de requisitos de negócios e planejar um aplicativo da web Model-View-Controller (MVC).

Tópicos

• Planejamento na fase de desenvolvimento do projeto
• Projetando modelos, controladores e visualizações

Laboratório: Projetando aplicativos da Web ASP.NET Core MVC

• Aulas de modelo de planejamento
• Controladores de planejamento
• Agendamento de visualizações
• Projetando uma arquitetura de aplicativo MVC

Depois de concluir este módulo, os alunos serão capazes de:

• Planeje uma arquitetura de aplicativo da web ASP.NET Core MVC com o gerenciamento de estado do aplicativo em mente
• Planeje modelos, controladores e visualizações de acordo com um conjunto de requisitos funcionais.

Módulo 3: Configurando um intermediário programas (Middleware) e serviços em ASP.NET Core

Este módulo mostra como usar o ASP.NET Core para lidar com solicitações e respostas por meio de middleware existente e personalizado e como configurar serviços para uso em middleware e todas as outras partes de seu aplicativo, como controladores. Aqui, os serviços são classes que fornecem funcionalidade que pode ser usada posteriormente em diferentes partes do aplicativo. Essa abordagem é baseada na injeção de dependência.

Tópicos

• Configurando Middlewares
• Configurando serviços

Laboratório: Configurando Middleware e Serviços no ASP.NET Core

• Trabalhar com arquivos estáticos
• Criando seu próprio middleware
• Usando injeção de dependência
• Injetando um serviço em um controlador

Depois de concluir este módulo, os alunos serão capazes de:

• Use o middleware existente para personalizar seu aplicativo ASP.NET Core.
• Crie seu próprio middleware e use-o para definir o comportamento personalizado.
• Compreenda os princípios básicos por trás da injeção de dependência e como eles são usados \u200b\u200bno ASP.NET Core.
• Crie um serviço personalizado, configure seu escopo e injete-o no middleware e nos controladores ASP.NET Core MVC.

Módulo 4: Desenvolvendo controladores

Este módulo explora o uso de controladores, que são responsáveis \u200b\u200bpor processar uma solicitação da web interagindo com o modelo e, em seguida, passando os resultados para a visualização.

Tópicos

• Escrevendo controladores e ações
• Configurando rotas
• Escrevendo Filtros de Ação

Laboratório: Desenvolvendo controladores

• Adicionando controladores e ações a um aplicativo MVC
• Configurando Rotas Usando a Tabela de Roteamento
• Configurando Rotas Usando Atributos
• Adicionando um filtro de ação

Depois de concluir este módulo, os alunos serão capazes de:

• Adicione um controlador a um aplicativo da web que responde às ações do usuário especificadas no projeto.
• Adicione rotas ao mecanismo de roteamento ASP.NET Core usando URLs amigáveis \u200b\u200bem um aplicativo web MVC.
• Escreva código em filtros de ação que são executados antes ou depois de uma ação do controlador.

Módulo 5. Projetando vistas

Este módulo descreve a função das visualizações em um aplicativo da web MVC, bem como sua criação e programação. Uma exibição é uma combinação de marcação HTML e código C # executado em um servidor da web. Este módulo também explora a criação de visualizações parciais e componentes de visualização que renderizam fragmentos de HTML para reutilização em um aplicativo da web.

• Criando visualizações com a sintaxe do Razor
• Usando HTML Helpers e Tag Helpers
• Reutilizar código de visualização

Laboratório: desenvolvendo visualizações

• Adicionando vistas a um aplicativo MVC
• Adicionando uma vista parcial
• Adicionando um componente de visualização

Depois de concluir este módulo, os alunos serão capazes de:

• Crie uma visualização MVC com marcação Razor para exibir dados aos usuários.
• Use os Helpers HTML e Tag Helpers em uma visualização.
• Reutilize a marcação do Razor em vários lugares em seu aplicativo.

Módulo 6: Desenvolvimento de modelos

Este módulo o orienta na criação de modelos em um aplicativo MVC que definem a lógica de negócios e representam as classes para cada tipo de objeto.

Tópicos

• Criação de modelos MVC
• Trabalhando com formulários
• Validando um aplicativo MVC

Laboratório: Desenvolvendo Modelos

• Adicionando um modelo
• Trabalhar com formulários (formulários)
• Adicionando Validação

Depois de concluir este módulo, os alunos serão capazes de:

• Adicione um modelo ao seu aplicativo MVC e escreva o código para implementar a lógica de negócios.
• Use a exibição e edição de anotações de dados.
• Valide a entrada do usuário usando anotações de dados.

Módulo 7: Usando o Entity Framework Core no ASP.NET Core

Este módulo descreve como criar um modelo de acesso a dados e lógica de negócios, separando a lógica de negócios da lógica de acesso a dados usando um repositório. Ao escrever um aplicativo ASP.NET, você pode usar as tecnologias Entity Framework Core (EF Core) e Language Integrated Query (LINQ) para tornar seu código de acesso a dados rápido de escrever e fácil de entender. Este módulo mostra como criar um site baseado em banco de dados em MVC.

Tópicos

• Introdução ao Entity Framework Core
• Trabalhando com Entity Framework Core

Laboratório: Usando o Entity Framework Core no ASP.NET Core

• Adicionando Entity Framework Core
• Usando Entity Framework Core para recuperar e armazenar dados
• Usando o Entity Framework Core para se conectar ao Microsoft SQL Server

Depois de concluir este módulo, os alunos serão capazes de:

• Conecte o aplicativo a um banco de dados para acessar e armazenar dados.
• Explique como funciona o EF Core.
• Trabalhe com o Entity Framework Core.
• Use EF Core para se conectar ao seu banco de dados, incluindo o Microsoft SQL Server.

Módulo 8: Usando modelo de layout, CSS e JavaScript em um aplicativo da Web ASP.NET Core

Este módulo descreve a capacidade de abordar um aplicativo MVC junto e compartilhar componentes comuns entre todas as visualizações, como cabeçalhos e rodapés. Além de descrever modelos e folhas de estilo CSS em cascata, este módulo cobre a criação de elementos HTML interativos usando JavaScript e usando a biblioteca jQuery.

Tópicos

• Usando o modelo de layout.
• Aplicando CSS e JavaScript.
• Usando jQuery.

Laboratório: Usando o modelo de layout, CSS e JavaScript em um aplicativo da Web ASP.NET Core

• Aplicação de layout a visualizações em um aplicativo.
• Usando CSS
• Usando JavaScript
• Usando jQuery.

Depois de concluir este módulo, os alunos serão capazes de:

• Implemente uma aparência consistente para aplicativos ASP.NET Core MVC.
• Adicione o código JavaScript a um aplicativo da web.
• Use a biblioteca jQuery no aplicativo da web.

Módulo 9: Desenvolvimento do lado do cliente

Este módulo descreve o uso do Bootstrap para estilizar um aplicativo da web, pré-processadores CSS Sass e Less, e configurar o Grunt e gulp e usá-los para compilar arquivos Sass em tempo de construção para o Microsoft Visual Studio.

Tópicos

• Aplicando Estilos
• Usando executores de tarefas
• Design adaptativo

Laboratório: Desenvolvimento do lado do cliente

• Usando gulp para executar tarefas
• Estilo com Sass
• Usando Bootstrap

Depois de concluir este módulo, os alunos serão capazes de:

• Use manipuladores de tarefas em um aplicativo ASP.NET Core.
• Projete um aplicativo da web que seja exibido corretamente em dispositivos com diferentes tamanhos de tela.

Módulo 10: Teste e solução de problemas

Este módulo descreve como melhorar a estabilidade e a qualidade de seu aplicativo, encontrando e corrigindo erros de código, travamentos e outros resultados inesperados. Os aplicativos MVC são adequados para testes de unidade, e esses testes garantem um código de alta qualidade testando sistematicamente a funcionalidade de cada pequeno componente. Além disso, este módulo discute as ferramentas de depuração e tratamento de exceções disponíveis no Visual Studio.

Tópicos

• Testando aplicativos MVC.
• Implementando uma estratégia de tratamento de exceções.
• Registrando aplicativos MVC.

Laboratório: Teste e solução de problemas

• Modelos de teste
• Testando controladores usando um repositório falso
• Implementação de repositório no projeto MVC
• Adicionando Tratamento de Exceções
• Adicionando registro.

Laboratório: Gerenciamento de segurança

• Usando identidade.
• Adicionando autorização.
• Evitando falsificação de solicitação entre sites.

Depois de concluir este módulo, os alunos serão capazes de:

• Adicionando autenticação básica ao aplicativo.
• Configurando a identidade do Microsoft ASP.NET Core.
• Adicione autorização básica ao aplicativo.
• Use várias abordagens diferentes para autorização.
• Saiba como funcionam as vulnerabilidades de segurança e como melhor se defender contra elas.

Módulo 12: Desempenho e comunicação

O objetivo deste módulo é mostrar como usar o cache para persistir solicitações repetitivas sem ter que reexecutar a mesma lógica. Este módulo também discute SignalR, uma estrutura que permite abstrair vários protocolos de comunicação diferentes em uma API fácil de usar para simplificar a comunicação bidirecional.

Este módulo descreve o conceito de uma API da web, bem como estende a funcionalidade básica do aplicativo para integração em outros aplicativos da web e móveis. Este módulo explora os novos recursos da API da Web MVC e como criar uma API da Web RESTful e chamá-la de outros aplicativos.

Tópicos

• Hospedagem e implantação local
• Implantar no Microsoft Azure
• Noções básicas do Microsoft Azure

Desenvolvendo aplicativos da Web ASP.NET Core MVC

O curso é lido de acordo com a última versão!

No curso, você aprenderá a criar aplicativos da web usando ASP.NET CORE MVC do .NET Framework. Você ganhará conhecimento e habilidades que permitirão aumentar significativamente o desempenho e a escalabilidade de seus aplicativos da web. No decorrer da lição, você comparará as tecnologias ASP.NET CORE MVC e ASP.NET Web Forms e obterá recomendações para escolher uma ou outra tecnologia.

O curso é calculado para desenvolvedores profissionais da Web com experiência na criação de aplicativos usando o Visual Studio.

Para treinamento em este curso Você precisa de um válido acesso à contaMicrosoft Azure. Observe que pode levar até 48 horas para obter um novo acesso. Se você não tiver acesso, informe seu gerente sobre isso ao se registrar para o treinamento. Nesse caso, forneceremos a você uma versão de avaliação: Windows Azure Pass de 30 dias.

Precisa de mais pratica? Está se preparando para os exames da Certificação Microsoft? Adquirir acesso a Labs Online - laboratórios virtuais em cursos autorizados pela Microsoft - durante todo o curso e duas semanas após a formatura! O serviço é único e disponível apenas no Centro "Especialista"

Perfil de público:

• O curso é destinado a desenvolvedores profissionais da Web que usam o Microsoft Visual Studio individualmente ou em equipe, em grandes ou pequenas organizações.

Pré-requisitos:

• 2-3 anos de experiência no desenvolvimento de aplicações web usando Microsoft Visual Studio e Microsoft ASP.NET;
• experiência prática com o .NET Framework;
• conhecimento básico da linguagem de programação C #.

Após a conclusão do curso, os alunos serão capazes de:

• descreva as tecnologias da Web da Microsoft e escolha a ferramenta certa para a tarefa em questão;
• projetar a arquitetura e implementação de um aplicativo da web que irá satisfazer um conjunto de requisitos funcionais, requisitos de interface do usuário e estar em conformidade com um modelo de negócios;
• criar um modelo MVC e escrever código que implemente a lógica de negócios do aplicativo e trabalhar com dados;
• adicionar controladores a aplicativos MVC para gerenciar a interação do usuário, atualizações de modelo e fornecer interação com visualizações;
• criar Visualizações MVC que permitem exibir e editar dados e interagir com Modelos e Controladores;
• execute testes de unidade e ferramentas de depuração para aplicativos da web no Visual Studio 2012 e configure aplicativos para solução de problemas.
• desenvolver aplicativos da Web que usam roteamento ASP.NET para fornecer URLs amigáveis \u200b\u200be navegação lógica para os usuários;
• fornecer um acordo aparência páginas do site, incluindo marca corporativa, em todo o aplicativo da web MVC;
• use atualização parcial da página e armazenamento em cache para reduzir a carga da rede, gerado pelo aplicativo, e reduzir o tempo de resposta às ações do usuário;
• escreva o código JavaScript que é executado no lado do cliente e usa a biblioteca de scripts jQuery para otimizar a experiência do usuário de aplicativos da web MVC;
• crie aplicativos MVC resistentes a ataques maliciosos e armazene informações sobre as preferências do usuário;
• entender como escrever um serviço da Web do Windows Azure e acessá-lo de um aplicativo MVC;
• descreva o que é a API da Web e por que os desenvolvedores podem adicioná-la a um aplicativo;
• alterar o modo de processamento de solicitações do navegador pelo aplicativo MVC;
• descrever como empacotar e implantar um aplicativo da web ASP.NET MVC 5 de um computador de desenvolvimento para um servidor da web;

• desenvolvimento de aplicações web utilizando ASP.NET MVC 5;
• desenvolvimento de modelos ASP.NET MVC 5;
• desenvolvimento de controladores ASP.NET MVC 5;
• desenvolvendo ASP.NET MVC 5 Views;
• como testar e depurar aplicativos da web ASP.NET MVC 5;
• estruturação de aplicações web ASP.NET MVC 5;
• a peculiaridade de aplicar estilos a aplicativos da Web ASP.NET MVC 5;
• mecanismo para construir páginas responsivas na ASP.NET MVC 5;
• a peculiaridade de usar JavaScript e jQuery para construir aplicativos web responsivos MVC 5;
• princípios de controle de acesso a aplicações web ASP.NET MVC 5;
• como construir aplicativos da Web ASP.NET MVC 5 robustos
• implementando APIs da Web em aplicativos da Web ASP.NET MVC 5
• manipulação de solicitações em aplicativos da web ASP.NET MVC 5;
• princípios de implantação de aplicativos da web ASP.NET MVC 5.

O conceito de MVC (Model-View-Controller: Model-View-Controller) tem sido mencionado com frequência no mundo da programação web nos últimos anos. Todo mundo que está de alguma forma conectado com o desenvolvimento de aplicativos da web já se deparou com essa sigla de uma forma ou de outra. Hoje vamos entender o que é o conceito MVC e por que se tornou popular.

A história mais antiga

MVC não é um modelo de projeto, é um modelo de construção que descreve como construímos a estrutura da nossa aplicação, as áreas de responsabilidade e a interação de cada uma das partes nesta estrutura.

Foi descrito pela primeira vez em 1979, é claro, para um ambiente diferente. O conceito de aplicativo da web ainda não existia. Tim Berners Lee plantou as sementes da World Wide Web (WWW) no início dos anos 90 e mudou o mundo para sempre. O modelo que usamos hoje é uma adaptação do modelo original para desenvolvimento web.

A enorme popularidade dessa estrutura em aplicações web se deve a sua inclusão em dois ambientes de desenvolvimento que se tornaram muito populares: Struts e Ruby on Rails. Esses dois ambientes de desenvolvimento mapearam os caminhos de desenvolvimento para as centenas de ambientes de trabalho criados posteriormente.

MVC para aplicativos da web

A ideia por trás do padrão de design MVC é muito simples: precisamos separar claramente as responsabilidades para os diferentes funcionamentos em nossos aplicativos:

O aplicativo está dividido em três componentes principais, cada um deles responsável por diferentes tarefas. Vamos dar uma olhada nos componentes usando um exemplo.

Controlador

Controlador gerencia as solicitações do usuário (recebidas como solicitações HTTP GET ou POST quando o usuário clica nos elementos da interface para realizar várias ações). Sua função principal é invocar e coordenar a ação dos recursos e objetos necessários para executar ações definidas pelo usuário. Normalmente, o controlador chama o modelo apropriado para a tarefa e seleciona a visualização apropriada.

Modelo

Modelo são dados e regras usados \u200b\u200bpara trabalhar com dados, que representam o conceito de controle de aplicativos. Em qualquer aplicação, toda a estrutura é modelada como dados, que são processados \u200b\u200bde uma determinada maneira. O usuário de um aplicativo é uma mensagem ou um livro? Apenas dados que devem ser processados \u200b\u200bde acordo com as regras (a data não pode indicar o futuro, o e-mail deve estar em um determinado formato, o nome não pode ter mais de X caracteres e assim por diante).

O modelo dá ao controlador uma visão dos dados que o usuário solicitou (mensagem, página do livro, álbum de fotos e similares). O modelo de dados será o mesmo, independentemente de como queremos apresentá-lo ao usuário. Portanto, escolhemos qualquer visualização disponível para a exibição de dados.

O modelo contém a parte mais importante da lógica de nossa aplicação, a lógica que resolve o problema com o qual estamos lidando (fórum, loja, banco, etc.). O controlador contém principalmente a lógica organizacional para o próprio aplicativo (muito semelhante à manutenção).

Visão

Visão fornece várias maneiras de representar dados derivados de um modelo. Pode ser um modelo preenchido com dados. Pode haver vários tipos diferentes e o controlador escolhe o que melhor se adapta à situação atual.

Um aplicativo da web geralmente consiste em uma coleção de controladores, modelos e visualizações. O controlador pode ser configurado como controlador principal, que recebe todas as solicitações e chama outros controladores para realizar ações dependendo da situação.

Vejamos um exemplo

Digamos que precisamos desenvolver uma livraria online. O usuário pode fazer o seguinte: visualizar livros, registrar, comprar, adicionar itens ao pedido atual, criar ou excluir livros (se ele for um administrador). Vamos ver o que acontece quando o usuário clica em uma categoria. fantasia para ver os títulos dos livros que estão disponíveis em nossa loja.

Temos um controlador específico para lidar com todas as ações relacionadas ao livro (visualizar, editar, criar e assim por diante). Vamos chamá-lo books_controller.php em nosso exemplo. Também precisamos de um modelo, por exemplo book_model.phpque processa dados e lógica associados a uma posição de loja. Por fim, precisamos de várias visualizações para representar os dados, como uma lista de livros, uma página de edição e assim por diante.

A figura a seguir mostra como a solicitação de um usuário para visualizar uma lista de livros por tópico é tratada. fantasia:

O controlador (books_controller.php) recebe a solicitação do usuário (solicitação HTTP GET ou POST). Podemos organizar um controlador central como index.php que recebe a solicitação e chama books_controller.php.

O controlador verifica a solicitação e os parâmetros e, em seguida, chama o modelo (book_model.php), solicitando ela tem uma lista de livros disponíveis sobre o assunto fantasia .

O modelo obtém dados de um banco de dados (ou de outra fonte que armazena informações), aplica filtros e a lógica necessária e retorna dados que representam uma lista de livros.

O controlador usa uma visualização adequada para apresentar os dados ao usuário. Se o pedido vier com celular, a visualização do telefone móvel é usada; se o usuário usar um determinado design de interface, a visualização apropriada será selecionada e assim por diante.

Quais são os benefícios?

O benefício mais óbvio que obtemos com o uso do conceito MVC é a separação clara da lógica de apresentação (interface do usuário) e da lógica do aplicativo.

O suporte a diferentes tipos de usuários que usam diferentes tipos de dispositivos é um problema comum atualmente. A interface fornecida deve ser diferente se a solicitação vier de um computador pessoal ou de um telefone celular. O modelo retorna os mesmos dados, a única diferença é que o controlador escolhe diferentes visualizações para produzir os dados.

Além de isolar as visualizações da lógica do aplicativo, o conceito de MVC reduz significativamente a complexidade de grandes aplicativos. O código é muito mais estruturado e, portanto, mais fácil de manter, testar e reutilizar soluções.

Por que usar um ambiente de trabalho?

Quando você usa o tempo de execução, a estrutura MVC básica já está configurada e tudo o que você precisa fazer é estender a estrutura colocando seus arquivos nos diretórios apropriados para corresponder ao padrão MVC. Além disso, você terá um conjunto de funções já escritas e bem testadas.

Vamos pegar o cakePHP como um exemplo de workbench MVC. Após a instalação, você terá três diretórios principais:

• bolo /
• vendedores /

Pasta aplicativo é a localização de seus arquivos. Este é o lugar para desenvolver sua parte do aplicativo.

Na pasta bolo hospeda arquivos cakePHP (funcionalidade de desktop).

Pasta vendedores serve para armazenar bibliotecas PHP de terceiros.

Seu espaço de trabalho (diretório do aplicativo) tem a seguinte estrutura:

• aplicativo /
  • config /
  • controladores /
  • locale /
  • modelos /
  • plugins /
  • testes /
  • vendedores /
  • visualizações /
  • webroot /

Você precisa colocar seus controladores no diretório controladores, modelos no diretório modelos e visualizações no diretório visualizações!

Depois de começar a usar o ambiente de trabalho, fica imediatamente claro onde está localizada praticamente qualquer parte do seu aplicativo que precise ser criada ou modificada. Essa organização em si simplifica muito o processo de desenvolvimento e manutenção de um aplicativo.

Usando o ambiente de trabalho para nosso exemplo

Uma vez que este tutorial não pretende mostrar o processo de criação de um aplicativo usando cakePHP, mostraremos apenas o código para o modelo, controlador e visualização, com comentários sobre os benefícios de usar o framework MVC. O código é especialmente simplificado e não adequado para uso em um aplicativo real.

Lembre-se de que estávamos em uma livraria e um usuário curioso queria ver uma lista completa de livros sobre o assunto. fantasia... O controlador recebeu a solicitação do usuário e coordenou as ações necessárias.

Portanto, assim que o usuário clica no botão, o navegador solicita o url fornecido:

Www.ourstore.com/books/list/fantasy

CakePHP formata URLs com um modelo / controlador / ação / param1 / param2 Onde açao é uma função chamada pelo controlador. Na forma clássica antiga, o url terá a seguinte aparência:

Www.ourstore.com/books_controller.php?action\u003dlist&category\u003dfantasy

Controlador

No ambiente de produção cakePHP, nosso controlador terá a seguinte aparência:

classe BooksController estende AppController (

Lista de funções ($ categoria) (

$ this-\u003e set ("books", $ this-\u003e Book-\u003e findAllByCategory ($ category));

Função add () (... ...)

Função delete () (... ...)

... ... } ?>

Simples, certo? Este controlador será salvo como books_controller.php e postado em / app / controllers... Ele contém uma lista de funções que executam as ações para nosso exemplo, bem como outras funções para executar operações relacionadas ao livro (adicionar um novo livro, excluir um livro e assim por diante).

O ambiente de trabalho nos fornece muitas soluções prontas e precisamos apenas gerar uma lista de livros. Existe uma classe base na qual a funcionalidade básica do controlador já está definida, então você precisa herdar as propriedades e funções desta classe ( AppController é herdeiro Controlador).

Tudo o que você precisa fazer na lista de ações é chamar o modelo para recuperar os dados e, em seguida, selecionar a visualização para apresentá-la ao usuário. Veja como fazer.

este-\u003e Livro é o nosso modelo e parte do código:

$ this-\u003e Livro-\u003e findAllByCategory ($ category)

diz ao modelo para retornar uma lista de livros sobre o tópico selecionado (veremos o modelo mais tarde).

Método conjunto na linha:

$ this-\u003e set ("books", $ this-\u003e Book-\u003e findAllByCategory ($ category));

O controlador transfere dados para a visualização. Variável livros pega os dados retornados pelo modelo e os torna visíveis.

Agora tudo o que resta é mostrar a visão, mas esta função é feita automaticamente no cakePHP se usarmos a visão padrão. Se quisermos usar uma visão diferente, devemos chamar explicitamente o método render.

Modelo

O modelo é ainda mais simples:

classe Book estende AppModel (

Por que está vazio? Porque ele herda de uma classe base que fornece a funcionalidade necessária, e precisamos usar a convenção de nomenclatura no CakePHP para que o workbench faça todas as outras tarefas automaticamente. Por exemplo, cakePHP sabe pelo nome que o modelo é usado em BooksControllere que ela tem acesso a uma tabela de banco de dados chamada books.

Com esta definição, teremos um modelo que somente poderá ler, deletar ou salvar dados no banco de dados.

Salve o código como book.php na pasta / app / models.

Visão

Tudo o que precisamos fazer agora é criar uma visão (pelo menos uma) para a lista de ações. A visão terá código HTML e algumas (poucas) linhas de código PHP para percorrer a matriz de livros fornecida pelo modelo.

Nome	Autor	Preço

Como você pode ver, a visualização não cria uma página completa, mas apenas um fragmento de HTML (tabela neste caso). Porque o CakePHP fornece outra maneira de definir um modelo de página, e a visão é inserida nesse modelo. O workbench também nos fornece alguns objetos auxiliares para realizar tarefas comuns ao criar partes de uma página HTML (inserir formulários, links, Ajax ou JavaScript).

Salve a vista como list.ctp (lista é o nome da ação e ctp significa Template CakePHP) na pasta / app / views / books (porque esta é uma visão para uma ação do controlador).

É assim que todos os três componentes são executados usando o ambiente de trabalho CakePHP!

“Não entendo por que as pessoas admiram tanto esse Caruso?” Com a língua na língua, pesquisando no Google, cantando - você não consegue descobrir!
- Você ouviu como o Caruso canta?
- Sim, Rabinovich cantou algo de seu repertório para mim no telefone.

Detetive de TI. Parte um

Eu percebo que escrever outro artigo sobre Model-View-Controller é estúpido e prejudicial para o "carma". No entanto, com esse "padrão" eu tenho um relacionamento muito pessoal - um projeto fracassado, meio ano de vida e trabalho duro "na cesta".

Reescrevemos o projeto, já sem MVC, apenas nos guiando pelos princípios - o código parou de parecer uma bola de espaguete e foi cortado ao meio (mais sobre isso mais tarde, no artigo prometido sobre como aplicamos os “princípios” em nosso projeto). Mas eu queria entender o que fizemos de errado, qual foi o erro? E por muito tempo, tudo que continha a abreviatura MVC foi estudado. Até conhecermos as obras originais do criador - Trygve Reenskaug ...

E então tudo se encaixou. Descobriu-se que, de fato, com base em princípios, reinventamos o "MVC original". E o que muitas vezes é apresentado como MVC não tem nada a ver com isso ... assim como uma boa arquitetura. E a julgar por quantas pessoas escrevem sobre a insolvência do "MVC clássico", discutem e inventam todo tipo de modificações nele, não estamos sozinhos no enfrentamento desse problema.

Por mais de 30 anos, as ideias e soluções coletadas em MVC continuam sendo as mais significativas para o desenvolvimento de interfaces de usuário. Mas, curiosamente, apesar da confusão existente e da abundância de interpretações conflitantes, os desenvolvedores continuam a se contentar com informações de segunda mão, extraindo conhecimento sobre MVC da Wikipedia, pequenos artigos na Internet e estruturas para o desenvolvimento de aplicativos da web. O mais avançado lê Martin Fowler. E por alguma razão quase ninguém se volta para as fontes primárias. Essa é a lacuna que eu gostaria de preencher. E, ao mesmo tempo, desfaça alguns mitos.

Mitos: MVC foi projetado para SmallTalk

O conceito MVC foi formulado por Trygve Reenskaug como resultado de seu trabalho na Xerox PARC em 1978/79. Normalmente, a criação do MVC está associada à linguagem SmallTalk, mas isso não é totalmente verdade. Na verdade, Reenskaug trabalhou no grupo de laptops Dynabook para "crianças de todas as idades" liderado por Alan Kay.

Para avaliar a dimensão e o caráter revolucionário desse projeto, é preciso ter em mente que aqueles foram os anos em que, para trabalhar com computadores, era necessário estudar manuais de múltiplas páginas e ter um título acadêmico. O problema que Alan Kay estava tentando resolver era aproximar o computador do usuário médio, "quebrar" a parede que os separava. Ele queria fornecer ao usuário ferramentas que fossem extremamente simples e convenientes, mas ao mesmo tempo possibilitassem o controle do computador e de aplicativos complexos.

Foi então / aí que as bases da interface gráfica foram lançadas, o conceito de "interface amigável" foi formado. E também a linguagem SmallTalk foi desenvolvida, juntamente com os conceitos de objeto programação orientadapara que o usuário não treinado “possa entender e escrever programas”. Steve Jobs descreve o que viu no Xerox PARC em 1979 - Como Steve Jobs obteve as ideias de GUI da XEROX (a partir de 6,30)

O projeto está sendo executado há cerca de 10 anos, por um grupo de desenvolvedores muito fortes. As soluções, abordagens, princípios encontrados como resultado, tanto no campo das interfaces de usuário, e no campo da programação orientada a objetos, e em geral no desenvolvimento de sistemas de computador grandes e complexos, foram, em certa medida, enumerados por Reenskaug e formaram a base do MVC. Portanto, MVC é, na verdade, antes de tudo, uma coleção de ideias arquitetônicas norteadoras. Em SmallTalk-80, essas idéias acabaram de obter sua primeira implementação significativa. Além disso, isso foi feito depois que Reenskaug deixou a Xerox PARC e sem sua participação.

Infelizmente, durante muito tempo praticamente não havia informações disponíveis sobre o "MVC real". A primeira publicação séria dos criadores apareceu apenas 10 anos depois - "Um livro de receitas para usar o paradigma da interface do usuário Model-View-Controller em Smalltalk-80". Até Fowler menciona que aprendeu MVC em uma versão funcional do SmallTalk - "Tive acesso a uma versão funcional do Smalltalk-80 para que pudesse aprender MVC. Não posso dizer que esta pesquisa foi completa, mas me permitiu compreender alguns aspectos da solução que outras descrições não poderiam explicar.".

Portanto, não é surpreendente que tenham surgido “mitos” e várias interpretações. O problema é que muitas fontes "secundárias" descrevem MVC não apenas de uma forma distorcida, mas também de uma forma enganosamente simplificada, geralmente na forma de algum tipo de esquema formal.

Como resultado, muitas pessoas realmente consideram o MVC um esquema ou um padrão (é por isso que a pergunta surge constantemente - qual dos muitos esquemas existentes é "correto" e por que existem tantos deles?). Chamadas MVC mais avançadas composto padrão, ou seja, uma combinação de vários padrões que funcionam juntos para implementar aplicativos complexos (geralmente Observer, Strategy e Composite são mencionados aqui). E apenas algumas pessoas entendem que MVC é principalmente um conjunto de idéias / princípios / abordagens arquitetônicas que podem ser implementados de maneiras diferentes usando padrões diferentes ...

Este último inclui em particular Martin Fowler. Aqui está o que ele escreve: “MVC é frequentemente referido como um padrão, mas não vejo muitos benefícios em pensar nele como um padrão, pois inclui muitas ideias diferentes. Diferentes pessoas lêem sobre MVC em diferentes fontes e obtêm diferentes idéias a partir daí, mas eles os chamam da mesma forma - "MVC". Isso leva a muita confusão e também serve como uma fonte de mal-entendidos e mal-entendidos sobre MVC, como se as pessoas descobrissem sobre ele através de um "telefone quebrado" .... Já perdi a conta do número de vezes que vi algo descrito como MVC e que não era. ”[Arquiteturas de GUI]

Eu me aventuraria a sugerir que uma das razões para o "telefone danificado" é que a maioria das fontes secundárias "nos bastidores" deixa a coisa mais importante - na verdade, as ideias arquitetônicas inerentes ao MVC por seus criadores e as tarefas que eles tentaram resolver. Tudo que permite entender a essência do MVC e evitar um grande número de armadilhas e erros. Portanto, neste artigo eu quero falar sobre o que geralmente permanece "nos bastidores" - MVC do ponto de vista de seus princípios e ideias arquitetônicas. Embora haja esquemas também. Em vez disso, vamos começar com eles.

Mas os links primeiro. O relatório original de Reenskaug é "Os relatórios MVC originais". Posteriormente, Reenskaug formulou tudo isso de forma mais clara e formalizou em seu trabalho subsequente “The Model-View-Controller (MVC). Seu passado e presente ”. Talvez alguém se interesse pela página onde são recolhidas as notas de Renskaug desse período, com os seus comentários - MVC XEROX PARC 1978-79.

A já mencionada primeira publicação sobre MVC em SmallTalk-80 de desenvolvedores apenas em qualidade aprimorada "Uma Descrição do Paradigma de Interface de Usuário Model-View-Controller no Sistema Smalltalk-80" (Glenn Krasner e Stephen Pope). O artigo “Programação de aplicativos em Smalltalk-80. How to use Model-View-Controller ”(o autor SteveBurbeck contribuiu para o Compilador SmallTalk para IBM baseado em Smalltalk-80, bem como para o desenvolvimento MacApp). Bem, se alguém deseja uma imersão completa - “Smalltalk-80. The Interactive Programming Environment ”da famosa Adele Goldberg em discussões com as quais Reenskaug criou os termos Model, View, Controller.

Esquemas MVC

Para entender do que se trata e qual é o problema, vamos primeiro analisar os "esquemas" MVC mais típicos. Isso é importante porque muitas vezes nenhuma explicação é dada aos diagramas e, além disso, acontece que as definições são emprestadas de um lugar e os diagramas de outro. Como resultado, você pode encontrar as mesmas descrições MVC com diagramas completamente diferentes, o que é muito confuso.

Portanto, apesar de MVC ser interpretado e representado de maneiras muito diferentes, em toda essa diversidade, um "núcleo" comum ainda pode ser distinguido. O comum é que em todos os lugares se fala sobre certas três partes - Modelo, Visão e Controlador, que se relacionam de uma determinada maneira, a saber:

O modelo não sabe nada sobre View ou Controller, o que permite desenvolvê-lo e testá-lo como um componente independente. E esse é o ponto principal do MVC.

A vista exibe o modelo. E isso significa que ele deve, de alguma forma, obter os dados de que precisa para exibir a partir dele. As mais comuns são as duas opções a seguir: 1) Active View, que conhece o modelo e obtém os dados necessários dele mesmo. 2) Visão Passiva, para a qual os dados são fornecidos pelo Controlador. Neste caso, a View não está conectada ao Model de forma alguma.




Pode haver várias visualizações - elas podem exibir os mesmos dados de maneiras diferentes, por exemplo, na forma de uma tabela ou gráfico, ou podem ser responsáveis \u200b\u200bpor exibir diferentes partes dos dados do Modelo.

1. O controlador é talvez o componente mais controverso. No entanto, é comum que o Controlador esteja sempre ciente do Modelo e possa alterá-lo (geralmente como resultado de ações do usuário).

Ele também pode gerenciar as visualizações / visualizações (especialmente se houver várias) e, portanto, saber sobre as visualizações, mas isso não é necessário.

A partir daqui, obtemos os esquemas básicos (simplificados ao máximo) das duas variedades mais comuns de MVC. A linha cruzada indica um link opcional entre o Controlador e a Visualização.

Como isso circuito básico parece em Fowler: "Relacionamentos básicos entre Model, View e Controller. (Eu os chamo de básicos porque na verdade a View e o Controller podem estar diretamente relacionados um ao outro. No entanto, a maioria dos desenvolvedores não usa esse relacionamento.)"

Mais longe. Um modelo, como uma visualização, também pode ser passivo ou ativo. Modelo Passivo não tem efeito na visualização ou no controlador. Neste caso, todas as alterações no Modelo são rastreadas pelo Controlador e ele também é responsável por redesenhar a Visualização quando necessário.

Mas normalmente, MVC ainda significa a opção com Modelo Ativo.

"Modelo Ativo" notifica que houve mudanças nele. E ela faz isso por meio de um modelo Observadorenviando notificações de alterações a todos os seus “assinantes”. O "Active View" se inscreve nessas mensagens e, portanto, sabe quando reler os dados de que precisa do modelo e atualizá-los. No caso de uma "Visualização Passiva", o Assinante é o Controlador, que então atualiza a Visualização.

Modelo Observador permite que o Modelo, por um lado, informe à Visualização ou ao Controlador que mudanças ocorreram nele e, por outro lado, de fato, "não sei" nada sobre eles (exceto que implementam uma determinada interface de "assinante" especificada) e, portanto, permanecem independentes. É chamado ligação solta e é considerado o segundo ponto-chave do MVC.

É por isso que quando se diz que MVC é um padrão composto, em primeiro lugar, o padrão é mencionado como um de seus componentes Observador... Em diagramas, o acoplamento fraco geralmente é desenhado com uma seta tracejada, mas muitas pessoas ignoram essa regra.

Assim, os "esquemas MVC" mais avançados seriam assim:

Comente: há autores que atribuem um significado completamente diferente aos termos modelos passivos e modelos ativos. Ou seja, o que normalmente é chamado de modelo Thin (um modelo que contém apenas dados) e o modelo de Tolstoi (um modelo completo contendo toda a lógica de negócios do aplicativo).

E a última coisa. De modo geral, MVC, em qualquer uma de suas variedades, é principalmente um modelo para o desenvolvimento de aplicativos com uma interface de usuário e seu objetivo principal é fornecer a interação de um aplicativo com o usuário. Portanto, em um esquema MVC completo (explícita ou implicitamente), deve haver do utilizador... E aqui existem basicamente duas interpretações:

Comente: você precisa ter em mente que a opção com Passiva, quando a Visualização não está de forma alguma conectada ao Modelo e o Controlador fornece os dados para exibi-lo, às vezes é chamado de MVC e às vezes é separado em um tipo separado - MVP, e então o Controlador é renomeado para Apresentador.

Para ilustrar tudo isso, existem vários diagramas "da Internet" (espero que tenha ficado mais claro por que eles são tão diferentes):

E agora o mais importante - como eles são usados, o que significam e a que o View Model e o Controller correspondem ao escrever aplicativos?

Existem duas abordagens radicalmente diferentes aqui, em cada uma das quais Model, View e Controller são interpretados de maneiras muito diferentes.

"MVC de três camadas" da web

A primeira abordagem vem da programação da web, onde MVC é o mais difundido e, portanto, reflete os recursos inerentes da programação da web tanto quanto possível. Ou seja, a vinculação à arquitetura de três camadas "banco de dados cliente-servidor" e a predominância de linguagens de script. Como resultado, os componentes MVC são formalmente ligados a três camadas de arquitetura e acontece que:

Model \u003d Database
Um modelo são simplesmente dados nos quais o aplicativo opera

Controlador \u003d Servidor
O controlador é a lógica de negócios do aplicativo. Às vezes, também se diz que o controlador é o centro de processamento de todas as solicitações e de tomada de decisões, bem como uma camada intermediária que fornece a comunicação entre o modelo e a visualização.

1. Ver \u003d Cliente (geralmente magro)
   Uma visão é uma interface de usuário. Além disso, a interface neste caso, via de regra, é entendida principalmente exclusivamente como "design", apenas um conjunto de elementos gráficos. A lógica desta interface, bem como a lógica de trabalhar com os dados, é transferida para o Controlador

Tanto foi escrito sobre a inadequação dessa abordagem que ela até entrou na Wikipedia (MVC. Os erros mais comuns). Os problemas que surgem neste caso são bem discutidos e detalhadamente no artigo, que se tornou uma espécie de clássico "". Portanto, tentarei simplesmente resumir brevemente:

A independência do modelo é fundamental para MVC. Se o modelo for fino, ou seja, conter apenas dados, a possibilidade de seu desenvolvimento independente não faz muito sentido. Conseqüentemente, com esta abordagem, o próprio MVC perde seu significado.

Toda a lógica de negócio da aplicação, ou seja, grande parte do código, está concentrada no Controller, e isso apesar de o Controller ser a parte mais dependente do MVC - em geral, depende tanto do Model quanto da View. De modo geral, em aplicativos bem projetados, eles tentam fazer exatamente o oposto - as partes mais dependentes devem ser mínimas, não máximas.

Na prática, um script geralmente corresponde ao Controlador em um aplicativo da web, e colocar toda a lógica de negócios no Controlador significa que a maior parte do aplicativo termina em um único script. É daí que veio o termo TTUK - um controlador gordo, burro e feio.

1. Uma vez que, como regra, não apenas o Modelo é fino, mas também a Visualização (Visualização monótona ou interface burra - GUI burra, Visualização burra), então, como resultado, além de toda a lógica de negócios do aplicativo, a lógica para gerenciar a interface do usuário também é colocada no Controlador. Ou seja, em vez de separar a lógica de negócios e a lógica de apresentação, essa abordagem resulta na mistura delas.

Erros típicos: misturar lógica de negócios e lógica GUI no controlador

A boa notícia é que a opção "Web MVC", que era a versão mais usada há poucos anos, agora está perdendo terreno. A má notícia é que ainda é generalizado, só que agora não explicitamente, mas de forma disfarçada. Já para as frases (entre aspas): " O modelo é a troca de dados com o banco de dados etc. O controlador é a lógica para o processamento desses dados e preparação para a Visualização"agora ativamente" menos ", então eles começaram a escrever:

• O modelo são os dados e métodos de trabalho com eles
• Controlador - processando ações do usuário e informações inseridas por ele

O fato é que em uma aplicação orientada a objetos não existem dados, mas existem muitos objetos e cada um deles contém algum tipo de dados e métodos de trabalhar com eles. Incluindo objetos de acesso ao banco de dados (se houver). Portanto, quando a definição do Modelo começa com a palavra "dados", ela tem essencialmente pouco significado e, muitas vezes, de forma velada, implica todos o mesmo acesso ao banco de dados. NO em processamento o mesmo ações do usuário muitas vezes, a maior parte da lógica de negócios é colocada e, como resultado, toda, ou quase toda, a lógica do aplicativo geralmente termina no Controlador.

"MVC arquitetônico"

A segunda abordagem está muito mais próxima das fontes originais. Portanto, iremos analisá-lo com mais detalhes.

Martin Fowler está absolutamente certo quando diz que MVC não é um padrão, mas um conjunto de princípios e idéias arquitetônicas usados \u200b\u200bna construção de sistemas de informação personalizados (geralmente complexos).

Tentamos coletar e descrever os princípios arquitetônicos no artigo "". Resumindo, a essência é a seguinte: um sistema complexo deve ser dividido em módulos. Além disso, é aconselhável fazer decomposição hierarquicamente, e os módulos em que o sistema é dividido devem ser, se possível, independentes, ou vagamente conectado (Baixo acoplamento) Quanto mais fraco o acoplamento, mais fácil é escrever / entender / estender / corrigir o programa. Portanto, uma das principais tarefas na decomposição é minimizar e enfraquecer as conexões entre os componentes.

Vamos ver como esses princípios são aplicados no MVC para criar a arquitetura primária (decomposição) de aplicativos personalizados. Basicamente, o MVC é baseado em três ideias bastante simples:

"1" Separação do modelo de domínio (lógica de negócios) do aplicativo da interface do usuário

A primeira e principal ideia do MVC é que qualquer aplicativo de usuário pode ser dividido em dois módulos - um dos quais fornece a funcionalidade principal do aplicativo, sua lógica de negócios, e o segundo é responsável pela interação com o usuário:

Assim, temos a oportunidade de desenvolver modelo de domínio, que contém a lógica de negócio do sistema e constitui o núcleo funcional da aplicação, sem pensar em como exatamente irá interagir com o usuário.

A tarefa de interação com o usuário é realizada em um módulo separado - interface de usuário e também pode ser resolvido de forma relativamente independente.

É o modelo de domínio (Domain Model from English modelo de domínio) é considerado Modelo em "MVC arquitetônico" (daí o termo). Portanto, é tão importante que seja independente e possa ser desenvolvido e testado de forma independente.

"A ideia central por trás do MVC, bem como a ideia central para todos os frameworks subsequentes, é o que chamo de Apresentação Separada. O objetivo da Visualização Separada é traçar uma linha clara entre os objetos de domínio que refletem nosso mundo real, e objetos de apresentação, que são elementos GUI na tela. Os objetos de domínio devem ser completamente independentes e funcionar sem referência à visão, eles devem ser capazes de suportar (suportar) múltiplas visões, talvez até simultaneamente. Esta abordagem, aliás, também foi uma das importantes aspectos da cultura Unix, permitindo ainda hoje trabalhar em uma variedade de aplicações, tanto através de linha de comandoe através da interface gráfica (simultaneamente). " - Fowler

"2" Independência do modelo e sincronização das interfaces de usuário através do modelo Observador

A segunda ideia chave é que, para ser capaz de desenvolver um modelo tanto faz, você precisa reduzir sua dependência da interface do usuário. E isso é feito, conforme mencionado acima, por meio do modelo Observador .

Modelo envia notificações de mudanças... A interface assina essas notificações e, portanto, sabe quando reler os dados do modelo e atualizar. Graças a isso, conseguimos praticamente modelo independenteque nada sabe sobre as interfaces de usuário associadas a ele, exceto que implementam a interface "observador".

Separação "3" da interface do usuário em visualização e controlador.

A terceira ideia é simplesmente a segunda etapa da decomposição hierárquica. Após a separação inicial do aplicativo em um modelo de negócio e uma interface, a decomposição continua no próximo nível hierárquico e a interface do usuário, por sua vez, é dividida em Visualização e Controlador.

Tenho a impressão de que muito poucas pessoas entendem a essência dessa divisão e, portanto, conseguem explicá-la. Normalmente, apenas o texto padrão simplificado é dado para que o Controlador reaja de alguma forma às ações do usuário, e a Visualização exibe o Modelo (portanto, na maioria das implementações, é a Visualização que assina notificações de mudanças no Modelo. Embora, como já mencionado, o assinante possa ser o Controlador ou Controlador junto).

Uma vez que a divisão da interface do usuário em View e Controller se refere a o segundo nível da hierarquia, é muito menos significativo do que a divisão primária do aplicativo em modelo de domínio e interface. Muitas vezes (especialmente quando se trata de widgets simples) isso não é feito e é usado " mVC simplificado", Em que há apenas um modelo e um único componente de IU, que é um ViewController combinado. Mais sobre isso mais tarde.

O MVC arquitetônico parece razoável à primeira vista. Porém, assim que tentarmos aplicá-lo não a um exemplo educacional de três classes, mas a um programa real, enfrentaremos uma série de problemas e questões sobre os quais raramente se escreve, mas que são extremamente importantes. E eles dizem respeito não apenas à interface do usuário, mas também ao próprio Modelo. Então, sugiro que você tente descobrir e, por fim, "ouça Caruso", ou seja, consulte as fontes primárias.

MVC original: Reenskaug e SmallTalk-80

Estamos acostumados com o fato de que MVC quase sempre é considerado no exemplo da criação de algum componente gráfico mais simples, toda a "lógica de negócios" do qual é colocada em uma classe com dados e alguns métodos para alterá-los. Mas o que fazer quando se trata de real aplicativos, cujo núcleo consiste em muitos objetos interconectados trabalhando juntos?

Em geral Modelo é um objeto ou vários objetos? E é realmente Modelo no "esquema MVC" é idêntico ao modelo de domínio que descreve o domínio e a lógica de negócios do aplicativo?

Que o modelo implementa o padrão Observador indica claramente que o modelo é exatamente um objeto. Isso também é indicado pelo fato de que a View e o Controller devem conhecer o Model (para tirar dados dele e fazer alterações) e, portanto, devem conter um link para ele. Mas então, se assumirmos que o Modelo significa o modelo de domínio, novamente chegaremos à conclusão de que todo o núcleo do aplicativo está em um objeto. Só que agora, em vez de um Controlador gordo e feio, temos um Modelo gordo. O Thick Model é certamente melhor, uma vez que é independente e pelo menos não mistura lógica de negócios com lógica de GUI, mas ainda assim é difícil atribuir tal solução a uma boa arquitetura.

A segunda opção permanece - o modelo é um conjunto de objetos de domínio que implementam conjuntamente a lógica de negócios. Esta suposição é confirmada pelo próprio Reenskaug: " Um modelo pode ser um único objeto (bastante desinteressante) ou pode ser alguma estrutura de objetos."Mas então a questão permanece - quem implementa o modelo Observador, onde o View obtém os dados, para onde o Controller envia os comandos do usuário?

E aqui muitas vezes encontramos uma tentativa de nos iludir por meio de aproximadamente o seguinte raciocínio: "Seja o modelo um conjunto de objetos de domínio, mas ... entre este conjunto há também um" objeto com dados ", por isso implementará o padrão Observer, e servir como fonte de dados para Weed. " Este truque pode ser chamado de Model in Model. E, de fato, esta é outra versão "velada" do fato de que "Modelo são dados".

Aqui, só podemos dizer uma coisa: uma arquitetura na qual um módulo (View ou Controller) deve "subir" dentro outro módulo (modelo de domínio) e procure por dados ou objetos para alterá-lo "cheira" muito mal. Acontece que a View e o Controller dependem dos detalhes de implementação do modelo de domínio e, se a estrutura desse mesmo modelo mudar, toda a interface do usuário terá que ser refeita.

Para entender “como deveria ser”, proponho voltar aos “princípios”. Quando foi dito que o sistema deveria ser dividido em módulos, amarrado frouxamente uns com os outros, não mencionamos a regra principal para obter esse acoplamento mais fraco. Ou seja, os módulos uns para os outros devem ser "caixas pretas". Sob nenhuma circunstância um módulo deve acessar os objetos de outro módulo diretamente e saber algo sobre sua estrutura interna. Os módulos devem interagir uns com os outros apenas no nível de interfaces abstratas (Princípio de inversão de dependência). Uma interface de módulo é geralmente implementada por um objeto especial - Fachada.

E se você procurar quais padrões permitem que você obtenha conectividade fraca, então o padrão estará em primeiro lugar Fachada, e só então Observador etc.

Bem, agora um diagrama do relatório de Trygve Reenskaug:

Explicação: Desde a época da criação do MVC, as interfaces programas de computador eram principalmente textuais, ou seja, eram essencialmente o tipo mais simples de editor, então, em vez do termo "Interface do usuário", que apareceu mais tarde, Trygve Reenskaug usa o termo "Editor" (editor).

Assim, a ideia-chave do MVC é realmente que o aplicativo do usuário é dividido em dois módulos - um dos quais modela o domínio e implementa a lógica de negócios ( modelo de domínio), e o segundo é responsável pela interação do usuário ( interface de usuário) mas ao mesmo tempo Modelo no "esquema MVC" em tudo não idêntico ao modelo de domínio (que pode ser tão complexo quanto você quiser e consistir em muitos objetos), mas é apenas isso interface e fachada.

Portanto, é claro que nem o View nem o Controller devem saber como o módulo de domínio (modelo de domínio) está organizado, onde e em que formato os dados são armazenados ali e como exatamente o controle é realizado. Eles apenas interagem com interface e implementá-lo objeto de fachada, que fornece todos os dados necessários no formato desejado e um conjunto conveniente de comandos de alto nível para controlar o subsistema e também implementa o padrão Observer para notificar significativo mudanças no subsistema. E se quisermos mudar o banco de dados, usar a nuvem, ou mesmo coletar os dados de que precisamos de várias fontes na rede ... se fizermos alguma alteração na lógica de negócios do aplicativo, mas ao mesmo tempo deixarmos a interface-fachada inalterada, então nem a Visualização nem o Controlador serão não afetará. Temos arquitetura sustentável mudar.

E se quisermos desenhar um esquema MVC, então deve ser assim:

Vamos examinar mais de perto esse esquema. Tradicionalmente, nas aplicações cliente-servidor, o servidor é considerado o principal. Ele fornece serviços / serviços e decide de que forma devem ser implementados. Assim, a interface e a fachada são geralmente definidas do ponto de vista do servidor. E os clientes se adaptam a este formato especificado.

Na prática, não é uma arquitetura orientada para o servidor que é mais adequada, mas sim para o cliente. Nele, o foco do servidor é deslocado para o cliente e a interface, ou melhor, as interfaces (e a fachada ou fachadas), são determinadas com base nas necessidades dos clientes. Em vez de Interface Fornecida (Interface fornecida) são usados Interfaces Requeridas ().

Implementações específicas podem variar, mas isso não é importante

Abordagem orientada para o cliente é muito mais adequada O princípio da separação de interfaces (Princípio de Segregação de Interface) já que em vez de uma única espessura ProvidedInterface muitos finos são usados.

Se não me engano, essa é a abordagem usada na arquitetura de microsserviços. Lá, para interagir com os mais diversos serviços, foi introduzido o conceito de gateway, que nada mais é do que uma fachada - “ Um API Gateway é um servidor que é o único ponto de entrada no sistema. É semelhante ao padrão Facade do design orientado a objetos. O API Gateway encapsula a arquitetura do sistema interno e fornece uma API que é feita sob medida para cada cliente... ”Construindo microsserviços: usando um gateway de API.

Além disso, este portal " em vez de fornecer um estilo de API de tamanho único, o gateway de API pode expor uma API diferente para cada cliente. Por exemplo, o gateway de API Netflix executa o código do adaptador específico do cliente que fornece a cada cliente uma API mais adequada aos seus requisitos)"API Gateway.

Olhamos para a fachada ... Aqui está a cola, o objeto mediador, proxy, filtro, adaptador ... conectando o modelo de domínio e a interface do usuário um ao outro e fornecendo os dados necessários no formato desejado / conveniente.

Surpreendentemente, além de Reenskaug, quase ninguém escreve sobre isso. Embora alguns redescubram essa ideia por conta própria (veja um exemplo ou a seção "Técnicas de programação baseadas em interface").

O tópico Modelos de Interface é especialmente bem abordado no artigo de um dos JavaGuru - Advanced MVC Patterns. O autor enfatiza que os Modelos não são dados, mas exclusivamente interfaces / objetos de mediação / filtros (Modelos como Proxies, Modelos como Filtros), que fornecem acesso conveniente aos dados que podem ser localizados em qualquer lugar - em máquinas diferentes, em formatos diferentes: “ O que a maioria dos programadores não pensa é que os modelos são apenas interfaces. Eles não devem conter nenhum dado! .. Os modelos de proxy expandem o escopo e permitem que você já use dados existentes onde quer que estejam”.

Devido ao fato de que a fachada presente no MVC original foi "perdida", seu papel é frequentemente assumido pelo Controlador. Daí a ideia de que o Controlador está “entre o Modelo e a Visão”, serve como uma cola entre eles e fornece os dados de que a Visão precisa.

Nos fóruns, a questão é frequentemente encontrada - "Qual a diferença entre o controlador e a fachada?" Apesar da ingenuidade, esta pergunta é bastante natural e é difícil dar uma resposta razoável a ela, uma vez que em muitos frameworks MVC o Controlador é na verdade uma fachada - "Front-Controller".

Por que essa decisão é ruim? Se for implementado literalmente, nada. Mas isso é em teoria. Na prática, muitas vezes há uma confusão de conceitos e conceitos e, como resultado, o Front Controller, por um lado, abusa de seus poderes e, em vez disso delegação de equipes começa a incluir implementação logíca de negócios. Por outro lado, ele continua a executar simultaneamente as funções da interface do usuário e, como resultado, a já mencionada mistura de "lógica de negócios" e "lógica GUI" ocorre nele (o que na verdade faz seu código parecer um enorme despejo).

Acho que é hora de passar para Smalltalk. Smalltalk-80 foi criado por pessoas muito talentosas. Realmente houve problemas com a documentação (especialmente porque "padrões de design" não existiam então), mas com a implementação, basicamente tudo estava bem e interfaces de usuáriocertamente não interagiu com o modelo de domínio diretamente.

Entre a interface e o modelo de domínio (objetos da linguagem SmallTalk) havia sempre uma certa classe / objeto intermediário, que fornecia acesso integral conveniente aos objetos do domínio, seus dados e métodos. Esses objetos intermediários (que na verdade atuam como fachadas) eram, na verdade, modelos em SmallTalk-80.

Por exemplo, para trabalhar com código em Smalltalk, as seguintes interfaces de GUI foram usadas: Inspector, Browser, Workspace, ...

Aqui está o que Glenn Krasner escreve sobre o arranjo deles:

"O Inspetor no sistema consiste em duas visualizações. ListView exibe a lista de variáveis \u200b\u200b(esquerda) e TextView mostra o valor da variável selecionada (direita) ... O modelo para essas visualizações é uma instância da classe" Inspetor"... Uma aula separada" Inspetor" é um mediador ou filtro a fim de fornecer acesso a qualquer propriedade de qualquer objeto. Usando objetos intermediários entre View e " real"modelos é uma maneira típica de isolar o comportamento de exibição do modelo de aplicativo ...

Assim como o Inspetor, os objetos intermediários também foram usados \u200b\u200bcomo modelos para navegadores do sistema. Uma instância da classe " Navegador“É um modelo de mediação para cada navegador do sistema ..."

Comente: O nome da classe de mediador que descreve o objeto fachada intermediário é geralmente igual ao nome do widget que o exibe. O inspetor chamou o modelo intermediário de “ Inspetor", E navegador, respectivamente -" Navegador».

No caso do Workspace, que era uma das interfaces mais simples " o modelo era uma instância StringHolder que simplesmente fornecia texto, ou seja, uma string com informações de formatação. "

No final de seu artigo, Krasner lista os modelos usados \u200b\u200bno SmallTalk (herdados da classe base do modelo): StringHolder, Navegador, Inspetor, FileModel, Ícone... E também observa que " os modelos eram quase sempre algum tipo de classe de filtro".

Posteriormente, no VisualWorks Smalltalk, a ideia de suportes intermediários foi desenvolvida e totalmente implementada. Lá, para acessar cada variável pertencente aos objetos do domínio, são utilizadas sua própria interface e fachada - ValueModel e ValueHolder. E, como você pode imaginar, é o ValueModel que implementa o modelo Observador, notificando a GUI sobre as mudanças que ocorrem "no domínio".

Erros típicos: acessar objetos de domínio diretamente

Devido ao fato de que os desenvolvedores nem sempre entendem bem o que está por trás de todos esses "modelos", e os próprios modelos são usados \u200b\u200bpara serem percebidos como dados e não uma interface, isso se torna a fonte de outro erro muito comum e que consome muitos recursos. Em vez de apenas o caminho certo interpretar e adaptar os dados de domínio existentes usando modelos de proxy que eles começam cópia de nesses modelos de proxy.

Por exemplo, ValueHolder é, via de regra, apenas um wrapper em torno de uma variável de domínio já existente, ele não deve conter dados, mas uma referência aos dados. Aqui está o que eles escrevem: " ValueModel não precisa realmente armazenar o valor porque ele já está sendo armazenado por outro modelo"(Compreendendo e usando ValueModels).

E aqui está uma citação do artigo Advanced MVC Patterns: " Um dos erros mais comuns que as pessoas cometem ao usar componentes Swing é copiar dados no modelo desses componentes Swing. O correto é utilizar os dados existentes, adaptando-os com um filtro ... Lembre-se: nunca copie dados que possam ser simplesmente interpretados!".

Considere o seguinte exemplo simples. Se você seguir as dicas da Internet e usar um código como este para "adicionar itens à lista" (retirado de StackOverflow e Adicionar e remover um item em uma JList), exatamente o mesmo acontecerá copiando dados para o modelo de lista:

Itens de objeto; // Objeto de domínio DefaultListModel model \u003d new DefaultListModel (); Lista JList \u003d novo JList (modelo); para (int i \u003d 0; i< items.length; i++){ // КОПИРОВАНИЕ доменных данных в модель списка! model.addElement(items[i]); }

É mais correto, é claro, usar os dados do array simplesmente envolvendo-os na interface ListModel (especialmente porque um AbstractListModel quase pronto foi criado para esse propósito):

// criar um adaptador de fachada para dados de domínio, // que simplesmente os interpreta conforme necessário ListModel model \u003d new AbstractListModel () (public int getSize () (return items.length;) public Object getElementAt (int index) (return items;) ); // passa a fachada criada para a lista como um modelo JList list \u003d new JList (model);

E se você precisa combinar dados, filtrar ou transformar de alguma forma, então os arrays intermediários são completamente desnecessários. Tudo é feito diretamente no modelo de fachada

Object items1; Object items2; // Objetos de domínio // um modelo de fachada que combina matrizes ListModel model \u003d new AbstractListModel () (public int getSize () (retornar items1.length + items2.length;) public Object getElementAt (int index) (índice de retorno

No caso de pequenos arrays estáticos, os benefícios não são óbvios. Mas, no caso geral, essa abordagem permite não apenas evitar a cópia, mas antes de tudo protege contra problemas associados à dessincronização de dados (se você não tiver preguiça de escrever métodos que notifiquem os ouvintes sobre as alterações).

Bem, se você quer brevidade, é melhor assim:

Lista JList \u003d novo JList (itens);

Nesse caso, o Java fará o próprio adaptador wrapper em vez de copiar.

Erros típicos: copiar dados de domínio em um modelo de componente GUI

Por fim, podemos dissipar o mito principal, que é a fonte do maior número de problemas e erros.

Mitos: O modelo no "esquema MVC" é idêntico ao modelo de domínio e aos dados

A confusão surge do fato de que a mesma palavra "Modelo" é usada em contextos diferentes. Quando se trata de decomposição e separação logíca de negócios de interface de usuário, então o modelo realmente significa exatamente modelo de domínio, contendo dados e a lógica de trabalhar com eles e fornecer a funcionalidade principal do aplicativo.

Mas, no contexto de modelos e esquemas, o modelo é antes de tudo interface e implementá-lo objeto proxy (fachada, adaptador, proxy) que fornecem acesso conveniente e seguro aos dados do domínio que podem ser localizados em qualquer lugar. Reenskaug escreveu: " objeto modelo com uma fachada que reflete o modelo mental do usuário".

Quando MVC é apresentado apenas como um "esquema", ter "modelos intermediários" parece complicado e confuso. Surgem questões ("Como esses modelos diferem entre si?", "Como usá-los corretamente?"), Interpretações ambíguas e muitas oportunidades de errar.

Mas se você entender as idéias arquitetônicas inerentes ao MVC, então tudo se torna extremamente claro: a interface do usuário não tem o direito de acessar os objetos do modelo de domínio diretamente. Isso significa que deve haver uma fachada / mediador / adaptador ... entre o modelo de domínio e a interface do usuário, e a interface do usuário (Visualização e Controlador) só pode interagir com ele. Não há oportunidades de cometer um erro.

E em geral torna-se tudo o mesmo que termo este objeto mediador é chamado e que tipo de Model-View-Qualquer tipo de MVC é usado ... Você começa a ver: qual problema está sendo resolvido, com a ajuda de quais modelos e como isso é bem ou mal feito

Em princípio, este artigo pode ser concluído. Como já mencionado, a divisão da interface do usuário em Visualização e Controlador é o ponto menos significativo, até mesmo auxiliar. Mas por outro lado, a interface do usuário está presente em todas as aplicações do usuário e muitas vezes é útil para se ter uma ideia das abordagens e ideias desenvolvidas nesta área. Além disso, é em torno da Controladora que as principais disputas estão sendo conduzidas. Portanto - totalmente dedicado a este tópico específico.