Spring的简介ioc容器及注入方式

这篇具有很好参考价值的文章主要介绍了Spring的简介ioc容器及注入方式。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

一.Spring的简介

1.Spring的特性

Spring是一个开源框架，它由Rod Johnson创建。它是为了解决企业应用开发的复杂性而创建的。

   Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。

   然而，Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。

   目的：解决企业应用开发的复杂性

   功能：使用基本的JavaBean代替EJB，并提供了更多的企业应用功能

   范围：任何Java应用

   简单来说，Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架。

2.Spring模块

在Java开发中，通常将Spring框架分为以下七个主要模块：

Spring核心容器（Spring Core Container）：这是Spring框架的核心部分，提供了IoC（Inversion of Control，控制反转）和DI（Dependency Injection，依赖注入）的功能，用于管理和组织应用程序的组件和对象。

Spring应用上下文（Spring Application Context）：该模块建立在核心容器之上，提供了一种高级方式来访问配置文件和管理Bean的生命周期，同时支持国际化、事件传播等特性。

Spring AOP（Spring Aspect-Oriented Programming）：该模块实现了面向切面编程（AOP），用于将横切关注点（例如日志、事务、安全）与应用程序的业务逻辑分离开来，并以声明式的方式将它们作为可重用的模块应用到系统中。

Spring JDBC（Spring Java Database Connectivity）：该模块封装了JDBC（Java数据库连接）代码，提供了简化数据库访问的方式，并且支持声明式的事务管理。

Spring事务管理（Spring Transaction Management）：该模块为应用提供了一种管理事务的手段，支持编程式事务管理和声明式事务管理，并且可以与各种事务管理技术（如JTA、JDBC等）进行集成。

Spring Web MVC（Spring Model-View-Controller）：该模块是Spring框架的Web应用程序开发部分，提供了一种MVC（Model-View-Controller）的模式来组织和管理Web应用程序的代码，支持请求处理、视图解析、数据绑定等功能。

Spring测试（Spring Testing）：该模块提供了用于测试Spring应用程序的功能和工具，包括单元测试、集成测试、模拟对象等。

这些模块一起构成了Spring框架的基础，并且可以根据具体需求进行灵活的组合和使用。

3.spring的常用注解

在Spring框架中，有许多常用的注解，以下是其中一些常见的注解：

1. @Component：将一个类标记为Spring的组件，并将其纳入到Spring容器中进行管理。这是一个通用的注解，可以用于任何类。

2. @Controller：标记一个类为Spring MVC的控制器，用于处理Web请求和响应。

3. @Service：标记一个类为服务层组件，通常用于封装业务逻辑，被注入到其他层进行调用。

4. @Repository：标记一个类为数据访问层组件，通常用于操作数据库或其他持久化操作。

5. @Autowired：用于自动装配Spring容器中的Bean，可以在类的属性、构造方法或者方法上使用。

6. @Value：用于从属性文件或者环境变量中读取配置值，并注入到类的属性中。

7. @RequestMapping：用于映射HTTP请求的URL路径到控制器的处理方法，并指定请求的HTTP方法。

8. @ResponseBody：将控制器方法的返回值直接作为HTTP响应的内容，而不是跳转到视图。

9. @PathVariable：用于获取URL路径中的参数值，并将其注入到控制器方法的参数中。

10. @RequestParam：用于获取请求中的参数值，并将其注入到控制器方法的参数中。

11. @SessionAttribute：用于将模型中的属性存储到HTTP会话中，以便在多个请求之间共享。

12. @Transactional：用于标记一个方法或者类需要进行事务管理。

这些注解只是Spring框架中的一部分，还有很多其他功能强大的注解可供使用。根据具体情况和需求，你可以使用适合的注解来简化开发、提高效率。

二.ioc容器的特点

1.ioc的介绍

IOC（Inversion of Control，控制反转）是一种软件设计的原则，用于实现松耦合和可维护性的应用程序。在IOC容器中，控制权从应用程序代码转移到容器中，由容器负责实例化、管理和协调应用程序中的对象。

