Spring Boot Mülakat Soruları: Kapsamlı Bir Rehber

Spring Boot Mülakat Soruları: Kapsamlı Bir Rehber

Spring Boot, modern Java geliştirme dünyasında vazgeçilmez bir araç haline gelmiştir. Hızlı uygulama geliştirme, kolay konfigürasyon ve üretim ortamına hazır çözümler sunmasıyla öne çıkar. Bu nedenle, Spring Boot bilgisi, Java geliştiricisi mülakatlarında en çok aranan yetkinliklerden biridir. Bu makale, Spring Boot mülakatlarında karşılaşabileceğiniz temelden ileri seviyeye kadar çeşitli soruları ve kapsamlı yanıtlarını ele almaktadır. Amacımız, hem teorik bilginizi pekiştirmek hem de pratik uygulamalarla ilgili içgörü kazanmanızı sağlamaktır.

Spring Boot Temelleri

Spring Boot’un ne olduğunu ve neden bu kadar popüler olduğunu anlamak, mülakatların ilk adımıdır.

Spring Boot Nedir ve Temel Avantajları Nelerdir?

Spring Boot, Spring ekosisteminin bir parçası olarak, üretim seviyesinde, bağımsız ve kolayca çalıştırılabilir Spring uygulamaları oluşturmayı basitleştiren bir projedir. Spring tabanlı uygulamaları yapılandırma ve dağıtma sürecini hızlandırmak için tasarlanmıştır.

Temel Avantajları:

* Otomatik Konfigürasyon (Auto-configuration): Spring Boot, classpath’inizdeki jar dosyalarına ve tanımladığınız bean’lere göre uygulamanızı otomatik olarak yapılandırır. Bu, manuel konfigürasyon ihtiyacını büyük ölçüde azaltır. Örneğin, bir veritabanı sürücüsü eklediğinizde, Spring Boot otomatik olarak bir DataSource bean’i yapılandırmaya çalışır.
* Starter Bağımlılıkları (Starter Dependencies): Yaygın kullanılan fonksiyonellikler (web, JPA, güvenlik vb.) için önceden tanımlanmış bağımlılık setleri sunar. Bu “starter”lar, ilgili tüm bağımlılıkları tek bir pakette toplayarak pom.xml veya build.gradle dosyasını sadeleştirir. Örneğin, spring-boot-starter-web eklediğinizde, Tomcat, Spring MVC ve JSON işleme için gerekli tüm bağımlılıklar otomatik olarak gelir.
* Gömülü Sunucular (Embedded Servers): Tomcat, Jetty veya Undertow gibi sunucuları doğrudan uygulamanın içine gömerek, .war dosyaları oluşturma ve harici bir uygulama sunucusuna dağıtma ihtiyacını ortadan kaldırır. Bu, uygulamaların tek bir java -jar komutuyla çalıştırılabilmesini sağlar.
* Üretim Ortamına Hazır Özellikler (Production-ready Features): Sağlık kontrolleri (health checks), metrikler, harici konfigürasyon ve güvenlik gibi üretim ortamı için kritik özellikleri kolayca entegre etme imkanı sunar (Spring Boot Actuator aracılığıyla).
* Daha Az XML Konfigürasyonu: Geleneksel Spring uygulamalarının aksine, Spring Boot çok az veya hiç XML konfigürasyonu gerektirmez. Çoğunlukla Java tabanlı konfigürasyon ve anotasyonlar kullanılır.
* CLI (Command Line Interface): Spring Boot CLI, Groovy ile Spring Boot uygulamalarını hızlıca prototiplemek için komut satırı araçları sağlar.

@SpringBootApplication Anotasyonu Ne İşe Yarar?

@SpringBootApplication anotasyonu, bir Spring Boot uygulamasının ana sınıfı üzerinde kullanılan bir kolaylık anotasyonudur. Aslında üç temel anotasyonun birleşimidir:

* @Configuration: Bu sınıfın, Spring IoC konteyneri için bean tanımlamaları sağlayabileceğini belirtir.
* @EnableAutoConfiguration: Spring Boot’un otomatik konfigürasyon mekanizmasını tetikler. Classpath’teki jar dosyalarına ve tanımlanmış bean’lere göre uygulamanın otomatik olarak yapılandırılmasını sağlar.
* @ComponentScan: Spring bileşenlerini (örneğin @Component, @Service, @Repository, @Controller ile işaretlenmiş sınıflar) otomatik olarak tarar ve Spring konteynerine bean olarak kaydeder. Varsayılan olarak, anotasyonun bulunduğu paketten ve alt paketlerinden tarama yapar.

Bu anotasyon sayesinde, tek bir anotasyonla bir Spring Boot uygulamasını başlatmak için gerekli tüm temel konfigürasyonları sağlamış olursunuz.

