Resumo do aprendizado de primavera (5): Montagem de feijão baseada em XML (3)

Um, o ciclo de vida do feijão

       O chamado ciclo de vida se refere a todo o processo de um objeto, desde a criação até a destruição. O contêiner Spring pode gerenciar o ciclo de vida do bean. Quando um bean é carregado no contêiner Spring, ele tem uma vida e o Spring executa algumas outras operações antes de garantir que o bean seja usado.

O ciclo de vida de um feijão é dividido nos seguintes processos:

(1) Crie uma instância de bean por meio do construtor (construção sem parâmetro).

(2) Defina valores para propriedades de bean e referências a outros beans (chame o método set).

(3) Chame o método de inicialização do bean (é necessário configurar o atributo initialization method-init-method).

(4) Use feijão (obtenha o objeto).

(5) Quando o contêiner é fechado, chame o método de destruição do bean (o método de destruição precisa ser configurado - o atributo do método de destruição).

       Em seguida, use o código para verificar o processo acima.

       (1) Crie a classe Aluno.

       1) Para verificar a primeira e a segunda etapas, é necessário adicionar instruções de saída na construção sem parâmetros e no método de definição.

       2) Defina os métodos initMethod () e destroyMethod () respectivamente e adicione instruções de saída.

public class Student {
    private String name;

    public Student(){
        System.out.println("第一步：调用无参构造创建对象");
    }

    public void setName(String name) {
        System.out.println("第二步：调用set方法注入属性值");
        this.name = name;
    }

    public void initMethod(){
        System.out.println("第三步：调用初始化方法");
    }

    public void destoryMethod(){
        System.out.println("第五步：执行完毕，调用销毁方法");
    }
}

       (2) Configure em bean.xml.

     <!-- 
        属性说明：
         init-method：实体类中初始化的方法。
         destroy-method：实体类中销毁的方法
      -->
    <bean id="student" class="com.yht.example3.entity.Student" init-method="initMethod" destroy-method="destoryMethod">
       <property name="name" value="YHT"></property>
   </bean>

       (3) Faça um teste.

    @Test
    public void testLive(){
        
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
        Student student = context.getBean("student", Student.class);
        System.out.println("第四步：获取到对象实例 \t" + student);
        // ApplicationContext中没有close()方法，而是在子类ClassPathXmlApplicationContext中
        context.close();
    }

       Os resultados da execução são os seguintes:

       Acima estão os cinco processos do ciclo de vida do bean no Spring. Além disso, existem dois processos antes e depois da inicialização do bean no Spring, que concluímos por meio do pós-processador do bean.

       (1) Defina MyBeanPost, implemente a interface BeanPostProcessor e substitua os métodos nela.

public class MyBeanPost implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("我在初始化之前执行");
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("我在初始化之后执行");
        return bean;
    }
}

        (2) Configure myBeanPost em bean.xml.

<bean id="myBeanPost" class="com.yht.example3.posthandler.MyBeanPost"></bean>

       (3) Execute o teste de unidade e obtenha os seguintes resultados:

A partir disso, podemos obter as sete etapas do ciclo de vida do feijão: 

(1) Crie uma instância de bean por meio do construtor (construção sem parâmetro).

(2) Defina valores para propriedades de bean e referências a outros beans (chame o método set).

(3) Operações realizadas antes da inicialização.

(4) Chame o método de inicialização do bean (é necessário configurar o atributo initialization method-init-method).

(5) Operações realizadas após a inicialização.

(6) Use feijão (obtenha o objeto).

(7) Quando o contêiner é fechado, chame o método de destruição do bean (o método de destruição precisa ser configurado - o atributo do método de destruição).

Em segundo lugar, o escopo do feijão

       Quando o Spring inicializa uma instância de um bean, ele pode especificar o escopo da instância. Cinco tipos de escopos são definidos no Spring. Os comumente usados ​​são singleton (caso único) e protótipo (casos múltiplos) . Os detalhes são os seguintes:

Atributos	Descrição
singleton	No modo Singleton, o Bean definido por singleton tem apenas uma instância no contêiner Spring, que também é o escopo padrão do Bean
protótipo	No modo de protótipo, cada vez que o Bean definido pelo protótipo é obtido através do container Spring, o container irá criar uma nova instância do Bean
solicitação	Em uma solicitação HTTP, o contêiner retornará a mesma instância do Bean. Para diferentes solicitações HTTP, diferentes instâncias serão retornadas, e o escopo é válido apenas dentro da solicitação HTTP atual
sessão	Em uma sessão HTTP, o contêiner retornará a mesma instância do Bean. Para diferentes solicitações HTTP, diferentes instâncias serão retornadas, e o escopo é válido apenas na sessão HTTP atual
sessão global	Em uma Sessão HTTP global, o contêiner retornará a mesma instância do Bean. Este escopo é válido apenas ao usar o contexto do portlet

 1 、 singleton

       Singleton é o escopo padrão do contêiner Spring. Quando o escopo de um Bean é singleton, haverá apenas uma instância de Bean compartilhada no contêiner Spring e todas as solicitações para o Bean, desde que o id corresponda à definição do Bean, apenas Retorne a mesma instância de Bean .

       No arquivo de configuração do Spring, você pode usar o atributo de escopo do elemento <bean> para definir o escopo do Bean como um singleton. O método de configuração é o seguinte:

 <bean id="teacher" class="com.yht.example3.entity.Teacher" scope="singleton"></bean>

       Use o programa a seguir para descobrir que os endereços do professor obtidos duas vezes são os mesmos, o que mostra que o professor neste momento é único e globalmente único.

    @Test
    public void testTeacher(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
        Teacher teacher1 = context.getBean("teacher", Teacher.class);
        Teacher teacher2 = context.getBean("teacher", Teacher.class);
        System.out.println("teacher1的地址 : " + teacher1);
        System.out.println("teacher2的地址 : " + teacher2);
    }

