Guice는 오픈 소스, Java 기반 종속성 주입 프레임 워크입니다. 조용하고 가볍고 Google에서 적극적으로 개발 / 관리하고 있습니다.

의존성 주입

모든 Java 기반 애플리케이션에는 최종 사용자가 작동하는 애플리케이션으로 보는 것을 표시하기 위해 함께 작동하는 몇 가지 개체가 있습니다. 복잡한 Java 애플리케이션을 작성할 때 애플리케이션 클래스는 다른 Java 클래스와 가능한 한 독립적이어야 이러한 클래스를 재사용하고 단위 테스트 중에 다른 클래스와 독립적으로 테스트 할 수 있습니다. 의존성 주입 (또는 와이어 링이라고도 함)은 이러한 클래스를 하나로 묶고 동시에 독립적으로 유지하는 데 도움이됩니다.

텍스트 편집기 구성 요소가 있고 맞춤법 검사를 제공하려는 응용 프로그램이 있다고 가정합니다. 표준 코드는 다음과 같습니다.

public class TextEditor {
   private SpellChecker spellChecker;
   
   public TextEditor() {
      spellChecker = new SpellChecker();
   }
}

여기서 우리가 한 것은 TextEditor와 SpellChecker 사이에 의존성을 생성하는 것입니다. 반전 제어 시나리오에서 대신 다음과 같은 작업을 수행합니다.

public class TextEditor {
   private SpellChecker spellChecker;
   
   @Inject
   public TextEditor(SpellChecker spellChecker) {
      this.spellChecker = spellChecker;
   }
}

여기서 TextEditor는 SpellChecker 구현에 대해 걱정할 필요가 없습니다. SpellChecker는 독립적으로 구현되며 TextEditor 인스턴스화시 TextEditor에 제공됩니다.

Guice를 사용한 종속성 주입 (바인딩)

종속성 주입은 Guice 바인딩에 의해 제어됩니다. Guice는 바인딩을 사용하여 개체 유형을 실제 구현에 매핑합니다. 이러한 바인딩은 모듈로 정의됩니다. 모듈은 아래와 같이 바인딩 모음입니다.

public class TextEditorModule extends AbstractModule {
   @Override 
   protected void configure() {
      /*
      * Bind SpellChecker binding to WinWordSpellChecker implementation 
      * whenever spellChecker dependency is used.
      */
      bind(SpellChecker.class).to(WinWordSpellChecker.class);
   }
}

모듈은 Guice의 객체 그래프 작성기 인 인젝터의 핵심 빌딩 블록입니다. 첫 번째 steo는 인젝터를 만든 다음 인젝터를 사용하여 개체를 가져올 수 있습니다.

public static void main(String[] args) {
   /*
   * Guice.createInjector() takes Modules, and returns a new Injector
   * instance. This method is to be called once during application startup.
   */
   Injector injector = Guice.createInjector(new TextEditorModule());
   /*
   * Build object using injector
   */
   TextEditor textEditor = injector.getInstance(TextEditor.class);   
}

위의 예에서 TextEditor 클래스 개체 그래프는 Guice에 의해 구성되며이 그래프에는 TextEditor 개체와 WinWordSpellChecker 개체로서의 종속성이 포함됩니다.

지역 환경 설정

여전히 Java 프로그래밍 언어에 대한 환경을 설정하려는 경우이 섹션에서는 시스템에서 Java를 다운로드하고 설정하는 방법을 안내합니다. 환경을 설정하려면 아래 단계를 따르십시오.

Java SE는 Java 다운로드 링크에서 무료로 사용할 수 있습니다 . 따라서 운영 체제에 따라 버전을 다운로드합니다.

지침에 따라 Java를 다운로드하고 .exe컴퓨터에 Java를 설치합니다. 시스템에 Java를 설치 한 후에는 올바른 설치 디렉토리를 가리 키도록 환경 변수를 설정해야합니다.

Windows 2000 / XP 용 경로 설정

c : \ Program Files \ java \ jdk 디렉토리에 Java를 설치했다고 가정합니다 .

• '내 컴퓨터'를 마우스 오른쪽 버튼으로 클릭하고 '속성'을 선택합니다.

• '고급'탭에서 '환경 변수'버튼을 클릭합니다.

• 이제 Java 실행 파일의 경로도 포함하도록 'Path'변수를 변경하십시오. 예를 들어 현재 경로가 'C : \ WINDOWS \ SYSTEM32'로 설정된 경우 경로를 'C : \ WINDOWS \ SYSTEM32; c : \ Program Files \ java \ jdk \ bin'으로 변경합니다.

Windows 95 / 98 / ME 용 경로 설정

c : \ Program Files \ java \ jdk 디렉토리에 Java를 설치했다고 가정합니다 .

• 'C : \ autoexec.bat'파일을 편집하고 끝에 'SET PATH = % PATH %; C : \ Program Files \ java \ jdk \ bin'줄을 추가합니다.

Linux, UNIX, Solaris, FreeBSD에 대한 경로 설정

환경 변수 PATH는 Java 바이너리가 설치된 위치를 가리 키도록 설정되어야합니다. 이 작업을 수행하는 데 문제가 있으면 쉘 문서를 참조하십시오.

예를 들어 bash를 셸로 사용하는 경우 '.bashrc : export PATH = / path / to / java : $ PATH'끝에 다음 줄을 추가합니다.

인기있는 자바 편집자

Java 프로그램을 작성하려면 텍스트 편집기가 필요합니다. 시중에는 정교한 IDE가 많이 있습니다. 그러나 지금은 다음 중 하나를 고려할 수 있습니다.

• Notepad − Windows 시스템에서는 메모장 (이 자습서에 권장 됨), TextPad와 같은 간단한 텍스트 편집기를 사용할 수 있습니다.

• Netbeans − 오픈 소스이며 무료로 제공되는 Java IDE입니다. https://www.netbeans.org/index.html.

• Eclipse − 또한 Eclipse 오픈 소스 커뮤니티에서 개발 한 Java IDE이며 다음에서 다운로드 할 수 있습니다. https://www.eclipse.org/.

Google Guice 환경

최신 버전의 Google Guice 및 관련 jar 파일을 다운로드합니다.

• Google Guice 4.0

• AOP 얼라이언스 1.0

• 구아바 16.0.1

• javax.inject 1.0

이 튜토리얼을 작성하는 시점에 C : \> Google 폴더에 복사했습니다.

OS	아카이브 이름
윈도우	guice-4.1.0.jar; aopalliance-1.0.jar; guava-16.0.1.jar; javax.inject-1.jar
리눅스	guice-4.1.0.jar; aopalliance-1.0.jar; guava-16.0.1.jar; javax.inject-1.jar
맥	guice-4.1.0.jar; aopalliance-1.0.jar; guava-16.0.1.jar; javax.inject-1.jar

