Wenn man einmal die Vorteile einer BeanFactory ala Spring kennengelernt hat, will man deren Vorteile nicht mehr missen. Es ist einfach viel angenehmer – insbesondere auch im Hinblick auf die Testbarkeit – wenn man Klassen als POJOs entwirft, die Eigenschaften besitzen, die von aussen gesetzt werden (Dependency Injection). Nun will man aber nicht immer einen "Container" wie Spring bem\u00fchen, selbst wenn Spring modular aufgebaut ist und leicht die Verwendung nur von Teilen erlaubt. Konkret wollte ich Dependency Injection sogar gerne in einem Appet nutzen, wof\u00fcr mir Spring zu gross erschien. Ergebnis war eine eigene kleine "BeanFactory" ala Spring … <\/p>\n
Die Features welche ich in typischen Anwendungen brauche:<\/p>\n
Alle diese Features sind in der einfachen Klasse "SimpleBeanFactory" realisiert:<\/p>\n
\npackage <\/span>com.rinke.solutions.beans;<\/p>\n
<\/span>import <\/span>java.beans.PropertyDescriptor;
\n<\/span>import <\/span>java.beans.PropertyEditor;
\n<\/span>import <\/span>java.beans.PropertyEditorManager;
\n<\/span>import <\/span>java.io.InputStream;
\n<\/span>import <\/span>java.lang.reflect.Method;
\n<\/span>import <\/span>java.util.ArrayList;
\n<\/span>import <\/span>java.util.HashMap;
\n<\/span>import <\/span>java.util.List;
\n<\/span>import <\/span>java.util.Map;<\/p>\n<\/span>import <\/span>javax.xml.parsers.SAXParser;
\n<\/span>import <\/span>javax.xml.parsers.SAXParserFactory;<\/p>\n<\/span>import <\/span>org.xml.sax.Attributes;
\n<\/span>import <\/span>org.xml.sax.SAXException;
\n<\/span>import <\/span>org.xml.sax.helpers.DefaultHandler;<\/p>\n<\/span>\/**
\n * simple bean factory.
\n * <\/span>@author <\/span>sr
\n *\/
\n<\/span>public class <\/span>SimpleBeanFactory <\/span>extends <\/span>DefaultHandler <\/span>{<\/p>\n<\/span>\/**
\n * stores singletons
\n *\/
\n <\/span>private <\/span>Map<String, Object> singletons = <\/span>new <\/span>HashMap<String, Object><\/span>()<\/span>;
\n <\/span>\/**
\n * stores bean definitions
\n *\/
\n <\/span>private <\/span>Map<String, BeanDefinition> beanDefs = <\/span>new <\/span>HashMap<String, BeanDefinition><\/span>()<\/span>;<\/p>\n<\/span>\/**
\n * state of parser
\n *\/
\n <\/span>private <\/span>String aktbean;
\n
\n <\/span>\/**
\n * part of bean definition: a setter call for init.
\n * <\/span>@author <\/span>sr
\n *\/
\n <\/span>private class <\/span>SetterCall <\/span>{
\n <\/span>\/**
\n * setter to call.
\n *\/
\n <\/span>Method setter;
\n <\/span>\/**
\n * immediate value to set.
\n *\/
\n <\/span>Object value;
\n <\/span>\/**
\n * alternatively: bean ref to set.
\n *\/
\n <\/span>String ref;
\n <\/span>\/**
\n * ctor using fields
\n * <\/span>@param <\/span>setter setter method to call
\n * <\/span>@param <\/span>value value to set
\n * <\/span>@param <\/span>ref or bean ref to set
\n *\/
\n <\/span>public <\/span>SetterCall<\/span>(<\/span>Method setter, Object value, String ref<\/span>) {
\n <\/span>this<\/span>.setter = setter;
\n <\/span>this<\/span>.value = value;
\n <\/span>this<\/span>.ref = ref;
\n <\/span>}
\n }
\n
\n <\/span>\/**
\n * bean definition consists of singleton flag, class, optional init method
\n * and a list of setter calls for initialization.
\n * <\/span>@author <\/span>sr
\n *\/
\n <\/span>private class <\/span>BeanDefinition <\/span>{
\n <\/span>boolean <\/span>isSingleton;
\n Class clazz;
\n Method initMethod;
\n List<SetterCall> inits = <\/span>new <\/span>ArrayList<SetterCall><\/span>()<\/span>;
\n <\/span>public <\/span>BeanDefinition<\/span>(<\/span>boolean <\/span>isSingleton, Class clazz, Method initMethod<\/span>) {
\n <\/span>this<\/span>.isSingleton = isSingleton;
\n <\/span>this<\/span>.clazz = clazz;
\n <\/span>this<\/span>.initMethod = initMethod;
\n <\/span>}
\n }<\/p>\n<\/span>\/**
\n * the factory singleton
\n *\/
\n <\/span>private static <\/span>SimpleBeanFactory theInstance;
\n
\n <\/span>\/**
\n * accessor for the factory
\n * <\/span>@return <\/span>the factory singleton
\n *\/
\n <\/span>public static <\/span>SimpleBeanFactory getInstance<\/span>() {
\n <\/span>if<\/span>( <\/span>theInstance == <\/span>null <\/span>) {
\n <\/span>theInstance = <\/span>new <\/span>SimpleBeanFactory<\/span>(<\/span>SimpleBeanFactory.<\/span>class<\/span>.getResourceAsStream<\/span>(<\/span>"\/context.xml"<\/span>))<\/span>;
\n <\/span>}
\n <\/span>return <\/span>theInstance;
\n <\/span>}
\n
\n <\/span>\/**
\n * ctor using input stream
\n * <\/span>@param <\/span>is
\n *\/
\n <\/span>public <\/span>SimpleBeanFactory<\/span>(<\/span>InputStream is<\/span>) {
\n <\/span>parse<\/span>(<\/span>is<\/span>)<\/span>;
\n <\/span>}<\/p>\n<\/span>\/**
\n * parser handler
\n * <\/span>@see <\/span>org.xml.sax.ContentHandler#startElement(java.lang.String, java.lang.String, java.lang.String, org.xml.sax.Attributes)
\n *\/
\n <\/span>@Override
\n <\/span>public <\/span>void <\/span>startElement<\/span>(<\/span>String uri, String localName, String qName,
\n Attributes attributes<\/span>) <\/span>throws <\/span>SAXException <\/span>{
\n <\/span>try <\/span>{
\n <\/span>if <\/span>(<\/span>qName.equals<\/span>(<\/span>"bean"<\/span>)) {
\n <\/span>aktbean = attributes.getValue<\/span>(<\/span>"id"<\/span>)<\/span>;
\n <\/span>if<\/span>( <\/span>beanDefs.get<\/span>(<\/span>aktbean<\/span>) <\/span>!= <\/span>null <\/span>) {
\n <\/span>throw new <\/span>IllegalArgumentException<\/span>(<\/span>"duplicate bean name " <\/span>+ aktbean<\/span>)<\/span>;
\n <\/span>}
\n <\/span>String classname = attributes.getValue<\/span>(<\/span>"class"<\/span>)<\/span>;
\n String initMethodName = attributes.getValue<\/span>(<\/span>"init-method"<\/span>)<\/span>;
\n Method initMethod = <\/span>null<\/span>;
\n <\/span>if<\/span>( <\/span>initMethodName != <\/span>null <\/span>) {
\n <\/span>initMethod = Class.forName<\/span>(<\/span>classname<\/span>)<\/span>.getMethod<\/span>(<\/span>initMethodName,new Class<\/span>[]{})<\/span>;
\n <\/span>}
\n <\/span>Class clazz = Class.forName<\/span>(<\/span>classname<\/span>)<\/span>;
\n beanDefs.put<\/span>(<\/span>aktbean, <\/span>