AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

Spring的基本介绍及ioc的三种注入方式

2023-11-30 97
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： Spring的基本介绍及ioc的三种注入方式

Spring的简介：

含义：

Spring是Java EE编程领域的一个轻量级开源框架，该框架由一个叫Rod Johnson的程序员在 2002 年最早提出并随后创建，是为了解决企业级编程开发中的复杂性，实现敏捷开发的应用型框架 。Spring是一个开源容器框架，它集成各类型的工具，通过核心的Bean factory实现了底层的类的实例化和生命周期的管理。在整个框架中，各类型的功能被抽象成一个个的 Bean，这样就可以实现各种功能的管理，包括动态加载和切面编程

特点：

1.方便解耦，简化开发

通过Spring提供的IoC容器，我们可以将对象之间的依赖关系交由Spring进行控制，避免硬编码所造成的过度程序耦合。有了Spring，用户不必再为单实例模式类、属性文件解析等这些很底层的需求编写代码，可以更专注于上层的应用。

2.AOP编程的支持

通过Spring提供的AOP功能，方便进行面向切面的编程，许多不容易用传统OOP实现的功能可以通过AOP轻松应付。

3.声明式事务的支持

在Spring中，我们可以从单调烦闷的事务管理代码中解脱出来，通过声明式方式灵活地进行事务的管理，提高开发效率和质量。

4.方便程序的测试

可以用非容器依赖的编程方式进行几乎所有的测试工作，在Spring里，测试不再是昂贵的操作，而是随手可做的事情。例如：Spring对Junit4支持，可以通过注解方便的测试Spring程序。

5.方便集成各种优秀框架

Spring不排斥各种优秀的开源框架，相反，Spring可以降低各种框架的使用难度，Spring提供了对各种优秀框架（如Struts,Hibernate、Hessian、Quartz）等的直接支持。

6.降低Java EE API的使用难度

Spring对很多难用的Java EE API（如JDBC，JavaMail，远程调用等）提供了一个薄薄的封装层，通过Spring的简易封装，这些Java EE API的使用难度大为降低。

7.Java 源码是经典学习范例

Spring的源码设计精妙、结构清晰、匠心独运，处处体现着大师对Java设计模式灵活运用以及对Java技术的高深造诣。Spring框架源码无疑是Java技术的最佳实践范例。如果想在短时间内迅速提高自己的Java技术水平和应用开发水平，学习和研究Spring源码将会使你收到意想不到的效果。

Spring的IOC（控制反转）

IOC：控制反转，是一个理论，概念，思想。
描述的：把对象的创建，赋值，管理工作都交给代码之外的容器实现，也就是对象的创建是有其它外部资源完成。

控制：创建对象，对象的属性赋值，对象之间的关系管理。

反转：把原来的开发人员管理，创建对象的权限转移给代码之外的容器实现。由容器代替开发人员管理对象。创建对象，给属性赋值。

正转：由开发人员在代码中，使用new 构造方法创建对象，开发人员主动管理对象。

容器：是一个服务器软件，一个框架（spring）

 

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">
    <bean class="com.xiaoxu.web.UserAction" id="userAction" >
        <property name="userService" ref="userService"></property>
    </bean>
    <bean class="com.xiaoxu.web.GoodsAction" id="goodsAction" >
        <property name="userService" ref="userService2"></property>
    </bean>
    <bean class="com.xiaoxu.service.impl.UserServiceimpl1" id="userService"></bean>
    <bean class="com.xiaoxu.service.impl.UserServiceimpl" id="userService2"></bean>
</beans>

UserService

package com.xiaoxu.service;
public interface UserService {
    public void update();
}

UserAction

package com.xiaoxu.web;
import com.xiaoxu.service.UserService;
public class UserAction {
    private UserService userService;
    public String update(){
        userService.update();
        return "list";
    }
    public UserService getUserService() {
        return userService;
    }
    public void setUserService(UserService userService) {
        this.userService = userService;
    }
}

GoodsAction

package com.xiaoxu.web;
import com.xiaoxu.service.UserService;
public class UserAction {
    private UserService userService;
    public String update(){
        userService.update();
        return "list";
    }
    public UserService getUserService() {
        return userService;
    }
    public void setUserService(UserService userService) {
        this.userService = userService;
    }
}

