Spring 学习笔记

IOC:控制反转 Inversion of Control

资源获取方式
    主动
        自己 new Car();
    被动
        资源的获取不是我们自己创建,而是交给一个容器来创建和设置;

DI: ( Dependency Injection )依赖注入

容器能知道哪个组件(类)运行的时候,需要另外一个类(组件) ; 容器通过反射的形式,将容器中准备好的BookService对象注入(利用反射给属性赋值)到BookServlet中;

创建容器并获取bean

ioc.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" xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd">
    <bean id="person01"  class="com.yhy.bean.Person">
    <property name="name" value="张三"></property>
    <property name="age" value="18"></property>
    </bean>
</beans>

Person类

public class Person {
	private String name;
	private String age;

		public Person() {
		System.out.println("容器创建的我，执行了构造函数");
	}

	public void setName(String name) {
		System.out.println("执行了setName");
		this.name = name;
	}

	public void setAge(String age) {
		System.out.println("执行了setAge");
		this.age = age;
	}
}

测试

		ApplicationContext ioc = new ClassPathXmlApplicationContext("ioc.xml");
		Person p11 = (Person) ioc.getBean("person01");
		Person p12 = (Person) ioc.getBean("person01");
		System.out.println(p11);
		System.out.println(p11 == p12);

输出结果

容器创建的我，执行了构造函数
执行了setName
执行了setAge
容器创建的我
执行了setName
执行了setAge
Person [name=张三, age=18]
true

总结：

1. 给容器中注册一个组件;我们也从容器中按照id拿到了这个组件的对象?
2. 组件的创建工作，是容器完成;
3. Person对象是什么时候创建好了呢?
4. 容器中对象的创建在容器创建完成的时候就已经创建好了;
5. 同一个组件在ioc容器中是单实例的;容器启动完成都已经创建准备好的

bean的作用域

prototype:多实例的
    1)、容器启动默认不会去创建多实例bean
    2)、获取的时候创建这个bean
    3)、每次获取都会创建一个新的对象
singleton:单实例的;默认的
    1)、在容器启动完成之前就已经创建好对象，保存在容器中了。
    2)、任何获取都是获取之前创建好的那个对象;

BeanPostProcessor：后置处理器

BeanPostProcessor是Spring IOC容器给我们提供的一个扩展接口，在任何初始化代码（比如配置文件中的init-method）调用之前调用；后者在初始化代码调用之后调用。。接口声明如下：

public interface BeanPostProcessor {
    //bean初始化方法调用前被调用
    Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException;
    //bean初始化方法调用后被调用
    Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException;
}

Person类：…其他方法跟上面Person类一模一样就不写了

public class Person {
	private String name;
	private String age;
	
	//多了个初始化方法
	public void myInit() {
		System.out.println("初始化：" + name + " " + age);
	}
	......
}

实现类

public class MyBeanProcessor implements BeanPostProcessor {

	@Override
	public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
		System.out.println("初始化前：bean=" + bean + ",类型= " + bean.getClass().getTypeName() + "，id=" + beanName);
		return bean;
	}

	@Override
	public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
		System.out.println("初始化后：bean=" + bean + ",类型= " + bean.getClass().getTypeName() + "，id=" + beanName);
		return bean;
	}
}

注册后置处理器

<bean id="person01"  class="com.yhy.bean.Person" init-method="myInit">
    <property name="name" value="张三"></property>
    <property name="age" value="18"></property>
    </bean>
<bean class="com.yhy.bean.MyBeanProcessor"></bean>

按照上面测试输出结果

容器创建的我，执行了构造函数
执行了setName
执行了setAge
初始化前：bean=Person [name=张三, age=18],类型= com.yhy.bean.Person，id=person01
初始化：张三 18
初始化后：bean=Person [name=张三, age=18],类型= com.yhy.bean.Person，id=person01
Person [name=张三, age=18]

通过注解配置bean

使用注解标识组件

@Component，@Respository，@Service，@Controller

1. 默认情况：使用组件的简单类名首字母小写后得到的字符串作为bean的id
2. 使用组件注解的value属性指定bean的id

注意：事实上Spring并没有能力识别一个组件到底是不是它所标记的类型，即使将@Respository注解用在一个表述层控制器组件上面也不会产生任何错误，所以@Respository、@Service、@Controller这几个注解仅仅是为了让开发人员自己明确当前的组件扮演的角色。

扫描组件

组件被上述注解标识后还需要通过Spring进行扫描才能够侦测到。

①指定被扫描的package

<context:component-scan base-package="com.atguigu.component"/>

②详细说明

1. base-package属性指定一个需要扫描的基类包，Spring容器将会扫描这个基类包及其子包中的所有类。

2. 当需要扫描多个包时可以使用逗号分隔。

3. 如果仅希望扫描特定的类而非基包下的所有类，可使用resource-pattern属性过滤特定的类，示例：

    <context:component-scan base-package="com.yhy.bean" resource-pattern="bean/*.class"/> 
   

@Autowired（依赖注入） 使用注意点

比如依赖注入一个BookService 实现类 ```java @Autowired private BookService bookService; ```

1. 先按照类型去容器 中找到对应的组件; bookService = ioc. getBean( BookService.class);
   1. 找到一个:找到就赋值
   2. 没找到:抛异常
   3. 找到多个实现类的，装配哪个？
        按照变量名作为id继续匹配; BookService1 、 BookService2。
        通过@Qualifier注解来指明使用哪一个实现类，实际上也是通过byName的方式实现:@Qualifier(value = "bookService1");
2. bean不止一个，默认根据@Autowired注解标记的成员变量名作为id查找bean, 进行装配

IOC总结

IOC就是个容器，用来存取组件的。 当有对类方法增强时（切面），IOC容器中保存的是代理对象，如果没有增强，保存的就是原生对象。