Spring学习笔记--Spring-认识Bean

最新推荐文章于 2021-09-07 17:22:07 发布

wei_小灰灰

最新推荐文章于 2021-09-07 17:22:07 发布

阅读量402

点赞数

分类专栏： Spring

本文链接：https://blog.csdn.net/weixin_44889138/article/details/104409520

版权

Spring 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

前一篇入门程序后，还是会有疑问，什么是bean？

Spring 可以被看作一个大型工厂，它的作用就是生产和管理Spring容器中的Bean，如果需要使用它，就要对Spring的配置文件进行配置。

文章目录

1. Bean的配置
- - 1.1 XML文件配置
  - 1.2 简单案例使用properties格式配置文件
2. Bean的实例化

1. Bean的配置

Spring支持XML和Properites两种格式的配置文件，常用的就是XML格式配置，这种方式通过XML文件来注册并管理Bean之间的依赖关系。

1.1 XML文件配置

XML配置文件的根元素是<beans></beans>，<beans>中包含了多个<bean>子元素，每一个<bean>子元素定义了一个Bean，描述了该Bean如何被装配到Spring容器中。

<bean>元素的常用属性

属性	描述
id	Bean的唯一标识符
class	指定了Bean的具体实现类(包含该类所在包)
scope	用来设置Bean作用域
init-method	Bean初始化方法
destroy-method	Bean销毁方法
factory-bean	Bean实例化时使用实例化工厂方式所需属性
factory-method	Bean实例化时使用静态/实例化工厂方式所需属性

<bean>元素的常用子元素

子元素	描述
constructor-arg	使用此元素传入构造函数参数进行实例化(构造注入)
property	用于调用Bean实例中的setter方法完成属性赋值(设值注入)

<constructor-arg>的属性/子元素

属性/子元素	描述
index(属性)	指定构造函数的序号(从0开始)
type(属性)	指定构造参数的类型
ref/value(可作为子元素,属性)	指定参数值/指定对Bean工厂中某个Bean实例的引用
ref/value(可作为子元素,属性)	指定参数值

<property>的属性/子元素

属性/子元素	描述
name(属性)	Bean实例中的相应属性名
ref/value(可作为子元素,属性)	指定参数值/指定对Bean工厂中某个Bean实例的引用
ref/value(可作为子元素,属性)	指定参数值

1.2 简单案例使用properties格式配置文件

在Spring不常用，(题外话)但是Spring Boot中不使用XML配置后(用注解替代了)，常用的是properties格式的配置文件，下面将通过简单例子描述

创建Web项目，导入所需jar包
在src下创建application.properties
创建包(我创建的包com.xhh.properties)下创建类(我创建的类Bean4.java，里面不用写什么)
创建xml文件(我创建的Bean4.xml)
创建测试类(我创建的Bean4Test.java)
在xml文件写入(代码在下)
在application.properties写入 bean4=com.xhh.properties.Bean4
运行测试(代码在下)

<?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:context="http://www.springframework.org/schema/context"
   xsi:schemaLocation="
      http://www.springframework.org/schema/beans
      http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
      http://www.springframework.org/schema/context
      http://www.springframework.org/schema/context/spring-context-4.2.xsd">

	  <!-- 若报错，检查beans中有没有xmlns:context值和
	  http://www.springframework.org/schema/context
      http://www.springframework.org/schema/context/spring-context-4.2.xsd -->
      <context:property-placeholder location="classpath:application.properties" />
	  
	  <bean id="bean4" class="${bean4}"></bean>
</beans>

package com.xhh.properties;

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


public class Bean4Test {

	public static void main(String[] args) {
		String beanXmlPath = "com/xhh/properties/Bean4.xml";
		
		ApplicationContext applicationContext = new 
				ClassPathXmlApplicationContext(beanXmlPath);
		
		Bean4 bean = (Bean4) applicationContext.getBean("bean4");
		System.out.println(bean);
	}
}

但还是用了XML，所以Spring中常用的还是XML，而Spring Boot用注解替代了在XML中配置Bean，Spring Boot的魅力。。。

2. Bean的实例化

在面向对象的程序中，如果想要使用某个对象，就要先实例化这个对象，同样在Spring中想要使用容器中的Bean，也需要实例化Bean。有三种方式：

