【Spring一】Spring使用-IOC控制反转-DI依赖注入

最新推荐文章于 2024-06-12 11:59:04 发布

xbd_zc

最新推荐文章于 2024-06-12 11:59:04 发布

阅读量427

点赞数

分类专栏：框架 Spring 文章标签： java mybatis 数据结构

本文链接：https://blog.csdn.net/xbd_zc/article/details/123787974

版权

框架同时被 2 个专栏收录

25 篇文章 0 订阅

订阅专栏

Spring

11 篇文章 0 订阅

订阅专栏

1.Spring

1.1.简介

Spring是一个开源框架，它由[Rod Johnson](https://baike.baidu.com/item/Rod Johnson)创建。它是为了解决企业应用开发的复杂性而创建的。Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。

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

轻量——从大小与开销两方面而言Spring都是轻量的。完整的Spring框架可以在一个大小只有1MB多的JAR文件里发布。并且Spring所需的处理开销也是微不足道的。此外，Spring是非侵入式的：典型地，Spring应用中的对象不依赖于Spring的特定类。
控制反转——Spring通过一种称作控制反转（IoC）的技术促进了松耦合。当应用了IoC，一个对象依赖的其它对象会通过被动的方式传递进来，而不是这个对象自己创建或者查找依赖对象。你可以认为IoC与JNDI相反——不是对象从容器中查找依赖，而是容器在对象初始化时不等对象请求就主动将依赖传递给它。
面向切面——Spring提供了面向切面编程的丰富支持，允许通过分离应用的业务逻辑与系统级服务（例如审计（auditing）和事务（transaction）管理）进行内聚性的开发。应用对象只实现它们应该做的——完成业务逻辑——仅此而已。它们并不负责（甚至是意识）其它的系统级关注点，例如日志或事务支持。
容器——Spring包含并管理应用对象的配置和生命周期，在这个意义上它是一种容器，你可以配置你的每个bean如何被创建——基于一个可配置原型（prototype），你的bean可以创建一个单独的实例或者每次需要时都生成一个新的实例——以及它们是如何相互关联的。然而，Spring不应该被混同于传统的重量级的EJB容器，它们经常是庞大与笨重的，难以使用。
框架——Spring可以将简单的组件配置、组合成为复杂的应用。在Spring中，应用对象被声明式地组合，典型地是在一个XML文件里。Spring也提供了很多基础功能（事务管理、持久化框架集成等等），将应用逻辑的开发留给了你。

所有Spring的这些特征使你能够编写更干净、更可管理、并且更易于测试的代码。它们也为Spring中的各种模块提供了基础支持。

下载

官网: Spring Framework

下载地址:Index of /spring-framework/docs

GitHub地址:spring-projects/spring-framework: Spring Framework (github.com)

maven导包

<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.3.16</version>
</dependency>

<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.3.16</version>
</dependency>

1.2.优点

Spring是一个开源的免费的框架(容器)
Spring是一个轻量级的, 非入侵式的框架( 不需要修改项目)
控制反转 IOC , 面向切面编程 AOP
支持事物的处理, 对框架整合的支持\

Spring就是一个轻量级的控制反转IOC , 和面向切面AOP 的编程框架

1.3.组成

1.4.拓展

Spring Boot
- 一个快速开发的脚手架
- 基于SpringBoot可以快速的开发单个微服务
- 约定大于配置
Spring Cloud
- Spring Cloud 是基于Spring Boot实现的

因为现在大多数公司都在使用SpringBoot进行快速开发,学习SpringBoot的前提,需要完全掌握Spring及,SpringMVC!

弊端: 发展了太久之后,违背了原来的理念!配置十分繁琐,人称:“配置地狱!”

2.IOC理论推导

原来

1,UserDao接口
2,UserDaoImpl 实现类
3,Service----ServiceImpl
4, 调用Service获得dao执行的结果

问题:

如果有多个实现类, 需要切换的话, 需要修改源代码, 才能实现扩展的方法(创建者控制)

//UserDao userDao = new UserDaoImpl();
  UserDao userDao = new UserDaoMysqlImpl();

调整后

添加set方法

//    UserDao userDao = new UserDaoImpl();
    UserDao userDao ;
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

调整后关系就变了, 由原来创建者(控制)定死的,变成了使用者(控制)能选择类型使用
利用set方法实现动态注入

这种思想, 从本质上解决了问题, 末尾程序员不用再去管理对象的创建了. 系统耦合性大大降低, 可以更加专注在业务的实现上,这就是IOC的原型

IOC的本质

**控制反转loC(Inversion of Control),是一种设计思想,DI(依赖注入)是实现loC的一种方法,**也
有人认为DI只是loC的另一种说法。没有loC的程序中,我们使用面向对象编程,对象的创建与对象间
的依赖关系完全硬编码在程序中,对象的创建由程序自己控制,控制反转后将对象的创建转移给第三
方,个人认为所谓控制反转就是:获得依赖对象的方式反转了。

**loC是Spring框架的核心内容,**使用多种方式完美的实现了loC,可以使用XML配置,也可以使用注
解,新版本的Spring也可以零配置实现loC。

Spring容器在初始化时先读取配置文件,根据配置文件或元数据创建与组织对象存入容器中,程序使
用时再从loc容器中取出需要的对象。

采用XML方式配置Bean的时候, Bean的定义信息是和实现分离的,而采用注解的方式可以把两者合
为一体,Bean的定义信息直接以注解的形式定义在实现类中,从而达到了零配置的目的。

控制反转是一种通过描述(XML或注解)并通过第三方去生产或获取特定对象的方式。在Spring中
实现控制反转的是loC容器,其实现方法是依赖注入(Dependency Injection,DI) 。

3.HelloSpring

实体类

package com.ccc.pojo;

public class Hello {
    private String str;

    public String getStr() {
        return str;
    }

    public void setStr(String str) {
        this.str = str;
    }

    @Override
    public String toString() {
        return "Hello{" +
                "str='" + str + '\'' +
                '}';
    }
}

配置元数据-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
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="hello" class="com.ccc.pojo.Hello">
        <property name="str" value="Hello,Spring"/>
    </bean>

</beans>

测试

public static void main(String[] args) {
    //获取Spring上下文对象, 所有对象都由spring管理, 使用直接在里面取
    ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
    Hello hello = (Hello) context.getBean("hello");
    System.out.println(hello.toString());//Hello,Spring

}

思考问题

Hello对象是谁创建的?
- hello对象是由Spring创建的
Hello对象的属性是怎么设置的?
- hello对象的属性是由Spring容器设置的,

这个过程就叫控制反转:

控制: 谁来控制对象的创建,传统应用程序的对象是由程序本身控制创建的,使用Spring后,对象是
由Spring来创建的.

反转: 程序本身不创建对象,而变成被动的接收对象.

依赖注入: 就是利用set方法来进行注入的., set注掉后抱错了

IOC是一种编程思想,由主动的编程变成被动的接收,

可以通过newClassPathXmlApplicationContext去浏览一下底层源码.

OK,到了现在,我们彻底不用再程序中去改动了,要实现不同的操作,只需要在xml配置文件中进行修改,所谓的loc,一句话搞定:对象由Spring来创建,管理,装配!

更改原来的代码

<?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
        https://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="mysql" class="com.ccc.dao.UserDaoMysqlImpl"/>
    <bean id="oracle" class="com.ccc.dao.UserDaoOracleImpl"/>
    <bean id="userServiceImpl" class="com.ccc.service.UserServiceImpl">
        <!--
                ref :引用Spring容器中创建好的对象
                name: 具体的值
        -->
        <property name="userDao" ref="oracle"/>
    </bean>

</beans>

public class UserTest {
    @Test
    public void test(){
        //获取ApplicationContext
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        UserServiceImpl userServiceImpl = (UserServiceImpl) context.getBean("userServiceImpl");
        userServiceImpl.show();
    }
}

对象由Spring接管后, 想变更功能就不需要修改代码了
只需要修改配置文件<property name="userDao" ref="mysql"/>

4.IOC创建对象的方式

使用无参构造创建对象(默认)
要使用有参构造创建对象
- 1,下标赋值index
- 2,参数类型 type
- 3,参数名 name 建议使用

4.1测试

实体类

package com.ccc.pojo;

public class User {
    private String name;

    public User() {
        System.out.println("执行了User无参构造");
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    public void show(){
        System.out.println("name"+name);
    }
}

测试

public class Test {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");

    }

在获取上下文的时候就已经把对象创建好了

把无参构造去掉(添加有参)

再执行就报错了, 需要在beans中配置

4.2beans配置有参构造函数参数的三种方式

index

<!--第一种通过下标赋值-->
<bean id="user" class="com.ccc.pojo.User">
    <constructor-arg index="0" value="张三"/>
</bean>

type

<!--第二种通过参数类型赋值, 不建议使用-->
<bean id="user" class="com.ccc.pojo.User">
    <constructor-arg type="java.lang.String" value="张三"/>
</bean>

Name(参数名),建议使用

<!--第三种通过参数name, 建议使用-->
<bean id="user" class="com.ccc.pojo.User">
    <constructor-arg name="name" value="张三"/>
</bean>

IOC创建对象总结

在配置文件加载的时候, 容器已经把管理的对象初始化了
有参是通过构造参数赋值
无参是通过set方法赋值

5.Spring配置

5.1.起别名

<!--起别名, 可以使用别名来获取对象-->
<alias name="user" alias="user2"/>

5.2.Bean的配置

<!--
    id       : bean 的唯一标识符, 也就相当于对象名
    class   : bean 对象所对应的全限定名(包名+类名)
    name   : 别名  可以同时起多个别名-->
<bean id="userTow" class="com.ccc.pojo.UserTow" name="userTow2,u2 u3;u4">
    <property name="name" value="张三"/>
</bean>

5.3.import

一般用于团队开发使用, 可以将多个配置文件, 导入合并为一个

假设, 项目有多人开发, 三个人创建了不同的beans, 我们可以用import将所有的beans.xm合并为一个总的

张三 beans1
李四 beans2
网二 beans3

applicationContext.xml

<import resource="beans1.xml"/>
<import resource="beans2.xml"/>
<import resource="beans3.xml"/>

使用的时候使用总的配置就可以了applicationContext.xml

6.DI依赖注入

构造器注入 (4.1)
set方式注入(4.1)
拓展方式注入

6.1.Set方式注入 * 重点

依赖注入: Set注入
- 依赖: bean对象的创建依赖于容器
- 注入: bean对象中的所有属性, 有容器来注入

环境搭建

实体类

import lombok.Data;
import java.util.*;
@Data
public class Student {
    private String name;
    private Address address;
    private String[] books;
    private List<String> hobbies;
    private Map<String,String> card;
    private Set<String> games;
    private Properties info;
}

import lombok.Data;

@Data
public class Address {
    private String address;

}

beans配置

<?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
        https://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="student" class="com.ccc.pojo.Student" >
    </bean>
</beans>

八种类型注入方式

<bean id="address" class="com.ccc.pojo.Address">
    <property name="address" value="这里"/>
</bean>
<bean id="student" class="com.ccc.pojo.Student" >
    <!--第一种, 值注入-->
    <property name="name" value="张三"/>
    <!--第二种, bean注入-->
    <property name="address" ref="address"/>
    <!--第三种, 数组注入-->
    <property name="books">
        <array>
            <value>book1</value>
            <value>book2</value>
            <value>book3</value>
        </array>
    </property>
    <!--第四种, List-->
    <property name="hobbies">
        <list>
            <value>学习1</value>
            <value>学习2</value>
            <value>学习3</value>
        </list>
    </property>
    <!--第五种, Map-->
    <property name="card">
        <map>
            <entry key="食堂卡" value="123123"/>
            <entry key="学生卡" value="321321"/>
        </map>
    </property>
    <!--第六种, set-->
    <property name="games">
        <set>
            <value>game1</value>
            <value>game2</value>
            <value>game3</value>
        </set>
    </property>
    <!--第七种, null空值-->
    <property name="wife">
        <null/>
    </property>
    <!--第八种, properties-->
    <property name="info">
        <props>
            <prop key="学号">123123</prop>
            <prop key="性别">男</prop>
        </props>
    </property>
</bean>

输出

Student(name=张三, address=Address(address=这里), books=[book1, book2, book3], 
		hobbies=[学习1, 学习2, 学习3], card={食堂卡=123123, 学生卡=321321}, 
		games=[game1, game2, game3], wife=null, info={学号=123123, 性别=男})

6.2.拓展方式注入

官方文档说可以使用p命名空间和c命令注入

P命名空间注入(set方法注入)

bean配置文件加入p标签
使用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
        https://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--p命名空间注入, 可以直接煮熟属性的值: property-->
    <bean id="user" class="com.ccc.pojo.User" p:name="张三" p:age="12"/>
</beans>

C命名空间注入(有参构造器注入)

bean配置文件加入c标签
使用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:p="http://www.springframework.org/schema/p"
       xmlns:c="http://www.springframework.org/schema/c"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--p命名空间注入, 可以直接注入属性的值: property-->
    <bean id="user" class="com.ccc.pojo.User" p:name="张三" p:age="12"/>

    <!--C命名空间注入, 通过构造器注入, construct-args-->
    <bean id="user1" class="com.ccc.pojo.User" c:name="张三" c:age="12"/>
</beans>

注意点

使用前导入标签

xmlns:p=&quot;http://www.springframework.org/schema/p&quot;
xmlns:c=&quot;http://www.springframework.org/schema/c&quot;-

p命名空间使用的是set 方式注入, 需有set方法
c命名空间使用的是有参构造注入, 需要有参构造

xbd_zc

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
【Spring一】Spring使用-IOC控制反转-DI依赖注入

文章目录1.Spring1.1.简介下载1.2.优点1.3.组成1.4.拓展2.IOC理论推导**原来 **问题:调整后IOC的本质3.HelloSpring实体类配置元数据-beans.xml测试思考问题更改原来的代码4.IOC创建对象的方式4.1测试实体类测试把无参构造去掉(添加有参)再执行就报错了, 需要在beans中配置4.2beans配置有参构造函数参数的三种方式indextypeName(参数名),建议使用IOC创建对象总结5.Spring配置5.1.起别名5.2.Bean的配置5.3.impo
复制链接

扫一扫