【Spring IOC容器】Bean管理的操作方式之基于xml方式

已于 2022-08-24 16:51:43 修改
阅读量263 收藏
点赞数
分类专栏： # Spring MVC 文章标签： spring bean
于 2021-01-26 20:34:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45797116/article/details/113095328
版权

文章目录

一、Bean管理

① 什么是Bean管理

Spring的Bean管理主要指的是如下两个操作：

  • Spring创建对象
public class User {
    public void add(){
        System.out.println("add....");
    }
}

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

   <!--配置User对象创建-->
   <bean id="user" class="com.atguigu.spring5.User"></bean>
</beans>

目前具有一个User类，原本可以通过new的方式去创建对象；但是现在我们将其交给Spring去管理，由Spring来完成对象的创建。Spring通过xml配置文件中的bean标签来配置创建的对象。

  • Spring注入属性
public class User {
    // 属性
    private String username;
    // 方法
    public void add(){
        System.out.println("add....");
    }
}

假设在User类中有一属性，原始的赋值方式就是创建set、get方法；但是现在既然对象都交由Spring去管理了，那么属性也同样。通过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 http://www.springframework.org/schema/beans/spring-beans.xsd">

   <!--配置User对象创建-->
   <bean id="user" class="com.atguigu.spring5.User">
     <property name="username" value="zyx"></property>
   </bean>
</beans>

返回顶部

② Bean管理的操作方式

  • 基于xml文件方式
  • 基于注解方式

返回顶部

二、Bean管理的操作方式之基于xml方式

♦ 基于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">

   <!--配置User对象创建-->
   <bean id="user" class="com.atguigu.spring5.User"></bean>
</beans>

（1）在 spring 配置文件中，使用 bean 标签，标签里面添加对应属性，就可以实现对象创建。

（2）在 bean 标签有很多属性，介绍常用的属性：

  • id 属性：唯一标识,给创建的对象创建的别名
  • class 属性：类全路径（包类路径）
  • name 属性：作用于id属性相同，区别在于name属性中可以添加特殊符号，而id属性不可以。

（3）创建对象时候，默认也是执行无参数构造方法完成对象创建。

  • 当我们创建有参构造的时候，系统不会生成无参构造方法。此时再次运行程序就会报错：No default constructor found; nested exception is java.lang.NoSuchMethodException: com.atguigu.spring5.User.<init>()，就是找不到无参构造方法。
    在这里插入图片描述
    返回顶部

♦ 基于xml方式注入属性

DI：依赖注入，就是注入属性，是IOC的一种具体表现，在创建对象的基础之上完成。

第一种注入方式：使用 set 方法 进行注入

（1）创建类，定义属性和对应的 set 方法

/**
* 演示使用 set 方法进行注入属性
*/
public class Book {
	 //创建属性
	 private String bname;
	 private String bauthor;
	 //创建属性对应的 set 方法
	 public void setBname(String bname) {
	      this.bname = bname;
	 }
	 public void setBauthor(String bauthor) {
	      this.bauthor = bauthor;
	 }
}

（2）在 spring 配置文件中通过bean标签配置对象创建，通过property标签的name、value参数配置属性注入

<!--2 set 方法注入属性-->
<bean id="book" class="com.atguigu.spring5.Book">
 <!--使用 property 完成属性注入
    name：类里面属性名称
    value：向属性注入的值
 -->
  <property name="bname" value="易筋经"></property>
  <property name="bauthor" value="达摩老祖"></property>
</bean>

第二种注入方式：使用 有参数构造 进行注入

（1）创建类，定义属性，创建属性对应有参数构造方法

/**
* 使用有参数构造注入
*/
public class Orders {
	 //属性
	 private String oname;
	 private String address;
	 //有参数构造
	 public Orders(String oname,String address) {
	     this.oname = oname;
	     this.address = address;
	 }
}

（2）在 spring 配置文件中进行配置

  • 通过bean对象标签下的constructor-arg标签的name、value参数配置
  • 通过bean对象标签下的constructor-arg标签的index、value参数配置
    • 其中index代表的是含参构造器的参数索引
<!--3 有参数构造注入属性-->
<bean id="orders" class="com.atguigu.spring5.Orders">
  <!--通过name属性匹配参数-->
  <constructor-arg name="oname" value="电脑"></constructor-arg>
  <constructor-arg name="address" value="China"></constructor-arg>
  <!--也可以通过索引index属性匹配参数-->
  <constructor-arg index="0" value="电脑"></constructor-arg>
  <constructor-arg index="1" value="China"></constructor-arg>
