Forem: Özgür Akıncı

Spring Boot SwaggerUI 2 Entegrasyonu

Özgür Akıncı — Wed, 19 Jan 2022 14:04:19 +0000

Swagger nedir?
API methodlarının dokumante edilmesine olanak sağlayan bir rest api arayüzüdür.

Spring Boot SwaggerUI Etegrasyonu

pom.xml

<dependency>
    <groupId>io.springfox</groupId>
    <artifactId>springfox-swagger2</artifactId>
    <version>3.0.0</version>
</dependency>

<dependency>
    <groupId>io.springfox</groupId>
    <artifactId>springfox-swagger-ui</artifactId>
    <version>2.9.2</version>
</dependency>

SpringSwaggerConfig.java

package com.app.learn_spring;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import springfox.documentation.builders.ApiInfoBuilder;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;

@Configuration
@EnableSwagger2
public class SpringSwaggerConfig {
    @Bean
    public Docket api() {
        return new Docket(DocumentationType.SWAGGER_2)
                .select()
                .apis(RequestHandlerSelectors.basePackage("com.app.learn_spring"))
                .paths(PathSelectors.any())
                .build().apiInfo(apiEndPointsInfo());

    }
    private ApiInfo apiEndPointsInfo() {
        return new ApiInfoBuilder().title("Spring Swagger API Documentation")
                .description("Spring Swagger API Documentation")
                .build();
    }
}

application.properties

spring.mvc.pathmatch.matching-strategy=ant-path-matcher

Örnek Rest Controller

package com.app.learn_spring.controller;

import io.swagger.annotations.Api;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

@RestController
@Api(value = "CustomController Api Doc")
public class CustomController {

    @RequestMapping(value = "/post_method_example", method = RequestMethod.POST)
    public String post() {
        return "post";
    }

    @RequestMapping(value = "/get_method_example", method = RequestMethod.GET)
    public String get() {
        return "get";
    }

    @RequestMapping(value = "/put_method_example", method = RequestMethod.PUT)
    public String put() {
        return "put";
    }

    @RequestMapping(value = "/delete_method_example", method = RequestMethod.DELETE)
    public String delete() {
        return "delete";
    }
}

Uygulama Görseli (http://localhost:8080/swagger-ui.html/)

Java Thread Sınıfı

Özgür Akıncı — Wed, 19 Jan 2022 09:48:50 +0000

Thread yapısı, aynı anda ve birbirini beklemeden birden çok işin gerçekleşebildiği yapıdır.

Thread oluştururken, java'da thread sınıfı extend edilebilir ya da runnable implementasyonu tercih edilebilir.

Java'da sadece bir sınıf extend edilebildiği ve daha fazla esneklik sağlamak için runnable implementasyonu daha avantajlıdır.

Önemli tanımlar
Runnable: Thread tanımlarının ne yapması gerektiğini açıklayan bir arayüzdür.
Run: Ana thread bekleme yaparak, diğer thread'ler çalışır.
Start: Ana thread bekleme yapmadan, diğer threadler ile birlikte çalışır.
Join: Mevcut thread işini bitirmeden, diğer thread işine başlayamaz.,
Synchronized: Method'a ulaşmak isteyen threadler method'a sıra ile girerler ve bir thread method'u bitirmeden diğer thread başlayamaz. (Kilitleme mekanizması vardır. Özetle, thread'ler birbirlerinin üstüne basmazlar)

Örnek Uygulama 1

package com.app.thread;
import java.util.List;

public class ThreadExample extends Thread implements Runnable{
    private List<Integer> v;
    public Integer sum = 0;

    public ThreadExample(List<Integer> p) {
        this.v = p;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + " started..");
        // Kilit mekanızması ihtiyaç dahilinde kullanılmalıdır.
        // Bu örnekte ihtiyaç yoktur.
        //synchronized(this) {
         for (Integer i : v) {
           sum += i;
         }
         System.out.println(Thread.currentThread().getName() + " => The sum: " + sum);
        //}
    }
    public Integer getSum() {
        return sum;
    }
}

package com.app.thread;

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

