代码应用场景1，属性继承父类

初始化后和销毁前的执行方法的配置的文件

初始化bean之后，和销毁之前的方法

bean 的 销毁

需要在bean 实例化执行一些逻辑

how？怎么使用懒加载

what？懒加载概念

通过注解实现Bean的初始化和销毁的逻辑处理（三种方式）

@PostConstruct:自定义初始化方法的标签。

@PreDestroy：自定销毁方法的标签。

方式一：Bean类实现InitializingBean、DisposableBean,并实现afterPropertiesSet()和destroy()。

代码：

@Component(value="bean2")

public class Bean2 implements InitializingBean,DisposableBean {

@Override

public void destroy() throws Exception {

System.out.println("Bean的销毁逻辑方法执行了");

}

@Override

public void afterPropertiesSet() throws Exception {

System.out.println("Bean的初始化逻辑方法执行了");

}

}

测试：

@Test

public void test(){

AbstractApplicationContext ac=new AnnotationConfigApplicationContext(Configuration2.class);

Bean2 bean=ac.getBean("bean2",Bean2.class);

System.out.println(bean);

ac.close();

}

结果：

Bean的初始化逻辑方法执行了

springinit_destory.Bean2@46a7cbfd

Bean的销毁逻辑方法执行了

方式二：不用实现接口，自定义方法，初始化方法添加@PostConstruct

销毁方法添加@PreDestroy。

@Component(value="bean2")

public class Bean2 {

@PostConstruct

public void onInit(){

System.out.println("Bean的初始化逻辑方法执行了");

}

@PreDestroy

public void destory(){

System.out.println("Bean的销毁逻辑方法执行了");

}

}

方式三：Bean的管理不通过@Component，而是通过@Bean，提供方法管理，Bean里提供的初始化和销毁方法不用添加注解，而是通过@Bean（initMethod=“初始化方法名”destroyMethod=“销毁方法名”）。

代码：

@Configuration

public class Configuration2 {

@Bean(initMethod="onInit",destroyMethod="destory",name="bean2")

public Bean2 bean(){

return new Bean2();

}

}

通过注解开启Bean的懒加载

懒加载：创建spring上下文时，并不会实例化Bean，而是在获取Bean时，才去实例化Bean。

步骤1：创建配置扫描文件，并添加注解@Configuration,@ComponentScan（“路径”）,这种在@Component下添加注解@Lazy,也可以不添加扫描注解，可以提供一个返回Bean实例的方法，并在方法上添加@Bean注解，通过这种实现懒加载，则在@Bean下添加注解@Lazy。

@Configuration

@ComponentScan("springlazy")

public class Configuration1 {

@Bean(name="bean2")

@Lazy

public Bean1 bean(){

return new Bean1();

}

}

步骤2：Bean类代码。

@Component(value="bean1")

@Lazy

public class Bean1 {

public Bean1(){

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

}

}

xml在<beans>标签里添加default-lazy-init通过注解实现。

@Configuration注解下添加@Lazy注解:该容器中所有作用域为singleton的Bean对象都会被懒加载。

代码：

@Configuration

@ComponentScan("springlazy")

@Lazy

public class Configuration1 {

@Bean(name="bean2")

public Bean1 bean(){

return new Bean1();

}

}

通过注解设定Bean的作用域Scope

一、Singleton作用域、prototype作用域、Web环境作用域（request作用域、session作用域、application作用域、websocket作用域）

@Scope（value=""）:实现实例化Bean的作用域功能。

实现Bean的多例模式：

Bean代码：

@Component(value="bean1")

@Scope(value="prototype")

public class Bean11 {

}

Configuration代码：

@Configuration

@ComponentScan("springscope")

public class Configuration11 {

@Bean(name="bean2")

@Scope(value="prototype")

public Bean11 getBean(){

return new Bean11();

}

}

测试代码：

@Test

