Spring DI依赖注入（2）用注解实现注入

最新推荐文章于 2024-10-06 14:11:41 发布
最新推荐文章于 2024-10-06 14:11:41 发布
阅读量204 收藏
点赞数
文章标签： spring java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_52095645/article/details/132157117
版权

目录

一、注解

1.将一个类声明为Bean的注解

2.属性装配

二、使用注解实现实体类的注入

三、使用注解实现三层架构注入

四、Bean的生命周期 

1.Bean的生命周期

2.案例代码演示

1.单例

2.多例（修改上述模式为prototype即可）

一、注解

1.将一个类声明为Bean的注解

        @Component：定义通用Bean的注解，可标注任意类为Bean。如果一个Bean不知道属于哪个层，可以使用@Component注解标注。

        @Repository：定义数据访问层Bean的注解。

        @Service：定义业务层Bean的注解。

        @Controller：定义控制层Bean的注解

2.属性装配

        @Autowired:Spring提供的注解，默认的注入方式为byType（按类型自动注入）

        @Qualifier（value = "属性名"）:根据byName的方式自动装配，不能单独使用，配合@Autowired使用

        @Resource：JDK提供的注解，默认注入方式为byName（按名称自动注入），可以单独使用

        @Value：实体类属性赋值，读取.properties结尾的文件进行赋值

二、使用注解实现实体类的注入

1.以学生类为例，定义两个属性，加入有参和无参的构造方法

package com.apesource.pojo;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.beans.factory.config.ConfigurableBeanFactory;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

@Component(value = "student")
@Scope(ConfigurableBeanFactory.SCOPE_SINGLETON)
public class Student {
    @Value("${msg1}")
    private String stuName;
    @Value("${msg2}")
    private int stuAge;

    @Override
    public String toString() {
        return "Student{" +
                "stuName='" + stuName + '\'' +
                ", stuAge=" + stuAge +
                '}';
    }

    public Student() {
        System.out.println("通过无参构造方法创建实例化对象");
    }

    public Student(String stuName, int stuAge) {
        this.stuName = stuName;
        this.stuAge = stuAge;
    }
}

2.在resource路径下创建spring config格式的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"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd"

>
<!--    自动扫描-->
    <context:component-scan base-package="com.apesource"></context:component-scan>
<!--    加载读取路径-->
    <context:property-placeholder location="classpath:msg.properties"></context:property-placeholder>
</beans>

三、使用注解实现三层架构注入

1.从数据访问层开始，继承接口，重写方法


//接口
public interface Dao {
    public void save();
}

@Repository(value = "dao")
public class DaoImp implements Dao{

    @Override
    public void save() {
        System.out.println("数据访问层");

    }
}

2.业务层继承接口重写方法，注入数据访问层，并实现方法的调用

public interface IService {
    public void save();
}
@Service(value = "service")
public class ServiceImp implements IService {
//    @Autowired     //自动装配
//    @Qualifier(value = "daoImpCopy")    //按照名称装配(配合@Autowired)

    @Resource(name = "dao")   //按名称装配(单独使用)
    Dao dao;

    public void setDao(Dao dao) {
        this.dao = dao;
    }

    @Override
    public void save() {
        System.out.println("业务层");
        dao.save();
    }
}

3.控制层继承接口，重写方法并注入业务层属性

public interface IController {
    public void save();
}
@Controller(value = "controller")
public class ControllerImp implements IController {
    @Autowired
    IService service;

    public void setService(IService service) {
        this.service = service;
    }

    @Override
    public void save() {
        System.out.println("控制层");
        service.save();
    }
}

4.测试

public class Test01 {
    public static void main(String[] args) {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("application.xml");
        IController controller = (IController) applicationContext.getBean("controller");
        controller.save();
    }
}

四、Bean的生命周期 

1.Bean的生命周期

1.实例化

2.属性赋值

3.初始化

        3.1接口初始化InitializingBean

        3.2属性初始化init-method

4.操作使用

5.销毁

        5.1接口销毁DisposableBean

        5.2属性销毁destory-method

2.案例代码演示

