Spring框架 (4) —— 标签说明

标签说明

alias标签

作用：为已配置的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">
        
	<bean id="user" name="test" class="cn.xc.spring.pojo.User"/>
	<!-- 
		标签alias: 为已配置的bean设置别名
			属性name: 必要属性, 代表为哪一个bean配置别名, 
				此属性的值为其他bean标签的id或name属性值
			属性alias: 必要属性, 代表新命名的别名是什么
	 -->
	<alias name="user" alias="user1"/>
			
</beans>

–测试代码

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

import cn.xc.entity.User;

public class Test {
	public static void main(String[] args) {
		// 读取Spring配置文件
		ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

		// 通过id获取User对象
		User user = (User) context.getBean("user");
		// 测试对象
		System.out.println(user);
		System.out.prntln("=====================================");
		// 通过alias获取User对象
		user = (User) context.getBean("user1");
		// 测试对象
		System.out.println(user);
	}
}

bean标签的配置

bean标签作用

用于声明一个类,在启动Spring框架的时候根据该配置的类创建对象到容器里面

属性声明

<!-- <bean>标签：用于声明一个类,在启动Spring框架的时候根据该配置的类创建对象到容器里面
	     name:设置对象名（唯一标识符）,可以有多个名称,每个名称用逗号隔开 :  name1,name2
	     id：设置对象名（唯一标识符，功能和name一样）
	     class:用于指定对象对应的类名
	     scope:用于设置的对象的作用范围，可选参数如下：
	        *singleton:单例（默认）
                对象出生：当程序加载配置文件创建容器时，创建
                对象活着：只要容器还在，一直活着
                对象死亡：应用停止，容器销毁，对象死亡
	        *prototype:多例（原型对象）
                对象出生：当程序加载配置文件创建容器时，创建
                对象活着：只要对象被使用，一直活着
                对象死亡：对象长时间不用，会被Java垃圾回收机制回收
	        *reqeust:web项目中，Spring将创建的对象放在request作用域中
	        *session:web项目中，Spring将创建的对象放在session作用域中
	        *globalSession:web项目中，应用域portlet环境，如果没有protlet环境相当于session
	    init-method:设置创建对象的时候，调用初始化方法
	    destroy-method:设置对象被回收时，调用注销的方法
	  -->
<bean name="customerServiceImpl" class="com.xc.spring.service.impl.CustomerServiceImpl"></bean>

Bean作用范围

作用范围也可以说生命周期（bean能存活多久）

singleton	单例 ，在Spring IoC容器中仅存在一个Bean实例 （默认的scope）
prototype	多例 ，每次从容器中调用Bean时，都返回一个新的实例，即每次调用getBean()时 ，相当于执行new XxxBean()：
request	用于web开发，将Bean放入request范围 ，request.setAttribute(“xxx”) ， 在同一个request 获得同一个Bean
session	用于web开发，将Bean 放入Session范围，在同一个Session 获得同一个Bean

在开发中主要使用 scope=“singleton”、 scope=“prototype”
对于MVC中的Action/Controller使用prototype类型，其他使用singleton

<!-- 
​    <bean id="" class="" scope="作用域"/>
​    scope : 配置当前bena的范围大小 
​    singleton: 单例 ，在Spring IoC容器中仅存在一个Bean实例 （默认的scope）
​    prototype: 多例 ，每次从容器中调用Bean时，都返回一个新的实例，即每次调用getBean()时 ，相当于执行new XxxBean()
-->
<bean id="someBean" class="cn.xc.spring.pojo.SomeBean" scope="prototype"></bean> 

在Web开发的三层架构中

Web：一般都是多例
Service ：单例
DAO ：单例

实例化Bean的四种方式

Spring创建Java的四种方式

构造器实例化（无参数构造器），最标准，使用最多。

public class SomeBean1 {
	public SomeBean1() {
		System.out.println("SomeBean1.SomeBean1()");
	}
}

配置文件

<!-- ①.构造器实例化（无参数构造器），最标准，使用最多。 -->
	<bean id="someBean1" class="cn.xc.spring.pojo.SomeBean1"></bean>

通过静态方法工厂创建

–静态工厂类

