Spring学习笔记---Bean的管理

最新推荐文章于 2024-08-22 16:43:35 发布
最新推荐文章于 2024-08-22 16:43:35 发布
阅读量303 收藏
点赞数
分类专栏： Spring 文章标签： Spring Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_21420941/article/details/93747510
版权

目录

 

一、Spring的Bean的实例化方式（了解）

1.无参构造方法的方式（默认）

2.静态工厂实例化的方式

 3.实例工厂实例化的方式

二、Spring的属性注入

1.构造方法的方式的属性注入

2.set方法的属性注入

3.P名称空间的属性注入

4.SpEL的属性注入

5.复杂属性的注入

一、Spring的Bean的实例化方式（了解）

Bean已经都交给Spring管理，Spring创建这些类的时候，有几种方式：

1.无参构造方法的方式（默认）

编写类：

package com.rosinante.spring.demo3;

public class Bean1 {
	public Bean1(){
		System.out.println("Bean1的无参数的构造方法执行了...");
	}
}

编写配置：

<!-- 无参数构造方法 -->
<bean id="bean1" class="com.rosinante.spring.demo3.Bean1"></bean>

编写测试类：

public class SpringDemo3 {
	@Test
	public void demo3(){
		ClassPathXmlApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
		Bean1 bean1 = (Bean1) applicationContext.getBean("bean1");
		applicationContext.close();
	}
}

运行结果如下：

2.静态工厂实例化的方式

编写Bean2的静态工厂：

package com.rosinante.spring.demo3;

public class Bean2Factory {
	public static Bean2 createBean2(){
		System.out.println("Bean2Factory方法执行了...");
		return new Bean2();
	}
}

编写配置：

<!-- 静态工厂实例化 -->
<bean id="bean2" class="com.rosinante.spring.demo3.Bean2Factory" factory-method="createBean2"></bean>

 编写测试类：

public void bean2Factory(){
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
		Bean2 bean2 = (Bean2)applicationContext.getBean("bean2");
		System.out.println(bean2);
}

运行结果如下：

 3.实例工厂实例化的方式

Bean3的实例工厂：

package com.rosinante.spring.demo3;

public class Bean3Factory {
	public Bean3 createBean3(){
		System.out.println("Bean3的实例工厂执行了...");
		return new Bean3();
	}
}

配置：

<!-- 实例工厂实例化 -->
<bean id="bean3Factory" class="com.rosinante.spring.demo3.Bean3Factory"></bean>
<bean id="bean3" factory-bean="bean3Factory" factory-method="createBean3"></bean>

编写测试类：

public void demo3(){
	ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
	Bean3 bean3 = (Bean3)applicationContext.getBean("bean3");
	System.out.println(bean3);
}

运行结果如下：

二、Spring的属性注入

给Bean中的属性设置值：

  • 构造方法方式
public class User{
    private String name;
    private String password;

    public User(String name,String password){
        this.name = name;
        this.password = password;
    }
}
  • set方法方式
public class User{
    private String name;
    
    public void setName(String name){
        this.name=name;
    }
}
  • 接口注入的方式（Spring不支持）
public interface Injection{
    public void setName(String name);
}

public class User implements Injection{
    private String name;
    
    public void setName(String anme){
        this.name=name;
    }
}

1.构造方法的方式的属性注入

编写一个pojo类car：

package com.rosinante.spring.demo4;

public class Car {
	private String name;
	private Double price;
	
	public Car(String name, Double price) {
		super();
		this.name = name;
		this.price = price;
	}

	@Override
	public String toString() {
		return "Car [name=" + name + ", price=" + price + "]";
	}
}

编写配置：

<!-- 构造方法的方式 -->
<bean id="car" class="com.rosinante.spring.demo4.Car">
	<constructor-arg name="name" value="宝马"></constructor-arg>
	<constructor-arg name="price" value="8000000"></constructor-arg>
</bean>

编写测试类：

public void demo1(){
	ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
	Car car= (Car)applicationContext.getBean("car");
	System.out.println(car);
}

运行结果如下：

 2.set方法的属性注入

  • set方法的属性注入

编写一个类car2：

package com.rosinante.spring.demo4;
/**
 * set方法的属性注入
 * @author Administrator
 *
 */
public class Car2 {
	private String name;
	private Double price;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Double getPrice() {
		return price;
	}
	public void setPrice(Double price) {
		this.price = price;
	}
	@Override
	public String toString() {
		return "Car2 [name=" + name + ", price=" + price + "]";
	}
	
}

编写配置文件：