构造器实例化(常用)
静态工厂方式实例化
实例工厂方式实例化

2.1 构造器实例化

在项目下创建包(我创建的包com.xhh.constructor)
创建类(我创建的类Bean1，不用写任何方法)
创建xml文件(我创建的类Bean1.xml)
创建测试类(我创建的类BeanTest1)，运行。

代码如下：

Bean1.java

package com.xhh.constructor;

public class Bean1 {
}

Bean2.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="bean1" class="com.xhh.constructor.Bean1">
    </bean>

</beans>

Bean1Test.java

package com.xhh.constructor;

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

public class Bean1Test {
	
	public static void main(String[] args) {
		
		String beanXmlPath = "com/xhh/constructor/Bean1.xml";
		
		ApplicationContext applicationContext = new 
				ClassPathXmlApplicationContext(beanXmlPath);
		
		Bean1 bean = (Bean1) applicationContext.getBean("bean1");
		System.out.println(bean);
	}
}

这里提一下，在前一篇中我把xml文件命名为applicationContext.xml并放到src目录下，所以使用该配置文件时不需要写其路径，只需写名字，而这次我把它放到了自建的包中，就需要指明路径。。。如代码中所示

2.2 静态工厂方式实例化

在项目下创建包(我创建的包com.xhh.static_factory)
创建类1(我创建的类Bean2.java，不用写任何方法)
创建类2(我创建的类Bean2Factory.java，创建一个静态方法(createBean)来放回Bean2实例)
创建xml文件(我创建的类Bean2.xml，里面的Bean配置，需要使用class指定工厂所在路径，使用factory-method=createBean，指定在工厂类中创建的静态方法名
创建测试类(我创建的类BeanTest2)，运行。

代码如下：
Bean2.java

package com.xhh.static_factory;

public class Bean2 {

}

Bean2Factory.java

package com.xhh.static_factory;

public class Bean2Factory {

	public static Bean2 createBean() {
		return new Bean2();
	}
}

Bean2.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="bean2" class="com.xhh.static_factory.Bean2Factory" factory-method="createBean">
    	
    </bean>

</beans>

Bean2Test.java

package com.xhh.static_factory;

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

public class Bean2Test {

	public static void main(String[] args) {
		
		String beanXmlPath = "com/xhh/static_factory/Bean2.xml";
		
		ApplicationContext applicationContext = new 
				ClassPathXmlApplicationContext(beanXmlPath);
		
		Bean2 bean = (Bean2) applicationContext.getBean("bean2");
		System.out.println(bean);
	}

}

2.3 实例工厂方式实例化

在项目下创建包(我创建的包com.xhh.instance_factory)
创建类1(我创建的类Bean3.java，不用写任何方法)
创建类2(我创建的类InstanceFactory.java，使用createBean()方法创建Bean3对象）
创建xml文件(我创建的类Bean3.xml，首先配置了一个工厂Bean，然后配置了需要实例化的Bean。在需要实例化的Bean添加属性：factory-bean=“工厂id” factory-method=“createBean”
创建测试类(我创建的类BeanTest3)，运行。

Bean3.java

package com.xhh.instance_factory;

public class Bean3 {

}

InstanceFactory.java.java

package com.xhh.instance_factory;

public class InstanceFactory {

	public InstanceFactory() {
		System.out.println("Bean实例化工厂中");
		
	}
	
	private Bean3 createBean() {
		
		return new Bean3();
	}
}

Bean3.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="instanceFactory" class="com.xhh.instance_factory.InstanceFactory">
    </bean>

	<bean id="bean3" factory-bean="instanceFactory" factory-method="createBean"></bean>
</beans>

Bean3Test.java

package com.xhh.instance_factory;

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

import com.xhh.static_factory.Bean2;

public class Bean3Test {

	public static void main(String[] args) {
		String beanXmlPath = "com/xhh/instance_factory/Bean3.xml";
		
		ApplicationContext applicationContext = new 
				ClassPathXmlApplicationContext(beanXmlPath);
		
		Bean3 bean = (Bean3) applicationContext.getBean("bean3");
		System.out.println(bean);
	}
}