SomeBean2/SomeBean2Facotry 
public class SomeBean2 {
	public SomeBean2() {
		System.out.println("SomeBean.SomeBean2()");
	}
}
/*
 * 静态工厂方法，提供一个 静态方法并返回 SomeBean2对象
 */
public class SomeBean2Facotry {
	//静态工厂方法
	public static SomeBean2 getSomeBean2() {
		System.out.println("执行静态工厂方法");
		return new SomeBean2();
	}
}

静态工厂配置

<!-- ②.静态工厂方法实例化：解决系统遗留问题 -->
	<bean id="someBean2" class="cn.xc.spring.pojo.SomeBean2Facotry"
		factory-method="getSomeBean2"></bean>

通过实体工厂创建

实体工厂

public class SomeBean3 {
	public SomeBean3() {
		System.out.println("SomeBean.SomeBean3()");
	}
}
/*
 * 对象工厂方法，提供一个成员/对象方法并返回 SomeBean3对象
 */
public class SomeBean3Facotry {
	//实例工厂方法
	public SomeBean3 getSomeBean3() {
		System.out.println("执行实例工厂方法");
		return new SomeBean3();
	}
}

配置方式

<!-- ③.实例工厂方法实例化：解决系统遗留问题 -->
	<!-- 1.配置工厂bean -->
	<bean id="someBean3Factory" class="cn.xc.spring.pojo.SomeBean3Facotry"></bean>
	<!-- 2.配置bena
		factory-bean : 创建bean的工厂对象对应的 id
		factory-method : 工厂bean中返回 bean对象的方法
	 -->
	<bean id="someBean3" factory-bean="someBean3Factory" factory-method="getSomeBean3"/>

实现FactoryBean接口实例化：实例工厂变种

实现FactoryBean接口,MyBatis和Spring集成就是使用的这种方式
此种方式，如果没有使用Bean对应的对象，Spring就不会自动创建，只有在使用的时候Spring才会创建对应的对象

public class SomeBean4 {
	public SomeBean4() {
		System.out.println("SomeBean4.SomeBean4()");
	}
}
/*
 *  实现FacotryBean接口，接口的泛型就是返回对象对应的数据类型，并提供一个getObject方法
 *  返回的就是泛型对应的对象
 *  此种方式：所有的框架和Spring集成的时候全部使用的是此种方式
 *  	MyBatis，Shiro安全框架等等
 */
public class SomeBean4Factory implements FactoryBean<SomeBean4> {
	@Override
	public SomeBean4 getObject() throws Exception {
		// 返回的泛型类型对应的对象
		SomeBean4 bean4 = new SomeBean4();
		return bean4;
	}
	@Override
	public Class<?> getObjectType() {
		// 返回Object类型
		return null;
	}
	@Override
	public boolean isSingleton() {
		// 是不是单例？
		return false;
	}
}

配置方式

<!-- ④.实现FactoryBean接口实例化：实例工厂变种：集成其他框架使用：LocalSessionFactoryBean -->
<bean id="someBean4" class="cn.xc.domian.SomeBean4ObjectFactory"></bean>

初始化和销毁方法

比如DataSource,SessionFactory最终都需要关闭资源:在Bean销毁之前,都要调用close方法.

<bean id="someBean" class="......" 
   		init-method="该类中初始化方法名" destroy-method="该类中销毁方法名">
</bean>

init-method：bean生命周期初始化方法,对象创建后就进行调用
destroy-method:容器被销毁的时候，如果bean被容器管理，会调用该方法。

default-init-method

分析原理:
如果bean的scope=“prototype”,那么容器只负责创建和初始化，它并不会被spring容器管理。交给用户自己调用.

<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"
	     
     default-init-method="init">
	<!-- 配置全局初始化方法,如果有100个bean中都有init方法,那么只要Spring容器一启动,bean对象一创建
		默认对象中只要有 init方法,都全部会执行:一般不建议使用
	 -->
	<!-- 
	init-method : 配置初始化方法名
	destroy-method : 配置销毁方法名
	 -->
	<bean id="someBean" class="cn.xc.spring.pojo.SomeBean" 
		init-method="init"
		destroy-method="destory"></bean> 
</beans>