以下是IOC容器的一些特点：

控制反转：IOC容器通过控制反转的方式，将对象的控制权从应用程序代码转移到容器中。应用程序不需要手动创建对象，而是由容器创建和管理对象的生命周期。

依赖注入：IOC容器通过依赖注入的方式，自动解决对象之间的依赖关系。应用程序只需要声明依赖关系，容器会负责自动注入所需的依赖。

松耦合：IOC容器通过解耦对象之间的依赖关系，实现了松耦合。对象只需要关注自身的功能，而不需要关心如何获取依赖的对象。这样可以提高代码的可维护性和可测试性。

配置集中管理：IOC容器通常将对象的配置信息集中存储在配置文件或注解中，而不是分散在应用程序的各个地方。这样可以提高配置的可维护性和可重用性。

生命周期管理：IOC容器负责管理对象的生命周期，例如对象的创建、初始化、销毁等。容器可以根据配置和需要来管理对象的生命周期，确保对象的正确创建和销毁过程。

AOP支持：很多IOC容器提供对面向切面编程（AOP）的支持。通过AOP，可以将与核心业务逻辑无关的横切关注点（如日志、事务、安全等）从应用程序中剥离出来，实现代码的模块化和复用。

总之，IOC容器通过控制反转和依赖注入等机制，实现了对象的解耦和集中管理，提高了代码的可维护性和可测试性，同时也为AOP等功能提供了支持。许多流行的框架和技术，如Spring框架，就是基于IOC容器来构建和管理应用程序的。

2.代码演示

当使用IOC容器时，我们可以通过配置文件或注解来定义对象之间的依赖关系

1.先定义一个接口

package com.YU.ioc.service;

/**
 * @author YU
 * @create 2023-08-14 18:15
 *
 * 更改用户信息的接口
 */
public interface UserService {
    public void update();
}

2.然后创建两个实现类实现上面的接口

package com.YU.ioc.service.impl;

import com.YU.ioc.service.UserService;

/**
 * @author YU
 * @create 2023-08-14 18:17
 */
public class UserServiceImpl1 implements UserService {

    public void update() {
        System.out.println("更改用户个人信息");
    }
}

public class UserServiceImpl2 implements UserService {
    public void update() {
        System.out.println("用户注销");
    }
}

3.现在，我们可以使用Spring的IOC容器来管理对象的生命周期和依赖注入。首先，我们需要创建一个配置文件（如spring-context.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">
<!-- 凡是spring配置文件spring-context.xml中配置，那么该类JavaBean就交给了spring容器管理-->
    <bean class="com.YU.ioc.web.UserAction" id = "userAction">
        <property name="userService" ref="userService"></property>
    </bean>
    <bean class="com.YU.ioc.web.BookAction" id = "bookAction">
        <property name="userService" ref="userServiceImpl1"></property>
    </bean>
    <bean class="com.YU.ioc.service.impl.UserServiceImpl2" id = "userService"></bean>
    <bean class="com.YU.ioc.service.impl.UserServiceImpl1" id = "userServiceImpl1"></bean>
</beans>

4.最后，我们就可以通过Spring的ioc容器获取Service接口了

三.Spring的注入方式

1.set注入

1.1 准备好Action层，定义好属性,提供get，set方法

package com.YU.ioc.web;

import com.YU.ioc.service.UserService;
import com.YU.ioc.service.impl.UserServiceImpl1;

import java.util.List;

/**
 * @author YU
 * @create 2023-08-14 18:29
 */
public class BookAction {
    private UserService userService;
    private String bname;//书名
    private int date;//发行日期
    private List<String> people;//适用人群

    public String getBname() {
        return bname;
    }

    public void setBname(String bname) {
        this.bname = bname;
    }

    public int getDate() {
        return date;
    }

    public void setDate(int date) {
        this.date = date;
    }

    public List<String> getPeople() {
        return people;
    }

    public void setPeople(List<String> people) {
        this.people = people;
    }