测试类

package com.xiaoxu.text;
import com.xiaoxu.web.GoodsAction;
import com.xiaoxu.web.UserAction;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class demo1 {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("/spring-context.xml");
        UserAction userAction = (UserAction) context.getBean("userAction");
             userAction.update();
        GoodsAction goodsAction = (GoodsAction) context.getBean("goodsAction");
            goodsAction.update();
    }
}

测试结果

注入方式

set注入

package com.xiaoxu.ioc.web;
import com.xiaoxu.ioc.service.UserService;
import java.util.List;
public class GoodsAction {
    /**
     * 例如:在不同的控制器中进行方法调用
     */
    private UserService userService;
    private String gname;//名称
    private int age;//保质期
    private List<String> peoples;//使用人群
    public String getGname() {
        return gname;
    }
    public void setGname(String gname) {
        this.gname = gname;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public List<String> getPeoples() {
        return peoples;
    }
    public void setPeoples(List<String> peoples) {
        this.peoples = peoples;
    }
    public UserService getUserService() {
        return userService;
    }
    public void setUserService(UserService userService) {
        this.userService = userService;
    }
    public void pop(){
        System.out.println("名称:"+this.gname);
        System.out.println("保证期:"+this.age);
        System.out.println("使用人群:"+this.peoples);
    }
    public String update(){
        userService.update();
        return "list";
    }
}
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       default-autowire="byName"
       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">
        <bean class="com.CloudJun.ioc.web.UserAction" id="userAction">
         <property name="userService" ref="userServiceImpl"></property>
        </bean>
        <bean class="com.CloudJun.ioc.web.GoodsAction" id="goodsAction">
            <property name="userService" ref="userServiceImpl2"></property>
            <property name="gname" value="辣条"></property>
            <property name="age" value="2"></property>
            <property name="peoples">
                <list>
                    <value>懒大王</value>
                    <value>美羊羊</value>
                    <value>沸羊羊</value>
                </list>
            </property>
        </bean>
        <bean class="com.CloudJun.ioc.service.impl.UserServiceImpl" id="userService" ></bean>
        <bean class="com.CloudJun.ioc.service.impl.UserServiceImpl2" id="userServiceImpl2"></bean>
</beans>

构造注入

package com.xiaoxu.ioc.web;
import com.xiaoxu.ioc.service.UserService;
import java.util.List;
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 UserService getUserService() {
        return userService;
    }
    public void setUserService(UserService userService) {
        this.userService = userService;
    }
    public void pop(){
        System.out.println("名字为:"+this.uname);
        System.out.println("年龄为:"+this.age);
        System.out.println("爱好为:"+this.hobby);
    }
    public String update(){
         userService.update();
         return "list";
     }
}
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       default-autowire="byName"
       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">
        <bean class="com.CloudJun.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>
        <bean class="com.CloudJun.ioc.web.GoodsAction" id="goodsAction">
            <property name="userService" ref="userServiceImpl2"></property>
            <property name="gname" value="奥里给"></property>
            <property name="age" value="2"></property>
            <property name="peoples">
                <list>
                    <value>懒大王</value>
                    <value>美羊羊</value>
                    <value>沸羊羊</value>
                </list>
            </property>
        </bean>
        <bean class="com.CloudJun.ioc.service.impl.UserServiceImpl" id="userService" ></bean>
        <bean class="com.CloudJun.ioc.service.impl.UserServiceImpl2" id="userServiceImpl2"></bean>
</beans>

接口注入

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       default-autowire="byName"
       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.CloudJun.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>
        <bean class="com.CloudJun.ioc.web.GoodsAction" id="goodsAction">
           <!-- <property name="userService" ref="userServiceImpl2"></property>
            <property name="gname" value="奥里给"></property>
            <property name="age" value="2"></property>
            <property name="peoples">
                <list>
                    <value>懒大王</value>
                    <value>美羊羊</value>
                    <value>沸羊羊</value>
                </list>
            </property>-->
        </bean>
        <bean class="com.CloudJun.ioc.service.impl.UserServiceImpl" id="userService" ></bean>
        <bean class="com.CloudJun.ioc.service.impl.UserServiceImpl2" id="userServiceImpl2"></bean>
