Spring--IOC--有关问题详解

一. 通过继承实现bean配置信息的重用

只是单纯的继承了配置信息，不存在父类和子类的说法，因为二者都是属于一个类的（HelloSpring）

<bean id="person01" class="HelloSpring">
    <property name="name" value="张三"></property>.
    <property name="age" value="36"></property>
</bean>

<!-- parent：指定当前bean配置继承于哪个bean-->
<bean id="person02" class="HelloSpring" parent="person01"></bean>

若想让一个bean只能被继承而不能被获取，可添加abstract属性

<bean id="person01" class="HelloSpring" abstract="true">
   <property name="name" value="张三"></property>.
   <property name="age" value="36"></property>
</bean>

二. bean之间的依赖

原来 bean 的创建顺序是按照配置顺序依次创建的

<bean id="person01" class="HelloSpring"></bean>
<bean id="book01" class="book"></bean>
<bean id="pen01" class="pen"></bean>

bean 之间的依赖只是改变 bean 的创建顺序

<bean id="person01" class="HelloSpring" depend-on="book01,pen01"></bean>
<bean id="book01" class="book"></bean>
<bean id="pen01" class="pen"></bean>

顺序为：book01,pen01,person01

depend-on 内部也有顺序，若改为depend-on="pen01,book01">则创建顺序为"pen01,book01,person01

三. （*）bean的作用域

bean的作用域：bean在默认情况下是单实例

指定作用域：

• prototype：多实例
  1. 容器启动默认不会创建
  2. 获取时创建这个 bean
  3. 每次获取都会创建一个新的实例
• singleton：单实例 ------ 默认
  1. 在容器启动前就已经创建好了
  2. 任何获取都是获取之前创建好的那个对象

<bean id="book01" class="book" scope="prototype"></bean>

四. （*）工厂模式

bean的创建默认就是框架利用反射new出来的bean实例

工厂模式：工厂帮我们创建对象（一个专门创建对象的类）

• 静态工厂：工厂本身不用创建对象，通过静态方法调用，对象 = 工厂类.工厂方法名()
• 实例工厂：工厂本身需要创建对象
  • 工厂类 工厂对象 = new 工厂类();
  • 工厂对象.工厂方法名()

//静态工厂
public class staticFactory(){
	public static book getbook(String bookname){
		book.books = new book();
		books.setAuthor("jess");
		books.setbookname(bookname);
		return books;
	}
}

//调用
staticFactory.getbook();

//实例工厂
public class InstanceFactory(){
	public book getbook(String bookname){
		book.books = new book();
		books.setAuthor("jess");
		books.setbookname(bookname);
		return books;
	}
}

//调用
new InstanceFactory().getbook();

补充：静态方法和实例方法的区别

1. 在外部调用静态方法时，可以使用"类名.方法名"的方式，也可以使用"对象名.方法名"的方式。而实例方法只有后面这种方式。也就是说，调用静态方法可以无需创建对象。
2. 静态方法在访问本类的成员时，只允许访问静态成员（即静态成员变量和静态方法），而不允许访问实例成员变量和实例方法；实例方法则无此限制。

<!-- 静态工厂 -->
<!-- class：指定工厂全类名 -->
<!-- factory-method：指定工厂方法 -->
<bean id="book01" class="staticFactory" factory-method="getbook">
	<!-- 传参:为方法指定参数 -->
	<constructor-arg name="bookname" value="playgame"></constructor-arg>
</bean>

<!-- 实例工厂 -->
<!-- 1.先配置出实例工厂对象-->
<bean id="bookFactory" class="InstanceFactory" ></bean>

<!-- 2.配置需要创建的对象使用哪个工厂-->
<!-- factory-bean：指定当前对象创建使用哪个工厂-->
<bean id="book02" class="book" factory-bean="bookFactory" factory-method="getbook"></bean>

（*）FactoryBean：spring规定的接口，只要是这个接口的实现类，spring都认为是一个工厂

spring自动调用工厂方法创建实例

public class MyFactory implements FactoryBean<book>(){
	//实现接口内的方法(此处只显示部分方法)
	
	//getObject:工厂方法，返回创建的对象
	//spring自动调用
	public book getObject() throws Exception{
		book.Book = new book();
		Book.setbookname(UUID.randomUUID.tostring());
		return Book;
	}

	//返回创建对象的类型,spring自动调用
	public Class<?> getobjectType(){
			return Book.class;
	}

	//是否是单例
	public boolean isSingleton(){
			return false;
	}
}

使用：

1. 编写FactoryBean实现类
2. 在spring配置文件中注册

<bean id="MyFactoryimp" class="MyFactory"></bean>

//虽然获取的是MyFactorp工厂类，但是获取到的bean是book.
//IOC容器创建时不会获取实例（与是否是多实例还是单实例无关）
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("bean.xml");
applicationContext.getBean("MyFactoryimp");

五. 创建有生命周期的bean

spring在创建或销毁时会调用指定方法

<bean id="book03" class="book" destroy-method="myDestory" init-method="myInit"></bean>

//方法不能有参数
public void myInit(){	
}
public void myDestory(){
}

bean的生命周期：

• 单例：（容器启动）构造器 ----》初始化方法 ----》（容器关闭）销毁方法
• 多例：（获取bean）构造器 ----》初始化方法 ----》容器关闭（不会调用销毁方法）

六. bean的后置处理器

spring有一个后置处理器接口BeanPostProcessor，可以再bean初始化前后调用方法

public class myBeanPostProcessor implements BeanPostProcessor(){
	//实现接口内方法
	public Object postProcessBeforeInitialization(Object bean,String beanName) throws BeansException{
		return bean;
	}

	//初始化之后返回的bean，返回的是什么，容器中保存的就是什么
	public Object postProcessAfterInitialization(Object bean,String beanName) throws BeansException{
		return bean;
	}
}

注册配置文件

<bean id="BeanPostProcessor" class="myBeanPostProcessor" ></bean>

单实例：（容器启动）构造器 ----》后置处理器before----》初始化方法 ----》后置处理器after----》（容器关闭）销毁方法

若没有自定义初始化方法，后置处理器会默认有初始化，依旧正常工作

七. （*）引用数据库连接池

数据库连接池作为单实例是最好的，一个项目就一个连接池。可以利用spring创建连接池对象。

<!-- pom.xml中添加依赖 -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.6</version>
</dependency>
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.8.12</version>
</dependency>

dbconfig.properties：

jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.username=root
jdbc.password=root
jdbc.url=jdbc:mysql://localhost:3306/db1

<!--引用外部属性：依赖context名称空间-->
<!-- 加载外部配置文件：classpath：引用类路径下的资源-->
<!--dbconfig.properties: property文件名-->
<context:property-placeholder location="classpath:dbconfig.properties">

<!-- 数据源 -->
<!-- ${key}：动态取出配置文件中某个key的值 -->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
	<property name="driverClassName" value="${jdbc.driver}" />
	<property name="url" value="${jdbc.url}" />
	<property name="username" value="${jdbc.username}" />
	<property name="password" value="${jdbc.password}" />
</bean>

username是spring中的key，为了防止配置文件中的key和spring关键字冲突，可以给username加一个前缀（jdbc.username）

八. 基于xml的自动装配

autowire=“default”, 不自动装配（赋值）

按照某种规则自动装配

• autowire=“byName”：按照名字赋值
  在容器中找以属性名作为id的组件，给它赋值
• autowire=“byType”：按照类型
  以属性类型作为查找依据，给它赋值。若容器中有多个此种类型的组件，报错
• autowire=“constructort”：按照构造器

<bean id="book11" class="book" autowire="default"></bean>