Spring学习（一）——容器注入

最新推荐文章于 2024-04-21 18:14:50 发布
最新推荐文章于 2024-04-21 18:14:50 发布
阅读量560 收藏 1
点赞数
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nc514819873/article/details/107906194
版权

开篇先小小感慨一下：人生全都是命运的安排呀，读大学、研究生躲了这么多年的Java，最终都要还回来啊。今天开始学习Spring了，开始搬砖的人生

文章目录

Spring基础

为了降低Java开发的复杂性，Spring采用了以下4种关键策略：

1、基于POJO的轻量级和最小侵入性编程，所有东西都是bean；

2、通过IOC，依赖注入（DI）和面向接口实现松耦合；
IOC（Inversion of controll 控制反转）：对象之间的依赖关系由容器来控制。
DI（Dependency injection 依赖注入）：容器通过调用对象提供的set方法或者构造器来建立依赖关系。
IOC是目标，DI是实现手段。
3、基于切面（AOP）和惯例进行声明式编程；

4、通过切面和模版减少样式代码，RedisTemplate，xxxTemplate；

1. set方式注入（较常用）

被注入类提供set方法，配置元素
以下给出一个简单的set方式注入依赖关系的例子：
1、配置xml文件

<bean id="b1" class="com.niuchen.spring.ioc.B"/>
 <!--
     property表示实用set方法注入依赖关系。
     其中，name指定属性名（注入类的对象属性），ref指定属性值（注入的bean的id）
-->
<bean id="a1" class="com.niuchen.spring.ioc.A">
    <property name="b" ref="b1"/>
</bean>

2、定义类

// 注入类
public class B {
    public B(){
        System.out.println("B");
    }

    public void f1(){
        System.out.println("B's f1");
    }
}

// 被注入类
public class A {
    private B b;//实际应用中更多使用接口定义对象属性，防止代码的修改，此处只为示例
    public A(){
        System.out.println("A");
    }
	// B类的set方法，注意方法名不可随意定义
    public void setB(B b) {
        System.out.println("setB");
        this.b = b;
    }

    public void excute(){
        System.out.println("excute");
        // 注入依赖后在A类中直接调用B类方法
        b.f1();
    }
}

3、测试例

public class TestCase {
    @Test
    public void test3(){
        AbstractApplicationContext ac = new ClassPathXmlApplicationContext("ioc.xml");
        A a = ac.getBean("a1", A.class);
        a.excute();
    }
｝
2. 构造器方式注入

1.添加相应构造器

public class A {
    //接口类型多态，避免了代码的修改
    private IB b;
    public A(){
        System.out.println("A");
    }
	// 添加相应的构造器
    public A(IB b){
        System.out.println("A(B)");
        this.b = b;
    }

    public void excute(){
        System.out.println("excute");
        b.f1();
    }
}

2.配置constructor-arg元素

<bean id="b2" class="com.niuchen.spring.ioc2.B"/>
<!--  constructor-arg 配置构造器注入
    index指定参数下标
  -->
<bean id="a2" class="com.niuchen.spring.ioc2.A">
    <constructor-arg index="0" ref="b2"/>
</bean>
3. 自动装配

spring容器根据某种规则自动建立对象之间的依赖关系。

  • 默认情况下，容器不会自动装配。
  • 可以通过指定autwire属性告诉容器进行自动装配（容器底层仍然通过上文的方式建立依赖关系）。
public class Waiter {
    public Waiter(){
        System.out.println("Waiter");
    }
}
public class Restaurant {
    private Waiter wt;
    public Restaurant(){
        System.out.println("Restaurant");
    }

    public void setWt(Waiter wt) {
        System.out.println("setwt");
        this.wt = wt;
    }