CLASSPATH 변수 설정

설정 CLASSPATHGuice jar 위치를 가리키는 환경 변수. 다음과 같이 다양한 운영 체제의 Google 폴더에 Guice 및 관련 jar를 저장했다고 가정합니다.

OS	산출
윈도우	환경 변수 CLASSPATH를 % CLASSPATH %; C : \ Google \ guice-4.1.0.jar; C : \ Google \ aopalliance-1.0.jar; C : \ Google \ guava-16.0.1.jar; C : \로 설정합니다. Google \ javax.inject-1.jar;.;
리눅스	export CLASSPATH = $ CLASSPATH : Google / guice-4.1.0.jar : Google / aopalliance-1.0.jar : Google / guava-16.0.1.jar : Google / javax.inject-1.jar :.
맥	export CLASSPATH = $ CLASSPATH : Google / guice-4.1.0.jar : Google / aopalliance-1.0.jar : Google / guava-16.0.1.jar : Google / javax.inject-1.jar :.

Guice 바인딩 메커니즘을 사용하여 단계별로 종속성 주입을 시연 할 샘플 콘솔 기반 애플리케이션을 만들어 보겠습니다.

1 단계 : 인터페이스 생성

//spell checker interface
interface SpellChecker {
   public void checkSpelling();
}

2 단계 : 구현 생성

//spell checker implementation
class SpellCheckerImpl implements SpellChecker {
   @Override
   public void checkSpelling() {
      System.out.println("Inside checkSpelling." );
   } 
}

3 단계 : 바인딩 모듈 생성

//Binding Module
class TextEditorModule extends AbstractModule {
   @Override
   protected void configure() {
      bind(SpellChecker.class).to(SpellCheckerImpl.class);
   } 
}

4 단계 : 종속성이있는 클래스 만들기

class TextEditor {
   private SpellChecker spellChecker;
   @Inject
   public TextEditor(SpellChecker spellChecker) {
      this.spellChecker = spellChecker;
   }
   public void makeSpellCheck(){
      spellChecker.checkSpelling();
   }
}

5 단계 : 인젝터 생성

Injector injector = Guice.createInjector(new TextEditorModule());

6 단계 : 종속성이 충족 된 객체를 가져옵니다.

TextEditor editor = injector.getInstance(TextEditor.class);

7 단계 : 개체를 사용합니다.

editor.makeSpellCheck();

완전한 예

GuiceTester라는 Java 클래스를 만듭니다.

GuiceTester.java

import com.google.inject.AbstractModule;
import com.google.inject.Guice;
import com.google.inject.Inject;
import com.google.inject.Injector;

public class GuiceTester {
   public static void main(String[] args) {
      Injector injector = Guice.createInjector(new TextEditorModule());
      TextEditor editor = injector.getInstance(TextEditor.class);
      editor.makeSpellCheck(); 
   } 
}

class TextEditor {
   private SpellChecker spellChecker;

   @Inject
   public TextEditor(SpellChecker spellChecker) {
      this.spellChecker = spellChecker;
   }

   public void makeSpellCheck(){
      spellChecker.checkSpelling();
   }
}

//Binding Module
class TextEditorModule extends AbstractModule {

   @Override
   protected void configure() {
      bind(SpellChecker.class).to(SpellCheckerImpl.class);
   } 
}

//spell checker interface
interface SpellChecker {
   public void checkSpelling();
}


//spell checker implementation
class SpellCheckerImpl implements SpellChecker {

   @Override
   public void checkSpelling() {
      System.out.println("Inside checkSpelling." );
   } 
}

산출

파일을 컴파일하고 실행하면 다음 출력이 표시됩니다.

Inside checkSpelling.

연결된 바인딩에서 Guice는 유형을 해당 구현에 매핑합니다. 아래 예제에서는 SpellCheckerImpl 구현으로 SpellChecker 인터페이스를 매핑했습니다.

bind(SpellChecker.class).to(SpellCheckerImpl.class);

구체적인 클래스를 하위 클래스에 매핑 할 수도 있습니다. 아래 예를 참조하십시오.

bind(SpellCheckerImpl.class).to(WinWordSpellCheckerImpl.class);

여기서 우리는 바인딩을 연결했습니다. 완전한 예에서 결과를 보겠습니다.

완전한 예

GuiceTester라는 Java 클래스를 만듭니다.

GuiceTester.java

import com.google.inject.AbstractModule;
import com.google.inject.Guice;
import com.google.inject.Inject;
import com.google.inject.Injector;

public class GuiceTester {
   public static void main(String[] args) {
      Injector injector = Guice.createInjector(new TextEditorModule());
      TextEditor editor = injector.getInstance(TextEditor.class);
      editor.makeSpellCheck(); 
   } 
}

class TextEditor {
   private SpellChecker spellChecker;

   @Inject
   public TextEditor(SpellChecker spellChecker) {
      this.spellChecker = spellChecker;
   }

   public void makeSpellCheck(){
      spellChecker.checkSpelling();
   }
}

//Binding Module
class TextEditorModule extends AbstractModule {

   @Override
   protected void configure() {
      bind(SpellChecker.class).to(SpellCheckerImpl.class);
      bind(SpellCheckerImpl.class).to(WinWordSpellCheckerImpl.class);
   } 
}

//spell checker interface
interface SpellChecker {
   public void checkSpelling();
}


//spell checker implementation
class SpellCheckerImpl implements SpellChecker {

   @Override
   public void checkSpelling() {
      System.out.println("Inside checkSpelling." );
   } 
}

//subclass of SpellCheckerImpl
class WinWordSpellCheckerImpl extends SpellCheckerImpl{
   @Override
   public void checkSpelling() {
      System.out.println("Inside WinWordSpellCheckerImpl.checkSpelling." );
   } 
}

산출

파일을 컴파일하고 실행하면 다음 출력이 표시됩니다.

Inside WinWordSpellCheckerImpl.checkSpelling.

구현과 함께 유형을 바인딩 할 수 있습니다. 여러 구현으로 유형을 매핑하려는 경우 사용자 지정 주석도 만들 수 있습니다. 개념을 이해하려면 아래 예를 참조하십시오.

바인딩 주석 만들기

@BindingAnnotation @Target({ FIELD, PARAMETER, METHOD }) @Retention(RUNTIME)
@interface WinWord {}

• @BindingAnnotation -주석을 바인딩 주석으로 표시합니다.

• @Target -주석의 적용 가능성을 표시합니다.

• @Retention -주석의 가용성을 런타임으로 표시합니다.

바인딩 주석을 사용한 매핑

bind(SpellChecker.class).annotatedWith(WinWord.class).to(WinWordSpellCheckerImpl.class);

바인딩 주석을 사용하여 삽입

@Inject
public TextEditor(@WinWord SpellChecker spellChecker) {
   this.spellChecker = spellChecker;
}

