Modello di design Singleton vs fagioli Singleton in contenitore Spring

Come tutti sappiamo abbiamo i bean come singleton di default nel contenitore Spring e se abbiamo un’applicazione web basata su Spring framework, allora in quel caso abbiamo davvero bisogno di implementare il modello di progettazione di Singleton per conservare i dati globali piuttosto che creare un bean attraverso la spring .

Per favore, sopportami se non sono in grado di spiegare cosa volessi veramente chiedere.

Un fagiolo singleton in spring e il motivo singleton sono piuttosto diversi. Il modello Singleton dice che una sola e unica istanza di una particolare class verrà mai creata per classloader.

L’ambito di un singleton Spring è descritto come “per contenitore per bean”. È l’ambito della definizione del bean per una singola istanza di object per contenitore di IoC di spring. L’ambito predefinito in spring è Singleton.

Anche se l’ambito predefinito è Singleton, è ansible modificare l’ambito del bean specificando l’attributo scope dell’elemento .

  

L’ambito Singleton in spring significa singola istanza in un contesto di spring.
Il contenitore Spring restituisce semplicemente la stessa istanza ancora e ancora per le chiamate successive per ottenere il bean.

E molla non dà fastidio se la class del bean è codificata come singleton o no, infatti se la class è codificata come singleton il cui costruttore è privato, Spring usa BeanUtils.instantiateClass (javadoc qui ) per impostare il costruttore su accessibile e invocare esso.

In alternativa, possiamo usare un attributo di metodo di fabbrica nella definizione di bean come questo

   

Facciamo l’esempio più semplice: hai un’applicazione e usi solo il classloader predefinito. Hai una class che, per qualsiasi ragione, decidi che non dovrebbe avere più di un’istanza nell’applicazione. (Pensa a uno scenario in cui diverse persone lavorano su alcuni pezzi dell’applicazione).

Se non si utilizza il framework Spring, il pattern Singleton garantisce che non ci sarà più di un’istanza di una class nella propria applicazione. Questo perché non è ansible istanziare istanze della class facendo ‘new’ perché il costruttore è privato. L’unico modo per ottenere un’istanza della class è chiamare un metodo statico della class (di solito chiamato ‘getInstance’) che restituisce sempre la stessa istanza.

Dire che stai usando il framework Spring nella tua applicazione, significa solo che oltre ai normali modi di ottenere un’istanza della class (metodi nuovi o statici che restituiscono un’istanza della class), puoi anche chiedere a Spring di farti ottenere un’istanza di quella class e Spring assicurerà che ogni volta che lo chiedi per un’istanza di quella class restituirà sempre la stessa istanza, anche se non hai scritto la class usando il pattern Singleton. In altre parole, anche se la class ha un costruttore pubblico, se si chiede sempre a Spring un’istanza di quella class, Spring chiamerà quel costruttore solo una volta durante la vita dell’applicazione.

Normalmente, se stai usando Spring, dovresti usare solo Spring per creare istanze e puoi avere un costruttore pubblico per la class. Ma se il tuo costruttore non è privato, non stai impedendo a nessuno di creare direttamente nuove istanze della class, aggirando Spring.

Se vuoi veramente una singola istanza della class, anche se usi Spring nella tua applicazione e definisci la class in Spring come single, l’unico modo per assicurarti che sia anche implementare la class usando il pattern Singleton. Ciò assicura che ci sarà una singola istanza, se le persone usano Spring per ottenere un’istanza o bypassare Spring.

Lo scope Singleton in Spring significa che questo bean verrà istanziato una sola volta da Spring. In contrasto con l’ambito del prototipo (nuova istanza ogni volta), ambito di richiesta (una volta per richiesta), ambito di sessione (una volta per sessione HTTP).

L’ambito Singleton ha tecnicamente a che fare con il modello di progettazione singleton. Non è necessario implementare i bean come singleton perché possano essere messi in ambito singleton.

I fagioli Singleton in spring e le classi basate sul modello di design Singleton sono piuttosto diversi.

Il modello Singleton garantisce che verrà creata una sola e unica istanza di una particolare class per ogni programma di caricamento classi in cui l’ambito di un bean singleton Spring viene descritto come “per contenitore per bean”. Lo scope Singleton in Spring significa che questo bean verrà istanziato una sola volta da Spring. Il contenitore Spring restituisce semplicemente la stessa istanza ancora e ancora per le chiamate successive per ottenere il bean.

Trovo che “per contenitore per bean” sia difficile da apprendere. Direi “un bean per ID bean”. Abbiamo un esempio per capirlo. Abbiamo un esempio di class bean. Ho definito due bean di questa class nella definizione bean, come:

       

Quindi, quando cerco di ottenere il bean con id “id1”, il contenitore spring crea un bean, lo memorizza nella cache e restituisce lo stesso bean a cui è mai stato fatto riferimento con id1. Se provo a ottenerlo con id7, verrà creato un altro bean dalla class Sample, lo stesso verrà memorizzato nella cache e restituito ogni volta che lo hai indicato con id7.

Questo è improbabile con il modello Singleton. Nel modello Singlton viene sempre creato un object per ogni programma di caricamento classi. Ma in spring molti oggetti vengono creati per la stessa class. Comunque in spring si rende l’ambito come Singleton che restituisce lo stesso object per lo stesso id. Riferimento

“singleton” in spring sta usando l’istanza di bean factory get, quindi la cache; quale modello di disegno singleton è rigorosamente, l’istanza può essere recuperata solo dal metodo statico get e l’object non può mai essere istanziato pubblicamente.

EX: “per contenitore per bean”.

           public class Test { @SuppressWarnings("resource") public static void main(String[] args) { ApplicationContext ac = new ClassPathXmlApplicationContext("ws.xml"); TestBean teatBean = (TestBean) ac.getBean("testBean"); TestBean myBean1 = (TestBean) ac.getBean("myBean"); System.out.println("a : " + teatBean.test + " : " + teatBean.getName()); teatBean.setName("a TEST BEAN 1"); System.out.println("uPdate : " + teatBean.test + " : " + teatBean.getName()); System.out.println("a1 : " + myBean1.test + " : " + myBean1.getName()); myBean1.setName(" a1 TEST BEAN 10"); System.out.println("a1 update : " + teatBean.test + " : " + myBean1.getName()); } } public class TestBean { public int test = 0; public String getName() { return name; } public void setName(String name) { this.name = name; } private String name = "default"; public TestBean(int i) { test += i; } } 

JAVA SINGLETON:

 public class Singleton { private static Singleton singleton = new Singleton(); private int i = 0; private Singleton() { } public static Singleton returnSingleton() { return singleton; } public void increment() { i++; } public int getInt() { return i; } } public static void main(String[] args) { System.out.println("Test"); Singleton sin1 = Singleton.returnSingleton(); sin1.increment(); System.out.println(sin1.getInt()); Singleton sin2 = Singleton.returnSingleton(); System.out.println("Test"); sin1.increment(); System.out.println(sin1.getInt()); } 

Il bean singleton Spring è descritto come “per contenitore per bean”. L’ambito Singleton in Spring indica che lo stesso object nella stessa posizione di memoria verrà restituito allo stesso ID bean. Se si creano più bean di ID diversi della stessa class, il contenitore restituirà oggetti diversi a ID diversi. Questo è come una mapping dei valori chiave in cui la chiave è bean id e value è l’object bean in un contenitore spring. Dove come modello Singleton garantisce che verrà creata una sola e unica istanza di una particolare class per ogni programma di caricamento classi.