Spring创建bean

其他 2018-07-17 21:12:11 阅读次数: 0
  1. 实例化Spring容器
  2. 使用Spring容器创建bean
  3. bean的作用域
  4. bean的生命周期
  5. Setter注入
  6. 构造器注入
  7. 自动装配

1 实例化Spring容器

1.1 问题

使用ApplicationContext的方式实例化Spring容器。

1.2 方案

使用ApplicationContext的方式实例化Spring容器的核心代码如下：


     
     
    
      
      
  1. String conf = "applicationContext.xml";
    2. 
      
      
  2. ApplicationContext ac = 
    3. 
      
      
  3. new ClassPathXmlApplicationContext(conf);
    4.

1.3 步骤

步骤一：创建项目，导入jar包

创建项目Spring01，导入Spring开发包，如下图所示：

图-1

步骤二：导入Spring配置文件

导入applicationContext.xml，代码如下：


     
     
    
      
      
  1. <?xml version="1.0" encoding="UTF-8"?>
    2. 
      
      
  2. <beans xmlns="http://www.springframework.org/schema/beans" 
    3. 
      
      
  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4. 
      
      
  4.     xmlns:context="http://www.springframework.org/schema/context" 
    5. 
      
      
  5.     xmlns:jdbc="http://www.springframework.org/schema/jdbc"  
    6. 
      
      
  6.     xmlns:jee="http://www.springframework.org/schema/jee" 
    7. 
      
      
  7.     xmlns:tx="http://www.springframework.org/schema/tx"
    8. 
      
      
  8.     xmlns:aop="http://www.springframework.org/schema/aop" 
    9. 
      
      
  9.     xmlns:mvc="http://www.springframework.org/schema/mvc"
    10. 
      
      
  10.     xmlns:util="http://www.springframework.org/schema/util"
    11. 
      
      
  11.     xmlns:jpa="http://www.springframework.org/schema/data/jpa"
    12. 
      
      
  12.     xsi:schemaLocation="
    13. 
      
      
  13.         http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
    14. 
      
      
  14.         http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd
    15. 
      
      
  15.         http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-3.2.xsd
    16. 
      
      
  16.         http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.2.xsd
    17. 
      
      
  17.         http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd
    18. 
      
      
  18.         http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa-1.3.xsd
    19. 
      
      
  19.         http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.2.xsd
    20. 
      
      
  20.         http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd
    21. 
      
      
  21.         http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.2.xsd">
    22. 
      
      
  22.     
    23. 
      
      
  23. </beans>
    24.

步骤三：写测试代码

创建测试类TestCase，并增加测试方法test1，代码如下：


     
     
    
      
      
  1. package com.tarena.test;
    2. 
      
      
  2. 
      
      
  3. import java.sql.SQLException;
    4. 
      
      
  4. import java.util.Calendar;
    5. 
      
      
  5. import java.util.Date;
    6. 
      
      
  6. import org.junit.Test;
    7. 
      
      
  7. import org.springframework.context.ApplicationContext;
    8. 
      
      
  8. import org.springframework.context.support.AbstractApplicationContext;
    9. 
      
      
  9. import org.springframework.context.support.ClassPathXmlApplicationContext;
    10. 
      
      
  10. import com.tarena.bean.Computer;
    11. 
      
      
  11. import com.tarena.bean.ExampleBean;
    12. 
      
      
  12. import com.tarena.bean.MobilePhone;
    13. 
      
      
  13. import com.tarena.bean.Student;
    14. 
      
      
  14. 
      
      
  15. public class TestCase {
    16. 
      
      
  16.     
    17. 
      
      
  17.     /**
    18. 
      
      
  18.      * 实例化Spring容器
    19. 
      
      
  19.      */
    20. 
      
      
  20.     @Test
    21. 
      
      
  21.     public void test1() {
    22. 
      
      
  22.         String cfg = "applicationContext.xml";
    23. 
      
      
  23.         ApplicationContext ctx = 
    24. 
      
      
  24.             new ClassPathXmlApplicationContext(cfg);
    25. 
      
      
  25.         System.out.println(ctx);
    26. 
      
      
  26.     }
    27. 
      
      
  27.     
    28. 
      
      
  28. }
    29.

步骤四：执行测试

运行测试方法test1，效果如下图所示：

图-2

1.4 完整代码

applicationContext.xml完整代码如下：

