Spring之对象创建（IOC）

最新推荐文章于 2022-04-26 16:07:23 发布
最新推荐文章于 2022-04-26 16:07:23 发布
阅读量227 收藏
点赞数
文章标签： java spring xml
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42923605/article/details/116950291
版权

Spring之对象创建

方式一基于XML

首先我们要知道一些基本概念
在这里插入图片描述

普通赋值法

1.导入Spring的包
在这里插入图片描述
下载地址：https://wws.lanzoui.com/iu7ndp7x8wf

2.创建Bean.xml文件并且进行配置
具体的有一些细节地方 写在了注释里面 回看的时候记得看注释

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:util="http://www.springframework.org/schema/util"
       xmlns="http://www.springframework.org/schema/beans"
       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必须要在上面添加两个东西-->
    <!--第一个  xmlns:util="http://www.springframework.org/schema/util"-->
    <!--第二个 在 xsi:schemaLocation里复制第一行 然后把beans改成util就ok-->
    <util:list id="list">
        <value>"xzh1"</value>
        <value>"xzh2"</value>
        <value>"xzh3"</value>
        <value>"xzh4"</value>
    </util:list>


    <!--scope可以设置多实例还是单实例
                prototype为多实例 即每次getBean得到的地址不一样
                singleton为单实例 即每次getBean得到一样的地址-->
    <bean id="Stu" class="com.xzh.Stu.Stu" scope="prototype">
        <!--property标签是调用set方法给他赋初值
         这个bean标签都是用这个方法-->

        <!--普通属性注入（赋初值）方法-->
        <property name="name">
            <value >"张三"</value>
        </property>


        <!--数组注入 必须要有array标签  还有就是方法中要有set方法-->
        <property name="courses">
            <array>
                <value>"xzh1"</value>
                <value>"xzh2"</value>
                <value>"xzh3"</value>
                <value>"xzh4"</value>
            </array>
        </property>


        <!--list注入 必须要有list标签  还有就是方法中要有set方法-->
        <!--这里的ref是引入了  util:list这个标签的值 list为他的id
        就不用再像之前那样输入值了 提高了重复调用行-->
        <property name="list" ref="list"></property>
        <!--map注入 必须要有map标签  还有就是方法中要有set方法-->
        <property name="map">
            <map>
                <entry key="xzh1" value="XZH1"></entry>
                <entry key="xzh2" value="XZH2"></entry>
                <entry key="xzh3" value="XZH3"></entry>
                <entry key="xzh4" value="XZH4"></entry>
            </map>
        </property>


        <!--set注入 必须要有set标签  还有就是方法中要有set方法-->
        <property name="set">
            <set>
                <value>"xzh1"</value>
                <value>"xzh2"</value>
                <value>"xzh3"</value>
                <value>"xzh4"</value>
            </set>
        </property>


        <!--list 对象 注入 必须要有list标签  还有就是方法中要有set方法-->
        <!--首先要创建一个这个对应对象（Person）的bean标签 然后通过ref引用-->
        <property name="listPerson">
            <list>
                <ref bean="Person1"/>
                <ref bean="Person2"/>
            </list>
        </property>
    </bean>


    <!--person类的bean-->
    <bean name="Person1" class="com.xzh.Stu.Person" >
        <!--constructor-arg是调用构造器方法-->
        <!--这个bean都是用的这个方法-->
        <constructor-arg name="age" value="18"></constructor-arg>
        <constructor-arg name="name" value="Person18"></constructor-arg>
    </bean>
    <bean name="Person2" class="com.xzh.Stu.Person">
        <constructor-arg name="age" value="19"></constructor-arg>
        <constructor-arg name="name" value="Person19"></constructor-arg>
    </bean>
</beans>

Test1.java测试文件 （实例化对象的文件）

package com.xzh.Stu;
import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @Author XuZhuHong
 * @CreateTime 2021/5/17 19:05
 */
