Que sont les modèles de conception Java ? Introduction au modèle Singleton dans les modèles de conception Java-javaDidacticiel-php.cn

Le contenu de cet article porte sur ce que sont les modèles de conception Java ? L'introduction du modèle singleton dans les modèles de conception Java a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer.

Avant-propos

J'ai entendu le nom de Design Pattern peu de temps après avoir appris la programmation, mais comme j'étais encore complètement novice à l'époque, je ne l'ai pas fait touche-le. Ce n'est que lorsque je me suis familiarisé avec les codes commerciaux simples au travail que je suis officiellement entré en contact avec les modèles de conception. Le premier modèle de conception avec lequel j'ai été en contact à cette époque était le Factory Pattern, mais cet article parle du Singleton Pattern, que j'expliquerai dans le prochain article. Quant à savoir pourquoi nous expliquons le modèle de cas unique en premier ? C'est parce que le modèle de cas unique est le modèle de conception le plus simple... . Tout a toujours une séquence, donc c’est facile d’abord, puis difficile. Bon, assez de bêtises, passons à l’histoire principale.

Introduction aux modèles de conception

Explication : L'introduction mentionnée ici est la véritable « introduction ».

Qu'est-ce qu'un modèle de conception ?

Un modèle de conception est un ensemble d'expériences de conception de code qui sont utilisées à plusieurs reprises, connues de la plupart des gens et cataloguées.

Pourquoi utiliser des modèles de conception

Utiliser des modèles de conception consiste à réutiliser le code, à rendre le code plus facile à comprendre par les autres et à garantir la fiabilité du code.

Types de modèles de conception

Il existe 23 types de modèles de conception. Selon la classification principale, il peut être divisé en trois grandes catégories :

1. Modèles basés sur la création

Ces modèles de conception permettent de masquer la logique de création. lors de la création d'objets, au lieu d'utiliser l'opérateur new pour instancier l'objet directement. Cela permet au programme d'être plus flexible dans la détermination des objets à créer pour une instance donnée.

Modèle Singleton
Modèle d'usine
Modèle d'usine abstrait
Mode Constructeur
Mode Prototype

Mode Structurel

Ceux-ci. les modèles de conception se concentrent sur la composition des classes et des objets. Le concept d'héritage est utilisé pour composer des interfaces et définir la manière dont les objets composés acquièrent de nouvelles fonctionnalités.

Mode Adaptateur
Mode Pont
Mode Filtre
Mode Composition
Mode Décorateur
Mode Apparence
Motif poids mouche
Modèle d'agent

3. Modèle de comportement

Ces modèles de conception accordent une attention particulière à la communication des objets entre .

Mode chaîne de responsabilité
Mode commande
Mode interprète
Modèle d'itérateur
Modèle de médiateur
Modèle de mémo
Modèle d'observateur
Modèle d'état
Modèle d'objet vide
Modèle de stratégie
Modèle de modèle
Modèle de visiteur

Principes du modèle de conception

Les six principes de modèles de conception

Principe d'ouverture et de fermeture : ouvert à l'extension, fermé à la modification.
Principe de substitution de Richter : un complément au principe d'ouverture et de fermeture. Partout où une classe de base peut apparaître, une sous-classe peut certainement apparaître. LSP est la pierre angulaire de la réutilisation de l'héritage. Ce n'est que lorsque la classe dérivée peut remplacer la classe de base et que la fonction de l'unité logicielle n'est pas affectée que la classe de base peut être véritablement réutilisée et que la classe dérivée peut également en ajouter de nouvelles sur la base de. la classe de base.
Principe d'inversion de dépendance : pour la programmation d'interface, comptez sur l'abstraction plutôt que sur le concret.
Principe d'isolation des interfaces : Essayez d'utiliser plusieurs interfaces isolées afin de réduire le couplage entre les classes.
Loi de Déméter : Une entité doit interagir le moins possible avec d'autres entités, ce qui rend les modules fonctionnels du système relativement indépendants.
Principe de composition et de réutilisation : Essayez d'utiliser la composition/agrégation au lieu de l'héritage.

Modèle Singleton

Qu'est-ce que le modèle Singleton

Garantit qu'il n'y a qu'une seule instance d'une certaine classe dans un système et que l'instance est facile d'accès depuis le monde extérieur. Par exemple, le gestionnaire de tâches de l'interface Windows peut être considéré comme un singleton.

Scénarios d'utilisation du mode singleton

Les plus couramment utilisés dans les programmes sont pool de connexions à la base de données, pool de threads, objet de journalAttendez.

Utiliser le mode singleton

