Cum funcționează contextul în Java?

În Java, nu există un concept centralizat de "context" în același sens ca în cadrul framework-urilor web sau sistemelor de operare. Cu toate acestea, în funcție de domeniul specific al dezvoltării Java, termenul "context" poate face referire la următoarele:

• Contextul de execuție (Execution Context): Starea programului într-un anumit moment. Include valorile variabilelor, punctul curent de execuție (instrucțiunea), stiva de apeluri a metodelor. La executarea unei metode, se creează un nou context de execuție (cadru de stivă) pentru acea metodă.

• Contextul de clasă (Class Context): Se referă la membrii statici ai clasei. Variabilele și metodele statice există independent de instanțele clasei și sunt accesibile prin numele clasei.

  class MyClass {
      static int staticVariable = 10; // Variabilă statică
      
      static void staticMethod() { // Metodă statică
          // Acces la staticVariable
      }
  }
  
  // Acces la membrii statici prin numele clasei
  int value = MyClass.staticVariable;
  MyClass.staticMethod();
  

• Contextul instanței (Instance Context): Se referă la membrii non-staționali ai obiectului. Variabilele și metodele instanței sunt accesibile doar printr-o anumită instanță a clasei.

  class MyClass {
      int instanceVariable = 5; // Variabilă de instanță
      
      void instanceMethod() { // Metodă de instanță
          // Acces la instanceVariable
      }
  }
  
  MyClass obj = new MyClass(); // Crearea unei instanțe
  int value = obj.instanceVariable; // Acces prin instanță
  obj.instanceMethod();
  

• Contextul de thread (Thread Context): Starea firului de execuție. Fiecare fir are propriul său stivă de apeluri și set de variabile locale. Firele se execută independent și pot avea acces la date comune, dar acest lucru necesită sincronizare pentru a evita problemele de concurență.

• Contextul Spring (Spring Context): În cadrul framework-ului Spring, "contextul aplicației" (ApplicationContext) este elementul central. Gestionează ciclul de viață al bean-urilor (obiecte create și gestionate de Spring), realizează injecția de dependențe, procesează configurația și oferă acces la resurse. Contextul Spring encapsulează configurația aplicației.

  // Exemplu de utilizare a ApplicationContext în Spring
  ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
  MyService myService = context.getBean(MyService.class);
  myService.doSomething();
  

• Contextul servlet (Servlet Context): În Java EE/Jakarta EE, ServletContext oferă informații despre aplicația web în care rulează servletul. Permite schimbul de date între servlete, accesul la resursele aplicației web și gestionarea configurației acesteia.

  // Exemplu de obținere a ServletContext în cadrul unui servlet
  public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
      ServletContext context = getServletContext();
      String appName = context.getServletContextName();
      // ... utilizarea contextului ...
  }
  

• Contextul JNDI (JNDI Context): Java Naming and Directory Interface (JNDI) utilizează un context pentru căutarea și accesul la resurse (cum ar fi sursele de date, cozi de mesaje, EJB). Contextul inițial (InitialContext) este punctul de intrare pentru căutarea în arborele de obiecte numite.

  // Exemplu de căutare a unei resurse prin InitialContext
  try {
      InitialContext ctx = new InitialContext();
      DataSource ds = (DataSource) ctx.lookup("jdbc/MyDataSource");
      // ... utilizarea DataSource
  } catch (NamingException e) {
      e.printStackTrace();
  }
  

Prin urmare, "context" în Java este un concept mai general, care poate însemna starea, mediul sau mediul în care rulează un anumit cod sau funcționează un component. Semnificația sa specifică depinde de subsistem sau framework-ul în care este utilizat.