Inversion of Control (IoC)

Inversion of Control (IoC) is not a design pattern, is a software principle. The main purpose of IoC is to minimize dependencies and manage object instances. IoC often uses with dependency injection. However, dependency injection is just an implementation of IoC. One of the best examples of using IoC is Spring Framework.

There are 2 IoC containers in Spring Framework, BeanFactory, and ApplicationContext. These container structures manage the components that make up the application using the dependency injection principle. Objects get about information such as XML, Java Code, and Java Annotation. It also provides convenience to the developer by adjusting the lifecycles of the objects themselves.

Dependency Injection (DI)

Dependency injection is a programming principle that allows an object to receive its dependencies (objects it needs to function) from an external source, rather than creating them itself. It realizes this transaction by decoupling the usage of an object from its creation. Thus, it will carry out dependency inversion and single responsibility from SOLID principles. As everyone knows, SOLID principles increase the reusability of our code, and its aim is to decrease what you need to change in a class. Dependency injection supports these goals by separating the usage and creation of an object. Please note that the creation of an object is more costly than the usage of that object.

The dependency injection principle is an alternative to the service locator pattern. Most popular frameworks implement dependency injection in their structure. So that, we can focus to be done business logic instead of the technical infrastructure. Some frameworks that use the dependency injection principle are as follows.

1. Spring Framework: Spring is a popular Java-based framework that provides comprehensive infrastructure support for building enterprise applications. It provides a built-in dependency injection mechanism.

2. Google Guice: Guice is a lightweight dependency injection framework for Java.

3. Dagger: Dagger is a dependency injection framework for Android and Java.

4. PicoContainer: PicoContainer is a lightweight Java-based dependency injection container.

5. AngularJS: AngularJS is a JavaScript-based framework for building web applications. It uses dependency injection to make components and services available to other components in the application.

6. React-Redux: React-Redux is a popular JavaScript library for building user interfaces with the React JavaScript library. It uses dependency injection to provide the store to the React components.

These are just a few examples of frameworks that use dependency injection. There are many other frameworks and libraries that use dependency injection in different programming languages.

Let’s do an example together now. Let’s say we have a class called DesktopComputerService that has a start method. It is defined as follows.

public class DesktopComputerService {

    public void start(String computerAccountName){
        System.out.println("Welcome to " + computerAccountName);
    }

}

This class shows a message when we turn on the computer. Our application code will be like below.

public class MyComputer {

    Laptop laptop;
    public MyComputer(Laptop laptop) {
        this.laptop = laptop;
    }

    public void startComputer(String accountName){
        laptop.start(accountName);
    }

}

Our client code that will use MyComputer class to start computer will be like below.

public static void main(String[] args) {
        MyComputer computer = new MyComputer();
        computer.startComputer("Alex Donnie");
}

Although everything seems normal in the code at first glance, some restrictions and difficulties will arise as the code grows.

· As is seen in the code, MyComputer class depends on DesktopComputerService class. This means that any future changes you make to the DesktopComputerService class will affect the MyComputer class.

· If we want to add new computer types as Laptop, Gaming, we will have to write other application for these.

· On the other hand, testing this application is very difficult because there is no way to mock it in the test class.

We have talked about what kind of difficulties we will encounter when we write a program without dependency injection. Let’s recode and expand the application using the dependency injection principle.

Firstly, we should use interfaces to use effectively classes and methods. By defining an interface called ComputerService, we include common methods for computer types.

public interface ComputerService {

    void start(String accountName);

    void logOut(String accountName);

}

Thus we can use the Laptop class as an implementation of ComputerService.

public class Laptop implements ComputerService{

    @Override
    public void start(String accountName) {
        System.out.println("Welcome to " + accountName);
    }

    @Override
    public void logOut(String accountName) {
        System.out.println("Logging out " + accountName);
    }

}

Finally, we create a class ourselves that is named “MyComputer”. We want to create an object from the Laptop class and use the class properties. We create an object from the Laptop class using dependency injection. There are three ways to implement dependency injection:

1. Constructor Injection

2. Setter Injection

3. Interface Injection

In summary, using dependency injection we created and managed objects. Many frameworks as Spring, manage self the dependency injection process. See you in another article. Stay with Java.

References

Inversion of Control Containers and the Dependency Injection pattern

https://www.digitalocean.com/community/tutorials/java-dependency-injection-design-pattern-example-tutorial

Spring batch, güçlü batch uygulamaları geliştirmek için tasarlanan açık kaynak bir araçtır. Spring batch sayesinde geniş hacimli verilerin işlenmesi, kayıtların takibi (logging/tracking), yapılan işlerin istatistikleri (job processing statistics), kaynak yönetimi (resource management) gibi konularda büyük kolaylıklar sağlar.