代码

TestCase完整代码如下：

代码

2 使用Spring容器创建bean

2.1 问题

演示如何使用Spring容器创建bean。

2.2 方案

使用Spring容器创建bean有3种方式：

2.3 步骤

步骤一：声明bean

在applicationContext.xml中，通过<bean>声明bean，代码如下：


     
     
    
      
      
  1. <?xml version="1.0" encoding="UTF-8"?>
    2. 
      
      
  2. <beans xmlns="http://www.springframework.org/schema/beans" 
    3. 
      
      
  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4. 
      
      
  4.     xmlns:context="http://www.springframework.org/schema/context" 
    5. 
      
      
  5.     xmlns:jdbc="http://www.springframework.org/schema/jdbc"  
    6. 
      
      
  6.     xmlns:jee="http://www.springframework.org/schema/jee" 
    7. 
      
      
  7.     xmlns:tx="http://www.springframework.org/schema/tx"
    8. 
      
      
  8.     xmlns:aop="http://www.springframework.org/schema/aop" 
    9. 
      
      
  9.     xmlns:mvc="http://www.springframework.org/schema/mvc"
    10. 
      
      
  10.     xmlns:util="http://www.springframework.org/schema/util"
    11. 
      
      
  11.     xmlns:jpa="http://www.springframework.org/schema/data/jpa"
    12. 
      
      
  12.     xsi:schemaLocation="
    13. 
      
      
  13.         http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
    14. 
      
      
  14.         http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd
    15. 
      
      
  15.         http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-3.2.xsd
    16. 
      
      
  16.         http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.2.xsd
    17. 
      
      
  17.         http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd
    18. 
      
      
  18.         http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa-1.3.xsd
    19. 
      
      
  19.         http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.2.xsd
    20. 
      
      
  20.         http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd
    21. 
      
      
  21.         http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.2.xsd">
    22. 
      
      
  22.     
    23. 
      
      
  23.     <!--通过构造器实例化bean -->
    24. 
      
      
  24.     <bean id="obj1" class="java.util.GregorianCalendar"/>
    25. 
      
      
  25.     
    26. 
      
      
  26.     <!--通过静态工厂方法实例化bean -->
    27. 
      
      
  27.     <bean id="obj2" class="java.util.Calendar" factory-method="getInstance"/>
    28. 
      
      
  28.     
    29. 
      
      
  29.     <!--通过实例工厂方法实例化bean -->
    30. 
      
      
  30.     <bean id="obj3" class="java.util.GregorianCalendar"/>
    31. 
      
      
  31.     <bean id="obj4" factory-bean="obj3" factory-method="getTime"/>
    32. 
      
      
  32.     
    33. 
      
      
  33. </beans>
    34.

步骤二：写测试代码

在TestCase中增加测试方法test2，在此方法中通过Spring容器来创建声明的bean，代码如下：


     
     
    
      
      
  1. package com.tarena.test;
    2. 
      
      
  2. 
      
      
  3. import java.sql.SQLException;
    4. 
      
      
  4. import java.util.Calendar;
    5. 
      
      
  5. import java.util.Date;
    6. 
      
      
  6. import org.junit.Test;
    7. 
      
      
  7. import org.springframework.context.ApplicationContext;
    8. 
      
      
  8. import org.springframework.context.support.AbstractApplicationContext;
    9. 
      
      
  9. import org.springframework.context.support.ClassPathXmlApplicationContext;
    10. 
      
      
  10. import com.tarena.bean.Computer;
    11. 
      
      
  11. import com.tarena.bean.ExampleBean;
    12. 
      
      
  12. import com.tarena.bean.MobilePhone;
    13. 
      
      
  13. import com.tarena.bean.Student;
    14. 
      
      
  14. 
      
      
  15. public class TestCase {
    16. 
      
      
  16. 
      
      
  17.     //其他方法略
    18. 
      
      
  18.     /**
    19. 
      
      
  19.      * 3种实例化bean的方式
    20. 
      
      
  20.      */
    21. 
      
      
  21.     @Test
    22. 
      
      
  22.     public void test2() {
    23. 
      
      
  23.         String cfg = "applicationContext.xml";
    24. 
      
      
  24.         ApplicationContext ctx = 
    25. 
      
      
  25.             new ClassPathXmlApplicationContext(cfg);
    26. 
      
      
  26.         
    27. 
      
      
  27.         Calendar cal1 = (Calendar) ctx.getBean("obj1");
    28. 
      
      
  28.         System.out.println(cal1);
    29. 
      
      
  29.         
    30. 
      
      
  30.         Calendar cal2 = ctx.getBean("obj2", Calendar.class);
    31. 
      
      
  31.         System.out.println(cal2);
    32. 
      
      
  32.         
    33. 
      
      
  33.         Date date = ctx.getBean("obj4", Date.class);
    34. 
      
      
  34.         System.out.println(date);
    35. 
      
      
  35.     }
    36. 
      
      
  36. 
      
      
  37. }
    38.

