2. JavaBeans als Komponenten Reflexion Nutzung von Class

2. JavaBeans als Komponenten
•
•
•
•
•
•
Reflexion
Reflexion
Java-GUI-Elemente sind Beans
Typischer Aufbau von Beans
Bound properties
Constrained Properties
Speichern
• Reflexion erlaubt in Java Meta-Programmierung; Klassen
selbst als Objekte nutzen
• Paket java.lang.reflect
• Zu jeder Klasse gibt es ein Klassenobjekt der Klasse Class
Class cl1 = String.class;
try { // oder
Class cl2 = Class.forName("java.lang.String");
} catch (ClassNotFoundException e) {
System.out.println("gibs nich")
}
Literatur:
• Sun, JavaBeans 1.01 Specification, http://java.sun.com/
javase/technologies/desktop/javabeans/docs/spec.html
• C. Ullenboom, Java ist auch eine Insel, 8. Auflage, Galileo
Press [Abschnitt 7.4]
Komponentenbasierte SoftwareEntwicklung
Prof. Dr.
Stephan Kleuker
54
Nutzung von Class
Komponentenbasierte SoftwareEntwicklung
Prof. Dr.
Stephan Kleuker
Exemplarische Methoden der Klasse Class
Annotation[] getDeclaredAnnotations()
present on this element.
• Klassenobjekt erlaubt
– Abfrage von Variablen, Konstruktoren, Methoden (mit
Sichtbarkeiten, Typen, Parametern, Exceptions,…)
– Abfrage und Änderung von Objektwerten
– Nutzung von Konstruktoren und Methoden
– Abfrage von Oberklassen
Field[] getDeclaredFields()
Returns an array of Field objects reflecting all
fields declared by the class or interface represented by this Class object.
Method[] getDeclaredMethods()
Returns an array of Method objects
reflecting all the methods declared by the class or interface represented
by this Class object.
Class[] getInterfaces()
Determines the interfaces implemented by the class
or interface represented by this object.
int getModifiers()
Returns the Java language modifiers for this class or
interface, encoded in an integer.
boolean isArray()
Determines if this Class object represents an array class.
T newInstance()
this Class object.
Prof. Dr.
Stephan Kleuker
Returns all annotations that are directly
Constructor[] getDeclaredConstructors()
Returns an array of Constructor objects
reflecting all the constructors declared by the class represented by this
Class object.
• Insgesamt können damit zur Laufzeit beliebige Klassen
analysiert und genutzt werden
• Zentrale Reflection-Klassen: Field, Constructor, Method,
Modifier
Komponentenbasierte SoftwareEntwicklung
55
56
Komponentenbasierte SoftwareEntwicklung
Creates a new instance of the class represented by
http://download.oracle.com/javase/1.5.0/docs/api/java/lang/Class.html
Prof. Dr.
Stephan Kleuker
57
Einsatzbereiche von Reflexion
Ungewöhnliches Beispiel (1/2)
• Eingesetzt zur Entwicklung von Entwicklungswerkzeugen
– Debugger
– Class Browser, UML-Diagrammableitung
– GUI Builder
– IDEs wie z.B. Eclipse und Netbeans
• Eingesetzt in Frameworks
– Einheitliche Klassenbehandlung ohne Interfaces
– Finden bestimmter Methoden (z. B. getXXX) und
Eigenschaften
– Meist Verwaltung unterschiedlicher Klassen
• Oft verknüpft mit anderen fortgeschrittenen Ansätzen
(ClassLoader, Annotationen, Bytecode-Manipulation)
Komponentenbasierte SoftwareEntwicklung
Prof. Dr.
Stephan Kleuker
• Praktisch nicht nutzbare Klasse
package model;
public class Heimlich {
private int x;
private Heimlich(){ }
private void ausgeben(){
System.out.println("x ist "+x);
}
}
• Hinweis: Folgender Ansatz geht nicht immer, hängt von
Security-Einstellungen ab
58
Ungewöhnliches Beispiel (2/2)
Prof. Dr.
Stephan Kleuker
Prof. Dr.
Stephan Kleuker
59
Hintergrund und Motivation von JavaBeans
public static void main(String[] s) throws Exception{
Class cl = Class.forName("model.Heimlich");
Constructor[] cons = cl.getDeclaredConstructors();
Constructor con = cons[0];
System.out.println(con);
if(!con.isAccessible()) // evtl. SecurityManager-Exception
con.setAccessible(true);
Object[] parameter = {};
Heimlich h = (Heimlich) con.newInstance(parameter);
System.out.println("" + h);
private model.Heimlich()
Field f=cl.getDeclaredFields()[0];
model.Heimlich@19821f
f.setAccessible(true);
x ist 42
f.set(h, 42);
Method m=cl.getDeclaredMethods()[0];
m.setAccessible(true);
m.invoke(h, parameter);
}
Komponentenbasierte SoftwareEntwicklung
Komponentenbasierte SoftwareEntwicklung
60
• JavaBeans sind als frühes Komponentenmodell entstanden
• Objekte einfach serialisierbar (damit einfach im Netz
austauschbar)
• Beans-Framework ermöglicht einfache Kommunikation
unter Beans
• Haupteinsatz: GUI-Komponenten, Swing nutzt Technologie
(ermöglicht u. a. GUI-Builder [gute/schlechte])
• Aktuelle Spezifikation: JavaBeans 1.01
• Ideen für JavaBeans Spec 2.0 (JSR-273) existieren/ ruhen
• Zitat: “A Java Bean is a reusable software component that
can be manipulated visually in a builder tool.”
• Achtung: nicht mit Enterprise JavaBeans verwechseln
Komponentenbasierte SoftwareEntwicklung
Prof. Dr.
Stephan Kleuker
61
Erinnerung: JButton (Nutzung)
Erinnerung: JButton (ActionListener)
public class ButtonFrame extends JFrame {
import
import
import
import
public ButtonFrame() {
setSize(200, 100);
JButton rot = new JButton("rot");
rot.addActionListener(new MeineAction(getContentPane(),
Color.RED));
add(rot, BorderLayout.EAST);
JButton blau = new JButton("blau");
blau.addActionListener(new MeineAction(getContentPane(),
Color.BLUE));
add(blau, BorderLayout.WEST);
setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
}
public class MeineAction implements ActionListener {
private Component komponente;
private Color farbe;
public MeineAction(Component komponente, Color farbe){
this.komponente = komponente;
this.farbe = farbe;
}
public static void main(String args[]) {
java.awt.EventQueue.invokeLater(new Runnable() {
public void run() {new ButtonFrame().setVisible(true);}
});
}
} Komponentenbasierte SoftwareEntwicklung
Prof. Dr.
Stephan Kleuker
}
62
Typische Beanmethoden (1/2)
Prof. Dr.
Stephan Kleuker
public void actionPerformed(ActionEvent e) {
komponente.setBackground(farbe);
}
Komponentenbasierte SoftwareEntwicklung
Prof. Dr.
Stephan Kleuker
63
Typische Beanmethoden (2/2)
public class Knopf {
public static void main(String[] s){
JButton jb= new JButton();
jb.addPropertyChangeListener(new PCL());
jb.setText("touch me");
jb.setToolTipText("bin ne Bean");
jb.setBackground(Color.red);
jb.setBorderPainted(false);
JFrame jf = new JFrame();
jf.addPropertyChangeListener(new PCL());
jf.add(jb);
jf.setSize(200, 100);
jf.setTitle("Knopf");
jf.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
jf.setVisible(true);
}
}
Komponentenbasierte SoftwareEntwicklung
java.awt.Color;
java.awt.Component;
java.awt.event.ActionEvent;
java.awt.event.ActionListener;
public class PCL implements PropertyChangeListener{
public PCL() {}
public void propertyChange(PropertyChangeEvent evt) {
System.out.println(evt.getPropertyName()
+" alt:"+evt.getOldValue()
+" neu:"+evt.getNewValue());
} text alt: neu:touch me
}
ToolTipText alt:null neu:bin ne Bean
background alt:javax.swing.plaf.ColorUIResource[r=238,...
borderPainted alt:true neu:false
title alt: neu:Knopf
defaultCloseOperation alt:1 neu:3
foreground alt:null neu:java.awt.Color[r=0,g=0,b=0]
font alt:null neu:java.awt.Font[family=Dialog,name=Dia...
ancestor alt:null neu:javax.swing.JPanel[null.contentP...
64
Komponentenbasierte SoftwareEntwicklung
Prof. Dr.
Stephan Kleuker
65
Elementare Anforderungen an JavaBean
Minimales Beispiel
• Default-Konstruktor (keine Parameter)
• Alle Exemplarvariablen (Properties, Attribute) über get- und
set-Methoden erreichbar
• Variable private <Typ> xx;
public void setXx(<Typ> xx) {
this.xx = xx;
}
public <Typ> getXx() {
return xx;
}
• Methoden können weiteren Code enthalten
• Jedwede Typen von Variablen sind serialisierbar
Komponentenbasierte SoftwareEntwicklung
Prof. Dr.
Stephan Kleuker
66
Komponentenbasierte SoftwareEntwicklung
Prof. Dr.
Stephan Kleuker
67
Einschub: typischer schlechter Stil
Indizierte Eigenschaften
• Für Eigenschaften, die in Arrays gespeichert werden,
besteht zusätzlich folgende Möglichkeit (Ausschnitt)
• Arrays sind für dynamische Datenmengen unflexibel
• Collections sind auch nutzbar (auch serialisierbar)
private String[] vorlesung;
public String[] getVorlesung() { //bekannt
return vorlesung;
}
public void setVorlesung(String[] vorlesung) { //bekannt
this.vorlesung = vorlesung;
}
public String getVorlesung(int index) {
return vorlesung[index];
}
public void setVorlesung(String vl, int index) {
vorlesung[index]=vl;
}
Komponentenbasierte SoftwareEntwicklung
import java.io.Serializable;
public class Student implements Serializable{
private String name;
private int cp;
public Student(){}
public int getCp() {
return cp;
}
public void setCp(int cp) {
this.cp = cp;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
Prof. Dr.
Stephan Kleuker
private Set<String> vorlesung= new HashSet<String>();
mit üblichen get- und set-Methoden
• In JavaBeans können weitere Methoden ergänzt werden
public void weitereVorlesung(String v){
vorlesung.add(v);
}
• Leider nicht unüblich der Stil „Innereien herausreißen,
verändern, Innereien wieder hinschieben“ (verletzt
eigentlich Geheimnisprinzip)
Student st = new Student();
st.getVorlesung().add("KomSE");
68
Komponentenbasierte SoftwareEntwicklung
Prof. Dr.
Stephan Kleuker
69
Gebundene Eigenschaften
Beispiel-Erweiterung in Student (1/2)
import java.beans.PropertyChangeListener;
import java.beans.PropertyChangeSupport;
…
private PropertyChangeSupport pcs=new PropertyChangeSupport(this);
• Bound properties sind Exemplarvariablen, die Änderungen
interessierten Beans mitteilen (Observer-Observable)
• Wer Änderungen mitteilen will,
– benötigt Objekt der Klasse PropertyChangeSupport
– muss Methoden add/removePropertyChangeListener
implementieren
public void setCp(int cp) {
int alt=this.cp;
this.cp = cp;
pcs.firePropertyChange("cp", alt, cp);
}
public void addPropertyChangeListener(PropertyChangeListener l){
pcs.addPropertyChangeListener(l);
}
• Interessenten für Änderungen müssen sich mit add…
anmelden
• Bei Anmeldung muss Objekt übergeben werden, das das
Interface PropertychangeListener implementiert
• normales Observer-Observable-Pattern
Komponentenbasierte SoftwareEntwicklung
Prof. Dr.
Stephan Kleuker
public void removePropertyChangeListener(
PropertyChangeListener l){
pcs.removePropertyChangeListener(l);
}
70
Beispiel-Erweiterung in Student (2/2)
Prof. Dr.
Stephan Kleuker
Prof. Dr.
Stephan Kleuker
71
Veto-Eigenschaften
import java.beans.PropertyChangeListener;
import java.beans.PropertyChangeEvent;
public class Studentnutzer {
public static void main(String[] args) {
Student s = new Student();
s.addPropertyChangeListener(new PropertyChangeListener() {
@Override
public void propertyChange(PropertyChangeEvent e) {
System.out.println("Eigenschaft "+e.getPropertyName()
+" alt:"+e.getOldValue()+" neu:"+e.getNewValue());
}
});
s.setCp(42);
s.setCp(s.getCp()+5);
s.setCp(47);
Eigenschaft cp alt:0 neu:42
}
Eigenschaft cp alt:42 neu:47
}
Komponentenbasierte SoftwareEntwicklung
Komponentenbasierte SoftwareEntwicklung
72
• Spezielle Möglichkeit von JavaBeans: Vetoable (constrained)
– Bean meldet angemeldeten Bean-Interessenten, dass eine
Exemplarvariable geändert wird
– Jede Bean kann „Einspruch“ gegen die Änderung
(PropertyVetoException) einlegen
• Konkretes Szenario: Kundenbestellung soll durchgeführt
werden, Kontoverwaltung und Lagerverwaltung lauschen und
können Einspruch einlegen
• Nach Einspruch werden alle angemeldeten Beans erneut mit
altem Wert informiert
Komponentenbasierte SoftwareEntwicklung
Prof. Dr.
Stephan Kleuker
73
Constrained und Bound
Beispiel ohne Bound Property (1/3)
private VetoableChangeSupport vcs=new VetoableChangeSupport(this);
public void setVorlesung(Set<String> vorlesung) {
Set<String> old = this.vorlesung;
in Student
try {
vcs.fireVetoableChange("vl", old, vorlesung);
this.vorlesung = vorlesung;
} catch (PropertyVetoException ex) {
System.out.println("abgelehnt: "+ex.getMessage());
}
}
• Listener für eine vetoable Property erhalten Änderung mit
public void vetoableChange(PropertyChangeEvent e)
• gibt e.getNewValue() e.getOldValue() e.getPropertyName()
• Problem: Listener macht kein Veto und rechnet mit Daten
weiter, aber anderer Listener hat Veto (vgl. dirty read)
• sauberer Ansatz, bei versuchter Änderung
– erst nach Vetos fragen
– wenn Veto, dann Änderung abbrechen
– wenn kein Veto, dann Änderung als bound property
behandeln (propertyChange), also zwei Listener
zusammen
• sauberes Beispiel: s. Praktikum
• schmuddeliges Beispiel: nächste Folien
• Anmerkung: Parameterinhalte kann man ändern
Komponentenbasierte SoftwareEntwicklung
Prof. Dr.
Stephan Kleuker
public void addVetoableChangeListener(VetoableChangeListener l){
vcs.addVetoableChangeListener(l);
}
public void removeVetoableChangeListener(
VetoableChangeListener l) {
vcs.removeVetoableChangeListener(l);
}
74
Beispiel ohne Bound Property (2/3)
public MeinVeto(String schlecht) {
this.schlecht = schlecht;
}
@Override
public void vetoableChange(PropertyChangeEvent evt)
throws PropertyVetoException {
Set<String> neu = (Set<String>) evt.getNewValue();
if (neu.contains(schlecht))
throw new PropertyVetoException("nicht "+schlecht, evt);
System.out.println("für "+schlecht+": "+(++aenderung));
}
}
Prof. Dr.
Stephan Kleuker
Prof. Dr.
Stephan Kleuker
75
Beispiel ohne Bound Property (3/3)
public class MeinVeto implements VetoableChangeListener{
private String schlecht;
private int aenderung;
Komponentenbasierte SoftwareEntwicklung
Komponentenbasierte SoftwareEntwicklung
76
public static void main(String[] args) {
Student stu = new Student();
Set<String> vls = new HashSet();
vls.add("C");
vls.add("Java");
stu.addVetoableChangeListener(new MeinVeto("BWL"));
stu.addVetoableChangeListener(new MeinVeto("C++"));
stu.setVorlesung(vls);
Set<String> tmp = (Set<String>)vls.clone();
für BWL: 1
tmp.add("C++");
für C++: 1
stu.setVorlesung(tmp);
System.out.println(stu.getVorlesung()); für BWL: 2
für BWL: 3
}
für C++: 2
abgelehnt: nicht C++
[C, Java]
Komponentenbasierte SoftwareEntwicklung
Prof. Dr.
Stephan Kleuker
77
Wesentlicher Nachrichtenfluss
stu:Student (+vcs)
setVorlesung
((C,Java))
Einfaches Speichern (von JavaBeans)
:MeinVeto(BWL)
fireVetoableChange
(vl,null,(C,Java))
public static void main(String[] args) {
Student stu = new Student();
HashSet<String> vls = new HashSet();
vls.add("C");
vls.add("Java");
stu.setVorlesung(vls); stu.setName("Erwin");
try {
XMLEncoder out = new XMLEncoder(new BufferedOutputStream(
new FileOutputStream("stu.xml")));
out.writeObject(stu);
out.close();
XMLDecoder in= new XMLDecoder(new BufferedInputStream(
new FileInputStream("stu.xml")));
Student st= (Student)in.readObject();
System.out.println(st.getVorlesung());
in.close();
} catch (FileNotFoundException ex) { }
[C, Java]
}
:MeinVeto(C++)
BWL:1
fireVetoableChange (vl,null,(C,Java))
C++:1
vorlesung=(C,Java)
setVorlesung
((C,Java,C++))
fireVetoableChange
(vl,(C,Java),(C,Java,C++))
BWL:2
fireVetoableChange(vl,(C,Java),(C,Java,C++))
PropertyVetoException
fireVetoableChange
(vl,(C,Java,C++),(C,Java))
BWL:3
fireVetoableChange(vl,(C,Java,C++),(C,Java))
C++:2
Komponentenbasierte SoftwareEntwicklung
Prof. Dr.
Stephan Kleuker
78
stu.xml
Prof. Dr.
Stephan Kleuker
79
Analyse des Beispiels
<?xml version="1.0" encoding="UTF-8"?>
<java version="1.6.0_12" class="java.beans.XMLDecoder">
<object class="beans.Student">
<void property="name">
<string>Erwin</string>
</void>
<void property="vorlesung">
<void method="add">
<string>C</string>
</void>
<void method="add">
<string>Java</string>
</void>
</void>
</object>
</java>
Komponentenbasierte SoftwareEntwicklung
Komponentenbasierte SoftwareEntwicklung
Prof. Dr.
Stephan Kleuker
• Wesentliche Funktionalität wurde an Java (genauer die
Virtual Machine VM) abgegeben; diese arbeitet als
Container
• VM kann direkt auf Exemplarvariablen zugreifen (Ansätze
mit Introspection, Reflection)
– Gib mir Exemplarvariablen
– Gib mir Exemplarmethoden
– (Textanalyse, Beginn mit get/set)
– Rufe auf Objekt mit Methode mit Namen … und
Parametern … auf
80
Komponentenbasierte SoftwareEntwicklung
Prof. Dr.
Stephan Kleuker
81
Weiterführend
• Zu jeder Bean kann es eine
BeanInfo-Klasse geben, die
die Bean beschreibt
• Ursprünglich sind Beans für
visuelle Komponenten
entwickelt worden; GUIBuilder erlauben die direkte
Bearbeitung von Properties
• Java-Bean für GUI-Builder in jar-Datei mit Manifest-Datei
(.mf)
• Es gibt eigene Werkzeuge zur Entwicklung mit Beans
Komponentenbasierte SoftwareEntwicklung
Prof. Dr.
Stephan Kleuker
82