Hello Spring

As with GET requests, we can use our local browser to make POST requests, a method that adds new data to a receiving web application. 

A common way to append data to an application is by submitting an HTML form. Let's say we want to add a new German Shepherd named "Charlie" to our list of dog intakes. We simply fill out a form that asks for the `name` of the pet ("Charlie") and `breed` ("German Shepherd"). After clicking the "submit" button, the browser sends a POST request with that data to the application. The Spring application then uses this inputted form data to create and add a new `dog` object to our existing `dogs` resource. 


Making POST Requests with a Web Browser

Alternatively, we can make GET requests using curl. Curl, short for Client for URLs, is a command line tool that allows us to transfer data to and from a server. It supports multiple protocols, including HTTP. You can read more about curl in our ["What is curl?"](https://www.codecademy.com/paths/create-rest-apis-with-spring-and-java/tracks/spring-apis-web-and-spring-basics/modules/how-spring-works/articles/what-is-curl-article) article.

Curl is also useful for testing HTTP request methods from your local command line. Let's say we want to test the HTTP endpoint `http://www.mypetclinic.com/dogs/`. We would use the curl command...

```
curl http://www.mypetclinic.com/dogs/
```

...which uses the GET request as the default method to retrieve the `dogs` resource from that URL; the `dogs` resource is displayed in the terminal rather than the browser. In doing so, we again confirm that our server is returning and displaying the information that we expect it to.


Making GET Requests with Curl

Well done! You've successfully used the Spring framework to handle HTTP requests (GET, POST, PUT, and DELETE), streamlining data transfer between the client application and a web server. 

In this lesson, we covered two different ways to make GET requests, an HTTP method that retrieves data from the server and sends it back to the application. 

1. Using the browser: type the URL `https://example.com/abc` into the address bar.  
2. Using curl: type `curl https://example.com/abc` into your local command line

In addition, we made POST requests, an HTTP method that adds new data to the web application. We can make POST requests using either curl or the browser. 

1. Using the browser: submit an HTML form that is setup to hit the `https://www.example.com/abc` endpoint.
2. Using curl: type `curl -X POST -d "{\"key1\":\"value1\", \"key2\":\"value2\"}" -H "Content-Type: application/json" https://example.com/abc` into the command line. 

Spring's ability to quickly and accurately respond to HTTP requests allows clients to easily manage, add, and delete data from their web applications. This functionality becomes especially useful when a client application is dealing with large amounts of information (e.g. when a large enterprise application is receiving millions of requests within a small time frame). By facilitating efficient interaction between client and server, the Spring framework enables us developers to easily build complex RESTful web apps with minimal effort and configuration.


Review

In addition, we can make POST requests using the curl command. Let's again imagine that we are adding Charlie the German Shepherd as a dog intake patient for our imaginary pet clinic. We would use this curl syntax: 

```
curl -X POST -d "{\"name\":\"Charlie\", \"breed\":\"German Shepherd\"}" -H "Content-Type: application/json" http://www.mypetclinic.com/dogs/ 
```

* `-X POST` tells the server that the client is making a POST request, where `-X` is the curl parameter specifying the type of request method to use. 
* `-d` (short for `--data`) indicates to the server that the client is sending new data to an existing application. 
* The content inside ` "{ }" `,  ` \"name\":\"Charlie\", \"breed\":\"German Shepherd\" ` , is the data that the client wants to send (as indicated by the preceding ` -d `). We use the `{\"key1\":\"value1\", \"key2\":\"value2\"}` syntax, where `name` and `breed` are the names of the two keys that define the dog object, and "Charlie" and "German Shepherd" are the values corresponding to those keys respectively. 
* ` -H "Content-Type: application/json"` specifies that we are sending data in JSON format. 
* Finally, the URL `http://www.mypetclinic.com/dogs/` tells the server where to send this new data. In this case, the newly-created `dog` object will be posted under the `dogs` resource.



Making POST Requests with Curl

Spring is an open-source Java framework that is useful, among other things, for building RESTful web applications. Like any web framework, Spring comes with an established set of code conventions and patterns, such as predefined templates, databases, and functions. These generic code conventions provide reusable infrastructural support, enabling developers to easily build a variety of applications without reinventing the wheel at the start of every project. Spring focuses on project "scaffolding" so that developers can concentrate on the core logic of applications (you can think of Spring as a Node.js, Django, or Ruby on Rails but for Java!).

Indeed, Spring contains templates for many different kinds of applications, or "Spring Projects", (including Spring Cloud, Spring Web Services, Spring Security, etc.). Spring Boot is one of the easiest ways to build Spring web projects, enabling applications to run with minimal configuration. Throughout this lesson we'll be using Spring Boot to build our own web apps. 

So how does a Spring web application actually work? The flow chart on the right shows the sequence of a typical HTTP GET request. 
1. The client sends a GET request to the Spring web server (i.e. the Spring application). 
2. The server sends a data request to the data store to retrieve the information requested by the client. 
3. The data store sends the requested data back to the server, if available.
4. The server sends that data -- the HTTP Response -- back to the client and displays it on the browser. 

It's important to note that this is just one scenario of a browser-based client initiating a GET request to retrieve some information from the data store. Depending on the application scenario, we might not always want or need to interact with the data store. For example, in the case of DELETE, it's possible that the data store won't return any data to the server. Moreover, a client is not limited to being the browser; a client can also be a desktop or mobile app, or tools and scripts. 

In the following exercises, we'll explore the basic functionality of the Spring framework by building a web app that responds to two common types of HTTP request methods: GET and POST. 

> For the purposes of this lesson, try to focus on the overall functionality of the Spring application (i.e. the backend operations by which the Spring server/application responds to requests) and how to interact with it (i.e. how the user sends requests to the Spring server/application). Don't worry about the exact syntax of the code: we'll provide you with everything you need to copy-and-paste into the workspace. 

Let's get started! 


1 Browser sends HTTP request to web server. 2 Web server sends data request to database. 3 Database sends data response to web server. 4 Web server sends HTTP response to browser

What is Spring?

Like any web framework that uses HTTP, Spring enables us to respond to GET requests, a method that retrieves the requested information from the server. That information is relayed back to the client and displayed on the browser. Whenever a user navigates to a website or clicks on a URL link, for example, they are initiating a GET request. 

Let’s take a look at an example. Imagine we are working with an online system that is keeping track of dog patient intakes for a pet clinic. The website address is `http://www.mypetclinic.com/dogs/ `, where `dogs` is the resource containing a list of `dog` objects. In REST environments, the client can access the `dogs` resource through this GET request: 

```
GET http://www.mypetclinic.com/dogs/ 
```


The server, upon receiving this GET request, should return a response that looks something like this: 

```
{
  "dogs": [
    {
      "id": 1,
      "name": "Bella",
      "breed": "Golden Retriever"
    },
    {
      "id": 2,
      "name": "Max",
      "breed": "Bulldog"
    },
    {
      "id": 3,
      "name": "Ruby",
      "breed": "Poodle"
    },
  ]
}
```

One common way to send a GET request is by typing the URL -- the HTTP endpoint --  into your local web browser. For example, when a user types `http://www.mypetclinic.com/dogs/` into the address bar, the browser

1. Makes a GET request (`GET http://www.mypetclinic.com/dogs/`) that retrieves the `dogs` resource (i.e. the file containing the list of dog intakes) and
2. Displays the response on the browser page. In doing so, the user confirms that the HTTP endpoint is working -- that the GET request is retrieving the requested resources from the Spring server.