千家信息网

请输入关键字词

热门搜索排行

最新搜索排行

导航： 首页 > 互联网科技 >

Spring Ioc中怎么加载Bean

发表于：2025-01-23 作者：千家信息网编辑
千家信息网最后更新 2025年01月23日，这篇文章将为大家详细讲解有关Spring Ioc中怎么加载Bean，文章内容质量较高，因此小编分享给大家做个参考，希望大家阅读完这篇文章后对相关知识有一定的了解。//真正实现向IOC容器获取Bean的
千家信息网最后更新 2025年01月23日Spring Ioc中怎么加载Bean

这篇文章将为大家详细讲解有关Spring Ioc中怎么加载Bean，文章内容质量较高，因此小编分享给大家做个参考，希望大家阅读完这篇文章后对相关知识有一定的了解。


//真正实现向IOC容器获取Bean的功能，也是触发依赖注入功能的地方        protected  T doGetBean(final String name, @Nullable final Class requiredType,                        @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {                //根据指定的名称获取被管理Bean的名称，剥离指定名称中对容器的相关依赖                // 如果指定的是别名，将别名转换为规范的Bean名称<1>               final String beanName = transformedBeanName(name);                Object bean;                // Eagerly check singleton cache for manually registered singletons.                // 从缓存中获取已被创建过的单例Bean<2>               Object sharedInstance = getSingleton(beanName);                //如果缓存中有                if (sharedInstance != null && args == null) {                        if (logger.isDebugEnabled()) {                                if (isSingletonCurrentlyInCreation(beanName)) {                                        logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +                                                        "' that is not fully initialized yet - a consequence of a circular reference");                                }                                else {                                        logger.debug("Returning cached instance of singleton bean '" + beanName + "'");                                }                        }                        //注意：BeanFactory是管理容器中Bean的工厂                        //     FactoryBean是创建创建对象的工厂Bean，两者之间有区别                        //获取给定Bean的实例对象，该对象要么是 bean 实例本身，要么就是 FactoryBean 创建的 Bean 对象                        //（为什么要再次获取呢，因为上面获取的sharedInstance不一定是完整的）<3>                       bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);                }                else {                        // Fail if we're already creating this bean instance:                        // We're assumably within a circular reference.                        // 因为 Spring 只解决单例模式下的循环依赖，在原型模式下如果存在循环依赖则会抛出异常。<4>                       if (isPrototypeCurrentlyInCreation(beanName)) {                                throw new BeanCurrentlyInCreationException(beanName);                        }                        // Check if bean definition exists in this factory.                        //对IOC容器中是否存在指定名称的BeanDefinition进行检查，首先检查是否                        //能在当前的BeanFactory中获取的所需要的Bean，如果不能则委托当前容器                        //的父级容器去查找，如果还是找不到则沿着容器的继承体系向父级容器查找                        BeanFactory parentBeanFactory = getParentBeanFactory();                        //当前容器的父级容器存在，且当前容器中不存在指定名称的Bean                        if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {                                // Not found -> check parent.                                //解析指定Bean名称的原始名称                                String nameToLookup = originalBeanName(name);                                // 若为 AbstractBeanFactory 类型，委托父类处理                                if (parentBeanFactory instanceof AbstractBeanFactory) {                                        return ((AbstractBeanFactory) parentBeanFactory).doGetBean(                                                        nameToLookup, requiredType, args, typeCheckOnly);                                }                                else if (args != null) {                                        // Delegation to parent with explicit args.                                        //委派父级容器根据指定名称和显式的参数查找                                        return (T) parentBeanFactory.getBean(nameToLookup, args);                                }                                else {                                        // No args -> delegate to standard getBean method.                                        //委派父级容器根据指定名称和类型查找                                        return parentBeanFactory.getBean(nameToLookup, requiredType);                                }                        }                        // 创建的Bean是否需要进行类型验证，一般不需要<5>                       if (!typeCheckOnly) {                                //向容器标记指定的Bean已经被创建                                markBeanAsCreated(beanName);                        }                        try {                                //从容器中获取 beanName 相应的 GenericBeanDefinition 对象，并将其转换为 RootBeanDefinition 对象                                // 主要解决Bean继承时子类合并父类公共属性问题<6>                               final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);                                // 检查给定的合并的 BeanDefinition (是否为抽象类)                                checkMergedBeanDefinition(mbd, beanName, args);                                // Guarantee initialization of beans that the current bean depends on.                                // 处理所依赖的 bean @DependsOn()                                // 获取当前Bean所有依赖Bean的名称<7>                               String[] dependsOn = mbd.getDependsOn();                                //如果有依赖                                if (dependsOn != null) {                                        for (String dep : dependsOn) {                                                //校验该依赖是否已经注册过给当前 Bean                                                if (isDependent(beanName, dep)) {                                                        //已注册，抛出异常                                                        throw new BeanCreationException(mbd.getResourceDescription(), beanName,                                                                        "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");                                                }                                                //没有，则先注册依赖的bean                                                registerDependentBean(dep, beanName);                                                //递归调用getBean()，先生成依赖的bean                                                getBean(dep);                                        }                                }                                // Create bean instance.                                //创建单例Bean<8>                               if (mbd.isSingleton()) {                                        //这里使用了一个匿名内部类，创建Bean实例对象，并且注册给所依赖的对象                                        sharedInstance = getSingleton(beanName, () -> {                                                try {                                                        //创建一个指定Bean实例对象，如果有父级继承，则合并子类和父类的定义                                                        return createBean(beanName, mbd, args);                                                }                                                catch (BeansException ex) {                                                        // Explicitly remove instance from singleton cache: It might have been put there                                                        // eagerly by the creation process, to allow for circular reference resolution.                                                        // Also remove any beans that received a temporary reference to the bean.                                                        //显式地从容器单例模式Bean缓存中清除实例对象                                                        destroySingleton(beanName);                                                        throw ex;                                                }                                        });                                        //获取给定Bean的实例对象                                        bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);                                }                                //创建多例Bean                                else if (mbd.isPrototype()) {                                        //原型模式(Prototype)是每次都会创建一个新的对象                                        Object prototypeInstance = null;                                        try {                                                //加载前置处理，默认的功能是注册当前创建的原型对象                                                beforePrototypeCreation(beanName);                                                //创建指定Bean对象实例                                                prototypeInstance = createBean(beanName, mbd, args);                                        }                                        finally {                                                //加载后置处理，默认的功能告诉IOC容器指定Bean的原型对象不再创建                                                afterPrototypeCreation(beanName);                                        }                                        //获取给定Bean的实例对象                                        bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);                                }                                //要创建的Bean既不是Singleton也不是Prototype                                //如：request、session、application等生命周期                                else {                                        String scopeName = mbd.getScope();                                        final Scope scope = this.scopes.get(scopeName);                                        //Bean定义资源中没有配置生命周期范围，则Bean定义不合法                                        if (scope == null) {                                                throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");                                        }                                        try {                                                //这里又使用了一个匿名内部类，获取一个指定生命周期范围的实例                                                Object scopedInstance = scope.get(beanName, () -> {                                                        //前置处理                                                        beforePrototypeCreation(beanName);                                                        try {                                                                return createBean(beanName, mbd, args);                                                        }                                                        finally {                                                                //后置处理                                                                afterPrototypeCreation(beanName);                                                        }                                                });                                                //获取给定Bean的实例对象                                                bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);                                        }                                        catch (IllegalStateException ex) {                                                throw new BeanCreationException(beanName,                                                                "Scope '" + scopeName + "' is not active for the current thread; consider " +                                                                "defining a scoped proxy for this bean if you intend to refer to it from a singleton",                                                                ex);                                        }                                }                        }                        catch (BeansException ex) {                                cleanupAfterBeanCreationFailure(beanName);                                throw ex;                        }                }                // Check if required type matches the type of the actual bean instance.                //对创建的Bean实例对象进行类型检查<9>               if (requiredType != null && !requiredType.isInstance(bean)) {                        try {                                T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);                                if (convertedBean == null) {                                        throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());                                }                                return convertedBean;                        }                        catch (TypeMismatchException ex) {                                if (logger.isDebugEnabled()) {                                        logger.debug("Failed to convert bean '" + name + "' to required type '" +                                                        ClassUtils.getQualifiedName(requiredType) + "'", ex);                                }                                throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());                        }                }                return (T) bean;        }

