O Model-View-Controller (MVC) é um conhecido padrão de design na área de desenvolvimento web. É uma maneira de organizar nosso código. Especifica que um programa ou aplicação deve consistir em modelo de dados, informações de apresentação e informações de controle. O padrão MVC precisa que todos esses componentes sejam separados como objetos diferentes.

Nesta seção, discutiremos a Arquitetura MVC em Java, juntamente com suas vantagens e desvantagens e exemplos para entender a implementação de MVC em Java.

O que é arquitetura MVC em Java?

Os designs de modelo baseados na arquitetura MVC seguem o padrão de design MVC. A lógica do aplicativo é separada da interface do usuário durante o projeto do software usando designs de modelo.

iterar mapa em java

A arquitetura do padrão MVC consiste em três camadas:

Modelo:Ele representa a camada comercial do aplicativo. É um objeto para transportar os dados que também pode conter a lógica para atualizar o controlador se os dados forem alterados.Visualizar:Representa a camada de apresentação do aplicativo. É usado para visualizar os dados que o modelo contém.Controlador:Funciona tanto no modelo quanto na visualização. É usado para gerenciar o fluxo do aplicativo, ou seja, o fluxo de dados no objeto do modelo e para atualizar a visualização sempre que os dados são alterados.

Na programação Java, o modelo contém o simples Aulas Java , a View usada para exibir os dados e o Controller contém o servlets . Devido a esta separação as solicitações do usuário são processadas da seguinte forma:

1. Um cliente (navegador) envia uma solicitação ao controlador no lado do servidor, para uma página.
2. O controlador então chama o modelo. Ele reúne os dados solicitados.
3. Em seguida, o controlador transfere os dados recuperados para a camada de visualização.
4. Agora o resultado é enviado de volta ao navegador (cliente) pela visualização.

Vantagens da Arquitetura MVC

As vantagens da arquitetura MVC são as seguintes:

• MVC possui o recurso de escalabilidade que, por sua vez, auxilia no crescimento do aplicativo.
• Os componentes são fáceis de manter porque há menos dependência.
• Um modelo pode ser reutilizado por múltiplas visualizações que fornecem capacidade de reutilização do código.
• Os desenvolvedores podem trabalhar com as três camadas (Modelo, Visualização e Controlador) simultaneamente.
• Usando MVC, a aplicação se torna mais compreensível.
• Usando MVC, cada camada é mantida separadamente, portanto, não precisamos lidar com códigos massivos.
• A extensão e o teste do aplicativo são mais fáceis.

Implementação de MVC usando Java

Para implementar o padrão MVC em Java, somos obrigados a criar as três classes a seguir.

Classe de Funcionário, atuará como camada de modeloClasse EmployeeView, atuará como uma camada de visualizaçãoClasse EmployeeContoller, atuará como uma camada controladora

Camadas de arquitetura MVC

Camada de modelo

O modelo no padrão de design MVC atua como uma camada de dados para o aplicativo. Representa a lógica de negócios do aplicativo e também o estado do aplicativo. O objeto modelo busca e armazena o estado do modelo no banco de dados. Usando a camada de modelo, regras são aplicadas aos dados que representam os conceitos de aplicação.

Vamos considerar o seguinte trecho de código que cria um que também é a primeira etapa para implementar o padrão MVC.

Funcionário.java

 // class that represents model public class Employee { // declaring the variables private String EmployeeName; private String EmployeeId; private String EmployeeDepartment; // defining getter and setter methods public String getId() { return EmployeeId; } public void setId(String id) { this.EmployeeId = id; } public String getName() { return EmployeeName; } public void setName(String name) { this.EmployeeName = name; } public String getDepartment() { return EmployeeDepartment; } public void setDepartment(String Department) { this.EmployeeDepartment = Department; } } 

O código acima consiste simplesmente em métodos getter e setter para a classe Employee.

Ver camada

Como o nome indica, view representa a visualização dos dados recebidos do modelo. A camada de visualização consiste na saída do aplicativo ou interface do usuário. Ele envia os dados solicitados ao cliente, que são buscados na camada de modelo pelo controlador.

Vejamos um exemplo onde criamos uma view usando a classe EmployeeView.

EmployeeView.java

 // class which represents the view public class EmployeeView { // method to display the Employee details public void printEmployeeDetails (String EmployeeName, String EmployeeId, String EmployeeDepartment){ System.out.println('Employee Details: '); System.out.println('Name: ' + EmployeeName); System.out.println('Employee ID: ' + EmployeeId); System.out.println('Employee Department: ' + EmployeeDepartment); } } 

Camada Controladora

A camada controladora recebe as solicitações do usuário da camada view e as processa, com as validações necessárias. Ele atua como uma interface entre Modelo e Visualização. As solicitações são então enviadas ao modelo para processamento de dados. Depois de processados, os dados são enviados de volta ao controlador e exibidos na visualização.

Vamos considerar o seguinte trecho de código que cria o controlador usando a classe EmployeeController.

EmployeeController.java

 // class which represent the controller public class EmployeeController { // declaring the variables model and view private Employee model; private EmployeeView view; // constructor to initialize public EmployeeController(Employee model, EmployeeView view) { this.model = model; this.view = view; } // getter and setter methods public void setEmployeeName(String name){ model.setName(name); } public String getEmployeeName(){ return model.getName(); } public void setEmployeeId(String id){ model.setId(id); } public String getEmployeeId(){ return model.getId(); } public void setEmployeeDepartment(String Department){ model.setDepartment(Department); } public String getEmployeeDepartment(){ return model.getDepartment(); } // method to update view public void updateView() { view.printEmployeeDetails(model.getName(), model.getId(), model.getDepartment()); } } 

Arquivo Java da classe principal

O exemplo a seguir exibe o arquivo principal para implementar a arquitetura MVC. Aqui, estamos usando a classe MVCMain.

MVCMain.java

 // main class public class MVCMain { public static void main(String[] args) { // fetching the employee record based on the employee_id from the database Employee model = retriveEmployeeFromDatabase(); // creating a view to write Employee details on console EmployeeView view = new EmployeeView(); EmployeeController controller = new EmployeeController(model, view); controller.updateView(); //updating the model data controller.setEmployeeName('Nirnay'); System.out.println('
 Employee Details after updating: '); controller.updateView(); } private static Employee retriveEmployeeFromDatabase(){ Employee Employee = new Employee(); Employee.setName('Anu'); Employee.setId('11'); Employee.setDepartment('Salesforce'); return Employee; } } 

O MVCPrincipal class busca os dados do funcionário do método onde inserimos os valores. Em seguida, ele empurra esses valores para o modelo. Depois disso, inicializa a visualização (EmployeeView.java). Quando a visualização é inicializada, o Controlador (EmployeeController.java) é invocado e vinculado à classe Employee e à classe EmployeeView. Por fim o método updateView() (método do controlador) atualiza os detalhes do funcionário para serem impressos no console.

Saída:

 Employee Details: Name: Anu Employee ID: 11 Employee Department: Salesforce Employee Details after updating: Name: Nirnay Employee ID: 11 Employee Department: Salesforce 

Desta forma, aprendemos sobre a Arquitetura MVC, o significado de cada camada e sua implementação em Java.