1、alias 标签:
作用:为已配置的 bean 设置别名
1 <?xml version="1.0" encoding="UTF-8"?>
2 <beans xmlns="http://www.springframework.org/schema/beans"
3 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4 xsi:schemaLocation="http://www.springframework.org/schema/beans
5 http://www.springframework.org/schema/beans/spring-beans.xsd">
6
7 <bean id="user" name="test" class="cn.mgy.entity.User"/>
8
9 <!--
10 标签alias: 为已配置的bean设置别名
11 属性name: 必要属性, 代表为哪一个bean配置别名,
12 此属性的值为其他bean标签的id或name属性值
13 属性alias: 必要属性, 代表新命名的别名是什么
14 -->
15 <alias name="user" alias="user1"/>
16
17 </beans>
测试代码:
1 import org.springframework.context.ApplicationContext;
2 import org.springframework.context.support.ClassPathXmlApplicationContext;
3
4 import cn.mgy.entity.User;
5
6 public class Test {
7 public static void main(String[] args) {
8 // 读取Spring配置文件
9 ApplicationContext context = new ClassPathXmlApplicationContext(
10 "applicationContext.xml");
11
12 // 通过id获取User对象
13 User user = (User) context.getBean("user");
14 // 测试对象
15 System.out.println(user);
16 System.out.prntln("=====================================");
17 // 通过alias获取User对象
18 user = (User) context.getBean("user1");
19 // 测试对象
20 System.out.println(user);
21 }
22 }
2、bean 标签的配置:
bean 标签的作用:用于声明一个类,在启动 Spring 框架的时候根据该配置的类创建对象到容器里面。
属性说明:
1 <!-- <bean>标签:用于声明一个类,在启动Spring框架的时候根据该配置的类创建对象到容器里面
2 name:设置对象名(唯一标识符)
3 id:设置对象名(唯一标识符,功能和name一样)
4 class:用于指定对象对应的类名,如果不是实现类必须要将bean声明为抽象的!!!
5 scope:用于设置的对象的作用范围,可选参数如下:
6 *singleton:单例(默认)
7 对象出生:当程序加载配置文件创建容器时,创建
8 对象活着:只要容器还在,一直活着
9 对象死亡:应用停止,容器销毁,对象死亡
10 *prototype:多例(原型对象)
11 对象出生:当程序加载配置文件创建容器时,创建,(每次调用会创建一个新对象)
12 对象活着:只要对象被使用,一直活着
13 对象死亡:对象长时间不用,会被Java垃圾回收机制回收 (该对象不被容器管理)
14 *reqeust:web项目中,Spring将创建的对象放在request作用域中
15 *session:web项目中,Spring将创建的对象放在session作用域中
16 init-method:设置创建对象的时候,调用初始化方法
17 destroy-method:设置对象被回收时,调用注销的方法
18
19 -->
20 <bean name="customerServiceImpl" class="cn.mgy.service.impl.CustomerServiceImpl"></bean>
3、实例化 Bean 的四种方式:
(1)通过 class 直接创建
1 <bean name="customerService" class="cn.mgy.service.CustomerService">
(2)通过静态方法工厂创建
1 package cn.mgy.factory;
2
3 import cn.mgy.service.CustomerService;
4
5 public class CreateFactory {
6
7 /**
8 * 使用一个静态工厂类,通过字符串创建一个对象
9 *
10 * @param className
11 * @return
12 */
13 public static Object create() {
14
15 return new CustomerService();
16
17 }
18
19 }
1 package cn.mgy.factory;
2 public class CustomerService {
3 void say();
4 }
1 package cn.mgy.factory;
2
3
4 public class CustomerServiceImpl implements CustomerService {
5 @Override
6 public void say() {
7 System.out.println("你好世界!");
8 }
9 }
静态工厂配置:
1 <bean name="customerService" factory-method="create" class="cn.mgy.factory.CreateFactory">
2 <property name="customerDAO" ref="customerDAOImpl"></property>
3 </bean>
(3)通过实体工厂创建
实体工厂,注意 create 方法没有 static
1 package cn.mgy.factory;
2
3 import cn.mgy.service.CustomerService;
4
5 public class CreateFactory {
6
7 /**
8 * 使用一个静态工厂类,通过字符串创建一个对象
9 *
10 * @param className
11 * @return
12 */
13 public Object create() {
14
15 return new CustomerService();
16
17 }
18
19 }
配置方式:
1 <?xml version="1.0" encoding="UTF-8"?>
2 <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-4.2.xsd ">
3 <bean name="customerDAOImpl" class="cn.mgy.dao.impl.CustomerDAOImpl"></bean>
4 <!--非静态的方法,必须需要对象来调用,所以必须要创建工厂类的对象 -->
5 <bean name="createFactory" class="cn.mgy.factory.CreateFactory" ></bean>
6 <bean name="customerService" factory-method="create" factory-bean="createFactory" >
7 <property name="customerDAO" ref="customerDAOImpl"></property>
8 </bean>
9 </beans>
(4)内置 FactoryBean 工厂创建对象的实现
Spring 支持一种通过实现 FactoryBean 的接口创建工厂类对象。必须返回泛型指定的类型对象。
1 public class HelloWorldServiceFactory implements FactoryBean<HelloWorldService> {
2
3 /**
4 * 返回创建的对象
5 */
6 @Override
7 public HelloWorldService getObject() throws Exception {
8 return new HelloWorldService();
9 }
10
11 /**
12 * 返回对象的类型
13 */
14 @Override
15 public Class<?> getObjectType() {
16 return HelloWorldService.class;
17 }
18
19 /**
20 * 是否是单例,如果是true ,否则就是false
21 */
22 @Override
23 public boolean isSingleton() {
24 return false;
25 }
26
27 }
调用代码:
1 package cn.mgy.test;
2
3 import org.junit.Test;
4 import org.springframework.beans.BeansException;
5 import org.springframework.context.support.ClassPathXmlApplicationContext;
6
7 import cn.mgy.service.HelloWorldService;
8
9 public class HelloWorldTest {
10
11 @Test
12 public void say() {
13
14 try {
15 //Spring框架的路径格式:如果从包里面开始读取的路径,使用classpath开始
16 ClassPathXmlApplicationContext applicationContext=new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
17 //对象名必须要和配置的对象名一一对应
18 HelloWorldService helloWorldService = applicationContext.getBean("helloWorldService", HelloWorldService.class);
19 helloWorldService.say();
20 applicationContext.close();
21 } catch (BeansException e) {
22 // TODO Auto-generated catch block
23 e.printStackTrace();
24 }
25
26 }
27
28 }
可以设置很多需要的参数再返回。如果我们创建一个对象需要设置很多参数的话,我们可以通过一个工厂类创建对象,这样就可以设置很多的参数。这样也就实现了将参数和对象打包了。
我们经常看见框架整合的时候,会看到 FactoryBean 接口创建对象。因为框架调用的时候经常涉及参数与对象绑定在一起,所以使用 FactoryBean 接口创建对象。