一、介绍

1.set注入和构造器注入是什么？

spring的控制反转（IOC）与依赖注入实现方式（DI）_云边的快乐猫的博客-CSDN博客

2.通俗的理解

已知：当前的spring框架不需要自己创建对象了。这些对象都交给spring的bean容器去管理。

那么想要这些对象想要关联起来或者传值进去怎么办呢？

那就要用到注入。例如一个Cat猫类对象想要使用Dog狗类中的方法。那么怎么办呢？

按照以前没有使用spring的思路就是：在Cat类中去实例化Dog类，然后调用Dog类的方法

用spring后：那就是在统一托管对象的spring容器里面去调用就好了。Cat类直接在spring容器里面调用Dog的方法就可以了

3.set注入和构造器注入的核心原理

（1）set注入的核心原理

通过反射机制调用set方法给属性赋值，让两个对象之间产生关系

（2）构造器注入的核心原理

通过调用构造方法来给属性赋值

4.set注入和构造器注入的类型

set注入有两种类型：引用类型、简单类型

构造器有两种类型：引用类型、简单类型

引用类型和简单类型区别：java数据类型（8个基本数据类型+3个引用数据类型）与数据类型转换知识点_java三种引用数据类型_云边的快乐猫的博客-CSDN博客

5.set注入的外部bean和内部bean

（1）外部bean：在spring的自定义xml配置bean文件中配置的bean含有ref引用的就是外部bean

（2）内部bean：在spring的自定义xml配置bean文件中配置的property标签再内嵌一个bean（不含id）

二、set注入和构造器注入例子步骤（引用数据类型）

（一）set注入

实验目标：创建一个Dog类，一个Cat类，交给spring中心托管。然后把Dog类的方法注入到Cat类里面，让Cat类去调用。本项目用的是maven项目

这里面有创建maven项目的方法

快速入门使用spring详细步骤（介绍、导入依赖、第一个简单程序）_云边的快乐猫的博客-CSDN博客

1.创建一个Dog类

package com.spring6.bean;

public class Dog {
    //1.新建一个方法
    public void DogEat(){
        System.out.println("这是狗的方法");
    }
}

2.创建一个Cat类

ps：被注入的Cat类里面要先写入要注入目标的私有对象.类.方法。然后生成一个set方法

然后类本身创建一个方法，去调用这个注入的对象方法

package com.spring6.bean;

public class Cat {
//一、要注入Cat里面的方法
    //1.Dog私有方法
    private Dog DogEat;
    //2.生成一个set方法
    public void setDog(Dog dog) {
        this.DogEat = dog;
    }

//二、写Cat自己的方法
    public void cat(){
        //3.调用注入狗的方法
        DogEat.DogEat();
    }
}

3.Dog类和Cat类统一交给spring管理

步骤：在resources里面创建一个配置xml文件。然后写入Dog和Cat这两个类的spring管理方式。

注入类：Dog。被注入类：Cat。就像Cat类里面被针管容器注入Dog类的方法

ps：不理解创建这个xml文件的可以看这篇文章

快速入门使用spring详细步骤（介绍、导入依赖、第一个简单程序）_云边的快乐猫的博客-CSDN博客

<?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">

    <!--1.配置Dog的XML文件 id：自定义。class：类的全限名-->
    <bean id="DogBean" class="com.spring6.bean.Dog"/>

    <!--2..配置cat的XML文件  ps：被注入的类里面要添加注入的-->
    <bean id="catBean" class="com.spring6.bean.Cat">
    <!--name这里填的是：注入里面set方法去除set后，并首字母改为小写的单词。ref翻译为引用的意思 ref后面指定的是注入的id-->
        <property name="dog" ref="DogBean"/>
    </bean>
</beans>

4.Test测试的java包里面创建一个包一个测试类去测试运行

package com.spring6.text;

import com.spring6.bean.Cat;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class springTText {
    @Test
    public void TT(){
        //1.半固定写法，扫描spring的xml文件（不固定的是要扫描的是哪个xml文件）
        ApplicationContext applicationContext =new ClassPathXmlApplicationContext("spring.xml");
        //2.半固定写法，获取spring里面要进行运行的类（不固定的是括号里面的，name为：要运行类的id，后面跟着的是要运行的类.class）
        Cat catBean = applicationContext.getBean("catBean", Cat.class);
        //3.上面自定义名.要运行类的方法
        catBean.cat();
    }
}

