<> Factory mode

<>1, Simple factory mode

<>1.1, definition

Simple factory mode (Simple Factory Pattern) It means that a factory object decides which product class instance to create , Not belong to 23 Design patterns .

A simple factory is a factory of products

<>1.2, Application scenario

The simple factory pattern is suitable for scenes where factory classes create fewer objects , And the client only needs to pass in factory parameters , You don't need to care about the logic of how to create objects .

<>1.3, shortcoming

The responsibilities of factories are relatively heavy , When adding new products, you need to modify the judgment logic of factory class , It violates the opening and closing principle .

It is not easy to expand the overly complex product structure .

<>1.4, example

Payment interface specification :
public interface IPay { void pay(); }
Concrete implementation :
public class AliPay implements IPay { @Override public void pay() { System.out.
println(" Alipay payment "); } } public class WxPay implements IPay { @Override public void
pay() { System.out.println(" Wechat payment "); } } public class BankPay implements IPay {
@Override public void pay() { System.out.println(" UnionPay payment "); } }
factory :
public class PayFactory { // Inherit interface specification using reflection mechanism , So as to realize product creation . public IPay create(Class<?
extends IPay> clazz) { try { if (null != clazz) { return clazz.newInstance(); }
}catch (Exception e) { e.printStackTrace(); } return null; } }
test :
public class Test { public static void main(String[] args) { PayFactory
payFactory= new PayFactory(); IPay pay = payFactory.create(AliPay.class); pay.
pay(); } }
<>2, Factory method model

<>2.1, definition

Factory method model (Factory Method
Pattern) It refers to defining an interface to create an object that loves you , But let's look at the class of this interface to decide which class to instantiate , Factory methods delay instantiation of classes to subclasses .

It belongs to creative design pattern .

Solve product expansion problems . Upgraded version of simple factory mode .

The factory method is the factory of the factory

<>2.2, Application scenario

Creating objects requires a lot of repetitive code .

client ( application layer ) It does not depend on how product class instances are created , Implementation and other details .

A class determines which object to create through its subclasses .

<>2.3, advantage

Users only need to care about the factory corresponding to the required products , No need to care about creation details .

Adding new products conforms to the opening and closing principle , It improves the scalability of the system .

<>2.4, shortcoming

The number of classes is easy to be too many , It increases the complexity of code structure .

It increases the abstraction and understanding difficulty of the system .

<>2.5, example

Payment interface specification :
public interface IPay { void pay(); }
Concrete implementation :
public class AliPay implements IPay { @Override public void pay() { System.out.
println(" Alipay payment "); } } public class WxPay implements IPay { @Override public void
pay() { System.out.println(" Wechat payment "); } } public class BankPay implements IPay {
@Override public void pay() { System.out.println(" UnionPay payment "); } }
Factory method :
public interface IPayFactory { IPay create(); }
Specific example factory :
public class AliPayFactory implements IPayFactory { @Override public IPay
create() { return new AliPay(); } } public class WxPayFactory implements
IPayFactory { @Override public IPay create() { return new WxPay(); } } public
class BankPayFactory implements IPayFactory { @Override public IPay create() {
return new BankPay(); } }
test :
public class Test { public static void main(String[] args) { IPayFactory
payFactory= new AliPayFactory(); IPay pay = payFactory.create(); pay.pay(); } }
<>3, Abstract factory pattern

<>3.1, definition

Abstract factory pattern (Abastract Factory Pattern) It refers to providing an interface to create a series of related or interdependent objects , There is no need to specify their specific classes .

It belongs to creative design pattern .

Product hierarchy and product family

** Product family :** A range of related products , Put them together to make them relevant .

** Product grade :** Same product standard ( That is, the same inheritance system ), Different characteristics .

<>3.2, Application scenarios related to ethylene shall be

client ( application layer ) Does not depend on how product class instances are created , Implementation and other details .

Emphasize a range of relevant product objects ( Belong to the same product family ) Create objects with . A lot of duplicate code is required .

Provide a library of product classes , All products appear with the same interface , So that the client does not depend on the specific implementation .

<>3.3, advantage

Code isolation of specific products in the application layer , No need to care about creation details

Unify a series of product families and create them together

<>3.4, shortcoming

Specifies all product sets that may be created , It is difficult to expand new products in the product family , The of the abstract factory needs to be modified Interface .

It increases the abstraction and understanding difficulty of the system .

Data connection pool is a classic factory model

<>3.5, example

Payment and collection interface specification :
public interface IPay { void pay(); } public interface ICollect { void collect(
); }
Concrete implementation :
public class AliPay implements IPay { @Override public void pay() { System.out.
println(" Alipay payment "); } } public class WxPay implements IPay { @Override public void
pay() { System.out.println(" Wechat payment "); } } public class AliCollect implements
ICollect { @Override public void collect() { System.out.println(" Alipay arrival "); } }
public class WxCollect implements ICollect { @Override public void collect() {
System.out.println(" Wechat arrival "); } }
Abstract factory :
public abstract class Factory { public void init(){ System.out.println(" Open payment link "
); } public abstract IPAay createPay(); public abstract ICollect createCollect()
; }
Factory implementation :
public class AliFactory extends Factory { @Override public IPAay createPay() {
return new AliPay(); } @Override public ICollect createCollect() { return new
AliCollect(); } } public class WxFactory extends Factory { @Override public
IPAay createPay() { return new WxPay(); } @Override public ICollect
createCollect() { return new WxCollect(); } }
test :
public class Test { public static void main(String[] args) { Factory factory =
new AliFactory(); factory.init(); IPAay aliPay = factory.createPay(); aliPay.pay
(); ICollect aliCollect = factory.createCollect(); aliCollect.collect(); Factory
wxFactory= new WxFactory(); wxFactory.init(); IPAay wxPay = wxFactory.createPay
(); wxPay.pay(); ICollect wxCollect = factory.createCollect(); wxCollect.collect
(); } }
<>4, summary

Simple factory : Factory of products

Factory method : Factory factory

Abstract factory : Complex Product Factory , More concerned about making the product family

Spring Application in :

*
AbastractFactory

*
AnnotationApplicationContext wait

Technology
©2019-2020 Toolsou All rights reserved,
C++ of string of compare usage Python Study notes ( one )evo Tool usage problems ——Degenerate covariance rank, Umeyama alignment is not possibleRISC-V_GD32VF103-TIMER0 timer interrupt java Array subscript variable _Java Basic grammar : array be based on stm32 Control four-wheel trolley motor drive ( one ) be based on redis Design of liking function Software engineering career planning mysql Query random data by conditions _MySQL Random query of several qualified records centos7 install RabbitMq