{"id":96260,"date":"2020-10-26T11:00:00","date_gmt":"2020-10-26T09:00:00","guid":{"rendered":"https:\/\/examples.javacodegeeks.com\/?p=96260"},"modified":"2022-07-07T15:20:19","modified_gmt":"2022-07-07T12:20:19","slug":"java-api-tutorial","status":"publish","type":"post","link":"https:\/\/examples.javacodegeeks.com\/java-api-tutorial\/","title":{"rendered":"Java API Tutorial"},"content":{"rendered":"

In this article, we will learn about Java API and working with Java API. We will discuss different types of API requests and what does REST API mean. We will also see an example of a REST API.<\/p>\n

You can also check this tutorial in the following video:<\/p>\n

\n
\"\"<\/a>
Java Web Services Tutorial – video<\/figcaption><\/figure>\n<\/div>\n

1. Java API<\/h2>\n

An API stands for Application Programming Interface, and it is an interface that allows communication between different applications using the packages it comprises. Java API comprises a collection of interfaces, classes, and packages. It helps us to use the packaged classes and interfaces to build our applications and supports reusability. Whenever we write any program in java, we use the Java API to do so. For example, we use JDBC API in java to connect to any database server to perform several transactions using java.<\/p>\n

2. How to use an API with Java<\/h2>\n

In Java, we use API to access other software applications and build java API’s to allow other systems to access our resources. In other words, we can either create a client for an existing API or an API service to be used by others.<\/p>\n

2.1 As a Client(as an API consumer)<\/h3>\n

If we want to access an API, we build a java API client for accessing the API based on the rules and controls provided by the API developer. We can access resources that we want from another system using the API exposed\/provided by the other system.<\/p>\n

2.2 As an API provider<\/h3>\n

We create an API so that the other system can access our resources via the API exposed\/provided by us. To access our API, they have to follow the standards and rules set up and build an API client.<\/p>\n

3. Types of API Requests<\/h2>\n

There are various kinds of API request based on the operation need to be performed. The most commonly used APIs requests are <\/p>\n

3.1 GET<\/h3>\n

GET is the most commonly used request and is used to get any resource from the server using an API. When a user requests an API using GET, the server returns the user’s data if it is available on the server.<\/p>\n

3.2 POST <\/h3>\n

This request type adds or posts any new data to the server. When a user requests an API using POST, the server adds the data into its resource and returns the status of whether the posting was a success or a failure.<\/p>\n

3.3 PUT<\/h3>\n

This request type updates\/modifies the data on the server. When a user requests an API using PUT, then the server updates the data into its resource and returns the status whether the update was a success or a failure.<\/p>\n

3.4 DELETE<\/h3>\n

This request type deletes the data from the server. When a user requests an API using DELETE, then the server removes the data from the resource and returns the status of whether the delete was successful or a failure.<\/p>\n

4. What does REST mean<\/h2>\n

REST stands for Representational State Transfer, and it’s an architectural pattern that defines a set of rules for developing web-services. And the web services built using these constraints are called Restful web service.
Rest APIs deal with client-server architecture and are stateless, meaning the server doesn’t store states, and each request is separate and independent.

<\/div> <\/div><\/p>\n

5. Simple API in java<\/h2>\n

We can create a REST API in java using several ways. And one of the most common way to create the java REST API is using Jersey. Follow the steps below to create the simple REST API<\/p>\n

5.1 Creating the web project with maven<\/h3>\n

The first step for creating any application is to have a project. You can do that using any IDE(Integrated Development Tool). I will show the sample using the IntelliJ Idea IDE. You can choose any other as well like one of the alternatives is Eclipse IDE. After creating the maven project, please add the below code into your pom.xml file to get the required dependencies.<\/p>\n

Maven dependencies in pom.xml file<\/em><\/span><\/p>\n

<project xmlns=\"http:\/\/maven.apache.org\/POM\/4.0.0\" xmlns:xsi=\"http:\/\/www.w3.org\/2001\/XMLSchema-instance\"\n  xsi:schemaLocation=\"http:\/\/maven.apache.org\/POM\/4.0.0 http:\/\/maven.apache.org\/maven-v4_0_0.xsd\">\n  <modelVersion>4.0.0<\/modelVersion>\n\n  <groupId>demo.jcg.restapi<\/groupId>\n  <artifactId>demoRestAPI<\/artifactId>\n  <packaging>war<\/packaging>\n  <version>1.0-SNAPSHOT<\/version>\n  <name>demoRestAPI<\/name>\n\n  <url>http:\/\/maven.apache.org<\/url>\n  <repositories>\n\t\t<repository>\n\t\t\t<id>maven2-repository.java.net<\/id>\n\t\t\t<name>Java.net Repository for Maven<\/name>\n\t\t\t<url>http:\/\/download.java.net\/maven\/2\/<\/url>\n\t\t\t<layout>default<\/layout>\n\t\t<\/repository>\n\t<\/repositories>\n  <dependencies>\n    <dependency>\n\t\t<groupId>com.sun.jersey<\/groupId>\n\t\t<artifactId>jersey-server<\/artifactId>\n\t\t<version>1.19.4<\/version>\n\t<\/dependency>\n\t<dependency>\n\t\t<groupId>com.sun.jersey<\/groupId>\n\t\t<artifactId>jersey-core<\/artifactId>\n\t\t<version>1.19.4<\/version>\n\t<\/dependency>\n\t<dependency>\n\t\t<groupId>com.sun.jersey<\/groupId>\n\t\t<artifactId>jersey-servlet<\/artifactId>\n\t\t<version>1.19.4<\/version>\n\t<\/dependency>\n  <\/dependencies>\n  \n  <build>\n    <finalName>demoRestAPI<\/finalName>\n\t    <plugins>\n\t\t    <plugin>\n\t\t      <artifactId>maven-compiler-plugin<\/artifactId>\n\t\t        <configuration>\n\t\t          <source>1.8<\/source>\n\t\t          <target>1.8<\/target>\n\t\t        <\/configuration>\n\t\t    <\/plugin>\n\t  <\/plugins>\n  <\/build>\n<\/project>\n\n<\/pre>\n
With the above configuration, your project will have all the dependencies to create a REST API. <\/p>\n
5.2 Creating the java rest service class<\/h3>\n
After having all the dependencies setup, we need to create the rest service class where we will write our API. Have a look into the code below<\/p>\n
Rest service class<\/em><\/span><\/p>\n
package demo.jcg.restapi;\n\nimport javax.ws.rs.GET;\nimport javax.ws.rs.Path;\nimport javax.ws.rs.PathParam;\n\n@Path(\"\/demo\")\npublic class RestAPIDemo\n{\n\t@GET\n\t@Path(\"\/{name}\")\n\tpublic String greetings(@PathParam(\"name\") String name)\n\t{\n\t\treturn  name.toUpperCase()+ \", from Java Code Geeks\";\n\t}\n}\n\n<\/pre>\n
Now let’s understand the class above, here the class RestAPIDemo is has used certain annotations which are<\/p>\n
@Path: This annotation makes your API’s path into the server resource, i.e. specifies the URI using which this API can be accessed.<\/p>\n
@GET:  This annotation specifies the type of request that can be made to this method. As discussed above GET is used to get some resource from the REST API<\/p>\n
@PathParam: This annotation tells that the URI path contains a parameter that needs to be passed when accessing this API resource.<\/p>\n
In the above program, we are exposing a GET method through our REST API, where the user will access the API by passing the name in the path param. They get the name appended with the greeting. For example “Shankar, from Java Code Geeks”. All the annotations are coming from the Jersey API library used.<\/p>\n
5.3 Configuring the web.xml<\/h3>\n
Now the final step before we can deploy our REST API, we need to do the configuration for our web.xml as shown below<\/p>\n
Configuration for web.xml<\/em><\/span><\/p>\n
<!DOCTYPE web-app PUBLIC\n \"-\/\/Sun Microsystems, Inc.\/\/DTD Web Application 2.3\/\/EN\"\n \"http:\/\/java.sun.com\/dtd\/web-app_2_3.dtd\" >\n\n<web-app>\n\n  <display-name>Archetype Created Web Application<\/display-name>\n  \n  <servlet>\n\t\t<servlet-name>jersey-serlvet<\/servlet-name>\n\t\t<servlet-class>com.sun.jersey.spi.container.servlet.ServletContainer<\/servlet-class>\n\t\t<init-param>\n\t\t     <param-name>com.sun.jersey.config.property.packages<\/param-name>\n\t\t     <param-value>demo.jcg.restapi<\/param-value>\n\t\t<\/init-param>\n\t\t<load-on-startup>1<\/load-on-startup>\n\t<\/servlet>\n \n\t<servlet-mapping>\n\t\t<servlet-name>jersey-serlvet<\/servlet-name>\n\t\t<url-pattern>\/*<\/url-pattern>\n\t<\/servlet-mapping>\n\t\n<\/web-app>\n\n<\/pre>\n
In the above web.xml file, we have to make sure that our servlet is added as Jersey’s servlet container within the servlet-class tags.<\/p>\n
\n
\ncom.sun.jersey.spi.container.servlet.ServletContainer\n<\/pre>\n<\/div>\n
5.4 Deploying our application<\/h3>\n
The final step to make our REST API running is to deploy the application into a server to serve the request made to this API.<\/p>\n
Adding a server in an IDE is very simple. For the above example, we use Apache Tomcat and then deploy the rest API into the server.<\/p>\n
Note: If you cannot add the server into the IDE due to some issues. We can directly place our war(Web-Archive) file inside the web apps folder of your tomcat server home directory. The war file is inside the target directory of our project.<\/p>\n
You can download the tomcat server here<\/a><\/p>\n
Check the final project structure of the project structure below<\/p>\n
\"\"
Project structure of the REST API<\/figcaption><\/figure>\n
5.5 Testing your application<\/h3>\n
Once deployed, we can test our REST API in any browser using the URL http:\/\/localhost:8080\/demo\/Shankar. As we saw in the rest service class, the path “demo” is part of the REST API URL. The output is<\/p>\n
\"\"
Output of the rest call<\/figcaption><\/figure>\n
6. Summary<\/h2>\n
In this article, we saw what Java API is, how we can use APIs with Java. We looked at the different types of API requests and discussed the REST API. We also created a sample REST API and tested it.<\/p>\n
7. More articles<\/h2>\n