AI 助理
备案控制台
开发者社区 彭世瑜的博客 文章 正文

Java学习路线-56：Spring与Ioc

2021-11-26 111
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
云数据库 RDS MySQL，集群系列 2核4GB
推荐场景：
搭建个人博客
RDS MySQL Serverless 基础系列，0.5-2RCU 50GB
推荐场景：
学生管理系统数据库设计 搭建个人博客
RDS MySQL Serverless 高可用系列，价值2615元额度，1个月
简介： Java学习路线-56：Spring与Ioc

Spring

官网：https://spring.io/

理念：使现有技术更加实用,本身是大杂烩整合现有的框架技术

优点：

  1. 轻量级框架
  2. Ioc 容器-控制反转 inversion of Control
  3. Aop 面向切面编程
  4. 对事务支持
  5. 对框架的支持

一、Ioc 控制反转

Ioc 是一种编程思想，由主动编程变为被动接收

别名：依赖注入 dependency injection

控制：

指谁来控制对象的创建

传统的应用程序对象的创建是由程序本身控制的

使用 spring 之后，由 spring 创建对象


反转：

正转指程序来创建对象

反转指程序本身不创建对象，而变成被动接受对象


总结：

以前对象是由程序本身创建，

使用 spring 之后，程序变为接收 spring 创建好的对象

简单示例

1、依赖 pom.xml

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context-support</artifactId>
    <version>5.2.6.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.2.6.RELEASE</version>
</dependency>

2、Person.java

package com.pengshiyu.bean;
public class Person {
    private String name;
    public void setName(String name) {
        this.name = name;
    }
    public void sayHello() {
        System.out.println("hello " + this.name);
    }
}

3、beans.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 name="person" class="com.pengshiyu.bean.Person">
        <property name="name" value="张三" />
    </bean>
</beans>

4、Demo.java

package com.pengshiyu.spring;
import com.pengshiyu.bean.Person;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Demo {
    public static void main(String[] args) {
        // 解析beans.xml 文件，生成对应的Bean对象
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        Person person = (Person)context.getBean("person");
        person.sayHello();
    }
}

二、Dao 管理示例

Ioc: 对象由 spring 来创建

1、UserDao

package com.spring.dao;
public interface UserDao {
    public void getUser();
}

2、UserDaoMysqlImpl

package com.spring.dao.impl;
import com.spring.dao.UserDao;
public class UserDaoMysqlImpl implements UserDao {
    @Override
    public void getUser() {
        System.out.println("Mysql 获取用户信息");
    }
}

3、UserDaoOracleImpl

package com.spring.dao.impl;
import com.spring.dao.UserDao;
public class UserDaoOracleImpl implements UserDao {
    @Override
    public void getUser() {
        System.out.println("Oracle 获取用户信息");
    }
}

4、UserService

package com.spring.service;
public interface UserService {
    public void getUser();
}

5、UserServiceImpl

package com.spring.service.impl;
import com.spring.dao.UserDao;
import com.spring.service.UserService;
public class UserServiceImpl implements UserService {
    private UserDao userDao = null;
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }
    @Override
    public void getUser() {
        this.userDao.getUser();
    }
}

6、beans.xml（简化版）

<beans >
    <bean id="mysqlDao" class="com.spring.dao.impl.UserDaoMysqlImpl" />
    <bean id="oracleDao" class="com.spring.dao.impl.UserDaoOracleImpl" />
    <bean id="service" class="com.spring.service.impl.UserServiceImpl">
        <property name="userDao" ref="mysqlDao"></property>
    </bean>
</beans>

7、TestDemo

package com.spring.test;
import com.spring.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class TestDemo {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        UserService service = (UserService)context.getBean("service");
        service.getUser();
    }
}

三、使用 Ioc 来创建对象的 3 种方法

Person 类

package com.pengshiyu.bean;
public class Person {
    private String name;
    public Person() {
    }
    public Person(String name) {
        this.name = name;
    }
    public void sayHello() {
        System.out.println("hello " + this.name);
    }
}

创建对象

package com.spring.test;
import com.pengshiyu.bean.Person;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Demo {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        Person person = (Person) context.getBean("person");
        person.sayHello();
    }
}

beans.xml(简化版)

1、无参构造