완전한 예

GuiceTester라는 Java 클래스를 만듭니다.

GuiceTester.java

import java.lang.annotation.Target;

import com.google.inject.AbstractModule;
import com.google.inject.BindingAnnotation;
import com.google.inject.Guice;
import com.google.inject.Inject;
import com.google.inject.Injector;

import java.lang.annotation.Retention;

import static java.lang.annotation.RetentionPolicy.RUNTIME;
import static java.lang.annotation.ElementType.PARAMETER;
import static java.lang.annotation.ElementType.FIELD;
import static java.lang.annotation.ElementType.METHOD;

@BindingAnnotation @Target({ FIELD, PARAMETER, METHOD }) @Retention(RUNTIME)
@interface WinWord {}

public class GuiceTester {
   public static void main(String[] args) {
      Injector injector = Guice.createInjector(new TextEditorModule());
      TextEditor editor = injector.getInstance(TextEditor.class);
      editor.makeSpellCheck();     
   } 
}

class TextEditor {
   private SpellChecker spellChecker;   

   @Inject
   public TextEditor(@WinWord SpellChecker spellChecker) {
      this.spellChecker = spellChecker;
   }

   public void makeSpellCheck(){
      spellChecker.checkSpelling(); 
   } 
}

//Binding Module
class TextEditorModule extends AbstractModule {

   @Override
   protected void configure() {
      bind(SpellChecker.class).annotatedWith(WinWord.class)
         .to(WinWordSpellCheckerImpl.class);    
   } 
}

//spell checker interface
interface SpellChecker {
   public void checkSpelling();
}

//spell checker implementation
class SpellCheckerImpl implements SpellChecker {

   @Override
   public void checkSpelling() {
      System.out.println("Inside checkSpelling." );
   } 
}

//subclass of SpellCheckerImpl
class WinWordSpellCheckerImpl extends SpellCheckerImpl{
   @Override
   public void checkSpelling() {
      System.out.println("Inside WinWordSpellCheckerImpl.checkSpelling." );
   } 
}

산출

파일을 컴파일하고 실행하면 다음 출력이 표시됩니다.

Inside WinWordSpellCheckerImpl.checkSpelling.

Guice는 사용자 지정 주석을 만들지 않고 바인딩을 매핑하는 또 다른 방법을 제공합니다. @Named 주석을 사용하여 그렇게 할 수 있습니다.

명명 된 주석을 사용한 매핑

bind(SpellChecker.class).annotatedWith(Names.named("OpenOffice")).to(OpenOfficeWordSpellCheckerImpl.class);

@Named 주석을 사용하여 삽입

@Inject
public TextEditor(@Named("OpenOffice") SpellChecker spellChecker) {
   this.spellChecker = spellChecker;
}

완전한 예

GuiceTester라는 Java 클래스를 만듭니다.

GuiceTester.java

import com.google.inject.AbstractModule;
import com.google.inject.Guice;
import com.google.inject.Inject;
import com.google.inject.Injector;
import com.google.inject.name.Named;
import com.google.inject.name.Names;

public class GuiceTester {
   public static void main(String[] args) {
      Injector injector = Guice.createInjector(new TextEditorModule());
      TextEditor editor = injector.getInstance(TextEditor.class);
      editor.makeSpellCheck();
   } 
}

class TextEditor {
   private SpellChecker spellChecker;
   

   @Inject
   public TextEditor(@Named("OpenOffice") SpellChecker spellChecker) {
      this.spellChecker = spellChecker;      
   }

   public void makeSpellCheck(){
      spellChecker.checkSpelling(); 
   }  
}

//Binding Module
class TextEditorModule extends AbstractModule {

   @Override
   protected void configure() {
      bind(SpellChecker.class).annotatedWith(Names.named("OpenOffice"))
         .to(OpenOfficeWordSpellCheckerImpl.class);
   } 
}

//spell checker interface
interface SpellChecker {
   public void checkSpelling();
}

//spell checker implementation
class SpellCheckerImpl implements SpellChecker {

   @Override
   public void checkSpelling() {
      System.out.println("Inside checkSpelling." );
   } 
}

//subclass of SpellCheckerImpl
class OpenOfficeWordSpellCheckerImpl extends SpellCheckerImpl{
   @Override
   public void checkSpelling() {
      System.out.println("Inside OpenOfficeWordSpellCheckerImpl.checkSpelling." );
   } 
}

산출

파일을 컴파일하고 실행하면 다음 출력이 표시됩니다.

Inside OpenOfficeWordSpellCheckerImpl.checkSpelling.

Guice는 값 객체 또는 상수로 바인딩을 만드는 방법을 제공합니다. JDBC URL을 구성하려는 경우를 고려하십시오.

@Named 주석을 사용하여 삽입

@Inject
public void connectDatabase(@Named("JBDC") String dbUrl) {
   //...
}

이것은 toInstance () 메서드를 사용하여 달성 할 수 있습니다.

bind(String.class).annotatedWith(Names.named("JBDC")).toInstance("jdbc:mysql://localhost:5326/emp");

완전한 예

GuiceTester라는 Java 클래스를 만듭니다.

GuiceTester.java

import com.google.inject.AbstractModule;
import com.google.inject.Guice;
import com.google.inject.Inject;
import com.google.inject.Injector;
import com.google.inject.name.Named;
import com.google.inject.name.Names;

public class GuiceTester {
   public static void main(String[] args) {
      Injector injector = Guice.createInjector(new TextEditorModule());
      TextEditor editor = injector.getInstance(TextEditor.class);
      editor.makeConnection();
   } 
}

class TextEditor {
   private String dbUrl;
   @Inject
   public TextEditor(@Named("JDBC") String dbUrl) {
      this.dbUrl = dbUrl;
   }

   public void makeConnection(){
      System.out.println(dbUrl);
   } 
}

//Binding Module
class TextEditorModule extends AbstractModule {

   @Override
   protected void configure() {
      bind(String.class)
         .annotatedWith(Names.named("JDBC"))
         .toInstance("jdbc:mysql://localhost:5326/emp");
   } 
}

산출

파일을 컴파일하고 실행하면 다음 출력이 표시됩니다.

jdbc:mysql://localhost:5326/emp

Guice는 @provides 메서드를 사용하여 복잡한 개체로 바인딩을 만드는 방법을 제공합니다.

@Provides
public SpellChecker provideSpellChecker(){
   String dbUrl = "jdbc:mysql://localhost:5326/emp";
   String user = "user";
   int timeout = 100;
   SpellChecker SpellChecker = new SpellCheckerImpl(dbUrl, user, timeout);
   return SpellChecker;
}

이 메 토스는 Binding Module의 일부이며 매핑 할 복잡한 개체를 제공합니다. 아래의 전체 예를 참조하십시오.

