Spring笔记Day1

最新推荐文章于 2023-09-03 10:36:22 发布

晚睡。

最新推荐文章于 2023-09-03 10:36:22 发布

阅读量68

点赞数

分类专栏：笔记文章标签： spring

本文链接：https://blog.csdn.net/CSDN_DK317/article/details/120291838

版权

笔记专栏收录该内容

15 篇文章 0 订阅

订阅专栏

本文详细介绍了Spring框架的核心概念，包括Spring的定义、优点、控制反转（IOC）和依赖注入（DI）。展示了通过set方法、构造函数和P标签空间三种方式实现属性注入，并探讨了Bean的作用域及其生命周期。此外，还演示了如何注入数组、List、Map和Set等集合属性，以及展示了不同方式创建和配置Bean的例子。

摘要由CSDN通过智能技术生成

1.Spring是什么？它的特点和优势分别是？

1.1 Spring是什么？

1.2 Spring的优点。

2.耦合是什么意思？

3.Spring核心是什么？

4.IOC是什么含义？

提到控制就要理解控制的含义，控制就是对象的创建、初始化、销毁。创建对象，原来是 new 一个，现在给 Spring 容器创建了；对象初始化，比如 A 依赖 B，原来是我们通过构造器或者 setter 方法赋值，现在给 Spring 容器自动注入了；销毁对象，原来是我们直接赋值 null 或者做一些销毁操作，现在给 Spring 容器管理生命周期负责销毁。明白了吧，IOC 解决了繁琐的对象生命周期的操作，解耦了我们的代码。

5.DI是什么？和IOC有什么区别？

IOC：控制反转，指将对象的创建权，反转到spring容器。

DI：依赖注入，指在创建对象的过程中，将对象依赖的属性通过配置进行注入。DI的实现依赖于IOC，先有控制反转才有依赖注入

6.属性注入的方式有哪些？

6.1 使用set方法进行注入

package com.Keafmd.spring5;

public class Book {

	//创建属性
    private  String bname;
    private String bauthor;
    private String address;

    //1、set方法注入
    //创建对应的set方法
    public void setBname(String bname) {
        this.bname = bname;
    }

    public void setBauthor(String bauthor) {
        this.bauthor = bauthor;
    }

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

    public void testdemo(){
        System.out.println(bname+" "+bauthor+" "+address);
    }
}

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 id="book" class="com.Keafmd.spring5.Book">
        <property name="bname" value="书名"></property>
        <property name="bauthor" value="作者"></property>

        <!--  向属性注入null值-->
        <!--<property name="address" >
            <null/>
        </property>-->
        
		<!-- <property name="address" value="&lt;&lt;北京&gt;&gt;"></property> -->

        <property name="address">
            <value><![CDATA[<<北京>>]]></value>
        </property>
    </bean>

</beans>

6.2 使用有参构造函数注入：

package com.Keafmd.spring5;

public class Orders {
    private String oname;
    private String address;

    public Orders(String oname, String address) {
        this.oname = oname;
        this.address = address;
    }

    public void ordersTest(){
        System.out.println(oname+" "+address);
    }
}

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 id="orders" class="com.Keafmd.spring5.Orders">
        <constructor-arg name="oname" value="电脑"/>
        <constructor-arg name="address" value="China"/>
    </bean>

</beans>

6.3 使用P标签空间注入

package com.Keafmd.spring5;

public class Book {

    private  String bname;
    private String bauthor;
    private String address;

    public void setBname(String bname) {
        this.bname = bname;
    }

    public void setBauthor(String bauthor) {
        this.bauthor = bauthor;
    }

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

    public void testdemo(){
        System.out.println(bname+" "+bauthor+" "+address);
    }
}

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

    <!--三、p名称空间注入属性-->

    <bean id="book" class="com.Keafmd.spring5.Book" p:bname="书名XXX" p:bauthor="作者XXX" p:address="地址XXX">
    </bean>

</beans>

7.Spring管理Bean的作用域。

当一个bean的作用域为Singleton，那么Spring IoC容器中只会存在一个共享的bean实例，并且所有对bean的请求，只要id与该bean定义相匹配，则只会返回bean的同一实例。
当一个bean的作用域为Prototype，表示一个bean定义对应多个对象实例。Prototype作用域的bean会导致在每次对该bean请求（将其注入到另一个bean中，或者以程序的方式调用容器的getBean()方法）时都会创建一个新的bean实例。
当一个bean的作用域为Request，表示在一次HTTP请求中，一个bean定义对应一个实例。
当一个bean的作用域为Session，表示在一个HTTP Session中，一个bean定义对应一个实例。该作用域仅在基于web的Spring ApplicationContext情形下有效。
当一个bean的作用域为Global Session，表示在一个全局的HTTP Session中，一个bean定义对应一个实例。典型情况下，仅在使用portlet context的时候有效。该作用域仅在基于web的Spring ApplicationContext情形下有效。

