使用GraphQL和SpringBoot构建员工管理系统

城里的月光
170 阅读3分钟

使用GraphQL和SpringBoot构建员工管理系统

在当今快速发展的技术环境中，高效的数据查询和操作至关重要。GraphQL是一种用于API的查询语言，它提供了一种更灵活、更强大的REST替代方案。当与SpringBoot（一种用于构建Java应用程序的流行框架）结合使用时，您将获得一个健壮且高效的数据管理系统。在本博客中，我们将介绍如何使用GraphQL和SpringBoot构建员工管理系统。

GraphQL是一种API查询语言，允许客户端准确请求所需的数据，使API快速灵活。它由Facebook开发，现在是一个开源项目。

SpringBoot是一个基于Java的开源框架，用于创建微服务。它易于设置并支持快速应用程序开发。

结合这两种技术，开发人员可以构建高效灵活的数据API。

设置项目

首先，确保您安装了必要的工具：

  • JDK 11或更高版本
  • Maven
  • IDE（IntelliJ IDEA、Eclipse等）

使用Spring Initializr（https：//start.spring.io/）创建一个新的SpringBoot项目：:)

  • 项目：Maven Project
  • 语言：Java
  • SpringBoot：最新稳定版本
  • 配置：Spring Web，Spring Data JPA，H2 Database，GraphQL SpringBootStarter

下载项目并将其导入IDE。

配置SpringBoot和GraphQL

在pom.xml文件中，确保包含以下依赖项：

<dependencies>
    <!-- Spring Boot dependencies -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <!-- H2 Database dependency -->
    <dependency>
        <groupId>com.h2database</groupId>
        <artifactId>h2</artifactId>
    </dependency>

    <!-- GraphQL dependencies -->
    <dependency>
        <groupId>com.graphql-java-kickstart</groupId>
        <artifactId>graphql-spring-boot-starter</artifactId>
    </dependency>
    <dependency>
        <groupId>com.graphql-java-kickstart</groupId>
        <artifactId>graphiql-spring-boot-starter</artifactId>
    </dependency>
</dependencies>

在src/main/resources/application.properties中配置数据库：

spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=password
spring.h2.console.enabled=true
spring.jpa.hibernate.ddl-auto=update

定义GraphQL Schema

创建目录src/main/resources/graphql并添加文件schema.graphqls：

type Query {
    getAllEmployees: [Employee]
    getEmployeeById(id: ID!): Employee
}

type Mutation {
    createEmployee(employeeInput: EmployeeInput): Employee
    updateEmployee(id: ID!, employeeInput: EmployeeInput): Employee
    deleteEmployee(id: ID!): Boolean
}

type Employee {
    id: ID!
    firstName: String!
    lastName: String!
    email: String!
    department: String!
}

input EmployeeInput {
    firstName: String!
    lastName: String!
    email: String!
    department: String!
}

创建员工实体

在Employee中定义src/main/java/com/example/employeemanagement/model/Employee.java实体：

package com.example.employeemanagement.model;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class Employee {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String firstName;
    private String lastName;
    private String email;
    private String department;

    // Getters and Setters
}

构建存储库层

在src/main/java/com/example/employeemanagement/repository/EmployeeRepository.java中创建存储库接口：

package com.example.employeemanagement.repository;

import com.example.employeemanagement.model.Employee;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface EmployeeRepository extends JpaRepository<Employee, Long> {
}

实现服务层

在src/main/java/com/example/employeemanagement/service/EmployeeService.java中创建服务类：

package com.example.employeemanagement.service;

import com.example.employeemanagement.model.Employee;
import com.example.employeemanagement.repository.EmployeeRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.Optional;

@Service
public class EmployeeService {

    @Autowired
    private EmployeeRepository employeeRepository;

    public List<Employee> getAllEmployees() {
        return employeeRepository.findAll();
    }

    public Optional<Employee> getEmployeeById(Long id) {
        return employeeRepository.findById(id);
    }

    public Employee createEmployee(Employee employee) {
        return employeeRepository.save(employee);
    }

    public Employee updateEmployee(Long id, Employee employeeDetails) {
        Employee employee = employeeRepository.findById(id).orElseThrow(() -> new RuntimeException("Employee not found"));

        employee.setFirstName(employeeDetails.getFirstName());
        employee.setLastName(employeeDetails.getLastName());
        employee.setEmail(employeeDetails.getEmail());
        employee.setDepartment(employeeDetails.getDepartment());

        return employeeRepository.save(employee);
    }

