Olá pessoal, sou Senura Vihan Jayadeva. Neste tutorial, vou orientá-lo a construir um Web Service RESTful com Spring Boot .

Certo, em primeiro lugar, vamos ver quais são os nossos requisitos. Para este projeto precisamos

• IDE ou editor de texto ( Eclipse , Intellij )
• JDK 1.8 +
• Maven 3+ ou Gradle 4+ (Contaremos com o Maven para este artigo)

Nosso primeiro passo é inicializar um projeto Spring Boot. Para isso, vou para o Intellij IDE. Em seguida, vá para Arquivo -> Novo -> Projeto -> Spring Assitant.

Se você puder ver uma opção chamada Spring Assistant , primeiro temos que instalar esse plugin .

Vá para Arquivo->Configurações->Plugins

Em seguida, instale o Spring Assistant .

Ok!. Acho que se você teve algum problema com o assistente de mola agora está claro.

Agora, como mencionei anteriormente, vá para o Spring Assistant e clique em Avançar.

Então você pode especificar seu próprio Groud Id , Artifact Id , Project Name , Java Version como desejar. Em seguida, clique em próximo.

Também adicionaremos algumas dependências aqui, pois queremos usá-las em nosso projeto:

• Spring Web — Para incluir Spring MVC e Tomcat incorporado em seu projeto
• Spring Data JPA — Java Persistence API e Hibernate
• Spring Boot DevTools — Ferramentas de desenvolvimento muito úteis
• Driver MySQL — Driver JDBC (pode ser qualquer banco de dados que você gostaria de usar)
• Lombok — ferramenta de biblioteca Java que gera código para minimizar o código clichê. A biblioteca substitui o código clichê por anotações fáceis de usar

Então você tem que selecionar um nome para o projeto e selecionar um local do projeto. Depois disso, clique no botão Concluir para construir o projeto.

Depois de criarmos o projeto, se você acessar pom.xml poderá ver as dependências que instalamos.

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
   <modelVersion>4.0.0</modelVersion>
   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>2.4.4</version>
      <relativePath/> <!-- lookup parent from repository -->
   </parent>
   <groupId>com.example</groupId>
   <artifactId>demo</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <name>demo</name>
   <description>Demo project for Spring Boot</description>
   <properties>
      <java.version>11</java.version>
      <spring-native.version>0.9.1</spring-native.version>
   </properties>
   <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>mysql</groupId>
         <artifactId>mysql-connector-java</artifactId>
         <scope>runtime</scope>
      </dependency>
      <dependency>
         <groupId>org.projectlombok</groupId>
         <artifactId>lombok</artifactId>
         <optional>true</optional>
      </dependency>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>
   </dependencies>

   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <configuration>
               <excludes>
                  <exclude>
                     <groupId>org.projectlombok</groupId>
                     <artifactId>lombok</artifactId>
                  </exclude>
               </excludes>
               <image>
                  <builder>paketobuildpacks/builder:tiny</builder>
                  <env>
                     <BP_NATIVE_IMAGE>true</BP_NATIVE_IMAGE>
                  </env>
               </image>
            </configuration>
         </plugin>

      </plugins>
   </build>
   <repositories>
      <repository>
         <id>spring-releases</id>
         <name>Spring Releases</name>
         <url>https://repo.spring.io/release</url>
      </repository>
   </repositories>
   <pluginRepositories>
      <pluginRepository>
         <id>spring-releases</id>
         <name>Spring Releases</name>
         <url>https://repo.spring.io/release</url>
      </pluginRepository>
   </pluginRepositories>

</project>

Em seguida, antes de começarmos a trabalhar no aplicativo, vamos querer configurar o banco de dados. Isso pode ser feito facilmente através do Spring Data JPA, que nos permite configurar essa conexão com apenas alguns parâmetros.

Para isso, na pasta de recursos , você pode ver um arquivo chamado application.properties .

Dentro do arquivo application.properties adicione esses detalhes. Como mencionei anteriormente aqui, usamos o MySQL como banco de dados. Aqui temos que especificar nosso nome de banco de dados, nome de usuário e senha .

spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url = jdbc:mysql://localhost:port/databasename
spring.datasource.username = username
spring.datasource.password = password
spring.jpa.show-sql = true
spring.jpa.hibernate.ddl-auto = update
spring.jpa.properties.hibernate.dialect = org.hibernate.dialect.MySQL5Dialect

      

Criando um modelo de aluno (modelo de domínio)

Agora vamos criar nosso modelo de aluno. Em primeiro lugar, vou criar um pacote para modelos. Dentro do pacote model, vou criar uma chamada de classe Student.java. Em seguida, adicione o seguinte código.

