### Spring Framework Temelleri
Spring Framework, Java uygulamaları için kapsamlı bir framework'tür ve uygulama geliştirme süreçlerini basitleştirmeyi amaçlar. Aşağıda Spring Framework'ün temelleri, Spring Boot ile hızlı uygulama geliştirme, ve Dependency Injection ile Inversion of Control (IoC) kavramları hakkında detaylı bilgi bulunmaktadır.
---
### Spring Framework Temelleri
Spring Framework, modüler bir yapıya sahip olup, çeşitli modülleri içerir. Bu modüller arasında en önemli olanları şunlardır:
1. **Core Container**: Uygulama bileşenlerini yönetir ve IoC (Inversion of Control) sağlar. Bu modül, `ApplicationContext` ve `BeanFactory` gibi temel sınıfları içerir.
2. **Data Access/Integration**: Veritabanı erişimi ve entegrasyon için destek sağlar. JDBC, ORM (Object-Relational Mapping), ve JMS (Java Message Service) desteği sunar.
3. **Web**: Web uygulamaları için destek sağlar, MVC (Model-View-Controller) yapısını içerir ve WebSocket, RESTful web servisleri gibi özellikleri destekler.
4. **AOP (Aspect-Oriented Programming)**: Kesitli programlama ile çapraz kesen endişeleri (örneğin, güvenlik) yönetir.
5. **Test**: Test yazılımı geliştirmek için çeşitli yardımcı sınıflar sunar.
#### Spring Configurasyonu
Spring Framework, genellikle XML tabanlı veya Java tabanlı konfigürasyon kullanılarak yapılandırılır.
**XML Konfigürasyonu Örneği:**
```xml
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="myBean" class="com.example.MyBean"/>
</beans>
```
**Java Konfigürasyonu Örneği:**
```java
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class AppConfig {
@Bean
public MyBean myBean() {
return new MyBean();
}
}
```
- **`@Configuration`**: Konfigürasyon sınıfını tanımlar.
- **`@Bean`**: Bean tanımlar.
---
### Spring Boot ile Hızlı Uygulama Geliştirme
Spring Boot, Spring Framework'ün üzerine inşa edilmiş bir projedir ve konfigürasyon işlemlerini basitleştirir. Spring Boot, "opinionated defaults" ve otomatik yapılandırma sağlar.
#### Spring Boot Başlangıç Projesi
1. **Spring Initializr Kullanarak Proje Oluşturma**: [Spring Initializr](https://start.spring.io/) web sitesi üzerinden proje oluşturabilirsiniz.
2. **Basit Spring Boot Uygulaması**
**`Application.java`**
```java
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
```
- **`@SpringBootApplication`**: Bu anotasyon, uygulama konfigürasyonunu ve otomatik yapılandırmayı sağlar.
3. **REST Controller Örneği**
**`HelloController.java`**
```java
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequestMapping("/api")
public class HelloController {
@GetMapping("/hello")
public String sayHello() {
return "Hello, World!";
}
}
```
- **`@RestController`**: RESTful web servislerini oluşturur.
- **`@GetMapping`**: HTTP GET isteklerini işaretler.
---
### Dependency Injection ve Inversion of Control (IoC)
#### Dependency Injection (DI)
Dependency Injection (DI), bir sınıfın bağımlılıklarını dışarıdan sağlayarak gevşek bağlılık ve test edilebilirlik sağlar. DI, uygulama bileşenlerinin birbirinden bağımsız olmasını sağlar.
##### DI Örneği
```java
import org.springframework.stereotype.Component;
@Component
public class Service {
public void performTask() {
System.out.println("Task performed.");
}
}
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
@Component
public class Client {
private final Service service;
@Autowired
public Client(Service service) {
this.service = service;
}
public void execute() {
service.performTask();
}
}
```
- **`@Component`**: Spring tarafından yönetilen bir bileşen olduğunu belirtir.
- **`@Autowired`**: Spring'e bağımlılığı enjekte etmesini belirtir.
#### Inversion of Control (IoC)
Inversion of Control (IoC), uygulama bileşenlerinin kontrolünü tersine çevirir. Bu, bileşenlerin bağımlılıklarını kendileri oluşturmak yerine, dışarıdan (bir IoC konteyneri tarafından) almasını sağlar.
##### IoC Container Örneği
Spring IoC konteyneri, uygulama bileşenlerini yönetir ve bağımlılıklarını enjekte eder. `ApplicationContext`, Spring IoC konteynerinin bir örneğidir.
```java
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
public class IoCExample {
public static void main(String[] args) {
ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
Client client = context.getBean(Client.class);
client.execute();
}
}
```
- **`AnnotationConfigApplicationContext`**: Java tabanlı konfigürasyon sınıflarını kullanarak IoC konteyneri oluşturur.
- **`getBean(Class<T> requiredType)`**: IoC konteynerinden bir bean alır.
---
### Özet
Spring Framework, Java uygulamaları için geniş kapsamlı bir yapı sağlar ve çeşitli modüller içerir. Spring Boot, uygulama geliştirme sürecini hızlandırır ve otomatik yapılandırma sağlar. Dependency Injection, sınıfların bağımlılıklarını dışarıdan alarak gevşek bağlılık sağlar, Inversion of Control ise kontrolü tersine çevirir ve bağımlılık yönetimini sağlar. Bu bilgiler, Spring tabanlı uygulama geliştirme sürecinde size yardımcı olacaktır.