Spring Framework 5

如何学习Spring框架

了解Spring的出现是为了解决什么问题！！！
了解Spring的出现是为了解决什么问题！！！
了解Spring的出现是为了解决什么问题！！！
学习Spring的两个核心概念以及其实现方式（IoC和AOP）

Spring 控制反转 （IoC）

Spring（IOC:控制反转）：从前需要我们自己做的事，现在要交给方法的调用者来处理(Sprig的IOC容器来处理)

如何实现自己的IOC容器

创建beans.xml

解析XML的方式有几种：
XML的解析方式分为四种：1、DOM解析；2、SAX解析；3、JDOM解析；4、DOM4J解析。其中前两种属于基础方法，是官方提供的平台无关的解析方式；后两种属于扩展方法，它们是在基础的方法上扩展出来的，只适用于java平台。
我们可以使用JDOM来解决以上问题

在pom.xml文件中添加依赖

  4.0.0
  com.foreknow
  foreknow_spring
  0.0.1-SNAPSHOT
  war
  foreknow_spring
  
    
    
        jdom
        jdom
        1.0
    
  

创建接口BeanFacory

package com.foreknow.spring;

public interface BeanFactory {
    /**
     * 根据key获取到value
     * @param id(key)
     * @return Object
     */
    public Object getBean(String id);
}

创建实现类ClassPathXmlApplicationContext

package com.foreknow.spring;

import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.jdom.Document;
import org.jdom.Element;
import org.jdom.input.SAXBuilder;

import com.foreknow.dao.UserDAO;
import com.foreknow.model.User;
import com.foreknow.service.UserService;
import com.foreknow.service.impl.UserServiceImpl;

public class ClassPathXmlApplicationContext implements BeanFactory {
    //创建一个工厂容器
    private Map beans = new HashMap<>();
    //使用构造器来解析beans.xml文件
    public ClassPathXmlApplicationContext() throws Exception{
        //1.创建一个解析器
        SAXBuilder saxBuilder = new SAXBuilder();
        //2.解析并读取beans.xml文件 构造Document文档对象
        Document document = saxBuilder.build(this.getClass().getClassLoader().getResourceAsStream("beans.xml"));
        //3.获取到根节点
        Element element = document.getRootElement();
        //4.获取到子节点
        List list = element.getChildren("bean");
        for(int i = 0;i)e.getChildren("property")){
                String name = propertyElement.getAttributeValue("name");//userDAO
                String bean = propertyElement.getAttributeValue("bean");//u
                //从Map中获取到UserDAOImpl对象
                Object beanObject = beans.get(bean);
                //模拟调用public void setUserDAO(UserDAO userDAO)
                String methodName = "set"+ name.substring(0, 1).toUpperCase()+name.substring(1);
                System.out.println(methodName);
                //需要java中的反射机制来自动调用setUserDAO方法
                //o.getClass().getMethod获取到UserServiceImpl对象中的某一个方法setUserDAO
                //beanObject.getClass().getInterfaces()[0]获取到方法的参数UserDAO
                Method method = o.getClass().getMethod(methodName, beanObject.getClass().getInterfaces()[0]);
                //方法的调用  o:UserServiceImpl对象中的setUserDAO(UserDAO userDAO)方法
                //beanObject:调用此方法时需要传入的参数  UserDAOImpl对象
                method.invoke(o, beanObject);
            }
        }
    }

    @Override
    public Object getBean(String id) {
        // TODO Auto-generated method stub
        return beans.get(id);
    }
    
    public static void main(String[] args) {
    
            try {
//              UserServiceImpl userService = new UserServiceImpl();
//              BeanFactory beanFactory = new ClassPathXmlApplicationContext();
//              UserDAO userDAO = (UserDAO)beanFactory.getBean("u");//UserDAOImpl对象
//              userService.setUserDAO(userDAO);
//              userService.addInfo(new User());
                
                BeanFactory beanFactory = new ClassPathXmlApplicationContext();
                //从工厂容器中获取到UserService对象
                UserService userService = (UserService)beanFactory.getBean("userService");
                userService.addInfo(new User());
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        
    }

}

什么是IOC

