Was sind Java-Designmuster? Einführung in das Singleton-Muster in Java Design Patterns-javaLernprogramm-php.cn

Der Inhalt dieses Artikels befasst sich mit den Java-Entwurfsmustern. Die Einführung des Singleton-Musters in Java-Designmuster hat einen gewissen Referenzwert. Freunde in Not können sich darauf beziehen.

Vorwort

Ich hörte den Namen Design Pattern nicht lange nachdem ich das erste Mal Programmieren gelernt hatte, aber da ich damals noch ein absoluter Anfänger war, hörte ich davon nichts Berühre es. Erst als ich mich bei der Arbeit mit einfachen Geschäftsregeln vertrauter machte, kam ich offiziell mit Designmustern in Kontakt. Das früheste Designmuster, mit dem ich damals in Kontakt kam, war das Factory Pattern, aber in diesem Artikel geht es um das Singleton Pattern, das ich im nächsten Artikel erläutern werde. Warum erklären wir zuerst das Einzelfallmuster? Das liegt daran, dass das Einzelfallmuster das einfachste Designmuster ist... . Alles hat immer eine Reihenfolge, also ist es zuerst einfacher und dann schwieriger. Okay, genug Unsinn, kommen wir zur Hauptgeschichte.

Einführung in Designmuster

Erklärung: Die hier erwähnte Einführung ist die eigentliche „Einführung“.

Was ist ein Entwurfsmuster?

Ein Entwurfsmuster ist eine Reihe von Code-Entwurfserfahrungen, die wiederholt verwendet werden, den meisten Menschen bekannt und katalogisiert sind.

Warum Entwurfsmuster verwenden?

Die Verwendung von Entwurfsmustern dient dazu, Code wiederzuverwenden, den Code für andere leichter verständlich zu machen und die Zuverlässigkeit des Codes sicherzustellen.

Arten von Designmustern

Es gibt 23 Arten von Designmustern. Es kann entsprechend der Hauptklassifizierung in drei Hauptkategorien unterteilt werden:

1. Erstellungsbasierte Muster

Diese Entwurfsmuster bieten eine Möglichkeit, die Erstellungslogik zu verbergen Erstellen von Objekten, anstatt den neuen Operator zum direkten Instanziieren des Objekts zu verwenden. Dadurch kann das Programm flexibler bestimmen, welche Objekte für eine bestimmte Instanz erstellt werden müssen.

Singleton-Muster
Fabrikmuster
Abstraktes Fabrikmuster
Builder-Modus
Prototyp-Modus

2. Strukturmodus

Diese Entwurfsmuster konzentrieren sich auf die Zusammensetzung von Klassen und Objekten. Das Konzept der Vererbung wird verwendet, um Schnittstellen zu erstellen und die Art und Weise zu definieren, wie zusammengesetzte Objekte neue Funktionalität erhalten.

Adaptermodus
Bridge-Modus
Filtermodus
Kompositionsmodus
Dekorationsmodus
Erscheinungsmodus
Fliegengewichtsmuster
Agentenmuster

3. Verhaltensmuster

Diese Entwurfsmuster legen besonderen Wert auf die Kommunikation zwischen Objekten .

Verantwortungskettenmodus
Befehlsmodus
Dolmetschermodus
Iteratormuster
Mediatormuster
Memomuster
Beobachtermuster
Zustandsmuster
Leerobjektmuster
Strategiemuster
Vorlagenmuster
Besuchermuster

Prinzipien des Designmusters

Die sechs Prinzipien von Entwurfsmuster

Öffnungs- und Schließprinzip: offen für Erweiterung, geschlossen für Änderung.
Richter-Substitutionsprinzip: eine Ergänzung zum Eröffnungs- und Schlussprinzip. Überall dort, wo eine Basisklasse erscheinen kann, kann sicherlich auch eine Unterklasse erscheinen. LSP ist der Eckpfeiler der Wiederverwendung der Vererbung. Nur wenn die abgeleitete Klasse die Basisklasse ersetzen kann und die Funktion der Softwareeinheit nicht beeinträchtigt wird, kann die Basisklasse wirklich wiederverwendet werden und die abgeleitete Klasse kann auch neue hinzufügen die Basisklasse.
Prinzip der Abhängigkeitsinversion: Verlassen Sie sich bei der Schnittstellenprogrammierung eher auf Abstraktion als auf Konkretheit.
Prinzip der Schnittstellenisolation: Versuchen Sie, mehrere isolierte Schnittstellen zu verwenden, um die Kopplung zwischen Klassen zu verringern.
Demeter-Gesetz: Eine Entität sollte so wenig wie möglich mit anderen Entitäten interagieren, wodurch die Funktionsmodule des Systems relativ unabhängig werden.
Prinzip der Zusammensetzung und Wiederverwendung: Versuchen Sie, Zusammensetzung/Aggregation anstelle von Vererbung zu verwenden.

Singleton-Muster

Was ist das Singleton-Muster?

Stellt sicher, dass es nur eine Instanz einer bestimmten Klasse in einem System gibt und dass die Instanz vorhanden ist von außen leicht zugänglich. Beispielsweise kann der Task-Manager in der Windows-Oberfläche als Singleton betrachtet werden.

Verwendungsszenarien des Singleton-Modus

Die in Programmen am häufigsten verwendeten sind Datenbankverbindungspool, Thread-Pool, ProtokollobjektWarte.

Singleton-Modus verwenden

Als wir den Singleton-Modus zum ersten Mal lernten, kamen wir im Wesentlichen mit diesen beiden Modi in Kontakt: hungriger chinesischer Stil und vollständiger chinesischer Stil (fauler chinesischer Stil). ) ).
Dann werfen wir zunächst einen Blick auf die Implementierung dieser beiden Modi.

Hungriger chinesischer Stil
Definieren Sie einen privaten Konstruktor, legen Sie sein eigenes Instanzobjekt als private Eigenschaft fest, fügen Sie statische und endgültige Modifikatoren hinzu und übergeben Sie dann die öffentlichen Rückgabeinstanzen statischer Methodenaufrufe.

 class SingletonTest1 {  

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

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

Nach dem Login kopieren

Fuhan-Stil
Definieren Sie einen privaten Konstruktor, definieren Sie eine statische private Variable der Klasse und definieren Sie dann eine öffentliche statische Methode, um den Wert des Klassenurteils auf Null zu setzen und direkt zurückzugeben wenn nicht leer, andernfalls eins rekonstruieren.

class SingletonTest2 {

     private SingletonTest2() {   
     }   

     private static SingletonTest2 instance;   

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

Nach dem Login kopieren

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

优点：写起来很简单，并且不会因为不加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;
        }
   }

Nach dem Login kopieren

因为该类的内部类是私有的，除了对外公布的公共静态方法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;   
        }   
    }

Nach dem Login kopieren

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

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

枚举单例

 enum SingletonTest7{
        INSTANCE;
     }

Nach dem Login kopieren

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

总结

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

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