Abstract engineering pattern of design pattern

1. Definition: Provides an entity class that creates a series of related or interdependent object interfaces without specifying them.

2. Extension:

Each pattern is a solution to a certain problem. The problem of abstract Factory mode is the system design of multi-product hierarchy.
Before you learn the concrete examples of an abstract factory, you should understand two important concepts: product family and product grade.

Product family: Refers to the family of products that are related to the function in different product grade structures. such as AMD's CPU and ADM chip motherboard, the formation of a family. Intel's CPU and Intel chip motherboards are also part of a family. And both families come from two product levels: CPU, motherboard. A hierarchical structure is made up of products of the same structure, as follows:

Understanding the structure of the product is the key to understanding the abstract factory model, and it can be seen that each factory in the abstract factory model creates a family of products instead of one or a group. Groups are free to mix! In fact, the factory method model and the abstract factory model this point difference.

2. Composition:

Abstract Factory:

Specific factory:

Abstract Products:

Specific Products:

3.UML class Diagram:

Let's take a look at the UML diagram of the abstract factory pattern:

Is the Abstract Factory schema structure diagram, allowing us to make a more convenient description:

1. Abstractproduct: Abstract products, they all have the potential to have two different implementations.
2. Concreteproduct: Including ProductA and PRODUCTB, the implementation of the specific classification of two abstract products.
3. Abstractfactory: Abstract factory interface, which should contain all the abstract methods of product creation.
4. Concretefactory: Includes Concretefactorya and CONCRETEFACTORYB, specific factories that create product objects with specific implementations.

4: Example:

Background: Demonstrate this design pattern with an instance of the operations of tables (User and Department) in different databases (Oracle or SQL Server). First look at the code structure diagram:

3.1 first defines two abstract product classes: Iuser.java and Idepartment.java.

Source code for Iuser.java:

[HTML]View Plaincopy

1. Package com.andyidea.patterns.abstractproduct;
3. /**
4. * Abstract Product role: User interface
5. * @author Andy.chen
6. *
7. */
8. Public interface Iuser {
10. }

Idepartment.java Source:

[HTML]View Plaincopy

1. Package com.andyidea.patterns.abstractproduct;
3. /**
4. * Abstract Product role: Department interface
5. * @author Andy.chen
6. *
7. */
8. Public interface Idepartment {
10. }

3.2 Defining abstract Factory classes: Idbfactory.java

[HTML]View Plaincopy

1. PACKAGE COM.ANDYIDEA.PATTERNS.ABSTRACTFACTORY;  
2.   
3. import com.andyidea.patterns.abstractproduct.idepartment;  
4. import com.andyidea.patterns.abstractproduct.iuser;  
5.   
6. /**  
7.  *  abstract factory Role: Factory interface   
8.  *  @author  andy.chen  
9.  *  
10.  */  
11. PUBLIC INTERFACE IDBFACTORY {  
12.   
13.      public iuser createuser ();   
14.     public  idepartment createdepartment ();   
15. }  

3.3 Create a specific product role class: Oracleofuser.java;oracleofdepartment.java;sqlserverofuser.java;sqlserverofdepartment.java. Inherit Iuser.java and Idepartment.java respectively.

Oracleofuser.java Source:

[HTML]View Plaincopy

1. Package com.andyidea.patterns.concreteproduct;
3. Import Com.andyidea.patterns.abstractproduct.IUser;
5. /**
6. * Specific product role: User in Oracle
7. * @author Andy.chen
8. *
9. */
10. public class Oracleofuser implements iuser{
12. Public Oracleofuser () {
13. SYSTEM.OUT.PRINTLN ("Oracle Factory: Operating the user table in Oracle.");
14. }
16. }

Oracleofdepartment.java Source:

[HTML]View Plaincopy

1. PACKAGE COM.ANDYIDEA.PATTERNS.CONCRETEPRODUCT;  
2.   
3. import com.andyidea.patterns.abstractproduct.idepartment;  
4.   
5. /**  
6.  *  specific product role: department  in Oracle  
7.  *  @author  andy.chen  
8.  *  
9.  */  
10. public class oracleofdepartment implements  idepartment{  
11.       
12.      public oracleofdepartment () {  
13.          SYSTEM.OUT.PRINTLN ("Oracle Factory: Operating the Department table in Oracle.");   
14.     }  
15.   
16. }   

Sqlserverofuser.java Source:

[HTML]View Plaincopy

1. PACKAGE COM.ANDYIDEA.PATTERNS.CONCRETEPRODUCT;  
2.   
3. IMPORT COM.ANDYIDEA.PATTERNS.ABSTRACTPRODUCT.IUSER;  
4.   
5. /**  
6.  *  specific product role: Sql server user  
7.  *  @author  andy.chen  
8.  *  
9.  */  
10. public class sqlserverofuser implements iuser{   
11.       
12.     public  Sqlserverofuser () {  
13.          System.out.println ("Sql server Factory: Operate the user table in Sql server.");   
14.     }  
15.   
16. }   