IOC—Inversion of Control，即“控制反转”，不是什么技术，而是一种设计思想。在Java开发中，IOC意味着将你设计好的对象交给容器控制，而不是传统的在你的对象内部直接控制。如何理解好IOC呢？理解好IOC的关键是要明确“谁控制谁，控制什么，为何是反转（有反转就应该有正转了），哪些方面反转了”，那我们来深入分析一下：
　　●谁控制谁，控制什么：传统Java SE程序设计，我们直接在对象内部通过new进行创建对象，是程序主动去创建依赖对象；而IOC是有专门一个容器来创建这些对象，即由IOC容器来控制对 象的创建；谁控制谁？当然是IOC容器控制了对象；控制什么？那就是主要控制了外部资源获取。
　　●为何是反转，哪些方面反转了：有反转就有正转，传统应用程序是由我们自己在对象中主动控制去直接获取依赖对象，也就是正转；而反转则是由容器来帮忙创建及注入依赖对象；为何是反转？因为由容器帮我们查找及注入依赖对象，对象只是被动的接受依赖对象，所以是反转；哪些方面反转了？依赖对象的获取被反转了。

IOC能做什么

IOC 不是一种技术，只是一种思想，一个重要的面向对象编程的法则，它能指导我们如何设计出松耦合、更优良的程序。传统应用程序都是由我们在类内部主动创建依赖对象，从而导致类与类之间高耦合，难于测试；有了IOC容器后，把创建和查找依赖对象的控制权交给了容器，由容器进行注入组合对象，所以对象与对象之间是 松散耦合，这样也方便测试，利于功能复用，更重要的是使得程序的整个体系结构变得非常灵活。
　　其实IOC对编程带来的最大改变不是从代码上，而是从思想上，发生了“主从换位”的变化。应用程序原本是老大，要获取什么资源都是主动出击，但是在IOC/DI思想中，应用程序就变成被动的了，被动的等待IOC容器来创建并注入它所需要的资源了。
　　IOC很好的体现了面向对象设计法则之一—— 好莱坞法则：“别找我们，我们找你”；即由IOC容器帮对象找相应的依赖对象并注入，而不是由对象主动去找。

IOC和DI的关系

IOC和DI由什么关系呢？其实它们是同一个概念的不同角度描述，由于控制反转概念比较含糊（可能只是理解为容器控制对象这一个层面，很难让人想到谁来维护对象关系），所以2004年大师级人物Martin Fowler又给出了一个新的名字：“依赖注入”，相对IoC 而言，“依赖注入”明确描述了“被注入对象依赖IoC容器配置依赖对象”。
DI—Dependency Injection，即“依赖注入”：组件之间依赖关系由容器在运行期决定，形象的说，即由容器动态的将某个依赖关系注入到组件之中。依赖注入的目的并非为软件系统带来更多功能，而是为了提升组件重用的频率，并为系统搭建一个灵活、可扩展的平台。通过依赖注入机制，我们只需要通过简单的配置，而无需任何代码就可指定目标需要的资源，完成自身的业务逻辑，而不需要关心具体的资源来自何处，由谁实现。
　　理解DI的关键是：“谁依赖谁，为什么需要依赖，谁注入谁，注入了什么”，那我们来深入分析一下：
　　●谁依赖于谁：当然是应用程序依赖于IOC容器；
　　●为什么需要依赖：应用程序需要IOC容器来提供对象需要的外部资源；
　　●谁注入谁：很明显是IOC容器注入应用程序某个对象，应用程序依赖的对象；
　　●注入了什么：就是注入某个对象所需要的外部资源（包括对象、资源、常量数据）。

Spring配制

声明一个简单的bean

第一个例子：
首先设置一个接口Perofrmance表示参赛者。

package com.moonlit.myspring;
public interface Performer {    
      void perform() throws PerformanceException;
}

创建一个Juggler(杂技师)类继承Performer表示参赛者是杂技师。

package com.moonlit.myspring;
public class Juggler implements Performer {    
private int beanBags = 3;    
public Juggler() {
    }    
    public Juggler(int beanBags) {        
    this.beanBags = beanBags;
    }    
    public void perform() throws PerformanceException {
        System.out.println("JUGGLING " + beanBags + " BEANBAGS");
    }
}

在spring-idol.xml配置文件中定义一个名为duke的bean，他对应Juggler类（把xml文件放在类路径下）。

测试代码：

package com.moonlit.practice;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.moonlit.myspring.PerformanceException;
import com.moonlit.myspring.Performer;
public class FirstBean {    
public static void main(String[] args) throws PerformanceException {
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-idol.xml");
        Performer performer = (Performer) context.getBean("duke");
        performer.perform();
    }
}

运行结果如下：

 JUGGLING 3 BEANBAGS

