Spring读书笔记一

1.

实现AOP的技术，主要有两大类：一是动态代理技术，利用截取消息的方式，对该消息进行装饰，以取代原有对象行为的执行。而是采用静态织入的方式，引入特定的语法创建“方面”，从而使得编译器可以在编译期间织入有关“方面”的代码。

2.

public static void main(String[] args) {
    ApplicationContext context = new FileSystemXmlApplicationXontext("applicationContext.xml");
    Animal animal = (Animal)context.getBean("animal");
    animal.say();
}

我们定义一个Bean类，这个类用来存放一个Bean拥有的属性

private String id;
private String type;
private Map<String, Object> properties = new HashMap<String, Object>();

一个Bean包括id,type,和Properties

接下来Spring 就开始加载我们的配置文件了，将我们配置的信息保存在一个HashMap中，HashMap的key就是Bean 的 Id ，HasMap 的value是这个Bean，只有这样我们才能通过context.getBean(“animal”)这个方法获得Animal这个类。我们都知道Spirng可以注入基本类型，而且可以注入像List，Map这样的类型，接下来就让我们以Map为例看看Spring是怎么保存的吧 .

<bean id="test" class="Test">
    <properties name="testMap">
        <map>
            <entry key="a">
                <value>1</value>
            </entry>
            <entry key="b">
                  <value>2</value>
            </entry>
        </map>
    </properties>
</bean>

if(beanProperty.element("map") != null) {
    Map<String, Object> propertiesMap = new HashMap<String, Object>();
    Element propertiesListMap = (Element)beanProperty.elements().get(0);
    Iterator<?> propertiesIterator = propertiesListMap.elements().iterator();

    while(propertiesIterator.hasNext()) {
        Element vet = (Element) propertiesIterator.next();
        if(vt.getName().equals("entry")) {
            String key = vet.attributeValue("key");
            Iterator<?> valuesIterator = vet.elements().iterator();

            while (valuesIterator.hasNext()) {
                Element value = (Element) valuesIterator.next();
                if (value.getName().equals("value")) {
                    propertiesMap.put(key, value.getText());
                }
                if (value.getName().equals("ref")) {
                    propertiesMap.put(key, new String[] {
                        value.attributeValue("bean")
                        });
                }
            }
        }
    }
     bean.getProperties().put(name, propertiesMap);
}

public static Object newInstance(String className) {
    Class<?> cls = null;
    Object obj = null;

    try {
        cls = Class.forName(className);
        obj = cls.newInstace();
    }catch (ClassNotFoundException e) {
                throw new RuntimeException(e);
    } catch (InstantiationException e) {
                throw new RuntimeException(e);
    } catch (IllegalAccessException e) {
                throw new RuntimeException(e);
    }
    return obj;
}

public static void setProperty(Object obj, String name, String value) {
    Class<? extends Object> clazz = obj.getClass();
    try {
        String methodName = returnSetMthodName(name);
        Method[] ms = clazz.getMethods();

        for(Method m:ms) {
            if (m.getName().equals(methodName)) {
                 if (m.getParameterTypes().length == 1) {
                    Class<?> clazzParameterType = m.getParameterTypes()[0];
                    setFieldValue(clazzParameterType.getName(), value, m,obj);
                    break;
                 }
            }
        }
    }
}

if (value instanceof Map) {
                Iterator<?> entryIterator = ((Map<?, ?>) value).entrySet()
                        .iterator();
                Map<String, Object> map = new HashMap<String, Object>();
                while (entryIterator.hasNext()) {
                    Entry<?, ?> entryMap = (Entry<?, ?>) entryIterator.next();
                    if (entryMap.getValue() instanceof String[]) {
                        map.put((String) entryMap.getKey(),
                                getBean(((String[]) entryMap.getValue())[0]));
                    }
                }
                BeanProcesser.setProperty(obj, property, map);
            }