1.首先，构造一个实体类，在实体类中创建一个无参构造方法：

2.实体类实现初始化和销毁接口，重写接口和属性方法：

package com.apesource.pojo;

import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;

public class Teacher implements InitializingBean, DisposableBean{
    private String tName;
    private int tAge;

    public Teacher() {
        System.out.println("通过无参构造方法实例化");
    }
    //属性赋值
    public void settName(String tName) {
        System.out.println("属性赋值");
        this.tName = tName;
    }

    public void settAge(int tAge) {
        this.tAge = tAge;
    }

    @Override
    public void destroy() throws Exception {
        System.out.println("接口销毁");
    }
    public void doDestroy(){
        System.out.println("属性销毁");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("接口初始化");
    }
    public void doInit(){
        System.out.println("属性初始化");
    }

    @Override
    public String toString() {
        return "Teacher{" +
                "tName='" + tName + '\'' +
                ", tAge=" + tAge +
                '}';
    }
}

3.在xml文件中配置相关信息：注入实体类、初始化方法和销毁方法

<!--    bean的生命周期-->
    <bean id="teacher" class="com.apesource.pojo.Teacher" init-method="doInit" destroy-method="doDestroy">
        <property name="tName" value="老师"></property>
        <property name="tAge" value="33"></property>
    </bean>

4.测试输出：

import com.apesource.pojo.Teacher;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
/*
* springIOC容器对bean管理
*/
public class Test01 {
    public static void main(String[] args) {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("application.xml");
        //生命周期
        ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("application.xml");
        Teacher teacher = (Teacher) classPathXmlApplicationContext.getBean("teacher");
        System.out.println(teacher);
        classPathXmlApplicationContext.close();
}

测试结果:

五、Bean的作用域

Spring中，bean作用域用于确定那种类型的bean实例从Spring容器中返回给调用者。

作用域描述
singletonBean在IOC容器中只存在一个实例，无论是获取Bean还是装配Bean都是同一个对象
prototype每次对Bean的请求都会创建一个新的实例，无论获取Bean还是装配Bean，都是一个新的实例对象
request每次http请求都会创建新的Bean实例，请求和响应共享Bean（只能在SpringMVC框架中使用）
session用于会话的共享Bean（只能在SpringMVC框架中使用）
application在Context中定义一个Bean（只能在SpringMVC框架中使用）
websocket在HTTP WebSocket生命周期中定义一个Bean（只能在SpringMVC框架中使用）

1.单例

A.注解版

1.构造一个实体类并使用Compoent注入容器，在xml文件中添加读取路径；

package com.apesource.pojo;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.beans.factory.config.ConfigurableBeanFactory;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

@Component(value = "student")
@Scope(ConfigurableBeanFactory.SCOPE_SINGLETON)
public class Student {
    @Value("${msg1}")
    private String stuName;
    @Value("${msg2}")
    private int stuAge;

    @Override
    public String toString() {
        return "Student{" +
                "stuName='" + stuName + '\'' +
                ", stuAge=" + stuAge +
                '}';
    }

    public Student() {
        System.out.println("通过无参构造方法创建实例化对象");
    }

    public Student(String stuName, int stuAge) {
        this.stuName = stuName;
        this.stuAge = stuAge;
    }
}

2.在实体类上添加@Scope注解开启作用域的配置，设置工厂模式为单例，在xml中添加自动扫描配置文件；

<!--    自动扫描-->
    <context:component-scan base-package="com.apesource"></context:component-scan>

3.测试输出；

package com.apesource.test;

import com.apesource.controller.IController;
import com.apesource.pojo.Student;
import com.apesource.pojo.Teacher;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/*
 * springIOC容器对bean管理
 */
public class Test01 {
    public static void main(String[] args) {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("application.xml");
        //@Scope作用域
        Student student1 = (Student) applicationContext.getBean("student");
        Student student2 = (Student) applicationContext.getBean("student");
        System.out.println(student1==student2);
}

测试结果：

B.XML版

1.构造实体类

package com.apesource.pojo;

public class Student {
    private String stuName;
    private int stuAge;