public class TestStru {
    @Test
    public void test1(){
        //从配置文件中得到信息 后面的那个"beanStu.xml" 是配置文件的文件名
        ClassPathXmlApplicationContext applicationContext =
                new ClassPathXmlApplicationContext("beanStu.xml");
        //用得到的信息 创建对象  "Stu"是bean标签中对应的name  Stu.Class是要创建的对象类型
        Stu stu1 = applicationContext.getBean("Stu", Stu.class);
        System.out.println(stu1);
    }
}

对应的Stu类：

package com.xzh.Stu;

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

/**
 * @Author XuZhuHong
 * @CreateTime 2021/5/17 18:58
 */
public class Stu {
    private String name;
    private String[] courses;
    private List<String> list;
    private Map<String, String> map;
    private Set<String> set;
    private List<Person> listPerson;

    public Stu() {
    }

    public Stu(String name, String[] courses, List< String > list, Map< String, String > map, Set< String > set, List< Person > listPerson) {
        this.name = name;
        this.courses = courses;
        this.list = list;
        this.map = map;
        this.set = set;
        this.listPerson = listPerson;
    }

    public String getName() {
        return name;
    }

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

    public String[] getCourses() {
        return courses;
    }

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

    public List< String > getList() {
        return list;
    }

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

    public Map< String, String > getMap() {
        return map;
    }

    public void setMap(Map< String, String > map) {
        this.map = map;
    }

    public Set< String > getSet() {
        return set;
    }

    public void setSet(Set< String > set) {
        this.set = set;
    }

    public List< Person > getListPerson() {
        return listPerson;
    }

    public void setListPerson(List< Person > listPerson) {
        this.listPerson = listPerson;
    }


    @Override
    public String toString() {
        return "Stu{" +
                "name='" + name + '\'' +
                ", courses=" + Arrays.toString(courses) +
                ", list=" + list +
                ", map=" + map +
                ", set=" + set +
                ", listPerson=" + listPerson +
                '}';
    }
}

对应用到的person类

package com.xzh.Stu;

/**
 * @Author XuZhuHong
 * @CreateTime 2021/5/17 19:24
 */
public class Person {
    private String name;
    private Integer age;

    public Person() {
    }

    public Person(String name, Integer age) {
        this.name = name;
        this.age = age;
    }



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

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

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

引入外部文件值赋值法

引入外部文件值的方法：

<?xml version="1.0" encoding="UTF-8"?>
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       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
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

    <!--用注解创建对象 需要开启对象扫描-->
    <!--先引入context标签-->
    <!--使用context:component-scan 标签
    ase-package是选择需要开启扫的包的路径 里面的文件代表 它和它的子包都会被扫描到-->
<context:component-scan base-package="com.xzh"/>


    <!--示例 1
 use-default-filters="false" 表示现在不使用默认 filter，自己配置 filter
 context:include-filter ，设置扫描哪些内容（这里是设置的Controller这个注解开启扫描）
-->
    <context:component-scan base-package="com.xzh" use-default-filters="false">
        <context:include-filter type="annotation"
                                expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>

    <!--示例 2
     下面配置扫描包所有内容
     context:exclude-filter： 设置哪些内容不进行扫描（这里是设置的Controller这个注解不扫描）
    -->
    <context:component-scan base-package="com.xzh">
        <context:exclude-filter type="annotation"
                                expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>

</beans>

对应的jdbc.properties文件

jdbc.url=jdbc:mysql://localhost:3306/book
jdbc.username=root
jdbc.password=000000

怎么在xml中加载properties?

首先导入context空间

xmlns:context=http://www.springframework.org/schema/context

然后用这种方式来加载

<!--加载外部文件-->
<context:property-placeholder location="classpath:jdbc.properties"/>

如何使用：里面的东西 ${jdbc.username} jdbc.username对应的是key

详细代码:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       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
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
    <!--加载外部文件-->
    <context:property-placeholder location="classpath:jdbc.properties"/>

    <bean class="com.alibaba.druid.pool.DruidDataSource" id="dataSource">
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="driverClassName" value="${jdbc.driver}"/>
    </bean>
</beans>

方式二 基于注解的方法

首先知道每个注解有什么用：
在这里插入图片描述
在这里插入图片描述

具体的细节我写在了注释里面

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       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
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

