spring中bean的配置(别名，实例化方法)

bean取别名

bean标签中除了IOC容器可以通过Id命名得到对应的实体类，也可以通过name属性的取名创建实体类。（bean可以定义多个别名 使用逗号 分号 空格来分隔）

<bean id="bookService" name="service service2 service3" class="com.springStudy.service.impl.BookServiceImpl">
        <!--配置service与dao的关系-->
<!--        property标签表示配置当前bean的属性-->
<!--        name属性表示配置一个具体的属性-->
<!--        ref表示参照哪一个bean-->
        <property name="bookDao" ref="bookDao"/>
    </bean>

public class main {
    public static void main(String[] args) {
        //3.获取IOC容器
        ApplicationContext ctx=new ClassPathXmlApplicationContext("applicationContext.xml");
        //4.获取bean
        BookService bookService = (BookService) ctx.getBean("service3");

        bookService.save();
    }
}

bean的作用范围(单例和多例的配置)

bean标签中 scope属性控制创建的实体是单例还是多例 singleton(单例模式)  prototype(多例模式)

spring中bean默认创建的对象是单例对象。(实例对象地址相同)
表现层对象，业务层对象，数据层对象，工具对象适合交给容器进行管理(只用创建一次即可)
封装实体的域对象不适合交给容器进行管理(其中的成员变量值会发生改变)

bean的实例化(三种方式)

构造方法(常用)

bean本质上就是对象，创建bean使用构造方法完成。(使用的是无参的构造方法，通过反射的方法实现因此无论无参构造方法是公有还是私有，都可以创建该实体类)

如果没有提供无参的构造方法,将抛出异常BeanCreationExcception

 

 

 静态工厂初始化对象

1.创建工厂类提供静态方法创建需要创建的对象

package com.beanStudy.factory;
import com.beanStudy.dao.OrderDao;
import com.beanStudy.dao.impl.OrderDaoImpl;

public class OrderDaoFactory {
    public static OrderDao getOrderDao(){
        System.out.println(" factory setup...");
        return new OrderDaoImpl();
    }
}

2.配置文件中配置对应的bean。

<!--使用静态工厂实例化-->
<!--    factory-method属性:从OrderDaoFactory中找到改方法并执行返回-->
    <bean id="orderDao" class="com.beanStudy.factory.OrderDaoFactory" factory-method="getOrderDao"/>

3.还是通过容器得到对应是实例化对象。

public class AppForInstanceBook {
    public static void main(String[] args) {
        ApplicationContext ctx=new ClassPathXmlApplicationContext("applicationContext.xml");
//        BookDao bookDao = (BookDao) ctx.getBean("bookDao");
//        bookDao.save();
        OrderDao orderDao = (OrderDao) ctx.getBean("orderDao");
        orderDao.save();
    }
}

执行结果：

 实例工厂初始化对象

1.创建工厂类提供方法创建所需实体类。

package com.beanStudy.factory;

import com.beanStudy.dao.UserDao;
import com.beanStudy.dao.impl.UserDaoImpl;

public class UserDaoFactory {
    public UserDao getUserDao(){
        return new UserDaoImpl();
    }
}

2.配置文件中配置bean
首先创建工厂的实体类，在创建所需类的bean
factory-bean：调用的工厂类bean。
factory-method：调用该工厂类的该方法。

<!--使用实例工厂实例化bean-->
    <bean id="userFactory" class="com.beanStudy.factory.UserDaoFactory"/>
    
    <bean id="userDao" factory-method="getUserDao" factory-bean="userFactory"/>

3.任然通过容器创建所需实体类
 

public class AppForInstanceBook {
    public static void main(String[] args) {
        ApplicationContext ctx=new ClassPathXmlApplicationContext("applicationContext.xml");
//        BookDao bookDao = (BookDao) ctx.getBean("bookDao");
//        bookDao.save();
        UserDao userDao = (UserDao) ctx.getBean("userDao");
        userDao.save();
    }
}

执行结果;

 FactoryBean实例化bean(实例工厂初始化对象的改良)(实用方法)

1.创建工厂类去实现FactoryBean<T>接口 T为所需要创建的类型
FactoryBean下有三个方法

package com.beanStudy.factory;

import com.beanStudy.dao.UserDao;
import com.beanStudy.dao.impl.UserDaoImpl;
import org.springframework.beans.factory.FactoryBean;

public class UserDaoFactoryBean implements FactoryBean<UserDao> {

    //代替原始实例工厂中创建对象的方法,得到bean的实例
    @Override
    public UserDao getObject() throws Exception {
        return new UserDaoImpl();
    }

    //返回的对象是什么类型
    @Override
    public Class<?> getObjectType() {
        return UserDao.class;
    }

    //控制实现的是单例还是双例(默认为true 单例对象)
    @Override
    public boolean isSingleton() {
        return true;
    }
}

2..配置文件中配置bean

<!--使用factoryBean实例化对象-->
        <bean id="userDao" class="com.beanStudy.factory.UserDaoFactoryBean"/>

此时创建的不是UserDaoFactoryBean的实体类，而是getObject方法返回的实体类。

运行结果:

bean的生命周期

生命周期:从创建到消亡的完整过程。
1.在所需控制生命周期的类中添加所需要的初始化操作方法,或销毁前的操作方法。

package com.beanStudy.dao.impl;

import com.beanStudy.dao.BookDao;

public class BookDaoImpl implements BookDao {

    @Override
    public void save() {
        System.out.println("Book dao save");
    }

    //表示bean初始化对应的操作
    public void init(){
        System.out.println("init...");
    }

    //表示bean销毁前对应的操作
    public void destory(){
        System.out.println("destory...");
    }

}

2.修改xml中的配置

<bean id="bookDao" class="com.beanStudy.dao.impl.BookDaoImpl" scope="singleton" init-method="init" destroy-method="destory"/>

init-method:bean初始化前执行该类中的此方法。
destory-method:bean消亡前执行该类中的此方法。

3.让bean消亡的两种方式
(1):ClassPathXmlApplicationContext中调用该类的close方法,直接将容器关闭。
(2):关闭钩子
      调用ClassPathXmlApplicationContext中的registerShutdownHook()方法。
      该方法的作用是，在虚拟机停止之前，会关闭容器。

package com.beanStudy;

import com.beanStudy.dao.BookDao;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class main {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext ctx=new ClassPathXmlApplicationContext("applicationContext.xml");
        BookDao bookDao = (BookDao) ctx.getBean("bookDao");
        ctx.registerShutdownHook();

        bookDao.save();
    }
}

如果不想通过xml配置实现生命周期的控制。可以实现InitializingBean和DisposableBean接口实现对应方法。

package com.beanStudy.service.impl;

import com.beanStudy.dao.BookDao;
import com.beanStudy.service.BookService;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;

public class BookServiceImpl implements BookService, InitializingBean, DisposableBean {


    @Override
    public void save() {
        System.out.println("book service save ...");
    }


    @Override
    public void destroy() throws Exception {
        System.out.println(" service destory");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println(" service init");
    }
}

      

bean的整个过程:
创建对象(内存分配)——>执行构造方法——>执行属性注入(set操作)——>执行bean初始化方法——>执行业务操作——>执行bean的销毁方法