Dynamiczna Java

1. Refleksja

1.1. Dynamiczne ładowanie klas

• getSuperClass() - zwracającą obiekt klasy Class oznaczający klasę bazową danej klasy,
• getInterfaces() - zawracającą tablicę obiektów, zawierającą interfejsy danej klasy,
• newInstance() - tworzącą nowy obiekt danej klasy.

package dynload;
import javax.swing.*;

class Main extends JFrame {

  static void exit(String s) {
    System.out.println(s);
    System.exit(1);
  }


  Main(String actionClassName) {
    Class actionClass = null;
    Action act = null;
    try {
      actionClass =  Class.forName(actionClassName);
      act = (Action) actionClass.newInstance();
    } catch (Exception exc) {
        exit("Obiekt klasy akcji nie może być utworzony");
    }

    JButton b = new JButton();
    b.setAction(act);
    add(b);
    setDefaultCloseOperation(DISPOSE_ON_CLOSE);
    pack();
    setLocationRelativeTo(null);
    setVisible(true);  }
  
  public static void main(String args[]) {
    final String in = JOptionPane.showInputDialog("Podaj nazwę klasy:");
    if (in != null) {
      SwingUtilities.invokeLater(new Runnable() {
        public void run() {
          new Main(in);
        }
      });  
     
    }
  }

}

package dynload;
import javax.swing.*;
import java.awt.event.*;

public class DialogAction extends AbstractAction {

  final static String ACTION_NAME = "Show msg";

   public DialogAction() {
     super(ACTION_NAME);
   }

   public void actionPerformed(ActionEvent e) {
     JOptionPane.showMessageDialog(null, ACTION_NAME);
   }

}

package dynload;
import javax.swing.*;
import java.awt.event.*;

public class PrintAction extends AbstractAction {

  final static String ACTION_NAME = "Print";

   public PrintAction() {
     super(ACTION_NAME);
   }

   public void actionPerformed(ActionEvent e) {
     System.out.println("Wykonan akcja: " + ACTION_NAME);
   }

}

1.2. Mechanizm refleksji

• stwierdzenie jakie i z jakimi argumentami metody występują w danej klasie (np. podawanej dynamicznie w trakcie wykonania programu)
• dynamiczne wywoływanie metod (specyfikowanych w trakcie wykonania programu) na rzecz jakiego obiektu (też dynamicznie ustalanego),
• dynamiczne uzyskiwanie i modyfikacje wartości pól obiektu.

• metody bez "Declared" zwracają składowe tylko publiczne, ale jednocześnie również dziedziczone,
• metody z "Declared" zwracają wszystkie składowe (również prywatne i zabezpieczone), ale bez dziedziczonych

1.3  Przykłady wykorzystania refleksji

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.border.*;
import java.lang.reflect.*;

public class Ramki extends JFrame {

   // Pola klasy określają różne rodzaje ramek
   private Border
     // empty = BorderFactory.createEmptyBorder(),
     blackLine = BorderFactory.createLineBorder(Color.black),
     blueLine3 = BorderFactory.createLineBorder(Color.blue, 3),
     // titled1 = BorderFactory.createTitledBorder("Tytuł"),
     titled2 = new TitledBorder(blueLine3,"Tytuł",
                   TitledBorder.CENTER, TitledBorder.CENTER,
                   new Font("Dialog", Font.BOLD | Font.ITALIC, 16),
                   Color.blue),
     etched = BorderFactory.createEtchedBorder(),
     etchedC = BorderFactory.createEtchedBorder(Color.red, Color.yellow),
     // raisedBevel = BorderFactory.createRaisedBevelBorder(),
     // loweredBevel = BorderFactory.createLoweredBevelBorder(),
     matteColor = BorderFactory.createMatteBorder(5, 10, 5, 15, Color.red),
     matteIcon = new MatteBorder(new ImageIcon("FastForward24.gif")),
     softBevR = new SoftBevelBorder(SoftBevelBorder.RAISED),
     softBevL = new SoftBevelBorder(SoftBevelBorder.LOWERED),
     compound1 = BorderFactory.createCompoundBorder(softBevR, softBevL),
     compound2 = BorderFactory.createCompoundBorder(blueLine3, compound1),
     compound3 = BorderFactory.createCompoundBorder(compound1, matteIcon);


  Ramki() {
    super("Prezentacja ramek");
    getContentPane().setLayout (new GridLayout(0,4,5,5));

    // Klasa tego obiektu
    Class c = getClass();

    // Uzyskanie tablicy wszystkich zadeklarowanych pól tej klasy
    Field[] field = c.getDeclaredFields();

    // Przebiegamy po polach-ramkach
    for (int i=0; i< field.length; i++) {

      // Nazwa pola (zmiennej) - opisującego kolejną ramkę
      String fldName = field[i].getName();

      // Tę nazwę wypiszemy na etykiecie
      JLabel l = new JLabel(fldName, JLabel.CENTER);

      // Uzyskanie referencji do obiektu, reprezentowanego przez
      // pole field[i] tego (this) obiektu. Czyli - do kolejnej ramki

      Object ramka = null;
      try {
        ramka = field[i].get(this);
      } catch (IllegalAccessException exc) { // Ten wyjatek może wystąpić
          exc.printStackTrace();             // gdy dostęp do pola jest zabroniony
      }                                      // np. z innej klasy do prywatnego pola

      // Dostaliśmy oczywiście ramkę, ale jako Object
      // - konieczna konwersja do Border

      l.setBorder((Border) ramka);

      getContentPane().add(l);
    }

    setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    pack();
    show();
  }

  public static void main(String[] args) {
    new Ramki();
  }
}

public class ActionSet {

 public void dodaj() { show("Dodaj"); }
 public void usuń() { show("Usuń"); }
 public void zastąp() { show("Zastąp"); }
 public void szukaj() { show("Szukaj"); }
 public void otwórz() { show("Otwórz"); }

 private void show(String string) {
   JOptionPane.showMessageDialog(null, string);
 }

}