완전한 예

GuiceTester라는 Java 클래스를 만듭니다.

GuiceTester.java

import com.google.inject.AbstractModule;
import com.google.inject.Guice;
import com.google.inject.Inject;
import com.google.inject.Injector;
import com.google.inject.Provides;

public class GuiceTester {
   public static void main(String[] args) {
      Injector injector = Guice.createInjector(new TextEditorModule());
      TextEditor editor = injector.getInstance(TextEditor.class);
      editor.makeSpellCheck();
   } 
}

class TextEditor {
   private SpellChecker spellChecker;
   @Inject
   public TextEditor( SpellChecker spellChecker) {
      this.spellChecker = spellChecker;
   }
   public void makeSpellCheck(){
      spellChecker.checkSpelling();
   } 
}

//Binding Module
class TextEditorModule extends AbstractModule {

   @Override
   protected void configure() {} 

   @Provides
   public SpellChecker provideSpellChecker(){

      String dbUrl = "jdbc:mysql://localhost:5326/emp";
      String user = "user";
      int timeout = 100;

      SpellChecker SpellChecker = new SpellCheckerImpl(dbUrl, user, timeout);
      return SpellChecker;
   }
}

//spell checker interface
interface SpellChecker {
public void checkSpelling();
}

//spell checker implementation
class SpellCheckerImpl implements SpellChecker {

   private String dbUrl;
   private String user;
   private Integer timeout;

   @Inject
   public SpellCheckerImpl(String dbUrl, 
      String user, 
      Integer timeout){
      this.dbUrl = dbUrl;
      this.user = user;
      this.timeout = timeout;
   } 

   @Override
   public void checkSpelling() { 
      System.out.println("Inside checkSpelling." );
      System.out.println(dbUrl);
      System.out.println(user);
      System.out.println(timeout);
   }
}

산출

파일을 컴파일하고 실행하면 다음 출력이 표시됩니다.

Inside checkSpelling.
jdbc:mysql://localhost:5326/emp
user
100

@provides 메서드가 더 복잡 해짐에 따라 이러한 메서드는 Provider 인터페이스를 사용하여 별도의 클래스로 이동할 수 있습니다.

class SpellCheckerProvider implements Provider<SpellChecker>{
   @Override
   public SpellChecker get() {
      String dbUrl = "jdbc:mysql://localhost:5326/emp";
      String user = "user";
      int timeout = 100;
      SpellChecker SpellChecker = new SpellCheckerImpl(dbUrl, user, timeout);
      return SpellChecker;
   } 
}

다음 단계는 공급자를 유형에 매핑하는 것입니다.

bind(SpellChecker.class).toProvider(SpellCheckerProvider.class);

아래의 전체 예를 참조하십시오.

완전한 예

GuiceTester라는 Java 클래스를 만듭니다.

GuiceTester.java

import com.google.inject.AbstractModule;
import com.google.inject.Guice;
import com.google.inject.Inject;
import com.google.inject.Injector;
import com.google.inject.Provider;

public class GuiceTester {
   public static void main(String[] args) {
      Injector injector = Guice.createInjector(new TextEditorModule());
      TextEditor editor = injector.getInstance(TextEditor.class);
      editor.makeSpellCheck();
   } 
}

class TextEditor {
   private SpellChecker spellChecker;
   @Inject
   public TextEditor( SpellChecker spellChecker) {
      this.spellChecker = spellChecker;
   }

   public void makeSpellCheck(){
      spellChecker.checkSpelling();
   } 
}

//Binding Module
class TextEditorModule extends AbstractModule {

   @Override
   protected void configure() {
      bind(SpellChecker.class)
         .toProvider(SpellCheckerProvider.class);
   } 
}

//spell checker interface
interface SpellChecker {
   public void checkSpelling();
}

//spell checker implementation
class SpellCheckerImpl implements SpellChecker {

   private String dbUrl;
   private String user;
   private Integer timeout;

   @Inject
   public SpellCheckerImpl(String dbUrl, 
      String user, 
      Integer timeout){
      this.dbUrl = dbUrl;
      this.user = user;
      this.timeout = timeout;
   } 

   @Override
   public void checkSpelling() { 
      System.out.println("Inside checkSpelling." );
      System.out.println(dbUrl);
      System.out.println(user);
      System.out.println(timeout);
   }
}

class SpellCheckerProvider implements Provider<SpellChecker>{

   @Override
   public SpellChecker get() {
      String dbUrl = "jdbc:mysql://localhost:5326/emp";
      String user = "user";
      int timeout = 100;

      SpellChecker SpellChecker = new SpellCheckerImpl(dbUrl, user, timeout);
      return SpellChecker;
   }
}

산출

파일을 컴파일하고 실행하면 다음 출력이 표시됩니다.

Inside checkSpelling.
jdbc:mysql://localhost:5326/emp
user
100

Guice는 toConstructor () 메서드를 사용하여 객체의 특정 생성자로 바인딩을 생성하는 방법을 제공합니다.

@Override
protected void configure() {
   try {
      bind(SpellChecker.class)
         .toConstructor(SpellCheckerImpl.class.getConstructor(String.class));
      } catch (NoSuchMethodException | SecurityException e) {
      System.out.println("Required constructor missing");
   } 
}

아래의 전체 예를 참조하십시오.

완전한 예

GuiceTester라는 Java 클래스를 만듭니다.

GuiceTester.java

import com.google.inject.AbstractModule;
import com.google.inject.Guice;
import com.google.inject.Inject;
import com.google.inject.Injector;
import com.google.inject.name.Named;
import com.google.inject.name.Names;

public class GuiceTester {
   public static void main(String[] args) {
      Injector injector = Guice.createInjector(new TextEditorModule());
      TextEditor editor = injector.getInstance(TextEditor.class);
      editor.makeSpellCheck();
   } 
}

class TextEditor {
   private SpellChecker spellChecker;
   @Inject
   public TextEditor( SpellChecker spellChecker) {
      this.spellChecker = spellChecker;
   }

   public void makeSpellCheck(){
      spellChecker.checkSpelling();
   } 
}

//Binding Module
class TextEditorModule extends AbstractModule {

   @Override
   protected void configure() {
      try {
         bind(SpellChecker.class)
            .toConstructor(SpellCheckerImpl.class.getConstructor(String.class));
      } catch (NoSuchMethodException | SecurityException e) {
         System.out.println("Required constructor missing");
      } 
      bind(String.class)
         .annotatedWith(Names.named("JDBC"))
         .toInstance("jdbc:mysql://localhost:5326/emp");
   } 
}

//spell checker interface
interface SpellChecker {
   public void checkSpelling();
}

//spell checker implementation
class SpellCheckerImpl implements SpellChecker {

   private String dbUrl;

   public SpellCheckerImpl(){}

