Spring ApplicationContext - Perdita di risorse: il "contesto" non viene mai chiuso

In un'applicazione Spring MVC, inizializzo una variabile in una delle classi di servizio utilizzando il seguente approccio:

ApplicationContext context = 
         new ClassPathXmlApplicationContext("META-INF/userLibrary.xml");
service = context.getBean(UserLibrary.class);

UserLibrary è un'utilità di terze parti che sto utilizzando nella mia applicazione. Il codice precedente genera un avviso per la variabile "contesto". L'avviso è mostrato di seguito:

Resource leak: 'context' is never closed

Non capisco l'avvertimento. Poiché l'applicazione è un'applicazione Spring MVC, non posso chiudere / distruggere il contesto in quanto mi riferisco al servizio mentre l'applicazione è in esecuzione. Qual è esattamente l'avvertimento che sta cercando di dirmi?

Poiché il contesto dell'app è un ResourceLoader(cioè operazioni di I / O), consuma risorse che devono essere liberate a un certo punto. È anche un'estensione di AbstractApplicationContextcui implementa Closable. Pertanto, ha un close()metodo e può essere utilizzato in un'istruzione try-with-resources .

try (ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("META-INF/userLibrary.xml")) {
  service = context.getBean(UserLibrary.class);
}

Se hai effettivamente bisogno di creare questo contesto è una domanda diversa (ti sei collegato ad esso), non lo commenterò.

È vero che il contesto viene chiuso implicitamente quando l'applicazione viene arrestata, ma non è sufficiente. Eclipse ha ragione, è necessario adottare misure per chiuderlo manualmente per altri casi al fine di evitare perdite di classloader.

close()non è definito ApplicationContextnell'interfaccia.

L'unico modo per eliminare l'avviso in modo sicuro è il seguente

ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext(...);
try {
    [...]
} finally {
    ctx.close();
}

Oppure, in Java 7

try(ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext(...)) {
    [...]
}

La differenza fondamentale è che dal momento che istanziate il contesto in modo esplicito (cioè utilizzando new), conoscete la classe che state istanziando, quindi potete definire la vostra variabile di conseguenza.

Se non stavi istanziando l'AppContext (cioè usando quello fornito da Spring), non potresti chiuderlo.

Un semplice cast risolve il problema:

((ClassPathXmlApplicationContext) fac).close();

Poiché il contesto dell'applicazione ha un'istanza di ClassPathXmlApplicationContext e lo stesso ha un metodo close (). Vorrei semplicemente CAST l'oggetto appContext e invocare il metodo close () come di seguito.

ApplicationContext appContext = new ClassPathXmlApplicationContext("spring.xml");
//do some logic
((ClassPathXmlApplicationContext) appContext).close();

Questo risolverà l'avviso di perdita di risorse.

prova questo. è necessario applicare il cast per chiudere applicationcontext.

   ClassPathXmlApplicationContext ctx = null;
      try {
         ctx = new ClassPathXmlApplicationContext(...);
            [...]
             } finally {
              if (ctx != null)
                  ((AbstractApplicationContext) ctx).close();       
      }

Anche se ho ricevuto lo stesso identico avvertimento, tutto ciò che ho fatto è stato dichiarare ApplicationContextal di fuori della funzione principale come private statice ta-da, problema risolto.

public class MainApp {
    private static ApplicationContext context;

    public static void main(String[] args) {
        context = new ClassPathXmlApplicationContext("Beans.xml");

        HelloWorld objA = (HelloWorld) context.getBean("helloWorld");

        objA.setMessage("I'm object A");
        objA.getMessage();

        HelloWorld objB = (HelloWorld) context.getBean("helloWorld");
        objB.getMessage();
    }
}

La trasmissione è la risoluzione corretta per questo problema. Ho affrontato lo stesso problema utilizzando la riga sottostante. ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);

Per risolvere l'avviso basta abbassare l' ctxoggetto come sotto e poi chiuderlo. ((AnnotationConfigApplicationContext) ctx).close();

Downcast il contesto a ConfigurableApplicationContext.

((ConfigurableApplicationContext)context).close();

Object obj = context.getBean("bean");
if(bean instanceof Bean) {
    Bean bean = (Bean) obj;
}

Nel mio caso la perdita scompare

Questo ha funzionato meglio per me.

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;


public class Test {

     private static ApplicationContext con;

     public static void main(String[] args) {

         con = new ClassPathXmlApplicationContext("config.xml");

         Employee ob = (Employee) con.getBean("obj");
         System.out.println("Emp Id " + ob.getEmpno());
         System.out.println("Emp name " + ob.getEmpname());
    }
}

Se stai usando ClassPathXmlApplicationContext , puoi usare

((ClassPathXmlApplicationContext) context).close();

per chiudere il problema della perdita di risorse.

Se stai usando AbstractApplicationContext, puoi eseguire il cast con il metodo close.

((AbstractApplicationContext) context).close();

Dipende dal tipo di contesto utilizzato nell'applicazione.

import org.springframework.context.ConfigurableApplicationContext;

((ConfigurableApplicationContext)ctx).close();

Rendete il contesto una variabile statica, il che significa che il contesto è disponibile per tutti i metodi statici nella classe e non è più limitato all'ambito del metodo principale. Quindi lo strumento non può più presumere che debba essere chiuso alla fine del metodo, quindi non emette più l'avviso.

public class MainApp {
    private static ApplicationContext context;
    public static void main(String[] args) {
          context = 
                 new ClassPathXmlApplicationContext("Beans.xml");

          HelloWorld obj = (HelloWorld) context.getBean("helloWorld");

          obj.getMessage();

       }
}

Sì, l'interfaccia ApplicationContextnon ha un close()metodo, quindi mi piace usare la classe AbstractApplicationContextper usare quel closemetodo in modo esplicito e anche qui puoi usare la tua classe di configurazione dell'applicazione Spring usando l'annotazione invece del XMLtipo.

AbstractApplicationContext context = new AnnotationConfigApplicationContext(SpringAppConfig.class);
Foo foo = context.getBean(Foo.class);

//do some work with foo

context.close();

il tuo Resource leak: 'context' is never closedavvertimento ora è sparito.

ha una soluzione semplice: basta inserire il core jar nelle librerie, fornito a questo link [scarica i file jar core per la primavera] [1] [1]: https://static.javatpoint.com/src/sp/spcorejars. cerniera lampo

Il metodo close è stato aggiunto all'interfaccia ConfigurableApplicationContext, quindi il meglio che puoi fare per accedervi è:

ConfigurableApplicationContext context = new ClassPathXmlApplicationContext(
                "/app-context.xml");

// Use the context...

context.close();