Spring——SpringIOC创建对象的方式、Spring配置文件简单介绍、Bean作用域及自动装配

Spring——SpringIOC创建对象的方式、Spring配置文件简单介绍

一、SpringIOC创建对象的方式

我们平时在创建对象的时候会使用无参构造、有参构造的方式创建。那么我们来看看Spring中怎么处理这两种情况。

创建实体类，并在实体类构造和set方法内部输出测试

package com.muhan.pojo;

public class User {
    private int id;
    private String name;
    private int age;

    public User() {
        System.out.println("User====无参构造");
    }

    public User(String name) {
        System.out.println("User====一个参参数的构造");
        this.name = name;
    }

    public User(String name, int age) {
        System.out.println("User====两个个参参数的构造");
        this.name = name;
        this.age = age;
    }

    public User(int id, String name, int age) {
        System.out.println("User====三个参参数的构造");
        this.id = id;
        this.name = name;
        this.age = age;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        System.out.println("User====setId方法被调用");
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        System.out.println("User====setName方法被调用");
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        System.out.println("User====setAge方法被调用");
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

测试代码：

import com.muhan.pojo.User;
import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class UserTest {
    @Test
    public void test(){
        //获取ClassPathXmlApplicationContext对象，关联spring配置文件applicationContext.xml
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        //获取对象名为user的对象
        User user = (User) context.getBean("user");
        System.out.println(user);
    }
}

(1)使用构造器通过下标注入

①使用三个参数构造器下标赋值：

    <!--1.使用构造器下标注入-->
    <bean id="user" class="com.muhan.pojo.User">
        <!--
            index=0：id
            index=1：name
            index=2：age
        -->
        <constructor-arg index="0" value="001"/>
        <constructor-arg index="1" value="张三"/>
        <constructor-arg index="2" value="18"/>
    </bean>

测试结果：

②使用两个参数构造器下标赋值：

    <!--2.使用构造器下标注入-->
    <bean id="user" class="com.muhan.pojo.User">
        <!--
            index=0：name
            index=1：age
        -->
        <constructor-arg index="0" value="张三"/>
        <constructor-arg index="1" value="18"/>
    </bean>

测试结果：

③使用一个参数的构造器下标赋值：

    <!--3.使用构造器下标注入-->
    <bean id="user" class="com.muhan.pojo.User">
        <constructor-arg index="0" value="张三"/>
    </bean>

测试结果：

④使用无参构造器创建对象：

    <!--4.使用构造器下标注入-->
    <bean id="user" class="com.muhan.pojo.User">
        
    </bean>

测试结果：

(2)使用构造器通过名称注入

①使用三个参数构造器通过名称注入

    <!--1..使用三个参数构造器通过名称注入-->
    <bean id="user" class="com.muhan.pojo.User">
        <constructor-arg name="id" value="001"/>
        <constructor-arg name="name" value="张三"/>
        <constructor-arg name="age" value="18"/>
    </bean>

测试结果：

②使用两个参数构造器通过名称注入

    <!--2.使用两个参数构造器通过名称注入-->
    <bean id="user" class="com.muhan.pojo.User">
        <constructor-arg name="name" value="张三"/>
        <constructor-arg name="age" value="18"/>
    </bean>

测试结果：

③使用一个参数构造器通过名称注入

    <!--3.使用一个参数构造器通过名称注入-->
    <bean id="user" class="com.muhan.pojo.User">
        <constructor-arg name="name" value="张三"/>
    </bean>

测试结果：

(3)setter注入

①使用setter注入一个值：

    <!--1.使用setter注入一个值-->
    <bean id="user" class="com.muhan.pojo.User">
        <property name="name" value="张三"/>
    </bean>

测试结果：

①使用setter注入两个值：

    <!--2.使用setter注入两个值-->
    <bean id="user" class="com.muhan.pojo.User">
        <property name="id" value="001"/>
        <property name="name" value="张三"/>
    </bean>

测试结果：

①使用setter注入三个值：

    <!--3.使用setter注入三个值-->
    <bean id="user" class="com.muhan.pojo.User">
        <property name="id" value="001"/>
        <property name="name" value="张三"/>
        <property name="age" value="18"/>
    </bean>

测试结果：

二、SpringIOC创建对象的方式总结

(1)注入方式：

• 1.通过构造注入（constructor-arg，下标与构造方法参数参数对应）
  • 通过下标（index）
    • 通过有参构造，无参构造
  • 通过参数名（name）
    • 通过有参构造，无参构造
• 2.通过setter注入（property，可以任意组合注入，默认调用无参构造和set方法）

(2)注意：

• 当我们使用setter（property）注入的时候，必须要有对应的set方法和无参构造（如果不写有参构造，默认会有无参构造），如果没有就会报错
• 当我们使用构造注入的时候，必须要有对应的构造方法，如果没有就会报错

三、Spring配置文件简单介绍

(1)bean

<!--bean讲解：
1.没有id，没有name，我们依旧可以获取这个对象，但是不建议使用、需要使用类的class对象获取；
    User bean = context.getBean(User.class);

2.id 就是对象的名字
3.class 就是要实例化的类
4.name就是别名
    有id的时候，name是别名 ， 没有id的时候，name就是对象的名字
    别名可以起多个
-->
<bean id="user" name="userTwo,user3" class="com.kuang.pojo.User">
    <property name="name" value="Spring"/>
</bean>

(2)alias

<!--alias讲解：
1. name ： 就是bean对象的id
2. alias ： 对象的别名
-->
<alias name="user" alias="user4"/>

(3)import

<!--import讲解
作用：导入另外一个资源，把另外配置文件装进来
    classpath*: 他会去所有地方寻找你的文件。【效率低】
    classpath: 只会在classpath中寻找文件，找不到就报错；【建议使用】
    file：填写文件路径url【不建议使用】
    http：填写网络路径url【不建议使用】
-->
<import resource="classpath*:userBeans.xml"/>
<import resource="classpath:userBeans.xml"/>
<import resource="file:"/>
<import resource="http:"/>

四、Bean作用域及自动装配（转载）

在Spring中，那些组成应用程序的主体及由SpringIOC容器所管理的对象，被称之为bean。简单地讲，bean就是由IOC容器初始化、装配及管理的对象。
配置文件中定义 Bean 时，我们不但可以配置 Bean 的属性值以及相互之间的依赖关系，还可以定义 Bean 的作用域 。作用域会对 Bean 的生命周期和创建方式产生影响 。
Bean 的作用域类型：

类型	说明
singleton	在 Spring 容器中仅存在一个 Bean 实例， Bean 以单例的形式存在，默认值。
prototype	每次从容器中调用 Bean 时，都会返回一个新的实例，即相当于执行 new XxxBean() 的实例化操作。
request	每次 http 请求都会创建一个新的 Bean ， 仅用于 WebApplicationContext 环境。request.setAttribute("","")
session	同一个 http Session 共享一个 Bean ，不同的 http Session 使用不同的 Bean，仅用于 WebApplicationContext 环境。session.setAttribute("","")
globalSession	同一个全局 Session 共享一个 bean, 用于 Porlet, 仅用于 WebApplication 环境。application.setAttribute("","")

Spring 以容器的方式，使得我们仅需配置，即可得到天然的单例模式。

在五种作用域中，request、session和globalSession三种作用域仅在web的应用中使用。

单列模式：该对象再内存中只存在一份
单列模式的实现方式有很多种，但是一般都是使用static关键字，让其成为静态共享资源
单列模式分为饿汉式和懒汉式，饿汉式的意思就是不管你要不要这个对象，我都给你提前创建好，在类加载的时候资源就加载；懒汉式是当需要时再加载。也就是说饿汉式和懒汉式最大的区别就是加载时机不同。
还有一种比较安全的实现方式是使用枚举实现单例模式

自动装配（了解）
自动装配的意思是说，当自动装配的属性和引用 的名称一样，可以使用自动装配

<bean id="myRole" class="com.kuang.dao.Role" p:id="101" p:name="管理员"/>

<!--自动装配，不建议使用，建议使用注解-->
<bean id="user" class="com.kuang.dao.User" autowire="byName"/>