import java.lang.reflect.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class ReflectionTest extends JFrame implements ActionListener {

  Method currAction = null; // bieżąca metoda obsługi
  Class actionClass = null; // klasa obsługi
  Object actionObject = null; // obiekt obsługi
  JPopupMenu popUp = null; // menu kontekstowe z wyborem obsługi
  JButton b;

  public ReflectionTest() {
    super("Test refleksji");
    try {
      actionClass = Class.forName("ActionSet");
      actionObject = actionClass.newInstance();
    } catch (Exception exc) {
      throw new RuntimeException("Wadliwa klasa obsługi");
    }

    popUp = new JPopupMenu();
    createMenuItems();

    b = new JButton("Użyj prawego klawisza myszki, by ustalić akcję");
    b.setFont(new Font("Dialog", Font.BOLD, 24));
    b.addActionListener(this);
    b.setComponentPopupMenu(popUp); 

    setLayout(new FlowLayout());
    add(b);
    setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
    pack();
    setLocationRelativeTo(null);
    setVisible(true);
  }

  void createMenuItems() {
    Method mets[] = null;
    try {
      mets = actionClass.getMethods();
    } catch (Exception exc) {
      throw new RuntimeException("Niedostępna info o metodach klasy obsługi");
    }

    for (Method m : mets) {
      if (m.getDeclaringClass() == actionClass) {
        String name = m.getName();
        JMenuItem mi = new JMenuItem(name);
        mi.addActionListener(this);
        popUp.add(mi);
      }
    }
  }

  void setCurrentAction(String action) {
    try {
      currAction = actionClass.getMethod(action); // zm. liczba arg.!!!
      b.setText("Teraz akcją jest: " + currAction.getName() + " - kliknij!");
    } catch (Exception exc) {
      throw new RuntimeException("Nieznana metoda obsługi");
    }
  }

  public void actionPerformed(ActionEvent e) {
    Object src = e.getSource();
    if (src instanceof JMenuItem)
      setCurrentAction(((JMenuItem) src).getText());
    else {
      try {
        currAction.invoke(actionObject); // zmienna liczba arg. !!!
      } catch (Exception exc) {
        JOptionPane.showMessageDialog(null, "Akcja na przycisku nieustalona!");
      }
    }
  }

  public static void main(String args[]) {
    new ReflectionTest();
  }

}

• uzyskanie metody o nazwie name zadeklarowanej w klasie c i mającej określone przez t1, t2, ... typy argumentów:

• wywolanie metody m na rzecz obiektu trg z argumentami x, y, z:

2. JavaBeans

2.1. Pojęcie JavaBean

• jakie ma właściwości? jakie metody służą do ich pobierania i ustalania?
• jakie obsługuje zdarzenia? jakie zdarzenia mogą się mu przytrafiać?
• jakie metody udostępnia otoczeniu (eksportuje)?

• uzgodnionym protokole. dotyczącym informacji o ziarnie (standardowe wzorce deklaracji metod i/lub klasy informacyjne)
• standardowych środkach pobierania informacji (introspekcja - realizowana przez klasę Introspector z pakietu java.beans)
• standardowych środkach dostosowania obiektu

2.2.  Właściwości i akcesory

• stosuje ogólnie przyjęte wzorce sygnatur metod  i/lub uzupełniona jest przez dodatkową specjalną klasę opisującą "niestandardowe" informacje o ziarnie (implementacja interfejsu BeanInfo)
• zapewnia serializację obiektów
• zawiera konstruktor bezparametrowy
• uzwględnia działania w środowisku wielowątkowym (do obiektu klasy może równocześnie odwoływać się kilka wątków)

2.3.  Nasłuch i wetowanie zmian właściwosci

• nazwę właściwości -  String getPropertyName()
• starą wartość własciwości  (przed zmianą) – Object getOldValue()
• nową wartość własciwości – Object getNewValue()

• właściwości związanych -  firePropertyChange
• właściwości ograniczanych -  fireVetoableChange słuchaczy.
• a także metod przyłączanai i odłączania słuchaczy tych zmian (addNNNListener, removeNNListener).

class Ziarno .... {

  //wsparcie
  private PropertyChangeSupport chg = new PropertyChangeSupport(this);

  String text;    // to będzie właściwośc związana o nazwie "text"
  ...
// setter
synchronized void setText(String newTxt) { // pamiętamy o wielowątkowości!

    String oldTxt =  text;   // stara wartość
    text = newTxt;           // ustalenie nowej wartości
     // powiadomienie
    chg.firePropertyChange("text", oldTxt, newTxt);
}
....

// metody dodawania i usuwania słuchaczy
public synchronized void addPropertyChangeListener(PropertyChangeListener l) {
 chg.addPropertyChangeListener(l);
 }

public synchronized void removePropertyChangeListener(PropertyChangeListener l) {
 chg.removePropertyChangeListener(l);
 }
...
}

class Ziarno .... {

  //wsparcie
  private VetoableChangeSupport veto = new VetoableChangeSupport(this);

  String text;    // to będzie właściwośc ograniczana o nazwie "tekst"
  ...
// setter

synchronized void setText(String newTxt)  throws PropertyVetoException
 {
    String oldTxt =  text;  // stara wartość

     // wywołujemy metodę fireVotoableChange, która z kolei
     // wywołuje metody vetoableChange zarejestrowanych słuchaczy
     // jeśli któraś z nich zgłasza veto, setter kończy działanie
     // a wyjątek PropertyVetoException jest przekazywany do obsługi
     //  przez metodę wywołującą setText

     veto.fireVetoableChange("tekst", oldTxt, newTxt);

     // Tylko jeśli nikt nie zawetował zmiany:

     text = newTxt;   // ustalenie nowej wartości
}
....
// metody dodawania i usuwania słuchaczy

public synchronized void addVetoableChangeListener(PropertyChangeListener l) {
 veto.addVetoableChangeListener(l);
 }

public synchronized void removeVetoableChangeListener(PropertyChangeListener l) {
 veto.removeVetoableChangeListener(l);
 }
...
}

// Uwaga: wsystkie klasy  zdarzeniowe i interfejsy nasłuchu
// dla właściwości znajdują się w pakiecie java.beans.

2.4.  JavaBean - przykład praktyczny

// Klasa Counter

import java.awt.event.*;
import java.beans.*;
import java.io.*;

public class Counter implements Serializable {

  private int count = 0;    // właściwość count

  // Pomocniczy obiekt do prowadzenia listy słuchaczy zmian właściwości oraz
  // propagowania zmian  wśród zarejestrowanych złuchaczy
   private PropertyChangeSupport propertyChange = new PropertyChangeSupport(this);


  // Konstruktory

  public Counter() {
    this(0);
  }

  public Counter(int aCount) {
    setCount( aCount );
  }


  // Metody przyłączania i odłączania słuchaczy zmian właściwości

  public synchronized void addPropertyChangeListener(PropertyChangeListener listener) {
    propertyChange.addPropertyChangeListener(listener);
  }

  public synchronized void removePropertyChangeListener(PropertyChangeListener l) {
    propertyChange.removePropertyChangeListener(l);
  }

  // Proste metody zwiększania i zmniejszania licznika

  public void increment() {
    setCount(getCount()+1);
  }

  public void decrement() {
    setCount(getCount()-1);
  }


  // Getter właściwości "count"
  public int getCount() {
    return count;
  }

  // Setter właściowści "count"
  public synchronized void setCount(int aCount) {
    int oldValue = count;
    count = aCount;

    // wywołanie metody firePropertChange z klasy PropertyChangeSupport
    // powoduje wygenerowanie zdarzenia PropertyChangeEvent i rozpropagowanie
    // go wśród wszystkich przyłączonych słuchaczy, ale tylko wtedy, gdy nowa
    // wartość właściwości różni się od starej wartości

    propertyChange.firePropertyChange("count", new Integer(oldValue),
                                            new Integer(aCount));
  }

}