Spring Boot Auto-configuration (Otomatik Konfigürasyon) Mekanizmasını Açıklayın.

Spring Boot’un en güçlü özelliklerinden biri olan otomatik konfigürasyon, geliştiricilerin manuel konfigürasyon yükünü azaltarak daha hızlı uygulama geliştirmesine olanak tanır. Çalışma prensibi şöyledir:

1. Classpath Tarama: Spring Boot, uygulamanın classpath’inde bulunan jar dosyalarını ve bağımlılıkları tarar.
2. Koşullu Bean Oluşturma: @Conditional anotasyonları (örneğin @ConditionalOnClass, @ConditionalOnMissingBean, @ConditionalOnProperty) kullanılarak, belirli koşullar altında bean’lerin oluşturulup oluşturulmayacağına karar verilir. Örneğin, spring-data-jpa bağımlılığı classpath’te mevcutsa ve henüz bir DataSource bean’i tanımlanmamışsa, Spring Boot varsayılan bir DataSource bean’i otomatik olarak yapılandırır.
3. spring.factories Dosyası: Otomatik konfigürasyon sınıfları, META-INF/spring.factories dosyasında listelenir. Spring Boot, bu dosyaları okuyarak hangi otomatik konfigürasyonların etkinleştirilebileceğini belirler.
4. Sıralama: Otomatik konfigürasyonlar, @AutoConfigureBefore, @AutoConfigureAfter gibi anotasyonlarla belirli bir sıraya göre uygulanır.

Bu mekanizma sayesinde, geliştiriciler sadece ihtiyaç duydukları bağımlılıkları ekler ve Spring Boot gerisini halleder. İstenirse, application.properties veya application.yml dosyalarında veya özel @Configuration sınıflarıyla otomatik konfigürasyonlar geçersiz kılınabilir veya devre dışı bırakılabilir.

Starter Bağımlılıkları (Starter Dependencies) Nelerdir ve Neden Kullanılırlar?

Starter bağımlılıkları, Spring Boot’un “starter” modülleri olarak bilinir. Bunlar, belirli bir işlevsellik (örneğin web uygulamaları, JPA, güvenlik, test) için gerekli olan tüm bağımlılıkları içeren önceden yapılandırılmış Maven veya Gradle bağımlılıklarıdır.

Örnekler:

* spring-boot-starter-web: RESTful uygulamalar için Spring MVC, Tomcat ve Jackson (JSON işleme) içerir.
* spring-boot-starter-data-jpa: JPA tabanlı veritabanı erişimi için Spring Data JPA, Hibernate ve JDBC içerir.
* spring-boot-starter-test: Test yazmak için JUnit, Mockito, Spring Test ve Hamcrest gibi kütüphaneleri içerir.
* spring-boot-starter-security: Spring Security entegrasyonu sağlar.

Kullanım Nedenleri:

* Basitlik: Geliştiricilerin, bir özellik için gereken her bağımlılığı manuel olarak eklemesi ve versiyon çakışmalarıyla uğraşması yerine, tek bir “starter” bağımlılığı eklemesi yeterlidir.
* Tutarlılık: Starter’lar, uyumlu bağımlılık versiyonlarını otomatik olarak getirir, böylece bağımlılık çakışmaları riski azalır.
* Hız: Uygulama geliştirme sürecini hızlandırır, çünkü temel konfigürasyon ve bağımlılık yönetimi basitleşir.
* Best Practices: Spring Boot ekibi tarafından belirlenen en iyi uygulamaları ve yaygın kullanım senaryolarını yansıtan bağımlılık setleri sunar.

Spring Boot’ta Gömülü Sunucular (Embedded Servers) Ne Anlama Gelir?

Gömülü sunucular, Spring Boot uygulamalarının kendi web sunucularını (örneğin Tomcat, Jetty veya Undertow) doğrudan uygulama içinde barındırması anlamına gelir. Geleneksel Java web uygulamalarında, .war dosyası harici bir uygulama sunucusuna (Apache Tomcat, JBoss, WebLogic gibi) dağıtılır. Spring Boot ile bu durum değişir:

* Tek Yürütülebilir Jar: Uygulama, java -jar your-app.jar komutuyla doğrudan çalıştırılabilen tek bir .jar dosyası olarak paketlenir. Bu .jar dosyası, hem uygulamanın kodunu hem de gömülü web sunucusunu içerir.
* Bağımsız Uygulamalar: Uygulamalar, harici bir sunucuya ihtiyaç duymadan tamamen bağımsızdır. Bu, dağıtımı ve operasyonu büyük ölçüde basitleştirir.
* Hızlı Başlangıç: Gömülü sunucular, uygulamanın çok daha hızlı başlamasını sağlar, çünkü harici bir sunucunun başlatılması ve uygulamanın ona dağıtılması gibi ek adımlar yoktur.
* Mikroservisler İçin İdeal: Mikroservis mimarilerinde, her servisin kendi bağımsız yaşam döngüsüne sahip olması ve kolayca dağıtılabilir olması gerektiği için gömülü sunucular büyük bir avantaj sağlar.