步骤三：执行测试

运行测试方法test2，效果如下图所示：

图-3

2.4 完整代码

applicationContext.xml完整代码如下：

代码

TestCase完整代码如下：

代码

3 bean的作用域

3.1 问题

本案例探讨通过Spring容器创建bean时，bean的作用域。

3.2 方案

3.3 步骤

步骤一：声明bean

在applicationContext.xml中，新声明一个bean，追加的代码如下：


     
     
    
      
      
  1.     <!-- bean的作用域 -->
    2. 
      
      
  2.     <bean id="obj5" class="java.util.GregorianCalendar" />
    3.

步骤二：写测试代码

在TestCase中追加测试方法test3，测试新声明的bean是否单例，追加代码如下：


     
     
    
      
      
  1.     /**
    2. 
      
      
  2.      * bean的作用域
    3. 
      
      
  3.      */
    4. 
      
      
  4.     @Test
    5. 
      
      
  5.     public void test3() {
    6. 
      
      
  6.         String cfg = "applicationContext.xml";
    7. 
      
      
  7.         ApplicationContext ctx = 
    8. 
      
      
  8.             new ClassPathXmlApplicationContext(cfg);
    9. 
      
      
  9.         Calendar cal1 = (Calendar) ctx.getBean("obj5");
    10. 
      
      
  10.         Calendar cal2 = (Calendar) ctx.getBean("obj5");
    11. 
      
      
  11.         System.out.println(cal1==cal2);
    12. 
      
      
  12.     }
    13.

步骤三：执行测试

执行测试方法test3，效果如下图所示：

图-4

步骤四：修改bean声明

修改applicationContext.xml中新声明的bean，增加scope=”prototype”，修改代码如下：


     
     
    
      
      
  1.     <!-- bean的作用域 -->
    2. 
      
      
  2.     <bean id="obj5" class="java.util.GregorianCalendar" scope="prototype"/>
    3.

步骤五：执行测试

执行测试方法test3，效果如下图所示：

图-5

3.4 完整代码

applicationContext.xml完整代码如下：

代码

TestCase完整代码如下：

代码

4 bean的生命周期

4.1 问题

本案例探讨bean的生命周期，以及bean的延迟实例化。

4.2 方案

Spring容器在创建bean时，可以帮忙管理bean的生命周期，即管理bean的初始化及销毁的方法。

默认情况下Spring容器创建时，会创建单例的对象，也可以让Spring容器延迟实例化这些单例的对象。

4.3 步骤

步骤一：创建bean

创建一个类ExampleBean，代码如下：


     
     
    
      
      
  1. package com.tarena.bean;
    2. 
      
      
  2. 
      
      
  3. import java.io.Serializable;
    4. 
      
      
  4. 
      
      
  5. public class ExampleBean implements Serializable {
    6. 
      
      
  6.     
    7. 
      
      
  7.     public ExampleBean() {
    8. 
      
      
  8.         System.out.println("实例化ExampleBean：" + this);
    9. 
      
      
  9.     }
    10. 
      
      
  10.     
    11. 
      
      
  11.     public void init() {
    12. 
      
      
  12.         System.out.println("初始化ExampleBean");
    13. 
      
      
  13.     }
    14. 
      
      
  14.     
    15. 
      
      
  15.     public void destroy() {
    16. 
      
      
  16.         System.out.println("销毁ExampleBean");
    17. 
      
      
  17.     }
    18. 
      
      
  18.     
    19. 
      
      
  19.     public void execute() {
    20. 
      
      
  20.         System.out.println("执行execute方法");
    21. 
      
      
  21.     }
    22. 
      
      
  22.     
    23. 
      
      
  23. }
    24.

步骤二：声明bean