    @Override
    public String toString() {
        return "Restaurant{" +
                "wt=" + wt +
                '}';
    }
}

配置xml

<bean id="wt" class="com.niuchen.spring.autoIn.Waiter"/>
    <!--  autowire:自动装配
        byName:容器根据属性名查找对应id的bean，并调用相应set方法注入。
               如果没有对应属性名的bean，则注入空值。
        byType:容器根据属性类型查找对应类型class的bean，并调用相应set方法注入。
               如果没有对应属性名的bean，则注入空值。
               如果有多个符合条件的bean则保报错。
        constructor:容器根据属性类型查找对应类型class的bean，并调用相应构造器方法注入。
      -->
    <bean id="rest" class="com.niuchen.spring.autoIn.Restaurant" autowire="byName"/>

junit测试

	@Test
    // 自动装配
    public void test5(){
        AbstractApplicationContext ac = new ClassPathXmlApplicationContext("auto.xml");
        Restaurant rest = ac.getBean("rest", Restaurant.class);
        System.out.println(rest);

    }
    /**
    *测试结果：Waiter
	*		  Restaurant
	*		  setwt
	*		  Restaurant{wt=com.niuchen.spring.autoIn.Waiter@eafc191}
    **/
4. 注入基本类型值

配置property属性的value标签。

public class ValueBean {
    private String name;
    private int age;
	
    public ValueBean(){System.out.println("Value");}
    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "ValueBean{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}


<bean id="vb" class="com.niuchen.spring.value.ValueBean">
    <property name="name" value="哈哈哈"/>
    <property name="age" value="30"/>
</bean>
5. 注入集合类型值

set方式注入
与基本类型相似，只是配置文件不同，不同类型集合使用对应类型标签赋值，如List使用list标签，Set使用set标签。

<bean id="vb" class="com.niuchen.spring.value.ValueBean">
    <property name="name" value="哈哈哈"/>
    <property name="age" value="30"/>
    <property name="city">
         <list>
             <value>北京</value>
             <value>重庆</value>
             <value>上海</value>
         </list>
     </property>
     <property name="interest">
          <set>
              <value>台球</value>
              <value>吉他</value>
              <value>音乐</value>
          </set>
      </property>
      <property name="score">
           <map>
               <entry key="英语" value="60" />
               <entry key="数学" value="66"/>
           </map>
      </property>
      <property name="db">
          <props>
              <prop key="usearname">nc</prop>
              <prop key="password">123456</prop>
          </props>
      </property>
</bean>

public class ValueBean {
    private String name;
    private int age;
    private List<String> city;
    private Set<String> interest;
    private Map<String, Double> score;
    private Properties db;

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

    public void setAge(int age) {
        this.age = age;
    }

    public void setCity(List<String> city) {
        this.city = city;
    }

    public void setInterest(Set<String> interest) {
        this.interest = interest;
    }

    public void setScore(Map<String, Double> score) {
        this.score = score;
    }

    public void setDb(Properties db) {
        this.db = db;
    }

    @Override
    public String toString() {
        return "ValueBean{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", city=" + city +
                ", interest=" + interest +
                ", score=" + score +
                ", db=" + db +
                '}';
    }
}

引用注入集合类型的值
对上个例子以引用方式注入的配置方式，该方式配置更整洁灵活，方便集合值重用