</bean>

第三种注入方式：使用 p名称空间 进行注入 — 简化set()注入

（1）使用 p 名称空间注入，可以简化基于 xml 配置方式

  • 第一步 在配置文件中添加 p 名称空间
  • xmlns:p="http://www.springframework.org/schema/p"
<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 名称空间
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
</beans>
  • 进行属性注入，在 bean 标签里面进行操作
<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 名称空间
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
   <!-- 注入属性值 -->    
   <bean id='orders' class="com.atguigu.spring5.Orders" p:oname="电脑" p:address="China"></bean>
</beans>

返回顶部

♦ xml注入其他类型属性

字面量 ---- 注入空值 < null >< /null >标签

<?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">
    <!--配置User对象创建-->
    <bean name="book" class="com.atguigu.spring5.Book">
        <property name="bookName" value="悲剧人偶"></property>
        <!--  对address属性注入空值   -->
        <property name="address">
            <null></null>
        </property>
        <property name="price" value="49.5"></property>
    </bean>
</beans>

在这里插入图片描述
返回顶部

字面量 ---- 注入特殊字符

  1. 把<、>进行转义 &lt；、&gt；
  2. 把带特殊符号内容写到 <![CDATA[...]]>中
<?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">
    <!--配置User对象创建-->
    <bean name="book" class="com.atguigu.spring5.Book">
        <!--  对address属性注入特殊符号   -->
        <property name="bookName">
            <value><![CDATA[<<悲剧人偶>>]]></value>
        </property>
        <!--  对address属性注入空值   -->
        <property name="address">
            <null></null>
        </property>
        <property name="price" value="49.5"></property>
    </bean>
</beans>

在这里插入图片描述
返回顶部

注入属性 - 外部 bean

（1）创建两个类 service 类和 dao 类

public class service {
    public void show(){
        System.out.println("Service show ..............");
    }
}

// Dao接口
public interface Dao {
    public void update();
}
// 实现类
public class DaoImpletes implements Dao {
    @Override
    public void update() {
        System.out.println("Dao update ..............");
    }
}

（2）在 service 调用 dao 里面的update()方法

  • 原始方式：
public class service {
    public void show(){
        // 创建Dao对象
        DaoImpletes dao = new DaoImpletes();
        // 调用方法
        dao.update();
        System.out.println("Service show ..............");
    }
}
  • 使用xml注入形式注入外部bean：
    • 利用bean标签配置创建不同的对象，在含有对象属性的bean中利用property标签的ref参数调取另外对象的id，以达到注入对象属性的效果。
public class service {
    // 对象属性
    private Dao dao;
    // set()
    public void setDao(Dao dao) {
        this.dao = dao;
    }
    // show()
    public void show(){
        System.out.println("Service show ..............");
    }
}

<?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">
    <!-- 创建service、dao对象 -->
    <bean id="service" class="com.atguigu.spring5.Service.service">
        <!-- 注入到对象
            name属性：类里面的属性名称
            ref属性 ：创建dao对象bean标签的id值
         -->
        <property name="dao" ref="DaoImpletes"></property>
    </bean>
    <bean id="DaoImpletes" class="com.atguigu.spring5.Dao.DaoImpletes"></bean>
</beans>

在这里插入图片描述

返回顶部

注入属性 - 内部 bean

（1）一对多关系：部门和员工（部门是一，员工是多）

  • 一个部门有多个员工，一个员工属于一个部门

（2）在实体类之间表示一对多关系，员工表示所属部门 - 使用对象类型属性进行表示

public class Dept {
    // 部门名称
    private String deptName;
    // set
    public void setDeptName(String deptName) {
        this.deptName = deptName;
    }   
    // 重写toString()
    @Override
    public String toString() {
        return "Dept{" +
                "deptName='" + deptName + '\'' +
                '}';
    }
}

public class Employee {
    // 员工姓名、性别
    private String eName;
    private String gender;
    // 员工所属部门，用对象形式表现
    private Dept dept;
    // set
    public void seteName(String eName) {
        this.eName = eName;
    }
    public void setGender(String gender) {
        this.gender = gender;
    }
    public void setDept(Dept dept) {
        this.dept = dept;
    }
}