<!-- set方法的方式 -->
<bean id="car2" class="com.rosinante.spring.demo4.Car2">
	<property name="name" value="奔驰"></property>
	<property name="price" value="1000000"></property>
</bean>

编写测试类：

@Test
public void demo2(){
	ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
	Car2 car2= (Car2)applicationContext.getBean("car2");
	System.out.println(car2);
}

运行结果如下：

  •  set方法设置对象类型的属性

创建一个employee类：

package com.rosinante.spring.demo4;

public class Employee {
	private String name;
	private Car2 car2;     //对象类型
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Car2 getCar2() {
		return car2;
	}
	public void setCar2(Car2 car2) {
		this.car2 = car2;
	}
	@Override
	public String toString() {
		return "Employee [name=" + name + ", car2=" + car2 + "]";
	}
	
}

配置：

<!-- set方法注入对象类型的属性 -->
<bean id="employee" class="com.rosinante.spring.demo4.Employee">
	<!-- value:设置普通类型的值，ref：设置其他类型的id或name -->
	<property name="name" value="zhangsan"></property>
	<property name="car2" ref="car2"></property>
</bean>

测试类：

public void demo3(){
	ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
	Employee employee= (Employee)applicationContext.getBean("employee");
	System.out.println(employee);
}

运行结果如下：

3.P名称空间的属性注入

（一）通过引入p名称空间完成属性的注入：

写法：

  • 普通属性   p：属性名=“值”
  • 对象属性   p：属性名-ref=“值”

（二）P名称空间的引入：

<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:p="http://www.springframework.org/schema/p"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

在配置文件开头的beans标签里引入：xmlns:p="http://www.springframework.org/schema/p"

（三）使用P名称空间

将car2的set方式注入属性改为P名称空间的方式：

<!-- 改为p名称空间的方式 -->
<bean id="car2" class="com.rosinante.spring.demo4.Car2" p:name="法拉利" p:price="3000000"></bean>

P名称空间注入属性为对象类型时：

<bean id="employee" class="com.rosinante.spring.demo4.Car2" p:name="zhangsan" p:car2-ref="car2"></bean>

4.SpEL的属性注入

SpEL：Spring Expression Language，Spring表达式语言

语法：

       #{SpLE}

例如已car2和employee为例，使用SpEL的方式注入属性

<!-- SpEL的属性注入 -->
<bean id="car2" class="com.rosinante.spring.demo4.Car2">
	<property name="name" value="#{'自行车'}"></property>
	<property name="price" value="#{3000}"></property>
</bean>
<bean id="employee" class="com.rosinante.spring.demo4.Employee">
	<property name="name" value="#{'zhangsan'}"></property>
	<property name="car2" value="#{car2}"></property>
</bean>

为了验证在SpEL中调用方法，创建一个CarInfo的类：

package com.rosinante.spring.demo4;

public class CarInfo {
	private String name;
	
	public String getName(){
		return "摩托车";
	}
	
	public Double calculatorPrice(){
		return Math.random()*3000;
	}
}

将该类配置：

<bean id="carInfo" class="com.rosinante.spring.demo4.CarInfo"></bean>

可以在SpEL中调用CarInfo中的calculatorPrice方法：

<bean id="car2" class="com.rosinante.spring.demo4.Car2">
	<property name="name" value="#{carInfo.name}"></property>
	<property name="price" value="#{carInfo.calculatorPrice()}"></property>
</bean>

运行结果如下：

5.复杂属性的注入

数组、集合的注入：

创建一个collectionBean类：

package com.rosinante.spring.demo5;

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

/**
 * 集合属性的注入
 * @author Administrator
 *
 */
public class CollectionBean {
	private String[] arrs;
	private List<String>list;
	private Set<String>set;
	private Map<String,String>map;
	
	public String[] getArrs() {
		return arrs;
	}

	public void setArrs(String[] arrs) {
		this.arrs = arrs;
	}

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

	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;
	}

	@Override
	public String toString() {
		return "CollectionBean [arrs=" + Arrays.toString(arrs) + ", list="
				+ list + ", set=" + set + ", map=" + map + "]";
	}
}

配置：

