6 - spring对象的获取及属性赋值方式 - 3

哆啦A梦的_梦

已于 2022-11-30 10:50:31 修改

阅读量333

点赞数

分类专栏： spring 文章标签： spring java maven

于 2022-10-31 11:43:38 首次发布

本文链接：https://blog.csdn.net/zhoulizhengZ/article/details/127612139

版权

spring 专栏收录该内容

14 篇文章 0 订阅

订阅专栏

8、bean的作用域控制，是否是单例

9、利用工厂模式创建bean对象

10、实现FactoryBean来创建对象

FactoryBean —— 是用来获取唯一的对象的。

（而 BeanFactory 定义的是一个接口，里面定义的更多的是规范）

11、bean对象的初始化和销毁

12、配置bean对象初始化方法的前后处理方法

代码示例：

代码结构;

bean文件夹下： person 、 MyBeanPostProcessor

person 类：

package com.zhoulz.bean;

import java.util.*;

/**
 * @Auther: zhoulz
 * @Description: com.zhoulz.bean
 * @version: 1.0
 */
public class Person {
    private int id;
    private String name;
    private Integer age;
    private String gender;

    //复杂类型
    private String[] hobbies;
    private Address address;

    //private List<String> lists;
    private List<Address> lists;
    private Set<String> sets;
    private Map<String, Object> maps;
    private Properties properties;


    public Person() {
        System.out.println("person被创建了！");
    }


    public void init(){
        System.out.println("person对象初始化完成");
    }

    public void destory(){
        System.out.println("person对象被销毁");
    }
    //然后见ioc.xml配置文件

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public String[] getHobbies() {
        return hobbies;
    }

    public void setHobbies(String[] hobbies) {
        this.hobbies = hobbies;
    }

    public Address getAddress() {
        return address;
    }

    public void setAddress(Address address) {
        this.address = address;
    }

    public List<Address> getLists() {
        return lists;
    }

    public void setLists(List<Address> lists) {
        this.lists = lists;
    }

    public Set<String> getSets() {
        return sets;
    }

    public void setSets(Set<String> sets) {
        this.sets = sets;
    }

    public Map<String, Object> getMaps() {
        return maps;
    }

    public void setMaps(Map<String, Object> maps) {
        this.maps = maps;
    }

    public Properties getProperties() {
        return properties;
    }

    public void setProperties(Properties properties) {
        this.properties = properties;
    }

    @Override
    public String toString() {
        return "Person{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", gender='" + gender + '\'' +
                ", hobbies=" + Arrays.toString(hobbies) +
                ", address=" + address +
                ", lists=" + lists +
                ", sets=" + sets +
                ", maps=" + maps +
                ", properties=" + properties +
                '}';
    }
}

MyBeanPostProcessor：

package com.zhoulz.bean;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanNameAware;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.context.annotation.Bean;

public class MyBeanPostProcessor implements BeanPostProcessor {

    //在每一个对象的初始化方法前面执行
    //bean—— 表示创建的具体对象
    //beanName—— 表示bean的id属性
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("postProcessBeforeInitialization:"+ beanName);
        return bean;
    }

    //在每一个对象的初始化方法后面执行
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("postProcessAfterInitialization:"+beanName);
        return bean;
    }
}

factory文件夹下：MyFactoryBean、PersonStaticFactory、PersonInstanceFactory

MyFactoryBean：

package com.zhoulz.factory;

import com.zhoulz.bean.Person;
import org.springframework.beans.factory.FactoryBean;
/**
 *此方式是spring创建bean方式的一种补充，用户可以按照需求创建对象，
 * 创建的对象交由spring IOC容器来进行管理，无论是否是单例，都是在用到
 * 的时候才会创建该对象，不用该对象不会创建
 * */
public class MyFactoryBean implements FactoryBean<Person> {
    //返回获取的bean
    @Override
    public Person getObject() throws Exception {
        Person person = new Person();
        person.setId(6);
        person.setName("王五");
        return person;
    }

    //获取返回bean的类型
    @Override
    public Class<?> getObjectType() {
        return Person.class;
    }

    //判断当前bean是否是单例的
    @Override
    public boolean isSingleton() {
        //return false; //单例
        return true; //多例   同上，无论是否是单例，都是在用到的时候才会创建该对象，不用该对象不会创建
    }
}