Sqlserverofdepartment.java Source:

[HTML]View Plaincopy

2. Package com.andyidea.patterns.concreteproduct;
6. Import com.andyidea.patterns.abstractproduct.IDepartment;
10. /**
12. * Specific Product roles: department in SQL Server
14. * @author Andy.chen
16. *
18. */
20. public class Sqlserverofdepartment implements idepartment{
24. Public Sqlserverofdepartment () {
26. SYSTEM.OUT.PRINTLN ("SQL Server factory: Manipulating the Department table in SQL Server.");
28. }
32. }

3.4 Create specific factory classes: Oraclefactory.java and Sqlserverfactory.java.

Oraclefactory.java Source:

[HTML]View Plaincopy

2. Package com.andyidea.patterns.concretefactory;
6. Import Com.andyidea.patterns.abstractfactory.IDBFactory;
8. Import com.andyidea.patterns.abstractproduct.IDepartment;
10. Import Com.andyidea.patterns.abstractproduct.IUser;
12. Import com.andyidea.patterns.concreteproduct.OracleOfDepartment;
14. Import Com.andyidea.patterns.concreteproduct.OracleOfUser;
18. /**
20. * Specific factory role: Oracle Factory
22. * @author Andy.chen
24. *
26. */
28. public class Oraclefactory implements idbfactory{
32. @Override
34. Public Iuser CreateUser () {
36. return new Oracleofuser ();
38. }
42. @Override
44. Public Idepartment createdepartment () {
46. return new Oracleofdepartment ();
48. }
52. }

Sqlserverfactory.java Source:

[HTML]View Plaincopy

2. Package com.andyidea.patterns.concretefactory;
6. Import Com.andyidea.patterns.abstractfactory.IDBFactory;
8. Import com.andyidea.patterns.abstractproduct.IDepartment;
10. Import Com.andyidea.patterns.abstractproduct.IUser;
12. Import com.andyidea.patterns.concreteproduct.SQLServerOfDepartment;
14. Import Com.andyidea.patterns.concreteproduct.SQLServerOfUser;
18. /**
20. * Specific factory role: SQL Server Factory
22. * @author Andy.chen
24. *
26. */
28. public class Sqlserverfactory implements idbfactory{
32. @Override
34. Public Iuser CreateUser () {
36. return new Sqlserverofuser ();
38. }
42. @Override
44. Public Idepartment createdepartment () {
46. return new Sqlserverofdepartment ();
48. }
52. }

3.5 Client Test class: Abstractfactoryclient.java

[HTML]View Plaincopy

2. Package com.andyidea.patterns.client;
6. Import com.andyidea.patterns.abstractproduct.IDepartment;
8. Import Com.andyidea.patterns.abstractproduct.IUser;
10. Import Com.andyidea.patterns.concretefactory.OracleFactory;
12. Import Com.andyidea.patterns.concretefactory.SQLServerFactory;
16. /**
18. * Abstract Factory Test class
20. * @author Andy.chen
22. *
24. */
26. public class Abstractfactoryclient {
30. public static void Main (string[] args) {
34. System.out.println ("Welcome to Andy.chen blog!" + "\ n"
36. + "Abstract Factory Patterns." + "\ n"
38. +"-------------------------------");
42. Iuser Oracleuser,sqluser;
44. Idepartment oracledept,sqldept;
46. Oraclefactory of = new Oraclefactory ();
48. Sqlserverfactory SF = new Sqlserverfactory ();
52. Oracleuser = of.createuser ();
54. oracledept = of.createdepartment ();
56. SqlUser = sf.createuser ();
58. sqldept = sf.createdepartment ();
60. }
62. }

"4" program Run results:

[HTML]View Plaincopy

1. Welcome to Andy.chen blog!
2. Abstract Factory Patterns.
3. -------------------------------
4. Oracle Factory: Operate the user table in Oracle.
5. Oracle Factory: Operate the Department table in Oracle.
6. SQL Server Factory: Manipulate the user table in SQL Server.
7. SQL Server Factory: Manipulate the Department table in SQL Server.

5. Application Summary:

Abstract Factory mode Benefits:

First, the easy-to-exchange product line, due to specific factory classes such as idbfactory factory = new Oraclefactory (), only needs to occur once during initialization in an application, making it very easy to change the specific factory of an application, It needs to change the specific plant to use different product configurations.
Second, it separates the concrete creation instance from the client, the client manipulates the instance through their abstract interface, and the specific class name of the product is separated from the implementation of the specific factory, and does not appear in the client code.

6. Extensions:

+ Reflection + configuration files further meet the Five principles of OO

Abstract engineering pattern of design pattern