Spring

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();
    }
}