    @Override
    public String toString() {
        return "Student{" +
                "stuName='" + stuName + '\'' +
                ", stuAge=" + stuAge +
                '}';
    }

    public Student() {
        System.out.println("通过无参构造方法创建实例化对象");
    }

    public Student(String stuName, int stuAge) {
        this.stuName = stuName;
        this.stuAge = stuAge;
    }

    public String getStuName() {
        return stuName;
    }

    public void setStuName(String stuName) {
        this.stuName = stuName;
    }

    public int getStuAge() {
        return stuAge;
    }

    public void setStuAge(int stuAge) {
        this.stuAge = stuAge;
    }
}

2.在xml中进行相关配置，设置scope="singleton";

<!--    bean的作用域-->
    <bean id="student" class="com.apesource.pojo.Student" scope="singleton">
        <property name="stuName" value="学生"></property>
        <property name="stuAge" value="18"></property>
    </bean>

3.测试输出；

package com.apesource.test;

import com.apesource.controller.IController;
import com.apesource.pojo.Student;
import com.apesource.pojo.Teacher;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/*
 * springIOC容器对bean管理
 */
public class Test01 {
    public static void main(String[] args) {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("application.xml");
        //@Scope作用域
        Student student1 = (Student) applicationContext.getBean("student");
        Student student2 = (Student) applicationContext.getBean("student");
        System.out.println(student1);
        System.out.println(student2);
        System.out.println(student1==student2);
}

2.多例（修改上述模式为prototype即可）

测试结果：

起个有趣的名字好难
关注
解析Spring DI 依赖注入的5种方式
CenterLogo
04-28 1320
一、什么是DI DI，是dependence injection的简称，译为依赖注入，和上一篇解释的IOC控制反转思想是一个意思，IOC是用来创建对象的思想，DI依赖注入，就是在配置Spring容器（xxx.xml文件）创建对象的同时为对象注入属性值。而依赖注入的方式有5种：Setter注入（set方法注入）、interface注入（接口注入）、constructor注入（构造注入）、autowi...
Spring常见的依赖注入多种实现方式
qq_41644707的博客
02-28 464
在实际开发中，如果依赖项可能发生变化，或者是可选的，可以考虑使用Setter方法注入。在接口中定义依赖项的setter方法，然后在实现类中实现该方法，将依赖项注入到对象中。注解注入是一种简单便捷的依赖注入方式，可以保证依赖项的可变性。在构造方法中，将依赖项作为参数传入，然后在对象被创建时将其保存在成员变量中。在依赖项上添加注解，然后在对象中使用@Autowired注解将依赖项注入到对象中。接口注入相对于构造方法注入和Setter方法注入，需要定义额外的接口，增加了代码复杂度，但可以保证依赖项的可变性。
Spring框架的依赖注入方式
weixin_62282158的博客
08-28 337
三种注入方式简介和简单代码案例
【精选】SpringDI依赖注入及注解实现SpringIoC
guojiaqi_的博客
11-28 1190
依赖注入（Dependency Injection，简称DI），它是Spring控制反转思想的具体实现。 控制反转将对象的创建交给了Spring，但是对象中可能会依赖其他对象。比如service类中要有dao类的属性，我们称service依赖于dao。
Spring DI简介及依赖注入方式和依赖注入类型
qq_53317005的博客
04-30 5574
Spring DI简介及依赖注入方式和依赖注入类型
使用注解实现 Spring 依赖注入
FireFox1997
06-22 536
依赖注入（Dependency Injection, DI）是一种设计模式，它将对象的依赖交给外部容器管理，而不是在对象内部自行创建这些依赖。Spring 框架通过 IoC（控制反转）容器实现了依赖注入，允许开发者轻松地管理对象及其依赖关系。Spring 提供了一系列注解，用于实现依赖注入。
Spring DI依赖注入（1） xml方式实现注入
weixin_52095645的博客
08-07 171
xml方式实现依赖注入
Spring--DI依赖注入详解
tq02的博客
03-29 1397
三种详细注入方式，构造注入、Setter注入、属性注入，以及@Autowired和@Resource两者区别
Spring 依赖注入详解
swadian2008的博客
10-25 4816
/ 依赖关系，指的就是对象之间的相互协作关系依赖注入（DI）是一个过程，在这个过程中，对象仅通过构造函数参数、工厂方法的参数或在对象被实例化后通过属性设置来定义它们的依赖项（即与该对象一起工作的其他对象）。然后，容器在创建 bean 时注入这些依赖项。这个过程基本上是与对象直接通过构造类或等机制来控制其依赖项的实例化或位置是相反的，因此得名控制反转。// 对象不直接创建自己，而是通过 Spring 容器创建，那么 Spring 容器是如何创建对象的？
SpringDI四种依赖注入方式详解
奈何的人生
07-18 1901
深入理解SpringDi依赖注入思想，关注DI与IOC的关系，详细列举了四种依赖注入的使用步骤详解
java Spring DI依赖注入.rar
01-30
2. 注解配置：使用如`@Component`、`@Service`、`@Repository`和`@Controller`等注解标记bean，使用`@Autowired`进行依赖注入。例如： ```java @Service public class Service { private final Dependency ...
Spring Ioc 注解 依赖注入
05-26
### Spring IoC与注解依赖注入详解 #### 一、Spring框架简介 Spring框架是由Rod Johnson创建的一个开源项目，最初是为了解决企业级应用开发中的复杂性问题而诞生的。Spring框架的核心特性包括IoC（Inversion of ...
Spring依赖注入DI.zip
08-08
Spring框架的依赖注入（Dependency Injection，简称DI）是其核心特性之一，它使得应用程序的组件之间可以松散耦合，增强了代码的可测试性和可维护性。在Spring框架中，DI通过控制反转（Inversion of Control，IoC）...
【Spring Security】基于SpringBoot3.3.4版本②如何配置免鉴权Path
Java技术栈，分享不断学习、不断超越、不断积累的历程！
10-03 1281
[【Spring Security】基于SpringBoot3.3.4版本①整合JWT的使用教程](https://blog.csdn.net/friendlytkyj/article/details/142679120) 在这篇文章中，详细演示了使用最新版`Spring Boot`，完成一个微服务开发，并使用`Spring Security`组件完成登录认证，同时整合了`JWT`，使用的`RSA`公私钥签名、验签。 接下来继续讲解下一个业务场景：一个真实场景的微服务，难免会有一些请求`Path`不需要任
SpringBoot实现社区医院数据集成解决方案
2401_85743969的博客
10-01 952
同时，一个大型的计算机网站系统，必须有一个正确的设计指导思想，通过合理选择数据结构、网络结构、操作系统以及开发环境，构成一个完善的网络体系结构，才能充分发挥计算机信息管理的优势。随着计算机技术的发展以及计算机网络的逐渐普及，互联网成为人们查找信息的重要场所，二十一世纪是信息的时代，所以信息的管理显得特别重要。随着互联网技术的快速发展，网络时代的到来，网络信息也将会改变当今社会。2.高可靠性：一个实用的网站同时必须是可靠的，本设计通过合理而先进的网络设计以及软、硬件的优化选型，可保证网站的可靠性与容错性。
Spring
m0_74728220的博客
10-02 1227
不直接创建对象，而是由容器创建，并设定一个或多个标识，需要的时候通过Bean名字从容器中获取，这看上去是类似于EJB的服务查找，但是Spring真正的核心是对于依赖的处理，使用配置的方式注入依赖。以A、B、C三个类为例，B、C都是单例模式的类，A需要调用B、C类的方法，这样A就和B、C形成了依赖，如果B、C交由容器管理，A虽然和容器产生依赖，但是依赖程度降低了。
SpringBoot
2301_78955442的博客
10-03 374
hellos的时候就 return hello worlds。hello的时候就 return hello world。并且在控制台也有相应的输出句子打印出来。1.SpringBoot的创建。springboot启动成功。
Springboot集成JSP报 404
最新发布
若初容若
10-06 229
Springboot集成JSP报 404。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

起个有趣的名字好难

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值