spring 学习01--IOC控制反转--DI依赖注入--bean自动装配autowire

最新推荐文章于 2024-09-09 19:49:04 发布
最新推荐文章于 2024-09-09 19:49:04 发布
阅读量94 收藏
点赞数
文章标签： spring java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xpc1998/article/details/120711594
版权

Spring学习01

IOC

  • 控制翻转，之前的对象的创建，管理是由程序来控制的，现在对象由Spring来创建、管理和装配

hellospring

  1. 编写类
public class User {
    String str;

    public String getStr() {
        return str;
    }

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

    @Override
    public String toString() {
        return "User{" +
                "str='" + str + '\'' +
                '}';
    }
}
  1. 编写xml配置文件来通过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="user1" class="com.xu.pojo.User">
        <property name="str" value="Hello Spring!"/>
    </bean>

</beans>
  1. 测试
public class getObjetBySpring {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        User user=(User) context.getBean("user1");
        System.out.println(user.getStr());
    }
}

IOC创建对象的方式

  1. 默认使用无参构造，以下这种配置方式使用的就是无参构造，如果写了有参构造这种配置方式就报错了
<bean id="user1" class="com.xu.pojo.User">
        <property name="str" value="Hello Spring!"/>
</bean>
  1. 有参构造的配置方式，有好几种，一般推荐如下这种
<bean id="user1" class="com.xu.pojo.User">
        <constructor-arg name="str" value="helloSpring!"></constructor-arg>
</bean>

//另外一种
<bean id="user1" class="com.xu.pojo.User">
        <constructor-arg index="0" value="HelloSpring!"/>
</bean>

spring配置

  • 别名，有两种方式，一种如下，一种是在bean里面配置
<alias name="user1" alias="user"></alias>
  • bean配置
<bean id="user1" class="com.xu.pojo.User" name="userNew">  //此处的name就是别名
        <constructor-arg index="0" value="HelloSpring!"/>
</bean>
  • import–用来多人合作，将多人的beans.xml合在一起

DI依赖注入

  • 本质就是怎么给类里面各种类型的对象赋值
  1. 创建Adress类
public class Address {

    private String address;

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }
}
  1. 创建student类
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 String wife;
    private Properties info;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Address getAddress() {
        return address;
    }

    public void setAddress(Address address) {
        this.address = address;
    }

    public String[] getBooks() {
        return books;
    }

    public void setBooks(String[] books) {
        this.books = books;
    }

    public List<String> getHobbies() {
        return hobbies;
    }

    public void setHobbies(List<String> hobbies) {
        this.hobbies = hobbies;
    }

    public Map<String, String> getCard() {
        return card;
    }

    public void setCard(Map<String, String> card) {
        this.card = card;
    }

    public Set<String> getGames() {
        return games;
    }

    public void setGames(Set<String> games) {
        this.games = games;
    }

    public String getWife() {
        return wife;
    }

    public void setWife(String wife) {
        this.wife = wife;
    }

    public Properties getInfo() {
        return info;
    }

    public void setInfo(Properties info) {
        this.info = info;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", address=" + address +
                ", books=" + Arrays.toString(books) +
                ", hobbies=" + hobbies +
                ", card=" + card +
                ", games=" + games +
                ", wife='" + wife + '\'' +
                ", info=" + info +
                '}';
    }
}
  1. 配置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 name="studentAddress" class="com.xu.pojo.Address">
        <property name="address" value="浙江省杭州市"/>
    </bean>

    <bean name="student" class="com.xu.pojo.Student">
        <!--普通类型注入-->
        <property name="name" value="xpc"/>
        <!--bean类型注入，前提是studentAddress已经注入好了-->
        <property name="address" ref="studentAddress"/>
        <!--数组类型-->
        <property name="books">
            <array>
                <value>水浒传</value>
                <value>三国演义</value>
                <value>红楼梦</value>
            </array>
        </property>
        <!--list-->
        <property name="hobbies">
            <list>
                <value>篮球</value>
                <value>足球</value>
                <value>乒乓球</value>
            </list>
        </property>
        <!--map,特殊-->
        <property name="card">
            <map>
                <entry key="身份证" value="12312321"/>
                <entry key="校园卡" value="12312312"/>
            </map>
        </property>
        <!--set-->
        <property name="games">
            <set>
                <value>王者荣耀</value>
                <value>英雄联盟</value>
            </set>
        </property>
        <!--空值null-->
        <property name="wife">
            <null></null>
        </property>
        <!--Properties-->
        <property name="info">
            <props>
                <prop key="driver">com.mysql.jdbc.driver</prop>
                <prop key="url">jdbc:mysql://localhost:3306/mybatis?</prop>
                <prop key="username">root</prop>
                <prop key="password">123456</prop>
            </props>
        </property>
    </bean>