<!-- Spring集合属性的注入 -->
<!-- 注入数组类型 -->
<bean id="collectionBean" class="com.rosinante.spring.demo5.CollectionBean">
	<!-- 注入数组类型 -->
	<property name="arrs">
		<list>
			<value>zhangsan</value>
			<value>lisi</value>
			<value>wangwu</value>
		</list>
	</property>
	<!-- 注入list集合 -->
	<property name="list">
		<list>
			<value>张三</value>
			<value>李四</value>
			<value>王五</value>
		</list>
	</property>
	<!-- 注入set集合 -->
	<property name="set">
		<set>
			<value>aaa</value>
			<value>bbb</value>
			<value>ccc</value>
		</set>
	</property>
	<!-- 注入map集合 -->
	<property name="map">
		<map>
			<entry key="aaa" value="111"></entry>
			<entry key="bbb" value="222"></entry>
			<entry key="ccc" value="333"></entry>
		</map>
	</property>
</bean>

编写测试类：

package com.rosinante.spring.demo5;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;


/**
 * 集合类型的属性注入
 * @author Administrator
 *
 */
public class SpringDemo5 {
	@Test
	public void demo1(){
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
		CollectionBean collectionBean= (CollectionBean)applicationContext.getBean("collectionBean");
		System.out.println(collectionBean);
	}
}

运行结果如下：