Yukarıdaki şemada spring batch yapısının genel işleyişini basit şekilde görebiliriz. Reader, verileri bir veri tabanından, dosyadan ya da kuyruktan okur. Okunan veriler processor yapısına iletilerek işlenir. Writer adımında ise işlenen veriler veri tabanına ya da dosyaya yazılarak süreç tamamlanmış olur. Bütün bu sürece (Reader -> Processor -> Writer) step denir. Oluşturulan bu step’ler ise Job dediğimiz yapılarla çalışır. Bir job birden fazla step çalıştırabileceği gibi bir programda birden fazla job da olabilir. Gelin şimdi hep beraber spring batch’in mimarisine bakalım.

Spring Batch Architecture

Spring batch’in katmanlı mimarisi 3 önemli komponentten oluşmaktadır.

Application katmanı, geliştiriciler tarafından yazılan bütün job’ları ve özel kodları içerir.

Batch core katmanı, job’ları başlatmak ve kontrol etmek için gerekli olan ana sınıfları içerir. Ayrıca JobLauncher, Job ve Step gibi adımların implemetasyonları yapılır.

Batch infrastructure katmanı, hem geliştiriciler (ItemReader ve ItemWriter) hem de framework tarafından kullanılan (RetryTemplate) reader ve writer methodları içerir.

Spring Batch Example

Spring hakkında genel bir fikir edindik, şimdi adım adım bir batch uygulaması yazalım. Bu örnek kapsamında haber raporlarını içeren veri seti kullandım. Excel formatında ki bu veri setini okuyarak tablolara yazacağız.

