Définition du modèle d'usine: fournit une interface pour créer des objets.
Pourquoi utiliser le mode d'usine
Le modèle d'usine est le modèle le plus utilisé que nous utilisons.
Pourquoi le modèle d'usine est-il si couramment utilisé? Parce que le modèle d'usine équivaut à créer de nouveaux objets d'instance, nous devons souvent générer des objets d'instance basés sur la classe de classe. besoin d'être plus prudent.
Prenons l'exemple de la classe d'échantillons.
La copie de code est la suivante:
Exemple d'échantillon = nouvel échantillon ();
Cependant, la réalité est que nous effectuons généralement des travaux d'initialisation lors de la création d'échantillons d'instances, tels que des bases de données de requête d'attribution, etc.
Tout d'abord, ce que nous pensons, c'est que nous pouvons utiliser le constructeur de l'échantillon, afin que l'instance soit générée et écrite comme:
La copie de code est la suivante:
Exemple d'échantillon = nouvel échantillon (paramètre);
Cependant, si le travail d'initialisation effectué lors de la création d'un exemple d'instance n'est pas aussi simple que l'attribution, il peut être un long code de code.
Pourquoi le code est-il laid? La méthode équivaut à de nombreux œufs. Envoiant de code long dans chaque segment, et le segment est à nouveau "encapsulé" (réduisant la connexion de couplage entre les segments), afin que les risques soient diversifiés. Plus de choses qui affecteront chaque segment.
Dans cet exemple, nous devons d'abord séparer le travail de création d'une instance à partir du travail d'utilisation d'une instance, c'est-à-dire séparer la grande quantité de travail d'initialisation requise pour créer une instance à partir du constructeur de l'échantillon.
Pour le moment, nous avons besoin du modèle d'usine d'usine pour générer des objets, et nous ne pouvons plus utiliser le nouvel échantillon simple (paramètres). De plus, si l'échantillon a un héritage tel que MySample, selon la programmation orientée vers l'interface, nous devons abstraction de l'échantillon dans une interface. Maintenant, l'échantillon est une interface, avec deux sous-classes Mysample et Hissample. Lorsque nous voulons les instancier, comme suit:
La copie de code est la suivante:
Échantillon mysample = new mysample (); échantillon HisSample = new HisSample ();
Au fur et à mesure que le projet s'approfondit, l'échantillon peut «faire sortir beaucoup de fils», nous devons donc instancier ces fils un par un. est inévitable dans les programmes traditionnels.
Mais si vous utilisez consciemment le modèle d'usine depuis le début, ces problèmes ont disparu.
Méthode d'usine
Vous construirez une usine spécialisée dans la production d'échantillons d'instances:
La copie de code est la suivante:
Classe publique Factory {
Créateur de l'échantillon statique public (int) {
// GetClass Generate Sample Généralement, le chargement dynamique des classes peut être utilisé pour charger des classes.
si (qui == 1)
retourner new Samplea ();
sinon si (qui == 2)
retourner un nouveau samponB ();
}
}
Ensuite, dans votre programme, si vous souhaitez instancier un exemple, utilisez le code de code de copie comme suit:
Échantillon Samplea = Factory.Creator (1);
De cette façon, la sous-classe spécifique de l'échantillon n'est pas impliquée dans l'ensemble du processus. Plus il est facile de faire des erreurs. Tous ceux qui ont fait un travail spécifique ont une compréhension approfondie de cela. Il semble que nous puissions également comprendre les principes de la vie de la programmation?
Utilisez des méthodes d'usine pour faire attention à plusieurs rôles. Pour générer l'échantillon de produit, comme indiqué dans la figure ci-dessous.
Pour être plus compliqué, il s'agit de développer la classe d'usine, qui hérite également de sa classe d'implémentation ConcreteFactory.
Usine abstraite
Le modèle d'usine comprend: méthode d'usine et usine abstraite.
La différence entre ces deux modèles réside dans la complexité de la création d'objets. Si notre méthode de création d'un objet devient compliqué, comme dans la méthode d'usine ci-dessus, il s'agit de créer un échantillon d'objet, si nous avons un nouvel échantillon d'interface de produit2.
En supposant ici: l'échantillon a deux classes en béton Samplea et Samleb, et Sample2 a également deux classes en béton Sample2a et SampleB2. Implémentation de sous-classe différentes parties, ce qui suit consiste à étendre l'usine dans l'exemple ci-dessus dans une usine abstraite:
La copie de code est la suivante:
Classe abstraite publique Factory {
Créateur d'échantillon abstrait public ();
Public Résumé Exemple2 Créateur (nom de chaîne);
}
classe publique SimpleFactory étend l'usine {
public échantillon créateur () {......... renvoie une nouvelle Samplea}
Public Sample2 Creator (nom de chaîne) {......... renvoyer un nouvel exemple2a}
}
classe publique BombFactory étend l'usine {
Créateur public public () {...... renvoyer un nouvel échantillon}
Public Sample2 Creator (nom de chaîne) {...... renvoyer un nouvel échantillon2b}
}
D'après ce qui précède, les deux usines produisent chacune un ensemble d'échantillons et d'échantillon2.
Il y a un autre point clé dans l'usine abstraite, car il existe une certaine connexion entre les méthodes qui produisent l'échantillon et l'échantillon 2 dans SimpleFactory, donc ces deux méthodes doivent être regroupées dans une classe. Le processus est unifié, par exemple: le processus de fabrication est relativement simple, donc le nom est simple.
Dans les applications pratiques, la méthode d'usine est utilisée plus fréquemment et elle est combinée avec des chargeurs de classe dynamiques.
Exemples de modèle d'usine Java
Prenons l'exemple de Jive ForumFactory.
La copie de code est la suivante:
Classe abstraite publique ForumFactory {
objet statique privé initlock = new object (); private static string classname = "com.jivesoftware.forum.database.dbForumFactory";
Forumfactory statique public GetInstance (autorisation d'autorisation) {
// Si aucune autorisation valide n'est passée, retournez null.
if (autorisation == null) {return null;}
// Le suivant utilise le mode singleton singleton
if (factory == null) {
synchronisé (initlock) {
if (factory == null) {......
essayer {
// Réimpression dynamique
Classe c = class.forname (className);
factory = (forumFactory) C.NewInstance ();
} catch (exception e) {return null;}
}
}
}
// maintenant, retour.
Renvoie un nouveau ForumFactoryProxy (Autorisation, Factory, Factory.getPerMissions (autorisation));
}
// La méthode de création du forum est complétée par un forum héritant de sous-classe.
Public Résumé Forum CreateForum (nom de chaîne, description de la chaîne)
lance UnauthorizedException, ForumalreadyExistSException;
....
}
Étant donné que Jive stocke désormais des publications de forum et d'autres données de contenu via le système de base de données, si vous souhaitez la modifier pour être implémentée via le système de fichiers, cette méthode d'usine ForumFactory fournit une interface dynamique:
La copie de code est la suivante:
String statique privé classname = "com.jivesoftware.forum.database.dbforumFactory";
Vous pouvez utiliser la méthode que vous avez développée pour créer un forum au lieu de com.jivesoftware.forum.database.dbforumFactory.
Dans le code ci-dessus, il existe trois modes. Forum d'accès: Un si vous êtes un utilisateur enregistré et un invité, les autorisations correspondantes seront différentes, et cette autorisation traverse l'ensemble du système.
Découvrez CatalogDaofactory dans Java Pet Store:
La copie de code est la suivante:
classe publique CatalogDaofactory {
/ **
* Cette méthode développe une sous-classe spéciale pour implémenter le modèle DAO.
* La définition de sous-classe spécifique se trouve dans le descripteur de déploiement J2EE.
* /
public statique CatalogDao getdao () lève CatalogDaosySexception {
CatalogDao Catdao = null;
essayer {
InitialContext ic = new initialContext ();
// Chargement dynamique de Catalog_DAO_CLASS
// Vous pouvez définir votre propre catalogue_dao_class, afin que vous n'ayez pas besoin de changer trop de code
//, effectuez les énormes changements de système.
String className = (string) ic.lookup (jndinames.catalog_dao_class);
catdao = (catalogdao) class.forname (className) .newInstance ();
} catch (namingException ne) {
Jetez un nouveau catalogDaosySException ("CatalogDaofactory.getDao: namingException tout en obtenant dao type: / n" + ne.getMessage ());
} catch (exception se) {
Jetez un nouveau catalogDaosySException ("CatalogDaofactory.getDao: Exception tout en obtenant dao type: / n" + se.getMessage ());
}
retour Catdao;
}
}
CatalogDaofactory est une méthode d'usine typique. .
On peut voir que la méthode d'usine fournit un mécanisme d'extension dynamique très flexible et puissant pour la structure du système. est possible de modifier les fonctions du système dans une transformation.