5.运行结果（Cat类被注入了Dog类的方法）

（二）构造器注入

实验目标：创建一个Dog类，一个Cat类，交给spring中心托管。然后把Dog类的方法注入到Cat类里面，让Cat类去调用。 目标和set一样，用的方式不一样而已

1.创建一个Dog类

package com.spring6.bean;

public class Dog {
    //1.新建一个方法
    public void DogEat(){
        System.out.println("这是狗的方法");
    }
}

2.创建一个Cat类

ps：被注入的Cat类里面要先写入要注入目标的私有对象.类.方法。然后生成一个构造方法

然后类本身创建一个方法，去调用这个注入的对象方法

3.Dog类和Cat类统一交给spring管理

步骤：在resources里面创建一个配置xml文件。然后写入Dog和Cat这两个类的spring管理方式。

注入类：Dog。被注入类：Cat。就像Cat类里面被针管容器注入Dog类的方法

ps：区别就是注入的这里这个可以自动扫描，也可以用name，也可以用序列号

<?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">

    <!--1.配置Dog的XML文件 id：自定义。class：类的全限名-->
    <bean id="DogBean" class="com.spring6.bean.Dog"/>

    <!--2..配置cat的XML文件  ps：被注入Cat类里面要添加注入的Dog-->
    <bean id="catBean" class="com.spring6.bean.Cat">
    <!--constructor-arg这个会自动扫描。ref翻译为引用的意思 ref后面指定的是注入Dog的id-->
        <constructor-arg ref="DogBean"/>
    </bean>
</beans>

4.Test测试的java包里面创建一个包一个测试类去测试运行

ps：这个和set注入的第4步一样

package com.spring6.text;

import com.spring6.bean.Cat;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class springTText {
    @Test
    public void TT(){
        //1.半固定写法，扫描spring的xml文件（不固定的是要扫描的是哪个xml文件）
        ApplicationContext applicationContext =new ClassPathXmlApplicationContext("spring.xml");
        //2.半固定写法，获取spring里面要进行运行的类（不固定的是括号里面的，name为：要运行类的id，后面跟着的是要运行的类.class）
        Cat catBean = applicationContext.getBean("catBean", Cat.class);
        //3.上面自定义名.要运行类的方法
        catBean.cat();
    }
}

5.运行结果（Cat类被注入了Dog类的方法）

ps：这个和set注入的第5步一样

二、set注入和构造器注入例子步骤（简单数据类型）

实验目标：创建一个User类，属性有名字和年龄。用spring的xml方式注入具体的值

（一）set注入

1.创建一个User类。里面带有名字和年龄属性，快捷键生成set方法和toString方法

package com.spring6.bean;

public class User {
    //1.创建类的属性
    private String username;
    private int age;
    //2.快捷键生成set方法

    public void setUsername(String username) {
        this.username = username;
    }

    public void setAge(int age) {
        this.age = age;
    }
    //3.快捷键生成toString方法
    @Override
    public String toString() {
        return "User{" +
                "username='" + username + '\'' +
                ", age=" + age +
                '}';
    }
}

2.创建一个spring的xml文件里面配置bean和注入属性具体的值

<?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">

    <!--1.配置User的XML文件   id:自定义  class：要设置类的全限名-->
    <bean id="userBean" class="com.spring6.bean.User">
    <!--2.用property name:要注入的属性名称  简单类型用value：注入属性的值        -->
        <property name="username" value="张三"/>
        <property name="age" value="18"/>
    </bean>
</beans>

3. Test测试的java包里面创建一个包一个测试类去测试运行

package com.spring6.text;

import com.spring6.bean.User;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class springTText {
    @Test
    public void TT(){
        //1.半固定写法，扫描spring的xml文件（不固定的是要扫描的是哪个xml文件）
        ApplicationContext applicationContext =new ClassPathXmlApplicationContext("spring.xml");
        //2.半固定写法，获取spring里面要进行运行的类（不固定的是括号里面的，name为：要运行类的id，后面跟着的是要运行的类.class）
        User username = applicationContext.getBean("userBean", User.class);
        //3.运行这个方法
        System.out.println(username);
    }
}

4.运行结果

（二）构造器注入

1.创建一个User类。快捷键生成构造器方法和toString方法