8.Spring管理Bean的生命周期。

Bean生命周期图示

9.如何注入集合属性？

package com.Keafmd.spring5.collectiontype;

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Set;

public class Stu {

    //1、数组类型属性
    private String[] courses;

    //2、list集合类型属性
    private List<String> list;

    //3、map集合类型属性
    private Map<String,String> maps;

    //4、set集合类型属性
    private Set<String> sets;


    //学生所学的多门课程
    private List<Course> courseList;

    public void setCourseList(List<Course> courseList) {
        this.courseList = courseList;
    }

    public void setCourses(String[] courses) {
        this.courses = courses;
    }

    public void setList(List<String> list) {
        this.list = list;
    }

    public void setMaps(Map<String, String> maps) {
        this.maps = maps;
    }

    public void setSets(Set<String> sets) {
        this.sets = sets;
    }

    public void test(){
        System.out.println(Arrays.toString(courses));
        System.out.println(list);
        System.out.println(maps);
        System.out.println(sets);
        System.out.println(courseList);
    }

}

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 id="stu" class="com.Keafmd.spring5.collectiontype.Stu">
        <!--数组类型属性注入-->
        <property name="courses">
            <array>
                <value>Java</value>
                <value>C++</value>
                <value>Python</value>
            </array>
        </property>

        <!--list类型属性注入-->
        <property name="list">
            <list>
                <value>小明</value>
                <value>小红</value>
            </list>
        </property>

        <!--map类型属性注入-->
        <property name="maps">
            <map>
                <entry key="Java" value="java"></entry>
                <entry key="C++" value="c++"></entry>
            </map>
        </property>

        <!--set类型属性注入-->
        <property name="sets">
            <set>
                <value>北京</value>
                <value>上海</value>
            </set>
        </property>

        <!--注入list集合类型，值是对象-->
        <property name="courseList">
            <list>
                <ref bean="course1"></ref>
                <ref bean="course2"></ref>
            </list>
        </property>
    </bean>
    <!--创建多个course对象-->
    <bean id="course1" class="com.Keafmd.spring5.collectiontype.Course">
        <property name="cname" value="Spring5框架"></property>
    </bean>

    <bean id="course2" class="com.Keafmd.spring5.collectiontype.Course">
        <property name="cname" value="MyBatis框架"></property>
    </bean>
</beans>

10.Spring中Bean的两种方式。

首先创建一个student类


@Data
@AllArgsConstructor
@NoArgsConstructor
public class Student implements Serializable {
 
    private static final long serialVersionUID = -2088281526481179972L;
    private int id;
    private String name;
    private int age;
}

在beans.xml中定义Student：

 <!-- 1.空值的student -->
    <bean id="studentNoValue" class="domain.Student"/>
 
    <!-- 2.带值的student -->
    <bean id="student" class="domain.Student">
        <property name="id" value="11"/>
        <property name="age" value="22"/>
        <property name="name" value="jack"/>
    </bean>
 
    <!-- 3.全参构造：使用成员变量名称对应 -->
    <bean id="studentConstruct" class="domain.Student">
        <constructor-arg name="age" value="22"></constructor-arg>
        <constructor-arg name="id" value="11"></constructor-arg>
        <constructor-arg name="name" value="jack"></constructor-arg>
    </bean>
 
    <!-- 4.全参构造：使用成员变量index对应 -->
    <bean id="studentConstruct2" class="domain.Student">
        <constructor-arg index="0" value="11"></constructor-arg>
        <constructor-arg index="1" value="jack"></constructor-arg>
        <constructor-arg index="2" value="22"></constructor-arg>
    </bean>
 
    <!-- 5.全参构造：使用成员变量类型对应 -->
    <bean id="studentConstruct3" class="domain.Student">
        <constructor-arg type="int" value="11"></constructor-arg>
        <constructor-arg type="java.lang.String" value="jack"></constructor-arg>
        <constructor-arg type="int" value="22"></constructor-arg>
    </bean>

晚睡。

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Spring笔记Day1

1.Spring是什么？它的特点和优势分别是？1.1 Spring是什么？1.2 Spring的优点。2.耦合是什么意思？3.Spring核心是什么？4.IOC是什么含义？提到控制就要理解控制的含义，控制就是对象的创建、初始化、销毁。创建对象，原来是 new 一个，现在给 Spring 容器创建了；对象初始化，比如 A 依赖 B，原来是我们通过构造器或者 setter 方法赋值，现在给 Spring 容器自动注入了；销毁对象，原来是我们直接赋值 null 或者做一些...
复制链接

扫一扫