Java 디자인 패턴 간단한 팩토리 패턴

1.1 Simple Factory Pattern

Simple Factory Pattern은 클래스를 생성하는 패턴으로 Static Factory Method 패턴이라고도 합니다. 단순 팩토리 패턴은 팩토리 객체를 사용하여 생성할 제품 클래스의 인스턴스를 결정합니다.

1.1.1 여러 형태의 팩토리 패턴

팩토리 패턴은 특히 공통 인터페이스를 사용하여 많은 수의 클래스를 인스턴스화하는 역할을 합니다. 팩토리 패턴은 인스턴스화할 클래스를 동적으로 결정할 수 있습니다. 팩토리 패턴은 다음과 같은 형식을 갖습니다.
z Simple Factory(Simple Factory) 패턴: 정적 팩토리 메소드(Static Factory Method) 패턴이라고도 합니다.
l 팩토리 메소드 패턴: 다형성 팩토리 패턴 또는 가상 생성자 패턴이라고도 합니다.
l 추상 팩토리 패턴: 도구 상자(Kit 또는 Toolkit) 패턴이라고도 합니다.
아래 그림은 간단한 팩토리 패턴의 단순화된 클래스 다이어그램을 보여줍니다.

간단한 팩토리 패턴 또는 정적 팩토리 메소드 패턴은 다양한 팩토리 메소드 패턴을 특수하게 구현한 것입니다. Java 언어에서 일반적인 팩토리 메소드 패턴은 디자인 기능을 저하시켜 정적 팩토리 메소드 패턴을 제공할 수 없습니다.

1.1.2 단순 공장 모드(일반 모드) 소개
예를 들어 사과, 딸기, 포도(포도) 등 다양한 과일을 생산하는 농장이 있고, 농장 정원사(FruitGardener)는 고객의 요구에 따라 해당 과일을 제공해야 합니다. 아래와 같이 간단한 팩토리 패턴을 사용하여 이 프로세스를 구현하는 방법을 살펴보겠습니다.

이 모드의 구현 소스 코드는 다음과 같습니다.

1.1.2.1 제품 인터페이스 - 과일 인터페이스: Fruit.java
package com.lavasoft.patterns.simplefactory.ybgc;

/**
* 작성: IntelliJ IDEA.
* 파일명:Fruit.java
* 사용자: LavaSoft
* 날짜: 2006-12-1
* 시간: 0:26:51
* "Java and Patterns" (--Dr. Yan Hong 작성) 읽기 노트
* 팩토리 패턴 패턴--간단한 팩토리 패턴--일반 패턴
* 읽어보기: 추상 제품 역할: 공장의 과일 제품 인터페이스 --과일
*/
공용 인터페이스 Fruit {
/**
*심기
*/
void plant();

/**
* 성장
*/
void Growth();

/**
* 수확
*/
void Harvest();
}

1.1.2.2 제품 - Pingguo 카테고리: Apple.java
package com .lavasoft.patterns.simplefactory .ybgc;

/**
* 작성: IntelliJ IDEA.
* 파일명:Apple.java
* 사용자: LavaSoft
* 날짜: 2006-12-1
* 시간: 0:47:25
* "Java and Patterns"(--Dr. Yan Hong 작성) 읽기 노트
* 팩토리 모드 모드--간단 팩토리 모드--일반 모드
* 읽어보기: Fruit Factory 제품: Apple
*/
공개 클래스 Apple은 Fruit {
private int treeAge;

/***/
public void plant() {
System.out.println("Apple이 심어졌습니다.");
}

/**

*심기

*/
public void 성장() {
System.out.println("Apple은 성장하고 있습니다...");
}

/**

* 성장

*/
public void 수확 () {
System.out.println("Apple이 수확되었습니다.");
}

/**

* 수확

*/
public int getTreeAge() {
return treeAge;
}

/**

* @return 리턴트리 나이

*/
public void setTreeAge(int treeAge) {
this.treeAge = treeAge;
}

}

1.1.2.3 产품-草莓类：Strawberry.java
package com.lavasoft.patterns.simplefactory.ybgc;

/**
* 작성: IntelliJ IDEA.
* 파일명:Strawberry.java
* 사용자: LavaSoft
* 날짜: 2006-12-1
* 시간: 0:45:09
* "Java and Patterns"(--Dr. Yan Hong 작성) 읽기 노트
* 팩토리 모드 모드--간단한 팩토리 모드--일반 모드
* ReadMe: Fruit Factory Products: Strawberry
*/
공개 클래스 Strawberry는 Fruit을 구현합니다. {
    /**
* 성장
*/
    public void Growth() {
        System.out.println("딸기가 자라고 있습니다...");
    }

/**
* 수확
*/
    public void Harvest() {
        System.out.println("딸기가 수확되었습니다.");
    }

    /**
*심기
*/
    public void plant() {
        System.out.println("딸기를 심었습니다.");
    }

    /**
* 도우미 방법
*/
    public static void log(String msg) {
        System.out.println(msg);
    }
}

 

