ioc,,aop,,java-reflect

IOC,依赖倒置的意思,
所谓依赖，从程序的角度看，就是比如A要调用B的方法，那么A就依赖于B，反正A要用到B，则A依赖于B。
所谓倒置，你必须理解如果不倒置，会怎么着，因为A必须要有B，才可以调用B，如果不倒置，意思就是A主动获取B的实例：B b = new B()，这就是最简单的获取B实例的方法（当然还有各种设计模式可以帮助你去获得B的实例，比如工厂、Locator等等），然后你就可以调用b对象了。
所以，不倒置，意味着A要主动获取B，才能使用B；到了这里，你就应该明白了倒置的意思了。倒置就是A要调用B的话，A并不需要主动获取B，而是由其它人自动将B送上门来。


形象的举例就是：


通常情况下，假如你有一天在家里口渴了，要喝水，那么你可以到你小区的小卖部去，告诉他们，你需要一瓶水，然后小卖部给你一瓶水！

这本来没有太大问题，关键是如果小卖部很远，那么你必须知道：从你家如何到小卖部；小卖部里是否有你需要的水；你还要考虑是否开着车去；等等等等，也许有太多的问题要考虑了。也就是说，为了一瓶水，你还可能需要依赖于车等等这些交通工具或别的工具，问题是不是变得复杂了？那么如何解决这个问题呢？


解决这个问题的方法很简单：小卖部提供送货上门服务，凡是小卖部的会员，你只要告知小卖部你需要什么，小卖部将主动把货物给你送上门来！这样一来，你只需要做两件事情，你就可以活得更加轻松自在：
第一：向小卖部注册为会员
第二：告诉小卖部你需要什么


是不是和Spring的做法很类似呢？Spring就是小卖部，你就是A对象，水就是B对象
第一：在Spring中声明一个类：A
第二：告诉Spring，A需要B


假设A是UserAction类，而B是UserService类
<bean id="userService" class="org.leadfar.service.UserService"/>
<bean id="documentService" class="org.leadfar.service.DocumentService"/>
<bean id="orgService" class="org.leadfar.service.OrgService"/>


<bean id="userAction" class="org.leadfar.web.UserAction">
     <property name="userService" ref="userService"/>
</bean>


在Spring这个商店（工厂）中，有很多对象/服务：userService,documentService,orgService，也有很多会员：userAction等等，声明userAction需要userService即可，Spring将通过你给它提供的通道主动把userService送上门来，因此UserAction的代码示例类似如下所示：


package org.leadfar.web;
public class UserAction{
     private UserService userService;
     public String login(){
          userService.valifyUser(xxx);
     }
     public void setUserService(UserService userService){ 
          this.userService = userService;
     }
}


在这段代码里面，你无需自己创建UserService对象（Spring作为背后无形的手，把UserService对象通过你定义的setUserService()方法把它主动送给了你，这就叫依赖注入！）


Spring依赖注入的实现技术是：动态代理

---------------------------------------------------
再说说AOP，即面向切面编程，面向切面编程的目标就是分离关注点。什么是关注点呢，就是你要做的事，就是关注点。假如你是个公子哥，没啥人生目标，天天就是衣来伸手，饭来张口，整天只知道玩一件事！那么，每天你一睁眼，就光想着吃完饭就去玩（你必须要做的事），但是在玩之前，你还需要穿衣服、穿鞋子、叠好被子、做饭等等等等事情，这些事情就是你的关注点，但是你只想吃饭然后玩，那么怎么办呢？这些事情通通交给别人去干。在你走到饭桌之前，有一个专门的仆人A帮你穿衣服，仆人B帮你穿鞋子，仆人C帮你叠好被子，仆人C帮你做饭，然后你就开始吃饭、去玩（这就是你一天的正事），你干完你的正事之后，回来，然后一系列仆人又开始帮你干这个干那个，然后一天就结束了！


