安科网

模拟spring框架，深入讲解spring的对象的创建

LeeEmmmm

LeeEmmmm

2019-07-01

关注 关注

导读

项目源码地址

因为公司使用的是spring框架，spring是什么？它就像包罗万象的容器，我们什么都可以往里面填，比如集合持久层的hibernate或mybatis框架，类似于拦截器的的shiro框架等等。

它的好处是可以自动创建对象。以前，在没有使用spring框架时，我们必须自己创建对象。但自从有了spring框架后，Java开发就像迎来了春天，一切都变的那么简单。

它有几种自动创建对象的方式，比如构造器创建对象，set创建对象。。。如果想要对其有更多的了解，那么，现在有很多博客，都对其做了详细的介绍。我在这里不必再做详解了。

本项目使用了logback和slf4j记录日志信息，因为它们两个是经常合作的。同时，也使用了lombok框架，这个框架可以自动生成set、get、toString、equals、hashcode方法等。

下面，便详细介绍我的这个项目。

设计模式

本项目采用工厂和建造者设计模式。

  • 工厂设计模式用来加载配置文件。

在没有使用注解的前提下，我们把所有的将要创建对象的信息写进配置文件中，这就是我们常说的依赖注入。而当代码加载时，需要加载这些配置文件。

这里需要两个类来支撑。一个是XmlConfigBean，记录每个xml文件中的bean信息。XmlBeanProperty这里记录每个bean中的属性信息。

加载文件方法中调用了这两个类，当然，我是用了org下的jdom来读取xml文件，正如以下代码所示。

/**
 * Created By zby on 22:57 2019/3/4
 * 加载配置文件
 *
 * @param dirPath 目录的路径
 */
