Spring Controller – Spring MVC Controller: Detaylı Bir İnceleme
Giriş: Spring MVC ve Controller’ların Kalbi
Modern web uygulamalarının geliştirilmesinde, kullanıcı arayüzü ile iş mantığı arasındaki etkileşimi düzenlemek hayati önem taşır. Bu bağlamda, Model-View-Controller (MVC) mimarisi, yazılım tasarımında uzun yıllardır kullanılan ve kendini kanıtlamış bir yaklaşımdır. Spring Framework, Java ekosistemindeki en güçlü ve yaygın kullanılan framework’lerden biri olarak, Spring MVC modülü ile bu mimariyi mükemmel bir şekilde hayata geçirir. Spring MVC’nin merkezinde ise “Controller”lar yer alır. Controller’lar, kullanıcıdan gelen istekleri karşılayan, iş mantığını tetikleyen ve uygun yanıtı döndüren ana bileşenlerdir. Bu makalede, Spring Controller’ların ne olduğunu, nasıl çalıştığını, farklı türlerini, yapılandırma seçeneklerini, ileri düzey özelliklerini ve en iyi uygulama yöntemlerini detaylı bir şekilde inceleyeceğiz. Amacımız, Spring MVC Controller’ları hakkında kapsamlı bir anlayış sağlamak ve okuyucuların bu güçlü bileşenleri etkili bir şekilde kullanmalarına yardımcı olmaktır.
Temel Kavramlar: MVC Mimarisi ve Spring MVC’deki Yeri
Spring MVC, web uygulamaları geliştirmek için tasarlanmış bir request-driven (istek odaklı) web framework’üdür. MVC tasarım desenini temel alır ve uygulamanın farklı katmanlarını birbirinden ayırarak geliştirme, bakım ve test süreçlerini kolaylaştırır.
MVC Mimarisi Bileşenleri
* Model: Uygulamanın verilerini ve iş mantığını temsil eder. Genellikle POJO (Plain Old Java Object) sınıflarından oluşur ve veritabanı etkileşimleri, iş kuralları gibi operasyonları içerir. Controller, genellikle Model’i günceller veya Model’den veri alır.
* View: Model’deki verilerin kullanıcıya sunulduğu arayüzdür. HTML, JSP, Thymeleaf, FreeMarker gibi şablon motorları kullanılarak oluşturulur. View, verileri görsel bir formatta gösterir ancak herhangi bir iş mantığı içermez.
* Controller: Kullanıcıdan gelen istekleri (request) alır, bu istekleri işler, Model’i günceller veya Model’den veri alır ve uygun View’i seçerek yanıtı (response) oluşturur. Controller, Model ve View arasındaki koordinasyonu sağlar.
Spring MVC’nin Temel Akışı ve DispatcherServlet
Spring MVC’deki istek işleme akışı, DispatcherServlet adı verilen merkezi bir ön kontrolcü (front controller) tarafından yönetilir. Bir kullanıcı bir web isteği gönderdiğinde:
1. İstek Gelir: Kullanıcıdan gelen HTTP isteği DispatcherServlet‘e ulaşır.
2. Handler Mapping: DispatcherServlet, gelen URL’ye göre hangi Controller metodunun isteği işleyeceğini belirlemek için HandlerMapping‘i kullanır.
3. Controller Çağrısı: Belirlenen Controller metodu çağrılır. Controller, isteği işler, gerekli iş mantığını yürütür (genellikle bir servis katmanı aracılığıyla), Model’i hazırlar.
4. ModelAndView Dönüşü: Controller metodu genellikle bir ModelAndView nesnesi veya bir View adını döndürür. ModelAndView hem Model verilerini hem de View adını içerir.
5. View Resolver: DispatcherServlet, Controller’dan dönen View adını kullanarak ViewResolver aracılığıyla gerçek View bileşenini (örn. JSP dosyası) bulur.
6. View Render Etme: View, Model’deki verileri kullanarak kendini render eder ve nihai HTML çıktısını oluşturur.
7. Yanıt Gönderme: DispatcherServlet, oluşturulan HTML yanıtını kullanıcıya geri gönderir.
Bu akış, Spring MVC’nin modüler ve esnek yapısının temelini oluşturur.
Controller Türleri: @Controller ve @RestController
Spring MVC’de Controller’ları tanımlamak için iki temel anotasyon kullanılır: @Controller ve @RestController. Bu iki anotasyonun temel farklarını ve kullanım senaryolarını anlamak önemlidir.
@Controller Anotasyonu
@Controller anotasyonu, bir sınıfın Spring MVC Controller’ı olduğunu belirtir. Geleneksel web uygulamaları için tasarlanmıştır ve genellikle View teknolojileri (JSP, Thymeleaf vb.) ile birlikte kullanılır. @Controller ile işaretlenmiş bir metodun dönüş değeri, varsayılan olarak bir View adıdır. Bu View adı, ViewResolver tarafından işlenerek ilgili View dosyasına yönlendirilir ve HTML gibi bir çıktı üretilir.
Örnek Kullanım:
@Controller
public class HomeController {
@GetMapping("/home")
public String showHomePage(Model model) {
model.addAttribute("message", "Merhaba Spring MVC!");
return "home"; // home.jsp veya home.html dosyasına yönlendirir
}
}
Bu örnekte, /home adresine yapılan bir GET isteği showHomePage metodu tarafından karşılanır. Metot, Model nesnesine bir message özniteliği ekler ve home adında bir String döndürür. Spring’in ViewResolver‘ı bu home String’ini alarak ilgili View’i (örneğin WEB-INF/views/home.jsp) bulur ve render eder.
@RestController Anotasyonu
@RestController anotasyonu, Spring 4.0 ile tanıtılmıştır ve @Controller ile @ResponseBody anotasyonlarının birleşimidir. RESTful web servisleri geliştirmek için özel olarak tasarlanmıştır. @RestController ile işaretlenmiş bir sınıf içindeki tüm metodların dönüş değeri, doğrudan HTTP yanıt gövdesine yazılır. Bu dönüş değeri genellikle JSON veya XML formatında olur ve otomatik olarak uygun bir HttpMessageConverter tarafından dönüştürülür. Bu sayede, Controller’dan dönen veriler doğrudan istemciye gönderilir, herhangi bir View Resolver’a ihtiyaç duyulmaz.
Örnek Kullanım:
@RestController
@RequestMapping("/api/users")
public class UserRestController {
@GetMapping("/{id}")
public User getUserById(@PathVariable Long id) {
// Veritabanından kullanıcıyı getirme mantığı
return new User(id, "John Doe", "john.doe@example.com"); // JSON olarak döner
}
@PostMapping
public User createUser(@RequestBody User user) {
// Yeni kullanıcıyı kaydetme mantığı
return user; // JSON olarak döner
}
}
Bu örnekte, /api/users/{id} adresine yapılan bir GET isteği getUserById metodu tarafından karşılanır. Metot, bir User nesnesi döndürür ve bu nesne otomatik olarak JSON formatına dönüştürülerek HTTP yanıt gövdesine yazılır. Bu, modern tek sayfa uygulamaları (SPA) veya mobil uygulamalar için arka uç (backend) API’leri geliştirirken son derece kullanışlıdır.
Özetle:
* @Controller: Geleneksel web uygulamaları, View (HTML) döndürmek için.
* @RestController: RESTful servisler, doğrudan veri (JSON/XML) döndürmek için.
Controller Oluşturma ve Yapılandırma
Bir Spring Controller’ı oluşturmak ve yapılandırmak, @Controller veya @RestController anotasyonunu kullanmanın yanı sıra, istekleri belirli metodlarla eşleştirmek ve metod parametrelerini yönetmek gibi adımları içerir.
İstek Eşleme Anotasyonları
İstekleri Controller metodlarına eşlemek için çeşitli anotasyonlar kullanılır:
* @RequestMapping: Hem sınıf hem de metod seviyesinde kullanılabilir. Belirli bir URL yolunu, HTTP metodunu (GET, POST vb.), parametreleri, başlıkları veya medya türlerini eşleştirmek için kullanılır.
@Controller
@RequestMapping("/products") // Sınıf seviyesi eşleme
public class ProductController {
@RequestMapping(method = RequestMethod.GET, value = "/list") // Metod seviyesi eşleme
public String listProducts() {
return "productList";
}
}
* @GetMapping, @PostMapping, @PutMapping, @DeleteMapping, @PatchMapping: Spring 4.3 ile tanıtılan bu anotasyonlar, @RequestMapping(method = RequestMethod.GET, value = "/path") gibi uzun ifadelerin kısaltılmış halidir. Daha okunabilir ve anlaşılırdır.
@RestController
@RequestMapping("/items")
public class ItemController {
@GetMapping // /items adresine GET isteği
public List- getAllItems() { / ... / return null; }
@PostMapping // /items adresine POST isteği
public Item createItem(@RequestBody Item item) { / ... / return item; }
@PutMapping("/{id}") // /items/{id} adresine PUT isteği
public Item updateItem(@PathVariable Long id, @RequestBody Item item) { / ... / return item; }
@DeleteMapping("/{id}") // /items/{id} adresine DELETE isteği
public void deleteItem(@PathVariable Long id) { / ... / }
}
Metod Parametreleri ve Anotasyonları
Controller metodları, gelen istekle ilgili bilgilere erişmek için çeşitli parametreler alabilir. Bu parametreler, Spring tarafından otomatik olarak çözümlenir ve doldurulur.
* HttpServletRequest, HttpServletResponse, HttpSession: Servlet API’sinden doğrudan nesnelere erişim sağlar.
* @RequestParam: URL sorgu parametrelerini (query parameters) metoda bağlar.
@GetMapping("/search")
public String searchProducts(@RequestParam String keyword,
@RequestParam(required = false, defaultValue = "0") int page) {
// keyword ve page parametrelerini kullan
return "searchResults";
}
* @PathVariable: URL yol değişkenlerini (path variables) metoda bağlar.
@GetMapping("/users/{id}")
public User getUserById(@PathVariable Long id) {
// id değişkenini kullan
return null;
}
* @RequestBody: HTTP isteğinin gövdesini (body) bir Java nesnesine dönüştürür. Genellikle JSON veya XML verilerini almak için RESTful servislerde kullanılır.
@PostMapping("/users")
public User createUser(@RequestBody User newUser) {
// newUser nesnesini kullan
return newUser;
}
* @ModelAttribute: Form verilerini bir POJO nesnesine bağlar. Ayrıca, View’e gönderilecek bir Model özniteliği olarak da kullanılabilir.
@PostMapping("/register")
public String registerUser(@ModelAttribute("userForm") User user, Model model) {
// user nesnesi form verileriyle doldurulur
model.addAttribute("successMessage", "Kayıt başarılı!");
return "registrationSuccess";
}
* Model veya ModelAndView: View’e gönderilecek verileri taşımak için kullanılır. Model sadece verileri tutarken, ModelAndView hem verileri hem de View adını tutar.
@GetMapping("/dashboard")
public String showDashboard(Model model) {
model.addAttribute("username", "admin");
return "dashboard";
}
* BindingResult: @ModelAttribute veya @RequestBody ile birlikte kullanıldığında, veri bağlama (data binding) ve doğrulama (validation) hatalarını yakalamak için kullanılır. Her zaman @ModelAttribute veya @RequestBody parametresinden hemen sonra gelmelidir.
@PostMapping("/submitForm")
public String submitForm(@Valid @ModelAttribute("myForm") MyForm myForm, BindingResult result) {
if (result.hasErrors()) {
return "myFormPage"; // Hatalar varsa formu tekrar göster
}
// Başarılı işlem
return "successPage";
}
Dönüş Tipleri
Controller metodları, farklı türlerde değerler döndürebilir:
* String: Bir View adı döndürür. ViewResolver tarafından çözümlenir.
* ModelAndView: Hem Model verilerini hem de View adını içerir.
* POJO (Plain Old Java Object): @ResponseBody (veya @RestController kullanılıyorsa varsayılan olarak) ile birlikte kullanıldığında, nesne JSON/XML’e dönüştürülerek doğrudan yanıt gövdesine yazılır.
* ResponseEntity>: HTTP durum kodu, başlıklar ve yanıt gövdesi üzerinde tam kontrol sağlar. RESTful servislerde yaygın olarak kullanılır.
@GetMapping("/status")
public ResponseEntity getStatus() {
return new ResponseEntity<>("Uygulama çalışıyor!", HttpStatus.OK);
}
@PostMapping("/create")
public ResponseEntity createUser(@RequestBody User newUser) {
// Kullanıcı oluşturma mantığı
return new ResponseEntity<>(newUser, HttpStatus.CREATED);
}
* void: Metot doğrudan HttpServletResponse nesnesini kullanarak yanıtı yazıyorsa veya bir RequestDispatcher kullanarak başka bir kaynağa yönlendiriyorsa kullanılabilir. Ancak, genellikle önerilmez, çünkü Controller metodunun sorumluluğunu artırır ve test edilebilirliğini azaltır.
İleri Seviye Controller Özellikleri
Spring Controller’lar, sadece istekleri işlemekle kalmaz, aynı zamanda veri doğrulama, hata yönetimi, ara kesiciler (interceptors) ve dosya yükleme gibi gelişmiş özellikler sunar.
Veri Doğrulama (Data Validation)
Kullanıcıdan alınan verilerin geçerliliğini kontrol etmek, güvenlik ve veri bütünlüğü açısından kritik öneme sahiptir. Spring, Bean Validation API’si (JSR 303/349) ile entegre olarak güçlü doğrulama yetenekleri sunar.
* @Valid ve @Validated: @ModelAttribute veya @RequestBody ile gelen nesnelerin doğrulanmasını tetikler. BindingResult ile birlikte kullanılır.
* Constraint Anotasyonları: @NotNull, @Size, @Min, @Max, @Email, @Pattern gibi anotasyonlar, POJO sınıflarının alanlarına uygulanarak doğrulama kuralları tanımlanır.
Örnek:
public class UserForm {
@NotNull
@Size(min = 3, max = 50)
private String username;
@Email
@NotNull
private String email;
// Getter ve Setter'lar
}
@PostMapping("/register")
public String registerUser(@Valid @ModelAttribute("userForm") UserForm userForm, BindingResult result) {
if (result.hasErrors()) {
return "registrationForm"; // Hataları gösteren sayfaya dön
}
// Veriler geçerliyse işlem yap
return "registrationSuccess";
}
Hata Yönetimi (Error Handling)
Uygulamalarda beklenmeyen hataların (istisnaların) düzgün bir şekilde yönetilmesi, kullanıcı deneyimi ve uygulamanın sağlamlığı için önemlidir.
* @ExceptionHandler: Bir Controller sınıfı içinde belirli istisna türlerini yakalamak için kullanılır. Metod, istisnayı işleyebilir ve uygun bir hata yanıtı döndürebilir.
@Controller
public class MyController {
// ...
@ExceptionHandler(MyCustomException.class)
public String handleMyCustomException(MyCustomException ex, Model model) {
model.addAttribute("errorMessage", ex.getMessage());
return "errorPage";
}
}
* @ControllerAdvice / @RestControllerAdvice: Uygulama genelinde veya belirli paketlerdeki Controller’lar için global hata yönetimi sağlamak amacıyla kullanılır. Tek bir yerde hata işleme mantığı tanımlamanıza olanak tanır.
@ControllerAdvice
public class GlobalExceptionHandler {
@ExceptionHandler(ResourceNotFoundException.class)
@ResponseStatus(HttpStatus.NOT_FOUND)
public ResponseEntity handleResourceNotFoundException(ResourceNotFoundException ex) {
return new ResponseEntity<>(ex.getMessage(), HttpStatus.NOT_FOUND);
}
@ExceptionHandler(Exception.class)
@ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
public ResponseEntity handleGenericException(Exception ex) {
return new ResponseEntity<>("Bir hata oluştu: " + ex.getMessage(), HttpStatus.INTERNAL_SERVER_ERROR);
}
}
Interceptor’lar (Handler Interceptors)
Interceptor’lar, Controller metodları çağrılmadan önce veya sonra belirli işlemleri gerçekleştirmek için kullanılan mekanizmalardır. Ortak işlevsellikleri (logging, güvenlik kontrolü, yetkilendirme, önbellekleme vb.) merkezi bir yerde yönetmek için idealdir. HandlerInterceptor arayüzü üç metod tanımlar:
* preHandle(): Controller metodu çağrılmadan önce yürütülür. true dönerse işleme devam edilir, false dönerse istek kesilir.
* postHandle(): Controller metodu çağrıldıktan ancak View render edilmeden önce yürütülür. ModelAndView‘ı değiştirebilir.
* afterCompletion(): View render edildikten sonra (isteğin tamamlanmasından sonra) yürütülür. Kaynakları temizlemek için kullanılabilir.
Interceptor’lar, WebMvcConfigurer arayüzünü uygulayan bir yapılandırma sınıfında kaydedilir.
Dosya Yükleme (File Upload)
Spring MVC, dosya yükleme işlemlerini kolayca yönetmek için MultipartFile arayüzünü ve ilgili yapılandırmaları sağlar.
@PostMapping("/upload")
public String handleFileUpload(@RequestParam("file") MultipartFile file, Model model) {
if (!file.isEmpty()) {
try {
byte[] bytes = file.getBytes();
// Dosyayı kaydetme veya işleme mantığı
model.addAttribute("message", "Dosya başarıyla yüklendi: " + file.getOriginalFilename());
} catch (IOException e) {
model.addAttribute("message", "Dosya yüklenirken hata oluştu: " + e.getMessage());
}
} else {
model.addAttribute("message", "Yüklenecek dosya seçilmedi.");
}
return "uploadStatus";
}
Dosya yükleme desteği için genellikle CommonsMultipartResolver veya StandardServletMultipartResolver gibi bir MultipartResolver bean’i yapılandırmak gerekir.
Uluslararasılaşma (Internationalization – I18n)
Uygulamanın farklı dillerde ve bölgesel ayarlarla çalışabilmesi için Controller’lar, LocaleResolver ve LocaleChangeInterceptor gibi bileşenlerle entegre edilebilir. Bu sayede, Controller metodları kullanıcının dil tercihine göre farklı mesajlar veya içerikler sunabilir.
Controller Test Etme
Sağlam ve güvenilir bir uygulama geliştirmek için Controller’ları test etmek hayati öneme sahiptir. Spring, Controller’ları test etmek için güçlü araçlar sunar.
Unit Testler ile MockMvc
Spring Test Framework’ü, MockMvc adı verilen bir araç sağlar. MockMvc, gerçek bir HTTP sunucusu başlatmadan Controller’ları test etmenizi sağlar. HTTP isteğini simüle eder ve Controller metodunun davranışını, Model’i, View adını veya yanıt gövdesini doğrulamaya olanak tanır.
* @WebMvcTest: Belirli bir Controller sınıfını test etmek için tasarlanmış bir dilim test anotasyonudur. Yalnızca MVC katmanını yükler, tüm Spring bağlamını değil, bu da testlerin daha hızlı çalışmasını sağlar.
* MockMvcRequestBuilders ve MockMvcResultMatchers: İstek oluşturmak ve sonuçları doğrulamak için kullanılır.
Örnek:
@WebMvcTest(HomeController.class)
public class HomeControllerTest {
@Autowired
private MockMvc mockMvc;
@Test
void testHomePage() throws Exception {
mockMvc.perform(get("/home"))
.andExpect(status().isOk())
.andExpect(view().name("home"))
.andExpect(model().attributeExists("message"))
.andExpect(model().attribute("message", "Merhaba Spring MVC!"));
}
}
Entegrasyon Testleri
Uygulamanın tüm katmanlarını (Controller, Servis, Repository) gerçek bir ortamda test etmek için entegrasyon testleri kullanılır.
* @SpringBootTest: Spring Boot uygulamaları için entegrasyon testleri yazmak için kullanılır. Tüm Spring bağlamını yükler.
* TestRestTemplate veya WebTestClient: Gerçek HTTP istekleri göndererek uygulamanın API’lerini test etmek için kullanılabilir.
En İyi Uygulamalar ve Tasarım Desenleri
Spring Controller’ları etkili bir şekilde kullanmak için bazı en iyi uygulamaları ve tasarım desenlerini takip etmek önemlidir.
Tek Sorumluluk Prensibi (Single Responsibility Principle – SRP)
Her Controller sınıfı ve metodu, tek bir belirli sorumluluğa sahip olmalıdır. Örneğin, bir UserController sadece kullanıcılarla ilgili işlemleri (oluşturma, okuma, güncelleme, silme) yönetmelidir. Farklı varlıklar veya işlevler için ayrı Controller’lar oluşturmak, kodu daha okunabilir, sürdürülebilir ve test edilebilir hale getirir.
Servis Katmanı Kullanımı
İş mantığını doğrudan Controller içinde yazmaktan kaçınılmalıdır. Controller’ın ana görevi, gelen isteği almak, uygun servis metodunu çağırmak ve yanıtı hazırlamaktır. Tüm iş kuralları, veritabanı etkileşimleri ve karmaşık algoritmalar bir “Servis” katmanına delege edilmelidir. Bu, Controller’ları hafif tutar ve iş mantığının yeniden kullanılabilirliğini artırır.
Örnek:
@RestController
@RequestMapping("/users")
public class UserController {
private final UserService userService; // Servis enjekte edilir
@Autowired
public UserController(UserService userService) {
this.userService = userService;
}
@GetMapping("/{id}")
public User getUser(@PathVariable Long id) {
return userService.findById(id); // İş mantığı serviste
}
}
DTO’lar (Data Transfer Objects)
Controller metodları genellikle istemciden gelen verileri almak veya istemciye veri göndermek için POJO’lar kullanır. Ancak, veritabanı varlıklarını (Entity) doğrudan Controller’da kullanmak yerine, DTO’lar (Data Transfer Objects) kullanmak daha iyi bir uygulamadır. DTO’lar, istemci ile Controller arasında aktarılan verilerin yapısını tanımlar ve hassas verilerin açığa çıkmasını önler.
Açık ve Anlaşılır URL’ler (RESTful Principles)
RESTful API’ler geliştirirken, URL’lerin kaynak odaklı, tahmin edilebilir ve anlamlı olması önemlidir. HTTP metodları (GET, POST, PUT, DELETE) doğru şekilde kullanılmalı ve durum kodları (200 OK, 201 Created, 404 Not Found vb.) uygun yanıtları yansıtmalıdır.
Güvenlik
Controller’lar, Spring Security gibi güvenlik framework’leriyle entegre edilerek kimlik doğrulama (authentication) ve yetkilendirme (authorization) kontrolleri uygulanmalıdır. @PreAuthorize, @PostAuthorize gibi anotasyonlar, metod seviyesinde güvenlik kuralları tanımlamak için kullanılabilir.
Sonuç
Spring MVC Controller’lar, modern Java tabanlı web uygulamalarının ve RESTful API’lerinin temel yapı taşlarıdır. Kullanıcıdan gelen istekleri karşılamak, iş mantığını yönlendirmek ve uygun yanıtları oluşturmak gibi kritik görevleri üstlenirler. @Controller ve @RestController anotasyonları, farklı kullanım senaryoları için esneklik sağlarken, @RequestMapping, @RequestParam, @PathVariable, @RequestBody gibi anotasyonlar ise istek parametrelerini ve gövdelerini kolayca işlemeyi mümkün kılar.
Veri doğrulama, hata yönetimi, interceptor’lar ve dosya yükleme gibi gelişmiş özellikler, Controller’ların sadece temel işlevleri yerine getirmesini değil, aynı zamanda sağlam, güvenli ve kullanıcı dostu uygulamalar geliştirmeyi de destekler. MockMvc gibi araçlarla test edilebilirlik, Controller’ların kalitesini ve güvenilirliğini artırır.
En iyi uygulamaları takip ederek – Controller’ları hafif tutmak, iş mantığını servis katmanlarına delege etmek, DTO’lar kullanmak ve RESTful prensiplere uymak – daha sürdürülebilir, ölçeklenebilir ve yönetilebilir uygulamalar inşa edilebilir. Spring Framework’ün sağladığı bu güçlü ve esnek Controller mekanizması, geliştiricilere modern web uygulamalarını hızlı ve verimli bir şekilde oluşturma imkanı sunar. Spring Controller’ları derinlemesine anlamak ve doğru bir şekilde uygulamak, herhangi bir Spring tabanlı projenin başarısı için anahtardır.