AOP的好处就是你只需要干你的正事，其它事情别人帮你干。也许有一天，你想裸奔，不想穿衣服，那么你把仆人A解雇就是了！也许有一天，出门之前你还想带点钱，那么你再雇一个仆人D专门帮你干取钱的活！这就是AOP。每个人各司其职，灵活组合，达到一种可配置的、可插拔的程序结构。


从Spring的角度看，AOP最大的用途就在于提供了事务管理的能力。事务管理就是一个关注点，你的正事就是去访问数据库，而你不想管事务（太烦），所以，Spring在你访问数据库之前，自动帮你开启事务，当你访问数据库结束之后，自动帮你提交/回滚事务！

----------------------------------------------------------------------------------------------------------------------------------------------------

spring ioc指的是控制反转，IOC容器负责实例化、定位、配置应用程序中的对象及建立这些对象间的依赖。交由Spring来管理这些，实现解耦

IoC与DI
　　首先想说说IoC（Inversion of Control，控制倒转）。这是spring的核心，贯穿始终。所谓IoC，对于spring框架来说，就是由spring来负责控制对象的生命周期和对象间的关系。这是什么意思呢，举个简单的例子，我们是如何找女朋友的？常见的情况是，我们到处去看哪里有长得漂亮身材又好的mm，然后打听她们的兴趣爱好、qq号、电话号、ip号、iq号………，想办法认识她们，投其所好送其所要，然后嘿嘿……这个过程是复杂深奥的，我们必须自己设计和面对每个环节。传统的程序开发也是如此，在一个对象中，如果要使用另外的对象，就必须得到它（自己new一个，或者从JNDI中查询一个），使用完之后还要将对象销毁（比如Connection等），对象始终会和其他的接口或类藕合起来。


　　那么IoC是如何做的呢？有点像通过婚介找女朋友，在我和女朋友之间引入了一个第三者：婚姻介绍所。婚介管理了很多男男女女的资料，我可以向婚介提出一个列表，告诉它我想找个什么样的女朋友，比如长得像李嘉欣，身材像林熙雷，唱歌像周杰伦，速度像卡洛斯，技术像齐达内之类的，然后婚介就会按照我们的要求，提供一个mm，我们只需要去和她谈恋爱、结婚就行了。简单明了，如果婚介给我们的人选不符合要求，我们就会抛出异常。整个过程不再由我自己控制，而是有婚介这样一个类似容器的机构来控制。Spring所倡导的开发方式就是如此，所有的类都会在spring容器中登记，告诉spring你是个什么东西，你需要什么东西，然后spring会在系统运行到适当的时候，把你要的东西主动给你，同时也把你交给其他需要你的东西。所有的类的创建、销毁都由 spring来控制，也就是说控制对象生存周期的不再是引用它的对象，而是spring。对于某个具体的对象而言，以前是它控制其他对象，现在是所有对象都被spring控制，所以这叫控制反转。如果你还不明白的话，我决定放弃。


IoC的一个重点是在系统运行中，动态的向某个对象提供它所需要的其他对象。这一点是通过DI（Dependency Injection，依赖注入）来实现的。比如对象A需要操作数据库，以前我们总是要在A中自己编写代码来获得一个Connection对象，有了 spring我们就只需要告诉spring，A中需要一个Connection，至于这个Connection怎么构造，何时构造，A不需要知道。在系统运行时，spring会在适当的时候制造一个Connection，然后像打针一样，注射到A当中，这样就完成了对各个对象之间关系的控制。A需要依赖 Connection才能正常运行，而这个Connection是由spring注入到A中的，依赖注入的名字就这么来的。那么DI是如何实现的呢？ Java 1.3之后一个重要特征是反射（reflection），它允许程序在运行的时候动态的生成对象、执行对象的方法、改变对象的属性，spring就是通过反射来实现注入的。关于反射的相关资料请查阅java doc。

--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

