Merhaba değerli Java dostları,

Bu yazımda yeni bir kategori olan Rest servis hakkında yazmak istiyorum. Öncelikle Rest servislerin popüler olmasının nedenleri, avantajları, dezavantajları gibi konulara hiç girmek istemiyorum. Bu konuyu merak eden arkadaşlarımız buradaki linkten detayları öğrenebilirler. Detaylara girmek istemeyeşimin nedeni bazı konuları buraya uzun uzadıya yazarak sizleri boğmak istemiyorum, bundan dolayı direkt örnek kodumuza geçiyorum.

Öncelikle iki projemiz olduğunu belirteyim. Rest bir web servis olduğu için olayın bir server bir de client tarafı olduğunu belirteyim. Önce server tarafı. Örnek kodlarımzda basit bir veri işleme servisi sunuyoruz. Önce bean sınıfı.

package anajavatica.rest.controller;

import java.io.Serializable;

public class Developer implements Serializable {

private static final long serialVersionUID = 1L;
private String name = “”;
private String language = “”;

public Developer(String name, String language) {
super();
this.name = name;
this.language = language;
}

public String getName() {
return name;
}

public String getLanguage() {
return language;
}

public void setName(String name) {
this.name = name;
}

public void setLanguage(String language) {
this.language = language;
}

@Override
public String toString() {
return “Developer: ” + getName() + “, ” + getLanguage();
}

}

Şimdi de verileri işleyen controller sınıfı. Bu sınıfı gerçekten veritabanı üzerinde çalışan veya veri üreten, işleyen bir sınıf olarakda düşünebiliriz.

package anajavatica.rest.controller;

import java.util.ArrayList;
import java.util.List;

public class RestServiceController {

private List developerList = new ArrayList<>();

public List getDeveloperList() {
return developerList;
}

public Developer getDeveloper(String name, String language) {
for (Developer d : getDeveloperList()) {
if (d.getName().equals(name) && d.getLanguage().equals(language))
return d;
}
return null;
}

public boolean addDeveloper(Developer developer) {
boolean result = true;
for (Developer d : getDeveloperList()) {
if (d.getName().equals(developer.getName()) && d.getLanguage().equals(developer.getLanguage())) {
result = false;
break;
}
}
if (result)
getDeveloperList().add(developer);
return result;
}

public boolean updateDeveloper(Developer developer) {
boolean result = false;
for (int i = 0; i < getDeveloperList().size(); i++) {
Developer d = getDeveloperList().get(i);
if (d.getName().equals(developer.getName())) {
getDeveloperList().set(i, developer);
result = true;
break;
}
}
return result;
}

}

Controller sınıfı üzerinde tamamen önyüzden bağımsız olarak çalışıyoruz. Böylece tarın rest yerine başka bir haberleşme şekli kullandığımızda kolaylıkla adapte edebileceğiz. Şimdi de rest servisi sağlayan sınıfımız.

 

package anajavatica.rest;

import javax.ws.rs.Consumes;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.PUT;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;

import anajavatica.rest.controller.Developer;
import anajavatica.rest.controller.RestServiceController;

@Produces(MediaType.APPLICATION_JSON)
@Consumes(MediaType.APPLICATION_JSON)
@Path(“/developerRestService”)
public class RestService {

private RestServiceController controller = new RestServiceController();

@GET
@Produces(MediaType.APPLICATION_JSON)
public int getAllDevelopers() {
return getController().getDeveloperList().size();
}

@GET
@Path(“getDeveloper/{name}/{language}”)
public Developer getDeveloper(@PathParam(“name”) String name, @PathParam(“language”) String language) {
return getController().getDeveloper(name, language);
}

@POST
public boolean addDeveloper(Developer developer) {
return getController().addDeveloper(developer);
}

@PUT
public boolean updateDeveloper(Developer developer) {
return getController().updateDeveloper(developer);
}

private RestServiceController getController() {
return controller;
}

}

Şimdi biraz detaya dalma zamanı. @Produces ve @Consumes annotationları ile bu sınıfın hangi tipte veri kabul ettiğini ve hangi tipte veri döndürdüğünü belirtiyoruz. Biz burada JSON formatı üzerinden ilerliyoruz. Envai çeşit tipten birisini seçebilirsiniz. @Path ile mevcut URI’ ye ek olarak hangi yolun ekleneceğini belirtiyoruz. Böylece bu sınıfa daha doğrusu bu sınıfın sunduğu servise ulaşmak için hangi pathin kullanılacağı ortaya çıkıyor. @GET, klasik HTTP GET işleminin karşılığını veriyor. getDeveloper metodu da @GET yöntemi ile çalışıyor; fakat getAllDevelopers metodundan farklı olarak bir @PATH alıyor ve iki tane de @PathParam alıyor. Böylece URI üzerinden göndereceğimiz değerler parametre olarak okunabiliyor. @POST ve @PUT metotları yine klasik HTTP POST ve HTTP PUT metotlarına karşılık geliyor.

Aslında rest servisin Java kodu tarafında gerekli tüm işlemleri yerine getirdik; ama siz buradaki kodları olduğu gibi kullandığınızda muhtemelen hatalar alacaksınız. Bazı kütüphaneleri indirmeniz gerekiyor. Ben bu örneği yaparken maven kullandım ve aşağıdaki kütüphaneleri indirdim.

 <dependency>