<beans>
    <bean name="person" class="com.pengshiyu.bean.Person" />
</beans>

2、有参构造

（1）根据参数下标设置

<beans>
    <bean name="person" class="com.pengshiyu.bean.Person">
        <!-- index 构造方法下标从 0 开始 -->
        <constructor-arg index="0" value="Tom" />
    </bean>
</beans>

（2）根据参数名称设置

<beans>
    <bean name="person" class="com.pengshiyu.bean.Person">
        <!-- name 参数名-->
        <constructor-arg name="name" value="Tom" />
    </bean>
</beans>

3、工厂方法创建

(1)静态工厂

package com.pengshiyu.factory;
import com.pengshiyu.bean.Person;
public class PersonFactory {
    public static Person newInstance(String name) {
        return new Person(name);
    }
}

<beans >
    <bean name="person" class="com.pengshiyu.factory.PersonFactory" factory-method="newInstance">
        <constructor-arg name="name" value="Tom" />
    </bean>
</beans>

（2）动态工厂

package com.pengshiyu.factory;
import com.pengshiyu.bean.Person;
public class PersonFactory {
    public Person newInstance(String name) {
        return new Person(name);
    }
}

<beans>
    <bean id="factory" class="com.pengshiyu.factory.PersonFactory" />
    <bean name="person" factory-bean="factory" factory-method="newInstance">
        <constructor-arg name="name" value="Tom"/>
    </bean>
</beans>

注意静态工厂 static

四、Spring 配置文件

id 是 bean 的唯一标识符，如果没有配置 id，name 默认为标识符

如果配置了 id，又配置了 name，则 name 是别名

name 可以设置多个别名分隔符可以是空格、逗号、分号

class 是 bean 的全限定名=包名+类名

如果不配置 id 和 name，那么可以可以使用如下方式获取对象

applicationContext.getBean(class)

配置如下

<beans >
    <bean id="person1" name="person user" class="com.pengshiyu.bean.Person" />
</beans>

获取方式

Person person = (Person) context.getBean("person1");
// 或者
Person person = (Person) context.getBean("user");
// 或者
Person person = (Person) context.getBean(Person.class);

导入文件

<beans>
    <import resource="person.xml"/>
</beans>

五、Spring 依赖注入 DI

dependency injection

依赖：指 bean 对象创建依赖于容器，bean 对象的依赖资源

注入：指 bean 对象依赖的资源由容器来设置和装配

spring 注入

测试

package com.spring.test;
import com.pengshiyu.bean.Person;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Demo {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        Person person = (Person) context.getBean("person");
        person.sayHello();
    }
}
  1. 构造器注入
package com.pengshiyu.bean;
public class Person {
    private String name;
    public Person(String name) {
        this.name = name;
    }
    public void sayHello() {
        System.out.println("hello " + this.name);
    }
}

<beans>
    <bean name="person" class="com.pengshiyu.bean.Person">
        <constructor-arg name="name" value="Tom"/>
    </bean>
</beans>
  1. setter 注入

（1）常量注入

package com.pengshiyu.bean;
public class Person {
    private String name;
    public void setName(String name) {
        this.name = name;
    }
    public void sayHello() {
        System.out.println("hello " + this.name);
    }
}

<beans >
    <bean name="person" class="com.pengshiyu.bean.Person">
        <property name="name" value="Tom"/>
    </bean>
</beans>

（2）bean 注入

package com.pengshiyu.bean;
public class Address {
    private String address;
    public void setAddress(String address) {
        this.address = address;
    }
    public String getAddress() {
        return address;
    }
}

package com.pengshiyu.bean;
public class Person {
    private String name;
    private Address address;
    public void setAddress(Address address) {
        this.address = address;
    }
    public void setName(String name) {
        this.name = name;
    }
    public void sayHello() {
        System.out.println("hello " + this.name + this.address.getAddress());
    }
}

<beans >
    <bean id="address" class="com.pengshiyu.bean.Address">
        <property name="address" value="北京"/>
    </bean>
    <bean name="person" class="com.pengshiyu.bean.Person">
        <property name="name" value="Tom"/>
        <property name="address" ref="address"/>
    </bean>
</beans>

（3）数组注入