动态编译，低耦合不依赖其它程序，独立，这个过程是在程序运行中创建的，动态的加载类
//编译时异常，运行时异常

AOP面向切面编程（也叫面向方面），可以通过预编译方式和运行期动态代理实现在不修改源代码的情况下给程序动态统一添加功能的

一种技术。AOP实际是GoF设计模式的延续，设计模式孜孜不倦追求的是调用者和被调用者之间的解耦，AOP可以说也是这种目标的一

种实现。
面向切面编程：就是在原直线编程的某处咔嚓一下，加点动西，而且不影响原来的代码。可以用在日志，加权限，事物，异常管理

等方面。

aop这种在运行时，动态地将代码切入到类的指定方法、指定位置上的编程思想就是面向切面的编程。

<pre name="code" class="java">public class UserDAOImp implements UserDAO  
{  
  
    @Override  
    public void save(User u)  
    {  
        System.out.println("before!!!!!");  
        System.out.println("a DAO implements!");  
        System.out.println("after!!!!!!");  
    }  
  
}  

reflect

java的反射机制把对象实例化在容器中反射机制创建对象;set属性；当然spring 肯定用的是更底层的反射机制，总之一个字:可麻烦了。。。

JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态 获取 的信息以及动态 调用 对象的方法的功能称为java语言的反射机制java里面不管一个类生成了多少个对象，这个对象都会对应内存里面的唯一一个class对象。Class本身描述了当前生成对象的描述信息，通过class对象 来去探知这个对象有哪些属性 和哪些对象生成了字符串类的多个对象，这些多个对象也都会对应于与String对应的class对象一个类对应一个class对象（与他关联的class对象）动态编译，低耦合不依赖其它程序，独立，这个过程是在程序运行中创建的，动态的加载类//编译时异常，运行时异常Class classType=Class.forName("java.lang.String");//这个字符串类所标识类的class对象反射可以操作私有方法

package basicsTest;

import java.lang.reflect.Method;

public class DumpMethods {
			public static void main(String[] args) throws Exception {
				Class<?> classType=Class.forName("java.lang.Object");//Class.forName(args[0]);动态的获取一个对象的方法 ，属性
				Method [] methods=classType.getDeclaredMethods();
				for(Method method: methods){
					System.out.println(method);
				}
					System.out.println();
			}
						
}

package basicsTest;

import java.lang.reflect.Method;

public class InvokeTester {
	
	
	public int add(int a,int b){
		return a+b;
	}

	public String echo(String a){
		
		return "Hello:"+a;
	}
	public static void main(String[] args) throws Exception {
		// TODO Auto-generated method stub
		
		InvokeTester test=new InvokeTester();
		System.out.println(test.add(1,2));
		System.out.println(test.echo("tom"));
		
		System.out.println("------------------------------");
		
		Class<?> classType=Class.forName("basicsTest.InvokeTester");//InvokeTester.class;
		//或者这个类对应的class对象Class.forName("InvokeTester");反射的方式操作一个类首先获取此类对应class对象
		
		Object invokeTester=classType.newInstance();//生成class类的实力
		
		System.out.println(invokeTester instanceof InvokeTester);
		
		//Field，method,麦瑟德，Constructor
		Method addMethod =classType.getMethod("add", new Class[]{int.class,int.class});//找到对应方法,获取方法要找到对应的method对象，数组离散
		
		
		Object result =addMethod.invoke(invokeTester, new Object[]{1,2});//，表示调用addMethod所对应的目标方法，调用invoke对目标方法的调用
		
		//打印
		System.out.println((Integer)result);
		
		
		Method echoMethod =classType.getMethod("echo", new Class[]{String.class});//找到对应方法，通过echo名字获取与他关联的method对象

		Object result2 =echoMethod.invoke(invokeTester, new Object[]{"tom"});//调用invokeTester对象的echoMethod传入 tom参数获得结果
		
		////打印
		System.out.println((Object)result2);
	}

}