package com.example.demo.model;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import javax.persistence.*;
@Data
@AllArgsConstructor
@NoArgsConstructor
@Entity
@Table(name="student_tbl")
public class Student {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int id;
    private String name;
    private int age;
    private String city;
}

      

A @Entityanotação especifica que a classe é uma entidade e está mapeada para uma tabela de banco de dados. A @Tableanotação especifica o nome da tabela de banco de dados a ser usada para mapeamento. A @Idanotação especifica a chave primária de uma entidade e @GeneratedValueprevê a especificação de estratégias de geração para os valores das chaves primárias.

Criando classes de repositório (camada de persistência)

Nosso próximo passo é criar uma classe de repositório. @Repositoryé uma anotação Spring que indica que a classe decorada é um repositório. Um repositório é um mecanismo para encapsular armazenamento, recuperação e comportamento de pesquisa que emula uma coleção de objetos.

Em primeiro lugar, vou criar um pacote para classes de repositório. Dentro do pacote crie uma Interface chamada StudentRepository . Em seguida, adicione o seguinte código.

package com.example.demo.repository;
import com.example.demo.model.Student;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
@Repository
public interface StudentRepository extends JpaRepository<Student,Integer> {
}

      

JpaRepositoryé uma extensão específica do JPA do Repository. Ele contém a API completa de CrudRepositorye PagingAndSortingRepository. Portanto, contém API para operações básicas de CRUD e também API para paginação e classificação.

Criando um Serviço (Camada de Negócios)

Marcamos beans com @Service para indicar que está mantendo a lógica de negócios . Portanto, não há outra especialidade a não ser usá-la na camada de serviço.

Aqui vamos implementar as funções como Insert , retrieve , update e delete the Student records. Escrevemos a lógica de negócios no arquivo de classe de serviço.

Agora crie um pacote chamado service e sob o pacote de serviço crie uma classe chamada StudentService . Por fim, adicione o seguinte código dentro da classe StudentService.

package com.example.demo.service;
import com.example.demo.model.Student;
import com.example.demo.repository.StudentRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
@Service
public class StudentService {
    @Autowired
    private StudentRepository studentRepository;
    public Student addStudent(Student student){
        return studentRepository.save(student);
    }
    public List<Student> getStudents(){
        return studentRepository.findAll();
    }
    public Student getStudentById(int id){
        return studentRepository.findById(id).orElse(null);
    }
    public String deleteStudent(int id){
        studentRepository.deleteById(id);
        return "Student removed";
    }
    public Student updateStudent(Student student){
        Student existingStudent = studentRepository.findById(student.getId()).orElse(null);
        existingStudent.setName(student.getName());
        existingStudent.setAge(student.getAge());
        existingStudent.setCity(student.getCity());
        return studentRepository.save(existingStudent);
    }
}

      

Criando um controlador

O código abaixo mostra o arquivo da classe Rest Controller, aqui nós @Autowired a classe StudentService e chamamos os métodos para operações crud.

package com.example.demo.controller;
import com.example.demo.model.Student;
import com.example.demo.service.StudentService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.List;
@CrossOrigin("*")
@RequestMapping(value = "/api/students")
@RestController
public class StudentController {
    @Autowired
    private StudentService studentService;
    @PostMapping
    public Student addStudent(@RequestBody Student student){
        return studentService.addStudent(student);
    }
    @GetMapping
    public List<Student> getStudents(){
        return  studentService.getStudents();
    }
    @GetMapping("/{id}")
    public Student getStudentById(@PathVariable int id){
        return studentService.getStudentById(id);
    }
    @PutMapping
    public Student updateStudent(@RequestBody Student student){
        return studentService.updateStudent(student);
    }
    @DeleteMapping("/{id}")
    public String deleteStudent(@PathVariable int id){
        return studentService.deleteStudent(id);
    }

}

      

Ok, agora clique com o botão direito do mouse no arquivo DemoApplication.java e clique em Executar. Antes de executar o aplicativo, certifique-se de ter criado um banco de dados com o nome fornecido no arquivo application.properties. No meu caso demospringboot .

Se o aplicativo for iniciado com sucesso, você obterá uma saída como abaixo no console.

Então, se você verificou o banco de dados, poderá ver que a tabela_aluno foi criada.

Certo, agora estamos quase terminando. Agora podemos testar as APIs REST usando um software chamado Postman .

1.Inserir Registro do Aluno

2. Obter todos os alunos

3. Obtenha detalhes do aluno por ID

4.Atualizar Aluno

5. Excluir Aluno

Ok, este é o fim deste tutorial de inicialização de primavera. Aqui eu cobri as operações básicas de CRUD . Espero que hoje você tenha aprendido alguma coisa. Obrigada !.