Eine kurze Einführung in das Singleton-Muster in Java

In diesem Artikel werden hauptsächlich einfache verwandte Informationen zum Java-Singleton-Modus vorgestellt, die einen gewissen Referenzwert haben

Konzept

Das Singleton-Muster ist ein häufig verwendetes Software-Designmuster. Es enthält in seiner Kernstruktur nur eine spezielle Klasse, die Singleton-Klasse genannt wird. Der Singleton-Modus kann sicherstellen, dass es nur eine Instanz einer Klasse im System gibt und dass die Instanz von außen leicht zugänglich ist, wodurch die Kontrolle über die Anzahl der Instanzen erleichtert und Systemressourcen gespart werden. Wenn nur ein Objekt einer bestimmten Klasse im System vorhanden sein soll, ist das Singleton-Muster die beste Lösung. Meiner Meinung nach erlaubt ein Singleton der Außenwelt nicht, Objekte zu erstellen.

1.1 Konzeptanalyse

Für Singletons sollten aus der obigen konzeptionellen Analyse die folgenden Bedingungen erfüllt sein:

Erstens: Es kann nur ein Singleton-Objekt geben;

Zweitens: Die Singleton-Klasse muss ihr eigenes eindeutiges Instanzobjekt erstellen.

Drittens: Auf dieses Instanzobjekt kann von der Außenwelt zugegriffen werden, und die Außenwelt kann es nicht selbst erstellen.

2. Mehrere gängige Methoden des Singleton-Modus

In Java ist der Singleton-Modus im Allgemeinen in Lazy-Stil und Hungrig-Typ sowie Registrierungstyp unterteilt. Der Registrierungstyp wird jedoch im Allgemeinen seltener gesehen und kann daher leicht ignoriert werden. Hätte der Autor es heute nicht plötzlich zusammenfassen wollen und im Internet nach Informationen gesucht, wäre mir das nicht aufgefallen. Der Code wird auf diese Weise veröffentlicht und unten erklärt.

2.1 Hungry-Chinese Singleton-Klasse

package com.ygh.singleton;
/**
 * 饿汉式单例类
 * @author 夜孤寒
 * @version 1.1.1
 */
public class HungerSingleton {
  //将构造方法私有，外界类不能使用构造方法new对象
  private HungerSingleton(){}
  //创建一个对象
  private static final HungerSingleton lazySinleton=new HungerSingleton();
  //设置实例获取方法，返回实例给调用者
  public static HungerSingleton getInstance(){
    return lazySinleton;
  }
}

Schreiben Sie eine Testklasse, um zu testen, ob der Singleton implementiert ist:

package com.ygh.singleton;
/**
 * 测试单例类
 * 
 * @author 夜孤寒
 * @version 1.1.1
 */
public class Test {
  public static void main(String[] args) {
    /*
     * 构造方法私有化，不能够使用下面方式new对象
     */
    //HungerSingleton hungerSingleton=new HungerSingleton();
    //使用实例获取方法来获取对象
    HungerSingleton h1=HungerSingleton.getInstance();
    HungerSingleton h2=HungerSingleton.getInstance();
    System.out.println(h1==h2);//true
  }
}

Wie aus dem Obigen ersichtlich ist: Die beiden Referenzen dieser Testklasse sind gleich, was bedeutet, dass die beiden Referenzen auf dasselbe Objekt verweisen, was genau dem Singleton-Muster entspricht Standard. Hier endet die hungrige chinesische Einführung.

2.2 Hungry-Chinese Singleton-Klasse

package com.ygh.singleton;
/**
 * 懒汉式单例类
 * @author 夜孤寒
 * @version 1.1.1
 */
public class LazySingleton {
  //将构造方法私有，外界类不能使用构造方法new对象
  private LazySingleton(){}
  //创建一个对象，不为final
  private static LazySingleton lazySingleton=null;
  //设置实例获取方法，返回实例给调用者
  public static LazySingleton getInstance(){
    //当单例对象不存在，创建
    if(lazySingleton==null){
      lazySingleton=new LazySingleton();
    }
    //返回
    return lazySingleton;
  }
}