1.1.2.4 产product-葡萄类: Grape.java
패키지 com.lavasoft.patterns.simplefactory.ybgc;

/**
* 작성: IntelliJ IDEA.
* 파일명:Grape.java
* 사용자: LavaSoft
* 날짜: 2006-12-1
* 시간: 0:36:56
* "Java and Patterns"(--Dr. Yan Hong 작성) 읽기 노트
* 팩토리 모드 모드--간단 팩토리 모드--일반 모드
* 읽어보기: 과일 팩토리 제품: 포도
*/
공용 클래스 Grape는 Fruit {
    private boolean seedless;   //是否有籽>

    /**

*심기
*/
    public void plant() {
        System.out.println("포도를 심었습니다.");
    }

    /**

* 성장
*/
    public void Growth() {
        System.out.println("포도가 자라고 있습니다...");
    }

    /**

* 수확
*/
    public void Harvest() {
        System.out.println("포도가 수확되었습니다.");
    }

    /**

* 시드가 있는지 @return
*/
    public boolean getSeedless() {
        시드 없는 반환;
    }

    /**

* 시드 유무에 관계없이 할당 방법
*/
    public void setSeedless(부울 시드 없음) {
        this.seedless = 씨 없음;
    }

    /**

* 도우미 방법
*/
    public static void log(String msg) {
        System.out.println(msg);
    }
}

 

1.1.2.5 工厂-园丁类：FruitGardener.java

package com.lavasoft.patterns.simplefactory.ybgc;

/**
* 작성: IntelliJ IDEA.
* 파일명:FruitGardener.java
* 사용자: LavaSoft
* 날짜: 2006-12-1
* 시간: 1:03:27
* "Java and Patterns"(--Dr. Yan Hong 작성) 읽기 노트
* 공장 모드 모드--간단한 공장 모드--일반 모드
* ReadMe: 공장 역할: 과일 정원사, 과일 제품 생산
*/
public class FruitGardener {
    /**
* 정적 팩토리 메소드
* @param which: 특정 제품 이름
* @과일 객체 반환
* @throws BadFruitException
*/
    public static Fruit Factory(String which) throws BadFruitException {
        if (which. equalsIgnoreCase("apple")) {
            return new Apple();
        } else if (which.equalsIgnoreCase("strawberry")) {
            return new Strawberry();
        } else if ( whyequalsignorecase ( "Grape")) {
return new 포도 (); } else { throw new badfruitexception ( "나쁜 과일 요청");
}
} }

 

1.1.2.6 工厂异常정义类：BadFruitException.java

package com.lavasoft.patterns.simplefactory.ybgc;

/**

* 작성: IntelliJ IDEA.

* FileName:BadFruitException.java
* 사용자: LavaSoft
* 날짜: 2006-12-1
* 시간: 1:04:56
* "Java and Patterns" (--Dr. Yan Hong 작성) 읽기 노트
* 팩토리 패턴 패턴--간단한 팩토리 패턴--일반 패턴
* ReadMe: 팩토리 예외 처리 클래스
*/
공용 클래스 BadFruitException 확장 예외 {
    public BadFruitException(String msg) {
        super(msg);     //사용 가능한 전략
    }
}

 

1.1.2.7 一般工厂模式的测试类

package com.lavasoft.patterns.simplefactory.ybgc ;

/**

* 작성: IntelliJ IDEA.

* 파일명:TestApp.java
* 사용자: LavaSoft
* 날짜: 2006-12-1
* 시간: 1:12:08
* "Java and Patterns"(--Dr. Yan Hong 작성) 읽기 노트
* 팩토리 패턴 패턴--간단한 팩토리 패턴--일반 패턴
* ReadMe: 일반 팩토리 패턴 테스트 클래스
*/
public class TestApp {
    /**
* 테스트 방법
*/
    private void test(String FruitName) {
        시도해 보세요 {
            Fruit f = FruitGardener.factory(fruitName);
            System.out.println("恭喜!生产了一个水果对象:" + FruitName);
       } catch(BadFruitException e) >            시스템. out.println("对不起!工厂目前不能生产你所要적품:" + FruitName);
            System.out.println(e.getMessage());     //출입异常信息
            e.printStackTrace();                    //출입异常堆栈信息
        }
    }

    /**
* 응모방법

*/

    public static void main(String args[]) {
        TestApp t = new TestApp ();
        t.test("사과");
        t.test("포도");
        t.test("딸기");

        t.test(" 자동차");  //此处会抛异常,water果工厂能生产car(轿车)吗!哈哈哈哈...
    }

}

 