2 、 protótipo

       Beans usando o escopo do protótipo criarão uma nova instância de Bean toda vez que o Bean for solicitado. Portanto, o escopo do protótipo deve ser usado para beans que precisam manter o estado da sessão (como a classe Action de Structs 2). Mude o atributo de escopo no exemplo acima para protótipo, e teste-o, você verá que os resultados obtidos duas vezes são inconsistentes, o que mostra que existem muitos casos do objeto.

<bean id="teacher" class="com.yht.example3.entity.Teacher" scope="prototype"></bean>

       Os resultados da execução são os seguintes:

3. A diferença entre singleton e protótipo

Diferença 1: Singleton é singleton, protótipo é várias instâncias.

Diferença 2: Quando socpe é definido como singleton, um objeto singleton será criado quando o arquivo de configuração do Spring for carregado. Quando socpe é definido como prototype, o objeto é criado quando getBean é chamado.

Três, três métodos de instanciação de feijão

       No Spring, se você deseja usar o Bean no contêiner, também precisa instanciar o Bean. Existem três maneiras de instanciar o Bean, a saber: instanciação de construtor, instanciação de fábrica estática e instanciação de fábrica de instância. A instanciação do construtor é um dos métodos mais comumente usados; outros métodos podem ser compreendidos.

1. Instanciação do construtor

       A instanciação do construtor significa que o contêiner Spring instancia o Bean por meio do método de construção sem argumento padrão na classe correspondente do Bean.

       (1) Crie a classe do professor

public class Teacher {
    private String name;
    private String major;

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

    public void setMajor(String major) {
        this.major = major;
    }

    public void showMessage(){
        System.out.println("教师：" + this.name + "，方向：" + this.major);
    }
}

       (2) Configure em bean.xml.

    <bean id="teacher1" class="com.yht.example3.entity.Teacher">
        <property name="name" value="赵茜"></property>
        <property name="major" value="网络"></property>
    </bean>

       (3) Execute o teste de unidade.

    @Test
    public void testCommon(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
        Teacher teacher = context.getBean("teacher1", Teacher.class);
        teacher.showMessage();//教师：赵茜，方向：网络
    }

2. Instanciação estática de fábrica

       (1) Crie uma classe MyStaticFactory e um método estático createObject () para retornar a instância do Professor.

public class MyStaticFactory {
    public static Teacher createObject(){
        return new Teacher();
    }
}

       (2) Configure em bean.xml.

    <!--  静态工厂实例化  -->
    <!--  
        class：静态工厂的类。
        factory-method：静态工厂中的方法
      -->
    <bean id="teacher2" class="com.yht.example3.factory.MyStaticFactory" factory-method="createObject">
        <property name="name" value="孙飞"></property>
        <property name="major" value="人工智能"></property>
    </bean>

       (3) Teste de unidade realizado.

    @Test
    public void testStatic(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
        Teacher teacher = context.getBean("teacher2", Teacher.class);
        teacher.showMessage();//教师：孙飞，方向：人工智能
    }

3. Instanciação de fábrica de instância

       (1) Crie uma classe MyCommonFactory e crie um método createObject () para retornar a instância do Professor.

public class MyCommonFactory {
    public Teacher createObject(){
        return new Teacher();
    }
}

       (2) Configure em bean.xml.

    <!--  实例工厂实例化  -->
    <!--
        factory-bean :指向配置的实例工厂
        factory-method：静态工厂中的方法
      -->
    <bean id="teacher3" factory-bean="teacherFactory" factory-method="createObject">
        <property name="name" value="郭安"></property>
        <property name="major" value="车联网"></property>
    </bean>
    <!-- 配置工厂 -->
    <bean id="teacherFactory" class="com.yht.example3.factory.MyCommonFactory"></bean>

       (3) Teste de unidade realizado.

    @Test
    public void testInstance(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean4.xml");
        Teacher teacher = context.getBean("teacher3", Teacher.class);
        teacher.showMessage();//教师：郭安，方向：车联网
    }

4. A diferença entre os três métodos de instanciação

　　Instanciação do construtor: instanciar o Bean através do método de construção sem parâmetros, cuja essência é entregar a classe correspondente do Bean para a própria fábrica do Spring (BeanFactory) para gerenciamento, e o modelo de fábrica do próprio Spring nos ajuda a criar e manter isso aula.

　　Método de instanciação da fábrica estática: crie e retorne o Bean por meio da fábrica estática. A essência é entregar a classe correspondente do Bean ao nosso próprio gerenciamento estático de fábrica. O Spring apenas nos ajudou a chamar o método de criação de uma instância da fábrica estática. Aplicação: Muitas vezes quando usamos a classe fornecida pelo pacote jar de terceiros, porque esta classe não possui método de construção, ela é criada através da fábrica estática fornecida pelo pacote de terceiros. pacote jar de terceiros Se gerenciado pelo Spring, você pode usar a fábrica estática fornecida pelo Spring para criar a configuração da instância.

　　Forma de instanciação da fábrica de instâncias: crie e retorne o Bean por meio da fábrica de instâncias. A essência é entregar o processo de criação da classe fábrica e chamar o método da classe fábrica para o método de criação da instância por Spring. O processo de criação a instância também é nossa. A fábrica de instâncias configurada é implementada internamente. Aplicação: Por exemplo, a integração do Spring e Hibernate é conseguida desta forma. Mas para classes de fábrica que não foram integradas ao Spring, geralmente as gerenciamos com código.