（3）在 spring 配置文件中进行配置

  • 主要就是在一个bean标签中，通过property标签完成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 http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--配置Employee对象-->
    <bean id="emp" class="com.atguigu.spring5.Employ.Employee">
        <!--  配置姓名、性别属性   -->
        <property name="eName" value="Tom"></property>
        <property name="gender" value="男"></property>
        <!--  配置部门对象属性 —— 注入内部bean  -->
        <property name="dept">
            <bean id="dept" class="com.atguigu.spring5.Employ.Dept">
                <property name="deptName" value="安保部门"></property>
            </bean>
        </property>
    </bean>
</beans>

@org.junit.Test
public void test_EMP(){
    try {
        //
        ApplicationContext context = new ClassPathXmlApplicationContext("com/atguigu/spring5/Employ/bean_Emp.xml");
        Employee employee = context.getBean("employee",Employee.class);
        System.out.println(employee);
        employee.show();
    } catch (Exception e){
        e.printStackTrace();
    }
}

com.atguigu.spring5.Employ.Employee@5891e32e
Tom::男::Dept{deptName='安保部门'}

返回顶部

注入属性 - 级联赋值（注入对象属性的同时对其属性赋值）

以下两种方式仅是针对赋值的形式：

方式一：通过注入外部bean的形式

  • 主要就是通过注入外部Bean的形式，达到注入对象同时注入其属性值。
  • 拿以下的代码来看，就是在Employee对象中注入Dept对象属性，并通过该对象属性对Dept类下的deptName属性进行赋值。
<?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">

    <!--配置Employee对象-->
    <bean id="employee" class="com.atguigu.spring5.Employ.Employee">
        <!--  配置姓名、性别属性   -->
        <property name="eName" value="Tom"></property>
        <property name="gender" value="男"></property>
        <!--  级联赋值 -->
        <property name="dept" ref="dept"></property>
    </bean>
    <bean id="dept" class="com.atguigu.spring5.Employ.Dept">
        <property name="deptName" value="财务部"></property>
    </bean>
</beans>

运行结果：

com.atguigu.spring5.Employ.Employee@7a30d1e6
Tom::男::Dept{deptName='财务部'}

方式二：通过get(),实现类引用.属性的形式赋值

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

    <!--配置Employee对象-->
    <bean id="employee" class="com.atguigu.spring5.Employ.Employee">
        <!--  配置姓名、性别属性   -->
        <property name="eName" value="Tom"></property>
        <property name="gender" value="男"></property>
        <!--  级联赋值 -->
        <property name="dept" ref="dept"></property>
        <property name="dept.deptName" value="技术部"></property>  必须在上一行的基础上进行
    </bean>
    <bean id="dept" class="com.atguigu.spring5.Employ.Dept">
        <property name="deptName" value="财务部"></property>
    </bean>
</beans>
  • 使用第二种方式要注意：
    • 需要在对象属性所在类中添加对象属性的get()方法。
    • 必须在引入外部bean后接着写属性赋值，顺序不能乱。必须得现有类引用才能去调用属性赋值。
    • < property name="dept" ref="dept"></ property >
      < property name="dept.deptName" value="技术部"></ property> 必须在上一行的基础上进行,一旦写了第二行，不管value有没有值，都会覆盖掉外部bean的value值("财务部")

运行结果：

com.atguigu.spring5.Employ.Employee@cb0ed20
Tom::男::Dept{deptName='技术部'}

返回顶部

注入属性 - 数组、list、set、map属性

（1）创建类，定义数组、list、map、set 类型属性，生成对应 set 方法

package com.atguigu.spring5.collection;

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.set集合类型属性
    private Set<String> set;
    // 4.map集合类型属性
    private Map<String,String> map;

    // set
    public void setCourses(String[] courses) {
        this.courses = courses;
    }
    public void setList(List<String> list) {
        this.list = list;
    }
    public void setSet(Set<String> set) {
        this.set = set;
    }
    public void setMap(Map<String, String> map) {
        this.map = map;
    }
}

（2）在 spring 配置文件进行配置

  • 数组：array、list 标签 + value标签
  • Lsit集合：list 标签+ value标签
  • Set集合：set 标签+ value标签
  • Map集合：map 标签+ entry标签
<?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.atguigu.spring5.collection.Stu">
        <!--  1.数组类型属性注入  -->
        <property name="courses">
            <array>
                <value>java</value>
                <value>mysql</value>
            </array>
        </property>
        <!--  2.list集合类型属性注入  -->
        <property name="list">
            <list>
                <value>张三</value>
                <value>李四</value>
            </list>
        </property>
        <!--  3.set集合类型属性注入  -->
        <property name="set">
            <set>
                <value>China</value>
                <value>England</value>
            </set>
        </property>
        <!--  4.map集合类型属性注入  -->
        <property name="map">
            <map>
                <entry key="JAVA" value="java"></entry>
                <entry key="PHP" value="php"></entry>
            </map>
        </property>
    </bean>
