Merhaba değerli Java dostları,
Bugünkü yazımda bir tasarım yöntemi olan aynı zamanda, özellikle Spring olmak üzere, çeşitli frameworklerde kullanılan bir yönteme değinmek istiyorum. Yöntemimizin adı method injection, tam Türkçe’ ye çeviremesek de diğer adıyla metot bağımlılığını enjekte etmek.
Method injection çıkış noktası, uygulama boyunca scope değeri farklı olan bean örneklerinin birbirine ihtiyaç duyması. Yine method injection için temel nokta, singleton yani tekil bir nesnenin kendi içerisinde prototype yani devamlı yeni nesneye ihtiyaç duyması. Singleton nesne sadece bir defa new ile oluşturulup, tüm uygulama boyunca kullanılacağı için prototype nesnenin devamlı new edilme imkanı ortadan kalkıyor. Spring ile method injection çok basit bir şekilde yapılıyor. Klasik bean tanımlamalarımıza ek olarak lookup-method ekliyoruz ve method injection gerçekleşmiş oluyor.
Önce sınıflarımıza bakalım.
package anajavatica.spring.methodinjection;
import java.awt.Color;
public class Car {
private Color carColor = null;
public Color getCarColor() {
return carColor;
}
public void setCarColor(Color carColor) {
this.carColor = carColor;
}
} |
Bir Car sınıfı ve basit olarak içerisinde renk mevcut. Car sınıfı bizim prototype sınıfımız olacak. Şimdi singleton sınıfa bakalım.
package anajavatica.spring.methodinjection;
import java.awt.Color;
import java.util.Random;
public abstract class CarFactory {
private Random randomGenerator = new Random();
public Car generateCar() {
return new Car();
}
public abstract Car generateCarByInjection();
public void produceCar() {
Car newCar = generateCar();
newCar.setCarColor(new Color(randomGenerator.nextInt(256), randomGenerator.nextInt(256), randomGenerator.nextInt(256)));
System.out.println(“Car produced with color: ” + newCar.getCarColor().getRed() + ” ” + newCar.getCarColor().getGreen() + ” ”
+ newCar.getCarColor().getBlue());
}
public void produceCarByInjection() {
Car newCar = generateCarByInjection();
newCar.setCarColor(new Color(randomGenerator.nextInt(256), randomGenerator.nextInt(256), randomGenerator.nextInt(256)));
System.out.println(“Car produced with injection with color: ” + newCar.getCarColor().getRed() + ” ” + newCar.getCarColor().getGreen() + ” ”
+ newCar.getCarColor().getBlue());
}
} |
Burada hem klasik new hem de method injection yöntemini göstermek için iki aynı kod bloğu mevcut. Son olarak xml tanımı ve main sınıfına baktıktan sonra detaylara girelim.
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”>
scope=”prototype” />
scope=”singleton”>
|
Main sınıfımız.
package anajavatica.spring.methodinjection;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MethodInjectionMain {
public static void main(String[] args) throws InterruptedException {
ApplicationContext context = new ClassPathXmlApplicationContext(“methodInjection.xml”);
CarFactory carFactory = context.getBean(“carFactory”, CarFactory.class);
carFactory.produceCar();
carFactory.produceCarByInjection();
carFactory.produceCar();
carFactory.produceCarByInjection();
((ClassPathXmlApplicationContext) context).close();
}
} |
Aslında çıktı olarak bakarsak iki yöntem de tam istediğimiz şeyleri yapıyor. produceCar metodu kendi içerisinde generateCar çağırıyor ve bu metot tamamen Car nesnesini bilmek zorunda. Yani yarın Car sınıfının constructoruna eklenecek olan bir alan bu sınıfı direkt etkileyecektir. Yani CarFactory sınıfı Car sınıfı ile ilgili herşeyi bilmek zorunda.
Method injection yönteminde ise bize Car üretecek metodu abstract tanımlıyoruz. Böylece bizim için sadece bir Car nesnesinin üretilmesi önemli duruma geliyor. Car sınıfı ile iligli detaya sahip olmamıza gerek kalmıyor. produceCarByInjection ise bu abstract metodu kullanarak method injection yöntemini gerçekleştirmiş oluyor.
Peki Spring bunu nasıl hallediyor diye soracak olursak olay çok basit bir XML tanımında saklı. Prototype bean tanımından sonra singleton bean tanımını yapıyoruz ve her defasında new ile nesne üretecek abstract metodu lookup-method özelliği ile veriyoruz. Böylece Spring bizim yerimize o sınıftan bir nesne üretip yine bizim yerimize get olarak döndürecektir.
Method injection yönteminin avantajları olmasına rağmen bazı dezavantajları da mevcut. Bunlardan ilk akla geleni, abstract bir yapı kullanılmasından dolayı birim test olayının zorlaşması. Diğer bir dezavantaj ise kodun anlaşılabilirliği azalmaktadır. Abstract metodun kimin tarafından ve nasıl doldurulduğu gibi akış zor takip edilmektedir.
Bol Java’ lı günler dileğiyle…
Yazan: Faruk BOZAN