Varsayılan olarak spring-boot-starter-web, Apache Tomcat’i gömülü sunucu olarak getirir. İstenirse, Maven veya Gradle bağımlılıklarını dışlayarak veya ekleyerek başka sunucular kullanılabilir (örneğin Jetty veya Undertow).

Spring Boot Actuator Nedir ve Ne Amaçla Kullanılır?

Spring Boot Actuator, Spring Boot uygulamalarına üretim ortamında uygulamayı izleme ve yönetme yetenekleri ekleyen bir modüldür. Uygulamanın durumunu, performansını ve sağlığını anlamak için çeşitli “endpoint”ler (uç noktalar) sağlar.

Başlıca Endpoint’ler:

* /health: Uygulamanın sağlık durumunu gösterir (UP/DOWN). Veritabanı bağlantısı, disk alanı gibi kritik bileşenlerin durumunu kontrol eder.
* /info: Uygulama hakkında genel bilgiler (versiyon, açıklama vb.) sağlar. Bu bilgiler application.properties veya application.yml‘den alınabilir.
* /metrics: Uygulamanın performans metriklerini (bellek kullanımı, CPU kullanımı, HTTP istek sayısı ve süresi vb.) sunar. Prometheus, Micrometer gibi izleme araçlarıyla entegre edilebilir.
* /env: Spring Environment’ındaki tüm konfigürasyon özelliklerini gösterir.
* /beans: Uygulamadaki tüm Spring bean’lerini ve bunların bağımlılıklarını listeler.
* /mappings: Tüm @RequestMapping yollarını listeler.
* /shutdown: Uygulamayı güvenli bir şekilde kapatır (varsayılan olarak devre dışıdır ve manuel olarak etkinleştirilmesi gerekir).

Kullanım Amaçları:

* İzleme (Monitoring): Uygulamanın canlı durumunu ve performansını takip etmek.
* Yönetim (Management): Uygulama özelliklerini (örneğin log seviyelerini) çalışma zamanında değiştirmek.
* Sorun Giderme (Troubleshooting): Hataları ve performans sorunlarını teşhis etmek.
* Otomasyon (Automation): Otomatik dağıtım ve ölçeklendirme sistemleri tarafından uygulamanın durumunu kontrol etmek için kullanılır.

Actuator endpoint’leri varsayılan olarak management.endpoints.web.exposure.include özelliği ile yapılandırılabilir (örneğin management.endpoints.web.exposure.include=* ile tüm endpoint’ler açılır). Güvenlik nedeniyle, bu endpoint’lere erişim genellikle Spring Security ile korunur.

Spring Boot Profilleri (Profiles) Ne İşe Yarar?

Spring Boot profilleri, uygulamanın farklı ortamlarda (geliştirme, test, üretim vb.) farklı konfigürasyonlarla çalışmasını sağlayan güçlü bir özelliktir. Tek bir kod tabanını korurken, veritabanı bağlantı bilgileri, log seviyeleri, harici servis URL’leri gibi ortama özgü ayarları kolayca yönetmeye olanak tanır.

Nasıl Kullanılır:

1. Profil Tanımlama: application.properties yerine application-{profile-name}.properties (veya .yml) dosyaları oluşturulur. Örneğin:
* application-dev.properties (geliştirme ortamı için)
* application-prod.properties (üretim ortamı için)
* application-test.properties (test ortamı için)
Genel ayarlar application.properties dosyasında kalırken, profile özgü ayarlar ilgili dosyada tanımlanır ve genel ayarları geçersiz kılar.

2. Bean’leri Profile Göre Aktif Etme: @Profile anotasyonu kullanılarak belirli bean’ler veya konfigürasyon sınıfları yalnızca belirli bir profil aktif olduğunda etkinleştirilebilir.

@Configuration
    @Profile("dev")
    public class DevConfig {
        // Dev ortamına özgü bean'ler
    }

    @Service
    @Profile("prod")
    public class ProdUserService implements UserService {
        // Üretim ortamına özgü servis implementasyonu
    }

3. Profil Aktifleştirme: Bir profil, çeşitli yollarla aktifleştirilebilir:
* application.properties: spring.profiles.active=dev
* Komut Satırı: java -jar myapp.jar --spring.profiles.active=prod
* Ortam Değişkeni: SPRING_PROFILES_ACTIVE=test
* IDE: Geliştirme ortamınızda (IntelliJ, Eclipse) çalışma konfigürasyonlarına ekleyerek.