   public SpellCheckerImpl(@Named("JDBC") String dbUrl){
      this.dbUrl = dbUrl;
   } 

   @Override
   public void checkSpelling() { 
      System.out.println("Inside checkSpelling." );
      System.out.println(dbUrl); 
   }
}

산출

파일을 컴파일하고 실행하면 다음 출력이 표시됩니다.

Inside checkSpelling.
jdbc:mysql://localhost:5326/emp

Guice는 java.util.logging.Logger 클래스에 대한 내장 바인딩을 제공합니다 . Logger의 이름은 Logger가 주입되는 클래스의 이름으로 자동 설정됩니다. 아래 예를 참조하십시오.

예

GuiceTester라는 Java 클래스를 만듭니다.

GuiceTester.java

import java.util.logging.Logger;

import com.google.inject.AbstractModule;
import com.google.inject.Guice;
import com.google.inject.Inject;
import com.google.inject.Injector;

public class GuiceTester {
   public static void main(String[] args) {
      Injector injector = Guice.createInjector(new TextEditorModule());
      TextEditor editor = injector.getInstance(TextEditor.class);
      editor.makeSpellCheck();
   } 
}

class TextEditor {
   private Logger logger;

   @Inject
   public TextEditor( Logger logger) {
      this.logger = logger;
   }

   public void makeSpellCheck(){
      logger.info("In TextEditor.makeSpellCheck() method");
   } 
}

//Binding Module
class TextEditorModule extends AbstractModule {

   @Override
   protected void configure() {
   } 
}

산출

파일을 컴파일하고 실행하면 다음 출력이 표시됩니다.

Dec 20, 2017 12:51:05 PM TextEditor makeSpellCheck
INFO: In TextEditor.makeSpellCheck() method

바인딩은 Binding Module에 정의되어 있으므로 Guice는 의존성을 주입해야 할 때마다 사용합니다. 바인딩이없는 경우 Just-In-Time 바인딩 생성을 시도 할 수 있습니다. 바인딩 모듈에있는 바인딩을 명시 적 바인딩이라고하며 우선 순위가 더 높은 반면 Just-In-Time 바인딩은 암시 적 바인딩이라고합니다. 두 유형의 바인딩이 모두있는 경우 매핑에 명시 적 바인딩이 고려됩니다.

다음은 Just-in-time 바인딩의 세 가지 유형의 예입니다.

바인딩 유형	기술
주사 가능한 생성자	비공개가 아닌 인수가없는 생성자는 Just-In-Time 바인딩에 적합합니다. 또 다른 방법은 @Inject 주석으로 생성자에 주석을 추가하는 것입니다.
@ImplementatedBy 주석	@ImplementatedBy 어노테이션은 구현 클래스에 대한 guice를 알려줍니다. 이 경우 Binding Module에 바인딩이 필요하지 않습니다.
@ProvidedBy 주석	@ProvidedBy 어노테이션은 구현 클래스의 제공자에 대한 정보를 알려줍니다. 이 경우 Binding Module에 바인딩이 필요하지 않습니다.

비공개가 아닌 인수가없는 생성자는 Just-In-Time 바인딩에 적합합니다. 또 다른 방법은 @Inject 주석으로 생성자에 주석을 추가하는 것입니다. 예를 참조하십시오.

예

GuiceTester라는 Java 클래스를 만듭니다.

GuiceTester.java

import com.google.inject.AbstractModule;
import com.google.inject.Guice;
import com.google.inject.Inject;
import com.google.inject.Injector;
import com.google.inject.name.Named;
import com.google.inject.name.Names;

public class GuiceTester {
   public static void main(String[] args) {
      Injector injector = Guice.createInjector(new TextEditorModule());
      TextEditor editor = injector.getInstance(TextEditor.class);
      editor.makeSpellCheck();
   } 
}

class TextEditor {
   private SpellChecker spellChecker;

   @Inject
   public TextEditor( SpellChecker spellChecker) {
      this.spellChecker = spellChecker;
   }

   public void makeSpellCheck(){
      spellChecker.checkSpelling();
   } 
}

//Binding Module
class TextEditorModule extends AbstractModule {

   @Override
   protected void configure() { 
      bind(SpellChecker.class).to(SpellCheckerImpl.class);
      bind(String.class)
         .annotatedWith(Names.named("JDBC"))
         .toInstance("jdbc:mysql://localhost:5326/emp");
   } 
}

//spell checker interface
interface SpellChecker {
   public void checkSpelling();
}

//spell checker implementation
class SpellCheckerImpl implements SpellChecker {

   @Inject @Named("JDBC")
   private String dbUrl;

   public SpellCheckerImpl(){}

   @Override
   public void checkSpelling() { 
      System.out.println("Inside checkSpelling." );
      System.out.println(dbUrl); 
   }
}

산출

파일을 컴파일하고 실행하면 다음 출력이 표시됩니다.

Inside checkSpelling.
jdbc:mysql://localhost:5326/emp

@ImplementatedBy 어노테이션은 구현 클래스에 대한 guice를 알려줍니다. 이 경우 Binding Module에 바인딩이 필요하지 않습니다. 예를 참조하십시오.

예

GuiceTester라는 Java 클래스를 만듭니다.

GuiceTester.java

import com.google.inject.AbstractModule;
import com.google.inject.Guice;
import com.google.inject.ImplementedBy;
import com.google.inject.Inject;
import com.google.inject.Injector;
import com.google.inject.name.Named;
import com.google.inject.name.Names;

public class GuiceTester {
   public static void main(String[] args) {
      Injector injector = Guice.createInjector(new TextEditorModule());
      TextEditor editor = injector.getInstance(TextEditor.class);
      editor.makeSpellCheck();
   } 
}

class TextEditor {
   private SpellChecker spellChecker;

   @Inject
   public TextEditor( SpellChecker spellChecker) {
      this.spellChecker = spellChecker;
   }

   public void makeSpellCheck(){
      spellChecker.checkSpelling();
   } 
}

//Binding Module
class TextEditorModule extends AbstractModule {

   @Override
   protected void configure() { 
      bind(String.class)
         .annotatedWith(Names.named("JDBC"))
         .toInstance("jdbc:mysql://localhost:5326/emp");
   } 
}

@ImplementedBy(SpellCheckerImpl.class)
interface SpellChecker {
   public void checkSpelling();
}

//spell checker implementation
class SpellCheckerImpl implements SpellChecker {

   @Inject @Named("JDBC")
   private String dbUrl;

   public SpellCheckerImpl(){}

   @Override
   public void checkSpelling() { 
      System.out.println("Inside checkSpelling." );
      System.out.println(dbUrl); 
   }
}

산출

파일을 컴파일하고 실행하면 다음 출력이 표시됩니다.

Inside checkSpelling.
jdbc:mysql://localhost:5326/emp

