526互联

bean 实例化的四种方法

发布时间 2024-01-02 21:38:11作者: belhomme

方式一：构造方法实例化 bean

  1. 准备需要被创建的类

    准备一个 BookDao 和 BookDaoImpl 类

    public interface BookDao {
    public void save();
}

public class BookDaoImpl implements BookDao {
    public void save() {
        System.out.println("book dao save ...");
    }

}

  2. 将类配置到 Spring 容器

    <?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl"/>

</beans>

  3. 编写运行程序

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

    }
}

方式二：静态工厂实例化

  1. 准备一个 OrderDao 和 OrderDaoImpl 类

    public interface OrderDao {
    public void save();
}

public class OrderDaoImpl implements OrderDao {
    public void save() {
        System.out.println("order dao save ...");
    }
}

  2. 创建一个工厂类 OrderDaoFactory 并提供一个静态方法

    //静态工厂创建对象
public class OrderDaoFactory {
    public static OrderDao getOrderDao(){
        return new OrderDaoImpl();
    }
}

  3. 编写 AppForInstanceOrder 运行类，在类中通过工厂获取对象

    public class AppForInstanceOrder {
    public static void main(String[] args) {
        //通过静态工厂创建对象
        OrderDao orderDao = OrderDaoFactory.getOrderDao();
        orderDao.save();
    }
}

  4. 在 spring 的配置文件 application.properties 中添加以下内容:

    <bean id="orderDao" class="com.itheima.factory.OrderDaoFactory" factory-method="getOrderDao"/>

  5. 在 AppForInstanceOrder 运行类，使用从 IOC 容器中获取 bean 的方法进行运行测试

    public class AppForInstanceOrder {
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");

        OrderDao orderDao = (OrderDao) ctx.getBean("orderDao");

        orderDao.save();

    }
}

方式三：实例工厂实例化

  1. 准备一个 UserDao 和 UserDaoImpl 类

    public interface UserDao {
    public void save();
}

public class UserDaoImpl implements UserDao {

    public void save() {
        System.out.println("user dao save ...");
    }
}

  2. 创建一个工厂类 OrderDaoFactory 并提供一个普通方法，注意此处和静态工厂的工厂类不一样的地方是方法不是静态方法

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

  3. 编写 AppForInstanceUser 运行类，在类中通过工厂获取对象

    public class AppForInstanceUser {
    public static void main(String[] args) {
        //创建实例工厂对象
        UserDaoFactory userDaoFactory = new UserDaoFactory();
        //通过实例工厂对象创建对象
        UserDao userDao = userDaoFactory.getUserDao();
        userDao.save();
}

  4. 在 spring 的配置文件中添加以下内容:

    <bean id="userFactory" class="com.itheima.factory.UserDaoFactory"/>
<bean id="userDao" factory-method="getUserDao" factory-bean="userFactory"/>

  5. 在 AppForInstanceUser 运行类，使用从 IOC 容器中获取 bean 的方法进行运行测试

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

方式四：FactoryBean 的使用

  1. 创建一个 UserDaoFactoryBean 的类，实现 FactoryBean 接口，重写接口的方法

    public class UserDaoFactoryBean implements FactoryBean<UserDao> {
    //代替原始实例工厂中创建对象的方法
    public UserDao getObject() throws Exception {
        return new UserDaoImpl();
    }
    //返回所创建类的Class对象
    public Class<?> getObjectType() {
        return UserDao.class;
    }
}

  2. 在 Spring 的配置文件中进行配置

    <bean id="userDao" class="com.itheima.factory.UserDaoFactoryBean"/>

FactoryBean 接口其实会有三个方法，分别是:

T getObject() throws Exception;

Class<?> getObjectType();

default boolean isSingleton() {
		return true;
}

方法一: getObject()，被重写后，在方法中进行对象的创建并返回

方法二: getObjectType(),被重写后，主要返回的是被创建类的 Class 对象

方法三: 没有被重写，因为它已经给了默认值，设置对象是否为单例，默认 true