bean1单例，Bean2多例的时候

如果想要注入的bean2是不同bean2时，可以用

    类中定义abstract抽象方法，protect abstract Bean2 createBean2();

    配置文件种 原来property标签注入的，改用lookup-method标签注入name制定泪中方法，bean制定注入bean2

1、构造方式注入

    类中有带参数构造方法

    xml中配置bean，子标签constructor-arg标签，配置属性  index、name、type确定构造参数，配置value，ref给属性赋值（ref用用，value基本）

还要简便写法如图，要改一下文件上面头部申明

2、集合类型注入

    类中get/set方法

    xml中配置property标签，标签下子标签list，list下用value/ref标签赋值；set用set标签，下面也用value/ref标签赋值；map用Map标签，entry标签赋值；properties，子标签props子标签prop赋值

Spring实例化bean的三种方式：

1、构造方法实例化Bean

2、静态方法实例化Bean

    BeanFactory类，类中有静态方法，作用实例化Bean

    xml中配置BeanFactory，标签属性中factory-method=类中实例化Bean的静态方法

3、实例化方法实例化Bean

    BeanFactory类，类中有方法，作用实例化Bean

    xml中配置BeanFactory，

    xml中配置bean，bean的属性中factory-bean=factoryBean  ，factory-method=factory中实例化bean的方法

4、Bean的别名

IoC容器约定

Spring通过注解注入Bean

@Autowired：通过该注解实现构造方法注入和set方法注入，可以标识在有参构造方法上、set方法上、属性上。

一、通过方法注入Bean

1：通过有参构造方法注入

步骤1：创建扫描配置类，并添加注解@Configuration、@ComponentScan（value=“路径”）

代码：

@Configuration

@ComponentScan(value="springzhuru")

public class MyConfiguration {

}

步骤2：创建要实例化的Bean，并提供有参的构造方法，并在构造方法上添加注解@Autowired在类上添加@Component。
代码：

@Component