理解：首先定义了一个接口Performer，然后写了一个类Juggler继承自Peformer,Juggler有一个私有成员变量beanBags,他的默认值是3，然后Juggler实现了Performer的perform方法，方法的输出带有beanBags的数量。
然后在测试的程序中，通过ApplicationContext类型对象加载了spring-idol.xml文件的内容，而在xml文件中定义了名为"duke"的bean，然后刚好就用到了。
然后bean返回的是一个Juggler，所以将

Performer performer = (Performer) context.getBean("duke");

改成

Juggler performer = (Juggler) context.getBean("duke");

也是可以的，但是在这里想看的效果是通过application context返回的是不是一个Juggler，因为通过输出的结果就可以知道了，所以这里用(Performer)，对中输出的效果显示bean对应的Performer真的是一个Juggler，这就是通过xml定义一个bean并通过application context获得这个bean对象的整个过程。

构造器注入

之前讲到的名为"duke"的bean有一个私有成员变量beanBags代表这个杂技师bean的一次性能够抛出的最多的数量，Juggler有一个构造函数，构造函数的第一个参数（这里只有一个参数）beanBags是一个整型的值，用于传递给Juggler的私有成员变量beanBags。
构造器注入的方法是：在bean中添加一个constructor-arg（如果构造函数的参数有两个，那就添加两个constructor-arg）。
在spring-idol.xml中修改bean "duke"如下：

再次运行FirstBean程序，输出如下：

JUGGLING 15 BEANBAGS

可以看到通过构造器诸如已经把duke的beanBags改为了15。
构造函数中的参数可能不是一个基础类型的变量，而可能是一个变量，这个时候只要把constructor-arg的value改成ref即可，ref对应的值需要被声明称一个bean元素。
使用一个会唱歌的杂技师PoeticJuggler类来演示，PoeticJuggler继承自Juggler，它具有一个Poem类型的私有成员变量poem，代表他要朗诵的诗歌。
Poem类：

package com.moonlit.myspring;
public interface Poem 
{    
  void recite();
}

定义一首名为Sonnet29的类用于表示名为一首sonnet29的诗：http://shakespeare-online.com/sonnets/29.html
Sonnet29实现了Poem接口。

package com.moonlit.myspring;
public class Sonnet29 implements Poem {    
private static String[] LINES = {
            "When, in disgrace with fortune and men's eyes,",
            "I all alone beweep my outcast state,",
            "And trouble deaf heaven with my bootless cries,",
            "And look upon myself, and curse my fate,",
            "Wishing me like to one more rich in hope,",
            "Featur'd like him, like him with friends possess'd,",
            "Desiring this man's art and that man's scope,",
            "With what I most enjoy contented least;",
            "Yet in these thoughts myself almost despising,",
            "Haply I think on thee, and then my state,",
            "Like to the lark at break of day arising",
            "From sullen earth, sings hymns at heaven's gate;",
            "For thy sweet love remember'd such wealth brings",
            "That then I scorn to change my state with kings.",
    };    

    public Sonnet29() {
    }   

     public void recite() {        
     for (String line : LINES) 
            System.out.println(line);
    }
}

有了Poem和他的一个实现类Sonnet29之后，开始来写PoeticJuggler，他继承自Juggler并且有一个Poem类型私有成员变量poem。

package com.moonlit.myspring;
public class PoeticJuggler extends Juggler {    
private Poem poem;    
public PoeticJuggler(Poem poem) {        
super();        
this.poem = poem;
    }    
    public PoeticJuggler(int beanBags, Poem poem) {        
    super(beanBags);        
    this.poem = poem;
    }    
    public void perform() throws PerformanceException {        
    super.perform();
        System.out.println("While reciting...");
        poem.recite();
    }
}

并且，需要在xml文件中声明Sonnet29和PoeticJuggler类对应的bean。

可以看到，"poeticDuke"使用了两个constructor-arg来声明参数，第一个参数使用value，第二个参数使用ref，Sonnet29类型的bean--"connet29"。
使用测试程序查看效果:

package com.moonlit.practice;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.moonlit.myspring.PerformanceException;
import com.moonlit.myspring.Performer;

public class FirstBean {
    public static void main(String[] args) throws PerformanceException {
        ApplicationContext context = new ClassPathXmlApplicationContext(
                "spring-idol.xml");
        Performer performer = (Performer) context.getBean("duke");
        performer.perform();
    }
}

程序输出如下：