1.1.2.8 테스트 실행 결과
축하합니다! 과일 오브제 생산:사과
축하합니다!축하합니다!과일 오브제 생산:포도
축하합니다!과일 오브제 생산:딸기
죄송합니다! 현재 귀하가 요청한 제품을 생산할 수 없습니다: 자동차
잘못된 과일 요청
com.lavasoft.patterns.simplefactory.ybgc.BadFruitException: 잘못된 과일 요청
com.lavasoft.patterns.simplefactory.ybgc.FruitGardener. 공장(FruitGardener.java:28)
com.lavasoft.patterns.simplefactory.ybgc.TestApp.test(TestApp.java:19)
com.lavasoft.patterns.simplefactory.ybgc.TestApp.main( TestApp.java:37)
sun.reflect.NativeMethodAccessorImpl.invoke0(네이티브 메서드)
sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)
sun.reflect.DelegatingMethodAccessorImpl.invoke에서 (DelegatingMethodAccessorImpl.java:25)
java.lang.reflect.Method.invoke(Method.java:585)
com.intellij.rt.execution.application.AppMain.main(AppMain.java:90) )

종료 코드 0으로 처리 완료

결과에서 공장에서 생산할 수 없는 종류의 자동차(자동차)가 들어있어서 예외가 있습니다 ㅎㅎㅎ 과수원은 가능합니다. 자동차를 생산하시나요? 유치원 아이들에게 알려주세요!

1.1.3 단순 팩토리 패턴의 일반적인 구조

요약하면, 위의 간단한 팩토리 패턴 예, 간단한 팩토리 패턴을 구현해야 합니다
z 팩토리 역할: 정원사
z 추상 제품: 과일 인터페이스
z 특정 제품: 사과, 포도, 딸기
또한, 일반적으로
z Factory Exception 클래스
z 클라이언트 클래스
를 구현하는 데 필요합니다. 간단한 팩토리 패턴의 일반적인 구조 다이어그램은 다음과 같습니다.

1.1 .4 간단한 팩토리 패턴 구현

1.1.4.1 인터페이스 또는 추상 클래스를 사용하여 다중 레벨 제품 구조 구현

팩토리 클래스는 여러 정적 팩토리 메소드를 가질 수 있습니다. 이는 다양한 제품 개체를 생산하는 데 사용됩니다.

1.1.4.2 다중 팩토리 메소드
는 다양한 제품 객체 생성을 담당합니다. 예를 들어 java.text.DateFormat 클래스는 하위 클래스의 팩토리 클래스이고 DateFormat은 클래스는 다중 정적 팩토리 메소드를 제공합니다.

1.1.4.3 추상 제품 역할 생략
시스템에 특정 제품 역할이 하나만 있는 경우 추상 제품 역할을 생략할 수 있습니다. 추상적인 제품 역할을 생략한 후 단순화된 클래스 다이어그램은 다음과 같습니다.

다음은 팩토리 역할이 특정 제품을 생성하는 예이며, 소스 코드는 다음과 같습니다.

1.1.4.3.1 제품 역할: ConcreteProduct.java
package com.lavasoft.patterns.simplefactory.gchb;

/**
* 작성: IntelliJ IDEA.
* 파일명:ConcreteProduct.java
* 사용자: LavaSoft
* 날짜: 2006-12-1
* 시간: 2:07:48
* "Java and Patterns"(--Dr. Yan Hong 작성) 읽기 노트
* 팩토리 패턴--간단한 팩토리 패턴--작업-도면 병합(팩토리 역할과 추상 제품 역할의 병합)
* ReadMe : 특정 제품 카테고리는 단일 제품 유형을 나타냅니다.
* /
public class ConcreteProduct {
public ConcreteProduct() {
}
}

1.1.4.3.2 팩토리 역할:
package com. lavasoft.patterns.simplefactory.gchb;

/**
* 작성: IntelliJ IDEA.
* 파일명:Creator.java
* 사용자: LavaSoft
* 날짜: 2006-12-1
* 시간: 1:56:43
* "Java and Patterns"(--Dr. Yan Hong 작성) 읽기 노트
* 팩토리 패턴--간단한 팩토리 패턴--작업-도면 병합(팩토리 역할과 추상 제품 역할의 병합)
* ReadMe : 특정 제품 카테고리, 추상적인 제품 역할과 병합되어 단일 유형의 제품만 생산합니다.
*/
public class Creator {
/**
* 정적 팩토리 메소드
* @제품 반환
*/
public static Creator Factory(){
새로운 Creator() 반환 ;
}
}