</beans>

web容器整合

配置监听器

package com.xiaoxu.listeer;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import javax.servlet.ServletContext;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
import javax.servlet.annotation.WebListener;
@WebListener("")
public class SpringLoadListener implements ServletContextListener {
    public void contextInitialized(ServletContextEvent sce) {
        //将spring上下文放入Tomcat上下文
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("/spring-context.xml");
        //获取Tomcat上下文
        ServletContext servletContext = sce.getServletContext();
        servletContext.setAttribute("springContext",context);
    }
}

配置servlet

package com.xiaoxu.servlet;
import com.xiaoxu.service.UserService;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
@WebServlet("/userList")
public class UserServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        this.doPost(req,resp);
    }
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //获取spring上下文对象
        ClassPathXmlApplicationContext context = (ClassPathXmlApplicationContext) req.getServletContext().getAttribute("springContext");
        UserService userService = (UserService) context.getBean("userService");
        userService.update();
        System.out.println(userService);
    }
}

运行结果

 


文章标签：
Java
Spring
容器
API
数据库连接
关键词：
Spring IOC
Spring注入
Spring基本介绍
Spring基本介绍注入
Spring ioc注入
懒大王o
目录
相关文章
SheepRunner
|
12天前
|
XML Java 数据格式
【SpringFramework】Spring IoC-基于XML的实现
本文主要讲解SpringFramework中IoC和DI相关概念，及基于XML的实现方式。
SheepRunner
101 69
技能实验室
|
3月前
|
Java Spring
在使用Spring的`@Value`注解注入属性值时，有一些特殊字符需要注意
【10月更文挑战第9天】在使用Spring的`@Value`注解注入属性值时，需注意一些特殊字符的正确处理方法，包括空格、引号、反斜杠、新行、制表符、逗号、大括号、$、百分号及其他特殊字符。通过适当包裹或转义，确保这些字符能被正确解析和注入。
技能实验室
205 3
SheepRunner
|
11天前
|
Java Spring 容器
【SpringFramework】Spring IoC-基于注解的实现
本文主要记录基于Spring注解实现IoC容器和DI相关知识。
SheepRunner
45 21
蓝染-惣右介
|
17天前
|
设计模式 XML Java
【23种设计模式·全精解析 | 自定义Spring框架篇】Spring核心源码分析+自定义Spring的IOC功能，依赖注入功能
本文详细介绍了Spring框架的核心功能，并通过手写自定义Spring框架的方式，深入理解了Spring的IOC(控制反转)和DI（依赖注入）功能，并且学会实际运用设计模式到真实开发中。
蓝染-惣右介
55 1
【23种设计模式·全精解析 | 自定义Spring框架篇】Spring核心源码分析+自定义Spring的IOC功能，依赖注入功能
三三是该溜子
|
16天前
|
存储 Java 应用服务中间件
【Spring】IoC和DI，控制反转，Bean对象的获取方式
IoC，DI，控制反转容器，Bean的基本常识，类注解@Controller，获取Bean对象的常用三种方式
三三是该溜子
42 12
运营研究坊
|
1月前
|
Java Spring
一键注入 Spring 成员变量，顺序编程
介绍了一款针对Spring框架开发的插件，旨在解决开发中频繁滚动查找成员变量注入位置的问题。通过一键操作（如Ctrl+1），该插件可自动在类顶部添加`@Autowired`注解及其成员变量声明，同时保持光标位置不变，有效提升开发效率和代码编写流畅度。适用于IntelliJ IDEA 2023及以上版本。
运营研究坊
49 2
一键注入 Spring 成员变量，顺序编程
喜欢猪猪
|
1月前
|
存储 缓存 Java
Spring面试必问：手写Spring IoC 循环依赖底层源码剖析
在Spring框架中，IoC（Inversion of Control，控制反转）是一个核心概念，它允许容器管理对象的生命周期和依赖关系。然而，在实际应用中，我们可能会遇到对象间的循环依赖问题。本文将深入探讨Spring如何解决IoC中的循环依赖问题，并通过手写源码的方式，让你对其底层原理有一个全新的认识。
喜欢猪猪
57 2
mikechen的互联网架构
|
2月前
|
XML 缓存 Java
搞透 IOC、Spring IOC ，看这篇就够了！
本文详细解析了Spring框架的核心内容——IOC（控制反转）及其依赖注入（DI）的实现原理，帮助读者理解如何通过IOC实现组件解耦，提高程序的灵活性和可维护性。关注【mikechen的互联网架构】，10年+BAT架构经验倾囊相授。
mikechen的互联网架构
85 2
蓝易云
|
2月前
|
安全 Java 测试技术
Java开发必读，谈谈对Spring IOC与AOP的理解
Spring的IOC和AOP机制通过依赖注入和横切关注点的分离，大大提高了代码的模块化和可维护性。IOC使得对象的创建和管理变得灵活可控，降低了对象之间的耦合度；AOP则通过动态代理机制实现了横切关注点的集中管理，减少了重复代码。理解和掌握这两个核心概念，是高效使用Spring框架的关键。希望本文对你深入理解Spring的IOC和AOP有所帮助。
蓝易云
49 0
喜欢猪猪
|
3月前
|
XML Java 数据格式
Spring IOC容器的深度解析及实战应用
【10月更文挑战第14天】在软件工程中，随着系统规模的扩大，对象间的依赖关系变得越来越复杂，这导致了系统的高耦合度，增加了开发和维护的难度。为解决这一问题，Michael Mattson在1996年提出了IOC（Inversion of Control，控制反转）理论，旨在降低对象间的耦合度，提高系统的灵活性和可维护性。Spring框架正是基于这一理论，通过IOC容器实现了对象间的依赖注入和生命周期管理。
喜欢猪猪
91 0