在applicationContext.xml中声明这个bean，追加代码如下：


     
     
    
      
      
  1.     <!-- bean的生命周期 -->
    2. 
      
      
  2.     <!-- bean的延迟实例化 -->
    3. 
      
      
  3.     <bean id="exampleBean" class="com.tarena.bean.ExampleBean"
    4. 
      
      
  4.         init-method="init" destroy-method="destroy" />
    5.

步骤三：写测试代码

在TestCase中增加测试方法test4，追加代码如下：


     
     
    
      
      
  1.     /**
    2. 
      
      
  2.      * 1.bean的生命周期；
    3. 
      
      
  3.      * 2.bean的延迟实例化；
    4. 
      
      
  4.      */
    5. 
      
      
  5.     @Test
    6. 
      
      
  6.     public void test4() {
    7. 
      
      
  7.         String cfg = "applicationContext.xml";
    8. 
      
      
  8.         AbstractApplicationContext ctx = 
    9. 
      
      
  9.             new ClassPathXmlApplicationContext(cfg);
    10. 
      
      
  10.         System.out.println("----------------");
    11. 
      
      
  11.         ExampleBean bean = 
    12. 
      
      
  12.             ctx.getBean("exampleBean", ExampleBean.class);
    13. 
      
      
  13.         bean.execute();
    14. 
      
      
  14.         ctx.close();
    15. 
      
      
  15.     }
    16.

步骤四：执行测试

执行测试方法test4，效果如下图：

图-6

步骤五：修改声明的bean

修改applicationContext.xml中新声明的bean，修改代码如下：


     
     
    
      
      
  1.     <!-- bean的生命周期 -->
    2. 
      
      
  2.     <!-- bean的延迟实例化 -->
    3. 
      
      
  3.     <bean id="exampleBean" class="com.tarena.bean.ExampleBean"
    4. 
      
      
  4.         init-method="init" destroy-method="destroy" lazy-init="true"/>
    5.

步骤六：执行测试

再次执行test4方法，效果如下图所示：

图-7

4.4 完整代码

applicationContext.xml完整代码如下：

代码

TestCase完整代码如下：

代码

5 Setter注入

5.1 问题

本案例探讨如何使用setter注入的方式为bean注入值。

5.2 方案

通过setter注入的方式，为bean注入值。

5.3 步骤

步骤一：创建bean

创建计算机类Computer，代码如下：


     
     
    
      
      
  1. package com.tarena.bean;
    2. 
      
      
  2. 
      
      
  3. import java.io.Serializable;
    4. 
      
      
  4. 
      
      
  5. public class Computer implements Serializable {
    6. 
      
      
  6. 
      
      
  7.     private String mainboard; // 主板
    8. 
      
      
  8.     private String hdd; // 硬盘
    9. 
      
      
  9.     private String ram; // 内存
    10. 
      
      
  10. 
      
      
  11.     public String getMainboard() {
    12. 
      
      
  12.         return mainboard;
    13. 
      
      
  13.     }
    14. 
      
      
  14. 
      
      
  15.     public void setMainboard(String mainboard) {
    16. 
      
      
  16.         this.mainboard = mainboard;
    17. 
      
      
  17.     }
    18. 
      
      
  18. 
      
      
  19.     public String getHdd() {
    20. 
      
      
  20.         return hdd;
    21. 
      
      
  21.     }
    22. 
      
      
  22. 
      
      
  23.     public void setHdd(String hdd) {
    24. 
      
      
  24.         this.hdd = hdd;
    25. 
      
      
  25.     }
    26. 
      
      
  26. 
      
      
  27.     public String getRam() {
    28. 
      
      
  28.         return ram;
    29. 
      
      
  29.     }
    30. 
      
      
  30. 
      
      
  31.     public void setRam(String ram) {
    32. 
      
      
  32.         this.ram = ram;
    33. 
      
      
  33.     }
    34. 
      
      
  34. 
      
      
  35. }
    36.

步骤二：声明bean

在applicationContext.xml中声明这个bean，追加代码如下：


     
     
    
      
      
  1.     <!-- setter注入 -->
    2. 
      
      
  2.     <bean id="computer" class="com.tarena.bean.Computer">
    3. 
      
      
  3.         <property name="mainboard" value="技嘉"/>
    4. 
      
      
  4.         <property name="hdd" value="希捷"/>
    5. 
      
      
  5.         <property name="ram" value="金士顿"/>
    6. 
      
      
  6.     </bean>
    7.