Faydaları:

* Ortam Bağımsızlığı: Uygulamanın farklı ortamlara kolayca uyarlanmasını sağlar.
* Kod Tekrarı Azaltma: Aynı işlevsellik için farklı ortamlar için ayrı kod tabanları tutma ihtiyacını ortadan kaldırır.
* Güvenlik: Hassas bilgilerin (veritabanı şifreleri) farklı profillerde güvenli bir şekilde yönetilmesine yardımcı olur.

application.properties ve application.yml Dosyaları Arasındaki Fark Nedir?

Her iki dosya da Spring Boot uygulamalarında harici konfigürasyon sağlamak için kullanılır. Temel fark, kullandıkları söz dizimindedir:

* application.properties:
* Anahtar-değer çiftleri kullanır.
* Her özellik ayrı bir satırda tanımlanır: server.port=8080
* Yorum satırları # ile başlar.
* Geleneksel ve yaygın kullanılan bir formattır.

* application.yml (YAML – YAML Ain’t Markup Language):
* Hiyerarşik bir yapı kullanır.
* Girintileme (indentation) önemlidir ve yapıyı tanımlar.
* Daha okunabilir ve düzenli bir yapı sunar, özellikle çok sayıda konfigürasyon özelliği olduğunda.
* Örnek:

server:
          port: 8080
        spring:
          datasource:
            url: jdbc:mysql://localhost:3306/mydb
            username: user
            password: pass

* Yorum satırları # ile başlar.
* Listeleri ve haritaları daha kolay tanımlama imkanı sunar.

Seçim Kriterleri:

* Tercih: Çoğunlukla kişisel veya takım tercihi meselesidir.
* Okunabilirlik: YAML, özellikle karmaşık ve çok seviyeli konfigürasyonlar için daha okunabilir kabul edilir.
* Araç Desteği: Her iki format da Spring Boot ve çoğu IDE tarafından tam olarak desteklenir.
* Geçerlilik: Spring Boot, hem .properties hem de .yml dosyalarını aynı anda bulursa, her ikisini de yükler ve .yml dosyaları genellikle .properties dosyalarını geçersiz kılar (aynı özellikler için). Genellikle application.yml tercih edilir.

Spring Boot ile Veri Erişimi ve Web Geliştirme

Spring Boot, veri erişimi ve web uygulamaları geliştirmeyi de basitleştirir.

Spring Data JPA Nedir ve Spring Boot ile Nasıl Kullanılır?

Spring Data JPA, Java Persistence API (JPA) tabanlı veri erişim katmanlarını uygulamayı basitleştiren bir Spring projesidir. Tekrarlayan kod yazma ihtiyacını ortadan kaldırarak geliştiricilerin daha hızlı çalışmasını sağlar.

Spring Boot ile Kullanımı:

1. Bağımlılık Ekleme: spring-boot-starter-data-jpa ve veritabanı sürücüsü (örneğin mysql-connector-java veya h2) bağımlılıkları pom.xml‘e eklenir.
2. Konfigürasyon: application.properties veya application.yml dosyasında veritabanı bağlantı bilgileri (URL, kullanıcı adı, şifre) ve Hibernate ayarları (DDL modu gibi) tanımlanır.

spring:
      datasource:
        url: jdbc:h2:mem:testdb
        driverClassName: org.h2.Driver
        username: sa
        password: password
      jpa:
        hibernate:
          ddl-auto: update # veya create, create-drop, none
        show-sql: true

3. Entity Tanımlama: JPA @Entity anotasyonu ile veritabanı tablolarına karşılık gelen Java sınıfları oluşturulur.

@Entity
    public class User {
        @Id
        @GeneratedValue(strategy = GenerationType.IDENTITY)
        private Long id;
        private String name;
        private String email;
        // Getter ve Setter'lar
    }

4. Repository Interface’leri: JpaRepository arayüzünü genişleterek, CRUD (Create, Read, Update, Delete) işlemleri için otomatik olarak methodlar sağlanır. Özel sorgular için method isimleri kurallarına uyarak veya @Query anotasyonu ile methodlar tanımlanabilir.

@Repository
    public interface UserRepository extends JpaRepository {
        Optional findByEmail(String email); // Özel sorgu
    }

5. Servis Katmanı: Repository’ler servis katmanında enjekte edilerek kullanılır.

@Service
    public class UserService {
        @Autowired
        private UserRepository userRepository;

        public User saveUser(User user) {
            return userRepository.save(user);
        }

        public Optional findUserById(Long id) {
            return userRepository.findById(id);
        }
        // Diğer iş mantığı
    }