Lorsque nous avons appris pour la première fois le mode singleton, nous sommes essentiellement entrés en contact avec ces deux modes : le style chinois affamé et le style chinois complet (style chinois paresseux ) ).
Ensuite, examinons d'abord la mise en œuvre de ces deux modes.

Style chinois affamé
Définissez un constructeur privé, définissez son propre objet d'instance en tant que propriété privée, ajoutez des modificateurs statiques et finaux, puis transmettez les appels de méthode statique publics qui renvoient des instances.

 class SingletonTest1 {  

    private SingletonTest1() {  
    }  
    private static final SingletonTest1 instance = new SingletonTest1();  

    public static SingletonTest1 getInstance() {  
        return instance;  
    }  
}

Copier après la connexion

Style Fuhan
Définissez un constructeur privé, définissez une variable privée statique de la classe, puis définissez une méthode statique publique pour définir la valeur de la classe Effectuez une jugement nul et retourner directement s'il n'est pas nul, sinon en reconstruire un.

class SingletonTest2 {

     private SingletonTest2() {   
     }   

     private static SingletonTest2 instance;   

     public static SingletonTest2 getInstance() {   
         if (instance == null) {
            instance = new SingletonTest2();
        }   
         return instance;   
     }   
 }

Copier après la connexion

简单的介绍了这两种的模式，然后我们再来看看这两种模式的优缺点吧。
饿汉式

优点：写起来很简单，并且不会因为不加synchronized关键字而造成的线程不安全问题。
缺点：当该类被加载的时候，会初始化该实例和静态变量并被创建并分配内存空间，并且会一直占用内存。

饱汉式

优点：写起来很简单，在第一次调用的时候才会初始化，节省了内存。
缺点：线程不安全，多个线程调用可能会出现多个实例。
总结：书写简单，线程不安全，效率还行。

虽然 饱汉式可以通过加上synchronized关键字保证线程安全。但是效率方法来说还不说是最优。

这里在介绍下个人认为在JDK1.5之前最优的两种写法，一种是静态内部类，另一种是双重锁检查。

静态内部类
定义一个私有的构造方法，定义一个该类私有静态的内部类，然后在内部类中定义一个该类的静态变量，然后通过公共的final修饰的静态方法调用返回实例。

  class  SingletonTest4 {
      private SingletonTest4(){
        }
       private static class SingletonTest5{
           private static SingletonTest4 instance = new SingletonTest4();
        }
        public static final SingletonTest4 getInstance(){
            return SingletonTest5.instance;
        }
   }

Copier après la connexion

因为该类的内部类是私有的，除了对外公布的公共静态方法getInstance()，是无法访问的。因为它是延迟加载，所以读取读取实例的时候不会进行同步，几乎没有性能的缺陷，而且还是线程安全的，并且不依赖JDK的版本。

双重锁检查
定义一个私有构造方法，通过volatile定义静态私有变量，保证了该变量的可见性，然后定义一个共有的静态方法，第一次对该对象实例化时与否判断，不为空直接返回，提升效率；然后使用synchronized 进行同步代码块，防止对象未初始化时，在多线程访问该对象在第一次创建后，再次重复的被创建；然后第二次对该对象实例化时与否判断，如果未初始化，则初始化，否则直接返回该实例。

  class SingletonTest6 { 
        private SingletonTest6() { 
        }   
        private static volatile SingletonTest6 instance;  
        public static SingletonTest6 getIstance() { 
            if (instance == null) {
                synchronized (SingletonTest6.class) {
                    if (instance == null) {
                        instance = new SingletonTest6();   
                    }   
                }   
            }   
            return instance;   
        }   
    }

Copier après la connexion

这种模式在很长的一段时间内可以说是最优的了，内存占用低，效率高，线程安全，多线程操作原子性。但是有个缺点就是书写麻烦，对新手不太友好。

JDK1.5之后出现了枚举，并且完美支持单例模式，并且线程安全、效率高！但是这些不是最重要的，最重要的是书写超级简单！究竟有多简单，看下面的示例应该就可以了解一下了。。。

枚举单例

 enum SingletonTest7{
        INSTANCE;
     }

Copier après la connexion

对的，你没看错，就这点代码，其它不需要了。。。
枚举需要在JDK1.5之后的版本，它无偿提供序列化机制，绝对防止多次实例化，即使在面对复杂的序列化或者反射攻击的时候。这种方法也被Effective Java作者Josh Bloch 所提倡。

总结

单例模式的几种使用就到这了，那么我们来总结下使用单例模式需要注意什么(不包括枚举)。

构造方法私有化（private）;
定义一个私有(private)静态(static)实例化对象;
对外提供一个公共(public)静态(static)的方法得到该实例;