public void test(){

ApplicationContext ac=new AnnotationConfigApplicationContext(Configuration11.class);

for(int i=0;i<10;i++){

Bean11 bean=ac.getBean("bean1", Bean11.class);

System.out.println(bean);

}

System.out.println("=================================");

for(int i=0;i<10;i++){

Bean11 bean1=ac.getBean("bean2",Bean11.class);

System.out.println(bean1);

}

}

结果：

springscope.Bean11@7cd3258f

springscope.Bean11@a470f4f

springscope.Bean11@3f3e10ce

springscope.Bean11@3c164d2

springscope.Bean11@dc218eb

springscope.Bean11@41f1f35b

springscope.Bean11@739ffd2f

springscope.Bean11@ca753f7

springscope.Bean11@3d79839e

springscope.Bean11@74b01999

=================================

springscope.Bean11@672add5f

springscope.Bean11@2f2bbce3

springscope.Bean11@607df346

springscope.Bean11@6ceeaa27

springscope.Bean11@28e51e50

springscope.Bean11@5a292b29

springscope.Bean11@44d0befd

springscope.Bean11@64aaf756

springscope.Bean11@145462bc

springscope.Bean11@301e2f11

二、自定义作用域
步骤1：根据spring.xml中自定义作用域配置，应该先实例化MyScope，所以先通过注解方式来实例化MyScope。

代码：

@Bean

public MyScope myScope(){

return new MyScope();

}

步骤2：根据spring.xml中自定义作用域配置，通过注解再实例化一个CustomScopeConfigurer，再通过该对象的addScope（String scopeName，Scope scope）方法来实现xml中的<map>标签的功能。

代码：

@Bean

public CustomScopeConfigurer customScopeConfigurer(){

CustomScopeConfigurer csc=new CustomScopeConfigurer();

csc.addScope("myScope",myScope());

return csc;

}

问题：CustomScopeConfigurer该对象没有addScope方法。

通过注解实现方法注入：（Bean的作用域为singleton，AnotherBean的作用域为prototype？）？ 

方法注入的使用

两种作用域的作用交集

bean的作用域

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;

}

测试代码：

@Test

public void test(){

ApplicationContext ac=new AnnotationConfigApplicationContext(MyConfiguration.class);

MyBean bean1=ac.getBean("myBean",MyBean.class);

System.out.println(bean1);

}

结果：

MyBean [anotherBean=springzhuru.AnotherBean@27b47740]

2：通过set方法注入

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

代码：

@Configuration

@ComponentScan(value="springzhuru")

public class MyConfiguration {

}

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

@Component(value="myBean")

public class MyBean {

private AnotherBean anotherBean;

private AnotherBean anotherBean1;

@Autowired

public MyBean(AnotherBean anotherBean) {

super();

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

this.anotherBean = anotherBean;

}

@Autowired

public void setAnotherBean1(AnotherBean anotherBean1) {

this.anotherBean1 = anotherBean1;

}

@Override

public String toString() {

return "MyBean [anotherBean=" + anotherBean + ", anotherBean1=" + anotherBean1 + "]";

}

}

测试：

@Test

public void test(){

ApplicationContext ac=new AnnotationConfigApplicationContext(MyConfiguration.class);

MyBean bean1=ac.getBean("myBean",MyBean.class);

System.out.println(bean1);

}

结果：anotherBean和anotherBean1相等，@Component是默认单例模式，同一spring上下文中只会创建一个AnotherBean的对象。

MyBean [anotherBean=springzhuru.AnotherBean@3c8587f, anotherBean1=springzhuru.AnotherBean@3c8587f]

二、集合类型Bean的注入

1、List集合类型Bean的注入

步骤1：创建注入Bean的类（包括创建集合类型的属性，基本类型的作为Bean的属性），并提供set方法，添加@Resource注解。

public class MyBean {

 private List<String> stringList;

public List<String> getStringList() {

return stringList;

}

@Resource        //@Resource注解首先会根据属性名称注入，其次会根据类型进行注入。

public void setStringList(List<String> stringList) {

this.stringList = stringList;

}

}

步骤2：扫描配置类，提供List<String>类型的实例的方法，并添加@Bean注解，告知spring由spring管理的方法。

@Bean