Spring Data JPA, veritabanı etkileşimlerini soyutlayarak ve standartlaştırarak geliştirme sürecini önemli ölçüde hızlandırır.

RESTful Web Servisleri Geliştirmek İçin Spring Boot’ta Hangi Anotasyonlar Kullanılır?

Spring Boot, RESTful web servisleri geliştirmek için Spring MVC’yi temel alır ve geliştirme sürecini basitleştiren anotasyonlar sunar:

* @RestController: Bu anotasyon, bir sınıfın hem @Controller hem de @ResponseBody anotasyonlarını birleştirdiğini belirtir. Yani, bu sınıftaki tüm metodların dönüş değerleri doğrudan HTTP yanıt gövdesine yazılır (genellikle JSON veya XML formatında). Bu, RESTful servisler için idealdir.
* @RequestMapping: Bir HTTP isteğini belirli bir methoda veya sınıfa eşlemek için kullanılır. Hem URL yolunu hem de HTTP metodunu (GET, POST, PUT, DELETE) belirtebilir.
* @RequestMapping("/api/users") (sınıf seviyesinde)
* @RequestMapping(value = "/{id}", method = RequestMethod.GET) (metod seviyesinde)
* @GetMapping, @PostMapping, @PutMapping, @DeleteMapping, @PatchMapping: @RequestMapping‘in daha spesifik ve okunabilir versiyonlarıdır. Sadece belirli bir HTTP metodu için eşleme yaparlar.
* @GetMapping("/api/users") (GET isteği için)
* @PostMapping("/api/users") (POST isteği için)
* @PutMapping("/api/users/{id}") (PUT isteği için)
* @DeleteMapping("/api/users/{id}") (DELETE isteği için)
* @PathVariable: URL yolundaki değişkenleri (örneğin /users/{id} içindeki id) metod parametrelerine bağlamak için kullanılır.
* @GetMapping("/api/users/{id}") public User getUserById(@PathVariable Long id) { ... }
* @RequestParam: HTTP isteğinin sorgu parametrelerini (query parameters) metod parametrelerine bağlamak için kullanılır (örneğin /users?name=John).
* @GetMapping("/api/users") public List searchUsers(@RequestParam String name) { ... }
* @RequestBody: HTTP isteğinin gövdesindeki (body) verileri (genellikle JSON veya XML) bir Java nesnesine dönüştürmek için kullanılır. Genellikle POST ve PUT isteklerinde veri göndermek için kullanılır.
* @PostMapping("/api/users") public User createUser(@RequestBody User user) { ... }
* @ResponseBody: (Genellikle @RestController ile örtülüdür) Bir metodun dönüş değerinin doğrudan HTTP yanıt gövdesine yazılacağını belirtir.
* @ResponseStatus: Bir metodun başarılı veya başarısız bir şekilde tamamlanması durumunda döndürülecek HTTP durum kodunu belirtir (örneğin HttpStatus.CREATED).
* @PostMapping public ResponseEntity createUser(@RequestBody User user) { return new ResponseEntity<>(userService.save(user), HttpStatus.CREATED); } (ResponseEntity ile de durum kodu ayarlanabilir)

Bu anotasyonlar, Spring Boot ile hızlı ve etkin bir şekilde RESTful API’ler geliştirmek için temel yapı taşlarıdır.

Spring Boot Uygulamalarında Hata Yönetimi Nasıl Yapılır?

Spring Boot uygulamalarında hata yönetimi, kullanıcıya anlamlı hata mesajları sunmak ve uygulamanın beklenmedik durumları zarif bir şekilde ele almasını sağlamak için kritik öneme sahiptir. Spring Boot, bu konuda birkaç güçlü mekanizma sunar:

1. @ExceptionHandler Anotasyonu: Bir Controller sınıfı içinde belirli istisna türlerini yakalamak için kullanılır. Metodun, yakalamak istediği istisna türünü parametre olarak alır ve bir ResponseEntity döndürerek HTTP durum kodu ve hata mesajı sağlayabilir.

@RestController
    @RequestMapping("/api/users")
    public class UserController {
        // ...
        @ExceptionHandler(UserNotFoundException.class)
        @ResponseStatus(HttpStatus.NOT_FOUND)
        public ErrorResponse handleUserNotFoundException(UserNotFoundException ex) {
            return new ErrorResponse(HttpStatus.NOT_FOUND.value(), ex.getMessage());
        }
    }

2. @ControllerAdvice Anotasyonu: Uygulama genelinde (global) hata yönetimi sağlamak için kullanılır. @ExceptionHandler anotasyonu ile birlikte kullanıldığında, tüm Controller’lar tarafından fırlatılan belirli istisnaları merkezi bir yerden yakalamayı sağlar. Bu, hata yönetim kodunun tekrarını önler ve daha temiz bir yapı sunar.

