Utilizando padrão MVC em projetos

 

Atualmente, é muito comum entrarmos na internet e nos depararmos com sites onde temos que interagir diretamente com eles para podermos por exemplo realizar um cadastro. Mas por trás desse site, existe todo um processo de construção, que envolve design, programação e construção de interface gráfica do sistema, para isso, existe um padrão conhecido entre os desenvolvedores chamado de padrão MVC. Esse padrão serve para montar um sistema completo que necessariamente precisa da interação do banco de dados com a interface do sistema.

O acrônimo MVC significa Model-View-Controller que basicamente são as camadas de desenvolvimento para qualquer sistema que tenha interface gráfica para interação do usuário.  A seguir será feita uma explicação sobre cada letra do acrônimo e como ele se aplica nas fases de desenvolvimento de sistemas.

Letra do Acronimo	O que significa	Para que serve
M	Model-Modelo	Define as classes que serão utilizadas para a construção do sistema. Cada classe deve conter os atributos necessários para o desenvolvimento de determinadas funcionalidades e métodos que podem ser utilizados para interação com o sistema.
V	View-Visualização (Interface do sistema)	São as interfaces que o sistema irá conter para interação direta do usuário. Essa camada é responsável pelo desenvolvimento das páginas web, ou interface gráfica do sistema
C	Controller-Controlador	Responsável pela comunicação entre o model e o view. Essa camada recebe requisições enviadas pelo usuário final e deve retornar o resultado esperado.

 

Em muitas aplicações, existem tambem a camada de serviço, onde são aplicadas as quatro operações básicas do banco de dados, e tambem outros serviços que são oferecidos pelo sistema.

A seguir será mostrado um exemplo de como se aplica o padrão MVC em uma aplicação Java utilizando a ferramenta Spring.

Em primeiro lugar, definimos as dependências necessárias para o desenvolvimento de um simples projeto MVC. Nesse caso utilizaremos o Maven, o gerenciador de dependências muito utilizado entre os desenvolvedores Java.

<dependencies>

    <dependency>

        <groupId>org.springframework.boot</groupId>

        <artifactId>spring-boot-starter-web</artifactId>

    </dependency>

    <dependency>

        <groupId>org.springframework.boot</groupId>

        <artifactId>spring-boot-starter-data-jpa</artifactId>

    </dependency>

    <dependency>

        <groupId>com.h2database</groupId>

        <artifactId>h2</artifactId>

        <scope>runtime</scope>

    </dependency>

    <dependency>

        <groupId>org.springframework.boot</groupId>

        <artifactId>spring-boot-starter-test</artifactId>

        <scope>test</scope>

    </dependency>

</dependencies>

 

Após definir as dependências do projeto podemos definir a classe de modelo do sistema, onde serão definida todas as características necessárias de uma classe para o sistema.

package com.example.model;

 

import javax.persistence.Entity;

import javax.persistence.GeneratedValue;

import javax.persistence.GenerationType;

import javax.persistence.Id;

 

@Entity

public class Contact {

                                              

    @Id

    @GeneratedValue(strategy = GenerationType.IDENTITY)

    private Long id;

    private String name;

    private String phone;

 

    public Contact() {}

 

    public Contact(String name, String phone) {

        this.name = name;

        this.phone = phone;

    }

 

    public Long getId() {

        return id;

    }

 

    public void setId(Long id) {

        this.id = id;

    }

 

    public String getName() {

        return name;

    }

 

    public void setName(String name) {

        this.name = name;

    }

 

    public String getPhone() {

        return phone;

    }

 

    public void setPhone(String phone) {

        this.phone = phone;

    }

 

    @Override

    public String toString() {

        return "Contact{id=" + id + ", name='" + name + "', phone='" + phone + "'}";

    }

}

A classe acima representa um modelo simples de um projeto MVC. Essa classe mostra todos os atributos e métodos necessários que serão utilizados posteriormente por outras classes do sistema.

Após definir o modelo do nosso projeto, iremos definir o repositório do nosso projeto, onde de acordo com o código, será extendido da classe JPARepository, onde contem todas as operações necessárias para o sistema.

package com.example.repository;

 

import com.example.model.Contact;

import org.springframework.data.jpa.repository.JpaRepository;

import org.springframework.stereotype.Repository;

                                

 

@Repository

public interface ContactRepository extends JpaRepository<Contact, Long> {

}

Após definir o repositório, será definido a camada de serviço, onde será definido os serviços necessários para realizar as operações no sistema.

package com.example.service;

 

import com.example.model.Contact;

import com.example.repository.ContactRepository;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Service;

 

import java.util.List;

 

@Service

public class ContactService {

    private final ContactRepository contactRepository;

 

    @Autowired

    public ContactService(ContactRepository contactRepository) {

        this.contactRepository = contactRepository;

    }

 

    public Contact addContact(Contact contact) {

        return contactRepository.save(contact);

    }

 

    public List<Contact> getAllContacts() {

        return contactRepository.findAll();

    }

 

    public void removeContact(Long id) {

        contactRepository.deleteById(id);

    }

}

Por último iremos definir a nossa classe de controller, responsável por gerenciar as requisições que serão realizadas pelo sistema.

package com.example.controller;

 

import com.example.model.Contact;

import com.example.service.ContactService;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.http.ResponseEntity;

import org.springframework.web.bind.annotation.*;

 

import java.util.List;

 

@RestController

@RequestMapping("/contacts")

public class ContactController {

    private final ContactService contactService;

 

    @Autowired

    public ContactController(ContactService contactService) {

        this.contactService = contactService;

    }

 

    @PostMapping

    public ResponseEntity<Contact> addContact(@RequestBody Contact contact) {

        Contact newContact = contactService.addContact(contact);

        return ResponseEntity.ok(newContact);

    }

 

    @GetMapping

    public ResponseEntity<List<Contact>> getAllContacts() {

        List<Contact> contacts = contactService.getAllContacts();

        return ResponseEntity.ok(contacts);

    }

 

    @DeleteMapping("/{id}")

    public ResponseEntity<Void> removeContact(@PathVariable Long id) {

        contactService.removeContact(id);

        return ResponseEntity.noContent().build();

    }

}

O controlador é responsável por gerenciar as requisições do sistema realizadas através da camada View. A camada View faz a requisição e a camada Controller realiza a requisição e retorna para View o resultado esperado pela requisição.

Em resumo, o padrão MVC organiza a aplicação em três camadas: Model, View e Controller, cada uma com responsabilidades específicas. Utilizando o Spring Boot, é possível implementar uma aplicação Java robusta e modular, onde a camada de serviço interage com o banco de dados e a Controller gerencia as requisições dos usuários, promovendo uma separação clara entre a lógica de negócios e a interface do usuário. Este padrão facilita a manutenção e a escalabilidade do sistema.