</beans>

public class Test {
    @org.junit.Test
    public void test_Stu(){
        try {
            ApplicationContext context = new ClassPathXmlApplicationContext("com/atguigu/spring5/collection/bean_Stu.xml");
            Stu stu = context.getBean("stu",Stu.class);
            stu.test();
        } catch (Exception e){
            e.printStackTrace();
        }
    }
}

[java, mysql]
[张三, 李四]
[China, England]
{JAVA=java, PHP=php}

返回顶部

注入属性 - 集合中注入对象属性值

（1）创建Course类、Stu类，Stu类中list集合类型属性，存储Course对象，生成对应 set 方法

// 课程类
public class Course {
    // 课程名称
    private String cname;
    // set
    public void setCname(String cname) {
        this.cname = cname;
    }
}

public class Stu {
    // 5.list集合中注入Course对象
    private List<Course> courseList;
    // set
    public void setCourseList(List<Course> courseList) {
        this.courseList = courseList;
    }
    //test
    public void test(){
        System.out.println(courseList);
    }
}

（2）在 spring 配置文件进行配置

  • 首先bean标签配置创建对象属性，然后在集合中添加ref标签引入对象
<?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.atguigu.spring5.collection.Stu">
        <!-- 注入list集合类型，值是对象 -->
        <property name="courseList">
            <list>
                <!-- 向list中注入Course对象(引用) -->
                <ref bean="course1"></ref>
                <ref bean="course2"></ref>
            </list>
        </property>
    </bean>
    <!--  创建多个course对象  -->
    <bean id="course1" class="com.atguigu.spring5.collection.Course">
        <property name="cname" value="Spring5"></property>
    </bean>
    <bean id="course2" class="com.atguigu.spring5.collection.Course">
        <property name="cname" value="Spring5-Bean"></property>
    </bean>
</beans>

public class Test {
    @org.junit.Test
    public void test_Stu(){
        try {
            ApplicationContext context = new ClassPathXmlApplicationContext("com/atguigu/spring5/collection/bean_Stu.xml");
            Stu stu = context.getBean("stu",Stu.class);
            stu.test();
        } catch (Exception e){
            e.printStackTrace();
        }
    }
}

[com.atguigu.spring5.collection.Course@4c762604, com.atguigu.spring5.collection.Course@2641e737]

返回顶部

注入属性 - 集合属性提取到外部(共用)

（1）在 spring 配置文件中引入名称空间 util

  • xmlns:util="http://www.springframework.org/schema/util" 配置util
  • http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd
<?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:util="http://www.springframework.org/schema/util"  配置util
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd"> 配置util

</beans>

（2）创建Book类，定义list集合属性

public class Book {
    // list集合属性
    private List<String> list;
    // set
    public void setList(List<String> list) {
        this.list = list;
    }
    // 重写toString()
    @Override
    public String toString() {
        return "Book{" +
                "list=" + list +
                '}';
    }
    // show()
    public void show(){
        System.out.println(list);
    }
}

（3）使用 util 标签完成 共有 list 集合注入提取

  • 通过ref参数引入所需集合的id即可实现
<?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:util="http://www.springframework.org/schema/util"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd">

    <!-- 提取list集合类型属性注入 -->
    <util:list id="booklist">
        <value><![CDATA[<<单恋>>]]></value>
        <value><![CDATA[<<大雪中的山庄>>]]></value>
        <value><![CDATA[<<重访边城>>]]></value>
    </util:list>
    <!-- 提取list集合类型属性注入使用 -->
    <bean id="book" class="com.atguigu.spring5.collection.Book">
        <property name="list" ref="booklist"></property>
    </bean>
</beans>

@org.junit.Test
public void test_Book(){
    try {
        ApplicationContext context = new ClassPathXmlApplicationContext("com/atguigu/spring5/collection/bean_Book.xml");
        Book book = context.getBean("book",Book.class);
        book.show();
    } catch (Exception e){
        e.printStackTrace();
    }
}

[<<单恋>>, <<大雪中的山庄>>, <<重访边城>>]

返回顶部