@ControllerAdvice
    public class GlobalExceptionHandler {

        @ExceptionHandler(UserNotFoundException.class)
        @ResponseStatus(HttpStatus.NOT_FOUND)
        public ErrorResponse handleUserNotFound(UserNotFoundException ex) {
            return new ErrorResponse(HttpStatus.NOT_FOUND.value(), ex.getMessage());
        }

        @ExceptionHandler(MethodArgumentNotValidException.class)
        @ResponseStatus(HttpStatus.BAD_REQUEST)
        public ErrorResponse handleValidationExceptions(MethodArgumentNotValidException ex) {
            List errors = ex.getBindingResult().getFieldErrors().stream()
                    .map(error -> error.getField() + ": " + error.getDefaultMessage())
                    .collect(Collectors.toList());
            return new ErrorResponse(HttpStatus.BAD_REQUEST.value(), "Validation failed: " + String.join(", ", errors));
        }

        @ExceptionHandler(Exception.class)
        @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
        public ErrorResponse handleAllExceptions(Exception ex) {
            return new ErrorResponse(HttpStatus.INTERNAL_SERVER_ERROR.value(), "An unexpected error occurred: " + ex.getMessage());
        }
    }

Burada ErrorResponse özel bir hata yanıtı sınıfı olabilir.

3. ProblemDetail (Spring 6+): Spring 6 ile birlikte RFC 7807 standardını uygulayan ProblemDetail sınıfı, API hata yanıtları için daha yapılandırılmış ve standart bir yol sunar.

4. ErrorController: Spring Boot, varsayılan olarak /error yolunda bir BasicErrorController sağlar. Bu kontrolcü, herhangi bir istisna fırlatıldığında ve diğer @ExceptionHandler‘lar tarafından yakalanmadığında devreye girer. application.properties dosyasında server.error.include-stacktrace=never gibi ayarlar yapılarak hata detaylarının görünürlüğü kontrol edilebilir.

Etkili hata yönetimi, API’nizin güvenilirliğini ve kullanılabilirliğini artırır.

Spring Boot Uygulamalarını Test Etme

Test, yazılım geliştirme sürecinin ayrılmaz bir parçasıdır ve Spring Boot, test yazmayı kolaylaştıran kapsamlı araçlar sunar.

Spring Boot Uygulamalarını Test Etmek İçin Hangi Anotasyonlar Kullanılır?

Spring Boot, farklı test senaryoları için özel test anotasyonları sağlar:

* @SpringBootTest: En kapsamlı test anotasyonudur. Tüm Spring uygulamasını yükler ve test etmenizi sağlar. Genellikle entegrasyon testleri için kullanılır.
* @SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT) ile gerçek bir web sunucusu (rastgele bir portta) başlatılabilir ve HTTP istekleri gönderilerek tam entegrasyon testleri yapılabilir.
* @SpringBootTest(classes = MySpringBootApplication.class) ile belirli bir ana uygulama sınıfı belirtilebilir.
* @SpringBootTest(properties = {"my.property=value"}) ile test sırasında özel konfigürasyon özellikleri ayarlanabilir.
* @SpringBootTest ile @Autowired kullanarak uygulamanın herhangi bir bean’ini test sınıfına enjekte edebilirsiniz.

* @WebMvcTest: Yalnızca Spring MVC katmanını (Controller’lar) test etmek için kullanılır. Diğer katmanlar (Servisler, Repository’ler) mock’lanır. Bu, daha hafif ve hızlı testler sağlar.
* Genellikle MockMvc ile birlikte kullanılır.
* @WebMvcTest(MyController.class) ile test edilecek belirli bir Controller sınıfı belirtilebilir.
* @MockBean ile servis veya repository bağımlılıkları mock’lanabilir.

* @DataJpaTest: Yalnızca JPA katmanını (Repository’ler) test etmek için kullanılır. Bellek içi bir veritabanı (örneğin H2) yapılandırır ve her testten sonra veritabanını temizler. Bu, veritabanı etkileşimlerini hızlıca test etmek için idealdir.
* @Autowired TestEntityManager ile veritabanına doğrudan erişim sağlanabilir.

* @JdbcTest: JDBC tabanlı veri erişimini test etmek için kullanılır, @DataJpaTest‘e benzer ancak doğrudan JDBC’ye odaklanır.

* @RestClientTest: REST istemcilerini (örneğin RestTemplate veya WebClient) test etmek için kullanılır. Harici servis çağrılarını mock’layarak istemci kodunun doğru çalıştığından emin olmayı sağlar.

