bean实例化的三种方式 bean标签常用属性单例模式和多例模式的对象 BeanFactory和ApplicationContext:

学习网站/博客：

spring https://spring.io/

The loC Container https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#beans

Spring官方文档（中文版！！！） https://blog.csdn.net/li1376417539/article/details/104951358/

1.bean实例化的三种方式：

页面结构整体布局：

运行结果如下：

代码如下：

pom.xml:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>lesson0820_spring</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

    <dependencies>
        <!--引入spring-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.18</version>
        </dependency>
    </dependencies>


</project>

Student:

package com.entity;

public class Student {

    public Student(){
        System.out.println("这是Student的构造方法...");
    }

    public void introduce(){
        System.out.println("我是一个学生");
    }
}

MyStaticFactory :

package com.factory;

import com.entity.Student;

/**
 * 静态工厂
 */
public class MyStaticFactory {
    /**
     * 静态返回学生实例
     * @return
     */
    public static Student createInstance(){
        System.out.println("调用静态工厂.....MyStaticFactory...createInstance");
        return new Student();
    }
}

MyInstanceFactory :

package com.factory;

import com.entity.Student;

/**
 * 实例工厂
 */
public class MyInstanceFactory {
    /**
     * 定义创建对象的实例方法
     * @return
     */
    public Student createInstance(){
        return new Student();
    }
}

Test:

package com.test;

import com.entity.Student;
import com.factory.MyInstanceFactory;
import com.factory.MyStaticFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {
    public static void main(String[] args) {
        //Student student = new Student();
        //创建spring bean容器对象
        ApplicationContext ac = new ClassPathXmlApplicationContext("spring-1.xml");
//        Student student = ac.getBean(Student.class);

        //静态工厂创建的对象，通过id名字，获取bean对象
//        Student s = (Student) ac.getBean("stu");
//        s.introduce();

        //实例工厂方式创建对象
        Student s2 = (Student) ac.getBean("stu2");
        s2.introduce();

    }
}

spring-1.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"
        default-lazy-init="true"
        >

    <!--class属性必须配置，用于指明要创建的bean对象的类型
        lazy-init="true":延迟加载(懒汉模式)
        1.bean的方式定义对象
    -->
<!--    <bean class="com.entity.Student" lazy-init="true"/>-->

    <!--2.静态工厂方式创建学生对象-->
    <bean id="stu" class="com.factory.MyStaticFactory" factory-method="createInstance"/>

    <!--3.实例工厂创建对象-->
    <bean id="fac" class="com.factory.MyInstanceFactory"/>
    <bean id="stu2" factory-bean="fac" factory-method="createInstance"/>

</beans>

2.bean标签常用属性：

代码整体布局：

运行结果：

添加/修改的代码如下：

spring-2.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"
    >

    <!--
    class属性：用于指定要创建的bean对象的类型，必须写的属性
    id属性: 用于唯一标识该类型对象，不能重复，但是可以省略
    name属性: 可以认为是对bean对象起的别名，可以设置多个名字，用空格或逗号分隔。
             现在一般不用
    lazy-init:是否是延迟加载(懒汉，饿汉)。可以在beans中配置全局的延迟加载属性default-lazy-init
    scope:定义创建对象的方式和范围,singleton(单例),prototype(多例),request,session,global-session
          singleton(单例):表示容器中，只有一个对象，每次获取的都是同一个对象
          prototype(多例):每次都是new一个新的对象返回
    init-method:定义bean生命周期的初始化函数
    destroy-method:定义bean生命周期的销毁函数
    -->
    <bean id="stu"
          name="s1 s2"
          class="com.entity.Student"
          lazy-init="true"
          scope="prototype"
          init-method="initStu"
          destroy-method="destroyStu" />
</beans>

Student:（修改）

package com.entity;

import org.springframework.beans.factory.annotation.Autowired;

public class Student {

    public Student(){
        System.out.println("这是Student的构造方法...");
    }

    //自我介绍
    public void introduce(){
        System.out.println("我是一个学生");
    }

    //学生初始化
    public void initStu(){
        System.out.println("调用了学生的初始化方法");
    }

    //学生销毁
    public void destroyStu(){
        System.out.println("调用了学生的销毁方法");
    }
}

(test)Test2:

package com.test;

import com.entity.Student;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test2 {
    public static void main(String[] args) {
        //创建spring容器
        ApplicationContext ctx = new ClassPathXmlApplicationContext("spring-2.xml");
        //根据id获取学生对象
        Student s1 =(Student) ctx.getBean("stu");
        System.out.println("s1:"+s1);
        //根据类型获取学生对象
        Student s2 = (Student) ctx.getBean(Student.class);
        System.out.println("s2:"+s2);
        //根据id和类型获取学生对象
        Student s3 = ctx.getBean("stu",Student.class);
        System.out.println("s3:"+s3);
        //根据name属性获取学生对象
        Student s4 = (Student) ctx.getBean("s1");
        Student s5 = (Student) ctx.getBean("s2");
        System.out.println("s4:"+s4);
        System.out.println("s5:"+s5);

    }
}

3.单例模式和多例模式的对象：

运行结果：

God:

package com.singleton;

public class God {

    public void createWorld(){
        System.out.println("上帝创造了世界....");
    }
}

Test:

package com.singleton;

public class Test {
    public static void main(String[] args) {
        God god = new God();
        god.createWorld();
        System.out.println(god);

        God god2 = new God();
        god2.createWorld();
        System.out.println(god2);
    }
}

（singleton）God:(添加)

package com.singleton;

public class God {

    //3.定义静态私有对象
    private static God god;

    //1.构造私有化
    private God(){

    }

    //2.定义静态工厂获取实例的方法，用于获取对象
    public static God createInstance(){
        if (god==null){
            god = new God();
        }
        return god;
    }

    public void createWorld(){
        System.out.println("上帝创造了世界....");
    }
}

（singleton）Test:(添加)

package com.singleton;

public class Test {
    public static void main(String[] args) {
        God god = God.createInstance();
        god.createWorld();
        System.out.println(god);

        God god2 = God.createInstance();
        god2.createWorld();
        System.out.println(god2);

    }
}