package com.pengshiyu.bean;
public class Book {
    private  String name;
    public Book(String name){
        this.name = name;
    }
    @Override
    public String toString() {
        return "《" + this.name + "》";
    }
}

package com.pengshiyu.bean;
import java.util.Arrays;
public class Person {
    private Book[] books;
    public void setBooks(Book[] books) {
        this.books = books;
    }
    @Override
    public String toString() {
        return "Person{" +
                "books=" + Arrays.toString(books) +
                '}';
    }
}

<beans >
    <bean name="person" class="com.pengshiyu.bean.Person">
        <property name="books">
            <array>
                <value>水浒传</value>
                <value>红楼梦</value>
                <value>三国演义</value>
                <value>西游记</value>
            </array>
        </property>
    </bean>
</beans>

（4）List 注入

package com.pengshiyu.bean;
import java.util.Arrays;
import java.util.List;
public class Person {
    private List<String>[] books;
    public void setBooks(List<String>[] books) {
        this.books = books;
    }
    @Override
    public String toString() {
        return "Person{" +
                "books=" + Arrays.toString(books) +
                '}';
    }
}

<beans>
    <bean name="person" class="com.pengshiyu.bean.Person">
        <property name="books">
            <list>
                <value>水浒传</value>
                <value>红楼梦</value>
                <value>三国演义</value>
                <value>西游记</value>
            </list>
        </property>
    </bean>
</beans>

(5)Map 注入

package com.pengshiyu.bean;
import java.util.Map;
public class Person {
    private Map<String, String> cards;
    public void setCards(Map<String, String> cards) {
        this.cards = cards;
    }
    @Override
    public String toString() {
        return cards.toString();
    }
}

<beans>
    <bean name="person" class="com.pengshiyu.bean.Person">
        <property name="cards">
            <map>
                <entry key="中国银行" value="123456"></entry>
                <entry key="建设银行" value="123456"></entry>
            </map>
        </property>
    </bean>
</beans>

（6）Set 注入

package com.pengshiyu.bean;
import java.util.Set;
public class Person {
    private Set<String> games;
    public void setGames(Set<String> games) {
        this.games = games;
    }
    @Override
    public String toString() {
        return games.toString();
    }
}

<beans>
    <bean name="person" class="com.pengshiyu.bean.Person">
        <property name="games">
            <set>
                <value>英雄联盟</value>
                <value>王者荣耀</value>
            </set>
        </property>
    </bean>
</beans>

(7)null 注入

package com.pengshiyu.bean;
public class Person {
    public void setWife(String wife) {
        this.wife = wife;
    }
    private String wife;
    @Override
    public String toString() {
        return wife;
    }
}

<beans>
    <bean name="person" class="com.pengshiyu.bean.Person">
        <property name="wife"><null/></property>
    </bean>
</beans>

(8) Properties 注入

package com.pengshiyu.bean;
import java.util.Properties;
public class Person {
    private Properties props;
    public void setProps(Properties props) {
        this.props = props;
    }
    @Override
    public String toString() {
        return this.props.toString();
    }
}

<beans >
    <bean name="person" class="com.pengshiyu.bean.Person">
        <property name="props">
            <props>
                <prop key="name">Tom</prop>
                <prop key="sex">Man</prop>
            </props>
        </property>
    </bean>
</beans>

(9) p 命名空间注入

需要有对应的 set 方法

package com.pengshiyu.bean;
public class Person {
    private String name;
    private int age;
    public void setName(String name) {
        this.name = name;
    }
    public void setAge(int age) {
        this.age = age;
    }
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

头文件需要引入

xmlns:p="http://www.springframework.org/schema/p"
<?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:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                        http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean name="person" class="com.pengshiyu.bean.Person"
          p:name="Tom" p:age="23"/>
</beans>

（10）c 命名空间注入

要求有对应的构造方法

package com.pengshiyu.bean;
public class Person {
    private String name;
    private int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

头文件需要引入

xmlns:c="http://www.springframework.org/schema/c"
<?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:c="http://www.springframework.org/schema/c"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                        http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean name="person" class="com.pengshiyu.bean.Person"
          c:name="Tom" c:age="23"/>
</beans>

六、bean 的作用域

spring

桥梁
轻量级
易学
ioc di
app
事务
整合框架

scope:

