[java] Guice를 사용한 이미지 처리

17 Nov 2023

java

이미지 처리는 많은 애플리케이션에서 필요한 기능이다. 자바 개발자들은 주로 ImageIO 또는 Java Advanced Imaging API를 사용하여 이미지를 처리한다. 그러나 이런 방식은 코드의 가독성과 유지 보수성을 저하시킬 수 있다.

Guice는 의존성 주입(Dependency Injection) 프레임워크로서 이미지 처리를 더욱 쉽고 유연하게 만들어 준다. Guice를 사용하여 이미지 처리를 구현해 보자.

Guice 설정

먼저 Guice를 사용하기 위해 프로젝트에 아래의 의존성을 추가해야 한다.

<dependency>
    <groupId>com.google.inject</groupId>
    <artifactId>guice</artifactId>
    <version>4.2.2</version>
</dependency>

이미지 처리 모듈 생성

이미지 처리에 필요한 모듈을 생성해야 한다. 아래와 같이 ImageModule 클래스를 생성하고, configure() 메서드에서 이미지 처리에 필요한 의존성들을 바인딩한다.

import com.google.inject.AbstractModule;
import java.io.File;
import java.util.logging.Logger;

public class ImageModule extends AbstractModule {

    private static final Logger LOGGER = Logger.getLogger(ImageModule.class.getName());

    private final File imageDirectory;

    public ImageModule(File imageDirectory) {
        this.imageDirectory = imageDirectory;
    }

    @Override
    protected void configure() {
        LOGGER.info("Binding ImageProcessor");
        bind(ImageProcessor.class).to(ImageProcessorImpl.class);
        
        LOGGER.info("Binding ImageRepository");
        bind(ImageRepository.class).toInstance(new ImageRepositoryImpl(imageDirectory));
    }
}

위에서 ImageProcessor와 ImageRepository는 이미지 처리에 필요한 인터페이스이다. ImageProcessorImpl과 ImageRepositoryImpl은 실제 구현체다.

이미지 처리 인터페이스 및 구현체 생성

ImageProcessor 인터페이스를 아래와 같이 생성한다.

public interface ImageProcessor {
    void processImage(File imageFile);
}

이 인터페이스를 구현한 실제 클래스 ImageProcessorImpl을 생성한다.

import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;

public class ImageProcessorImpl implements ImageProcessor {
    @Override
    public void processImage(File imageFile) {
        try {
            BufferedImage image = ImageIO.read(imageFile);

            // 이미지 처리 로직 구현

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

ImageRepository 인터페이스와 실제 구현체 ImageRepositoryImpl도 아래와 같이 생성한다.

public interface ImageRepository {
    void saveImage(BufferedImage image, String fileName);
}

public class ImageRepositoryImpl implements ImageRepository {

    private final File imageDirectory;

    public ImageRepositoryImpl(File imageDirectory) {
        this.imageDirectory = imageDirectory;
    }

    @Override
    public void saveImage(BufferedImage image, String fileName) {
        File output = new File(imageDirectory, fileName);
        try {
            ImageIO.write(image, "png", output);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

이미지 처리 사용 예제

이제 위에서 생성한 모듈과 인터페이스, 구현체를 사용하여 이미지 처리를 할 수 있다. 아래는 예제 코드이다.

import com.google.inject.Guice;
import com.google.inject.Injector;
import java.io.File;

public class ImageProcessingExample {

    public static void main(String[] args) {
        File imageDirectory = new File("path/to/image/directory");

        Injector injector = Guice.createInjector(new ImageModule(imageDirectory));
        ImageProcessor imageProcessor = injector.getInstance(ImageProcessor.class);

        File imageFile = new File(imageDirectory, "example.jpg");
        imageProcessor.processImage(imageFile);
    }
}

위의 예제 코드에서 ImageProcessingExample 클래스는 Guice를 사용하여 ImageProcessor 의존성을 주입받아 이미지 처리를 수행하는 예제이다.

결론

Guice를 사용하면 이미지 처리 기능을 더욱 유연하고 간편하게 구현할 수 있다. Guice를 사용한 이미지 처리는 코드의 가독성과 유지 보수성을 향상시키며, 의존성 주입을 통해 각 구현체들을 유연하게 교체할 수 있는 장점을 가진다.