<groupId>javax.ws.rs</groupId>
<artifactId>javax.ws.rs-api</artifactId>
<version>2.0</version>
</dependency><dependency>
<groupId>org.glassfish.jersey.containers</groupId>
<artifactId>jersey-container-servlet-core</artifactId>
<version>2.22.2</version>
</dependency><dependency>
<groupId>org.glassfish.jersey.media</groupId>
<artifactId>jersey-media-json-jackson</artifactId>
<version>2.22.2</version>
</dependency>

Bunun yanı sıra web.xml üzerinde de bazı eklemeler yapmamız lazım.

 

 <servlet>
<servlet-name>Jersey RESTful Application</servlet-name>
<servlet-class>org.glassfish.jersey.servlet.ServletContainer</servlet-class>
<init-param>
<param-name>jersey.config.server.provider.packages</param-name>
<param-value>anajavatica.rest</param-value>
</init-param>
</servlet>
<servlet-mapping>
<servlet-name>Jersey RESTful Application</servlet-name>
<url-pattern>/rest/*</url-pattern>
</servlet-mapping>

Böylece örneğimizin server tarafı tamamlanmış oldu. Şimdi sıra geldi client tarafına. Önce gerekli kütüphanelere bakalım.

 

 <dependency>
<groupId>javax.ws.rs</groupId>
<artifactId>javax.ws.rs-api</artifactId>
<version>2.0</version>
</dependency><dependency>
<groupId>org.glassfish.jersey.core</groupId>
<artifactId>jersey-client</artifactId>
<version>2.22.2</version>
</dependency>

<dependency>
<groupId>org.glassfish.jersey.media</groupId>
<artifactId>jersey-media-json-jackson</artifactId>
<version>2.22.2</version>
</dependency>

 

Şimdi de rest servisleri çağıracak client main sınıfımız.

 

import java.net.MalformedURLException;

import javax.ws.rs.client.Client;
import javax.ws.rs.client.ClientBuilder;
import javax.ws.rs.client.Entity;
import javax.ws.rs.client.Invocation;
import javax.ws.rs.client.WebTarget;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;

import anajavatica.rest.controller.Developer;

public class RestServiceClient {

private Client buildClient() {
Client client = ClientBuilder.newClient();
client.register(com.fasterxml.jackson.jaxrs.json.JacksonJaxbJsonProvider.class);
return client;
}

public void addDeveloper() throws MalformedURLException {
Client client = buildClient();
WebTarget target = client.target(“http://localhost:8080/AnaJavaticaRestWeb/rest/developerRestService/”);
Developer newDeveloper = new Developer(“Developer1”, “Java”);
Invocation.Builder builderLogin = target.request(MediaType.APPLICATION_JSON);
Response response = builderLogin.post(Entity.json(newDeveloper));
System.out.println(“addDeveloper: ” + response.readEntity(Boolean.class));
}

public void updateDeveloper() throws MalformedURLException {
Client client = buildClient();
WebTarget target = client.target(“http://localhost:8080/AnaJavaticaRestWeb/rest/developerRestService/”);
Developer updateDeveloper = new Developer(“Developer1”, “JavaFX”);
Invocation.Builder builderLogin = target.request(MediaType.APPLICATION_JSON);
Response response = builderLogin.put(Entity.json(updateDeveloper));
System.out.println(“updateDeveloper: ” + response.readEntity(Boolean.class));
}

public void getAllDevelopers() throws MalformedURLException {
Client client = buildClient();
WebTarget target = client.target(“http://localhost:8080/AnaJavaticaRestWeb/rest/developerRestService/”);
Invocation.Builder builderLogin = target.request(MediaType.APPLICATION_JSON);
Response response = builderLogin.get();
Integer allDeveloperListSize = response.readEntity(Integer.class);
System.out.println(allDeveloperListSize);
}

public void getDeveloper() throws MalformedURLException {
Client client = buildClient();
WebTarget target = client.target(“http://localhost:8080/AnaJavaticaRestWeb/rest/developerRestService/”)
.path(“/getDeveloper/Developer2/Delphi”);
Invocation.Builder builderLogin = target.request(MediaType.APPLICATION_JSON);
Developer developer = builderLogin.get(Developer.class);
if (developer != null)
System.out.println(“getDeveloper: ” + developer.toString());
else
System.out.println(“Developer is not exist!”);
}

public static void main(String[] args) throws MalformedURLException {

RestServiceClient restClient = new RestServiceClient();
restClient.addDeveloper();
restClient.getAllDevelopers();
restClient.updateDeveloper();
restClient.getDeveloper();

}

}

Burada her rest servis metoduna karşılık bir client metodu oluşturduk. Bazı önemli noktalar şunlar; hangi URI kullanılacak, request tipi, post, put, get metotları ve dönüş değerleri.

Umarım yeni kategorimin ilk yazısı biraz da olsa faydalı olmuştur.

Bol Java’ lı günler dileğiyle… 🙂

Categories:

No responses yet

Bir cevap yazın

E-posta hesabınız yayımlanmayacak.