步骤三：写测试代码

在TestCase中增加测试方法test5，追加代码如下：


     
     
    
      
      
  1.     /**
    2. 
      
      
  2.      * setter注入
    3. 
      
      
  3.      */
    4. 
      
      
  4.     @Test
    5. 
      
      
  5.     public void test5() throws SQLException {
    6. 
      
      
  6.         String cfg = "applicationContext.xml";
    7. 
      
      
  7.         AbstractApplicationContext ctx = 
    8. 
      
      
  8.             new ClassPathXmlApplicationContext(cfg);
    9. 
      
      
  9.         Computer computer = 
    10. 
      
      
  10.             ctx.getBean("computer", Computer.class);
    11. 
      
      
  11.         System.out.println(computer.getMainboard());
    12. 
      
      
  12.         System.out.println(computer.getHdd());
    13. 
      
      
  13.         System.out.println(computer.getRam());
    14. 
      
      
  14.     }
    15.

步骤四：执行测试

执行测试方法test5，效果如下图所示：

图-8

5.4 完整代码

Computer完整代码如下：

代码

applicationContext.xml完整代码如下：

代码

TestCase完整代码如下：

代码

6 构造器注入

6.1 问题

本案例探讨如何使用构造器注入的方式为bean注入值。

6.2 方案

通过构造器注入的方式，为bean注入值

6.3 步骤

步骤一：创建bean

创建一个手机类MobilePhone，代码如下：


     
     
    
      
      
  1. package com.tarena.bean;
    2. 
      
      
  2. 
      
      
  3. import java.io.Serializable;
    4. 
      
      
  4. 
      
      
  5. public class MobilePhone implements Serializable {
    6. 
      
      
  6. 
      
      
  7.     private String cpu;
    8. 
      
      
  8.     private String ram;
    9. 
      
      
  9. 
      
      
  10.     public MobilePhone(String cpu, String ram) {
    11. 
      
      
  11.         this.cpu = cpu;
    12. 
      
      
  12.         this.ram = ram;
    13. 
      
      
  13.     }
    14. 
      
      
  14. 
      
      
  15.     public String getCpu() {
    16. 
      
      
  16.         return cpu;
    17. 
      
      
  17.     }
    18. 
      
      
  18. 
      
      
  19.     public void setCpu(String cpu) {
    20. 
      
      
  20.         this.cpu = cpu;
    21. 
      
      
  21.     }
    22. 
      
      
  22. 
      
      
  23.     public String getRam() {
    24. 
      
      
  24.         return ram;
    25. 
      
      
  25.     }
    26. 
      
      
  26. 
      
      
  27.     public void setRam(String ram) {
    28. 
      
      
  28.         this.ram = ram;
    29. 
      
      
  29.     }
    30. 
      
      
  30. 
      
      
  31. }
    32.

步骤二：声明bean

在applicationContext.xml中声明这个bean，追加代码如下：


     
     
    
      
      
  1.     <!--构造器注入 -->
    2. 
      
      
  2.     <bean id="phone" class="com.tarena.bean.MobilePhone">
    3. 
      
      
  3.         <constructor-arg index="0" value="ARM"/>
    4. 
      
      
  4.         <constructor-arg index="1" value="2G"/>
    5. 
      
      
  5.     </bean>
    6.

步骤三：写测试代码

在TestCase中增加测试方法test6，追加代码如下：


     
     
    
      
      
  1.     /**
    2. 
      
      
  2.      * 构造器注入
    3. 
      
      
  3.      */
    4. 
      
      
  4.     @Test
    5. 
      
      
  5.     public void test6() throws SQLException {
    6. 
      
      
  6.         String cfg = "applicationContext.xml";
    7. 
      
      
  7.         AbstractApplicationContext ctx = 
    8. 
      
      
  8.             new ClassPathXmlApplicationContext(cfg);
    9. 
      
      
  9.         MobilePhone phone = 
    10. 
      
      
  10.             ctx.getBean("phone", MobilePhone.class);
    11. 
      
      
  11.         System.out.println(phone.getCpu());
    12. 
      
      
  12.         System.out.println(phone.getRam());
    13. 
      
      
  13.     }
    14.

步骤四：执行测试