public class MyBean {

private AnotherBean anotherBean;

@Autowired

public MyBean(AnotherBean anotherBean) {

super();

this.anotherBean = anotherBean;

}

SpringIOC注解基本使用（spring2.5后支持注解来管理javaBean）

@Configuration：该注解标识在类上，然后就可以通过AnnotationConfigApplicationContext（***.class）来获取spring上下文环境(相当于xml的功能）。

@Bean：与xml配置文件<bean>标签一个用处，<bean>标签的id相当于获得@Bean(name="Id名")，如果不使用name，Id名为方法名称。

@Component：告知spring管理这个类，还可以通过该注解的value属性指定Bean的Id。

@Controller：被标注在Controller层。

@Service：被标注在Service层。

@Repository：被标注在Dao层

与Spring.xml相比不同点：

1、不用配置xml文件

2、提供一个配置类，并采用注解，来获取Bean

3、获取spring上下文的对象不同，注解使 用AnnotationConfigApplicationContext(***.class)获取spring上下文。

步骤1：提供一个配置类，并在类上添加@Configuration注解，并提供一个返回Bean对象的方法，并在该方法上添加注解。（如果@Bean没指定name属性，则Id为方法名）

步骤2：提供一个要创建的Bean的类。

如何进行简化：当要获取多个Bean时，则要编写多个@Bean注解和获取Bean方法？

步骤1：在配置类中添加@ComponentScan（value=“扫描的路径”）注解。

@ComponentScan（）注解的作用：扫描带有注解@Component的Class，Spring将管理这些Class。

步骤2：Bean的类上加注解@Component，它的Bean的Id是类名的首字母小写的全称，如果不想使用这种方式，则使用@Component（value=“Id名”）。

spring.xml中开启包扫描：<context:component-scan base-package="扫描的包路径"/>

如何给Bean取别名（一个Bean对应多个Id名）？

因为Bean（）注解里的name属性是String类型的数组，所以可以通过它来指定Bean的多个Id。注意：@Component里的value是字符串类型，只能有一个BeanId。

spring.xml给Bean取别名？

<bean id="bean1" name="bean2,bean3" class="..."/>

<alias name="bean1"  alias="bean4"/>

Bean属性继承应用场景：

场景一：ParentClass（属性1,属性2，属性3，get和set方法）

子类1（属性4，属性5） 

子类2（属性6，属性7）

场景2：子类1和子类2没有父类，而是有一些相同的属性。

类1：（属性1，属性2，属性3，属性4，属性5）

类2：（属性1，属性2，属性3，属性6，属性7）

abstract="true"：设置<bean>标签只是定义性的，不会对它进行实例化操作。

parent属性：在Bean的子类bean标签添加，值为父类的Id。

Bean初始化及销毁逻辑处理（在singleton作用域上进行讲解）

Bean初始化——如果需要在Bean实例化时执行一些逻辑，Spring提供了两种方法：（有一个javaBean，该Bean作用，连接数据库，例如session，断开数据库连接，该Bean被创建之后，执行数据库连接的过程）

方法1：bean标签里的init-method属性，该值为Bean的某一方法，Spring实例化时，会调用Bean的该方法。

方法2：让Bean实现InitializingBean接口，Spring在实例化该Bean时，检测到Bean实现了该接口，就会调用该接口所定义的相应方法。

Bean销毁——如果需要在Bean销毁之前执行一些逻辑，有两种方法。

方法1：bean标签里的destory-method属性，该值为Bean的某一方法，Spring销毁该Bean时，会调用Bean的该方法。

方法2：让Bean实现DisposableBean接口，Spring在销毁该Bean时，检测到Bean实现了该接口，就会调用该接口所定义的相应方法。

Bean懒加载概念：

Spring容器会在创建容器时提前初始化Singleton作用域的bean，但是如果Bean被标注了lazy-init=“true”,则该Bean只有在其被需要的时候才会被初始化。（只对singleton作用域的bean有效）

代码：<bean id="bean" class="main.java.com.Bean懒加载.Bean" scope="singleton" lazy-init="true"></bean>

解决多个bean使用懒加载问题：

<beans标签里添加default-lazy-init=“true”>:表示spring配置文件里所有bean都是懒加载模式。

使用场景：

如果某个Bean在程序整个运行周期都可能不会被使用，那么可考虑设定该Bean为懒加载。

优点：尽可能的节省了资源。

缺点：可能会导致某个操作相应操作时间增加。

spring通过xml实现自定义作用域（自定义双例模式作用域）

SimpleThreadScope：Spring内置作用域。

编写自定义作用域：

步骤1：实现Scope接口(org.springframework.beans.factory.config),主要关注实现的get方法和remove方法。

get方法：按照name参数，按照我们自己定义的规则，去返回一个Bean，如果我们定义的规则里，Bean不存在，那么将通过objectFactory去创建一个Bean。

双例模式：一个bean的Id对应两个实例，实现双例模式，需要两个Map集合，Map<String,Object> map1=new HashMap<String,Object>();Map<String,Object> map2=new HashMap<String,Object>();。

springweb上下文环境

request作用域：每次执行request请求调用到bean时会重新实例化bean对象

session作用域：请求session重置后会重新实例化

application作用域：应用重启后会重新实例化

通过Spring的xml文件配置Bean作用域：（Spring默认作用域是Singleton）

1、Singleton作用域（单例模式：通过Spring容器实现单例模式，具有局限性：保证在一个Spring上下文(ApplicationContext）是单例模式，多个AppliactionContext单例模式就失效了。

定义：如果一个<bean>的作用域为Singleton，则该<bean>只会被实例化一次，只有一个Bean会被创建。（每次向Spring上下文（ApplicationContext生命周期存活）请求这个实例时，Spring都会返回同一个实例）。

2、prototype作用域（多例模式）

定义：如果一个<bean>的作用域为prototype，则该<bean>会被实例化多次，有多个Bean会被创建（每次向Spring上下文请求该Bean都会new一个新的实例）。

第一种：通过构造方法注入Bean

#<bean>标签管理class对象。

#bean的构造方法参数标签 constructor-arg。

#index 表示构造方法的第几个参数。

#name 表示构造方法的参数名。

#type 表示对应的参数类型。

#value 表示为参数提供赋值，一般用于String等简单常用对象。

#ref 表示为参数提供赋值，一般是复杂点的依赖其它 class的对象（取bean的id）。

注意：只要通过index、name、type的组合明确表示出构造函数的那一个参数即可，

不一定全用，只用index也可以。

<bean class="com.imooc.spring.ioc.class06.Bean">

<constructor-arg  index="0" name="anotherBean"

type="com.imooc.spring.ioc.class06.AnotherBean">

</constructor-arg> 

</bean>

通过构造方法注入Bean，输出结果：

成功的给属性赋值。 

1、通过构造方法实例化Bean。

步骤1：创建要实例化的类，并提供无参构造方法。

public class Bean {

public Bean(){

System.out.println("Bean被创建了");

}

步骤2：spring.xml中配置

<bean id="bean的唯一标识" class="要实例化bean的路径"></bean>

测试:ApplicationContext context=new ClassPathXmlApplicationContext(spring.xml的路径);

Bean bean=context.getBean("bean",Bean.class);

System.out.println(bean);

2、通过静态方法实例化Bean。（通过Bean2的工厂的静态方法实例化Bean）

步骤1：创建Bean2的工厂Bean2Factory类以及Bean2类，并且提供一个静态、返回值类型为Bean2的方法,返回new Bean2()。

public class Bean2Factory {

public static Bean2 getBean2(){

return new Bean2();

}

}

public class Bean2 {

public Bean2(){

System.out.println("Bean2被创建了。");

}

步骤2：配置Spring.xml

<bean class="Bean2工厂的路径" factory-method="Bean2工厂的静态方法名" id="Bean2工厂的唯一标识"></bean>

测试:

ApplicationContext context=new ClassPathXmlApplicationContext("spring-ioc2.xml");

Bean2 bean=context.getBean("bean2factoryId",Bean2.class);

System.out.println(bean);

3、通过实例方法实例化Bean。（通过Bean2的工厂的实例方法实例化Bean）

步骤1：创建Bean3的工厂Bean3Factory类以及Bean3类，并且提供一个返回值类型为Bean3的方法，方法返回new Bean3()。

public class Bean3Factory {

public  Bean3 getBean3(){

return new Bean3();

}

}

public class Bean3 {

public Bean3(){

System.out.println("Bean3被创建了。");

}

}

步骤2：配置Spring.xml

<bean class="main.java.com.imooc2.Bean3Factory" id="bean3Factory"></bean>

<bean class="main.java.com.imooc2.Bean3" factory-bean="bean3Factory" factory-method="getBean3" id="bean3"></bean>

给bean取别名：有类Bean1，并且通过bean标签实例化Bean1，给Bean1的实例取多个名字。

例如：方式一：bean标签里添加name属性

<bean id="bean" class="main.java.com.imooc1.Bean" name="bean1_1,bean1_2"></bean>

           方式二:添加<alias>标签

<bean id="bean" class="main.java.com.imooc2.Bean1" name="bean1_1,bean1_2"></bean>

<alias name="bean" alias="bean1_3"/><!-- alias只支持一个别名 -->

org.springframework.beans.factory.config