Testklasse:

package com.ygh.singleton;
/**
 * 测试单例类
 * 
 * @author 夜孤寒
 * @version 1.1.1
 */
public class Test {
  public static void main(String[] args) {
    /*
     * 构造方法私有化，不能够使用下面方式new对象
     */
    //LazySingleton lazySingleton=new LazySingleton();
    //使用实例获取方法来获取对象
    LazySingleton l1=LazySingleton.getInstance();
    LazySingleton l2=LazySingleton.getInstance();
    System.out.println(l1==l2);//true
  }
}

Wie aus dem Obigen ersichtlich ist: Die beiden Referenzen dieser Testklasse sind gleich, was bedeutet, dass die beiden Referenzen auf dasselbe Objekt verweisen, und dies entspricht genau dem Singleton-Musterstandard. Dies ist das Ende der Einführung zum faulen Mann.

2.3 Der Unterschied zwischen dem faulen chinesischen Stil und dem hungrigen chinesischen Stil

Der faule chinesische Stil bedeutet, dass ein Singleton-Objekt erstellt wird, wenn kein Objekt vorhanden ist erstellt werden, ist dies möglicherweise nicht so einfach zu verstehen, aber wenn Leser daran interessiert sind, mehr zu erfahren, können sie Haltepunkte in Eclipse zum Testen verwenden, Haltepunkte zum Inhalt innerhalb der geschweiften Klammern der LazySingleton-Klasse hinzufügen und dann in der Testen Sie die Klasse und verwenden Sie die Debug-Operation. Dies kann leicht widergespiegelt werden, wenn beim ersten Mal ein Objekt erstellt wird, beim zweiten Mal jedoch kein Objekt.

Der hungrige chinesische Stil wird durch die Verwendung des Schlüsselworts final zum Erstellen des Objekts implementiert. Wenn der Aufrufer das Instanzobjekt benötigt, kann die erstellte Instanz über die Methode getInstance abgerufen werden.

2.4 Registrierte Singleton-Klasse

Der Autor ist mit der registrierten Singleton-Klasse nicht sehr vertraut. Ich habe einen Code im Internet veröffentlicht, damit Sie ihn selbst studieren können eigen.

import java.util.HashMap;
import java.util.Map;

/**
 * 登记式单例类
 * @author Administrator
 *
 */
public class RegisterSingleton {
 private static Map<String, RegisterSingleton> map = new HashMap<String, RegisterSingleton>();
 static {
  RegisterSingleton single = new RegisterSingleton();
  map.put(single.getClass().getName(), single);
 }

 /*
  * 保护的默认构造方法
  */
 protected RegisterSingleton() {
 }

 /*
  * 静态工厂方法,返还此类惟一的实例
  */
 public static RegisterSingleton getInstance(String name) {
  if (name == null) {
   name = RegisterSingleton.class.getName();
   System.out.println("name == null" + "--->name=" + name);
  }
  if (map.get(name) == null) {
   try {
    map.put(name, (RegisterSingleton) Class.forName(name).newInstance());
   } catch (InstantiationException e) {
    e.printStackTrace();
   } catch (IllegalAccessException e) {
    e.printStackTrace();
   } catch (ClassNotFoundException e) {
    e.printStackTrace();
   }
  }
  return map.get(name);
 }

 /*
  * 一个示意性的商业方法
  */
 public String about() {
  return "Hello, I am RegSingleton.";
 }

 public static void main(String[] args) {
  RegisterSingleton single3 = RegisterSingleton.getInstance(null);
  System.out.println(single3.about());
 }
}

Das obige ist der detaillierte Inhalt vonEine kurze Einführung in das Singleton-Muster in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!