MentaContainer

package org.mentacontainer.impl;

import java.lang.reflect.Constructor;

import java.lang.reflect.Method;

import java.util.HashMap;

import java.util.Iterator;

import java.util.LinkedList;

import java.util.List;

import java.util.Map;

import org.mentacontainer.ConfigurableComponent;

import org.mentacontainer.util.FindMethod;

/**

 * A simple implementation of the Component interface.

 *

 * @author sergio.oliveira.jr@gmail.com

 */

public class MentaComponent implements ConfigurableComponent {

            private final Class<? extends Object> klass;

            private Map<String, Object> props = null;

            private List<Object> initValues = null;

            private Constructor<? extends Object> constructor = null;

            private Map<String, Method> cache = null;

            private final boolean singleton;

            private Object singletonValue = null;

            public MentaComponent(Class<? extends Object> klass, boolean singleton) {

                this.klass = klass;

                this.singleton = singleton;

            }

            public MentaComponent(Class<? extends Object> klass) {

                this(klass, false);

            }

            public boolean isSingleton() { return singleton; }

            public ConfigurableComponent addProperty(String name, Object value) {

                if (props == null) {

                    props = new HashMap<String, Object>();

                    cache = new HashMap<String, Method>();

                }

                props.put(name, value);

                return this;

            }

            public ConfigurableComponent addInitValue(Object value) {

                if (initValues == null) {

                    initValues = new LinkedList<Object>();

                }

                initValues.add(value);

                return this;

            }

            private Class<? extends Object>[] getClasses(List<Object> values) {

                Class<? extends Object>[] types = (Class<? extends Object>[]) new Class[values.size()];

                Iterator<Object> iter = values.iterator();

                int index = 0;

                while(iter.hasNext()) {

                    Object value = iter.next();

                    if (value != null) {

                        types[index++] = value.getClass();

                    } else {

                        types[index++] = null;

                    }

                }

                return types;

            }

            private Object [] getValues(List<Object> values) throws InstantiationException {

                Object [] array = new Object[values.size()];

                int index = 0;

                Iterator<Object> iter = values.iterator();

                while(iter.hasNext()) {

                        Object obj = iter.next();

                        array[index++] = obj;

                }

                return array;

            }

                /*

                 * Use reflection to set a property in the bean

                 */

                private void setValue(Object bean, String name, Object value) {

                        try {

                                StringBuffer sb = new StringBuffer(30);

                                sb.append("set");

                                sb.append(name.substring(0,1).toUpperCase());

                                if (name.length() > 1) sb.append(name.substring(1));

                    String methodName = sb.toString();

                    if (!cache.containsKey(name)) {

                        Method m = null;

                        try {

                            m = FindMethod.getMethod(klass, methodName, new Class[] { value.getClass() });

                        } catch(Exception e) {

                            // try primitive...

                            Class<? extends Object> primitive = getPrimitiveFrom(value);

                            if (primitive != null) {

                                try {

                                    m = klass.getMethod(methodName, new Class[] { primitive });

                                } catch(Exception ex) {

                                        // not found!

                                }

                            }

                            if (m == null) {

                                throw new InstantiationException("Cannot find method or field for property: " + name);

                            }

                        }

                        if (m != null) {

                            cache.put(name, m);

                            m.setAccessible(true);

                        }

                    }    

                    Method m = cache.get(name);

                    if (m != null) {

                        m.invoke(bean, new Object[] { value });

                    }                

                        } catch(Exception e) {

                                throw new RuntimeException("Error trying to set a property with reflection: " + name, e);

                        }

                }

            private static Class<? extends Object> getPrimitiveFrom(Object w) {

                if (w instanceof Boolean) { return Boolean.TYPE; }

                else if (w instanceof Byte) { return Byte.TYPE; }

                else if (w instanceof Short) { return Short.TYPE; }

                else if (w instanceof Character) { return Character.TYPE; }

                else if (w instanceof Integer) { return Integer.TYPE; }

                else if (w instanceof Long) { return Long.TYPE; }

                else if (w instanceof Float) { return Float.TYPE; }

                else if (w instanceof Double) { return Double.TYPE; }

                return null;

            }  

            public <T> T getInstance()  {

                if (singleton && singletonValue != null) return (T) singletonValue;

                Object obj = null;

                if (initValues != null && initValues.size() > 0) {

                    if (constructor == null) {

                        try {

                            constructor = klass.getConstructor(getClasses(initValues));

                        } catch(Exception e) {

                            throw new RuntimeException("Cannot find a constructor for class: " + klass, e);

                        }

                    }

                    try {

                        obj = constructor.newInstance(getValues(initValues));

                    } catch(Exception e) {

                        throw new RuntimeException("Cannot create instance from constructor: " + constructor, e);

                    }

                } else {

                    try {

                        obj = klass.newInstance();

                    } catch(Exception e) {

                        throw new RuntimeException("Cannot create instance from class: " + klass, e);

                    }

                }

                if (props != null && props.size() > 0) {

                    Iterator<String> iter = props.keySet().iterator();

                    while(iter.hasNext()) {

                        String name = iter.next();

                        Object value = props.get(name);

                        setValue(obj, name, value);

                    }

                }

                if (obj != null && singleton) singletonValue = obj;

                return (T) obj;

            }

        }