//Klasa CounterView
//Widok licznika przedstawiamy w postaci etykiety

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.beans.*;


public class CounterView extends JLabel implements PropertyChangeListener {


  // Konstruktor domyślny: inicjalizuje etykietę tekstem "0"
  CounterView()  {
     this("0");
  }

  // Konstruktor inicjalizujący etykietę podanym tekstem
  CounterView(String lab) {
     super(lab);
     setOpaque(true);   // etykieta nie przezroczysta
       // ramka
     setBorder(BorderFactory.createLineBorder(Color.black));
       // rozmiary i wyrównanie tekstu
     setPreferredSize(new Dimension(75, 40));
     setHorizontalAlignment(CENTER);
  }

  // obługa zdarzenia PropertyChange
  public void propertyChange(PropertyChangeEvent e)  {
    Integer oldVal = (Integer) e.getOldValue(),
           newVal = (Integer) e.getNewValue();
    System.out.println("Value changed from " + oldVal + " to " + newVal);
    setText("" + newVal + "");  // pokazanie na etykiecie nowego stanu licznika
   }


}

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.beans.*;
import java.io.*;

public class CounterControlGui extends JFrame implements ActionListener {

  Counter counter;
  JButton binc = new JButton("Increment");
  JButton bdec = new JButton("Decrement");
  JTextField txt = new JTextField(10);

  // Konstruktor otrzymuje jako argumenty obiekty typu Counter i CounterView
  // Pierwszy jest nam potrzebny do komunikacji z licznikiem, drugi - widok
  // wbudujemy w to GUI.

  CounterControlGui(Counter c, CounterView clab)  {
    counter = c;
    Container cp = getContentPane();
    cp.setLayout(new FlowLayout());
    binc.addActionListener(this);
    cp.add(binc);
    cp.add(clab);
    bdec.addActionListener(this);
    cp.add(bdec);
    txt.addActionListener(this);
    cp.add(txt);
    setDefaultCloseOperation(3);
    pack();
    show();
  }


  // Obsługa akcji
  public void actionPerformed(ActionEvent e)  {
      if (e.getSource() == txt)  {
         int n = 0;
         try  {
            n = Integer.parseInt(txt.getText());
         } catch (NumberFormatException exc)  { return; }
         counter.setCount(n);
         return;
      }
      String cmd = e.getActionCommand();
      if (cmd.equals("Increment")) counter.increment();
      else if (cmd.equals("Decrement")) counter.decrement();
      else System.out.println("Unrecognized command");
  }

}

public class Main {

 public static void main(String[] args)  {

   // Tworzymy obiekty: licznik i jego widok
   Counter counter = new Counter();
   CounterView counterView = new CounterView(""+counter.getCount());

   // Rejestrujemy widok jako słuchacza zmian licznika
   counter.addPropertyChangeListener(counterView);

   // Tworzymu GUI kontrolera i pokazujemy go
   CounterControlGui gui = new CounterControlGui(counter, counterView);
   gui.pack();
   gui.show();
  }

}

import java.beans.*;

public class CounterLimitator implements VetoableChangeListener {

// minimalne i makszymalne dopuszczalne wartości licznika
private int min, max;

CounterLimitator(int minLim, int maxLim)  {
  min = minLim;
  max = maxLim;
}

// Obsługa zdarzenia vetoableChange
// metoda może sygnalizować PropertyVetoException
public void vetoableChange(PropertyChangeEvent e)
            throws PropertyVetoException {
   Integer newVal = (Integer) e.getNewValue();
   int val = newVal.intValue();
   // Sprawdzamy, czy zmiana  licznika jest dopuszczalna,
   // jeśli nie – sygnalizujemy wyjatek  PropertyVetoException
   if (val < min || val > max)
      throw new PropertyVetoException("Niedopuszczalna zmiana wartości", e);
   }

}

public class Counter {

//...

private VetoableChangeSupport vetos = new VetoableChangeSupport(this);

public synchronized void addVetoableChangeListener(VetoableChangeListener l) {
	vetos.addVetoableChangeListener(l);
}

public synchronized void removeVetoableChangeListener(VetoableChangeListener l) {
	vetos.removeVetoableChangeListener(l);
}

// ...
}

public class Counter {

//...
public synchronized void setCount(int aCount)
                         throws PropertyVetoException {

     int oldValue = count;

     // wywołujemy metodę fireVotoableChange, która z kolei
     // wywołuje metody vetoableChange zarejestrowanych słuchaczy
     // jeśli któraś z nich zgłasza veto, setter kończy działanie
     // a wyjątek PropertyVetoException jest przekazywany do obsługi
     // przez metodę wywołującą setCount
     // (co zaznaczyliśmy w nagłówku metody przez
     // throws PropertyVetoException)

    vetos.fireVetoableChange("count", new Integer(oldValue), new Integer(aCount));

    // tylko jeśli nikt nie zawetował

    count = aCount;  // ustalamy nową wartość licznika

    // ... powiadamiamy nasłuchujących zmiany właściwości count

    propertyChange.firePropertyChange("count", new Integer(oldValue),
                                       new Integer(aCount));
}

//...
}

public class CounterControlGui .... {

....
public void actionPerformed(ActionEvent e)  {
  try  {
    if (e.getSource() == txt)  {
       int n = 0;
       try  {
          n = Integer.parseInt(txt.getText());
       } catch (NumberFormatException exc)  { return; }
       counter.setCount(n);
       return;
    }
    String cmd = e.getActionCommand();
    if (cmd.equals("Increment")) counter.increment();
    else if (cmd.equals("Decrement")) counter.decrement();
    else System.out.println("Unrecognized command");
  } catch (PropertyVetoException exc)  { // obługa wyjatku:
      System.out.println(""+ exc);       // podanie informacji
                                         //o niedopuszczalnej zmianie wartości
  }
}

//...
}

import java.beans.*;
public class Main {

 public static void main(String[] args) throws PropertyVetoException {
   Counter counter = new Counter();
   CounterView counterView = new CounterView(""+counter.getCount());
   counter.addPropertyChangeListener(counterView);

   // licznik może się zmieniać od –5 do 10
   // bo Limitator zawetuje każdą inną zmianę
   CounterLimitator clim = new CounterLimitator(-5, 10);
   counter.addVetoableChangeListener(clim);

   CounterControlGui gui = new CounterControlGui(counter, counterView);
   gui.pack();
   gui.show();
  }

}

2.5. Introspekcja

• analizę komponentów za pomocą metod refleksji przy założeniu, że stosowane są pewne standardowe wzorce nazewnictwa, umożliwiające określenie  własnściwości i ich typu, metod pobierania i ustalania tych właściwości,  rodzajóa zdarzeń,  metod rejestracji słuchaczy i nnych metod udostępnianych przez dane ziarno "na zewnątrz"
• określanie uzewnętrznianych właściwości i funkcjonalności ziarna na podstawie dowolnie specyfikowanych przez twórcę ziarna elementów, zapisywanych w odpowiedniej dla danego ziarna klasie BeanInfo.