* @MockBean: Spring uygulama bağlamına sahte (mock) bean’ler eklemek veya mevcut bir bean’i sahte bir sürümüyle değiştirmek için kullanılır. Genellikle @WebMvcTest veya @SpringBootTest ile birlikte kullanılır. Mockito ile entegre çalışır.

* @SpyBean: @MockBean‘e benzer, ancak mevcut bir bean’in gerçek metodlarını çağırırken belirli metodları sahteleyebilir.

Bu anotasyonlar, farklı test seviyelerinde (unit, integration, slice) Spring Boot uygulamalarını etkin bir şekilde test etmeye olanak tanır.

İleri Düzey Konular ve En İyi Uygulamalar

Mülakatlarda sadece temel bilgileri bilmek değil, aynı zamanda ileri düzey konulara hakim olmak ve en iyi uygulamaları anlamak da önemlidir.

Spring Boot ile Mikroservis Geliştirmenin Avantajları Nelerdir?

Spring Boot, mikroservis mimarileri için doğal bir seçimdir ve birçok avantaj sunar:

* Hızlı Geliştirme: Spring Boot’un otomatik konfigürasyon ve starter bağımlılıkları sayesinde, her bir mikroservis hızlıca geliştirilebilir ve ayağa kaldırılabilir.
* Bağımsız Dağıtım: Gömülü sunucular sayesinde her mikroservis, kendi başına çalıştırılabilir bir JAR dosyası olarak paketlenebilir ve bağımsız olarak dağıtılabilir. Bu, dağıtım süreçlerini hızlandırır ve basitleştirir.
* Teknoloji Çeşitliliği: Her mikroservis, farklı teknolojiler veya Spring Boot versiyonları ile geliştirilebilir. Bu, teknoloji seçimi konusunda esneklik sağlar.
* Ölçeklenebilirlik: Mikroservisler bağımsız olduğu için, ihtiyaç duyulan servisler diğerlerinden bağımsız olarak yatayda ölçeklenebilir.
* Hata İzolasyonu: Bir serviste meydana gelen hata, diğer servisleri doğrudan etkilemez, bu da sistemin genel direncini artırır.
* Geliştirici Verimliliği: Küçük, odaklanmış kod tabanları üzerinde çalışmak, geliştirici ekiplerinin daha verimli olmasını sağlar.
* Spring Cloud Entegrasyonu: Spring Boot, mikroservis mimarisinde karşılaşılan zorlukları (servis keşfi, API ağ geçitleri, dağıtık konfigürasyon, yük dengeleme, devre kesici) çözmek için Spring Cloud projesiyle mükemmel bir uyum içindedir.

Spring Boot Uygulamalarını Dockerize Etmenin Adımları Nelerdir?

Spring Boot uygulamalarını Docker konteynerlerine dönüştürmek, dağıtım, ölçekleme ve ortam tutarlılığı açısından büyük avantajlar sağlar. Temel adımlar şunlardır:

1. Uygulamayı Paketleme: Spring Boot uygulamasını çalıştırılabilir bir JAR dosyası olarak paketleyin. Bu genellikle mvn package veya gradle bootJar komutuyla yapılır.

mvn clean package

2. Dockerfile Oluşturma: Uygulamanın kök dizinine bir Dockerfile oluşturun. Bu dosya, Docker imajının nasıl oluşturulacağını tanımlar.

