# Make request: Spigot

## Example for making your first request

In this class, I will walk you through the process of utilizing **all four HTTP methods**. If you\
have prior experience with microservices or basic HTTP requests, the concepts should be straightforward to understand.

{% tabs %}
{% tab title="Make a request (Response)" %}
These methods direct requests to specific endpoints. The final step is to implement\
the logic for these methods within your microservice application.

{% code title="PlayerRepository.java" %}

```java
import micro.api.service.*;
import micro.api.payload.*;

public class PlayerRepository extends ServiceEndpoint {
   /**
    * This points to `http://localhost:5000/api/player`
    */
    public PlayerRepository(ServiceHost host) {
       super("/player", host);
    }

    /**
     * Example of GET request, get player's data.
     * @return a new PlayerClient object.
     */
    public PlayerClient loadPlayer(UUID uuid) {
        Query query = new Query();
        query.add("uuid", uuid.toString());

        return super.get("/load", PlayerClient.class, query);
    }
    
    /**
     * Example of POST request, add a new friend.
     * @return The updated PlayerClient object.
     */
    public PlayerClient addFriend(UUID uuid, UUID target) {
        Body body = new Body();
        body.add("uuid", uuid.toString());
        body.add("target", target.toString());

        return super.post("/friend_add", PlayerClient.class, body);
    }
    
    /**
     * Example of PUT request, update player's coins.
     * @return The updated PlayerClient object.
     */
    public PlayerClient updateCoins(UUID uuid, int amount) {
        Body body = new Body();
        body.add("uuid", uuid.toString());
        body.add("coins", amount);

        return super.put("/coin_update", PlayerClient.class, body);
    }
    
    /**
     * Example of DELETE request, delete player data.
     * @return The deleted PlayerClient object.
     */
    public PlayerClient deletePlayer(UUID uuid) {
        Query query = new Query();
        query.add("uuid", uuid.toString());
        
        return super.delete("/delete", PlayerClient.class, query);
    }
}
```

{% endcode %}
{% endtab %}

{% tab title="Make a request (No response)" %}
{% hint style="info" %}
**Information**

As you can tell in this class, there's **no** GET request example, because a GET request always returns a value or content of some sort, hence why it's called GET. 
{% endhint %}

This is the same class as the previous example, only this time we don't serialize the response into an object, we simply ask for the status code.

```java
import micro.api.service.*;
import micro.api.payload.*;

public class PlayerRepository extends ServiceEndpoint {
   /**
    * This points to `http://localhost:5000/api/player`
    */
    public PlayerRepository(ServiceHost host) {
       super("/player", host);
    }

    /**
     * Example of POST request, add a new friend.
     * @return A status code object of the request.
     */
    public ServiceResponse addFriend(UUID uuid, UUID target) {
        Body body = new Body();
        body.add("uuid", uuid.toString());
        body.add("target", target.toString());

        return super.post("/friend_add", body);
    }
    
    /**
     * Example of PUT request, update player's coins.
     * @return A status code object of the request.
     */
    public ServiceResponse updateCoins(UUID uuid, int amount) {
        Body body = new Body();
        body.add("uuid", uuid.toString());
        body.add("coins", amount);

        return super.put("/coin_update", body);
    }
    
    /**
     * Example of DELETE request, delete player data.
     * @return A status code object of the request.
     */
    public ServiceResponse deletePlayer(UUID uuid) {
        Query query = new Query();
        query.add("uuid", uuid.toString());
        
        return super.delete("/delete", query);
    }
}
```

\
As you can see in this example, instead of returning a serialized object, it returns an object with a status code of the request. The *ServiceResponse* is actually an enumerator which holds the most common status codes of a request;

```java
/**
 * Most common status codes in a microservice.
 */
public enum ServiceResponse {
    OK(200),
    Created(201),
    Accepted(202),
    NoContent(204),
    BadRequest(400),
    Unauthorized(401),
    Forbidden(403),
    NotFound(404),
    NotAllowed(405),
    Conflict(409),
    InternalServerError(500),
    NotImplemented(501),
    ServiceUnavailable(503),
    Unknown(-1);

    private final int code;

    ServiceResponse(int code) {
        this.code = code;
    }

    public int getStatusCode() {
        return code;
    }
}
```

{% endtab %}

{% tab title="PlayerClient.java" %}

<pre class="language-java" data-title="PlayerClient.java"><code class="lang-java">public class PlayerClient {
   /**
    * These fields will get initialized when
    * loading the player from the service.
    */
   private String uuid;
   private int level;
   private <a data-footnote-ref href="#user-content-fn-1">Rank</a> rank;
   private int coins;
   private List&#x3C;String> friends;

   public UUID getUUID() { 
      return UUID.fromString(uuid); 
   }

   public int getLevel() {
       return level;
   }

   public <a data-footnote-ref href="#user-content-fn-1">Rank</a> getRank() {
      return rank;
   }

   public int getCoins() {
      return coins;
   }
   
   public List&#x3C;String> getFriends() {
       return friends;
   }
}
</code></pre>

{% endtab %}
{% endtabs %}

[^1]: ```java
    public enum Rank {
        PLAYER,
        HELPER,
        MODERATOR,
        ADMIN,
        OWNER,
    }
    ```


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://walkinthepark.gitbook.io/microservice-api/reference/intro-making-requests/make-request-spigot.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.