@ProvidedBy 어노테이션은 구현 클래스의 제공자에 대한 정보를 알려줍니다. 이 경우 Binding Module에 바인딩이 필요하지 않습니다. 예를 참조하십시오.

예

GuiceTester라는 Java 클래스를 만듭니다.

GuiceTester.java

import com.google.inject.AbstractModule;
import com.google.inject.Guice;
import com.google.inject.Inject;
import com.google.inject.Injector;
import com.google.inject.ProvidedBy;
import com.google.inject.Provider;

public class GuiceTester {
   public static void main(String[] args) {
      Injector injector = Guice.createInjector(new TextEditorModule());
      TextEditor editor = injector.getInstance(TextEditor.class);
      editor.makeSpellCheck();
   } 
}

class TextEditor {
   private SpellChecker spellChecker;
   @Inject
   public TextEditor( SpellChecker spellChecker) {
      this.spellChecker = spellChecker;
   }

   public void makeSpellCheck(){
      spellChecker.checkSpelling();
   } 
}

//Binding Module
class TextEditorModule extends AbstractModule {

   @Override
   protected void configure() {     
   } 
}

@ProvidedBy(SpellCheckerProvider.class)
interface SpellChecker {
   public void checkSpelling();
}

//spell checker implementation
class SpellCheckerImpl implements SpellChecker {

   private String dbUrl;
   private String user;
   private Integer timeout;

   @Inject
   public SpellCheckerImpl(String dbUrl, 
      String user, 
      Integer timeout){
      this.dbUrl = dbUrl;
      this.user = user;
      this.timeout = timeout;
   } 

   @Override
   public void checkSpelling() { 
      System.out.println("Inside checkSpelling." );
      System.out.println(dbUrl);
      System.out.println(user);
      System.out.println(timeout);
   }
}

class SpellCheckerProvider implements Provider<SpellChecker>{

   @Override
   public SpellChecker get() {
      String dbUrl = "jdbc:mysql://localhost:5326/emp";
      String user = "user";
      int timeout = 100;

      SpellChecker SpellChecker = new SpellCheckerImpl(dbUrl, user, timeout);
      return SpellChecker;
   }
}

산출

파일을 컴파일하고 실행하면 다음 출력이 표시됩니다.

Inside checkSpelling.
jdbc:mysql://localhost:5326/emp
user
100

주입은 개체에 의존성을 주입하는 과정입니다. 생성자 주입은 매우 일반적입니다. 이 과정에서 종속성은 생성자에 대한 인수로 주입됩니다. 아래 예를 참조하십시오.

GuiceTester라는 Java 클래스를 만듭니다.

GuiceTester.java

import com.google.inject.AbstractModule;
import com.google.inject.Guice;
import com.google.inject.Inject;
import com.google.inject.Injector;

public class GuiceTester {
   public static void main(String[] args) {
      Injector injector = Guice.createInjector(new TextEditorModule());
      TextEditor editor = injector.getInstance(TextEditor.class);
      editor.makeSpellCheck(); 
   } 
}

class TextEditor {
   private SpellChecker spellChecker;

   @Inject
   public TextEditor(SpellChecker spellChecker) {
      this.spellChecker = spellChecker;
   }

   public void makeSpellCheck(){
      spellChecker.checkSpelling();
   }
}

//Binding Module
class TextEditorModule extends AbstractModule {

   @Override
   protected void configure() {
      bind(SpellChecker.class).to(SpellCheckerImpl.class);
   } 
}

//spell checker interface
interface SpellChecker {
   public void checkSpelling();
}


//spell checker implementation
class SpellCheckerImpl implements SpellChecker {

   @Override
   public void checkSpelling() {
      System.out.println("Inside checkSpelling." );
   } 
}

산출

파일을 컴파일하고 실행하면 다음 출력이 표시됩니다.

Inside checkSpelling.

주입은 개체에 의존성을 주입하는 과정입니다. 메서드 주입은 값 개체를 개체에 대한 종속성으로 설정하는 데 사용됩니다. 아래 예를 참조하십시오.

예

GuiceTester라는 Java 클래스를 만듭니다.

import com.google.inject.AbstractModule;
import com.google.inject.Guice;
import com.google.inject.ImplementedBy;
import com.google.inject.Inject;
import com.google.inject.Injector;
import com.google.inject.name.Named;
import com.google.inject.name.Names;

public class GuiceTester {
   public static void main(String[] args) {
      Injector injector = Guice.createInjector(new TextEditorModule());
      TextEditor editor = injector.getInstance(TextEditor.class);
      editor.makeSpellCheck();
   } 
}

class TextEditor {
   private SpellChecker spellChecker;

   @Inject
   public TextEditor( SpellChecker spellChecker) {
      this.spellChecker = spellChecker;
   }

   public void makeSpellCheck(){
      spellChecker.checkSpelling();
   } 
}

//Binding Module
class TextEditorModule extends AbstractModule {

   @Override
   protected void configure() { 
      bind(String.class)
         .annotatedWith(Names.named("JDBC"))
         .toInstance("jdbc:mysql://localhost:5326/emp");
   } 
}

@ImplementedBy(SpellCheckerImpl.class)
interface SpellChecker {
   public void checkSpelling();
}

//spell checker implementation
class SpellCheckerImpl implements SpellChecker {
 
   private String dbUrl;

   public SpellCheckerImpl(){}
   
   @Inject 
   public void setDbUrl(@Named("JDBC") String dbUrl){
      this.dbUrl = dbUrl;
   }

   @Override
   public void checkSpelling() { 
      System.out.println("Inside checkSpelling." );
      System.out.println(dbUrl); 
   }
}

산출

파일을 컴파일하고 실행하면 다음 출력이 표시됩니다.

Inside checkSpelling.
jdbc:mysql://localhost:5326/emp

주입은 개체에 의존성을 주입하는 과정입니다. 필드 주입은 값 개체를 개체의 필드에 대한 종속성으로 설정하는 데 사용됩니다. 아래 예를 참조하십시오.

예

GuiceTester라는 Java 클래스를 만듭니다.

GuiceTester.java

import com.google.inject.AbstractModule;
import com.google.inject.Guice;
import com.google.inject.ImplementedBy;
import com.google.inject.Inject;
import com.google.inject.Injector;
import com.google.inject.name.Named;
import com.google.inject.name.Names;

public class GuiceTester {
   public static void main(String[] args) {
      Injector injector = Guice.createInjector(new TextEditorModule());
      TextEditor editor = injector.getInstance(TextEditor.class);
      editor.makeSpellCheck();
   } 
}

class TextEditor {
   private SpellChecker spellChecker;

   @Inject
   public TextEditor( SpellChecker spellChecker) {
      this.spellChecker = spellChecker;
   }

   public void makeSpellCheck(){
      spellChecker.checkSpelling();
   } 
}

