一块儿写框架-Ioc内核容器的实现-基础功能-getBean(五)

 

实现的功能

1. 启动程序时，将@ComponentScan加载的类，建立对象并放在容器里面。（查看上一篇文）

2. 经过ApplicatoinContext的getBean()方法得到容器里面的对象。

   （1）使用getBean（"对象名"）返回的对象都Object类型

   （2）使用getBean("对象名",<对象类型>)，返回指定类型的对象

思路说明

 

在上面的代码的基础上，在AbstractApplicationContext抽象类实现getBean的方法。经过getBean能够得到容器中的对象。

 

 

实现步骤

实现使用getBean（"对象名"）返回的对象都Object类型

 

1.在AbstractApplicationContext重写getBean方法

 

 1     /**
 2      * 实现从容器经过对象名，得到对象
 3      */
 4     @Override
 5     public Object getBean(String objectName) {
 6         //1.得到容器中的全部对象
 7         Map<String, Object> objects = this.getContext().getObjects();
 8         //2.经过Key得到容器中的对象
 9         Object object = objects.get(objectName);
10         //3.若是对象不为空，返回对象
11         if(object!=null){
12             return object;
13         }
14         return null;
15     }

 

 

测试代码

1.测试对象UserService类代码

package ioc.core.test.service;

/**
 * 一个普通的类，用于测试是否能够建立对象
 * @author ranger
 *
 */
public class UserService {
    
    public void login(){
        System.out.println("-登陆-");
    }
}

 

2.经过getBean得到容器中的UserService对象

 

 1 package ioc.core.test;
 2 
 3 import org.junit.Test;
 4 
 5 import ioc.core.impl.AnntationApplicationContext;
 6 import ioc.core.test.config.Config;
 7 import ioc.core.test.service.UserService;
 8 
 9 public class AnntationApplicationContextTest {
10     
11     @Test
12     public void login(){
13         try {
14             AnntationApplicationContext context=new AnntationApplicationContext(Config.class);
15             //若是能够打印出容器里面的对象，说明成功
16             UserService userService = (UserService) context.getBean("UserService");
17             //若是能够调用login方法，说明成功。
18             userService.login();
19         } catch (Exception e) {
20             e.printStackTrace();
21         }
22     }
23 
24 }

测试结果

 

实现使用getBean("对象名",<对象类型>)，返回指定类型的对象

 

1.在ApplicationContext接口增长一个getBean的重载方法

 

 1 package ioc.core;
 2 
 3 /**
 4  * Ioc框架的容器操做接口
 5  * @author ranger
 6  *
 7  */
 8 public interface ApplicationContext {
 9     /**
10      * 经过容器里面的对象名，返回容器中的对象
11      * @param objectName
12      * @return
13      */
14     Object getBean(String objectName);
15     
16     /**
17      * 经过容器里面的对象名，返回容器中的对象,指定返回类型
18      * @param objectName
19      * @param className
20      * @return
21      */
22     <T> T getBean(String objectName,Class<T> className);
23 
24 }

 

2.AbstractApplicationContext类实现该方法

 

 1     @Override
 2     public <T> T getBean(String objectName, Class<T> className) {
 3         //1.得到容器中的全部对象
 4         Map<String, Object> objects = this.getContext().getObjects();
 5         //2.经过Key得到容器中的对象
 6         Object object = objects.get(objectName);
 7         //3.若是对象不为空，,判断对象是否与传入的类类型的父接口或类类型兼容，返回对象
 8         if(object!=null&&className.isAssignableFrom(object.getClass())){
 9             return (T) object;
10         }
11         return null;
12     }

 

测试代码

--根据传入的类型，直接返回指定的类型，不用强制转换

package ioc.core.test;

import org.junit.Test;

import ioc.core.impl.AnntationApplicationContext;
import ioc.core.test.config.Config;
import ioc.core.test.service.UserService;

public class AnntationApplicationContextTest {
    @Test
    public void login(){
        try {
            AnntationApplicationContext context=new AnntationApplicationContext(Config.class);
            //若是能够打印出容器里面的对象，说明成功
            UserService userService = context.getBean("UserService", UserService.class);
            userService.login();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}