  1. singleton 单例 整个容器只有一个对象实例（默认）
  2. prototype 原型 每次获取 Bean 都产生一个新对象
  3. request 每次请求时创建一个新的对象
  4. session 会话范围内有一个对象
  5. global session 只在 portlet 下有用，表示 applicatio
  6. application 在应用范围中有一个对象


Bean 自动装配

autowire

  1. byName
  2. byType
  3. constructor

不推荐使用自动装配

文章标签：
云数据库 RDS MySQL 版
Java
容器
Spring
关键词：
Spring IOC
Spring java
Java Spring
Java IOC
Java spring ioc
相关实践学习
如何在云端创建MySQL数据库
开始实验后，系统会自动创建一台自建MySQL的 源数据库 ECS 实例和一台 目标数据库 RDS。
全面了解阿里云能为你做什么
阿里云在全球各地部署高效节能的绿色数据中心，利用清洁计算为万物互联的新世界提供源源不断的能源动力，目前开服的区域包括中国（华北、华东、华南、香港）、新加坡、美国（美东、美西）、欧洲、中东、澳大利亚、日本。目前阿里云的产品涵盖弹性计算、数据库、存储与CDN、分析与搜索、云通信、网络、管理与监控、应用服务、互联网中间件、移动服务、视频服务等。通过本课程，来了解阿里云能够为你的业务带来哪些帮助 &nbsp; &nbsp; 相关的阿里云产品：云服务器ECS 云服务器 ECS（Elastic Compute Service）是一种弹性可伸缩的计算服务，助您降低 IT 成本，提升运维效率，使您更专注于核心业务创新。产品详情: https://www.aliyun.com/product/ecs
编程达人
目录
相关文章
喜欢猪猪
|
1月前
|
监控 Java 应用服务中间件
高级java面试---spring.factories文件的解析源码API机制
【11月更文挑战第20天】Spring Boot是一个用于快速构建基于Spring框架的应用程序的开源框架。它通过自动配置、起步依赖和内嵌服务器等特性，极大地简化了Spring应用的开发和部署过程。本文将深入探讨Spring Boot的背景历史、业务场景、功能点以及底层原理，并通过Java代码手写模拟Spring Boot的启动过程，特别是spring.factories文件的解析源码API机制。
喜欢猪猪
71 2
m1a6
|
19天前
|
Java 开发者 微服务
Spring Boot 入门：简化 Java Web 开发的强大工具
Spring Boot 是一个开源的 Java 基础框架，用于创建独立、生产级别的基于Spring框架的应用程序。它旨在简化Spring应用的初始搭建以及开发过程。
m1a6
38 6
Spring Boot 入门：简化 Java Web 开发的强大工具
喜欢猪猪
|
16天前
|
存储 缓存 Java
Spring面试必问：手写Spring IoC 循环依赖底层源码剖析
在Spring框架中，IoC（Inversion of Control，控制反转）是一个核心概念，它允许容器管理对象的生命周期和依赖关系。然而，在实际应用中，我们可能会遇到对象间的循环依赖问题。本文将深入探讨Spring如何解决IoC中的循环依赖问题，并通过手写源码的方式，让你对其底层原理有一个全新的认识。
喜欢猪猪
38 2
阿里云开发者
|
1月前
|
人工智能 前端开发 Java
基于开源框架Spring AI Alibaba快速构建Java应用
本文旨在帮助开发者快速掌握并应用 Spring AI Alibaba，提升基于 Java 的大模型应用开发效率和安全性。
阿里云开发者
200 5
基于开源框架Spring AI Alibaba快速构建Java应用
小王老师呀
|
2月前
|
Java 数据库连接 开发者
Spring 框架：Java 开发者的春天
【10月更文挑战第27天】Spring 框架由 Rod Johnson 在 2002 年创建，旨在解决 Java 企业级开发中的复杂性问题。它通过控制反转（IOC）和面向切面的编程（AOP）等核心机制，提供了轻量级的容器和丰富的功能，支持 Web 开发、数据访问等领域，显著提高了开发效率和应用的可维护性。Spring 拥有强大的社区支持和丰富的生态系统，是 Java 开发不可或缺的工具。
小王老师呀
61 8
mikechen的互联网架构
|
1月前
|
XML 缓存 Java
搞透 IOC、Spring IOC ，看这篇就够了！
本文详细解析了Spring框架的核心内容——IOC（控制反转）及其依赖注入（DI）的实现原理，帮助读者理解如何通过IOC实现组件解耦，提高程序的灵活性和可维护性。关注【mikechen的互联网架构】，10年+BAT架构经验倾囊相授。
mikechen的互联网架构
63 2
悟道了凡
|
2月前
|
JSON Java Maven
实现Java Spring Boot FCM推送教程
本指南介绍了如何在Spring Boot项目中集成Firebase云消息服务（FCM），包括创建项目、添加依赖、配置服务账户密钥、编写推送服务类以及发送消息等步骤，帮助开发者快速实现推送通知功能。
悟道了凡
109 2
路卿老师
|
1月前
|
Java 数据库连接 API
Spring 框架的介绍（Java EE 学习笔记02）
Spring是一个由Rod Johnson开发的轻量级Java SE/EE一站式开源框架，旨在解决Java EE应用中的多种问题。它采用非侵入式设计，通过IoC和AOP技术简化了Java应用的开发流程，降低了组件间的耦合度，支持事务管理和多种框架的无缝集成，极大提升了开发效率和代码质量。Spring 5引入了响应式编程等新特性，进一步增强了框架的功能性和灵活性。
路卿老师
45 0
蓝易云
|
1月前
|
安全 Java 测试技术
Java开发必读，谈谈对Spring IOC与AOP的理解
Spring的IOC和AOP机制通过依赖注入和横切关注点的分离，大大提高了代码的模块化和可维护性。IOC使得对象的创建和管理变得灵活可控，降低了对象之间的耦合度；AOP则通过动态代理机制实现了横切关注点的集中管理，减少了重复代码。理解和掌握这两个核心概念，是高效使用Spring框架的关键。希望本文对你深入理解Spring的IOC和AOP有所帮助。
蓝易云
39 0
auqbllxiu
|
Java 数据库连接 Maven
Java学习路线-66：Maven
Java学习路线-66：Maven
auqbllxiu
116 0

热门文章

最新文章