İlk olarak gerekli dependency’lerimiz pom.xml dosyamıza ekleyerek başlıyoruz. Proje kapsamında postgresql ve spring data jpa kullanacağız. Farklı bir veri tabanı ile çalışmak isterseniz maven repository’den (https://mvnrepository.com/) gerekli dependency’leri indirebilirsiniz.

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-batch</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>org.postgresql</groupId>
            <artifactId>postgresql</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.36</version>
        </dependency>

application.properties dosyasında veri tabanı bağlantı ayarlarımızı ve batch’e ait bazı konfigürasyonları yapıyoruz. Eğer program ayağa kalkar kalkmaz batch’in çalışmasını istemiyorsak spring.batch.job.enabled özelliğini false olarak güncellemeliyiz.

spring.datasource.driver-class-name=org.postgresql.Driver
spring.datasource.url=jdbc:postgresql://localhost:5432/demoBatch
spring.datasource.username=postgres
spring.datasource.password=postgres

spring.jpa.hibernate.ddl-auto=update
spring.batch.jdbc.initialize-schema=always
spring.jpa.show-sql=true


#disabled job run at startup
spring.batch.job.enabled=false
spring.main.allow-bean-definition-overriding=true

Entity ve Repository

Csv dosyasından okunacak olan verileri NewsReport entity sınıfı temsil etmektedir. Haberler gerçekliğe göre ayrılırken ise RealNews ve FakeNews sınıfları kullanılmıştır. Her entity sınıfına ait repository interface’leri bulunmaktadır. Benzer yapıda oldukları için aşağıda sadece RealNews ve RealNewsRepository kodlarına yer verilmiştir.

@Data
@Entity
@Table(name = "REAL_NEWS")
public class RealNews {

    @Id
    @GeneratedValue
    private Long id;

    @Column(columnDefinition = "text", name = "TITLE")
    private String title;

    @Column(columnDefinition = "text", name = "NEWS_URL")
    private String url;

    @Column(name = "SOURCE_DOMAIN")
    private String sourceDomain;

    @Column(name = "TWEET_NUM")
    private int tweetNum;

}

Program için ön hazırlığımızı yaptığımıza göre artık batch kısmına girebiliriz. Yukarıda da bahsettiğim gibi veriler bir dosya, veri tabanı ya da kuyruktan okunabilir. Bu dosya üzerinden ve veri tabanından veri okuyacağız.

public interface RealNewsRepository extends JpaRepository<RealNews,Long> {
}

Reader

İlk aşamada .csv formatta bir dosyadan veri okuyacağımız için FlatFileItemReaderBuilder kullandık. FlatFileItemReaderBuilder’ın ayrıntıları için dökümana (https://docs.spring.io/spring-batch/docs/current/api/org/springframework/batch/item/file/builder/FlatFileItemReaderBuilder.html) bakabilirsiniz. Burada ki önemli nokta dosyadan okunan verilerin oluşturmuş olduğumuz entity sınıfı ile eşleşebilmesidir. Bunun için csv dosyasında bulunan kolon isimleri ile entity sınıfında yapılan tanımlar aynı olmalıdır.

@Bean(name = "readerNewsReportCSVFile")
public ItemReader<NewsReport> readerNewsReportCSVFile(){
    return new FlatFileItemReaderBuilder<NewsReport>()
         .name("readerNewsReportCSVFile")
         .resource(new FileSystemResource("dataset/FakeNewsNet.csv"))
         .linesToSkip(1)
         .delimited()
         .names("title","news_url","source_domain","tweet_num","real")
         .targetType(NewsReport.class)
         .build();
}

Çeşitli işlemleri gerçekleştirebilmek için farklı Reader sınıfları vardır. Örneğin dosya üzerinden FlatFileItemReader ile okuma işlemi yapılabilirken, RepositoryItemReader sınıfı veri tabanından okuma yapar. Daha detaylı bilgi için https://docs.spring.io/spring-batch/docs/current/reference/html/readersAndWriters.html#repositoryItemReader adresini ziyaret edebilirsiniz.

@Bean(name = "readerNewsReportByRealStatus")
public RepositoryItemReader<NewsReport> readerNewsReportByRealStatus(){
    RepositoryItemReader<NewsReport> reader = new RepositoryItemReader<>();
    reader.setRepository(newsReportRepository);
    reader.setMethodName("findByReal");
    List<Object> queryMethodArguments = new ArrayList<>();
    queryMethodArguments.add("1");
    reader.setArguments(queryMethodArguments);
    Map<String, Sort.Direction> sorts = new LinkedHashMap<>();
    sorts.put("id", Sort.Direction.ASC);
    reader.setSort(sorts);
    return reader;
}

Processor

Reader ve Writer adımları birçok işimizi tamamlamak için yeterlidir. Ancak bazı durumlarda writer adımına geçmeden önce business logic ekleme ihtiyacımız olabilir. Bu durumlarda akışa process ekleyerek ara işlemlerimizi gerçekleştirebiliriz.

@Slf4j
@Component
public class RealNewsProcessor implements ItemProcessor<NewsReport, RealNews>{

    @Override
    public RealNews process(NewsReport newsReport) throws Exception {
        log.info("Processing real news.....{}", newsReport);
        RealNews realNews = new RealNews();
        realNews.setUrl(newsReport.getNews_url());
        realNews.setTitle(newsReport.getTitle());
        realNews.setTweetNum(Integer.parseInt(newsReport.getTweet_num()));
        realNews.setSourceDomain(newsReport.getSource_domain());
        return realNews;
    }

}

Burada csv dosyasından okunan haber verilerinin gerçeklik durumuna göre ayrıştırılmasını process adımlarında sağladık. Ayrıştırılan gerçek haberleri RealNews nesnesi ile Writer adımına aktarıyoruz.

Writer

Writer adımında ise Process adımından geriye dönen nesne veri tabanı veya dosyaya yazılır.

@Bean(name = "writerRealNewsReportTable")
public RepositoryItemWriter<RealNews> writerRealNewsReportTable(){
    RepositoryItemWriter<RealNews> writer = new RepositoryItemWriter<>();
    writer.setRepository(realNewsRepository);
    writer.setMethodName("save");
    return writer;
}

Step

Step adımını, şu zamana kadar yapmış olduğumuz Reader, Process ve Writer adımlarının toparlandığı bölüm olarak düşünebiliriz. Listener ile step’den önce ve sonraki hareketleri kontrol edebiliriz.

@Bean
public Step stepRealNewsReport(@Qualifier("readerNewsReportByRealStatus") ItemReader<NewsReport> itemReader, @Qualifier("writerRealNewsReportTable") ItemWriter<RealNews> itemWriter, StepCompletionNotificationListener listener){
    return stepBuilderFactory
           .get("stepRealNewsReport")
           .listener(listener)
           .<NewsReport, RealNews>chunk(50)
           .reader(itemReader)
           .processor(realNewsProcessor())
           .writer(itemWriter)
           .build();
}

Step’ler chunk ve tasklet olmak üzere 2 farklı şekilde oluşturulabilirler. Chunk yapısı ile hangi veri tipinden, tek transactionda kaç adet veri okunup işleneceği verilir. Chunk’da verilen ilk parametre okunan verinin hangi tipte olduğunu ikinci parametre ise hangi tipte yazılacağını temsil etmektedir. Chunksize ise transaction başına kaç verinin işleneceğini belirler. Tasklet, bir kaynaktan dosya silme veya bir kaynağa dosya yüklemek gibi tek işin gerçekleştirildiği yapılardır. Bu örnekte chunk processing tercih edilmiştir.

Job

Job adımı ile beraber oluşturmuş olduğumuz step’leri sırasıyla çalıştırıyoruz. Step adımında olduğu gibi Job’larda da listener yapıları kullanılabilir. Böylece Job’ların çalışmadan önce ve sonraki durumları kontrol edilebilir.

@Bean
public Job job(JobCompletionNotificationListener listener,Step stepNewsReport,Step stepRealNewsReport,Step stepFakeNewsReport){
    return jobBuilderFactory
           .get("job")
           .incrementer(new RunIdIncrementer())
           .listener(listener)
           .start(stepNewsReport)
           .next(stepRealNewsReport)
           .next(stepFakeNewsReport)
           .build();
}

Job’lar için listener’ın yanında farklı konfigürasyonlarda yapılabilir. Örneğin, bir job tekrardan başlatılması istenmiyorsa preventRestart() ile bu engellenebilir.

Kaynak kodlara erişmek için https://github.com/eymeneruyar/Spring-Batch-NewsReport

Referanslar

https://www.tutorialsbuddy.com/spring-batch-with-mysql-example

Spring Batch - Reference Documentation

https://www.kaggle.com/