Spring（1）【IOC,DI,bean】

Spring:
Spring是一个开源框架，也是一个轻量级框架；Spring是为简化企业应用而生；Spring是一个IOC(di)和AOP容器框架；在IOC和AOP的基础上Spring可以整合各种优秀框架；
实例化Spring容器：

ApplicationContext acx = new ClassPathXmlApplicationcationContext("beans.xml")

IOC:
Inversion of control:控制反转
所谓控制反转就是程序本身不负责对象的创建和维护，对象的创建和维护由外部容器负责，这样控制权就由应用转移到了外部容器，控制权的转移就是所谓的控制反转；
优势：程序中需要实例化那个类，不是写死的而是由配置文件决定的；

<bean id="t" class="com.xaeduask.b_interface.Car"></bean>

//声明一个接口
public inetrface Toy{
    pubic void play();
}
//两个实现类
class gun implements Toy{
    pubic void play(){
        System.out.print("biu biu biu .....")
    }
} 
class gun implements Toy{
    pubic void play(){
        System.out.print("biu biu biu .....")
    }
} 
//测试类中的代码
ApplicatinContext ac = new ClassPathXmlApplicationContext("主配置文件路径")
Toy t = (Toy)ac.getBean("t")
t.play();

三种创建Bean的方法
1：使用bean元素创建

其实用的是User类的无参构造器

<bean id="u" class="com.xaeduask.c_createbean.User">
    </bean>

//创建一个生成User对象的工厂，静态的和普通的
public Class UserFactory{
public static User getUser(){
System.out.print(“UserFactory.getUser（）….”)
return new User();
}
public static User getUser2(){
System.out.print(“UserFactory.getUser2（）….”)
return new User();
}
}
2：使用静态工厂生成bean

<bean id ="u" class="...UserFactory" factory-method="getUser"></bean>

3:使用普通工厂

<bean id ="uf" class="...UserFactory"></bean>
<bean id="u2" factory-bean="uf" factory-method="getUser2"></bean>

Bean中的Scope属性(bean的作用域)
1.singleton 表示bean是单例的，（默认值）
2.prototype,表示多例，每次获取U的时候都会创建新的对象
（
ssh(struts2,spring,hibernate,必须使用多例)
ssm(springMVC,spring,mybatis,必须使用单例)
）
3.request, 表示bean在同一次请求范围中，是一个。多次请求，就实例化多个。
4. session, 表示bean在同一次会话范围中，是一个。多次会话，就实例化多个。
bean 的生命周期
当scope是Singleton的时候
1.在spring ioc容器在加载applicationContext的时候就会实例化bean;
2.在bean被实例化后，就调用bean元素的init-method属性指定的方法，该方法在bean 的整个生命周期中只执行一次；
3.在每次调用bean的时候都调用bean的方法；
4.在关闭Spring ioc时，就调用destory-method指定的方法，该方法在bean 的整个生命周期中只执行一次；
当scope是prototype时
1.在每次从容器中获取bean的时候会实例化bean；
2.在bean被实例化后，就调用bean元素的init-method属性指定的方法，该方法在bean 的整个生命周期中只执行一次；
3.在每次调用bean的时候都调用bean的方法；
4.在关闭Spring ioc时，不会调用destory-method指定的方法；
DI(依赖注入）
1.利用实体类中的Setter给属性注入值

    <bean id="u" class="...User">
        <property name="id" value="100"></property>
        <property name="name" value="张三"></property>    
    </bean>

2.利用有参构造器给属性注入值

<bean id="u2" class="...User">
        <constructor-arg value="200"></constructor-arg>
        <constructor-arg name="李四"></constructor-arg>
        <constructor-arg ref="c"></constructor-arg>
    </bean>

3.注入复合类型的属性值
(1)

   <bean id="c" class="...User">
        <property name="brand" value="BMW"></property>
        <property name="color" value="red"></property>  
    </bean>
    <bean id="u3" class="...User">
        <property name="id" value="600"></property>
        <property name="name" value="张三"></property>
        <property name="car" ref="c"></property>
    </bean>

(2)

<bean id="u4" class="com.xaeduask.e_di.User">
        <property name="id" value="400"></property>
        <property name="name" value="zzz"></property>
        <property name="car">
            <bean class="com.xaeduask.e_di.Car">
                <property name="brand" value="AUDI"></property>
                <property name="color" value="黑色"></property>
            </bean>
        </property>
    </bean>

集合属性的DI

    private List<String> list;
    private Set<String> set;
    private Map<String, String> map;
    private String[] strs;

<property name="list">
            <list>
                <value>1</value>
                <value>2</value>
                <value>3</value>
                <value>4</value>
                <value>5</value>
            </list>
        </property>
        <property name="set">
            <set>
                <value>z</value>
                <value>a</value>
                <value>h</value>
                <value>b</value>
                <value>c</value>
            </set>
        </property>
        <property name="map">
            <map>
                <entry key="aa" value="哈哈" />
                <entry key="bb" value="嘻嘻" />
                <entry key="cc" value="呵呵" />
            </map>
        </property>
        <property name="strs">
            <array>
                <value>艾伦</value>
                <value>沈腾</value>
                <value>马力</value>
            </array>
        </property>

便利Map的方式：

Map<String,String> map = f.getMap();
    Set<Entry<String, String>> set = map.entrySet();
        Iterator<Entry<String, String>> it = set.iterator();
        while(it.hasNext()) {
        Entry<String,String> entry = it.next();
        System.out.println(entry.getKey() + "---" + entry.getValue());
    }

依赖注入depend

<bean id="c" class="com.xaeduask.f_depends.Car" depends-on="d">
</bean>
<bean id="d" class="com.xaeduask.f_depends.Door" depends-on="w">
</bean>
<bean id="w" class="com.xaeduask.f_depends.Window">
</bean>

annotation注解
两种方式，一种是ioc容器通过xml文件读取bean实例化，还有一种是通过扫描包实现管理（加注解@component）
@component:被ioc容器管理
@component(“abc”):起别名
@value:给属性赋值
@autowied针对符合类型自动匹配
1.先按类型匹配再按名字匹配
@Resource
1.先按名字找找不到再按类型找

@Component("abc")
public class User implements Serializable{
    @Value("222")
    private Integer id;
    @Value("叶孤城")
    private String name;
     @Autowired
     private Car car;
     }

复合类car

public class car{
    @value("BMW")
    private String brand;
    @value("red")
    private String color;
    }