Spring的一些标签说明

Posted 2021-11-27 maigy

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 接口创建对象。因为框架调用的时候经常涉及参数与对象绑定在一起，所以使用 FactoryBean 接口创建对象。