Spring 框架：
   前无古人，后无来者。它可以包容其他的一切框架。
   a. 什么是Spring框架：
       它是用于简化J2EE业务层开发的轻量级技术框架，他的核心是IOC和AOP
       AOP：编程思想：面向对象: OOP
                           过程
                           服务：   分布式架构：SOA
                           切面的编程: AOP
   b. 编码体验Spring 的强大之处：
       作用：可以把普通的JavaBean魔术般的变为ejb
       对象实例化的不同之处

   c. 引入Spring框架
       Spring.jar : spring1.0-Spring5.0 (屹立不倒，而且越来越牛)
   d. 使用的Spring框架（容器）来构建对象：
       观察：实例化武器Weapon   实例化骑士Knight
       利用Spring框架来实例化这两个对象
       配置 xml/annocation：以前Spring框架都是利用XML来配置
       ，但是现在来看还是标注。并存的，看的懂，其实用xml配置更加灵活
       ，清晰，但是他比较繁琐，而标注比较简单
       beans.xml --- src/main/resources
   e. 在配置文件中配置你需要实例化的JavaBean
           Weapon      Knight
   f. 调用代码实例化Bean

原理：工厂设计模式反射机制
   a.构建BeanFactory
   ApplicationContext：其实就是那个工厂，他是创建Bean的工厂类
   所以Spring框架利用了工厂设计模式，先构造出工厂类，然后工厂来实例化
   他所管理的Bean。
   b. 你要告诉这个工厂我要实例化哪些Bean传一个字符串来告诉工厂实例化的类
       Spring把要实例化的Bean写到了配置文件中，
       然后利用XML的解析技术拿到要实例化累的相关信息，然后实例化相应的Bean
   c. 类只要能参数化了，那么就可以把他写道配置文件，
       然后就可以利用反射技术进行实例化Class.forName("类名")
结论：Spring是个大容器（工厂）他去实例化你想要的Bean，也就是说你把Bean的生命周期纳入到Spring容器中去管理，
       不是我们直接构造出来的，这种技术就交Spring的IOC技术。
       IOC技术：控制反转，也叫（依赖注入），他们说的一回事。
       控制反转：Bean的生命周期不受你控制，而是交给Spring容器管理。
优势： 1. 解耦，完全可以面向接口编程
           在代码中完全不用体现具体的实现类
       2. 类配置在配置文件中，方便修改维护
       Spring容器对Bean的管理，默认是单例的。
       Spring框架用到那些设计模式：工厂模式单例模式代理设计模式
   Spring框架如何利用IOC
       (1). 实现了控制反转，Spring容器能帮我们实例化对象，但是并没有做到DI（依赖注入）//为我们提供依赖注入。

配置Spring
   xml来配置Bean，利用Spring容器来例化Bean（IOC）
   Spring（4.0），Spring支持用标注的形式来配置
   如何利用标注来实现Spring框架的IOC？
   (1). 利用@Componet标注来注解你要纳入到Spring容器管理的类
   (2). 写个配置类，要告诉Spring从哪些地方来找这些Bean

   1. @Component 标注注解组件
   2. @Configuration
       @ComponentScan("day")   注明组件的位置,配置类相当于bean.xml配置文件
       @Autowired   如果Spring容器检测到Weapon类的实例，就会自动注入进来
       @Qualifier("axe")//-- 明确指定这个Bean
   3. Spring容器获取Bean

使用XML构建Spring

1.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.xsd">
    <!-- 武器Bean类 -->
   <bean id="weapon" class="day01.Axe"></bean>
    骑士Bean类
    <bean id="knight" class="day01.Knight">
        骑士Bean的武器属性
            name="weapon" 的值一定要和Knight类的属性值一样
            ref="weapon" 的值一定要和你配置的武器类Bean 的ID 一样
        
        <property name="weapon" ref="weapon"></property>
    </bean> 
    
</beans>

2.Weapon.java

import org.springframework.stereotype.Component;

/**
 * 武器类（接口）
 * @author 
 *
 */
public interface Weapon {
    void fire();
}
//-- 斧头