Rosinante.
关注
专栏目录
Spring是如何管理Bean
gysibm的博客
10-14 1570
我们知道，容器是一个空间的概念，一般理解为可盛放物体的地方。在Spring容器通常理解为BeanFactory或者ApplicationContext。我们知道spring的IOC容器能够帮我们创建对象，对象交给spring管理之后我们就不用手动去new对象。 BeanFactory与ApplicationContext的区别是什么？ BeanFactory采用了工厂设计模式，负责读取bean配置文档，管理bean的加载，实例化，维护bean之间的依赖关系，负责bean的声明周期。而ApplicationC
4 - Spring 学习笔记 - Bean 管理 XML 方式(注入集合属性)
m0_53708566的博客
06-19 145
IOC 操作 Bean 管理(xml 注入集合属性) 1、注入数组类型属性 2、注入 List 集合类型属性 3、注入 Map 集合类型属性 （1）创建类，定义数组、list、map、set 类型属性，生成对应 set 方法。 public class Student { // 1. 数组类型属性 private String[] courses; // 2. List 集合类型属性 private List<String> list; // 3. map
Spring：Bean的管理学习笔记
Derrick
07-19 164
1：通过Spring工厂类来获取Bean的实例，在Spring IOC简单例子中用到了applicationContext，接口为ApplicationContext，具体的为FileSystemXmlApplication与ClassPathXmlApplication 2：BeanFactory是在工厂实例化完事之后，在方法getBean才会创建这个类的实例，ApplicationContex...
Bean管理 (重要)
cl的博客
01-22 1020
频繁创建对象是耗费资源的，所以可以将对象交给Spring的IOC容器管理。需要用到这个对象时直接依赖注入Spring当中提供的注解@Component以及，同时我们也学习了如何为应用程序注入运行时所需要依赖的bean对象，也就是。
Spring框架学习笔记（一）：Spring Bean管理
SpringWaterLikeMe
03-02 424
Spring Bean管理Spring Bean管理创建SpringBean的三种方式Bean的配置id/nameclassBean的作用域Bean生命周期Bean生命周期详解bean postprocessor的作用Bean构造方法、属性注入、Getter、Setter，P、SPEL、复杂类型属性注入注解定义Bean属性输入注解其余注解XML与注解混合开发传统XML开发XML与注解混合 Spri...
Bean的管理
最新发布
weixin_63111096的博客
08-22 580
bean标签: 把一个类的对象交给Spring管理。
Spring学习笔记-cqupt
03-19
在本篇 Spring 学习笔记中，我们将探讨 Spring 的入门、优点、组成以及重要的IOC理论。 1. **Spring 简介** Spring 是一个开源的、免费的 Java 框架，它的目标是减少企业级开发的复杂性。它集成了许多现有的技术，...
Spring学习笔记（9）----让Spring自动扫描和管理Bean
05-26
在Spring框架中，自动扫描和管理Bean是一种便捷的方式，它允许开发者无需显式配置每个Bean，而是通过指定包路径来让Spring自动发现和管理Bean。本文将深入探讨这个主题，帮助你更好地理解和应用这一功能。 首先，让...
Spring学习笔记---黑马视频课
sinat_38189533的博客
05-09 238
一、Spring框架的体系结构 二、开发步骤
Spring学习笔记----Spring Framework体系结构及内部各模块jar之间的maven依赖关系
Vivienne_ChenW的博客
08-01 787
一、目前的问题 在 Spring Boot 出现之前，Spring开发java项目，当配置maven依赖的时候并不能知道要配置哪些spring的jar，经常是胡乱添加一堆，编译或运行报错就继续配置jar依赖，导致spring依赖混乱。甚至下一次创建相同类型的工程时也不知道要配置哪些spring的依赖，还是拷贝之前的，导致maven越来越乱，还容易出错。 为何需要添加这些依赖？各依赖之间有何关系？某个依赖是否可以省略？要回答这些问题，就有必要了解 Spring 的依赖体系。 二、应用 spring的jar包只
Bean管理学习笔记
weixin_30364325的博客
07-07 258
1、BeanFactory 介绍 1.1 首先什么是Bean？ 1、Bean在Spring技术中是基于组件 2、他是Spring容器管理的最基本最常见的单元。在spring的应用场合中，bean可以是数据源、java的普通类 3、其实例保存在Spring的容器中，这种方式也是spring的核心思想所在 Bean通常被定义在配置文件中，bean的实例化由spring的ioc容器...
IOC Bean管理
weixin_52875557的博客
10-06 583
1、什么是Bean管理，Bean管理指的是俩个操作： 1、Spring创建对象 2、Sping注入属性 Spring创建对象的方式在IOC概念和原理文章中有讲，下面讲讲Spring注入属性的方式。 Spring注入属性：假如有一个User类，里面有一个私有的成员变量 private String userName；按照以往的方式，我们要给userName设置属性值，需要用到set方法，而现在这个过程是交给Spring做到。这里属性的值可以是基本数据类型，也可以是对象。 2.Bean管理...
Spring的Bean管理：
WARGON的博客
07-26 316
1：Bean实例化的三种方式： 首先提到一点。只要在配置文件中正确配置的&lt;bean&gt;在通过配置文件生成工厂时就创建了相应的实例。在Spring容器中等待调用。     使用无参构造的方式：也就是在配置文件中配置： &lt;bean id="aaa" class="xxx.xxx.xxxx"&gt;&lt;/bean&gt; class指向的是一个类的全路径类名。该类必须有无参...
Spring的Bean管理
龙云尧的博客
06-20 323
本博客基于SpringSourceCodeTest仓库中【SpringDemo1.0】tag进行的编写。 目录 文章目录目录Spring的Bean管理基于扫描的方式装载beanXML格式解读XML内容解读基于定义的方式装载bean基于注解的方式装载bean Spring的Bean管理 基于配置文件进行bean管理的方案是Spring初期推行的方式，在历史比较悠久的Spring项目中比较常见。 基于扫描的方式装载bean 一个比较典型的配置文件通常包含<context>标签， <cont.
Spring Bean的管理
Rankis的博客
03-14 850
Spring Bean的管理 1.spring工厂类的介绍 工厂类接口： 1）.ApplicationContext 每次容器启动时，就会创建容器配置的所有对象，并提供更多功能 1.相当于一个大工厂，提供了根据配置文件中的id属性值，获取对象 2.两个实现类： a.ClassPathXmlApplication类：从类的根路径下加载配置文件（企业项目开发中，使用较多） b.FileSystemX...
spring Bean管理
joker柒月的博客
05-06 181
Spring的工厂类 Spring的Bean管理（bean的三种实例化方式） Bean的作用域 Spring容器中Bean的生命周期 演示如何增强一个类的方法 Spring的属性注入DI ...
Spring框架 —— Bean的管理
qq_45830276的博客
06-17 784
bean管理能够更加方便的创建对象和对属性的赋值，以及常用注解的方式创建对象更加便利
IOC原理及xml配置操作bean
F13253524870的博客
06-03 406
文章目录IOC概述IOC底层原理IOC的bean管理IOC操作bean的管理（基于xml）基于 xml 方式注入属性xml注入其他类型属性注入null值注入属性值中包含特殊符号注入外部bean注入内部bean注入集合在集合中注入对象把集合注入部分提取出来FactoryBeanbean的作用域bean的生命周期 IOC概述 IOC底层原理 底层实现用到的技术：xml解析、工厂模式、反射机制 解析过程： 第一步：通过xml解析技术获取xml文件中配置的bean对象的包名+类名 第二步：通过反射机制获取配置中
Spring学习之Bean管理
m0_64460657的博客
03-19 1273
Spring之Bean管理 IOC DI
Spring框架LoadTimeWeaver详解-华为工程师笔记
虽然具体的内容没有给出，但是可以推测笔记详细介绍了Spring的核心组件，如IoC容器、bean的创建和管理、依赖注入，以及AOP的使用等。 这篇笔记对于理解Spring框架，特别是如何使用LoadTimeWeaving技术来实现运行时...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值