    public boolean deleteEmployee(Long id) {
        Employee employee = employeeRepository.findById(id).orElseThrow(() -> new RuntimeException("Employee not found"));
        employeeRepository.delete(employee);
        return true;
    }
}

开发GraphQL解析器

在src/main/java/com/example/employeemanagement/resolver中创建GraphQL解析器：

  1. 查询解析器
   package com.example.employeemanagement.resolver;

   import com.coxautodev.graphql.tools.GraphQLQueryResolver;
   import com.example.employeemanagement.model.Employee;
   import com.example.employeemanagement.service.EmployeeService;
   import org.springframework.beans.factory.annotation.Autowired;
   import org.springframework.stereotype.Component;

   import java.util.List;

   @Component
   public class Query implements GraphQLQueryResolver {

       @Autowired
       private EmployeeService employeeService;

       public List<Employee> getAllEmployees() {
           return employeeService.getAllEmployees();
       }

       public Employee getEmployeeById(Long id) {
           return employeeService.getEmployeeById(id).orElse(null);
       }
   }
  1. 突变解析器
   package com.example.employeemanagement.resolver;

   import com.coxautodev.graphql.tools.GraphQLMutationResolver;
   import com.example.employeemanagement.model.Employee;
   import com.example.employeemanagement.service.EmployeeService;
   import com.example.employeemanagement.input.EmployeeInput;
   import org.springframework.beans.factory.annotation.Autowired;
   import org.springframework.stereotype.Component;

   @Component
   public class Mutation implements GraphQLMutationResolver {

       @Autowired
       private EmployeeService employeeService;

       public Employee createEmployee(EmployeeInput employeeInput) {
           Employee employee = new Employee();
           employee.setFirstName(employeeInput.getFirstName());
           employee.setLastName(employeeInput.getLastName());
           employee.setEmail(employeeInput.getEmail());
           employee.setDepartment(employeeInput.getDepartment());
           return employeeService.createEmployee(employee);
       }

       public Employee updateEmployee(Long id, EmployeeInput employeeInput) {
           Employee employeeDetails = new Employee();
           employeeDetails.setFirstName(employeeInput.getFirstName());
           employeeDetails.setLastName(employeeInput.getLastName());
           employeeDetails.setEmail(employeeInput.getEmail());
           employeeDetails.setDepartment(employeeInput.getDepartment());
           return employeeService.updateEmployee(id, employeeDetails);
       }

       public boolean deleteEmployee(Long id) {
           return employeeService.deleteEmployee(id);
       }
   }
  1. 员工输入类
   package com.example.employeemanagement.input;

   public class EmployeeInput {

       private String firstName;
       private String lastName;
       private String email;
       private String department;

       // Getters and Setters
   }

测试API

使用IDE或在终端中执行mvn spring-boot:run来运行应用程序。

打开浏览器并导航到http://localhost:8080/graphiql以访问GraphiQL接口，用于测试GraphQL查询和突变。

样品编号：

  • 让所有员工

:

  query {
      getAllEmployees {
          id
          firstName
          lastName
          email
          department
      }
  }
  • 按ID获取员工：
  query {
      getEmployeeById(id: 1) {
          id
          firstName
          lastName
          email
          department
      }
  }

样本突变：

  • 创建员工：
  mutation {
      createEmployee(employeeInput: {
          firstName: "John"
          lastName: "Doe"
          email: "john.doe@example.com"
          department: "Engineering"
      }) {
          id
          firstName
          lastName
          email
          department
      }
  }
  • 更新员工：
  mutation {
      updateEmployee(id: 1, employeeInput: {
          firstName: "Jane"
          lastName: "Doe"
          email: "jane.doe@example.com"
          department: "HR"
      }) {
          id
          firstName
          lastName
          email
          department
      }
  }
  • 删除员工：
  mutation {
      deleteEmployee(id: 1)
  }

结论

在这篇博客中，我们介绍了如何使用GraphQL和SpringBoot构建员工管理系统。我们涵盖了设置项目、配置GraphQL、定义模式、创建实体、构建存储库和服务层、实现GraphQL解析器以及测试API。这种技术组合提供了一种强大而灵活的方式来处理现代应用程序中的数据。

avatar
文章
阅读
粉丝