# Temel imaj olarak OpenJDK kullanın. Üretim için daha hafif bir JRE imajı tercih edilebilir.
    FROM openjdk:17-jdk-slim

    # İmaj içinde çalışacak uygulamanın JAR dosyasını kopyalamadan önce çalışma dizinini belirleyin.
    WORKDIR /app

    # Uygulamanın JAR dosyasını Docker imajına kopyalayın.
    # Örneğin: target/my-spring-boot-app-0.0.1-SNAPSHOT.jar
    COPY target/*.jar app.jar

    # Uygulamanın çalıştırılacağı portu belirtin. (Opsiyonel ama iyi bir pratik)
    EXPOSE 8080

    # Uygulamayı başlatmak için ENTRYPOINT komutunu kullanın.
    # Bu, kapsayıcı her başlatıldığında çalıştırılacak varsayılan komuttur.
    ENTRYPOINT ["java", "-jar", "app.jar"]

    # Alternatif olarak, JVM argümanları eklemek için:
    # ENTRYPOINT ["java", "-Dspring.profiles.active=prod", "-jar", "app.jar"]

3. Docker İmajını Oluşturma: Dockerfile‘ın bulunduğu dizinde aşağıdaki komutu çalıştırarak Docker imajını oluşturun.

docker build -t my-spring-boot-app .

* -t my-spring-boot-app: İmaja my-spring-boot-app adını verir.
* .: Dockerfile‘ın mevcut dizinde olduğunu belirtir.

4. Docker Konteynerini Çalıştırma: Oluşturulan imajdan bir Docker konteyneri başlatın.

docker run -p 8080:8080 my-spring-boot-app

* -p 8080:8080: Host makinenin 8080 portunu konteynerin 8080 portuna eşler.
* my-spring-boot-app: Çalıştırılacak imajın adıdır.

5. Gelişmiş Optimizasyonlar:
* Çok Aşamalı Derleme (Multi-stage Builds): Daha küçük imajlar oluşturmak için derleme ortamını çalışma ortamından ayırın.
* Jib: Google’ın Jib aracı, Dockerfile yazmaya gerek kalmadan Spring Boot uygulamalarını Docker imajlarına dönüştürmeyi otomatikleştirir.
* Layered JARs (Spring Boot 2.3+): Spring Boot’un katmanlı JAR özelliği, Docker imajlarının daha verimli bir şekilde katmanlanmasını sağlar, bu da değişikliklerde daha hızlı imaj oluşturma ve indirme süreleri anlamına gelir.

Dockerize etmek, Spring Boot uygulamalarınızın tutarlı bir şekilde farklı ortamlarda çalışmasını ve modern DevOps süreçlerine entegre olmasını sağlar.

Spring Boot DevTools Nedir ve Ne Amaçla Kullanılır?

Spring Boot DevTools, geliştirme sürecini hızlandırmak ve kolaylaştırmak için tasarlanmış bir dizi araç içeren bir modüldür. Sadece geliştirme ortamında kullanılmalı ve üretim ortamı paketlerine dahil edilmemelidir.

Başlıca Özellikleri:

* Otomatik Yeniden Başlatma (Automatic Restart): Uygulama classpath’indeki dosyalar değiştiğinde (örneğin bir Java sınıfını kaydettiğinizde), DevTools uygulamayı otomatik olarak yeniden başlatır. Bu, geliştiricilerin değişiklikleri anında görmesini sağlar.
* Tarayıcıda Canlı Yeniden Yükleme (Live Reload): Tarayıcıya özel bir eklenti ile kullanıldığında, uygulamanın yeniden başlatılmasının ardından tarayıcıyı otomatik olarak yeniler.
* Varsayılan Konfigürasyonlar: Geliştirme dostu varsayılan konfigürasyonlar sağlar. Örneğin, Thymeleaf önbelleğini devre dışı bırakır, H2 veritabanı konsolunu etkinleştirir.
* Global Ayarlar: ~/.spring-boot-devtools.properties dosyasında global DevTools ayarları yapılabilir.
* Uzaktan Debugging Desteği: Güvenlik önlemleriyle birlikte uzaktan debug yapma imkanı sunar.

Nasıl Kullanılır:

1. Bağımlılık Ekleme: spring-boot-devtools bağımlılığı pom.xml veya build.gradle dosyasına eklenir. scope=runtime olarak belirtilmesi, üretim paketine dahil edilmemesini sağlar.

        org.springframework.boot
        spring-boot-devtools
        runtime
        true
    

Önemli Notlar:

* Güvenlik: DevTools’un üretim ortamında kullanılması güvenlik riskleri taşıyabilir, bu nedenle spring.devtools.restart.enabled=false gibi özelliklerle devre dışı bırakılması veya üretim ortamı paketlerinden hariç tutulması önerilir.
* Hız: Otomatik yeniden başlatma, büyük uygulamalar için biraz zaman alabilir, ancak genellikle manuel yeniden başlatmadan daha hızlıdır.

DevTools, geliştiricilerin “kodla, kaydet, gör” döngüsünü hızlandırarak genel üretkenliği artırır.

Sonuç

Spring Boot, modern Java geliştirme için güçlü ve esnek bir çerçevedir. Bu makalede ele alınan mülakat soruları, Spring Boot’un temel prensiplerinden ileri düzey kullanım senaryolarına kadar geniş bir yelpazeyi kapsamaktadır. Otomatik konfigürasyon, starter bağımlılıkları, gömülü sunucular gibi temel kavramları anlamak, veri erişimi ve web geliştirme için kullanılan anotasyonlara hakim olmak, hata yönetimini ve test stratejilerini bilmek, bir Spring Boot geliştiricisi olarak yetkinliğinizi gösterecektir. Ayrıca, mikroservisler, Docker entegrasyonu ve geliştirici araçları gibi ileri düzey konulara olan aşinalığınız, sizi diğer adaylardan ayıracaktır. Mülakatlara hazırlanırken bu konuları derinlemesine incelemeniz ve pratik örneklerle pekiştirmeniz, başarı şansınızı artıracaktır.