• EventSetDescriptor[]  getEventSetDescriptors()  - zwraca tablicę deskryptorów zdarzeń
• PropertyDescriptor[]  getPropertyDescriptors()  - zwraca tablicę deskryptorów własności
• MethodDescriptor[]   getMethodDescriptors()     - zwraca tablicę deskryptorów metod
• dla każdgo deskryptora metody ParameterDescriptor[] getParameterDexriptors() - zwraca tablicę deskryptorów parametrów tej metody
  

import java.lang.reflect.*;
import java.beans.*;

public class BeanAnalyze {

  static void say(String s) { System.out.println(s); }

  public static void main(String[] arg) throws Exception {

    BeanInfo beanInfo = Introspector.getBeanInfo(Class.forName(arg[0]));

    PropertyDescriptor[] pd = beanInfo.getPropertyDescriptors();
    MethodDescriptor[] md = beanInfo.getMethodDescriptors();
    EventSetDescriptor[] evd = beanInfo.getEventSetDescriptors();

    say("Właściwości:");
    for (int i = 0; i < pd.length; i++) {
      say(pd[i].getShortDescription());
      // getReadMethod i getWriteMethod zwracają obiekty typu Method
      say(" getter: "+ pd[i].getReadMethod());
      say(" setter: "+ pd[i].getWriteMethod());
    }

    say("\nMetody:");
    for (int i=0; i<md.length; i++) {
      say(" " + md[i].getMethod());
    }

    say("\nZdarzenia:");
    for (int i = 0; i < evd.length; i++) {
      say("Zdarzenie : " + evd[i].getShortDescription());
      Method[] met = evd[i].getListenerMethods();
      say("Metody obsługi:");
      for (int j=0; j < met.length; j++)  say(" " + met[j]);
    }
  }

}

2.6. Dynamiczne pobieranie i ustalanie właściwości

public class TestBean {

  private String[] headers;
  private int count;


  public TestBean() {
  }

  public TestBean(int n) {
    count = n;
  }

  public String[] getHeaders() {
    return headers;
  }

  public void setHeaders(String[] value) {
    headers = value;
  }

  public int getCount() {
    return count;
  }

  public void setCount(int value) {
    count = value;
  }

}

import java.beans.*;
import java.awt.*;
import javax.swing.*;

public class DynamicExec {

  public static void main(String[] args) throws Exception {

    Statement stmt;
    Expression expr;

    JButton b = new JButton();

    // Na rzecz przycisku wołamy dynamicznie metodę setText
    // z argumentem "Przycisk"
    stmt = new Statement(b, "setText", new Object[] { "Przycisk" });
    stmt.execute();

    // Jaki wynik? Najpierw statyczne odwołanie
    System.out.println("Tekst na przycisku 1: " + b.getText());

    // Teraz dynamicznie: stwórzmy wyrażenie, którego wynikiem
    // jest wynik podanej metody z podanymi argumentami wywolanej
    // na rzecz b
    // Uwaga: brak argumentów - czyli tablica Object o rozmiarze 0
    expr = new Expression(b, "getText", new Object[0]);

    // Jeżeli wyrażenie expr nie ma jeszcze wyniku
    // metoda getValue() wywołuje podaną w wyrażeniu metodę
    // i zwraca jej wynik; w przeciwnym razie zwraca
    // ustalony wczesniej wynik

    String txt = (String) expr.getValue();
    System.out.println("Tekst na przycisku 2: " + txt);

    // Możemy też stosować klasy Statement i Expression
    // wobec naszych własnych klas JavaBeans

    TestBean tbean = new TestBean();

    // Uwaga: przy przekazywaniu argumentów i zwrocie wynikow
    // następują automatyczne przeksztalcenia pomiedzy
    // typami prostymi i odpowiadającymi im klasami opakowującymi
    // np. int - Integer  - setCount wymaga argumentu int,
    // my podajemy Integer

    stmt = new Statement(tbean, "setCount",
                               new Object[] { new Integer(22) });
    stmt.execute();

    // Jaka jest teraz wartość właściwości count
    // I znowu: getCount() zwraca int, my odbieramy Integer

    expr = new Expression( tbean, "getCount", new Object[0] );
    Integer val = (Integer) expr.getValue();

    System.out.println("Wartość count: " + val);

    // Czy możemy działać na tabliach? Ależ tak!

    stmt = new Statement(tbean, "setHeaders",
                         new Object[] { new String[] { "a", "b" } }
                        );
    stmt.execute();

    expr = new Expression(tbean, "getHeaders", new Object[0]);
    String[] hdr = (String[]) expr.getValue();

    System.out.println("Ustalone nagłówki");
    for (int i=0; i<hdr.length; i++)
       System.out.println(hdr[i]);

    // Możemy nawet stworzyć nowy obiekt
    // używając specjalnej nazwy metody - new  (oczywiście)

    expr = new Expression(TestBean.class, "new",
                          new Object[] { new Integer(111) }
                         );
    TestBean tb2 = (TestBean) expr.getValue();

    expr = new Expression (tb2, "getCount", new Object[0]);
    val = (Integer) expr.getValue();

    System.out.println("W nowym obiecie count = " + val);

  }
}

2.7. Serializacja JavaBeans

import java.beans.*;
import java.awt.*;
import javax.swing.*;
import java.io.*;

public class SerialBean {

  String fname = "test.xml";

  public SerialBean() {
    JButton b = new JButton("Kąśliwie wróbel ćwierkał");
    b.setBackground(Color.red);
    b.setForeground(Color.yellow);

    try {
      XMLEncoder enc = new XMLEncoder(
                         new BufferedOutputStream(
                            new FileOutputStream(fname)
                            )
                      );
      enc.writeObject(b);
      enc.close();
    } catch (FileNotFoundException exc) {
        exc.printStackTrace();
        System.exit(1);
    }
    nowReadAndReport();
  }

  private void nowReadAndReport() {
    try {
      XMLDecoder dec = new XMLDecoder(
                          new BufferedInputStream(
                              new FileInputStream(fname)));
      Object obj = dec.readObject();
      JButton b = (JButton) obj;
      dec.close();
      System.out.println("Napis na przycisku: " + b.getText());
      System.out.println("Kolor tła: " + b.getBackground());
      System.out.println("Kolor tekstu : " + b.getForeground());

    } catch (FileNotFoundException exc) {
        exc.printStackTrace();
        System.exit(1);
    }
  }



  public static void main(String[] args) {
    SerialBean serialbean = new SerialBean();
  }


}

<?xml version="1.0" encoding="UTF-8"?>
<java version="1.4.1-rc" class="java.beans.XMLDecoder">
 <object class="javax.swing.JButton">
  <string>KÄĹ>liwie wrĂłbel Ä+wierkaĹ'</string>
  <void property="background">
   <object class="java.awt.Color">
    <int>255</int>
    <int>0</int>
    <int>0</int>
    <int>255</int>
   </object>
  </void>
  <void property="foreground">
   <object class="java.awt.Color">
    <int>255</int>
    <int>255</int>
    <int>0</int>
    <int>255</int>
   </object>
  </void>
 </object>