    public void pros() {
        System.out.println(this.bname);
        System.out.println(this.date);
        System.out.println(this.people);
    }

    public UserService getUserService() {
        return userService;
    }

    public void setUserService(UserService userService) {
        this.userService = userService;
    }

    public String update() {
        userService.update();
        return "list";
    }
}

2.配置好Xml文件

<bean class="com.YU.ioc.web.BookAction" id = "bookAction">
        <property name="userService" ref="userServiceImpl1"></property>
        <property name="bname" value="亚马逊漂流记"></property>
        <property name="date" value = "12"></property>
        <property name="people" >
            <list>
                <value>儿童</value>
                <value>青少年</value>
            </list>
        </property>
    </bean>

3.编写方法，显示是否注入成功

Spring的简介ioc容器及注入方式,spring,tomcat,java

4.测试

package com.YU.ioc.demo;

import com.YU.ioc.web.BookAction;
import com.YU.ioc.web.UserAction;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @author YU
 * @create 2023-08-14 19:16
 */
public class Demo1 {
    public static void main(String[] args) {
        //处理用户请求时，获取spring上下文对象
        ClassPathXmlApplicationContext context = new                     ClassPathXmlApplicationContext("spring-context.xml");
        BookAction bookAction = (BookAction) context.getBean("bookAction");
        bookAction.pros();
    }
}

5.打印结果

Spring的简介ioc容器及注入方式,spring,tomcat,java

显示注入成功

2.构造方法注入

1.准备好Action层，与set注入的不同的是，用的是构造方法注入

package com.YU.ioc.web;

import com.YU.ioc.service.UserService;

import java.util.List;

/**
 * @author YU
 * @create 2023-08-14 18:35
 */
public class UserAction {
    private UserService userService;
    private String uname;
    private int age;
    private List<String> hobby;

    public UserAction() {

    }
    public UserAction(String uname, int age, List<String> hobby) {
        this.uname = uname;
        this.age = age;
        this.hobby = hobby;
    }
    public void pros(){
        System.out.println(this.uname);
        System.out.println(this.age);
        System.out.println(this.hobby);
    }
    public UserService getUserService() {
        return userService;
    }

    public void setUserService(UserService userService) {
        this.userService = userService;
    }

    public String update(){
        userService.update();
        return "list";
    }
}

2.配置XML文件

<bean class="com.YU.ioc.web.UserAction" id = "userAction">
        <property name="userService" ref="userService"></property>
        <constructor-arg name="uname" value="小刘"></constructor-arg>
        <constructor-arg name="age" value = "18"></constructor-arg>
        <constructor-arg name="hobby" >
            <list>
                <value>打球</value>
                <value>读书</value>
            </list>
        </constructor-arg>
    </bean>

区别在于用到是construct-arg

3.编写测试方法，判断是否注入成功

Spring的简介ioc容器及注入方式,spring,tomcat,java

4.测试

package com.YU.ioc.demo;

import com.YU.ioc.web.BookAction;
import com.YU.ioc.web.UserAction;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @author YU
 * @create 2023-08-14 19:16
 */
public class Demo1 {
    public static void main(String[] args) {
        //处理用户请求时，获取spring上下文对象
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring-context.xml");
        UserAction userAction = (UserAction) context.getBean("userAction");
        userAction.pros();
    }
}

5.测试结果

Spring的简介ioc容器及注入方式,spring,tomcat,java

显示注入成功文章来源地址https://www.toymoban.com/news/detail-664890.html

3.总结

构造方法注入强调依赖的必需性和不变性，适用于一次性注入全部依赖的情况。

Setter方法注入提供了更大的灵活性，允许在对象创建后动态地注入依赖，适用于需要可选依赖或在运行时修改依赖的情况。

在实践中，可以根据具体需求选择适合的注入方式，甚至可以将构造方法注入和Setter方法注入结合起来使用，以达到更好的灵活性和控制。

到了这里，关于Spring的简介ioc容器及注入方式的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！