  • 1
    【Java多数据源实现教程】实现动态数据源、多数据源切换方式（上）
  • 2
    Java-学习笔记-8-接口
  • 3
    java中的工厂模式
  • 4
    超简单的java爬虫
  • 5
    Java 学习路线 2024 最新版！
  • 6
    迅速了解多例模式竞争者-枚举 | 带你学《Java面向对象编程》之七十四
  • 7
    带你读《Java程序设计与计算思维》之三：流程控制
  • 8
    java源码 - ReentrantLock
  • 9
    Java Poi 创建与读取Excel
  • 10
    关于《Java数字图像处理-编程技巧与应用实践》一书 源代码
  • 1
    Spring高手之路18——从XML配置角度理解Spring AOP
    95
  • 2
    Spring Boot中一般如何使用线程池？
    753
  • 3
    Spring Boot 源码面试知识点
    100
  • 4
    【MongoDB 专栏】MongoDB 与 Spring Boot 的集成实践
    253
  • 5
    深入探索Spring Boot Web应用源码及实战应用
    105
  • 6
    ruoyi-nbcio从spring2.7.18升级springboot到3.1.7，java从java8升级到17（二）
    350
  • 7
    springboot全局自定义异常
    44
  • 8
    RabbitMQ的springboot项目集成使用-01
    147
  • 9
    什么是Spring Boot 自动配置？
    60
  • 10
    Spring cloud原理详解
    79

    • 相关课程

    更多
  • Java Web开发系列课程 - Spring框架入门
  • Java面向对象开发
  • Java高级开发
  • Java零基础入门
  • Spring Boot 2.5.x开发实战
  • Spring Cloud微服务架构设计与开发实战

    • 相关电子书

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

    • 相关实验场景

    更多
  • 阿里云平台上进行Java程序的编译与运行
  • 使用Java面向对象编写网络通信程序应用
  • Spring-cloud-stream-binder-rocketmq入门与实践
  • 手动部署Java Web环境（Alibaba Cloud Linux 2）
  • 搭建Java Web开发环境（Anolis OS）
  • RocketMQ中使用Java客户端发送消息和消费的应用
    • 下一篇
    DataWorks