1.1.4.3.3 테스트 클래스
package com.lavasoft.patterns.simplefactory.gchb;

/**
* 작성: IntelliJ IDEA.
* 파일명:TestApp.java
* 사용자: LavaSoft
* 날짜: 2006-12-1
* 시간: 2:11:30
* "Java and Patterns"(--Dr. Yan Hong 작성) 읽기 노트
* 팩토리 패턴--간단한 팩토리 패턴--작업-도면 병합(팩토리 역할과 추상 제품 역할 병합)
* ReadMe: 작품-그림 병합 테스트 수업
*/
public class TestApp {
private void test() {
Creator t = Creator.factory();
System.out.println("제품 성공적으로 생성되었습니다!");
}

public static void main(String args[]) {
new TestApp().test();
}
}

1.1.4.3.4 테스트 결과
제품이 성공적으로 생산되었습니다!

종료 코드 0으로 프로세스 완료

1.1 .4.4 추상 역할과 병합된 팩토리 역할
어떤 경우에는 팩토리 역할이 추상 제품 역할로 수행될 수 있습니다. 일반적인 애플리케이션은 아래 그림에 표시된 것처럼 하위 클래스의 팩토리이기도 한 추상 제품 클래스인 java.text.DateFormat 클래스입니다.

다음은 구현을 직접 작성했으며 소스 코드는 다음과 같습니다.

1.1.4.4.1 추상 제품 클래스(팩토리 클래스이기도 함)
package com.lavasoft.patterns.simplefactory. cxsl;

/**
* 작성: IntelliJ IDEA.
* 파일명:AbsProduct.java
* 사용자: LavaSoft
* 날짜: 2006-12-3
* 시간: 3:23:47
* "Java and Patterns"(--Dr. Yan Hong 작성) 읽기 노트
* 팩토리 패턴 - 단순 팩토리 패턴 - 팩토리 역할과 추상 제품 역할의 병합
* ReadMe: 추상 제품 클래스 및 팩토리 동시에 수업합니다.
*/
공용 추상 클래스 AbsProduct {
static Product Factory(){
return new Product();
}
}

1.1.4.4.2 특정 제품 등급
패키지 com.lavasoft.patterns.simplefactory.cxsl;

/**
* 작성: IntelliJ IDEA.
* 파일명:Product.java
* 사용자: LavaSoft
* 날짜: 2006-12-3
* 시간: 3:23:54
* "Java and Patterns"(Dr. Yan Hong 작성) 읽기 노트
* 팩토리 패턴--간단한 팩토리 패턴--팩토리 역할과 추상적인 제품 역할 병합
* ReadMe: 특정 제품 카테고리
*/
public class Product {
Product(){
}
}

1.1.4.4.3 테스트 클래스
package com.lavasoft.patterns.simplefactory .cxsl;

/**
* 작성: IntelliJ IDEA.
* 파일명:TestApp.java
* 사용자: LavaSoft
* 날짜: 2006-12-3
* 시간: 3:30:30
* "Java and Patterns"(--Dr. Yan Hong 작성) 읽기 노트
* 팩토리 패턴 - 단순 팩토리 패턴 - 팩토리 역할과 추상 제품 역할 병합
* ReadMe: 테스트 클래스
*/
public class TestApp {
private void test() {
제품 a = AbsProduct.factory();
시스템. out.println("제품 객체 생성 성공!");
}

public static void main(String args[]) {
TestApp test = new TestApp();
test .test();
}
}

1.1.4.4.4 테스트 결과

제품 객체 성공적으로 생성되었습니다!

종료 코드 0으로 프로세스 완료

이 구현은 매우 간단하므로 코드에 대해서는 자세히 설명하지 않겠습니다!

1.1.4.5 세 가지 역할이 모두 병합됩니다

위의 예를 바탕으로 하면 추상적인 제품 역할도 생략되고, 팩토리 역할도 가능합니다. 특정 제품 역할과 병합됩니다. 즉, 제품 클래스는 자체 공장입니다. 아래 그림과 같습니다.

간단한 구현 예는 다음과 같습니다.

1.1.4.5.1 특정 제품 카테고리
패키지 com.lavasoft.patterns.simplefactory.sshb;

