Spring -- 配置bean

配置通过静态工厂方法创建的bean

public class StaticBookFactory {
    
    
    //静态工厂方法；
    public static Book getBook(String bookName){
        System.out.println("静态工厂方法调用...");
        Book book = new Book();
        book.setBookName(bookName+"_static");
        book.setAuthor(new Person());
        book.setInfo(new HashMap<String,Object>());
        book.setLists(new ArrayList<>());
        book.setPrice(98.98);
        return book;
    }

}

spring配置如下：

<bean id="book01" 
           class="com.soyoungboy.spring.factory.StaticBookFactory"
           factory-method="getBook">
           <!-- 给方法参数定义值 -->
        <constructor-arg value="西游记"></constructor-arg>
    </bean>

class:指定为工厂类型
factory-method=""：告诉Spring这个工厂的工厂方法;
Spring会调用工厂方法，把返回的结果放在容器中；容器中其实保存的是Book

实例工厂：

1)、必须得有这个工厂对象
2)、我们创建bean的时候使用这个工厂

例如：

public class InstanceBookFactory {

    // 实例工厂方法；
    public Book getBook(String bookName) {
        System.out.println("实例工厂方法调用...");
        Book book = new Book();
        book.setBookName(bookName+"_instance");
        book.setAuthor(new Person());
        book.setInfo(new HashMap<String, Object>());
        book.setLists(new ArrayList<>());
        book.setPrice(98.98);
        return book;
    }

}

spring配置文件如下：

<bean id="instanceBookFactory" class="com.soyoungboy.spring.factory.InstanceBookFactory"></bean>
     <bean id="book02" class="com.atguigu.spring.Book"
         factory-bean="instanceBookFactory" factory-method="getBook">
         <constructor-arg value="东游记"></constructor-arg>
     </bean>

告诉Spring创建book对象的时候使用哪个工厂对象
factory-bean="instanceBookFactory":指定工厂对象
factory-method="getBook":指定工厂方法

FactoryBean

public class SpringSupportFactory implements FactoryBean<Book> {

    /**
     * 造书的工厂方法
     */
    @Override
    public Book getObject() throws Exception {
        System.out.println("SpringFactory......");
        Book book = new Book();
        book.setBookName("SpringFactory");
        return book;
    }

    /**
     * 告诉外界这个工厂是造什么类型数据的
     */
    @Override
    public Class<?> getObjectType() {
        return Book.class;
    }

    /**
     * 是单例？
     *         true：代表造的数据是单例
     *         false：代表不是单例
     */
    @Override
    public boolean isSingleton() {
        return false;
    }

}

配置文件如下:

<bean id="springSupportFactory" class="com.soyoungboy.spring.factory.SpringSupportFactory"></bean>

Spring定义的一个工厂接口；实现这个接口；实现了这个接口的所有类，Spring就认为这是一个工厂类容器中保存的是getObject方法返回的对象

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

<bean id="person01" class="com.soyoungboy.spring.Person" abstract="true">
        <property name="firstName" value="三"></property>
        <property name="lastName" value="王"></property>
        <property name="gender" value="男"></property>
    </bean>

通过abstract属性创建一个模板bean:abstract="true"：这是一个抽象定义，只是让别人继承的。

<bean id="person03" parent="person01">
        <property name="lastName" value="张"></property>
        <property name="age" value="19"></property>
    </bean>

parent="person01"：只是指配置的继承。

bean之间的依赖

改变创建顺序
depends-on="person02":依赖的bean优先创建

    <!-- 默认是按照配置顺序来创建bean的 -->
    <bean id="book01" class="com.soyoungboy.spring.Book" depends-on="person02"></bean>
    <!-- parent="person01"：只是指配置的继承 -->
    <bean id="person02" parent="person01">
        <property name="lastName" value="张"></property>
        <property name="age" value="19"></property>
    </bean>
    <bean id="person03" parent="person01">
        <property name="lastName" value="张"></property>
        <property name="age" value="19"></property>
    </bean>

bean的作用域(是否单多实例)

scope="":作用域;
　　prototype:原型，多实例；
　　singleton:单实例（默认）

web环境有用的
　　request:同一次请求创建一次对象
　　session:同一个会话创建一个对象

单实例：
　　1、默认注册的bean都是单实例的
　　2、容器一启动就会创建这些单实例bean
多实例：
　　1、容器启动不会创建这些bean

<bean id="car01" class="com.soyoungboy.spring.Car" scope="prototype"></bean>

创建带有生命周期方法的bean

生命周期：（从创建到销毁的过程）；
　　Spring帮我们创建对象====销毁:
　　Spring允许我们为bean自定义声明周期方法，在具体生命周期的时候会自动调用

　　init-method="":指定初始化方法;
　　destroy-method="":指定销毁方法;
调用：
单实例：
　　容器启动（调用构造器）===init=====xxxx====容器关闭销毁；
多实例：（销毁方法不会被调用）
　　每次获取（调用构造器）===init====xxx====容器关闭；

public class Car {
    
    public void carInit(){
        System.out.println("car..init。。。。");
    }
    
    public void carDestroy(){
        System.out.println("car..destroy。。。。");
    }

    public Car() {
        super();
        // TODO Auto-generated constructor stub
        System.out.println("car创建....");
    }
}

配置调用对应的初始化和销毁方法：

<bean id="car02" class="com.soyoungboy.spring.Car" 
        init-method="carInit" destroy-method="carDestroy"></bean>

bean的后置处理器:BeanPostProcessor(接口)

作用：拦截bean的初始化过程在初始化前后做一些工作；
使用：
　　1、写实现
　　2、注册在容器中

public class MyBeanPostProcessor implements BeanPostProcessor {

    /**
     * 创建对象===初始化前===【初始化】==初始化后===使用=====销毁
     * 
     * 
     * 初始化前调用
     * 
     * Object bean, 刚刚创建好的bean
     * String beanName    创建的bean的名字id
     */
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName)
            throws BeansException {
        // TODO Auto-generated method stub
        System.out.println("postProcessBeforeInitialization：bean=id："+beanName+"==》详细信息："+bean);
        return bean;
    }

    /**
     * 初始化后调用的
     * 
     * Object bean        
     * String beanName
     */
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName)
            throws BeansException {
        // TODO Auto-generated method stub
        System.out.println("postProcessAfterInitialization：bean=id："+beanName+"==》详细信息："+bean);
        return bean;
    }

}

配置文件内容如下：

<bean class="com.soyoungboy.spring.process.MyBeanPostProcessor"></bean>

Spring认为每一个组件是有默认初始化方法的，只是我们可
能没定义
1、每个bean创建初始化后置处理器都会工作
2、我们可以在后置处理器中对初始化前后的bean进行检查修改。。。