IOC思想：Spring容器来实现相互依赖对象的创建，协调工作。对象只需要关心业务逻辑本身就好了。从这方面来说，对象如何得到他的协作对象的责任被反转了（IOC、DI）。控制反转就是获得依赖对象的方式反转了。由Spring来负责控制对象的生命周期和对象间的关系。
IOC(控制反转)之中的核心是在系统运行中，动态的向某个对象提供它所需要的其他对象。这一点是通过DI（Dependency Injection，依赖注入）来实现的。
那么DI是如何实现的呢？ Java 1.3之后一个重要特征是反射（reflection），它允许程序在运行的时候动态的生成对象、执行对象的方法、改变对象的属性，spring就是通过反射来实现注入的。
ApplicationContext context = new FileSystemXmlApplicationContext( "applicationContext.xml");
A a = (A) context.getBean("a");
pojo类的属性也是可以通过Spring注入进去的。Spirng不但可以注入基本类型，而且可以注入像List，Map这样的类型。
Map类型的配置：
1 <bean id="test" class="Test"> 2 <property name="testMap"> 3 <map> 4 <entry key="a"> 5 <value>1</value> 6 </entry> 7 <entry key="b"> 8 <value>2</value> 9 </entry> 10 </map> 11 </property> 12 </bean>
<bean id="userAction" class="com.dobestself.action.UserAction" scope="prototype"> <property name="userBO" ref="userBO" /> 论property可以传递的类型，如果把ref换成value则直接传递字符串（值），如果传递另外的bean，则要用ref。如果传递Map,参考上文。 </bean> Spring运行机制剖析：
1 //定义一个Bean类，这个类用于存放一个Bean拥有的属性。
2 /* Bean Id */
3 private String id;
4 /* Bean Class */
5 private String type;
6 /* Bean Property */
7 private Map<String, Object> properties = new HashMap<String, Object>();
8 /*接下来Spring 就开始加载我们的配置文件了，将我们配置的信息保存在一个HashMap中，HashMap的key就是Bean 的 Id ，HasMap 的value是这个Bean，只有这样我们才能通过context.getBean("animal")这个方法获得Animal这个类。我们都知道Spirng可以注入基本类型，而且可以注入像List，Map这样的类型，接下来就让我们以Map为例看看Spring是怎么保存的吧*/
9 //Map配置可以像下面的
10 <bean id="test" class="Test">
11 <property name="testMap">
12 <map>
13 <entry key="a">
14 <value>1</value>
15 </entry>
16 <entry key="b">
17 <value>2</value>
18 </entry>
19 </map>
20 </property>
21 </bean>
22 //Spring是怎样保存上面的配置
23 if (beanProperty.element("map") != null) {
24 Map<String, Object> propertiesMap = new HashMap<String, Object>();
25 Element propertiesListMap = (Element) beanProperty
26 .elements().get(0);
27 Iterator<?> propertiesIterator = propertiesListMap
28 .elements().iterator();
29 while (propertiesIterator.hasNext()) {
30 Element vet = (Element) propertiesIterator.next();
31 if (vet.getName().equals("entry")) {
32 String key = vet.attributeValue("key");
33 Iterator<?> valuesIterator = vet.elements()
34 .iterator();
35 while (valuesIterator.hasNext()) {
36 Element value = (Element) valuesIterator.next();
37 if (value.getName().equals("value")) {
38 propertiesMap.put(key, value.getText());
39 }
40 if (value.getName().equals("ref")) {
41 propertiesMap.put(key, new String[] { value
42 .attributeValue("bean") });
43 }
44 }
45 }
46 }
47 bean.getProperties().put(name, propertiesMap);
48 }
49 /*接下来就进入最核心部分了，让我们看看Spring 到底是怎么依赖注入的吧，其实依赖注入的思想也很简单，它是通过反射机制实现的，在实例化一个类时，它通过反射调用类中set方法将事先保存在HashMap中的类属性注入到类中。让我们看看具体它是怎么做的吧。
50 首先实例化一个类，像这样 */
51 public static Object newInstance(String className) {
52 Class<?> cls = null;
53 Object obj = null;
54 try {
55 cls = Class.forName(className);
56 obj = cls.newInstance();
57 } catch (ClassNotFoundException e) {
58 throw new RuntimeException(e);
59 } catch (InstantiationException e) {
60 throw new RuntimeException(e);
61 } catch (IllegalAccessException e) {
62 throw new RuntimeException(e);
63 }
64 return obj;
65 }
66 //接着它将这个类的依赖注入进去，像这样
67 public static void setProperty(Object obj, String name, String value) {
68 Class<? extends Object> clazz = obj.getClass();
69 try {
70 String methodName = returnSetMthodName(name);
71 Method[] ms = clazz.getMethods();
72 for (Method m : ms) {
73 if (m.getName().equals(methodName)) {
74 if (m.getParameterTypes().length == 1) {
75 Class<?> clazzParameterType = m.getParameterTypes()[0];
76 setFieldValue(clazzParameterType.getName(), value, m,
77 obj);
78 break;
79 }
80 }
81 }
82 } catch (SecurityException e) {
83 throw new RuntimeException(e);
84 } catch (IllegalArgumentException e) {
85 throw new RuntimeException(e);
86 } catch (IllegalAccessException e) {
87 throw new RuntimeException(e);
88 } catch (InvocationTargetException e) {
89 throw new RuntimeException(e);
90 }
91 }
92 /*最后它将这个类的实例返回给我们，我们就可以用了。我们还是以Map为例看看它是怎么做的，我写的代码里面是创建一个HashMap并把该HashMap注入到需要注入的类中，像这样，*/
93 if (value instanceof Map) {
94 Iterator<?> entryIterator = ((Map<?, ?>) value).entrySet()
95 .iterator();
96 Map<String, Object> map = new HashMap<String, Object>();
97 while (entryIterator.hasNext()) {
98 Entry<?, ?> entryMap = (Entry<?, ?>) entryIterator.next();
99 if (entryMap.getValue() instanceof String[]) {
100 map.put((String) entryMap.getKey(),
101 getBean(((String[]) entryMap.getValue())[0]));
102 }
103 }
104 BeanProcesser.setProperty(obj, property, map);
105 }
反射：由对象反推类
1 public static void printMethods(Class cl)
2 {
3 Method[] methods =cl.getDeclaredMethods();//返回一个包含方法对象的数组
4 for(Method m : methods)//循环该类的每个方法
5 {
6 Class retType = m.getReturnType();//该方法的返回类型，
7 Sting name = m.getName();//获得方法名
8 Systen.out.print(" "+Modifier.toString(m.getModifiers());打印方法修饰符
9 System.out.print(" "+retType.getName() + " " + name +"(");
10
11 Class[] paramTypes = m.getParameterTypes();//获得一个方法参数数组（getparameterTypes用于返回一个描述参数类型的Class对象数组）
12
13 for(int j = 0 ; j < paramTypes.length ; j++)
14
15 {
16 if ( j > 0 ) System.out.print(" , "); //如果有多个参数，中间则用逗号隔开，否则直接打印参数
17 System.out.print (paramTypes[ j ].getName);
18 }
19 System.out.println (" );");
20 }}
21
22 //////////getparameterTypes方法用于返回一个描述参数类型的Class对象数组）
参考文献：
http://blog.csdn.net/it_man/article/details/4402245
时间： 2024-10-08 17:48:51