JUGGLING 16 BEANBAGS
While reciting...
When, in disgrace with fortune and men's eyes,
I all alone beweep my outcast state,
And trouble deaf heaven with my bootless cries,
And look upon myself, and curse my fate,
Wishing me like to one more rich in hope,
Featur'd like him, like him with friends possess'd,
Desiring this man's art and that man's scope,
With what I most enjoy contented least;
Yet in these thoughts myself almost despising,
Haply I think on thee, and then my state,
Like to the lark at break of day arising
From sullen earth, sings hymns at heaven's gate;
For thy sweet love remember'd such wealth brings
That then I scorn to change my state with kings.

理解：可以通过构造器注入来模拟构造函数传入的参数，通过constructor-arg value="XX"传递一个基本类型的参数XX，通过constructor-arg ref="XX"传递一个bean。

注入各种bean属性

这里通过一个MoonlightPoet类来演示了注入Bean属性property的效果。

package com.moonlit.myspring;

import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.util.Properties;

public class MoonlightPoet {
    private String name;
    private int age;
    private Poem poem;
    private List list;
    private Map map;

    public void perform() {
        System.out.println("name : " + name);
        System.out.println("age : " + age);
        poem.recite();
        for (String val : list) 
            System.out.println("in list : " + val);
        for (Entry entry : map.entrySet())
            System.out.println("in map : " + entry.getKey() + " -- " + entry.getValue());
    }
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext(
                "spring-idol.xml");
        MoonlightPoet moonlightPoet = (MoonlightPoet) context.getBean("moonlightPoet");
        moonlightPoet.perform();
    }
    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 Poem getPoem() {
        return poem;
    }
    public void setPoem(Poem poem) {
        this.poem = poem;
    }
    public List getList() {
        return list;
    }
    public void setList(List list) {
        this.list = list;
    }
    public Map getMap() {
        return map;
    }
    public void setMap(Map map) {
        this.map = map;
    }

}

该bean在xml文件中定义如下：

    
    
    
    
      
        hello
        world
        
      
    
    
      
    

输出结果：

name : moonlit
age : 22
When, in disgrace with fortune and men's eyes,
I all alone beweep my outcast state,
And trouble deaf heaven with my bootless cries,
And look upon myself, and curse my fate,
Wishing me like to one more rich in hope,
Featur'd like him, like him with friends possess'd,
Desiring this man's art and that man's scope,
With what I most enjoy contented least;
Yet in these thoughts myself almost despising,
Haply I think on thee, and then my state,
Like to the lark at break of day arising
From sullen earth, sings hymns at heaven's gate;
For thy sweet love remember'd such wealth brings
That then I scorn to change my state with kings.
in list : hello
in list : world
in map : key1 -- value1
in map : key2 -- value2
in map : key3 -- value3

理解：
注入简单值：

其中XX是变量名，YY是值。
引用其他Bean：

其中XX是变量名，YY是引用的bean的id。
装配List：

YY
或者


其中XX是变量名，YY是值，ZZ是引用的bean。
装配Map：

因为map的key和value可以对应一个基础类型的值，也可以对应一个bean，所以key,value对应值，key-ref,value-ref对应bean。
使用Spring的命名空间p装配属性
可以在beans中添加

xmlns:p="http:www.springframework.org/schema/beans"

来使用p:作为元素所有属性的前缀来装配Bean的属性。用法如下：

-ref后缀作为一个标识来告知Spring应该装配一个引用而不是字面值。

自动装配bean属性

Spring提供了四种类型的自动装配策略：
byName – 把与Bean的属性具有相同名字(或者ID)的其他Bean自动装配到Bean的对应属性中。
byType – 把与Bean的属性具有相同类型的其他Bean自动装配到Bean的对应属性中。
constructor – 把与Bean的构造器入参具有相同类型的其他Bean自动装配到Bean的对应属性中。
autodetect – 首先使用costructor进行自动装配。如果失败，再尝试使用byType进行自动装配。
这里以关羽和青龙偃月刀为例： 首先定义一个武器接口Weapon：

package com.moonlit.myspring;

public interface Weapon {    
    public void attack();
}

然后定义一个Weapon接口的实现Falchion类:

package com.moonlit.myspring;

public class Falchion implements Weapon {    
public void attack() {
        System.out.println("falcon is attacking!");
    }
}

定义一个英雄接口Hero：

package com.moonlit.myspring;

public interface Hero {    
    public void perform();
}

然后定义一个Hero接口的实现Guanyu类（代表关羽）：

package com.moonlit.myspring;

public class GuanYu implements Hero {    

    private Weapon weapon;    
    public void perform() {
        System.out.println("GuanYu pick up his weapon.");
        weapon.attack();
    }    
    public Weapon getWeapon() {        

        return weapon;
    }    

