spring 模拟构造注入

模拟构造注入

spring的注入方式主要有set注入和构造注入，本文将使用反射技术构造注入；

spring中构造注入

构造注入需配置如下的信息

<bean id = "userBean" class="com.xidu.spring.damain.User">
    <constructor-arg index="0" value="张三"/>
    <constructor-arg index="1" value="15"/>
</bean>

在配置中我们发现，需要配置序号和值。

反射模拟构造注入

下面是模拟构造注入的代码，采用了ArrayList集合模拟构造元素的模拟输入。

User.java

package com.xidu.reflect;

public class User {
    //public、private
    public String name;
    public int age;
    private String address;
    //无参构造
    public User() {
    }
    //有参构造
    public User(String name, int age, String address) {
        this.name = name;
        this.age = age;
        this.address = address;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }


    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }


    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", address='" + address + '\'' +
                '}';
    }
}

SetClassByConstruct.java

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Parameter;
import java.util.ArrayList;
import java.util.List;


public class SetClassByConstruct {
    public static void main(String[] args) {
        //反射将类的属性赋值
        //准备数据；
        List fieldValueList = new ArrayList();
        fieldValueList.add("李四");
        fieldValueList.add("15");
        fieldValueList.add("太阳系");
        //根据输入类，获得类名
        User user = new User();
        String className = user.getClass().toString().split(" ")[1];
        try {
            Class<?> aClass = Class.forName(className);
            //获得所有的构造
            Constructor<?>[] declaredConstructors = aClass.getDeclaredConstructors();
            //遍历构造
            for (Constructor<?> constructor : declaredConstructors) {
                //获得该构造中的实例变量属性
                Parameter[] parameters = constructor.getParameters();
                //考虑到存在不同的构造，当构造中类型和输入List中的数量相同的时候，创建对象，并赋值；
                if (parameters.length==fieldValueList.size()) {
                    //新建数组，用于存储
                    Object[] fieldValue = new Object[fieldValueList.size()];
                    for (int i = 0; i < parameters.length; i++) {
                        //获得第i个变量；
                        Parameter parameter = parameters[i];
                        //获得第i变量的类型；
                        String consFieldTypeName = parameter.getType().getSimpleName();
                        //根据变量类型修改fieldValueList的值的类型，并存储进去fieldValue；
                        fieldValue[i] = setValueByFiledType(consFieldTypeName, fieldValueList.get(i));
                    }
                    //新建属性类；
                    Object agency = constructor.newInstance(fieldValue);
                    //打印输出
                    System.out.println("有参构造对象--->"+agency);
                    break;
                }
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }
    /**
     * 根据属性类型，修改value类型
     * @param filedType
     * @param value
     */
    public static Object setValueByFiledType(String filedType,Object value){
        //byte int short long float double boolean char
        //Byte Integer Short Long Float Double Boolean Char
        //String
        if (filedType.equals("byte") || filedType.equals("Byte")) {
            value = Byte.parseByte(value.toString());
        }
        if (filedType.equals("int") || filedType.equals("Integer")) {
            value = Integer.parseInt(value.toString());
        }
        if (filedType.equals("short") || filedType.equals("Short")) {
            value = Short.parseShort(value.toString());
        }
        if (filedType.equals("long") || filedType.equals("Long")) {
            value = Long.parseLong(value.toString());
        }
        if (filedType.equals("float") || filedType.equals("Float")) {
            value = Float.parseFloat(value.toString());
        }
        if (filedType.equals("double") || filedType.equals("Double")) {
            value = Double.parseDouble(value.toString());
        }
        if (filedType.equals("boolean") || filedType.equals("Boolean")) {
            value = Boolean.parseBoolean(value.toString());
        }
        if (filedType.equals("char") || filedType.equals("Character")) {
            value = value.toString().charAt(0);
        }
        if (filedType.equals("String")) {
            value = value;
        }
        return value;
    }
}