spring注解非单例 spring 非单例注入的原理

转载

信息流星 2024-02-15 19:48:04

文章标签 spring注解非单例 spring xml 依赖注入 文章分类 架构后端开发

文章目录

一：Why Spring？
二：第一个Spring程序
三：Bean的有参构造
四：依赖注入DI（dependence Injection）

官网文档

一：Why Spring？

Spring：译为春天（程序员的春天），Spring之前主要是EJB的方式，耦合性强，配置规则臃肿繁琐，为了解决J2EE的臃肿低效，Spring应运而生。2004年发布了第一版。

Spring特点

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

二：第一个Spring程序

导入Spring依赖

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.3.6</version>
</dependency>

构建一个实体类

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 + '\'' +
                '}';
    }
}

<?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">

    <!--Spring在此处创建对象，对象名为helloSpring，创建对象为pojo.hello，在bean内部设置属性值-->
    <!--等同于Hello helloSpring = new Hello();helloSpring.str = "Hello Spring"-->
    <bean id="helloSpring" class="com.chelsea.pojo.Hello">
        <!--设置属性值的时候就是依赖注入，是通过set方法注入的-->
        <property name="str" value="Hello Spring"/>
    </bean>

</beans>

测试配置好的Spring环境

public class myTest {
    public static void main(String[] args) {
        //获取Spring上下文对象
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
        //从容器中获取对象并强制转换
        Hello hello = (Hello) applicationContext.getBean("helloSpring");
        //使用此对象中的所有方法
        System.out.println(hello.toString());
    }
}

Spring IOC和Bean
SpringIOC：IOC（Inversion of Control）意为控制反转，也称为依赖注入。这是一个过程，其中对象仅通过构造函数参数，工厂方法的参数来构造对象。
Bean：Spring本身是一个容器，来管理各种对象。由SpringIOC容器管理的对象成为bean，bena是由SpringIOC容器实例化，组装和管理的对象。如果不是由Spring创建的，那就只是一个普通的对象实例。Bean和Bean之间的依赖关系在Bean的配置（xml文件）中显示。

三：Bean的有参构造

Bean的有参构造

<?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">

    <!--其中在配置文件加载的时候，容器中的对象就已经初始化了-->

    <!--id：bean的唯一标识符，也就是对象名-->
    <!--class：bean对象所对应的全限定名-->
    <!--name：相当于别名，且可以同时取多个，所以alias就是无用的-->
    <!--scope：对象创建方式，可以单例等-->
    <!--class对象的有参构造方法-->
    <bean id="user" class="com.chelsea.pojo.User" name="user3,user4 user5;user6">
        <!--第一种方法：通过下标赋值-->
<!--        <constructor-arg index="0" value="Chelsea"/>-->
        <!--第二种方法：通过类型赋值（此方法不建议使用，因为若有多个同类型参数，无法进行区分）-->
<!--        <constructor-arg type="java.lang.String" value="Chelsea"/>-->
        <!--第三种方法：直接使用名字进行赋值-->
        <constructor-arg name="name" value="chelsea"/>
    </bean>

    <!--alias就是取别名，此时新名字和旧名字都能通过getbean的方式取出对象-->
    <alias name="user" alias="user2"/>
</beans>

Spring Xml文件中import的用法
在同一个Spring项目中，可能有多个bean配置文件，其中多个文件可以使用import标签进行整合，如下所示：

<?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">

    <!--import：用来导入设计的多个beansxml文件，最终在测试中，只引入ApplicationContext这一个xml文件即可-->
    <import resource="beans.xml"/>
    <import resource="beans1.xml"/>
    <import resource="beans2.xml"/>
</beans>

四：依赖注入DI（dependence Injection）

依赖注入和控制反转说的是同一件事情，立场不同。通过依赖注入来实现了控制反转，依赖注入可以简单的理解为传参，根据传参的不同来构造不同对象进而构建不同对象。
本节介绍xml文件中依赖注入的几种方式。

构造一个实体类Student

public class Student {
	//方便代码观赏，此处就不写构造器和Set get方法
    private Address address;
    private String name;
    private String[] book;
    private List<String> hobbys;
    private Map<String,String> card;
    private Set<String> games;
    private Properties info;
    private String wife; 
}

在xml文件中进行不同类型的依赖注入

<bean id="student" class="com.chelsea.pojo.Student">

        <!--第一种：普通值注入-->
        <property name="name" value="chelsea"/>

        <!--第二种：引用类型注入-->
        <property name="address" ref="address"/>

        <!--第三种：数组注入-->
        <property name="book">
            <array value-type="java.lang.String">
                <value>红楼梦</value>
                <value>三国演义</value>
                <value>水浒传</value>
                <value>西游记</value>
            </array>
        </property>

        <!--第四种：List注入-->
        <property name="hobbys">
            <list value-type="java.lang.String">
                <value>读书</value>
                <value>跑步</value>
                <value>玩游戏</value>
            </list>
        </property>

        <!--第五种：Map集合注入-->
        <property name="card">
            <map key-type="java.lang.String" value-type="java.lang.String">
                <entry key="身份证" value="1234567890"/>
                <entry key="学号" value="13241241"/>
                <entry key="宿舍号" value="A218"/>
            </map>
        </property>

        <!--第六种：Set集合注入-->
        <property name="games">
            <set value-type="java.lang.String">
                <value>王者荣耀</value>
                <value>英雄联盟</value>
                <value>俄罗斯方块</value>
            </set>
        </property>

        <!--第七种：Properties配置文件注入-->
        <property name="info">
            <props>
                <prop key="饭量">1.5斤</prop>
                <prop key="身高">3米</prop>
                <prop key="体重">120kg</prop>
                <prop key="性别">男</prop>
            </props>
        </property>

        <!--第八种：空值注入-->
        <property name="wife">
            <null/>
        </property>
    </bean>
    <bean id="address" class="com.chelsea.pojo.Address">
        <property name="address" value="陕西"/>
    </bean>

使用P/C命名标签来进行属性装配
要在xml的头文件中引入p和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命名空间通过在上述引用链接即可-->
    <!--P原称为Properties，相当于在bean种配置值而已-->
    <!--P就是一种简化配置的标签，否则原配置则为最下面那种方式-->
    <!--此方法是通过set方法注入的-->
    <bean id="user" class="com.chelsea.pojo.User" p:age="18" p:name="chelsea" scope="singleton"/>

    <!--c标签的使用-->
    <!--c标签只有当对象存在有参构造器时才可以被使用-->
    <!--此方法是通过构造器方式注入的-->
    <bean id="user1" class="com.chelsea.pojo.User" c:age="19" c:name="chelsea1"/>

<!--    <bean id="user" class="com.com.chelsea.pojo.User">-->
<!--        <property name="name" value="chelsea"/>-->
<!--        <property name="age" value="18"/>-->
<!--    </bean>-->

    <!--bean配置中有scope属性，用来配置bean的作用域-->
    <!--singleton：单例模式-->
    <!--prototype:每次获取都重新创建一个对象-->
    <!--还有request，application，session等后期再说-->

</beans>

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。