class Axe implements Weapon{

    @Override
    public void fire() {
        System.out.println("砍两下.....");
    }
    
}

class Gun implements Weapon{
    @Override
    public void fire() {
        System.out.println("枪.....");
    }
}

3.Knight.java

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Component;

/**
 * 骑士类
 * @author 儿子
 *
 */

public class Knight {

    private Weapon weapon;
    
    public Knight() {}
    public Knight(Weapon weapon) {
        this.weapon = weapon;
    }
    
    public void setWeapon(Weapon weapon) {
        this.weapon = weapon;
    }
    
    public void attack() {
        weapon.fire();
    }
    
    
}

4.invoker.java

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

/**
 * 调用者
 * 
 */
public class Invoker {
    public static void main(String[] args) {
        /* 以下的代码是我们传统的构造Bean的方式
        //-- 1. 武器
        Weapon weapon = new Axe();
        //-- 2. 骑士
        Knight knight = new Knight(weapon);
        //-- 3. 骑士发起攻击
        knight.attack();
        //-- 4. 换武器：
           knight.setWeapon(new Gun());
        knight.attack();
        */
        
        //-- 利用Spring框架来构建Bean对象
        //-- 1. 构造Spring容器对象(利用xml文件的配置)
        ApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");
    //-- 2. 通过Spring容器来获取想要的Bean
    Knight knight = (Knight)ctx.getBean("knight");
    //-- 3. 骑士发起攻击
    knight.attack();    
    
    }
}

使用注解构建Spring

1.Weapon.java

import org.springframework.stereotype.Component;

/**
 * 武器类（接口）
 * @author 
 *
 */
public interface Weapon {
    void fire();
}
//-- 斧头
@Component("axe")
class Axe implements Weapon{

    @Override
    public void fire() {
        System.out.println("砍两下.....");
    }
    
}
@Component("gun")
class Gun implements Weapon{
    @Override
    public void fire() {
        System.out.println("枪.....");
    }
}

2.Knight.java

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Component;

/**
 * 骑士类
 * @author 儿子
 *
 */
@Component("knight")
public class Knight {
    @Autowired //- 如果Spring容器检测到Weapon类的实例，就会自动注入进来
    @Qualifier("axe")//-- 明确指定这个Bean
    private Weapon weapon;
    
    public Knight() {}
    public Knight(Weapon weapon) {
        this.weapon = weapon;
    }
    
    public void setWeapon(Weapon weapon) {
        this.weapon = weapon;
    }
    
    public void attack() {
        weapon.fire();
    }
    
    
}

3.Weapon.java

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Component;

/**
 * Spring 容器的配置类，来代替那个Bean.xml文件
 * 1. 类上面使用@Component来注解
 * 2. 在配置类中使用@Bean 标注来注解你要实例化的类
 * @author 
 *
 */
@Configuration
@ComponentScan("day01")    //-- 告诉Spring从哪个包下寻找Component或者Bean
public class BaseConfiguration {
    /*@Bean("a")
    public String A(){        //- 类似于@Component标注
        return "a";
    }
    
    @Bean("foo")
    public Foo foo() {
        return new Foo();
    }*/
}

4.Invoker.java

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

/**
 * 调用者
 * 
 */
public class Invoker {
    public static void main(String[] args) {
        /* 以下的代码是我们传统的构造Bean的方式
        //-- 1. 武器
        Weapon weapon = new Axe();
        //-- 2. 骑士
        Knight knight = new Knight(weapon);
        //-- 3. 骑士发起攻击
        knight.attack();
        //-- 4. 换武器：
        knight.setWeapon(new Gun());
        knight.attack();
        */
        
    
        //-- 1.构造Spring容器
        ApplicationContext ctx = 
                new AnnotationConfigApplicationContext(BaseConfiguration.class);
        //-- 2. 获取Bean
        
        Knight knight = (Knight)ctx.getBean("knight");
//        System.out.println(ctx.toString());
        knight.attack();
        
//        Axe axe = (Axe)ctx.getBean("axe");
//        System.out.println(axe);
//        axe.fire();
    }
}

Spring