</beans>
  1. 测试
public class DITest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        Student student=(Student) context.getBean("student");
        System.out.println(student);
    }
}
  1. 测试结果
Student{
    name='xpc', 
    address=Address{address='浙江省杭州市'}, 
    books=[水浒传, 三国演义, 红楼梦], 
    hobbies=[篮球, 足球, 乒乓球], 
    card={身份证=12312321, 校园卡=12312312}, 
    games=[王者荣耀, 英雄联盟], wife='null', 
    info={password=123456, url=jdbc:mysql://localhost:3306/mybatis?,                         driver=com.mysql.jdbc.driver, username=root}}

拓展方式注入

  • p命名空间和c命名空间注入
  • p命名空间对应简化的是无参构造注入
  • c命名空间对应的是有参构造注入
  1. 无参构造，使用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">

    <bean name="user" class="com.xu.pojo.User" p:name="xpc" p:age="18"></bean>

</beans>
  1. 有参构造，使用c命名空间
  2. 无参构造和有参构造都有的时候可以都用
<?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"   //p命名空间

       xmlns:c="http://www.springframework.org/schema/c" //c命名空间

       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean name="user" class="com.xu.pojo.User" c:name="xpc" c:age="18"></bean>

    <bean name="user2" class="com.xu.pojo.User" p:name="gh" p:age="19"></bean>

</beans>

bean的作用域

//spring默认为单例，在此模式下，每次从容器中获得的对象都是同一个
<bean name="user" class="com.xu.pojo.User" c:name="xpc" c:age="18" scope="singleton"></bean>
//测试
public class DITest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("userbean.xml");
        User user=context.getBean("user",User.class);
        User user2 = context.getBean("user", User.class);
        System.out.println(user.hashCode());
        System.out.println(user2.hashCode());
        System.out.println(user==user2);

    }
}
//测试结果
1651855867
1651855867
true
  • 也可设置为原型模式
//scope代表的就是作用域
<bean name="user" class="com.xu.pojo.User" c:name="xpc" c:age="18" scope="prototype"></bean>
//测试结果
1539805781
1206883981
false

bean的自动装配

三种方式：

  1. 在xml中显式装配

  2. 用java 显式装配

  3. 隐式自动装配【重要】

    • 使用byName，去容器里面找
    • byName的限制–byName自动装配是根据setxxx方法中的xxx命名，而且要小写，例如setCat
    <?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 name="dog" class="com.xu.pojo.Dog"/>
    <bean name="cat" class="com.xu.pojo.Cat"/>
 	//只要要装配的bean的name和person的set方法后面的是一样的即可
    //此处因为方法是setDog和setCat所以可以自动装配
    <bean name="person" class="com.xu.pojo.Person" autowire="byName">
        <property name="name" value="xpc"></property>
    </bean>

</beans>
    • 使用byType，只需要对象属性和容器里面的对象类型一致就可以自动装配-------person 里面的对象类型是Dog和Cat，容器里面的bean也是Dog和Cat
    //连name 都不用写
<bean  class="com.xu.pojo.Dog"/>
    <bean  class="com.xu.pojo.Cat"/>

    <bean name="person" class="com.xu.pojo.Person" autowire="byType">
        <property name="name" value="xpc"></property>