    <!--用注解创建对象 需要开启对象扫描-->
    <!--先引入context标签-->
    <!--使用context:component-scan 标签
    ase-package是选择需要开启扫的包的路径 里面的文件代表 它和它的子包都会被扫描到-->
<context:component-scan base-package="com.xzh"/>



    <!--示例 1
 use-default-filters="false" 表示现在不使用默认 filter，自己配置 filter
 context:include-filter ，设置扫描哪些内容（这里是设置的Controller这个注解开启扫描）
-->
    <context:component-scan base-package="com.xxx" use-default-filters="false">
        <context:include-filter type="annotation"
                                expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>

    <!--示例 2
     下面配置扫描包所有内容
     context:exclude-filter： 设置哪些内容不进行扫描（这里是设置的Controller这个注解不扫描）
    -->
    <context:component-scan base-package="com.xxx">
        <context:exclude-filter type="annotation"
                                expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>

</beans>

UserService类：

package com.xzh.Spring5.Annotation;

/**
 * @Author XuZhuHong
 * @CreateTime 2021/5/18 15:19
 */

import com.xzh.Spring5.dao.UserDao;
import com.xzh.Spring5.dao.UserDaoImpl;
import org.springframework.beans.factory.annotation.*;
import org.springframework.stereotype.Service;
/**
 * //**********************创建对象的注解***************
 * @Component 控制器(注入服务), 用于标注控制层组件(如struts中的action)
 * @Service 服务(注入dao), 用于标注业务层组件
 * @Repository dao(实现dao访问), 用于标注数据访问组件，即DAO组件
 * @Controller 把普通pojo实例化到spring容器中
 * 上面这4个都可以实现对象创建  但是建议在哪一层就用哪一个
 */

//这个value值就等于我们用bean标签的id标签
//可以省略value 那么默认值就是 类名第一个字母小写
@Service(value = "userService")
public class UserService {
    String name;
    @Value(value = "18")
    Integer age;
    /**
     * //**********************注入值的注解***************
     * 基于注解方式的注入方法
     * @AutoWireds  根据属性类型进行自动注入 可以单独使用
     * @Qualifiers  根据属性名称进行注入  必须和上面一起使用
     * @Resource    根据类型或属性注入 后期新版java好像已经没有了
     * @Value       普通注入
     */

    @Autowired//使用注解注入  根据属性类别自动注入
    @Qualifier(value = "userDaoImpl") //value必须要有  值就是在对象创建时注解里的value  即bean标签中的id
    UserDaoImpl userDaoImpl;

    @Autowired
    UserDao userDao;