</java>

2.8. Inne zagadnienia związane z JavaBeans

• przystosowanie ziaren: klasy-edytory właściwości używane m.in. w środowiskach wizualnych
• tworzenie klas BeanInfo, opisujących informacje niedostępną metodami refleksji,
• koteksty (BeanContext) - swoiste kontenery, dostarczające generalnych mechanizmów i serwisów dla JavaBeans.

3. Metadane i adnotacje

3.1. Wprowadzenie

• do celów poprawy niezawodności programowania (np. @override),
• do generacji dodatkowych kodów programu (uzupełniających klas),
• do określania sposobu funkcjonowaniu programu w fazie wykonania (można krótko zapisać różne rzeczy).
• do celów konfiguracyjnych,
• do generowania pomocniczych plików (np. różnych deskryptorów itp.)

• zastosowanie adnotacji może znacznie ułatwić pisanie i wdrażanie aplikacji, szczególnie dużych; kody mogą być wielokrotnie mniejsze, pracochłonność znacząco ograniczona itp.

• pojawiają się jakby nowe elementy składniowo-semantyczne; ponieważ każdy może definiować własne adnotacje, to istnieje niebezpieczeństwo, że pojawi się mnóstwo "dialektów" Javy - czyli standard Javy + wymyślne, niestandardowe adnotacje,
• adnotacje pozwalają upraszczać wiele rzeczy, zapisywać niejako symbolicznie jednym słowem, to co bez nich wymagało być może dziesiątek linii kodu; ale tych zapisów (notacji i ich znaczeń) trzeba się też uczyć (dla różnych środowisk za każdym razem od nowa) i mieć świadomość, do czego tego tak naprawdę te skróty prowadzą (co robią),
• na razie nie ma dobrej koncepcji sprawdzania błędowi na poziomie metadanych.

3.2 Rodzaje adnotacji

• adnotacje wbudowane w Javę
• regularne
• metaadnotacje

• adnotacje użytkownika (tworzone przez użytkownika)
• stosowane na etapie kompilacji (przetwarzane przez narzędzia)
• stosowane w fazie wykonania (za pomocą mechanizmów refleksji)

• pakietów
• klas
• interfejsów
• pól
• konstruktorowi
• metod
• zmiennych lokalnych
• innych adnotacji

1. adnotacja nie oznaczona znacznikiem @Target ma zastosowanie wszędzie.
2. aby określić kilka możliwych zastosowań piszemy @Target({ a, b, c } ), gdzie a, b, c to elementy w postaci ElementType.rodzaj, a rodzaj to jeden z PACKAGE, METHOD, FIELD itp.

• przez narzędzia do generacji (i ew. równoczesnej kompilacji) kodu (wtedy potrzebne są tylko w fazie kompilacji),
• albo przez mechanizmy refleksji  - wtedy powinny być zapisane w klasie wykonywalnej i dostępne dla tych mechanizmów w fazie wykonania programu,
• albo przez narzędzia przetwarzania "binarnej" postaci klas (umożliwiające m.in. różne iniekcje, zmiany, usuwanie kodu binarnego) - wtedy powinny być zapisane w klasie, ale nie muszą być dostępne dla mechanizmów refleksji.

3.3. Definiowanie adnotacji

• typy proste (int, short, long, byte, char, double, float, boolean),
• String,
• typ referencyjny, reprezentowany przez Class, w tym także w wersji sparametryzowanej,
• enum.
• adnotacja,
• tablica (w/w elementów).

public @interface Opis {
    String text() default "Brak opisu";
    int version() default 1;
}


// i zastosowanie np. do opisu klasy:

@Opis(text="Klasa warzyw", version=2)
public class Warzywa { ... }

3.4. Przetwarzanie adnotacji w fazie wykonania

• ustalić rodzaj adnotacji przez @Retention(RetentionPolicy.RUNTIME),
• użyć metod refleksji do uzyskania informacji które elementy i za pomocą jakich adnotacji są zaznaczane,
• od uzyskanych adnotacji dowiedzieć się ew. dodatkowych informacji, zapisanych w nich jako dane; po czym na podstawie adnotacji i tych danych dynamicznie wytworzyć i wykonać odpowiedni kod.

• przy zastosowaniu nazwanych pakietów nazwy interfejsów adnotacji muszą być kwalifikowane nazwą pakietu,
• wszystkie adnotacje (jako interfejsy) rozszerzają interfejs Annotation, wobec czego mogą być traktowane jako Annotation i dlatego takie są wyniki w/w metod; zwróćmy uwagę, że dzięki parametryzacji nie musimy stosować konwersji zawężających.

import java.lang.annotation.*;
import java.awt.*;

@Target(ElementType.FIELD)             // do oznaczania pól
@Retention(RetentionPolicy.RUNTIME)    // faza wykonania

public @interface Loc {
   String to();
}

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.lang.reflect.*;

public class Annot0 extends JFrame {

  JComponent cp = (JComponent) getContentPane();

  @Loc(to="cp") JPanel p1 = new JPanel();
  @Loc(to="cp") JPanel p2 = new JPanel();

  @Loc(to="p1") JButton b1 = new JButton("Przycisk 1");
  @Loc(to="p1") JButton b2 = new JButton("Przycisk 2");
  @Loc(to="p2") JButton b3 = new JButton("Przycisk 3");
  @Loc(to="p2") JButton b4 = new JButton("Przycisk 4");
  @Loc(to="p2") JButton b5 = new JButton("Przycisk 5");

  public Annot0() {
    setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    cp.setLayout(new BoxLayout(cp, BoxLayout.Y_AXIS));
    try {
      locateComponents();   // metoda ta zajmie się wkładaniem do kontenerow
    } catch(Exception exc) {
        exc.printStackTrace();
    }
    pack();
    show();
  }
//....
}

  private void locateComponents() throws Exception {
    Class klasa =  getClass();
    for (Field f : klasa.getDeclaredFields()) {   // po polach klasy
      Loc annot = f.getAnnotation(Loc.class);     // dla f uzyskać anotację Loc
      if (annot == null) continue;                // nie ma - następne pole
      System.out.println(annot);                  // zobaczmy jak wygląda
      String contName = annot.to();               // od adnotacji: nazwa kontenera
      Field contField = klasa.getDeclaredField(contName);  // pole, ktore go deklaruje
      Object container = contField.get(this);  // sam obiekt-kontener
      Method m = container.getClass().getMethod("add", Component.class); // metoda add
      m.invoke(container, f.get(this)); // i jej wywołanie - dodajemy komponent
    }
}

3.5. Przetwarzanie adnotacji w fazie kompilacji

import java.lang.annotation.*;

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.SOURCE)
public @interface BeanTemplate {
}