/**
* 작성: IntelliJ IDEA.
* 파일명:ConcreteProduct.java
* 사용자: LavaSoft
* 날짜: 2006-12-1
* 시간: 2:20:38
* "Java and Patterns"(--Dr. Yan Hong 작성) 읽기 노트
* 팩토리 패턴--간단한 팩토리 패턴--3색이 하나로 통합된 패턴
* ReadMe: 추상 제품, 제품, 공장 클래스 3 및 1 특정 제품 카테고리
*/
public class ConcreteProduct
{
public ConcreteProduct(){}

/**
* 정적 팩토리 메소드
* @return 특정 제품 ConcreteProduct 인스턴스
*/
public static ConcreteProduct Factory()
{
return new ConcreteProduct();
}
}

1.1.4.5.2 테스트 클래스
package com.lavasoft .patterns.simplefactory.sshb;

/**
* 작성: IntelliJ IDEA.
* 파일명:TestApp.java
* 사용자: LavaSoft
* 날짜: 2006-12-1
* 시간: 2:24:22
* "Java and Patterns" (--Dr. Yan Hong 작성) 읽기 노트
* 팩토리 모드--간단한 팩토리 모드--3가지 색상을 하나의 모드로
* ReadMe: 테스트 방법
*/

public class TestApp {
//테스트 방법
private void test(){
ConcreteProduct t=ConcreteProduct.factory();
System.out.println("제품이 성공적으로 생산되었습니다!");
}
//
public static void main(String args[]){
new TestApp().test();
}
}

1.1.4.5.3 테스트 실행 결과
제품이 성공적으로 제작되었습니다!

종료 코드 0으로 프로세스 완료

코드는 매우 간단하므로 더 이상 설명하지 않겠습니다.

1.1.4.6 제품 객체 재활용 및 등록된 팩토리 방법
이는 싱글톤 모드와 다중 인스턴스 모드에서 논의됩니다.
간단한 팩토리 패턴의 장점과 단점

1.1.4.6.1 단순 팩토리 패턴의 장점
핵심 팩토리 클래스, 어떤 팩토리 클래스를 생성할지 결정하는 팩토리 클래스 어떤 상황 제품 클래스의 예. 고객은 상품 객체를 직접 생성하는 책임에서 면제되며, 상품만을 "소비"합니다. 간단한 팩토리 패턴은 이 접근 방식을 통해 책임 분리를 달성합니다.

1.1.4.6.2 단순 팩토리 패턴의 단점
제품 클래스가 복잡한 다단계 계층 구조를 가질 경우 팩토리 클래스는 자신만 갖습니다. 단점은 변하지 않은 채 모든 변화에 적응하는 것입니다.
이 팩토리 클래스는 모든 제품 생성 로직을 집약하여 모든 것을 알고 있는 전능한 클래스(신 클래스라고도 함)를 구성합니다. 이 클래스에 문제가 발생하면 전체 애플리케이션에 큰 영향을 미칩니다.
제품에 여러 인터페이스가 있는 경우 어떤 조건에서 어떤 제품 클래스 인스턴스를 생성할지 결정하기 어려울 수 있습니다.
공장에 새로운 제품을 추가하는 것은 고통스러운 과정입니다. 팩토리 역할은 각 제품, 제품 생성 방법, 고객에게 제공할 시기를 알아야 합니다. 즉, 새로운 제품을 수락한다는 것은 이 팩토리 역할의 소스 코드를 수정하는 것을 의미합니다. 단순 공장에서는 개방형 폐쇄 원칙을 제한된 범위에서만 지원합니다.
간단한 팩토리 패턴은 정적 메서드를 팩토리 메서드로 사용하고 정적 메서드는 서브클래스에서 상속받을 수 없으므로 팩토리 역할은 상속을 기반으로 계층 구조를 형성할 수 없습니다. 이러한 단점은 팩토리 메소드 패턴에서 극복됩니다.

1.1.4.7 Java의 간단한 팩토리 패턴 적용
DateFormat 및 간단한 팩토리 패턴
SAX2 라이브러리의 XMLReaderFactory 및 간단한 팩토리 패턴

1.1.4.8 누와는 흙으로 사람을 만든다
누와는 흙으로 사람을 만들어야 한다. 간단한 팩토리 패턴을 적용한 클래스 다이어그램은 다음과 같다.

누와는 공장 캐릭터, 사람은 추상적인 제품 캐릭터, 장산과 리시는 제품이다. 구체적인 구현은 여기에서 제공되지 않습니다. 과일을 생산하는 정원사의 예를 참조하세요.

더 많은 Java 디자인 패턴 단순 팩토리 패턴 관련 기사를 보려면 PHP 중국어 사이트를 주목하세요!