public class Main{
    public static void main(String[] args) {
        List<Integer> v = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8));
        List<ThreadExample> allThreads = new ArrayList<>();

        int threadCount = 3; int totalSum = 0; int startIndex = 0;
        // Her bir thread ne kadarlık iş yapacak.
        int perCountOfThread = v.size() / threadCount + ((v.size() % threadCount == 0) ? 0 : 1);

        // Belirlenen dinamik thread sayısı kadar thread başlatılıyor.
        for(int i=1; i<=threadCount; i++) {
            int lastIndex = Math.min((startIndex + perCountOfThread), v.size());
            ThreadExample thread = new ThreadExample(v.subList(startIndex, lastIndex));
            thread.start();
            // Başlatılan tüm threadleri bir listeye alıyoruz.
            allThreads.add(thread);
            startIndex = startIndex+perCountOfThread;
        }

        // İşini bitiren threadleri bir listeye alınıyor.
        // Sonuçlar ana thread tarafından toplanıyor.
        List<String> completedThread = new ArrayList<>();
        while (completedThread.size() != threadCount) {
            for (ThreadExample tempThread : allThreads) {
                if (!tempThread.isAlive() && !completedThread.contains(tempThread.getName())) {
                    totalSum += tempThread.getSum();
                    completedThread.add(tempThread.getName());
                }
            }
        }

        System.out.println(Thread.currentThread().getName() + " => The sum: " + totalSum);
    }
}

Program Çıktısı

Not: Thread.join(), iş parçacığının tamamen bitmesini beklerken, iki iş parçacığının aynı anda aynı kod parçasını yürütmesini önlemek için synchronized bir blok kullanılabilir.

Örnek Uygulama 2

package com.app.thread;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Main{
    public static void main(String[] args){
        List<Integer> v = new ArrayList<>(Arrays.asList(1, 2, 3,4));

        ThreadExample thread1 = new ThreadExample(v);
        ThreadExample thread2 = new ThreadExample(v);

        try {
            thread1.start();
            thread1.join(); // thread2 çalışabilmek için bekleyecektir.
            thread2.start();
            thread2.join(); // main thread çalışabilmek için bekleyecektir.
           // start yerine run kullanılırsa, 
           // main thread 2 numaralı thread'i beklemeyecek 
           // böylece thread2.join() satırına ihtiyaç duyulmayacaktır. 
        }catch (InterruptedException e) {
            System.out.println(e.getMessage());
        }

        Integer totalSum = thread1.getSum() + thread2.getSum();
        System.out.println(Thread.currentThread().getName() + " => The sum: " + totalSum);
    }
}

Program Çıktısı

Java Main Method ve “Merhaba Dünya”

Özgür Akıncı — Tue, 18 Jan 2022 12:28:24 +0000

JVM tarafından bir Java uygulamasının çalışabilmesi için “main methodunun” olması zorunlu kılınmıştır.

Main method’unun temel özellikleri

Public olmalıdır.
Method adı “main” olmalıdır.
Static olmalı ve dönüş tipi void olmalıdır. (Program işini bitirse bile, JVM çalışmaya devam edebileceğinden, dönüş değerinin bir önemi olmayacaktır. Bu sebeple void olmalıdır.)

Örnek program

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Merhaba Dunya"); 
    }
}

Program Çıktısı
“.java” uzantılı dosyanın javac ile derlenmesi ve sonrasında “.class” uzantılı dosyanın çalıştırılması.

JVM, JDK,JRE ve ClassLoader Nedir ?

Özgür Akıncı — Tue, 18 Jan 2022 12:04:40 +0000

JVM(Java Virtual Machine), JDK(Java Development Kit) ve JRE(Java Runtime Environment) java uygulama geliştiricilerinin aşina olması gereken temel kavramların başında gelmektedir.

JRE (Java Runtime Environment)
Java programlarının çalışmak için ihtiyaç duyduğu sınıfları ve JVM(Java Virtual Machine)’i içerisinde barındırır.

JRE => JVM ve Java Kütüphanelerini içermektedir.

JVM (Java Virtual Machine)
Derlenmiş bytecode’lar (.class) direk olarak CPU üzerinde çalışmazlar. CPU tarafından anlaşılması için aradaki JVM bytecode’ları okunabilir makine kodları olarak yorumlar.

JDK (Java Development Kit)
Java ile uygulama geliştirmek için olmazsa olmaz bileşendir. İçerisinde JRE, Compiler ve Debugger gibi geliştirme araçları yer alır.

JDK => JRE,Compiler ve debugger içermektedir.

Java ClassLoader
JVM tarafından Java programlarını çalıştırmak için gerekli olan tüm sınıflar, ihtiyaç duyulduğu anda ve istek gerçekleştirilerek ClassLoader ile belleğe yüklenir.