骑着蜗牛ひ追导弹'
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
IOC操作Bean管理（基于注解方式）
m0_57448314的博客
12-02 1092
注解是代码特殊标记，格式：@注解名称（属性名称=属性值，属性名称=属性值）使用注解，注解作用于类上面，方法上面，属性上面使用注解目的，简化xml配置。
spring在IoC容器中装配Bean详解
08-28
在 Spring 框架中，IoC 容器是 Bean 的容器，负责创建、管理和装配 Bean。在本文中，我们将详细介绍 Spring 在 IoC 容器中装配 Bean 的过程。 一、Spring 配置概述 Spring 配置概述分为三部分：基于 XML 的配置、...
＜Spring＞IOC容器---Bean管理XML方式-3
小李子还挺酸的博客
05-25 201
一、IOC容器—Bean管理XML方式（创建对象和set注入属性） 1、IOC操作Bean管理（概念） 1、什么是Bean管理 Bean管理指的是两个操作 （1）Spring创建对象 （2）Spring注入属性 2、Bean管理操作有两种方式 （1）基于xml配置文件方式实现 （2）基于注解方式实现 2、IOC操作Bean管理（基于xml方式） 1、基于xml方式创建对象 （1）在spring配置文件中，使用bean标签，标签里面添加对应属性，就可以实现对象创建 （2）在bean标签有两个常用属性
（2）Spring--基于XML的方式管理Bean
qq_43555873的博客
03-15 410
1.1IOC和DI 1.IOC(Inversion of Control)：反转控制 在应用程序中的组件需要获取资源时，传统的方式是组件主动的从容器中获取所需要的资源，在这样的模式下开发人员往往需要知道在具体容器中特定资源的获取方式，增加了学习成本，同时降低了开发效率。 反转控制的思想完全颠覆了应用程序组件获取资源的传统方式：反转了资源的获取方向——改由容器主动的将资源推送给需要的组件，开发人员不需要知道容器是如何创建资源对象的，只需要提供接收资源的方式即可，极大的降低了学习成本，提高了开发的效率。这
JAVA-4-[Spring框架]基于XML方式的Bean管理
qq_20466211的博客
03-22 476
Spring框架
spring IOC容器 Bean 管理——基于注解方式
学而时习
07-01 1万+
IOC 操作 Bean 管理(基于注解方式) ​ 1、什么是注解 ​ （1）注解是代码特殊标记，格式：@注解名称(属性名称=属性值, 属性名称=属性值…) ​ （2）使用注解，注解作用在类上面，方法上面，属性上面 ​ （3）使用注解目的：简化 xml 配置 ​ 2、Spring 针对 Bean 管理中创建对象提供注解 ​ 下面四个注解功能是一样的，都可以用来创建 bean 实例 ​ （1）@Component ​ （2）@Service ​ （3）@Controller ​ （4）@Repository
spring IOC容器管理必须知道这些操作——基于XML方式
热门推荐
学而时习
07-01 5万+
Spring——IOC（控制反转） 一、IOC容器 ​ 1、什么是IOC（控制反转） ​ a）把对象创建和对象之间的调用过程，交给Spring进行管理 ​ b）使用IOC目的：为了降低耦合度 ​ 2、IOC底层 ​ a）xml解析、工厂模式、反射 ​ 3、Spring提供的IOC容器实现的两种方式（两个接口） ​ a）BeanFactory接口：IOC容器基本实现是Spring内部接口的使用接口，不提供给开发人员进行使用（加载配置文件时候不会创建对象，在获取对象时才会创建对象。） ​ b）App
Spring IOC容器与 Bean 管理 第1关：使用 Spring IOC 容器获取 Bean 信息
于建章的博客
11-07 1670
Spring IOC容器与 Bean 管理 第1关：使用 Spring IOC 容器获取 Bean 信息
Spring IOC容器-Bean管理——基于XML方式（续集）
学而时习
07-01 1万+
Spring IOC容器-Bean管理——基于XML（续集） ​ 1、IOC 操作 Bean 管理（FactoryBean） ​ 1、Spring 有两种类型 bean，一种普通 bean，另外一种工厂 bean（FactoryBean） ​ 2、普通 bean：在配置文件中定义 bean 类型就是返回类型 ​ 3、工厂 bean：在配置文件定义 bean 类型可以和返回类型不一样 第一步 创建类，让这个类作为工厂 bean，实现接口 FactoryBean 第二步 实现接口里面的方法，在实现的方法
Spring IOC的bean管理--基于XML管理bean及其自动装配、基于注解管理bean及其Autowired自动装配
蒋大钊的博客
02-15 1772
Spring之基于xml的自动装配、基于Autowired注解的自动装配，由浅入深，通俗易懂
Spring框架学习笔记（二）：Spring IOC容器配置 Bean，分别基于XML配置bean 和 基于注解配置 bean
最新发布
2301_76144723的博客
05-10 918
本文主要介绍spring框架中，基于xml配置文件配置bean和基于注解配置bean
详解Spring IOC 容器启动流程分析
08-25
Spring IOC 容器是 Java 企业级应用程序的核心组件之一，它提供了一个统一的依赖注入机制，使得应用程序的组件之间能够松耦合。Spring IOC 容器的启动流程是整个 Spring 框架的核心所在，本文将从 ...
Spring实现一个简单的SpringIOC容器
08-30
Spring的IOC（Inversion of Control，控制反转）容器是其核心特性之一，它负责管理和装配应用程序中的对象。本文将深入探讨如何实现一个简单的Spring IOC容器，以及涉及的主要知识点。 首先，控制反转是一种设计...
【Spring JDBC】数据库连接基本步骤
懂得一千零一种,赋予你失败的方法！
04-02 2772
Spring JDBC 数据库连接基本步骤 1.配置依赖项 <!-- mysql jar包 --> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>8.0.17</version> // 这里我用的数据库是8.0.17版本的，一般的5.？的版本
【MyBatis】三层架构
懂得一千零一种,赋予你失败的方法！
04-16 1725
文章目录三层架构和SSM框架的对应关系一、什么是框架？二、三层架构三、持久层技术解决方案四、Jdbc编程的分析主要回顾 三层架构和SSM框架的对应关系 一、什么是框架？ ​ 框架( Framework)是整个或部分系统的可重用设计,表现为一组抽象构件及构件实例间交互的方法;另一种定义认为,框架是可被应用开发者定制的应用骨架。前者是从应用方面而后者是从目的方面给出的定义。简而言之,框架其实就是某种应用的半成品,就是一组组件,供你选用完成你自己的系统。简单说就是使用别人搭好的舞台,你来做表演。而且,框架一般是
【MyBatis】Spring整合MyBatis配置
懂得一千零一种,赋予你失败的方法！
05-21 1727
文章目录Spring整合MyBatis配置1.pom.xml依赖2.mybatis-config.xml3.dbconfig.properties4.spring-mybatis.xml Spring整合MyBatis配置 1.pom.xml依赖 添加mybatis的依赖包 <!-- mybatis框架包 start --> <dependency> <groupId>org.mybatis</groupId> <artifact.
【MyBatis】 SqlMapConfig.xml配置文件解析
懂得一千零一种,赋予你失败的方法！
05-04 1647
文章目录1.properties (属性)2. typeAliases(类型别名) SqlMapConfig.xml中基本配置的内容如下: properties(属性) settings(全局配置参数) typeAliases(类型别名) typeHandlers(类型处理器) objectFactory(对象工厂) plugins(插件) environments(环境集合属性对象) environment(环境子属性对象) transactionManager(事务管理) dataSource(数.
【MyBatis】Dao层的实现
懂得一千零一种,赋予你失败的方法！
05-04 1213
文章目录一、 查询所有1.Dao层接口2.Dao层实现类3.测试二、 插入用户1.Dao层接口2.Dao层实现类3.测试三、 刪除用户1.Dao层接口2.Dao层实现类3.测试四、 更新用户1.Dao层接口2.Dao层实现类3.测试五、 查询一个用户1.Dao层接口2.Dao层实现类3.测试六、 根据名称模糊查询1.Dao层接口2.Dao层实现类3.测试七、 聚合函数查询总数1.Dao层接口2.Dao层实现类3.测试八、流程分析 一、 查询所有 1.Dao层接口 package com.zyx.cor.
【Spring IOC容器】Bean的作用域
懂得一千零一种,赋予你失败的方法！
01-28 1177
文章目录Bean的作用域▶ Bean的作用域种类▶ 常用Bean的作用域① singleton 单实例对象② prototype 多实例对象▶ 总结★ singleton 和 prototype 区别 Bean的作用域 ▶ Bean的作用域种类 通过Spring容器创建一个Bean容器的时候，不仅可以完成Bean的实例化，还可以为Bean指定特定的作用域。 返回顶部 ▶ 常用Bean的作用域 ① singleton 单实例对象 singleton是Spring容器默认的作用域。当Bean的作用域..
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

骑着蜗牛ひ追导弹'

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

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

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

打赏作者

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

抵扣说明：

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

余额充值