    <!--  util命名空间  将集合类型的值配置成一个bean -->
    <util:list id="cityBean">
        <value>北京</value>
        <value>重庆</value>
        <value>上海</value>
    </util:list>
    <util:set id="interestBean">
        <value>台球</value>
        <value>吉他</value>
        <value>音乐</value>
    </util:set>
    <util:map id="scoreBean">
        <entry key="英语" value="60" />
        <entry key="数学" value="66"/>
    </util:map>
    <util:properties id="dbBean">
        <prop key="usearname">nc</prop>
        <prop key="password">123456</prop>
    </util:properties>
    <!--  引用的方式注入集合类型的值，方便重用  -->
    <bean id="vb2" class="com.niuchen.spring.value.ValueBean">
        <property name="city" ref="cityBean"/>
        <property name="interest" ref="interestBean"/>
        <property name="score" ref="scoreBean"/>
        <property name="db" ref="dbBean"/>
    </bean>

附加小知识点：
spring表达式：#｛bean_id.属性｝
Spring容器可以通过Spring表达式获取到其他bean的属性值。

<!--  spring表达式读取其他bean的属性  -->
    <bean id="sp1" class="com.niuchen.spring.value.SpelBean">
        <property name="name" value="#{vb.name}"/>
        <property name="city" value="#{vb.city[1]}"/>
        <property name="score" value="#{vb.score.english}"/>
        <property name="pageSize" value="#{config.pagesize}"/>
    </bean>
Growing_Snake
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
初识Spring——Spring核心容器
02-24
而控制反转就是把传统程序中需要实现对象的创建、代码的依赖，反转给一个专门的"第三方"即容器来实现，即将创建和查找依赖对象的控制权交给容器，由容器将对象进行组合注入，实现对象与对象的松耦合，便于功能的复用...
spring 将bean注入容器4种方式
goxingman的博客
07-30 1849
一.通过xml方式注入容器 1.建立xml文件，将bean配置到xml中 2.创建xml读取方法，ClassPathXmlApplicationContext（）来读取配置文件 二。通过@componentScan,扫描指定包下的bean 1.创建bean，注意加上@component注解 2.创建配置类，扫描bean所在包 3.启动时加载配置类，（如果项目是springboot，那么会自动加载配置类，不用这一步） 三。通过@bean注入容器 1.创建bean，不用加上@
Spring的简介ioc容器及注入方式
ChatYU的博客
08-16 401
IOC（Inversion of Control，控制反转）是一种软件设计的原则，用于实现松耦合和可维护性的应用程序。在IOC容器中，控制权从应用程序代码转移到容器中，由容器负责实例化、管理和协调应用程序中的对象。以下是IOC容器的一些特点：控制反转：IOC容器通过控制反转的方式，将对象的控制权从应用程序代码转移到容器中。应用程序不需要手动创建对象，而是由容器创建和管理对象的生命周期。依赖注入：IOC容器通过依赖注入的方式，自动解决对象之间的依赖关系。
手把手教你使用 Spring IOC 容器完成注入操作（xml注入 + 注解注入）
最新发布
2401_83916394的博客
04-21 742
M —— modal 模型层（实体类）V —— views 视图层 （界面）C —— controller 控制层 （用来完执行一些操作）这三层架构各自分工，独自完成相对应的功能，但是这样的程序写出来会导致程序之间耦合性过高。
【SSH快速进阶】——Spring IOC容器注入的几种方式
点滴汇聚，智在积累。——Danny
07-25 2203
IOC（Inversion of Control）：控制反转，怎么理解这句话呢？看一个例子就明白了。　　一个操作用户的Dao层接口UserDao ：public interface UserDao { public void addUser(String username,String password); }　　UserDao 的两个实现类（Oracle版本和MySql版本）：public
Bean注入容器的多种方式
u014365523的博客
08-19 2909
bean注入容器
SpringBoot自动配置及容器注入理解
m0_60938243的博客
08-12 489
SpringBoot的自动装配和容器注入的一些知识点
Spring从入门到入土——依赖注入（DI）
12-20
DIDependency Injection概念注入方式...Spring从入门到入土——依赖注入（DI） Spring从入门到入土——Bean的作用域 Dependency Injection 概念 依赖注入（DI） 依赖：指Bean对象的创建依赖于容器。Bean对象的依赖资
零基础入门学习——Spring Boot注解(一)
08-30
* `@Bean`：用于标注方法产生一个 Bean，告诉 Spring 容器可以从该方法中获取一个 Bean 注入 Bean 的注解 * `@Autowired`：自动注入 Bean，default byType 型的注入，可以用于属性或方法上 * `@Qualifier`：用于...
spring为类的静态属性实现注入实例方法
08-25
其中，`dingdingReceiverMan` 属性的 set 方法通过 `@Value` 注解来注入一个配置“monitor_log.dingding.receiverMan”，而 `redisUtil` 属性的 set 方法通过 `@Autowired` 注解来注入一个 Bean——被 `@Component` ...
spring注入方式
shangliangren的博客
04-03 4461
接口注入： 一个类依赖另一个接口都实现，先在配置文件中设定都实现类都类名，动态加载实现类，并通过接口强制转型后为class类所用 Setter注入： Setter注入模式使用比较多，它更加直观，被注入的属性需要有set方法，setter注入时在bean实例创建完成之后执行 Setter注入可以注入简单值和map、set、list、数组，简单值注入使用＜property＞的value属性 构造器注入： 构造器注入，也就是通过构造方法注入依赖，构造函数的参数一般情况下就是依赖项，spring容器会根据bean中
c# 实现的简单的 注入容器
09-21
在学习 IOC 的时候根据自己的理解，实现的简单的注入容器，实现构造函数注入，属性注入，字段注入。代码比较简单 适合理解 注入容器原理
将bean注入Spring容器的五种方式
gs2436的博客
02-15 2310
我们在项目开发中都用到Spring，知道对象是交由Spring去管理。那么将一个对象加入到Spring容器中，有几种方法呢，我们来总结一下。
spring容器注入---@Import
weixin_40017062的博客
01-15 496
spring容器注入三种方式： 1、通过xml配置、注解 2、通过 @Configuration 与 @Bean 这两个注解配合 3、@Import 方式注入
2024年Java常见面试题目，java集合框架面试
2401_84413490的博客
04-20 398
1.1 传统应用架构的问题1.2 微服务架构是什么1.3 微服务架构有哪些特点和挑战1.4 如何搭建微服务架构2.1 Spring Boot 是什么2.2 如何使用Spring Boot框架2.3 Spring Boot生产级特性3.1 Node.js 是什么3.2 如何使用 Node.js3.3 使用Node.js搭建微服务网关4.1 ZooKeeper 是什么4.2 如何使用 ZooKeeper4.3 实现服务注册组件4.4 实现服务发现组件5.1 Docker 是什么5.2 如何使用 Docker5.
Spring IOC之容器注入
BushRo
07-03 1529
spring最主要的功能就是IOC和AOP，IOC指的是容器注入，帮我们把Bean注入到容器中。实际上就是把类解析成spring能够识别的标识，而标识就是BeanDefinition，有了这个标识spirng就可以做各种各样的事情了。那么我们有必要了解什么是BeanDefinition并且它是如何生成的。什么是BeanDefinitionBeanDefinition中的常用属性BeanDefinition的常见读取器ChildBeanDefinition从Spring2.5开始，ChildBeanDefin
容器中的组件注入（多种方式）
Serendipity的博客
09-13 407
@Configuration+@Bean 前置 创建User和Pet类 public class User { private String name; private Integer age; public User(){ } public User(String name, Integer age) { this.name = name; this.age = age; } public String getN
Spring和Springboot中容器注入那些事
mutf7的博客
07-17 481
Spring和Springboot中容器注入那些事 spring容器如何去存储我们的bean 底层：每一个bean对应了一个BeanDefinition对象，每个bean注册到Map中。如何证明呢? 答案是：使用BeanDefintionMap来存储的所有的bean。 也就是说springioc就是一个map，仅此而已。 springioc负责：对象的初始化，对象管理，对应的依赖注入，对象的生命周期，对象的获取等（对象的生命周期的管理） 一般情况下，JVM不会回收这块空间，因为它是一个强引用，除非调用了
容器和注入技术
baihu6628的博客
03-10 121
JVM是Java程序唯一认识的操作系统，可执行.class文件。WEB容器是Servlet/JSP唯一认得的HTTP服务器。 容器说白了就是一个用java写的程序，运行与JVM之上。HTTP那些文字性的通信协议，如何变成Servlet/JSP中可用的Java对象，其实就是容器的剖析与转换。 只要写的Servlet/JSP符合WEB容器的标准规范，Servlet/JSP就可以在各...
Spring Boot 实践之十三 10 Spring Boot综合项目实战——个人博客系统拓展模块
05-24
最后，我们需要在 Spring Boot 项目中将这个拓展模块注入到容器中，并在需要的地方调用它的方法。我们可以使用 `@Autowired` 注解将拓展模块注入到其他组件中： ```java @Service public class BlogService { @...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Growing_Snake

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值