执行测试方法test6，效果如下图：

图-9

6.4 完整代码

MobilePhone完整代码如下：

代码

applicationContext.xml完整代码如下：

代码

TestCase完整代码如下：

代码

7 自动装配

7.1 问题

通过Spring自动装配机制，自动为一个bean装配其关联的bean。

7.2 方案

采用autowire=”byType”，即按照bean的类型进行自动装配。

7.3 步骤

步骤一：创建bean

创建一个学生类Student，该类中有计算机、手机属性，即学生关联了计算机和手机，代码如下：


     
     
    
      
      
  1. package com.tarena.bean;
    2. 
      
      
  2. 
      
      
  3. import java.io.Serializable;
    4. 
      
      
  4. 
      
      
  5. public class Student implements Serializable {
    6. 
      
      
  6. 
      
      
  7.     private Computer computer;
    8. 
      
      
  8.     private MobilePhone mobilePhone;
    9. 
      
      
  9. 
      
      
  10.     public Computer getComputer() {
    11. 
      
      
  11.         return computer;
    12. 
      
      
  12.     }
    13. 
      
      
  13. 
      
      
  14.     public void setComputer(Computer computer) {
    15. 
      
      
  15.         this.computer = computer;
    16. 
      
      
  16.     }
    17. 
      
      
  17. 
      
      
  18.     public MobilePhone getMobilePhone() {
    19. 
      
      
  19.         return mobilePhone;
    20. 
      
      
  20.     }
    21. 
      
      
  21. 
      
      
  22.     public void setMobilePhone(MobilePhone mobilePhone) {
    23. 
      
      
  23.         this.mobilePhone = mobilePhone;
    24. 
      
      
  24.     }
    25. 
      
      
  25. 
      
      
  26. }
    27.

步骤二：声明bean

在applicationContext.xml中声明这个bean，并声明按类型自动装配其关联属性，追加代码如下：


     
     
    
      
      
  1.     <!--自动装配 -->
    2. 
      
      
  2.     <bean id="student" class="com.tarena.bean.Student" autowire="byType">
    3. 
      
      
  3.     </bean>
    4.

步骤三：写测试代码

在TestCase中增加测试方法test7，追加代码如下：


     
     
    
      
      
  1.     /**
    2. 
      
      
  2.      * 自动装配
    3. 
      
      
  3.      */
    4. 
      
      
  4.     @Test
    5. 
      
      
  5.     public void test7() throws SQLException {
    6. 
      
      
  6.         String cfg = "applicationContext.xml";
    7. 
      
      
  7.         AbstractApplicationContext ctx = 
    8. 
      
      
  8.             new ClassPathXmlApplicationContext(cfg);
    9. 
      
      
  9.         Student student = 
    10. 
      
      
  10.             ctx.getBean("student", Student.class);
    11. 
      
      
  11.         System.out.println(student.getComputer());
    12. 
      
      
  12.         System.out.println(student.getMobilePhone());
    13. 
      
      
  13.     }
    14.

步骤四：执行测试

执行测试方法test7，效果如下图：

图-10

7.4 完整代码

Student完整代码如下：

代码

applicationContext.xml完整代码如下：

代码

TestCase完整代码如下：

代码

猜你喜欢

转载自blog.csdn.net/magicianjun/article/details/78770879
今日推荐
《美国对全球网络空间安全与发展的威胁和破坏》报告发布
火速冲上 GitHub 热榜 —— 开源编程语言、框架哪有这么可爱？
北京人形机器人创新中心发布全球首个纯电驱拟人奔跑的全尺寸人形机器人“天工”
LFOSSA 源来如此公开课 | 掌握云原生未来：CNCF 认证全面攻略与备考秘籍
周排行
循环神经网络（rnn）讲解
Tigao教程四：单独的关节运动
金蝶K3WISE15.0-注册套打教程
如何在Mac上配置Kubernetes
Android应用结束自身进程的方法
SpringMVC学习 十三 拦截器栈
中国驻洛杉矶总领馆举行新春招待会
HttpClient get post 发送
11 - three.js 笔记 - 绘制三维字体模型
Mysql递归获取某个父节点下面的所有子节点和子节点上的所有父节点
每日归档
更多
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)
2024-04-27(56)
2024-04-26(39)
2024-04-25(22)
2024-04-24(36)
2024-04-23(26)
2024-04-22(39)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022