代码很长，需要一些耐心，下面我们来逐步分析这段代码：

  • <1>处：具体分析，见2.1获取原始beanName

  • <2>处: 具体分析，见2.2从缓存中获取单例bean

  • <3>处: 具体分析，见2.3获取最终的bean实例对象

  • <4>处: 具体分析，见2.4原型模式依赖检查(Prototype)和从 parentBeanFactory 获取 Bean

  • <5>处: 具体分析，见2.5标记bean为已创建或即将创建

  • <6>处: 具体分析，见2.6获取BeanDefinition

  • <7>处: 具体分析，见2.7bean依赖处理

  • <8>处: 具体分析，见2.8不同作用域bean的实例化

  • <9>处: 具体分析，见2.9类型转换

2.4、原型模式依赖检查(Prototype)和从 parentBeanFactory 获取 Bean

原型模式依赖检查，对应代码如下：

if (isPrototypeCurrentlyInCreation(beanName)) {        throw new BeanCurrentlyInCreationException(beanName);        }

跟踪进去：

        /** Names of beans that are currently in creation */        private final ThreadLocal prototypesCurrentlyInCreation =                        new NamedThreadLocal<>("Prototype beans currently in creation");protected boolean isPrototypeCurrentlyInCreation(String beanName) {                //从ThreadLocal中取出正在创建的prototype                Object curVal = this.prototypesCurrentlyInCreation.get();                return (curVal != null &&                                (curVal.equals(beanName) || (curVal instanceof Set && ((Set) curVal).contains(beanName))));        }
Spring 只处理单例模式下得循环依赖，对于原型模式的循环依赖直接抛出异常。
Spring会把正在创建的原型模式Bean存入ThreadLoacl，在这里通过ThreadLoacl来判断当前Bean是否已经创建。
从 parentBeanFactory 获取 Bean，对应代码如下：
// Check if bean definition exists in this factory.        //对IOC容器中是否存在指定名称的BeanDefinition进行检查，首先检查是否        //能在当前的BeanFactory中获取的所需要的Bean，如果不能则委托当前容器        //的父级容器去查找，如果还是找不到则沿着容器的继承体系向父级容器查找        BeanFactory parentBeanFactory = getParentBeanFactory();        //当前容器的父级容器存在，且当前容器中不存在指定名称的Bean        if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {                // Not found -> check parent.                //解析指定Bean名称的原始名称                String nameToLookup = originalBeanName(name);                // 若为 AbstractBeanFactory 类型，委托父类处理                if (parentBeanFactory instanceof AbstractBeanFactory) {                        return ((AbstractBeanFactory) parentBeanFactory).doGetBean(                                        nameToLookup, requiredType, args, typeCheckOnly);                }                else if (args != null) {                        // Delegation to parent with explicit args.                        //委派父级容器根据指定名称和显式的参数查找                        return (T) parentBeanFactory.getBean(nameToLookup, args);                }                else {                        // No args -> delegate to standard getBean method.                        //委派父级容器根据指定名称和类型查找                        return parentBeanFactory.getBean(nameToLookup, requiredType);                }        }
如果当前容器缓存中没有相对应的 BeanDefinition 对象，则会尝试从父类工厂（parentBeanFactory）中加载，然后再去递归调用 getBean(...) 方法
2.5、标记bean为已创建或即将创建
对应代码如下：
//创建的Bean是否需要进行类型验证，一般不需要                        if (!typeCheckOnly) {                                //向容器标记指定的Bean已经被创建                                markBeanAsCreated(beanName);                        }
typeCheckOnly是doGetBean(final String name, @Nullable final Class requiredType,@Nullable final Object[] args, boolean typeCheckOnly)方法中的一个参数，一般这个参数传的都是false
接着追踪markBeanAsCreated()方法：
protected void markBeanAsCreated(String beanName) {                // 没有创建                if (!this.alreadyCreated.contains(beanName)) {                        synchronized (this.mergedBeanDefinitions) {                                // 再次检查一次：DCL 双重校验                                if (!this.alreadyCreated.contains(beanName)) {                                        clearMergedBeanDefinition(beanName);                                        // 添加到已创建 bean 集合中                                        this.alreadyCreated.add(beanName);                                }                        }                }        }
这里用到了单例模式中耳熟能详的双重校验
2.6、获取BeanDefinition
对应代码如下：
        //从容器中获取 beanName 相应的 GenericBeanDefinition 对象，并将其转换为 RootBeanDefinition 对象        //主要解决Bean继承时子类合并父类公共属性问题        final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);        // 检查给定的合并的 BeanDefinition (是否为抽象类)        checkMergedBeanDefinition(mbd, beanName, args);
这段代码注释很详细，就不多解释了。
2.7、bean依赖处理
对应代码如下：
// Guarantee initialization of beans that the current bean depends on.        // 处理所依赖的 bean @DependsOn()        //获取当前Bean所有依赖Bean的名称<1>       String[] dependsOn = mbd.getDependsOn();        //如果有依赖        if (dependsOn != null) {                for (String dep : dependsOn) {                        //校验该依赖是否已经注册过给当前 Bean<2>                       if (isDependent(beanName, dep)) {                                //已注册，抛出异常                                throw new BeanCreationException(mbd.getResourceDescription(), beanName,                                                "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");                        }                        //没有，则先注册依赖的bean<3>                       registerDependentBean(dep, beanName);                        //递归调用getBean()，先生成依赖的bean<4>                       getBean(dep);                }        }
在spring中有一个@DependsOn注解，它的作用是依赖加载，比如A对象要在B对象加载之后才能加载，那么可以在A上面加@DependsOn(value = "B")注解，就可以达到我们的要求。
其实@DependsOn实现的原理就是上面这段代码。
  • <1>、通过我们前面从IoC容器中拿到的BeanDefinition，调用mbd.getDependsOn()方法，获取当前bean所有的依赖。
  • <2>、遍历这些依赖，判断此依赖是否已注册给当前的Bean
  • <3>、没有，则先注册依赖的Bean
  • <4>、递归调用getBean()，先生成依赖的bean
<2>、遍历这些依赖，判断此依赖是否已注册给当前的Bean
代码:
         // 保存的是bean与其依赖的映射关系：B - > A        private final Map> dependentBeanMap = new ConcurrentHashMap<>(64);        //保存的是bean与其依赖的映射关系：A - > B        private final Map> dependenciesForBeanMap = new ConcurrentHashMap<>(64);private boolean isDependent(String beanName, String dependentBeanName, @Nullable Set alreadySeen) {                if (alreadySeen != null && alreadySeen.contains(beanName)) {                        return false;                }                // 获取当前原始 beanName                String canonicalName = canonicalName(beanName);                // 获取该bean依赖的其他bean集合                Set dependentBeans = this.dependentBeanMap.get(canonicalName);                if (dependentBeans == null) {                        return false;                }                // 存在，则证明该依赖已经注册到bean中                if (dependentBeans.contains(dependentBeanName)) {                        return true;                }                // 递归检测依赖                for (String transitiveDependency : dependentBeans) {                        if (alreadySeen == null) {                                alreadySeen = new HashSet<>();                        }                        alreadySeen.add(beanName);                        if (isDependent(transitiveDependency, dependentBeanName, alreadySeen)) {                                return true;                        }                }                return false;        }
这段代码很简单，主要就是通过dependentBeanMap获取当前bean对应的所有依赖dependentBeans，然后判断是否已注册，接着递归检查依赖的Bean有没有依赖，如果有，就递归调用isDependent()检查
<3>、没有，则先注册依赖的Bean
如果没有注册依赖的Bean到该 Bean，则执行注册registerDependentBean(dep, beanName)：
 // 保存的是bean与其依赖的映射关系：B - > A        private final Map> dependentBeanMap = new ConcurrentHashMap<>(64);        //保存的是bean与其依赖的映射关系：A - > B        private final Map> dependenciesForBeanMap = new ConcurrentHashMap<>(64);//为指定的Bean注入依赖的Bean        public void registerDependentBean(String beanName, String dependentBeanName) {        // A quick check for an existing entry upfront, avoiding synchronization...        //获取原始beanName        String canonicalName = canonicalName(beanName);        Set dependentBeans = this.dependentBeanMap.get(canonicalName);        if (dependentBeans != null && dependentBeans.contains(dependentBeanName)) {                return;        }        // No entry yet -> fully synchronized manipulation of the dependentBeans Set        //先从容器中：bean名称-->全部依赖Bean名称集合找查找给定名称Bean的依赖Bean        synchronized (this.dependentBeanMap) {                //获取给定名称Bean的所有依赖Bean名称                dependentBeans = this.dependentBeanMap.get(canonicalName);                if (dependentBeans == null) {                        //为Bean设置依赖Bean信息                        dependentBeans = new LinkedHashSet<>(8);                        this.dependentBeanMap.put(canonicalName, dependentBeans);                }                //把映射关系存入集合                dependentBeans.add(dependentBeanName);        }        //从容器中：bean名称-->指定名称Bean的依赖Bean集合找查找给定名称Bean的依赖Bean        synchronized (this.dependenciesForBeanMap) {                Set dependenciesForBean = this.dependenciesForBeanMap.get(dependentBeanName);                if (dependenciesForBean == null) {                        dependenciesForBean = new LinkedHashSet<>(8);                        this.dependenciesForBeanMap.put(dependentBeanName, dependenciesForBean);                }                //把映射关系存入集合                dependenciesForBean.add(canonicalName);        }        }
套用上面的例子，如果 A @DependsOn(value = "B") ，也就是说A依赖于B，那么该方法registerDependentBean(dep, beanName)中，参数 dep 就是B，beanName 就是A。
这段代码中其实就是把bean之间的依赖关系注册到两个map中。
  • dependentBeanMap 存入(B,A)
  • dependenciesForBeanMap 存入(A,B)
<4>、递归调用getBean(dep)，先生成依赖的bean
到了这一步，递归调用getBean(beanName)方法也就是doGetBean(beanName)重走当前流程，来先实例化依赖的Bean。等依赖的Bean实例化之后，当前bean再接着往下执行。
2.8、不同作用域bean的实例化
代码：
        // Create bean instance.        //创建单例Bean        if (mbd.isSingleton()) {                //这里使用了一个匿名内部类，创建Bean实例对象，并且注册给所依赖的对象                sharedInstance = getSingleton(beanName, () -> {                        try {                                //创建一个指定Bean实例对象，如果有父级继承，则合并子类和父类的定义                                return createBean(beanName, mbd, args);                        }                        catch (BeansException ex) {                                // Explicitly remove instance from singleton cache: It might have been put there                                // eagerly by the creation process, to allow for circular reference resolution.                                // Also remove any beans that received a temporary reference to the bean.                                //显式地从容器单例模式Bean缓存中清除实例对象                                destroySingleton(beanName);                                throw ex;                        }                });                //获取给定Bean的实例对象                bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);        }        //创建多例Bean        else if (mbd.isPrototype()) {                //原型模式(Prototype)是每次都会创建一个新的对象                Object prototypeInstance = null;                try {                        //加载前置处理，默认的功能是注册当前创建的原型对象                        beforePrototypeCreation(beanName);                        //创建指定Bean对象实例                        prototypeInstance = createBean(beanName, mbd, args);                }                finally {                        //加载后置处理，默认的功能告诉IOC容器指定Bean的原型对象不再创建                        afterPrototypeCreation(beanName);                }                //获取给定Bean的实例对象                bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);        }        //要创建的Bean既不是Singleton也不是Prototype        //如：request、session、application等生命周期        else {                String scopeName = mbd.getScope();                final Scope scope = this.scopes.get(scopeName);                //Bean定义资源中没有配置生命周期范围，则Bean定义不合法                if (scope == null) {                        throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");                }                try {                        //这里又使用了一个匿名内部类，获取一个指定生命周期范围的实例                        Object scopedInstance = scope.get(beanName, () -> {                                //前置处理                                beforePrototypeCreation(beanName);                                try {                                        return createBean(beanName, mbd, args);                                }                                finally {                                        //后置处理                                        afterPrototypeCreation(beanName);                                }                        });                        //获取给定Bean的实例对象                        bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);                }                catch (IllegalStateException ex) {                        throw new BeanCreationException(beanName,                                        "Scope '" + scopeName + "' is not active for the current thread; consider " +                                        "defining a scoped proxy for this bean if you intend to refer to it from a singleton",                                        ex);                }        }
这段代码很明显，分成了3个部分：
  • singleton Bean实例化
  • Prototype Bean实例化
  • 其他类型 Bean 实例化(session,request等)
我们先来看singleton Bean实例化：
if (mbd.isSingleton()) {        //这里使用了一个匿名内部类，创建Bean实例对象，并且注册给所依赖的对象        sharedInstance = getSingleton(beanName, () -> {        try {                //创建一个指定Bean实例对象，如果有父级继承，则合并子类和父类的定义                return createBean(beanName, mbd, args);        }        catch (BeansException ex) {                // Explicitly remove instance from singleton cache: It might have been put there                // eagerly by the creation process, to allow for circular reference resolution.                // Also remove any beans that received a temporary reference to the bean.                //显式地从容器单例模式Bean缓存中清除实例对象                destroySingleton(beanName);                throw ex;        }        });        //获取给定Bean的实例对象        bean = getObjectForBeanInstance(sharedInstance, name,beanName, mbd);        }
Spring Bean 的作用域默认为 singleton 。还有其他作用域，如 prototype、request、session 等。
不同的作用域会有不同的初始化策略。
详见Spring Ioc 之 Bean的加载（三）：各个 scope 的 Bean 创建。
2.9、类型转换
代码：
// Check if required type matches the type of the actual bean instance.        //对创建的Bean实例对象进行类型检查        if (requiredType != null && !requiredType.isInstance(bean)) {        try {                //执行转换                T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);                // 转换失败，抛异常                if (convertedBean == null) {                        throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());                }                return convertedBean;        }        catch (TypeMismatchException ex) {                if (logger.isDebugEnabled()) {                        logger.debug("Failed to convert bean '" + name + "' to required type '" +                                        ClassUtils.getQualifiedName(requiredType) + "'", ex);                }                throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());        }        }        return (T) bean;
requiredType是 getBean() 方法可传入的一个参数，即可以根据指定的 beanName 和 requiredType 来获取Bean。
但是一般情况下是不需要类型检查的，requiredType一般为null，如getBean(beanName)
当requiredType不为null的时候走这段逻辑。
关于Spring Ioc中怎么加载Bean就分享到这里了，希望以上内容可以对大家有一定的帮助，可以学到更多知识。如果觉得文章不错，可以把它分享出去让更多的人看到。


        


        
 很赞哦！ 

        


        



        对象
            容器
            实例
            名称
            代码
            处理
            检查
            模式
            原型
            类型
            分析
            递归
            方法
            缓存
            作用
            功能
            参数
            周期
            就是
            生命
    
数据库的安全要保护哪些东西
数据库安全各自的含义是什么
生产安全数据库录入
数据库的安全性及管理
数据库安全策略包含哪些
海淀数据库安全审计系统
建立农村房屋安全信息数据库
易用的数据库客户端支持安全管理
连接数据库失败ssl安全错误
数据库的锁怎样保障安全

计算机二级数据库知识点介绍
数据库恢复综述是第几章
app软件开发预见风险
jquery 服务器请求
无线网络服务器
数据库项目经历怎么写
vps服务器安全软件
网络安全画像
宁夏建材网络安全
南明区有梦网络技术服务工作室
网络安全学习免费学
湖北工程软件开发平台
武汉东西湖区网络安全中心
软件开发流程实验报告
数据库工程师作用
服务器管理节点在哪
php表单查询数据库
全球船舶档案数据库
数据库aoc和aop
嘉定区管理软件开发定制价格
学生系统数据库设计
柳州软件开发定制
关于成立软件开发小组的通知
双路华南x79服务器功耗
服务器隔音降温箱
数媒专业和计算机网络技术
厦门收银软件开发
聊城想学网络技术
网络安全天幕系统
长沙app应用软件开发公司
        

        


        
        

        

          
        

      
    


    



    

      

        
相关文章

      

      
    






   





  



































0