Wprowadzenie do GraphQL z użyciem Spring Boot


Wprowadzenie do GraphQL z użyciem Spring Boot

GraphQL to sposób komunikowania się z API jako alternatywna dla stylu REST. W przypadku RESTa mamy dużą liczbę adresów (z ang. endpoint’s) gdzie każdy ma obsługę zapytań CRUD. Kiedy projekt się rozrasta liczba tych adresów rośnie. GraphQL eliminuje ten problem. Mamy jeden adres – endpoint i od konstrukcji zapytania do API zależy to co zostanie zwrócone/zrealizowane. Z artykułu dowiesz się w jaki sposób zaprojektować swoje pierwsze API z użyciem techniki GraphQL. Do dzieła! Tworzymy n0wy projekt Spring Boota.

Plik pom.xml:

<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.graphql-java</groupId>
        <artifactId>graphql-spring-boot-starter</artifactId>
        <version>5.0.2</version>
    </dependency>
    <dependency>
        <groupId>com.graphql-java</groupId>
        <artifactId>graphql-java-tools</artifactId>
        <version>5.2.4</version>
    </dependency>
    <dependency>
        <groupId>com.graphql-java</groupId>
        <artifactId>graphiql-spring-boot-starter</artifactId>
        <version>5.0.2</version>
    </dependency>
    <dependency>
        <groupId>com.h2database</groupId>
        <artifactId>h2</artifactId>
        <scope>runtime</scope>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.8</version>
        <optional>true</optional>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
        <exclusions>
            <exclusion>
                <groupId>org.junit.vintage</groupId>
                <artifactId>junit-vintage-engine</artifactId>
            </exclusion>
        </exclusions>
    </dependency>
</dependencies>

Klasa modelu – User.java:

@Data
@EqualsAndHashCode
@Entity
public class User {
 
    private static final long serialVersionUID = 1L;
 
    @Id
    @Column(name = "ID", nullable = false)
    @GeneratedValue(strategy = GenerationType.AUTO)
    private int id;
 
    @Column(name = "name", nullable = false)
    private String name;
 
    @Column(name = "surname", nullable = false)
    private String surname;
}

repozytorium do operacji na danych – UserRepository.java:

@Repository
public interface UserRepository extends JpaRepository<User, Integer> {
}

Plik src\main\resources\graphql\user.graphqls – katalog graphql należy utworzyć:

type User {
    id: ID!,
    name: String,
    surname: String,
}
 
type Query {
    users(count: Int):[User]
    user(id: ID):User
}
 
type Mutation {
    createUser(name: String!, surname: String!):User
}

gdzie:

Query – typ służy do zapytań zwracających dane,

Mutation – typ służyt do zapisu danych.

Klasa serwisu:

@Service
public class UserService {
 
    private final UserRepository userRepository ;
 
    public UserService(final UserRepository userRepository) {
        this.userRepository = userRepository ;
    }
 
    @Transactional
    public User createUser(final String name,final String surname) {
        final User user = new User();
        user.setName(name);
        user.setSurname(surname);
        return this.userRepository.save(user);
    }
 
    @Transactional(readOnly = true)
    public List<User> gelAllUsers(final int count) {
        return this.userRepository.findAll().stream().limit(count).collect(Collectors.toList());
    }
 
    @Transactional(readOnly = true)
    public Optional<User> getUser(final int id) {
        return this.userRepository.findById(id);
    }
}

Klasa UserQuery – wyświetlanie użytkowników:

@Component
public class UserQuery implements GraphQLQueryResolver {
 
    @Autowired
    private UserService userService;
 
    public List<User> getUsers(final int count) {
        return this.userService.gelAllUsers(count);
    }
 
    public Optional<User> getUser(final int id) {
        return this.userService.getUser(id);
    }
}

Klasa UserMutation – zapis użytkowników:

@Component
public class UserMutation implements GraphQLMutationResolver {
 
    @Autowired
    private UserService userService;
 
    public User createUser(final String name, final String surname) {
        return this.userService.createUser(name, surname);
    }
}

po uruchomieniu aplikacji pod adresem:

http://localhost:8080/graphiql

znajduje się interfejs graficzny do wykonywania operacji GraphQL.Wykonujemy pierwsze zapytanie które utworzy nowego użytkownika i przypisze mu unikalny identyfikator – id:

mutation {
  createUser(name: "Java", surname: "Leader") 
  {
    id
  }
}

wynik to:

{
  "data": {
    "createUser": {
      "id": "1"
    }
  }
}

wykonujemy drugie zapytanie które wyświetli użytkowników:

query {
  users(count: 1) 
  {
    id, 
    name, 
    surname
  }
}

wynik to:

{
  "data": {
    "users": [
      {
        "id": "1",
        "name": "Java",
        "surname": "Leader"
      }
    ]
  }
}

Zobacz kod na GitHubie i zapisz się na bezpłatny newsletter!

.


Leave a comment

Your email address will not be published.


*