import com.sun.mirror.apt.*;
import com.sun.mirror.declaration.*;
import com.sun.mirror.type.*;
import com.sun.mirror.util.*;

import java.beans.*;
import java.io.*;
import java.util.*;


public class BeanTemplateAnnotationFactory
       implements AnnotationProcessorFactory
{

   // Typ adnotacji
   private final String annoType = "BeanTemplate";

   public Collection<String> supportedAnnotationTypes() {
      return Arrays.asList(annoType);
   }

   public Collection<String> supportedOptions() {
      return Arrays.asList(new String[0]);
   }

   public AnnotationProcessor   // ważna metoda getProcessorFor
          getProcessorFor(Set<AnnotationTypeDeclaration> atds,
                          final AnnotationProcessorEnvironment env)
   {
      return new AnnotationProcessor() { // procesor - w klasie wewnętrznej

        public void process() {
          // deklaracje markowane adnotacją annoType (teraz "BeanTemplate")
          Collection<Declaration> dcls =
             env.getDeclarationsAnnotatedWith(
                (AnnotationTypeDeclaration) env.getTypeDeclaration(annoType));

          for (Declaration d : dcls) { 
             if (d instanceof ClassDeclaration) {  // jeżeli klasa
               ClassDeclaration cdcl = (ClassDeclaration) d;
               String name = cdcl.getSimpleName();
               if (!name.endsWith("Template")) {
                  // od env uzyskujemy środki raportowania błędów, ostrzeżeń, info.
                  env.getMessager().printWarning("Wadliwa nazwa klasy bean template");
                  continue;
               }
               String qname = cdcl.getQualifiedName();
               env.getMessager().printNotice(qname);
               qname = qname.substring(0, qname.lastIndexOf("Template"));
               name = name.substring(0, name.lastIndexOf("Template"));
               try {
                 // od env uzyskamy plik i skojarzony z nim PrintWriter
                 PrintWriter out = env.getFiler().createSourceFile(qname);
                 // generujemy świeży kod na podstawie info o zaznaczonej klasie
                 out.println("public class " + name + " {" );
                 Collection<FieldDeclaration> fdcl = cdcl.getFields();
                 for (FieldDeclaration f : fdcl) {
                   String fname = f.getSimpleName();
                   String mname = Character.toUpperCase(fname.charAt(0)) +
                                  fname.substring(1);
                   String ftype = f.getType().toString();
                   out.println("  private " + ftype + " " + fname + ";");
                   out.println("  public " + ftype + " get" +  mname +
                               "() { return " + fname + "; }");
                   out.println("  public void set" +  mname +
                               "(" + ftype + " v) { " + fname + " = v; }");
                 }
                 out.println("}");
                 out.close();
               } catch(IOException exc) { exc.printStackTrace(); }
             }
             else  // jeśli nie byla klasa, to ktoś się pomylił i zazn. interfejs
               env.getMessager().printWarning("Adnotacja dotyczy interfejsu");
          }
        }
      };
   }



}

import java.awt.*;
@BeanTemplate public class Bean1Template {
  String txt;
  Color color;
}

import java.awt.*;
public class Annot1 {


  public Annot1() {
    Bean1 b = new Bean1();
    b.setTxt("Pies");
    b.setColor(Color.BLUE);

    System.out.println(b.getTxt() + "\n" + b.getColor());

  }

  public static void main(String[] args) {
     new Annot1();
  }

}

apt -factory BeanTemplateAnnotationFactory *.java

public class Bean1 {
  private java.awt.Color color;
  public java.awt.Color getColor() { return color; }
  public void setColor(java.awt.Color v) { color = v; }
  private java.lang.String txt;
  public java.lang.String getTxt() { return txt; }
  public void setTxt(java.lang.String v) { txt = v; }
}

3.6. Adnotacje a transformowanie kodu binarnego

• Javassist,
• BCEL.

• zastępowaniu metod i konstruktorów.
• dodawanie kodu na początku lub w końcu ciała metod lub konstruktorów.

4. Skrypty w Javie

4.1. Wprowadzenie

• wywoływać skrypt,
• wywoływac wybrane funkcje/metody ze skryptu,
• odczytywać informacje (zmienne) zmienione lub dostarczone przez skrypt

• korzystać z możliwości swojego języka skryptowego
• korzystać z bibliotek Javy
• odczytywać informacje z aplikacji (dostęp do zmiennych)

• prototypowanie aplikacji
• testowanie aplikacji
• wzbogacanie aplikacji o możliwości języków skryptowych (np. niektóre fragmenty łatwiej napisać w skrypcie)
• dostarczanie użutkownikowi środków prgramistycznego dostępu do środowiska aplikacji
• np. makra-programy do elastycznych obliczeń
• np. makra edycyjne

4.2. Motory skryptowe i dostęp do nich z aplikacji Javy