public static LoadConfig loadXmlConFig(String dirPath) {
    if (StringUtils.isEmpty(dirPath)){
        throw new RuntimeException("路径不存在");
    }
    if (null == config) {
        File dir = new File(dirPath);
        List<File> files = FactoryBuilder.createFileFactory().listFile(dir);
        if (CollectionUtil.isEmpty(files)) {
            throw new RuntimeException("没有配置文件files=" + files);
        }
        allXmls = new HashMap<>();
        SAXBuilder saxBuilder = new SAXBuilder();
        Document document = null;
        for (File file : files) {
            try {
                Map<String, XmlConfigBean> beanMaps = new HashMap<>();
                //创建配置文件
                String configFileName = file.getName();
                document = saxBuilder.build(file);
                Element rootEle = document.getRootElement();
                List beans = rootEle.getChildren("bean");
                if (CollectionUtil.isNotEmpty(beans)) {
                    int i = 0;
                    for (Iterator beanIterator = beans.iterator(); beanIterator.hasNext(); i++) {
                        Element bean = (Element) beanIterator.next();
                        XmlConfigBean configBean = new XmlConfigBean();
                        configBean.setId(attributeToConfigBeanProps(file, i, bean, "id"));
                        configBean.setClazz(attributeToConfigBeanProps(file, i, bean, "class"));
                        configBean.setAutowire(attributeToConfigBeanProps(file, i, bean, "autowire"));
                        configBean.setConfigFileName(configFileName);
                        List properties = bean.getChildren();
                        Set<XmlBeanProperty> beanProperties = new LinkedHashSet<>();
                        if (CollectionUtil.isNotEmpty(properties)) {
                            int j = 0;
                            for (Iterator propertyIterator = properties.iterator(); propertyIterator.hasNext(); j++) {
                                Element property = (Element) propertyIterator.next();
                                XmlBeanProperty beanProperty = new XmlBeanProperty();
                                beanProperty.setName(attributeToBeanProperty(file, i, j, property, "name"));
                                beanProperty.setRef(attributeToBeanProperty(file, i, j, property, "ref"));
                                beanProperty.setValue(attributeToBeanProperty(file, i, j, property, "value"));
                                beanProperties.add(beanProperty);
                            }
                            configBean.setProperties(beanProperties);
                        }
                        beanMaps.put(configBean.getId(), configBean);
                    }
                }
                allXmls.put(configFileName, beanMaps);
            } catch (JDOMException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return new LoadConfig();
    }
    return config;
}

上面使用到了文件工厂设计模式，内部使用深度递归算法。如果初始目录下，仍旧有子目录，调用自身的方法，直到遇见文件，如代码所示：

/**
 * Created By zby on 14:04 2019/2/14
 * 获取文件的集合
 */
private void local(File dir) {
    if (dir == null) {
        logger.error("文件夹为空dir=" + dir);
        throw new RuntimeException("文件夹为空dir=" + dir);
    }
    File[] fies = dir.listFiles();
    if (ArrayUtil.isNotEmpty(fies)) {
        for (File fy : fies) {
            if (fy.isDirectory()) {
                local(fy);
            }
            String fileName = fy.getName();
            boolean isMatch = Pattern.compile(reg).matcher(fileName).matches();
            boolean isContains = ArrayUtil.containsAny(fileName, FilterConstants.FILE_NAMES);
            if (isMatch && !isContains) {
                fileList.add(fy);
            }
        }
    }
}
  • 建造者设计模式

这里用来修饰类信息的。比如，将类名的首字母转化为小写；通过类路径转化为类字面常量，如代码所示：

/**
 * Created By zby on 20:19 2019/2/16
 * 通过类路径转为类字面常量
 *
 * @param classPath 类路径
 */
public static <T> Class<T> classPathToClazz(String classPath) {
    if (StringUtils.isBlank(classPath)) {
        throw new RuntimeException("类路径不存在");
    }
    try {
        return (Class<T>) Class.forName(classPath);
    } catch (ClassNotFoundException e) {
        logger.error("路径" + classPath + "不存在,创建失败e=" + e);
        e.printStackTrace();
    }
    return null;
}

类型转换器

如果不是用户自定义的类型，我们需要使用类型转化器，将配置文件的数据转化为我们Javabean属性的值。因为，从配置文件读取过来的值，都是字符串类型的，加入Javabean的id为long型，因而，我们需要这个类型转换。

/**
 * Created By zby on 22:31 2019/2/25
 * 将bean文件中的value值转化为属性值
 */

public final class Transfomer {

    public final static Integer MAX_BYTE = 127;

    public final static Integer MIN_BYTE = -128;

    public final static Integer MAX_SHORT = 32767;

    public final static Integer MIN_SHORT = -32768;

    public final static String STR_TRUE = "true";

    public final static String STR_FALSE = "false";

    /**
     * Created By zby on 22:32 2019/2/25
     * 数据转化
     *
     * @param typeName 属性类型的名字
     * @param value    值
     */
    public static Object transformerPropertyValue(String typeName, Object value) throws IllegalAccessException {
        if (StringUtils.isBlank(typeName)) {
            throw new RuntimeException("属性的类型不能为空typeName+" + typeName);
        }
        if (typeName.equals(StandardBasicTypes.STRING)) {
            return objToString(value);
        } else if (typeName.equalsIgnoreCase(StandardBasicTypes.LONG)) {
            return stringToLong(objToString(value));
        } else if (typeName.equals(StandardBasicTypes.INTEGER) || typeName.equals(StandardBasicTypes.INT)) {
            return stringToInt(objToString(value));
        } else if (typeName.equalsIgnoreCase(StandardBasicTypes.BYTE)) {
            return stringToByte(objToString(value));
        } else if (typeName.equalsIgnoreCase(StandardBasicTypes.SHORT)) {
            return stringToShort(objToString(value));
        } else if (typeName.equalsIgnoreCase(StandardBasicTypes.BOOLEAN)) {
            return stringToBoolean(objToString(value));
        } else if (typeName.equalsIgnoreCase(StandardBasicTypes.DOUBLE)) {
            return stringToDouble(objToString(value));
        } else if (typeName.equalsIgnoreCase(StandardBasicTypes.FLOAT)) {
            return stringToFloat(objToString(value));
        } else if (typeName.equals(StandardBasicTypes.DATE)) {
            return stringToDate(objToString(value));
        } else if (typeName.equals(StandardBasicTypes.BIG_DECIMAL)) {
            return stringToBigDecimal(objToString(value));
        } else {
            return value;
        }
    }


    /**
     * Created By zby on 22:32 2019/2/25
     * 数据转化
     */
    public static void transformerPropertyValue(Object currentObj, Field field, Object value) throws IllegalAccessException {
        if (null == currentObj && field == null) {
            throw new RuntimeException("当前对象或属性为空值");
        }
        String typeName = field.getType().getSimpleName();
        field.setAccessible(true);
        field.set(currentObj, transformerPropertyValue(typeName, value));
    }

    /**
     * Created By zby on 23:29 2019/2/25
     * obj to String
     */
    public static String objToString(Object obj) {
        return null == obj ? null : obj.toString();
    }

    /**
     * Created By zby on 23:54 2019/2/25
     * String to integer
     */
    public static Integer stringToInt(String val) {
        if (StringUtils.isBlank(val)) {
            return 0;
        }
        if (val.charAt(0) == 0) {
            throw new RuntimeException("字符串转为整形失败val=" + val);
        }
        return Integer.valueOf(val);
    }

    /**
     * Created By zby on 23:31 2019/2/25
     * String to Long
     */
    public static Long stringToLong(String val) {
        return Long.valueOf(stringToInt(val));
    }

    /**
     * Created By zby on 23:52 2019/2/26
     * String to byte
     */
    public static Short stringToShort(String val) {
        Integer result = stringToInt(val);
        if (result >= MIN_SHORT && result <= MAX_SHORT) {
            return Short.valueOf(result.toString());
        }
        throw new RuntimeException("数据转化失败result=" + result);
    }

    /**
     * Created By zby on 0:03 2019/2/27
     * String to short
     */
    public static Byte stringToByte(String val) {
        Integer result = stringToInt(val);
        if (result >= MIN_BYTE && result <= MAX_BYTE) {
            return Byte.valueOf(result.toString());
        }
        throw new RuntimeException("数据转化失败result=" + result);
    }

    /**
     * Created By zby on 0:20 2019/2/27
     * string to double
     */
    public static Double stringToDouble(String val) {
        if (StringUtils.isBlank(val)) {
            throw new RuntimeException("数据为空，转换失败");
        }
        return Double.valueOf(val);
    }

    /**
     * Created By zby on 0:23 2019/2/27
     * string to float
     */
    public static Float stringToFloat(String val) {
        if (StringUtils.isBlank(val)) {
            throw new RuntimeException("数据为空，转换失败");
        }
        return Float.valueOf(val);
    }

    /**
     * Created By zby on 0:19 2019/2/27
     * string to boolean
     */
    public static boolean stringToBoolean(String val) {
        if (StringUtils.isBlank(val)) {
            throw new RuntimeException("数据为空，转换失败val=" + val);
        }
        if (val.equals(STR_TRUE)) {
            return true;
        }
        if (val.equals(STR_FALSE)) {
            return false;
        }
        byte result = stringToByte(val);
        if (0 == result) {
            return false;
        }
        if (1 == result) {
            return true;
        }
        throw new RuntimeException("数据转换失败val=" + val);
    }


    /**
     * Created By zby on 0:24 2019/2/27
     * string to Date
     */
    public static Date stringToDate(String val) {
        if (StringUtils.isBlank(val)) {
            throw new RuntimeException("数据为空，转换失败val=" + val);
        }
        SimpleDateFormat format = new SimpleDateFormat();
        try {
            return format.parse(val);
        } catch (ParseException e) {
            throw new RuntimeException("字符串转为时间失败val=" + val);
        }
    }

    /**
     * Created By zby on 0:31 2019/2/27
     * string to big decimal
     */
    public static BigDecimal stringToBigDecimal(String val) {
        if (StringUtils.isBlank(val)) {
            throw new RuntimeException("数据为空，转换失败val=" + val);
        }
        return new BigDecimal(stringToDouble(val));
    }

}

常量类型

  • 自动装配类型
/**
 * Created By zby on 13:50 2019/2/23
 * 装配类型
 */
public class AutowireType {
    
    /**
     * 缺省情况向，一般通过ref来自动（手动）装配对象
     */
    public static final String NONE = null;

    /**
     * 根据属性名事项自动装配，
     * 如果一个bean的名称和其他bean属性的名称是一样的，将会自装配它。
     */
    public static final String BY_NAME = "byName";

    /**
     * 根据类型来装配
     * 如果一个bean的数据类型是用其它bean属性的数据类型，兼容并自动装配它。
     */
    public static final String BY_TYPE = "byType";

    /**
     * 根据构造器constructor创建对象
     */
    public static final String CONSTRUCTOR = "constructor";

    /**
     * autodetect – 如果找到默认的构造函数，使用“自动装配用构造”; 否则，使用“按类型自动装配”。
     */
    public static final String AUTODETECT = "autodetect";
    
}
  • 属性类型常量池
/**
 * Created By zby on 22:44 2019/2/25
 * 类型常量池
 */
public class StandardBasicTypes {

    public static final String STRING = "String";

    public static final String LONG = "Long";

    public static final String INTEGER = "Integer";

    public static final String INT = "int";

    public static final String BYTE = "Byte";

    public static final String SHORT = "Short";

    public static final String BOOLEAN = "Boolean";

    public static final String DOUBLE = "double";

    public static final String FLOAT = "float";

    public static final String DATE = "Date";

    public static final String TIMESTAMP = "Timestamp";

    public static final String BIG_DECIMAL = "BigDecimal";

    public static final String BIG_INTEGER = "BigInteger";

}

getBean加载上下文文件

首先需要一个构造器，形参时文件的名字；getBean方法，形参是某个bean的id名字，这样，根据当前bean的自动装配类型，来调用相关的方法。

/**
 * Created By zby on 11:17 2019/2/14
 * 类的上下文加载顺序
 */
public class ClassPathXmlApplicationContext {

private static Logger logger = LoggerFactory.getLogger(ClassPathXmlApplicationContext.class.getName());

private String configXml;

public ClassPathXmlApplicationContext(String configXml) {
    this.configXml = configXml;
}

/**
 * Created By zby on 18:38 2019/2/24
 * bean对应的id的名称
 */
public Object getBean(String name) {
    String dirPath="../simulaspring/src/main/resources/";
    Map<String, Map<String, XmlConfigBean>> allXmls = LoadConfig.loadXmlConFig(dirPath).getAllXmls();
    boolean contaninsKey = MapUtil.findKey(allXmls, configXml);
    if (!contaninsKey) {
        throw new RuntimeException("配置文件不存在" + configXml);
    }
    Map<String, XmlConfigBean> beans = allXmls.get(configXml);
    contaninsKey = MapUtil.findKey(beans, name);
    if (!contaninsKey) {
        throw new RuntimeException("id为" + name + "bean不存在");
    }
    XmlConfigBean configFile = beans.get(name);
    if (null == configFile) {
        throw new RuntimeException("id为" + name + "bean不存在");
    }
    String classPath = configFile.getClazz();
    if (StringUtils.isBlank(classPath)) {
        throw new RuntimeException("id为" + name + "类型不存在");
    }
    String autowire = configFile.getAutowire();
    if (StringUtils.isBlank(autowire)) {
        return getBeanWithoutArgs(beans, classPath, configFile);
    } else {
        switch (autowire) {
            case AutowireType.BY_NAME:
                return getBeanByName(beans, classPath, configFile);
            case AutowireType.CONSTRUCTOR:
                return getBeanByConstruct(classPath, configFile);
            case AutowireType.AUTODETECT:
                return getByAutodetect(beans, classPath, configFile);
            case AutowireType.BY_TYPE:
                return getByType(beans, classPath, configFile);
        }
    }
    return null;
  }
}

下面主要讲解默认自动装配、属性自动装配、构造器自动装配

默认自动装配

如果我们没有填写自动装配的类型，其就采用ref来自动（手动）装配对象。

/**
 * Created By zby on 18:33 2019/2/24
 * 在没有设置自动装配时，通过ref对象
 */
private Object getBeanWithoutArgs(Map<String, XmlConfigBean> beans, String classPath, XmlConfigBean configFile) {
//属性名称
String proName = null;
try {
    Class currentClass = Class.forName(classPath);
    //通过引用 ref 创建对象
    Set<XmlBeanProperty> properties = configFile.getProperties();
    //如果没有属性，就返回，便于下面的递归操作
    if (CollectionUtil.isEmpty(properties)) {
        return currentClass.newInstance();
    }
    Class<?> superClass = currentClass.getSuperclass();
    //TODO 父类的集合
//            List<Class> superClasses = null;
    //在创建子类构造器之前，创建父类构造器，
    // 父类构造器的参数子类构造器的参数
    Object currentObj = null;
    //当前构造器
    Object consArgsObj = null;
    String consArgsName = null;
    boolean hasSuperClass = (null != superClass && !superClass.getSimpleName().equals("Object"));
    if (hasSuperClass) {
        Constructor[] constructors = currentClass.getDeclaredConstructors();
        ArrayUtil.validateArray(superClass, constructors);
        Parameter[] parameters = constructors[0].getParameters();
        if (parameters == null || parameters.length == 0) {
            consArgsObj = constructors[0].newInstance();
        } else {
            ArrayUtil.validateArray(superClass, parameters);
            consArgsName = parameters[0].getType().getSimpleName();
            //配置文件大类型,与参数构造器的类型是否相同
            for (XmlBeanProperty property : properties) {
                String ref = property.getRef();
                if (StringUtils.isNotBlank(ref) && ref.equalsIgnoreCase(consArgsName)) {
                    classPath = beans.get(ref).getClazz();
                    Class<?> clazz = Class.forName(classPath);
                    consArgsObj = clazz.newInstance();
                }
            }
            currentObj = constructors[0].newInstance(consArgsObj);
        }
    } else {
        currentObj = currentClass.newInstance();
    }
    for (XmlBeanProperty property : properties) {
        //这里适合用递归，无限调用自身
        //通过name找到属性，配置文件中是否有该属性，通过ref找到其对应的bean文件
        proName = property.getName();
        Field field = currentClass.getDeclaredField(proName);
        if (null != field) {
            String ref = property.getRef();
            Object value = property.getValue();
            //如果没有赋初值，就通过类型创建
            if (null == value && StringUtils.isNotBlank(ref)) {
                boolean flag = StringUtils.isNotBlank(consArgsName) && null != consArgsObj && consArgsName.equalsIgnoreCase(ref);
                //递归调用获取属性对象
                value = flag ? consArgsObj : getBean(ref);
            }
            field.setAccessible(true);
            Transfomer.transformerPropertyValue(currentObj, field, value);
        }
    }
    return currentObj;
} catch (ClassNotFoundException e) {
    logger.error("名为" + classPath + "类不存在");
    e.printStackTrace();
} catch (InstantiationException e) {
    e.printStackTrace();
} catch (IllegalAccessException e) {
    e.printStackTrace();
} catch (InvocationTargetException e) {
    e.printStackTrace();
} catch (NoSuchFieldException e) {
    logger.error(classPath + "类的属性" + proName + "不存在");
    throw new RuntimeException(classPath + "类的属性" + proName + "不存在");
}
return null;
}

构造器创建对象

根据构造器constructor创建对象

/**
 * Created By zby on 23:06 2019/3/2
 *
 * @param classPath  类路径
 * @param configFile 配置文件
 */
private Object getBeanByConstruct(String classPath, XmlConfigBean configFile) {
    try {
        Class currentClass = Class.forName(classPath);
        Set<XmlBeanProperty> properties = configFile.getProperties();
        if (CollectionUtil.isEmpty(properties)) {
            return currentClass.newInstance();
        }
        ///构造器参数类型和构造器对象集合
        Object[] objects = new Object[properties.size()];
        Class<?>[] paramType = new Class[properties.size()];
        Field[] fields = currentClass.getDeclaredFields();
        int i = 0;
        for (Iterator iterator = properties.iterator(); iterator.hasNext(); i++) {
            XmlBeanProperty property = (XmlBeanProperty) iterator.next();
            String proName = property.getName();
            String ref = property.getRef();
            Object value = property.getValue();
            for (Field field : fields) {
                Class<?> type = field.getType();
                String typeName = type.getSimpleName();
                String paramName = field.getName();
                if (paramName.equals(proName) && ObjectUtil.isNotNull(value) && StringUtils.isBlank(ref)) {
                    objects[i] = Transfomer.transformerPropertyValue(typeName, value);
                    paramType[i] = type;
                    break;
                } else if (paramName.equals(proName) && StringUtils.isNotBlank(ref) && ObjectUtil.isNull(value)) {
                    objects[i] = getBean(ref);
                    paramType[i] = type;
                    break;
                }
            }
        }
        return currentClass.getConstructor(paramType).newInstance(objects);
    } catch (ClassNotFoundException e) {
        logger.error("名为" + classPath + "类不存在");
        e.printStackTrace();
    } catch (InstantiationException e) {
        e.printStackTrace();
    } catch (IllegalAccessException e) {
        e.printStackTrace();
    } catch (InvocationTargetException e) {
        e.printStackTrace();
    } catch (NoSuchMethodException e) {
        e.printStackTrace();
    }
    return null;
}

属性自动装配

根据属性名事项自动装配，如果一个bean的名称和其他bean属性的名称是一样的，将会自装配它。

/**
 * Created By zby on 21:16 2019/3/1
 * 根据属性名事项自动装配，
 * @param classPath 类路径
 * @param configFile  配置文件
 */
private Object getBeanByName( String classPath, XmlConfigBean configFile) {
    String proName = null;
    try {
        Class currentClass = Class.forName(classPath);
        Class superclass = currentClass.getSuperclass();
        Method[] methods = currentClass.getDeclaredMethods();
        List<Method> methodList = MethodHelper.filterSetMethods(methods);
        Object currentObj = currentClass.newInstance();
        Set<XmlBeanProperty> properties = configFile.getProperties();
        //配置文件中，但是有父类，
        if (CollectionUtil.isEmpty(properties)) {
            boolean isExit = null != superclass && !superclass.getSimpleName().equals("Object");
            if (isExit) {
                Field[] parentFields = superclass.getDeclaredFields();
                if (ArrayUtil.isNotEmpty(parentFields)) {
                    if (CollectionUtil.isNotEmpty(methodList)) {
                        for (Field parentField : parentFields) {
                            for (Method method : methodList) {
                                if (MethodHelper.methodNameToProName(method.getName()).equals(parentField.getName())) {
                                    //如果有泛型的话
                                    Type genericType = currentClass.getGenericSuperclass();
                                    if (null != genericType) {
                                        String genericName = genericType.getTypeName();
                                        genericName = StringUtils.substring(genericName, genericName.indexOf("<") + 1, genericName.indexOf(">"));
                                        Class genericClass = Class.forName(genericName);
                                        method.setAccessible(true);
                                        method.invoke(currentObj, genericClass);
                                    }
                                    break;
                                }
                            }
                            break;
                        }
                    }
                }

            }
            return currentObj;
        }
        //传递给父级对象 service -- 》value
        List<Method> tmpList = new ArrayList<>();
        Map<String, Object> map = new HashMap<>();
        Object value = null;
        for (XmlBeanProperty property : properties) {
            proName = property.getName();
            if (ArrayUtil.isNotEmpty(methods)) {
                String ref = property.getRef();
                value = property.getValue();
                for (Method method : methodList) {
                    String methodName = MethodHelper.methodNameToProName(method.getName());
                    Field field = currentClass.getDeclaredField(methodName);
                    if (methodName.equals(proName) && null != field) {
                        if (null == value && StringUtils.isNotBlank(ref)) {
                            value = getBean(ref);
                        } else if (value != null && StringUtils.isBlank(ref)) {
                            value = Transfomer.transformerPropertyValue(field.getType().getSimpleName(), value);
                        }
                        method.setAccessible(true);
                        method.invoke(currentObj, value);
                        map.put(proName, value);
                        tmpList.add(method);
                        break;
                    }
                }
            }
        }
        tmpList = MethodHelper.removeMethod(methodList, tmpList);
        for (Method method : tmpList) {
            Class<?>[] type = method.getParameterTypes();
            if (ArrayUtil.isEmpty(type)) {
                throw new RuntimeException("传递给父级对象的参数为空type=" + type);
            }
            for (Class<?> aClass : type) {
                String superName = ClassHelper.classNameToProName(aClass.getSimpleName());
                value = map.get(superName);
                method.setAccessible(true);
                method.invoke(currentObj, value);
            }
        }
        return currentObj;
    } catch (ClassNotFoundException e) {
        logger.error("名为" + classPath + "类不存在");
        e.printStackTrace();
    } catch (InstantiationException e) {
        e.printStackTrace();
    } catch (IllegalAccessException e) {
        e.printStackTrace();
    } catch (InvocationTargetException e) {
        e.printStackTrace();
    } catch (NoSuchFieldException e) {
        logger.error("类" + classPath + "属性" + proName + "不存在");
        e.printStackTrace();
    }
    return null;
}

总结

这里没有使用注解，但我们也可以使用注解的方式实现自动装配，但这并不是spring的核心，应该是spring的美化，核心值如何实现自动装配。

spring框架 框架

LeeEmmmm

LeeEmmmm

0 关注 0 粉丝 0 动态

关注 关注

相关推荐

关于使用IDEA的springboot框架往Redis里写入数据乱码问题

解决方法：在你RedisUtil类里加入下图红框的的代码，

vapaad 2020-10-22

Spring Batch真是个优秀的批处理框架，用完爱不释手！

Spring Batch是一个轻量级的、完善的批处理框架，作为Spring体系中的一员，它拥有灵活、方便、生产可用的特点。在应对高效处理大量信息、定时处理大量数据等场景十分简便。结合调度框架能更大地发挥Spring Batch的作用。Batch Core核

smalllove 2020-11-03

Java开发人员必知的常用类库，这些你都知道吗？

作为一名程序员，我们要避免重复发明轮子，尽可能使用一些成熟、优秀、稳定的的第三方库，站在巨人的肩膀上搭建可靠、稳定的系统。Spring框架为现代基于Java的企业应用程序提供了一个全面的编程和配置模型，使用开发基于Java语言的应用更加简单、便捷。Spri

greensomnuss 2020-10-27

Java程序员不能错过的7个基本框架

现在IT开发人员面对的较大挑战就是复杂性，构建的应用越来越复杂。今天给大家列出Java程序员不能错过的7个基本框架，或许会对你有帮助哦。Hibernate是优秀的Java持久性框架，是一个开放源代码的对象关系映射框架，它对 JDBC 进行轻量级的对象封装，

feinifi 2020-10-14

摊牌了！我要手写一个“Spring Boot”

本文转载自微信公众号「JavaGuide」，作者Guide哥。我们经常会对自己早期写的代码感觉恶心，这是导致很多项目烂尾的很重要的一个原因之一。自己沉淀的知识更多，对于某个知识点的理解更加深刻。所以，最近几个月我一直抽空对 JavaGuide 上早期的一些

RickyIT 2020-09-27

最火热的极速开发框架Spring Boot-蛙课网

Spring Boot请添加链接描述是Spring家族中的一个全新的框架，它用来简化Spring应用程序的创建和开发过程，也可以说Spring Boot能简化我们之前采用Spring mvc + Spring + MyBatis 框架进行开发的过程；在以往

meleto 2020-08-17

不用 Spring Security 可否？试试这个小而美的安全框架

写在前面在一款应用的整个生命周期，我们都会谈及该应用的数据安全问题。用户的合法性与数据的可见性是数据安全中非常重要的一部分。但是，一方面，不同的应用对于数据的合法性和可见性要求的维度与粒度都有所区别；另一方面，以当前微服务、多服务的架构方式，如何共享Ses

MicroBoy 2020-08-02

事务_简单转账业务模拟mybatis、Spring框架

`account_name` varchar CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,) ENGINE = InnoDB AUTO_INCREMENT = 4 CHARACT

牧场SZShepherd 2020-07-20

Spring(1)：Spring介绍

Spring是一个开源框架，它由Rod Johnson创建；它是为了解决企业应用开发的复杂性而创建的。从大小与开销两方面而言Spring都是轻量的。完整的Spring框架可以在一个大小只有1MB多的JAR文件里发布。此外，Spring是非侵入式的：典型地，

容数据服务集结号 2020-07-19

一个90后女孩的第一个 Spring Boot 应用

本文转载自微信公众号「小明菜市场 」，作者小明菜市场。Spring Boot的出现，主要是用来解决 Spring 过去的一些问题，提出了约定优于配置的思想，默认对很多方法进行了设置，使得开发者可以快速的构建项目，集成第三方的内容。使得开发效率大大提升。S

与卿画眉共浮生 2020-11-13

详解 | Spring Boot 核心的 3 个注解详解

本文转载自微信公众号「小明菜市场」，作者小明菜市场 。Spring Boot 最大的特点是无需 XML 配置文件，能够实现自动装配，并进行全自动化的jar包配置。Spring Boot 是微服务的核心，其Spring Cloud 是基于Spring Bo

hellowordmonkey 2020-11-02

SpringBoot Web 应用源码解析：综合实战和整体总结

关于 Web 方面的配置比较多，值得庆幸的是，Spring Boot 已经帮我们预置初始化了很多基础组件。但在实践的过程中，某些基础的组件并不能满足我们的实际需求,这时就需要我们重新初始化相应组件，甚至在某些极端的情况下需要完全接管 Spring Boot

丽丽 2020-10-30

Spring和SpringBoot最核心的3大区别，详解！

对于 Spring和 SpringBoot到底有什么区别，我听到了很多答案，刚开始迈入学习 SpringBoot的我当时也是一头雾水，随着经验的积累、我慢慢理解了这两个框架到底有什么区别，相信对于用了 SpringBoot很久的同学来说，还不是很理解 Sp

周太郎 2020-10-28

Spring框架里注解@Autowired的工作原理

Suppose I have a bean named HelloWorld which has a member attribute points to another bean User.With annotation @Autowired, as l

职业炮灰 2020-10-16

一个快速找到Spring框架是在哪里找到XML配置文件并解析Beans定义的小技巧

The line 399 where exception is raised will be automatically located. The core logic to load xml file is just near the exception

与卿画眉共浮生 2020-10-14

Java开发人员应该学习的5个基本框架

Spring，Hibernate，Spring Boot，Spring Security和Spring Cloud是最重要的Java框架。Java开发人员，您好，如果您正在考虑应该学习哪种框架以成为完整的开发人员，那么您来对地方了。尽管有数十种Java框架

feinifi 2020-10-13

SpringBoot的设计理念和目标、整体架构你有深入了解吗

读者可根据日常习惯，选择熟悉的代码阅读 I 具，比如 Intellij IDEA、Spring Tool Suite、Eclipse、 MyEclipse 等。阅读 Spring Boot 源代码之前，我们还需搭建基础阅读环境。Spring Boot 对

yangjinpingc 2020-10-09

聊一下简易版的“Spring Boot”写的咋样了

昨天早上，6 点多一点就起来写代码了，前天晚上和朋友一起吃晚饭回来之后也搞到很晚，有时候想尽快把某些东西写完的时候确实是会这样。但是，说实话效率会降低很多，不推荐这样做。像我之前写guide-rpc-framework[1] 的时候，经常周末不出门，一坐

davis 2020-09-29

Spring Boot：企业常用的Starter以及实现

Spring Boot是由Pivotal团队提供的全新框架，其设计目的是用来简化新Spring应用的初始搭建以及开发过程。该框架使用了特定的方式来进行配置，从而使开发人员不再需要定义样板化的配置。通过这种方式，Boot致力于在蓬勃发展的快速应用开发领域成为

lisongchuang 2020-09-27

烂了大街的 Spring 循环依赖问题，你以为自己就真会了吗

初学 Spring 的时候，我们就知道 IOC，控制反转么，它将原本在程序中手动创建对象的控制权，交由 Spring 框架来管理，不需要我们手动去各种 new XXX。所谓的循环依赖是指，A 依赖 B，B 又依赖 A，它们之间形成了循环依赖。在 Spri

tangxiong0 2020-09-03
LeeEmmmm

LeeEmmmm

W3CSchool教程
HTML 教程
CSS 教程
Bootstrap 教程
Javascript 教程
jQuery 教程
后端教程
C 教程
Java 教程
PHP 教程
Python 教程
Go 教程
移动开发
Android 教程
Swift 教程
Kotlin 教程
jQuery Mobile 教程
ionic 教程
关于我们
新闻动态
联系方式
招聘英才
安科实验室
帮助与反馈

安科网(Ancii)，中国第一极客网

Copyright © 2013 - 2019 Ancii.com

京ICP备18063983号 京公网安备11010802014868号