Ambito del bean @Scope ("prototipo") che non crea nuovo bean

Voglio usare un bean prototipo annotato nel mio controller. Ma la primavera sta creando un fagiolo singleton. Ecco il codice per questo:

@Component
@Scope("prototype")
public class LoginAction {

  private int counter;

  public LoginAction(){
    System.out.println(" counter is:" + counter);
  }
  public String getStr() {
    return " counter is:"+(++counter);
  }
}

Codice controller:

@Controller
public class HomeController {
    @Autowired
    private LoginAction loginAction;

    @RequestMapping(value="/view", method=RequestMethod.GET)
    public ModelAndView display(HttpServletRequest req){
        ModelAndView mav = new ModelAndView("home");
        mav.addObject("loginAction", loginAction);
        return mav;
    }

    public void setLoginAction(LoginAction loginAction) {
        this.loginAction = loginAction;
    }

    public LoginAction getLoginAction() {
        return loginAction;
    }
    }

Modello di velocità:

 LoginAction counter: ${loginAction.str}

Spring config.xmlha attivato la scansione dei componenti:

    <context:annotation-config />
    <context:component-scan base-package="com.springheat" />
    <mvc:annotation-driven />

Ricevo un conteggio incrementale ogni volta. Non riesco a capire dove sto sbagliando!

Aggiornare

Come suggerito da @gkamal , ho creato HomeController webApplicationContext-aware e il problema è stato risolto.

codice aggiornato:

@Controller
public class HomeController {

    @Autowired
    private WebApplicationContext context;

    @RequestMapping(value="/view", method=RequestMethod.GET)
    public ModelAndView display(HttpServletRequest req){
        ModelAndView mav = new ModelAndView("home");
        mav.addObject("loginAction", getLoginAction());
        return mav;
    }

    public LoginAction getLoginAction() {
        return (LoginAction) context.getBean("loginAction");
    }
}

Il prototipo di ambito significa che ogni volta che chiedi a Spring (getBean o iniezione di dipendenza) un'istanza creerà una nuova istanza e fornirà un riferimento a ciò.

Nel tuo esempio, una nuova istanza di LoginAction viene creata e iniettata nel tuo HomeController. Se si dispone di un altro controller in cui si immette LoginAction, verrà visualizzata un'istanza diversa.

Se si desidera un'istanza diversa per ogni chiamata, quindi è necessario chiamare getBean ogni volta, l'iniezione in un bean singleton non lo farà.

Dalla primavera 2.5 esiste un modo molto semplice (ed elegante) per raggiungere questo obiettivo.

Puoi semplicemente modificare i parametri proxyModee valuel' @Scopeannotazione.

Con questo trucco puoi evitare di scrivere codice extra o iniettare ApplicationContext ogni volta che hai bisogno di un prototipo all'interno di un bean singleton.

Esempio:

@Service 
@Scope(value="prototype", proxyMode=ScopedProxyMode.TARGET_CLASS)  
public class LoginAction {}

Con la configurazione sopra LoginAction(dentro HomeController) è sempre un prototipo anche se il controller è un singleton .

Solo perché il bean iniettato nel controller ha un ambito prototipo non significa che lo sia!

@controller è un oggetto singleton e se iniettare un bean prototipo in una classe singleton renderà il bean prototipo anche come singleton a meno che non si specifichi l'utilizzo della proprietà del metodo di ricerca che crea effettivamente una nuova istanza del bean prototipo per ogni chiamata effettuata.

Come menzionato da nicholas.hauschild, l' iniezione del contesto primaverile non è una buona idea. Nel tuo caso, @Scope ("richiesta") è sufficiente per risolverlo. Supponiamo che siano necessarie diverse istanze del LoginActionmetodo controller. In questo caso, consiglierei di creare il bean del fornitore ( soluzione Spring 4 ):

    @Bean
    public Supplier<LoginAction> loginActionSupplier(LoginAction loginAction){
        return () -> loginAction;
    }

Quindi iniettarlo nel controller:

@Controller
public class HomeController {
    @Autowired
    private  Supplier<LoginAction> loginActionSupplier;  

L'uso ti ApplicationContextAwaresta legando a Spring (che potrebbe essere o meno un problema). Consiglierei di passare a LoginActionFactory, che puoi chiedere una nuova istanza di LoginActionogni volta che ne hai bisogno.

usa l'ambito della richiesta @Scope("request")per ottenere il bean per ogni richiesta o @Scope("session")per ottenere il bean per ogni "utente" della sessione

Un bean protoype iniettato all'interno di un bean singelton si comporterà come singelton fino a quando non viene chiamato esplicitamente la creazione di una nuova istanza tramite get bean.

context.getBean("Your Bean")

@Componente

@Scope (value = "prototipo")

public class TennisCoach implementa Coach {

// un po 'di codice

}

È possibile creare una classe statica all'interno del controller in questo modo:

    @Controller
    public class HomeController {
        @Autowired
        private LoginServiceConfiguration loginServiceConfiguration;

        @RequestMapping(value = "/view", method = RequestMethod.GET)
        public ModelAndView display(HttpServletRequest req) {
            ModelAndView mav = new ModelAndView("home");
            mav.addObject("loginAction", loginServiceConfiguration.loginAction());
            return mav;
        }


        @Configuration
        public static class LoginServiceConfiguration {

            @Bean(name = "loginActionBean")
            @Scope("prototype")
            public LoginAction loginAction() {
                return new LoginAction();
            }
        }
}

Per impostazione predefinita, i bean Spring sono singoli. Il problema sorge quando proviamo a cablare bean di diversi ambiti. Ad esempio, un bean prototipo in un singleton. Questo è noto come problema dell'iniezione di bean con ambito.

Un altro modo per risolvere il problema è l'iniezione di metodo con l' annotazione @Lookup .

Ecco un bell'articolo su questo problema relativo all'iniezione di bean prototipo in un'istanza singleton con più soluzioni.

https://www.baeldung.com/spring-inject-prototype-bean-into-singleton

Il controller ha bisogno anche del @Scope("prototype") definito

come questo:

@Controller
@Scope("prototype")
public class HomeController { 
 .....
 .....
 .....

}