    public void setWeapon(Weapon weapon) {        

        this.weapon = weapon;
    }
}

在不涉及自动装配的情况下，想要通过Spring的DI将Fachion类对象注入到Guanyu类的weapon属性中，可以新建一个xml文件（这里取名为spring-idol.xml）并在里面填写：
spring-idol.xml:

其中最主要的内容就是两个bean的声明部分：

第一个bean标签定义了一个Falchion类型的bean，第二个bean标签中将第一个bean作为weapon的值装配到了weapon属性中。 然后可以写一个测试程序来查看效果：

package com.moonlit.practice;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.moonlit.myspring.Hero;

public class AutowirePractice {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-idol.xml");
        Hero guanyu = (Hero) context.getBean("guanyu");
        guanyu.perform();
    }
}

输出结果如下：

GuanYu pick up his weapon.
falcon is attacking!

到目前为止还没有涉及到自动装配的内容，接下来开始讲述自动装配的内容。

byName自动装配

改变spring-idol.xml中bean声明内容的形式如下：

得到一样的结果。
将Falchion类的id去了一个和Guanyu类的属性weapon一样的名字，并且在guanyu bean中添加了autowire="byName"用于指明装配类型是byName自动装配。这个时候guanyu bean就是在上下文中找名为weapon的bean装配到他自己的weapon属性中。

byType自动装配

改变spring-idol.xml中bean声明内容的形式如下：

得到一样的结果。
这里已经不用关注Falchion类对应的bean的id是什么了，因为已经定义guanyu bean的autowire属性为"byType"。这个时候guanyu bean会在上下文中寻找和weapon具有相同类型的类对应的bean。
因为Guanyu类的weapon实现Weapon借口，整个上下文中目前只有一个Weapon接口的实现Falchion类，所以以"byType"类型就检测到了falchion bean并将其注入到了guanyu bean的weapon属性中。
但是也会出现一种情况就是检测的时候可能会出现多个相同type的bean，这个时候就不知道要装配那个了。比如，在新建一个实现Weapon接口的方天画戟类HalBerd：

package com.moonlit.myspring;

public class Halberd implements Weapon {    

    public void attack() {
        System.out.println("halberd is attacking!!!");
    }
}

并且在xml文件中声明一个新的halberd bean：

在这种情况下就会出错，因为有两个bean满足byType的结果。
这个时候有两种解决办法：
第一种方法是将其中一个bean的primary属性设为false，比如：将方天画戟falchion bean的primary属性设为true，以防冠以使用方天画戟（很好奇吕布死了之后，赤兔马归关羽了，方天画戟去哪里了）：

输出结果如下：

GuanYu pick up his weapon.
halberd is attacking!!!

从输出结果中可以看到，关羽没有使用青龙偃月刀，而是使用方天画戟进行攻击了。

primary的默认属性是false。
第二种方法是设置其中一个bean的autowire-candidate属性为false，比如：将方天画戟的autowire-candidate属性设为false：

这个时候测试程序的输出如下：

GuanYu pick up his weapon.
falcon is attacking!

可以看到这个时候关羽又重拾了青龙偃月刀。可以看到，当halberd bean的autowire-candidate属性设为false时，他将不会作为自动装配的竞选bean之一，这个时候虽然halberd的primary属性为true，但是halberd bean没有参与自动装配的竞选，所以自动装配到了falchion。
这种感觉就好像：“隔壁村李小花觊觎已久，但是一个要成为海贼王的男人，于是拒绝了她……最终她嫁给了隔壁老王，过上了幸福的生活”。

使用注解装配bean

使用@Autowired注解
从Spring2.5开始，最有趣的一种装配Spring Bean的方式是使用注解自动装配Bean的属性。
Spring默认禁用注解装配，最简单的启用方式是使用Spring的context命名空间配置中的元素，如下所示：

继续上一节的例子，在xml文件中定义两个bean：falchion bean和guanyu bean，为了实现@Autowired自动装配，在GuanYu类中的setWeapon()方法前添加了@Autowired注解，如下：
GuanYu.java:

package com.moonlit.myspring;
import org.springframework.beans.factory.annotation.Autowired;
public class GuanYu implements Hero {    

   @Autowired   
    private Weapon weapon;    
    public void perform() {
        System.out.println("Guan Yu pick up his weapon.");
        weapon.attack();
    }    
    public Weapon getWeapon() {        

        return weapon;
    }