//Binding Module
class TextEditorModule extends AbstractModule {

   @Override
   protected void configure() { 
      bind(String.class)
         .annotatedWith(Names.named("JDBC"))
         .toInstance("jdbc:mysql://localhost:5326/emp");
   } 
}

@ImplementedBy(SpellCheckerImpl.class)
interface SpellChecker {
   public void checkSpelling();
}

//spell checker implementation
class SpellCheckerImpl implements SpellChecker {

   @Inject @Named("JDBC")
   private String dbUrl;

   public SpellCheckerImpl(){}

   @Override
   public void checkSpelling() { 
      System.out.println("Inside checkSpelling." );
      System.out.println(dbUrl); 
   }
}

산출

파일을 컴파일하고 실행하면 다음 출력이 표시됩니다.

Inside checkSpelling.
jdbc:mysql://localhost:5326/emp

주입은 개체에 의존성을 주입하는 과정입니다. 선택적 주입은 존재하는 경우 종속성 주입을 의미합니다. 메서드 및 필드 삽입은 선택적으로 종속 될 수 있으며 종속성이없는 경우 일부 기본값이 있어야합니다. 아래 예를 참조하십시오.

예

GuiceTester라는 Java 클래스를 만듭니다.

GuiceTester.java

import com.google.inject.AbstractModule;
import com.google.inject.Guice;
import com.google.inject.ImplementedBy;
import com.google.inject.Inject;
import com.google.inject.Injector;
import com.google.inject.name.Named;

public class GuiceTester {
   public static void main(String[] args) {
      Injector injector = Guice.createInjector(new TextEditorModule());
      TextEditor editor = injector.getInstance(TextEditor.class);
      editor.makeSpellCheck();
   } 
}

class TextEditor {
   private SpellChecker spellChecker;

   @Inject
   public TextEditor( SpellChecker spellChecker) {
      this.spellChecker = spellChecker;
   }

   public void makeSpellCheck(){
      spellChecker.checkSpelling();
   } 
}

//Binding Module
class TextEditorModule extends AbstractModule {

   @Override
   protected void configure() {} 
}

@ImplementedBy(SpellCheckerImpl.class)
interface SpellChecker {
   public void checkSpelling();
}

//spell checker implementation
class SpellCheckerImpl implements SpellChecker {

   private String dbUrl = "jdbc:mysql://localhost:5326/emp";

   public SpellCheckerImpl(){}
   
   @Inject(optional=true)
   public void setDbUrl(@Named("JDBC") String dbUrl){
      this.dbUrl = dbUrl;
   }

   @Override
   public void checkSpelling() { 
      System.out.println("Inside checkSpelling." );
      System.out.println(dbUrl); 
   }
}

산출

파일을 컴파일하고 실행하면 다음 출력이 표시됩니다.

Inside checkSpelling.
jdbc:mysql://localhost:5326/emp

주입은 개체에 의존성을 주입하는 과정입니다. 메서드 및 필드 주입은 injector.injectMembers () 메서드를 사용하여 종료 객체를 사용하여 초기화하는 데 사용할 수 있습니다 . 아래 예를 참조하십시오.

예

GuiceTester라는 Java 클래스를 만듭니다.

GuiceTester.java

import com.google.inject.AbstractModule;
import com.google.inject.Guice;
import com.google.inject.ImplementedBy;
import com.google.inject.Inject;
import com.google.inject.Injector;

public class GuiceTester {
   public static void main(String[] args) {
      Injector injector = Guice.createInjector(new TextEditorModule());
      SpellChecker spellChecker = new SpellCheckerImpl();
      injector.injectMembers(spellChecker);
      
      TextEditor editor = injector.getInstance(TextEditor.class);     
      editor.makeSpellCheck();
   } 
}

class TextEditor {
   private SpellChecker spellChecker;

   @Inject
   public void setSpellChecker(SpellChecker spellChecker){
   this.spellChecker = spellChecker;
   }
   public TextEditor() { }

   public void makeSpellCheck(){
      spellChecker.checkSpelling();
   } 
}

//Binding Module
class TextEditorModule extends AbstractModule {

   @Override
   protected void configure() {      
   } 
}

@ImplementedBy(SpellCheckerImpl.class)
interface SpellChecker {
   public void checkSpelling();
}

//spell checker implementation
class SpellCheckerImpl implements SpellChecker {

   public SpellCheckerImpl(){}
   
   @Override
   public void checkSpelling() { 
      System.out.println("Inside checkSpelling." );
   }
}

파일을 컴파일하고 실행하면 다음 출력이 표시됩니다.

Inside checkSpelling.

Guice는 기본 동작으로 값을 제공 할 때마다 새 인스턴스를 반환합니다. 범위를 통해 구성 할 수 있습니다. 다음은 Guice가 지원하는 범위입니다.

• @Singleton-응용 프로그램 수명 동안 단일 인스턴스. @Singleton 객체는 스레드로부터 안전해야합니다.

• @SessionScoped-웹 애플리케이션의 특정 세션에 대한 단일 인스턴스. @SessionScoped 개체는 스레드로부터 안전해야합니다.

• @RequestScoped-웹 애플리케이션의 특정 요청에 대한 단일 인스턴스. @RequestScoped 개체는 스레드로부터 안전 할 필요가 없습니다.

범위를 적용하는 방법.

다음은 범위를 적용하는 방법입니다.

클래스 수준에서

@Singleton
class SpellCheckerImpl implements SpellChecker {

   public SpellCheckerImpl(){}
   
   @Override
   public void checkSpelling() { 
      System.out.println("Inside checkSpelling." );
   }
}

구성 수준에서

bind(SpellChecker.class).to(SpellCheckerImpl.class).in(Singleton.class);

방법 수준에서

@Provides @Singleton
public SpellChecker provideSpellChecker(){

   String dbUrl = "jdbc:mysql://localhost:5326/emp";
   String user = "user";
   int timeout = 100;

   SpellChecker SpellChecker = new SpellCheckerImpl(dbUrl, user, timeout);
   return SpellChecker;
}

예

작동중인 클래스 수준에서 범위를 살펴 보겠습니다.

@Singleton 주석을 사용한 결과

GuiceTester라는 Java 클래스를 만듭니다.

GuiceTester.java

import com.google.inject.AbstractModule;
import com.google.inject.Guice;
import com.google.inject.Inject;
import com.google.inject.Injector;
import com.google.inject.Singleton;

public class GuiceTester {
   public static void main(String[] args) {
      Injector injector = Guice.createInjector(new TextEditorModule());
      SpellChecker spellChecker = new SpellCheckerImpl();
      injector.injectMembers(spellChecker);

      TextEditor editor = injector.getInstance(TextEditor.class);     
      System.out.println(editor.getSpellCheckerId());

      TextEditor editor1 = injector.getInstance(TextEditor.class);     
      System.out.println(editor1.getSpellCheckerId());
   } 
}