    public void show() {
        System.out.println("UserService   我是用户************");
        userDaoImpl.show();
        userDao.show();
    }

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

UserDao接口类

package com.xzh.Spring5.dao;

/**
 * @Author XuZhuHong
 * @CreateTime 2021/5/18 15:48
 */
public interface UserDao {
    void  show();
}

UserDaoImpl接口实现类

package com.xzh.Spring5.dao;

import org.springframework.stereotype.Repository;

/**
 * @Author XuZhuHong
 * @CreateTime 2021/5/18 15:48
 */
@Repository
public class UserDaoImpl implements UserDao {
    @Override
    public void show() {
        System.out.println("UserDaoImpl    *************");
    }
}

测试类

import com.xzh.Spring5.Annotation.UserService;
import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @Author XuZhuHong
 * @CreateTime 2021/5/18 15:24
 */
public class TestSpring {
    @Test
    public void test1() {
        //实例化方法还是和之前的一样
        ClassPathXmlApplicationContext classPathXmlApplicationContext =
                new ClassPathXmlApplicationContext("Annotation.xml");
        UserService userService = classPathXmlApplicationContext.getBean("userService", UserService.class);

        System.out.println(userService);
        userService.show();
    }
}
快落靓仔
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
创建Maven项目和Spring IOC实例过程解析
08-25
创建Maven项目和Spring IOC实例过程解析 一、Maven项目创建过程 Maven是一个基于项目对象模型（Project Object Model，POM）的项目管理工具，主要用于管理和构建Java项目。创建Maven项目需要使用IDEA开发工具，并...
Spring之IOC详解
08-31
Spring之IOC详解 IOC（Inversion of Control，控制反转）是一种重要的面向对象编程法则，用于削减计算机程序的耦合问题。它是轻量级的Spring框架的核心。控制反转一般分为两种类型，依赖注入（Dependency Injection...
【spring系列】spring对象的创建
王华春_Jason
10-24 456
一、HelloSpring 1、创建基础项目、导入项目依赖 <dependencies> <!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc --> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-we
《Spring》------对象的创建机制剖析
zhoukun@Fly
11-13 1815
前言 利用Spring框架，我们很方便的将对象管理起来，比如说：“从对象的创建（Ioc），到对象的使用（DI）”。那么在对象是以何种方式创建的，以及其创建的时间，还有创建对象是单例的还是多例是怎么控制的哪？让小编结合在项目中的经验，好好的剖析一下。 1、对象的创建方式1.1、利用构造函数创建对象配置文件<bean id="helloWorld" class="com.spring.createobj
源码分析：Spring是如何把Bean注册到IOC容器中的？
热门推荐
果子爸聊技术
09-23 2万+
Spring注册过程分析，建议收藏
Spring对象创建的三种方式
weixin_41384583的博客
09-17 313
spring创建对象的三种方式详解 2018年01月18日 17:29:37 nwpu_geeker 阅读数：3597 标签： springioc创建对象对象 更多 个人分类： spring笔记 版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/nwpu_geeker/article/details/79098797 前言 我们知道spri...
2.IOC创建对象方式
qq_43626215的博客
02-16 135
IOC创建对象方式 1.通过无参构造方法来创建 1）User.java public class User { private String name; public User() { System.out.println("user无参构造方法"); } public void setName(String name) { this.name = name; } public void show(){ System.out.prin
Spring中IoC优点与缺点解析
08-28
IoC(Inversion of Control)是 Spring 框架中的一种设计模式，它的主要思想是将对象的创建和管理交给容器，从而解耦合对象之间的依赖关系。今天，我们将详细解析 IoC 的优点和缺点。 优点 1. 简化对象的创建：IoC ...
spring核心IOC以及DI
01-21
2. **依赖注入（DI）**：DI是IOC的具体实现方式之一，它允许开发者声明组件之间的依赖关系，而不是直接在代码中创建或查找依赖对象。Spring容器会根据这些声明，在运行时自动将依赖对象注入到需要它们的组件中。这...
SpringIOC DI循环依赖实例详解
08-24
在创建 Bean 对象时，SpringIOC 会使用 lambda 表达式来调用 createBean() 方法，将 Bean 对象创建并注入依赖项。在创建完成后，SpringIOC 会将 Bean 对象添加到 singletonObjects 容器中，并将 Bean 名称添加到 ...
浅谈Spring框架，自动注入对象IoC/DI的过程（一）
明天的你会感谢今天的自己
11-07 391
写在前面的话：学java已经好一段时间了，从大三开始，但现在毕业后在500强国企的子公司上班，一心觉得自己还是很喜欢专研技术的，什么东西都想学，各种资料收集了一大堆，但真正去看的却没几个。由于公司开发的项目都是给自己公司的业务员用的，我现在手上的EC项目真的是从jdbctemplate，到hibernate，再到mybatis，还有我没有听说过的很老的ORM框架都有了，导致项目混乱，领导也不敢推翻...
Spring-IoC注入过程
Ellen_Tangxiang的博客
06-03 808
本文基于spring5.1.6 大体流程 使用ResourceLoader加载资源 创建Bean工厂 获得BeanDefinition 装载资源 资源定位、装载、注册 装载。装载就是 BeanDefinition 的载入 //加载资源 ClassPathResource resource = new ClassPathResource("bean.xml"); //创建bean工厂 Defau...
spring创建对象的过程（生命周期）
波波的博客
04-26 3839
在还没使用spring框架的时候，我们创建对象的时候方式 1.类的反射 2.new 3.instance 代码比较重复而且一些必须创建的对象，比如说业务层都需要创建，dao层也需要创建，这样导致我们重复操作了这些事情 但是spring容器可以帮我们处理这些繁琐的事情，而且还能加强(具体如何加强后面说到) spring得益于它的IOC和AOP，大大减少我们的琐碎事情 下面就来聊聊spring如何帮我们创建对象的！！ spring创建对象流程 1.启动application，扫描该app下的所
Spring系列（二）Spring是如何通过IOC来创建对象的？
大鱼的博客
04-08 625
扩展：Spring系列学习汇总 文章目录一、IOC如何获取对象1.1 Spring是如何获取对象的？1.2 改造案例由xml选择创建对象二、IOC是通过什么方式来创建对象的？2.1 通过无参构造函数来创建对象2.2 通过有参构造方法来创建对象三、Spring的配置3.1 alias（别名）：3.2 Bean的配置：3.3 import（团队合作之导入） 一、IOC如何获取对象 1.1 Spring是如何获取对象的？ ①新建一个maven项目后导入webmvc的依赖：因为webmvc包含了很多其他依赖，为.
Spring将类注入到IOC容器（方法及注意）
qq_52971866的博客
12-18 2071
1.使用@Bean 注解，用于注入第三方 jar 包到SpringIOC容器中。 2.使用@Import({Order.class, Member.class, MyImportBeanDefinitionRegistrar.class}) 注解，可以注入多个类，多个类之间使用 , 分割，主要用于注入第三方的 jar 包到SpirngIOC容器中。 3.在类文件的开头写上以下中一个（具体哪一个自己看情况选择） （1）、@Component(“id”) ：通用的 （2）、@Repository(“id.
Spring创建对象的几种方式
排长性感的小屁屁
08-09 2197
1.Spring中创建对象的方式 1.1使用无参构造创建对象（默认） spring中默认使用无参构造函数， package com.wshy.pojo; /** * @title: Hello * @Author: wshy */ public class Hello { private String str; public Hello(){ System.out.println ("spring无参构造函数！"); } public String
Spring中的三种创建对象的方法
x瓜皮的博客
09-18 1766
我们都知道Spring主要特点就是将不再使用传统的创建对象，而是将创建对象的步骤都放入xml配置文件当中。那么我们总结一下通过xml配置实例的三种方法：普通构造方法创建（无参数构造方法）、静态工厂方法创建、实例工厂方法创建 普通构造方法创建（无参数构造方法） 这种方法是利用一个类中的无参构造方法创建的，例如我们有Hello这个类： public class Hello { private String name; public Hello(){ //该方法为无参构造方法，如果
spring创建对象的三种方式详解
nwpu_geeker的博客
01-18 1万+
前言我们知道spring框架的核心就是IOC容器了，那么IOC容器主要的作用就是创建对象和处理对象之间的依赖关系。本文主要讲解IOC容器创建对象的三种方式。创建对象的三种方式1） 调用无参数构造器 2） 带参数构造器 3） 工厂创建对象 包括：3.1 工厂类，静态方法创建对象 3.2 工厂类，非静态方法创建对象1.调用无参数的构造器具体如下
Spring注解的方式来创建对象
浪漫韫秋
07-11 4031
Spring的bean管理(注解) 1. 什么是注解 代码里面的一些特殊的标记。我们使用注解也可以直接来完成一些相关的功能。 注解的写法是@注解名称(属性名称=属性值) 注解可以用在类、方法、属性。 2. Spring注解开发的基本的准备工作 注解可以替代配置文件，但是不能完全脱离配置文件，只是能够减少配置。 导入jar包，就是导入spring最基本的几个jar包。 导入a...
对Spring创建对象的理解
最新发布
05-16
Spring的对象创建过程分为两个阶段： 1. 实例化对象：首先根据配置文件或注解，创建对象的实例，也就是调用构造方法或工厂方法来创建对象。 2. 初始化对象：当对象被创建出来之后，IoC容器会自动调用一些特定的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值