    public void setWeapon(Weapon weapon) {        

        this.weapon = weapon;
    }
}

通过基于注解的方式，可以不用在xml文件中为guanyu bean添加autowire属性了。
spring-idol内部的代码：

@Autowired注解存在一个限制：
匹配多个Bean
限定歧义性的依赖
有可能存在多个bean满足装配条件，比如，这里，falchion bean和halberd bean都满足装配到guanyu bean的weapon属性中的条件。此时如果只是用@Autowired注解的话就会出问题，才@Autowired注解下添加@Qualifier注解如下：

    @Autowired
    @Qualifier("falchion")    
    private Weapon weapon;

就会将falchion bean装入到weapon中。
如上所示，@Qualifier注解将尝试注入ID为falchion的Bean。
除了通过Bean的ID来限定，也可以给Bean添加一个qualifier属性，通过这个qualifier属性来获得限定，如：
给halberd bean添加一个qualifier，值为"weaponOfGuanYu"：

然后对GuanYu类weapon类的注解如下：

    @Autowired
    @Qualifier("weaponOfGuanYu")    
    private Weapon weapon;

输出如下：

Guan Yu pick up his weapon.
halberd is attacking!!!

可以看出，@qualifier降低了@Autowired的匹配范围，最终筛选得到了halberd bean装入weapon属性。
这里的元素限定了方天画戟（halberd）Bean是关羽使用的武器（weaponOgGuanYu）。除了可以在XML中指定qualifier，还可以使用Qualifier类来标注Halberd类：

package com.moonlit.myspring;

import org.springframework.beans.factory.annotation.Qualifier;

@Qualifier("weaponOfGuanYu")
public class Halberd implements Weapon {    
public void attack() {
        System.out.println("halberd is attacking!!!");
    }
}

程序运行将得到相同的结果。
即使有助于完全消除Spring配置文件中的元素，但是还是不能完全消除，仍然需要使用元素显示定义Bean。因此元素出现了，它除了完成一样的工作，还允许Spring自动检测Bean和定义Bean。这就意味着不使用元素，Spring应用中的大多数（或者所有）Bean都能够自动实现定义和装配。

自动检测

为了配置Spring自动检测，需要使用元素来代替元素：

元素会扫描指定的包以及所有子包，并查找出能够自动注册为Spring Bean的类。base-package属性标示了元素所扫描的包。
为自动检测标注Bean
默认情况下，查找使用构造型（stereotype）注解所标注的类，这些特殊的注解如下：
类型 说明
@component 通用的构造型注解，标示该类为Spring 组件。
@Controller 标识将该类定义为Spring MVC controller。
@Repository 标识将该类定义为数据仓库（例如：Dao层）。
@Service 标识将该类定义为服务（例如：Service层）。

效果相同,都是告诉Spring框架在启动时就初始化对象，但是语义不同

@component（"guanyu"）
  ApplicationContext applicationContext
                = new ClassPathXmlApplicationContext("spring.xml");

        Hero hero = (Hero)applicationContext.getBean("guanyu");
        hero.perform();

springAOP

首先创建一个狗类的接口

package com.foreknow.proxy;
/**
 * 创建一个狗类的接口
 * @author Administrator
 *
 */
public interface Dog {
    public void info();
    public void run();
}

狗类的实现类

package com.foreknow.proxy;

import javax.sound.midi.MidiDevice.Info;

public class GouhuiImpl implements Dog {

    @Override
    public void info() {
        System.out.println("Info......");   
    }

    @Override
    public void run() {
        System.out.println("run......");
    }
}

定义一个拦截器

package com.foreknow.proxy;
/**
 * 拦截器
 * 拦截某一个方法后要在之前或之后的操作方法
 * @author Administrator
 *
 */
public class DogInterceptor {
    public void method1() {
        System.out.println("mothod1");
    }
    public void method2() {
        System.out.println("method2");
    }
}

创建一个工厂类

package com.foreknow.proxy;

import java.lang.reflect.Proxy;

/**
 * 创建一个工厂类
 * Proxy它是在程序运行时生成的类。当然Proxy不会代替你去做实际的工作，是由动态代理类ProxyHandler完成实际的工作
 * @author Administrator
 *
 */
public class MyProxyFactory {
    public static Object getProxy(Object obj) {
        ProxyHandler h = new ProxyHandler();
        //设置目标对象
        h.setTarget(obj);
        //loader - 定义代理类的类加载器
        //interfaces - 代理类要实现的接口列表
        //h - 指派方法调用的调用处理程序
        return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), h);
    }
}