</bean>
不进大厂不改名--
关注
依赖注入与自动装配
chuituoyi7265的博客
04-25 387
依赖注入：当一个类的实例需要另一个类的实例协助时，在传统的程序设计过程中，通常有调用者来创建被调用者的实例。然而采用依赖注入的方式，创建被调用者的工作不再由调用者来完成，因此叫控制反转，创建被调用者的实例的工作由IoC容器来完成，然后注入调用者，因此也称为依赖注入。依赖注入的方式有两种：构造器...
spring框架特性:依赖注入(DI)与控制反转(IOC)----set方式注入/构造器方式注入/基本类型值注入/自动装配(autowire)/
qq_26570215的博客
11-07 273
如果说控制反转(ioc)是我们想要通过spring框架达到的目的,那么依赖注入(di)便是我们强有力的手段!以此来实现高内聚低耦合! 这里有一个A类 有什么方法可以让我们在不使用NEW的情况下创建出来该A类对象呢? 见证奇迹的时刻到了 一.我们创建一个Maven工程, 二.导包spring-webmvc ,Junit 三. 创建一个B类,构建其无参构造器,在B类中创建一个方法b1()...
java-12:spring MVC - 控制反转IOC，依赖注入DI
xushaozhang的专栏
10-06 622
学习spring框架之前，先理解几个概念： 1.第一部分：依赖倒置原则 2.第二部分：控制反转，控制反转容器（实例） 3.第三部分：控制反转，控制反转容器（全面理解，面试题） 综合性理解：控制反转（IOC）个人理解就是：真正的控制方不是上层类或者下层类，而是框架，也就是控制反转容器（即中央处理器），由框架根据配置文件提供各下层类实例，通过依赖注入的方式提供给上层类的注入点的接口或者抽象类...
Spring框架概述 --- 控制反转, 依赖注入, 容器和Bean
HelloWorld
09-17 428
Spring框架的好处 控制反转 Spring IOC容器和Bean 依赖注入 --- 控制反转的实现方法 Spring中bean的装配 ---- 定义bean并描述bean之间的依赖关系
Spring学习笔记 - 第一章 - IoC（控制反转）、IoC容器、Bean的实例化与生命周期、DI（依赖注入）
weixin_45063639的博客
11-20 1107
Spring的优点：简化开发IOCAOP事务处理框架整合MyBatisStrutsStruts2Hibernate…主要的学习内容IOC整合Mybatis(IOC的具体应用)AOP声明式事务(AOP的具体应用)学习重心Spring的思想Spring的基础操作案例练习官网：https://spring.io。
Spring Bean管理--依赖注入、自动装配
chuangxin的专栏
09-27 2011
一、摘要 本文主要介绍Spring Bean管理的依赖注入（Dependdency Injection，DI）部分：基于Setter注入，构造函数注入，自动装配注入，@Autowired注解注入等。 二、依赖注入 所谓注入，就是给某一个bean实例的属性设置值时，无需显现编写code就可以实现属性赋值；所谓依赖注入，则通常指bean实例引用了其它实例，如常见的service需要引用dao，则对于s...
Spring(一)----IOC控制反转、DI依赖注入
qq_43699614的博客
06-14 349
Spring(一)----IOC控制反转、DI依赖注入 Spring基础知识学习笔记(一)，内容包括： Spring入门案例 IOC控制反转理解 属性注入的不同方式 注入不同类型的属性值 自动装配与注解开发 参考视频： B站 尚硅谷雷丰阳大神的Spring、Spring MVC、MyBatis课程 【狂神说Java】Spring5最新完整教程IDEA版通俗易懂 1. Spring概述 开源的免费框架，是一个容器，可以管理所有的组件(类)； 轻量级的、非入侵的框架，不依赖于Spring的API
Spirng框架的入门----IOC控制反转与DI依赖注入的三个阶段
HSQdePYZ的博客
08-02 145
IOC（inverse of control）控制反转：其核心理念是将对象的控制权交给Spring框架管理，由Spring框架根据配置文件和注解统一管理Bean对象的创建和对象之间的依赖关系，是Spring框架的核心思想之一，主要作用是降低程序之间的耦合性。SpringIOC容器是实现IOC设计模式的一个重要组件，用来创建Bean对象并管理Bean对象的生命周期，并根据配置文件和注解，管理容器中的每一个对象和对象间的依赖关系，属于Spring中的Core核心板块。
Spring-搭建环境-IOC控制反转&依赖注入
weixin_45790562的博客
06-18 126
Spring spirng相关技术 Spring data Spring boot Spring framework Spring social IOC控制反转：（DI：依赖注入） 搭建Spring环境 下载jar 网址：jar包地址 下载之后是一个 压缩包：spring-framework-4.3.9.RELEASE-dist.zip 2.在libs目录下，引入（4+1）个jar包 spring-aop.jar 开发AOP特性时需要的jar包 spring-beans.jar 处
maven-spring-ioc
08-07
Spring还提供了一种自动装配Bean的方式，即根据类型或名称自动查找并注入依赖。这可以通过`autowire`属性实现： - `byType`：基于依赖类型自动装配。 - `byName`：基于依赖的属性名自动装配。 ### 7. Profile ...
Spring04--依赖注入，bean 的作用域和自动装配
CSDN_SHY的博客
05-20 157
一、依赖注入 1.构造器注入,上一章有~ 2.set方式注入 依赖注入：set注入 依赖：bean对象的创建依赖于容器,Bean对象的依赖资源 注入：bean对象中的所有属性，由容器来设置和装配 Set注入：要求被注入的属性 , 必须有set方法 , set方法的方法名由set + 属性首字母大写 , 如果属性是boolean类型 , 没有set方法 , 是 is . 环境搭建： 地址类： public class Address { private String address; publ
Spring之依赖注入（IOC、DI）详解---配置Bean
Megustas_JJC的博客
01-16 1094
Spring是什么 轻量级：Spring 是非侵入性的 - 基于 Spring 开发的应用中的对象可以不依赖于 Spring 的 API 依赖注入(DI — dependency injection、IOC) 面向切面编程(AOP — aspect oriented programming) 容器: Spring 是一个容器, 因为它包含并且管理应用对象的生命周期 框架: Spring 实现了使用简
Spring_IoC控制反转、依赖注入详解
WziH_CSDN的博客
09-30 677
Spring_IoC 一、IoC相关概念简介 1、理解【控制】和【依赖】的概念 IoC即控制反转、依赖注入 。—— OOAD依赖倒置 【控制】和【依赖】都代表对象之间的关联关系，而且他们在Spring中是一对近义词，控制和依赖几乎是并存的。 例如，现有如下需求：汽车的功能是行驶，司机的功能是驾驶汽车，令汽车行驶。 我们可以通过代码描述上述关系： public class Car { // 汽车类 private String name; // 品牌 private Double price;
spring揭秘19-spring事务01-事务抽象
PacosonSWJTU的博客
09-08 1308
1）spring对事务元素进行抽象， 客户端仅按照统一的编程模型管理事务，而不用关心数据访问技术以及具体要访问什么类型的事务资源；此外：spring事务管理与spring提供的数据访问技术（如JdbcTemplate）进行结合；2）spring事务框架设计的基本原则： 让事务管理逻辑与数据访问逻辑解耦；spring揭秘15-spring集成数据访问技术(orm框架)总结事务隔离级别；isolation；事务传播行为；事务超时时间；timeout；是否为只读事务；readOnly；
Spring05——注解开发定义bean、Spring纯注解开发模式
后端小白个人学习记录
09-08 903
注解开发定义bean、Spring纯注解开发模式
SpringSecurity原理解析（二）：认证流程
liang8999的博客
09-08 1067
attemptAuthentication 方法在子类UsernamePasswordAuthenticationFilter 中实现的。attemptAuthentication方法的作用是获取Authentication对象其实就是对应的认证过程，用该AuthenticationProvider的authenticate函数认证，如果认证成功则整个认证过程结束。AuthenticationManager接口中就定义了一个方法authenticate方法，用于处理认证的请求；
SSM框架学习（二：SpringFramework实战指南）
最新发布
xpy2428507302的博客
09-09 939
一个项目，一个工程，导出为一个war包，在一个Tomcat上运行，即 all in one。单一架构的项目主要应用技术框架为：Spring , SpringMVC , Mybatis负责实例化、配置和组装 bean（组件）。容器通过读取配置元数据（配置文件）来获取有关要实例化、配置和组装组件的指令。XML、Java 注解或 Java 代码形式。它允许表达组成应用程序的组件以及这些组件之间丰富的相互依赖关系。应用程序类与配置元数据相结合，才拥有完全配置且可执行的系统或应用程序。
基于SpringBoot的旅游管理系统
heye0910032的博客
09-08 460
随着科技的发展，旅游管理系统的信息化成为提升旅游服务效率的关键。本系统采用JSP技术和SpringBoot框架，结合MySQL数据库，旨在实现一个功能全面、操作简便、安全可靠的旅游管理平台。系统通过需求分析、系统设计、功能实现和测试，确保了良好的用户体验和数据处理能力，为旅游业务的现代化管理提供了强有力的技术支持。本研究成功开发了一个基于SpringBoot的旅游管理系统，该系统通过集成多种旅游管理功能，显著提高了旅游服务的效率和质量。系统的用户友好界面和强大的后端功能，使得管理员和用户都能从中受益。
Spring IOC与DI：依赖注入与构造注入解析
"本资源主要介绍了Spring框架中的IoC（Inversion of Control，控制反转）和DI（Dependency Injection，依赖注入）概念，以及如何在Spring中实现依赖注入，包括构造注入、设值注入和p命名空间注入。此外，还提到了...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值