热门文章

最新文章

  • 1
    SpringMvc+Spring+MyBatis 基于注解整合
  • 2
    Spring Boot功能实战
  • 3
    Hessian解析及应用（整合Spring）
  • 4
    【小家Spring】Spring MVC之RequestContextHolder和LocaleContextHolder的使用详解以及使用误区
  • 5
    Spring(九)之事件处理
  • 6
    Spring中继承配置的注入方法
  • 7
    spring-注入对象map
  • 8
    Spring（17）——对JSR330标准的支持
  • 9
    轻松了解Spring中的控制反转和依赖注入（二）
  • 10
    spring 源码之模板设计模式
  • 1
    Spring高手之路18——从XML配置角度理解Spring AOP
    109
  • 2
    Spring Boot中一般如何使用线程池？
    804
  • 3
    Spring Boot 源码面试知识点
    105
  • 4
    【MongoDB 专栏】MongoDB 与 Spring Boot 的集成实践
    269
  • 5
    深入探索Spring Boot Web应用源码及实战应用
    117
  • 6
    ruoyi-nbcio从spring2.7.18升级springboot到3.1.7，java从java8升级到17（二）
    370
  • 7
    springboot全局自定义异常
    48
  • 8
    RabbitMQ的springboot项目集成使用-01
    152
  • 9
    什么是Spring Boot 自动配置？
    64
  • 10
    Spring cloud原理详解
    84

    • 相关课程

    更多
  • 全面讲解Spring Cloud Alibaba技术栈（知识精讲+项目实战）第四阶段
  • 精通Spring Cloud Alibaba
  • 微服务框架 Spring Cloud 快速入门
  • Java Web开发系列课程 - Spring框架入门
  • Spring Boot 2.5.x开发实战
  • Spring Cloud微服务架构设计与开发实战

    • 相关电子书

    更多
  • 云栖社区特邀专家徐雷Java Spring Boot开发实战系列课程（第20讲）：经典面试题与阿里等名企内部招聘求职面试技巧
  • 微服务架构模式与原理Spring Cloud开发实战
  • 阿里特邀专家徐雷Java Spring Boot开发实战系列课程（第18讲）：制作Java Docker镜像与推送到DockerHub和阿里云Docker仓库

    • 相关实验场景

    更多
  • Spring-cloud-bus-rocketmq入门与实践
  • Spring-cloud-stream-binder-rocketmq入门与实践
  • 从零搭建Spring Boot的Hello World
    • 下一篇
    DataWorks智能交互式数据开发与分析之旅