package com.spring6.bean;

public class User {
    //1.创建类的属性
    private String username;
    private int age;

    public User(String username, int age) {
        this.username = username;
        this.age = age;
    }

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

2.创建一个spring的xml文件里面配置bean和注入属性具体的值

<?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">

    <!--1.配置User的XML文件   id:自定义  class：要设置类的全限名-->
    <bean id="userBean" class="com.spring6.bean.User">
    <!--2.constructor-arg:自动扫描属性  value：里面填入要注入属性的具体值 -->
        <constructor-arg  value="李四"/>
        <constructor-arg  value="19"/>
    </bean>
</beans>

3. Test测试的java包里面创建一个包一个测试类去测试运行

package com.spring6.text;

import com.spring6.bean.User;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class springTText {
    @Test
    public void TT(){
        //1.半固定写法，扫描spring的xml文件（不固定的是要扫描的是哪个xml文件）
        ApplicationContext applicationContext =new ClassPathXmlApplicationContext("spring.xml");
        //2.半固定写法，获取spring里面要进行运行的类（不固定的是括号里面的，name为：要运行类的id，后面跟着的是要运行的类.class）
        User username = applicationContext.getBean("userBean", User.class);
        //3.运行这个方法
        System.out.println(username);
    }
}

4.运行结果

ps：感觉set注入和构造注入就快捷键生成的代码不一样，一个生成set方法，一个生成构造器方法。xml配置里面也有些细微不一样而已，其他的大致一样

spring的注入（set注入、构造器注入）

1.set注入和构造器注入是什么？

2.通俗的理解

3.set注入和构造器注入的核心原理

4.set注入和构造器注入的类型

5.set注入的外部bean和内部bean

二、set注入和构造器注入例子步骤（引用数据类型）

（一）set注入

1.创建一个Dog类

2.创建一个Cat类

3.Dog类和Cat类统一交给spring管理

4.Test测试的java包里面创建一个包一个测试类去测试运行

5.运行结果（Cat类被注入了Dog类的方法）

（二）构造器注入

1.创建一个Dog类

2.创建一个Cat类

3.Dog类和Cat类统一交给spring管理

4.Test测试的java包里面创建一个包一个测试类去测试运行

5.运行结果（Cat类被注入了Dog类的方法）

二、set注入和构造器注入例子步骤（简单数据类型）

（一）set注入

1.创建一个User类。里面带有名字和年龄属性，快捷键生成set方法和toString方法

2.创建一个spring的xml文件里面配置bean和注入属性具体的值

3. Test测试的java包里面创建一个包一个测试类去测试运行

4.运行结果

（二）构造器注入

1.创建一个User类。快捷键生成构造器方法和toString方法

2.创建一个spring的xml文件里面配置bean和注入属性具体的值

3. Test测试的java包里面创建一个包一个测试类去测试运行

4.运行结果

相关推荐

菜鸟笔记

热门教程

1.set注入和构造器注入是什么？

2.通俗的理解

3.set注入和构造器注入的核心原理

4.set注入和构造器注入的类型

5.set注入的外部bean和内部bean

二、set注入和构造器注入例子步骤（引用数据类型）

（一）set注入

1.创建一个Dog类

2.创建一个Cat类

3.Dog类和Cat类统一交给spring管理

4.Test测试的java包里面创建一个包一个测试类去测试运行

5.运行结果（Cat类被注入了Dog类的方法）

（二）构造器注入

1.创建一个Dog类

2.创建一个Cat类

3.Dog类和Cat类统一交给spring管理

4.Test测试的java包里面创建一个包一个测试类去测试运行

5.运行结果（Cat类被注入了Dog类的方法）

二、set注入和构造器注入例子步骤 （简单数据类型）

（一）set注入

1.创建一个User类。里面带有名字和年龄属性，快捷键生成set方法和toString方法

2.创建一个spring的xml文件里面配置bean和注入属性具体的值

3. Test测试的java包里面创建一个包一个测试类去测试运行

4.运行结果

（二）构造器注入

1.创建一个User类。快捷键生成构造器方法和toString方法

2.创建一个spring的xml文件里面配置bean和注入属性具体的值

3. Test测试的java包里面创建一个包一个测试类去测试运行

4.运行结果

相关推荐

菜鸟笔记

热门教程

二、set注入和构造器注入例子步骤（简单数据类型）