PersonStaticFactory：

package com.zhoulz.factory;

import com.zhoulz.bean.Person;
/**
 * 静态工厂类
 * */
public class PersonStaticFactory {
    //先建立一个静态方法
    public static Person getInstance(String name){
        Person person = new Person();
        person.setId(1);
        person.setName(name);
        person.setAge(18);
        return person;
    }
}

PersonInstanceFactory：

package com.zhoulz.factory;

import com.zhoulz.bean.Person;

/**
 * 实例工厂类
 * */
public class PersonInstanceFactory {
    //先建立一个方法
    public Person getInstance(String name){
        Person person = new Person();
        person.setId(2);
        person.setName(name);
        person.setAge(20);
        return person;
    }
}

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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="person" class="com.zhoulz.bean.Person" > <!--单例-->
        <property name="id" value="1"></property>
        <property name="name" value="lisi"></property>
        <property name="age" value="20"></property>
        <property name="gender" value="男"></property>
    </bean>

    <!--设置bean对象的作用域-->
    <!--
    通过scope属性可以指定当前bean的作用域
    singleton:单例模式，从IOC容器中获取的都是同一个对象，默认的作用域
    prototype:多例模式，从IOC容器获取的对象每次都是新创建

    在spring4.x的版本中，还包括另外两种作用域：
    request：每次发送请求都会有一个新的对象；
    session：每一次会话都会有一个新的对象
    （几乎不用，从来没用过，因此在5版本的时候被淘汰了）

    注意：
         如果是singleton作用域的话，每次在创建IOC容器完成之前此对象已经创建完成
         如果是prototype作用域的话，每次是在需要用到此对象的时候才会创建
    -->
    <bean id="person2" class="com.zhoulz.bean.Person" scope="singleton"></bean>

    <!--利用工厂模式创建bean对象-->
    <!--静态工厂:类名.静态方法()-->
    <bean id="person4" class="com.zhoulz.factory.PersonStaticFactory" factory-method="getInstance">
        <constructor-arg value="zhangsan"></constructor-arg>
    </bean>
    <!--实例工厂：先创建工厂实例，然后调用工厂实例方法
      factory-bean:表示具体工厂类的实例
      factory-method:表示具体工厂实例的方法
    -->
    <bean id="instanceFactory" class="com.zhoulz.factory.PersonInstanceFactory"></bean>
    <bean id="person5" class="com.zhoulz.bean.Person" factory-bean="instanceFactory" factory-method="getInstance">
        <constructor-arg value="lisi"></constructor-arg>
    </bean>

    <bean id="myFactoryBean" class="com.zhoulz.factory.MyFactoryBean"></bean>

    <!--spring容器在创建对象的时候可以指定具体初始化和销毁方法
        init-method : 在对象创建完成之后会调用初始化方法
        destroy-method：在容器关闭的时候会调用销毁方法
   另外：
   初始化和销毁的方法跟scope属性也是相关联的
     如果是singleton，初始化和销毁的方法都存在
     如果是prototype，初始化方法会调用，但是销毁的方法不会调用
    -->
    <bean id="person7" class="com.zhoulz.bean.Person" init-method="init" destroy-method="destory" scope="singleton"></bean>


    <bean id="myBeanPostProcessor" class="com.zhoulz.bean.MyBeanPostProcessor"></bean>

</beans>

测试类：

import com.zhoulz.bean.Person;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("ioc.xml");

        /*Person person = context.getBean("person", Person.class);
        System.out.println(person);*/

        /*Person person2 = context.getBean("person2", Person.class);
        //System.out.println(person2);
        Person person3 = context.getBean("person2", Person.class);
        System.out.println(person2 == person3); //singleton —— true
                                                //prototype —— false*/

        /*Person person4 = context.getBean("person4", Person.class);
        System.out.println(person4);

        Person person5 = context.getBean("person5", Person.class);
        System.out.println(person5);*/

        /*Person myFactoryBean = context.getBean("myFactoryBean", Person.class);
        System.out.println(myFactoryBean);*/

        Person person7 = context.getBean("person7", Person.class);
        System.out.println(person7);
        //调用close()方法来关闭容器
        //context.close(); //直接用——没有该方法,报错
        //必须先进行一个（从上到下的）转型
        ((ClassPathXmlApplicationContext)context).close();
    }
}