class TextEditor {
   private SpellChecker spellChecker;

   @Inject
   public void setSpellChecker(SpellChecker spellChecker){
      this.spellChecker = spellChecker;
   }
   public TextEditor() { }

   public void makeSpellCheck(){
      spellChecker.checkSpelling();
   } 

   public double getSpellCheckerId(){
      return spellChecker.getId();
   }
}

//Binding Module
class TextEditorModule extends AbstractModule {

   @Override
   protected void configure() {   
      bind(SpellChecker.class).to(SpellCheckerImpl.class);
   } 
}

interface SpellChecker {
   public double getId();
   public void checkSpelling();
}

@Singleton
class SpellCheckerImpl implements SpellChecker {

   double id; 
   public SpellCheckerImpl(){
      id = Math.random();    
   }

   @Override
   public void checkSpelling() { 
      System.out.println("Inside checkSpelling." );
   }

   @Override
   public double getId() { 
      return id;
   }
}

파일을 컴파일하고 실행하면 다음 출력이 표시 될 수 있습니다.

0.3055839187063575
0.3055839187063575

@Singleton 주석이없는 결과

GuiceTester라는 Java 클래스를 만듭니다.

GuiceTester.java

import com.google.inject.AbstractModule;
import com.google.inject.Guice;
import com.google.inject.Inject;
import com.google.inject.Injector;

public class GuiceTester {
   public static void main(String[] args) {
      Injector injector = Guice.createInjector(new TextEditorModule());
      SpellChecker spellChecker = new SpellCheckerImpl();
      injector.injectMembers(spellChecker);

      TextEditor editor = injector.getInstance(TextEditor.class);     
      System.out.println(editor.getSpellCheckerId());

      TextEditor editor1 = injector.getInstance(TextEditor.class);     
      System.out.println(editor1.getSpellCheckerId());
   } 
}

class TextEditor {
   private SpellChecker spellChecker;

   @Inject
   public void setSpellChecker(SpellChecker spellChecker){
      this.spellChecker = spellChecker;
   }
   public TextEditor() { }

   public void makeSpellCheck(){
      spellChecker.checkSpelling();
   } 

   public double getSpellCheckerId(){
      return spellChecker.getId();
   }
}

//Binding Module
class TextEditorModule extends AbstractModule {

   @Override
   protected void configure() {   
      bind(SpellChecker.class).to(SpellCheckerImpl.class);
   } 
}

interface SpellChecker {
   public double getId();
   public void checkSpelling();
}

class SpellCheckerImpl implements SpellChecker {

   double id; 
   public SpellCheckerImpl(){
      id = Math.random();    
   }

   @Override
   public void checkSpelling() { 
      System.out.println("Inside checkSpelling." );
   }

   @Override
   public double getId() { 
      return id;
   }
}

파일을 컴파일하고 실행하면 다음 출력이 표시 될 수 있습니다.

0.556007079571739
0.22095011760351602

Google Guice-AOP

AOP, Aspect 지향 프로그래밍은 프로그램 로직을 소위 관심사라고하는 별개의 부분으로 분해하는 것을 수반합니다. 애플리케이션의 여러 지점에 걸쳐있는 기능을 교차 절단 문제라고하며 이러한 교차 절단 문제는 애플리케이션의 비즈니스 로직과 개념적으로 분리됩니다. 로깅, 감사, 선언적 트랜잭션, 보안, 캐싱 등과 같은 측면에 대한 다양한 일반적인 좋은 예가 있습니다.

OOP에서 모듈화의 핵심 단위는 클래스이고 AOP에서는 모듈화 단위가 aspect입니다. 종속성 주입은 애플리케이션 개체를 서로 분리하는 데 도움이되며 AOP는 영향을받는 개체에서 교차 절단 문제를 분리하는 데 도움이됩니다. AOP는 Perl, .NET, Java 등과 같은 프로그래밍 언어의 트리거와 같습니다. Guice는 애플리케이션을 가로채는 인터셉터를 제공합니다. 예를 들어 메서드가 실행될 때 메서드 실행 전후에 추가 기능을 추가 할 수 있습니다.

중요한 수업

• Matcher-Matcher는 값을 수락하거나 거부하는 인터페이스입니다. Guice AOP에서는 두 개의 matcher가 필요합니다. 하나는 어떤 클래스가 참여하는지 정의하고 다른 하나는 해당 클래스의 메소드를위한 것입니다.

• MethodInterceptor-MethodInterceptors는 매칭 메소드가 호출되면 실행됩니다. 메서드, 인수 및 수신 인스턴스와 같은 호출을 검사 할 수 있습니다. 교차 절단 논리를 수행 한 다음 기본 메서드에 위임 할 수 있습니다. 마지막으로 반환 값 또는 예외를 검사하고 반환 할 수 있습니다.

예

GuiceTester라는 Java 클래스를 만듭니다.

GuiceTester.java

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;

import com.google.inject.AbstractModule;
import com.google.inject.Guice;
import com.google.inject.Inject;
import com.google.inject.Injector;
import com.google.inject.matcher.Matchers;

public class GuiceTester {
   public static void main(String[] args) {
      Injector injector = Guice.createInjector(new TextEditorModule());
      TextEditor editor = injector.getInstance(TextEditor.class);
      editor.makeSpellCheck(); 
   } 
}

class TextEditor {
   private SpellChecker spellChecker;

   @Inject
   public TextEditor(SpellChecker spellChecker) {
      this.spellChecker = spellChecker;
   }

   public void makeSpellCheck(){
      spellChecker.checkSpelling();
   }
}

//Binding Module
class TextEditorModule extends AbstractModule {

   @Override
   protected void configure() {
      bind(SpellChecker.class).to(SpellCheckerImpl.class);
      bindInterceptor(Matchers.any(), 
         Matchers.annotatedWith(CallTracker.class), 
         new CallTrackerService());
   } 
}

//spell checker interface
interface SpellChecker {
   public void checkSpelling();
}

//spell checker implementation
class SpellCheckerImpl implements SpellChecker {

   @Override @CallTracker
   public void checkSpelling() {
      System.out.println("Inside checkSpelling." );
   } 
}

@Retention(RetentionPolicy.RUNTIME) @Target(ElementType.METHOD)
@interface CallTracker {}

class CallTrackerService implements MethodInterceptor  {

   @Override
   public Object invoke(MethodInvocation invocation) throws Throwable {
      System.out.println("Before " + invocation.getMethod().getName());
      Object result = invocation.proceed();
      System.out.println("After " + invocation.getMethod().getName());
      return result;
   }
}

파일을 컴파일하고 실행하면 다음 출력이 표시 될 수 있습니다.

Before checkSpelling
Inside checkSpelling.
After checkSpelling