一起写框架-Ioc内核容器的实现-对象的调用-方法注入容器的对象(十一)

实现功能

就是在方法的上面加入@Autowired注解，容器中的对象会注入到对应类型的参数。

注意：暂时实现注入一个对象。所有方法的参数列表的参数只能有一个。

实现思路

其实实现的思路和给字段注入的逻辑是一样的。遍历类所有的方法有没有@Autowired，有的就给它赋予容器中对应的对象。

实现步骤

1. 在AbstractApplicationContext类增加两个方法区分属性注入（autowiredField）和方法注入（autowiredMethod）

/**
     * 属性注入
     * @param object
     * @param context
     * @throws IllegalArgumentException
     * @throws IllegalAccessException
     */
    private void autowiredField(Object object,Context context) throws IllegalArgumentException, IllegalAccessException {
        // 5.获得对象的表结构
        Class<? extends Object> classType = object.getClass();
        // 6.获得字段的结构
        Field[] fields = classType.getDeclaredFields();
        for (int i = 0; i < fields.length; i++) {
            // autowired获得注解
            Autowired autowired = fields[i].getAnnotation(Autowired.class);
            if (autowired != null) {
                Class<?> fieldType = fields[i].getType();
                String fieldName = fields[i].getName();
                // 如果容器里面有对应的对象
                Object fieldObject = context.getObject(fieldType, fieldName);
                // 允许访问私有方法
                if (fieldObject != null) {
                    // 属性是私有的也可以访问
                    fields[i].setAccessible(true);
                    // 将属性值赋予这个对象的属性
                    fields[i].set(object, fieldObject);
                }

            }
        }
    }
    /**
     * 注意set方法的规范
     * 限定方法只能注入一个参数，并且注入对象的方法只能有一个参数
     * @param object
     * @param context
     * @throws IllegalArgumentException
     * @throws IllegalAccessException
     * @throws InvocationTargetException
     */
    private void autowiredMethod(Object object,Context context) throws IllegalArgumentException, IllegalAccessException, InvocationTargetException {
        // 5.获得对象的表结构
        Class<? extends Object> classType = object.getClass();
        // 6.获得类方法的结构
        Method[] methods = classType.getDeclaredMethods();
        for (int i = 0; i < methods.length; i++) {
            // autowired获得注解
            Autowired autowired = methods[i].getAnnotation(Autowired.class);
            if (autowired != null) {
                //获得参数列表的类型
                Class<?>[] parameterTypes = methods[i].getParameterTypes();
                
                String fieldName = methods[i].getName();
                
                // 如果容器里面有对应的对象，限定一个方法只能注入一个对象
                Object methodObject = context.getObject(parameterTypes[0], fieldName);
                // 允许访问私有方法
                if (methodObject != null) {
                    // 属性是私有的也可以访问
                    methods[i].setAccessible(true);
                    // 将属性值赋予这个对象的属性
                    methods[i].invoke(object, methodObject);
                }

            }
        }
    }

2.修改autowired方法的逻辑。将原来只遍历属性的@Autowired注解，修改为同时遍历属性和方法上面的的对象注入注解@Autowired

    /**
     * 给对象的属性注入关联的对象
     * @throws IllegalArgumentException
     * @throws IllegalAccessException
     * @throws InvocationTargetException 
     */
    private void autowired() throws IllegalArgumentException, IllegalAccessException, InvocationTargetException {
        // 1.获得容器
        Context context = contexts.get();
        // 2.获得容器中的所有对象。
        Map<String, Object> objects = context.getObjects();
        // 3.获得容器中所有的对象值
        Collection<Object> values = objects.values();
        // 4.获得对象的迭代器
        Iterator<Object> iterator = values.iterator();
        while (iterator.hasNext()) {
           Object object = iterator.next();
           //1.注入到属性
            this.autowiredField(object, context);
            //2.注入到方法
            this.autowiredMethod(object, context);
        }
    }

测试代码

测试目录结构

1.在UserServiceImpl类里面增加通过方法注入UserDAO的注解

package ioc.core.test.service.impl;

import ioc.core.annotation.Autowired;
import ioc.core.annotation.stereotype.Service;
import ioc.core.test.dao.UserDAO;
import ioc.core.test.service.UserService;

/**
 * 一个普通的类，用于测试是否可以创建对象
 * @author ranger
 *
 */
@Service
public class UserServiceImpl implements UserService {
    
    @Autowired
    private UserDAO userDAO;
    
    @Override
    public void login(){
        System.out.println("-登录Service-");
        userDAO.save();
    }

}

2.测试类调用UserController的对象

package ioc.core.test;

import org.junit.Test;

import ioc.core.impl.AnntationApplicationContext;
import ioc.core.test.config.Config;
import ioc.core.test.controller.UserController;

public class AnntationApplicationContextTest {
    
    @Test
    public void login(){
        try {
            AnntationApplicationContext context=new AnntationApplicationContext(Config.class);
             UserController userController = context.getBean("userController", UserController.class);
             userController.login();
            System.out.println(context.getContext().getObjects());
        
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

3.测试结果，同时可以调用UserController，UserServiceImpl，UserDAO对象。说明成功！