• AppleScript (https://jasconn.dev.java.net - Mac OS X only)
• Bex script (http://bexscript.sourceforge.net)
• PHP (http://www.caucho.com/resin-3.0/quercus/) - pure Java implementation of PHP.
• PHP (http://php-java-bridge.sourceforge.net/) - uses native PHP implementation through remoting.
• Python (http://jepp.sourceforge.net/) - uses the native Python implementation to implement JSR 223 engine.

ScriptEngineManager manager = new ScriptEngineManager();
ScriptEngine engine = manager.getEngineByName(nazwa_motoru);

ScriptEngineManager mgr ...
List<ScriptEngineFactory> factories = mgr.getEngineFactories();

import java.util.*;
import javax.script.*;

public class DiscoverEngines {
  
  public static void main(String[] args) {

    ScriptEngineManager mgr = new ScriptEngineManager();
   
    List<ScriptEngineFactory> factories = mgr.getEngineFactories();
    
    for (ScriptEngineFactory factory : factories) {
    
      System.out.println("ScriptEngineFactory Info");
      
      String engName = factory.getEngineName();
      String engVersion = factory.getEngineVersion();
      System.out.println("Script Engine: " + engName + " v. " + engVersion);

      List<String> engNames = factory.getNames();
      for(String name : engNames) System.out.println("Engine Alias: " + name);
      
      String langName = factory.getLanguageName();
      String langVersion = factory.getLanguageVersion();
      System.out.println("Language: " + langName + " v. " +  langVersion);
      
      List<String> exts = factory.getExtensions();
      for(String ext : exts) System.out.println("Script file extension: " + ext);
      
      System.out.println("-------------------------------------------");
    }    
  }

}

4.2. Wykonanie skryptów

• zapisane jako String,
• lub czytane z dowolnego strumienia typu Reader.

import javax.script.*;


public class GroovyTest {

  public static void main(String[] args) {
    ScriptEngineManager manager = new ScriptEngineManager();
    ScriptEngine engine = manager.getEngineByName("groovy");
    try {
      String script = "\"Ala ma kota i psa\".tokenize().each { println it + ' ' + it.length()}";
      engine.eval(script);
    } catch (ScriptException e) {
      e.printStackTrace();
    }
  }

}

1. treśc skryptu sformułowano w języku Groovy jako String
2. warto zwrócić uwagę na moc tego języka - metoda tokenize(), konstrukcja each oraz tzw. domknięcie (zamiast definiowania tradycyjnej funkcji) bardzo ułatwia programowanie.

import java.io.*;
import javax.script.*;

public class GroovyTest2 {

  public static void main(String[] args) {
    ScriptEngineManager manager = new ScriptEngineManager();
    ScriptEngine engine = manager.getEngineByName("groovy");

    try {
      engine.eval(new FileReader("test1.groovy"));
    } catch (ScriptException e) {
      e.printStackTrace();
    } catch (FileNotFoundException e) {
      e.printStackTrace();
    }
  }

}

function square(n) {
  return n*n;
}

function cube(n) {
  return n*n*n;
}

import java.io.*;
import javax.script.*;
import javax.swing.*;

public class InvokeTest {

  public static void main(String[] args) {
    ScriptEngineManager manager = new ScriptEngineManager();
    ScriptEngine engine = manager.getEngineByName("rhino");

    if (!(engine instanceof Invocable))
      throw new RuntimeException("Engine not invocable");

    Invocable eng = (Invocable) engine; // konieczna konwersja

    try {
      engine.eval(new FileReader("test1.js")); // przygotowanie skryptu
      String in;
      while ((in = JOptionPane.showInputDialog("Podaj nazwe funkcji i argument")) != null) {
        String[] call = in.split(" ");
        double res = (Double) eng.invokeFunction(call[0], call[1]); // wołanie wybranej funkcji
        System.out.println("Wynik " + res);
      }
    } catch (ScriptException e) {
      e.printStackTrace();
    } catch (FileNotFoundException e) {
      e.printStackTrace();
    } catch (NoSuchMethodException e) {
      e.printStackTrace();
    }
  }

}

• JSE winien implementować interfejs Compilable,
• skompilowaną postać skryptu uzyskujemy z engine.compile(skrypt) w postaci wyniku typu CompiledScript,
• na rzecz tego wyniku wołamy metodę eval().

4.3. Wymiana danych

• GLOBAL_SCOPE - wiązanie globalnego zakresu (jego elementy są dostępne dla wszystkich JSE tworzonych przez tego samego zarządce ScriptEngineManager)
• ENGINE_SCOPE - wiązanie "zakresu motoru" dostępne dla danego JSE (cały czas w cyklu jego zycia, nie tylko w trakcie wykonania konkretnego skryptu),
• wiązania dodatkowych zakresów - oprócz GLOABAL_SCOPE i ENGINE_SCOPE mogą być dodatkowe zakresy,
• wiązanie tworzone ad hoc i podawane  jako argument metody eval: eval(skrypt, Bindings). 

• pobrać mapę wiązań zakresu SCRIPT_ENGINE - metody getBindings(..) z klas implementujących ScriptEngine lub ScriptContext i z tej mapy pobierać wartości zmiennych,
• pobrać wartości zmiennych za pomocą metod get(key, value) ze ScriptEngine lub getAttribute(key, ScriptContext.ENGINE_SCOPE) z interfejsu ScriptContext
• pobierać wartości z mapy Bindings przekazanej w eval.

• scriptManager.put(key, value) // dodaje do zakresu  GLOBAL_SCOPE
• engine.put(key, value)  // dodaje do zakresu ENGINE_SCOPE
• scriptContext.setAttribute(key, value, scope) // dodaje do wybranego zakresu
• put lub putAll na rzecz Bindings danego zakresu lub własnych (przekazanych w eval)

....
      String script = "a =1; b = 2; c =2;";
      engine.eval(script);
      showBindings();
....


  private static void showBindings() {
    System.out.println("Show bindings");
    ScriptContext ctx = engine.getContext();   // uzyskanie biezącego kontekstu
    List<Integer> scopes = ctx.getScopes();    // z tego kontekstu - jakie są zakresy
    for (Integer scope : scopes) {             // dla każdego zakresu.... :
      System.out.println("Scope: " + scope);
      Bindings bnd = ctx.getBindings(scope);            // wiązania
      System.out.println(bnd.getClass().getName());     // jaka to klasa?
      for (String key : bnd.keySet()) {                 // co jest w wiązaniach?
        System.out.println(key + " = " + bnd.get(key));
      }
    }
  }

      String script = "a =1; b = 2; c =2;";
      engine.eval(script);
      script = "xyz = 10;";
      engine.eval(script);
      showBindings();

      String txt = "Ala ma kota";
      engine.put("txt", txt);
      script = "println('Ze skryptu : ' + txt + a + b + c + xyz);";
      engine.eval(script);

      Bindings sb = new SimpleBindings();
      int i = 1000;
      Date data = new Date();
      sb.put("i", i);
      sb.put("data", data);
      script = "println('Ze skryptu : ' + data + ' liczba ' + i); hhh = 7777;"; 

      engine.eval(script, sb);  // podajemy jako drugi argument Bindings

      showBindings();
      System.out.println("A co jest w naszych bindings?");
      for (String key : sb.keySet()) {
        System.out.println(key + " = " + sb.get(key));
      }
      System.out.println("Koniec naszych");

      script = "println('Ze skryptu liczba = ' + i); print('Ze skryptu txt: '); println(txt);";
      engine.eval(script, sb);

      Bindings eb = engine.getBindings(ScriptContext.ENGINE_SCOPE);  // wiązania motoru
      eb.putAll(sb);  // dodajemy do nich nasze
      script = "println('Ze skryptu : ' + txt + ' liczba ' + i);";
      engine.eval(script);
      showBindings();

      i = 99;
      txt = "Nowy tekst";
      engine.eval(script);

4.4. Kontekst

      // Zobaczmy co można zrobić z Writerem
      StringWriter sw = new StringWriter();
      engine.getContext().setWriter(new PrintWriter(sw));
      script = "println('To powinno pójść na nowy Writer');";
      engine.eval(script);

      JOptionPane.showMessageDialog(null, sw.toString());

4.5. Dostęp do obiektów Javy ze skryptów

public class SwingFromRhino {

  public static void main(String[] args) {
    ScriptEngineManager manager = new ScriptEngineManager();
    ScriptEngine engine = manager.getEngineByName("rhino");
    
    String script = engine.getFactory().getProgram(
        "importPackage (javax.swing)",
        "f = new JFrame('Okno')",
        "f.setSize(200,200)",
        "f.show()"
        );
    
    System.out.println(script);
    
    try {
      engine.eval(script);
    } catch (ScriptException e) {
      e.printStackTrace();
    }

  }

}

class Person {
  String name;

  public Person(String name) {
    super();
    this.name = name;
  }


  public String getName() {
    return name;
  }


  public void setName(String name) {
    this.name = name;
  }

}

public class Groovy2 {

  public static void main(String[] args) {
    ScriptEngineManager manager = new ScriptEngineManager();
    ScriptEngine engine = manager.getEngineByName("groovy");
    try {

      Person p = new Person("Ala");
      String call = engine.getFactory().getMethodCallSyntax("p", "setName", "\"Pies\"");

      System.out.println(call);
      engine.put("p", p);

      engine.eval(call);
      System.out.println(p.getName());

      String out = engine.getFactory().getOutputStatement(p.getName());
      System.out.println(out);
      engine.eval(out);

    } catch (ScriptException e) {
      e.printStackTrace();
    }

  }

}

4.6. Przykład: programowanie skryptowe na zmiennych aplikacji

• automatyczne przekazywanie zmiennych aplikacji do środowiska skryptowego, w tym tablic,
• wykonywanie na nich obliczeń w skrypcie (w tym na tablicach),
• uzyskiwanie wyników obliczeń w aplikacji,
• komunikację skryptu z elementami GUI (np. pole tekstowe).

importPackage(javax.swing);
a = a + 1;
b = 33;
c = a + b;
sum = 0;
for (i in arr) { 
  arr[i] = arr[i]*2;
  sum += arr[i];
}
JOptionPane.showMessageDialog(null, "Suma = " + sum);
infoText.setText("Suma = " + sum);

class Varman {
  
  private Object vars;
  private Bindings bindings;
  private Field[] fields;
  
  public Varman(Bindings bindings, Object vars) {
    this.vars = vars;
    this.bindings = bindings;
    fields = vars.getClass().getDeclaredFields();
    for (int i = 0; i < fields.length; i++) {
      try {
        String name = fields[i].getName();
        if (name.indexOf("this$") != -1) continue;
        Object value =  fields[i].get(vars);
        bindings.put(name, value);
      } catch (Exception e) {
        e.printStackTrace();
      } 
    }
  }
  
  public void getVars() {
    for (int i = 0; i < fields.length; i++) {
      String name = fields[i].getName();
      if (name.indexOf("this$") != -1) continue;      
      Object value =  bindings.get(name);
      try {
        fields[i].set(vars, value);
      } catch (Exception e) {
        e.printStackTrace();
      } 
    }
  }
  
  public String getVarsPageView() {
    StringBuilder sb = new StringBuilder();
    for (int i = 0; i < fields.length; i++) {
      try {
        String name = fields[i].getName();
        if (name.indexOf("this$") != -1) continue;
        Object value = fields[i].get(vars);
        if (fields[i].getType().isArray()) {
          StringBuilder tmp = new StringBuilder("{ ");
          tmp.append(Array.get(value, 0));
          for (int j=1; j < Array.getLength(value); j++) tmp.append(", ").append(Array.get(value, j));
          tmp.append(" }");
          value = tmp;
        }
        sb.append('\n').append(name).append(" = ").append(value);
      } catch (Exception e) {
        e.printStackTrace();
      } 
    }
    return sb.toString();
  }
}


public class CalcJs1 {

  private ScriptEngineManager manager = new ScriptEngineManager();
  private ScriptEngine engine = manager.getEngineByName("rhino");
  private Bindings bindings = engine.createBindings();
  
  private class Var {
    double a = 7, b, c, d, e, f;
    int[] arr = { 1, 2, 3 };
  }
  
  public CalcJs1() {
    Var v = new Var();
    Varman vm = new Varman(bindings, v);
    showInfoFrame(bindings);
    try {
      engine.eval(new FileReader("testCalc.js"), bindings);
    } catch (FileNotFoundException e) {
      e.printStackTrace();
    } catch (ScriptException e) {
      e.printStackTrace();
    }
    vm.getVars();
    JOptionPane.showMessageDialog(null, vm.getVarsPageView(), "Wyniki", 1);
    for (int i = 0; i < v.arr.length; i++) {
      System.out.println("arr " +i+ " = " + v.arr[i]);
    }
  }  
  
  private void showInfoFrame(Bindings bindings) {
    JFrame f = new JFrame("Wyniki");
    JTextField tf = new JTextField("Na razie nie ma wyniku               ");
    f.add(tf);
    f.pack();
    f.setLocation(600, 300);
    f.setVisible(true);
    bindings.put("infoText", tf);
  }

  public static void main(String[] args) {
    new CalcJs1();
  }
  

}

4.7. Przykład: wykorzystanie możliwości JavaScript w apletach Javy

function chgStyle(cssFile) {
  var link = document.getElementById("slink");
  link.setAttribute('href', cssFile);
}

import java.awt.*;
import java.awt.event.*;
import java.io.*;

import javax.script.*;
import javax.swing.*;

@SuppressWarnings("serial")
public class Konfigurator extends JApplet implements ActionListener {

  ScriptEngine engine;
  String[] cssFiles = { "style/first.css", "style/second.css", "style/third.css", "style/last.css" };
  String[] opis = { "Surowy", "Kolorowy", "Powiększony", "Słoneczny" };
  String script;

  @Override
  public void init() {
    ClassLoader myloader = getClass().getClassLoader();
    ScriptEngineManager manager = new ScriptEngineManager(myloader);
    engine = manager.getEngineByName("BrowserJS");
    engine.put("applet", this);
    
    BufferedReader br;
    StringBuilder sb = new StringBuilder();
    try {
      br = new BufferedReader(new FileReader("menu.js"));
      for (String line; (line = br.readLine()) != null;)
        sb.append(line).append('\n');
    } catch (IOException e1) {
      e1.printStackTrace();
    }
    
    script = sb.toString();
    
    JMenu[] menu = { new JMenu("Wygląd"), new JMenu("Spis treści"), 
                     new JMenu("Ważne linki"), new JMenu("Wyszukiwanie"),  new JMenu("Pomoc") }; 
    for (int i = 0; i < opis.length; i++) {
      JMenuItem mi = new JMenuItem(opis[i]);
      mi.setActionCommand(cssFiles[i]);
      mi.addActionListener(this);
      menu[0].add(mi);
    }
     
    JMenuBar mb = new JMenuBar();
    for (int i = 0; i < menu.length; i++) {
      if (i == menu.length-1) mb.add(Box.createHorizontalGlue());
      mb.add(menu[i]);
      menu[i].addMouseListener(new MouseAdapter() {
        Color back; 
        @Override
        public void mouseEntered(MouseEvent e) {
          Component c = e.getComponent();
          back = c.getForeground();
          c.setForeground(Color.BLUE);
        }

        @Override
        public void mouseExited(MouseEvent e) {
          e.getComponent().setForeground(back);
        }
        
      });
    }

    this.setJMenuBar(mb);
  }
  
   public void actionPerformed(ActionEvent e) {
        try {
          String name = e.getActionCommand();
          engine.eval(script);
          if (engine instanceof Invocable) {
            Invocable inv = (Invocable) engine;
            inv.invokeFunction("chgStyle", name);
          }
          else JOptionPane.showMessageDialog(null, "Engine not invocable");
        } catch (Exception exp) {
          throw new RuntimeException(exp);
        }
  }
   
}

5. Zadania i ćwiczenia