public List<String> stringList(){

List<String> list=new ArrayList<String>();

list.add("哈哈");

list.add("嘿嘿");

list.add("呵呵");

return list;

}

测试：

@Test

public void test(){

ApplicationContext ac=new AnnotationConfigApplicationContext(MyConfiguration.class);

MyBean myBean=ac.getBean("myBean",MyBean.class);

System.out.println(myBean);

for (String s:myBean.getStringList()) {

System.out.println(s);

}

}

通过注解注入List的第二种方式：在扫描配置类中添加几个返回类型为字符串类型的方法，返回的字符串都会被注入到Bean的集合属性中。

@Configuration

@ComponentScan(value="springzhuru")

public class MyConfiguration {

@Bean

public String string1(){

return "111";

}

@Bean

public String string2(){

return "222";

}

}

测试：

MyBean [anotherBean=springzhuru.AnotherBean@7ea7476f, anotherBean1=springzhuru.AnotherBean@7ea7476f, anotherBean2=springzhuru.AnotherBean@7ea7476f, stringList=[222, 111]]

222

111

List注入方式：如果一个Bean有一个List类型的属性需要注入，spring会到上下文中（扫描注解类）查找所有该List中定义泛型的所有实例（带有@Bean），然后将所有实例注入到List里面。

@Qualifier("stringList")指定Id，而且在集合属性的set方法上的@Qualifier（“stringList”）指定Id。

拓展：@Order（数值），来控制实例化Bean的顺序，小的先注入。前提：Spring4.2版本以后该注解才起作用，可以通过它实现注入集合中数据的顺序。

Map注入

步骤1：创建Map类型的集合，并提供set方法

public class MyBean {

 private Map<String,Integer> getIntegerMap;

@Resource("map")

public void setGetIntegerMap(Map<String, Integer> getIntegerMap) {

this.getIntegerMap = getIntegerMap;

}

public Map<String, Integer> getGetIntegerMap() {

return getIntegerMap;

}

}
步骤2：扫描配置文件中提供返回map集合的方法。

@Bean("map")

public Map<String,Integer> integerMap(){

Map<String,Integer> map=new HashMap<String,Integer>();

map.put("aaa", 111);

map.put("bbb", 222);

map.put("ccc", 333);

return map;

}

测试：

@Test

public void test(){

ApplicationContext ac=new AnnotationConfigApplicationContext(MyConfiguration.class);

MyBean myBean=ac.getBean("myBean",MyBean.class);

System.out.println(myBean);

for(Entry<String,Integer> entry:myBean.getGetIntegerMap().entrySet()){

System.out.println(entry);

}

}

Map注入的第二种方式：同List相同，创建多个方法返回Integer类型参数。
扫描配置类代码：

@Bean                //该情况下key的值为Bean的名

public Integer integerMap1(){

return 444;

}

@Bean

public Integer integerMap2(){

return 555;

}

结果:还可以通过给@Bean（name="名称"）来给实例取名。

springzhuru.MyBean@11de0733

integerMap1=444

integerMap2=555

四、String、Integer等简单类型的注入

步骤1：创建简单数据类型的变量，并提供set方法，并在set方法上添加

@value（“值”）注解。

public class MyBean {

private String string;

public String getString() {

return string;

}

@Value("2222")

public void setString(String string) {

this.string = string;

}

}

测试：

@Test

public void test(){

ApplicationContext ac=new AnnotationConfigApplicationContext(MyConfiguration.class);

MyBean myBean=ac.getBean("myBean",MyBean.class);

System.out.println(myBean);

}

结果：MyBean [string=2222]

五、SpringIoC容器内置接口实例注入

private ApplicationContext context;

//这种情况下,可以直接使用ApplicationContext方法

public ApplicationContext getContext() {

return context;

}

@Autowired

public void setContext(ApplicationContext context) {

this.context = context;

}

拓展：除了可以将ApplicationContext注入进来，还可以将BeanFactory、Environment、ResourceLoader、ApplicationEventPublisher、MessageResource及其实现类。

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"/>