JAVA Spring 配置及IOC AOP相关

http://www.importnew.com/13246.html

先下载

http://repo.spring.io/release/org/springframework/spring/3.2.9.RELEASE/

spring-framework-3.2.9.RELEASE-dist.zip 

解压

右键在Package Explorer中点击> Build Path > Configure Build Path...。然后点击Add External JARs...加入我们需要的Spring库。

此外，为了打印信息，我

http://commons.apache.org/proper/commons-logging/download_logging.cgi们还需要一个Apache Commons Logging API。

下载commons-logging-1.2-bin.zip   解压

然后和添加Spring库一样添加commons-logging-1.2.jar到CLASSPATH中。

Java源代码

首先新建一个包“com.importnew”。右键点击src，然后> New > Package，新建com.importnew包。

然后我们需要在com.importnew包下新建两个Java源文件HelloWorld.java和MainApp.java。

HelloWorld.java:

package com.importnew;
 

public class HelloWorld {
 
    private String message;
 
    public void setMessage(String message){
        this.message  = message;
    }
 
    public String getMessage(){
        return this.message;
    }
 
    public void printMessage(){
        System.out.println("Your Message : " + message);
    }
}

MainApp.java:

package com.importnew;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
 
public class MainApp {
    public static void main(String[] args) {
 
        ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
 
        HelloWorld obj = (HelloWorld) context.getBean("helloWorld");
 
        obj.printMessage();
    }
}

配置文件

接下来，我们需要新建一个XML文件来配置bean，这个XML的作用是集中在一个地方，配置和管理所有的bean。有关bean的概念，重用组件 

1、所有属性为private
2、提供默认构造方法
3、提供getter和setter
4、实现serializable接口

我们将这个XML文件也放在src下面，这样就保证Eclipse可以在CLASSPATH下读取到这个文件。

新建一个Beans.xml，当然这个文件名任意，不过要和MainApp.java中ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml")设置的一致。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
 
       <bean id="helloWorld" class="com.importnew.HelloWorld">
           <property name="message" value="Hello World!"/>
       </bean> 
</beans>

这个Beans.xml文件中设置了bean，包含在<beans>和</beans>中。每个bean都有一个唯一的id这个语句为message变量赋值，这样就能打印出Hello World!了。要修改输出，只需要修改XML文件，而不需要修改MainApp.java和HelloWorld.java。

还要注意：

<?xml version="1.0" encoding="UTF-8"?>  
这一句要顶头写。要不然貌似会报错。

运行程序

当你完成了以上的步骤，我们便可以运行程序了。

右键MainApp.java，点击> Run As > Java Application。也可以在工具栏找到运行按钮。

如果一切正常，输出如下：

Your Message : Hello World!

回顾运作流程

1. 首先会运行main()语句，Spring框架使用ClassPathXmlApplicationContext()首先创建一个容器。
2. 这个容器从Beans.xml中读取配置信息，并根据配置信息来创建bean(也就是对象)，每个bean有唯一的id。
3. 然后通过context.getBean()找到这个id的bean，获取对象的引用。
4. 通过对象的引用调用printMessage()方法来打印信息。

好了，这是你的第一个Spring应用。你已经学会用Eclipse新建Java项目，导入Spring和commons-logging库，编写Java源代码和XML配置文件，并且成功运行了。如果要更改输出，只需要修改XML文件中的value值，而不需要更改Java源文件。

 再看个下面这个例子
 
 http://blog.youkuaiyun.com/zhangerqing/article/details/8546049 
 
 新建一个User类，一个UserDao类以及一个测试类：

public class User {  
    private String name;  
    private int age;  
    private int score;  
    public String getName() {  
        return name;  
    }  
    public void setName(String name) {  
        this.name = name;  
    }  
    public int getAge() {  
        return age;  
    }  
    public void setAge(int age) {  
        this.age = age;  
    }  
    public int getScore() {  
        return score;  
    }  
    public void setScore(int score) {  
        this.score = score;  
    }  
      
    public String toString(){  
        return "tostring from user";  
    }  
}  

package com.importnew;


public class UserDao {  
    private User user;  //这里其实实现了一个更深一层的IOC
      
    public void add(){  
        System.out.println("add from userdao");  
        System.out.println(user.toString());  
    }  
  
    public User getUser() {  
        return user;  
    }  
  
    public void setUser(User user) {  
        this.user = user;  
    }  
  
      
} 

package com.importnew;

import org.springframework.context.ApplicationContext;  
import org.springframework.context.support.ClassPathXmlApplicationContext;  
  
public class DITest {  
  
    public static void main(String[] args) {  
        ApplicationContext atx = new ClassPathXmlApplicationContext("beans.xml");  
        UserDao userDao = (UserDao) atx.getBean("userDao");  
        userDao.add();  
    }  
  
}  

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
 
        <bean id="user" class="com.importnew.User"/>  
	<bean id="userDao" class="com.importnew.UserDao">  
    		<property name="user" ref="user"/>  
	</bean>  
</beans>

在main函数中我们看到编程过程中，主要干了下面的事：

获取bean.xml文件，创建实例对象，直接调用方法。

　　可以看到，我们开发的程序只有“创建实例对象，直接调用方法”，并没有为他进行初始化等工作，就可以直接调用它的方法，获取它的值。其实spring在程序初始化的时候，就会为我们把bean对应的对象注入进来，帮助我们完成初始化，因此我们只要通过一个引用对象，就可以直接调用了。

关于IOC（控制反转\依赖注入） 和AOP（面向切面编程）。。见下面链接

http://www.cnblogs.com/o-andy-o/archive/2012/09/09/2677821.html

其实IOC不是spring专有的，只不过Spring中使用了IOC作为核心

说白了就是spring取得了配置文件然后给生产一个对象注入到你配置想要的地方，也是spring基本的思想，也是spring的核心.

即解析xml。然后根据xml里的内容，采用java的反射机制把对象实例化在容器中。

Spring的IoC容器就是一个实现了BeanFactory接口的可实例化类。事实上，Spring提供了两种不同的容器：一种是最基本的BeanFactory，另一种是扩展的ApplicationContext。BeanFactory 仅提供了最基本的依赖注入支持，而 ApplicationContext 则扩展了BeanFactory ,提供了更多的额外功能。

要清楚属性名和方法的关系，在Java里，get、set就是属性访问器，其对应的方法是getXxx，setXxx，其属性是get或set后面的字符串，然后第一个字符串变小写，那就是其属性了。例如有个属性名称为：name，那么在使用其写属性时一定是这样：把属性名的第一个字母大写，然后在前面加个set。

setName()

可自动添加：

http://jingyan.baidu.com/article/020278118074f61bcd9ce551.html

关于AOP

底层原理都是用的动态代理，分为JDK动态代理和cglib动态代理。

Spring提供了4种实现AOP的方式：
1.经典的基于代理的AOP
2.@AspectJ注解驱动的切面
3.纯POJO切面
4.注入式AspectJ切面

详见

http://blog.youkuaiyun.com/udbnny/article/details/5870076