01 Spring IoC 依赖查找

SpringUtils工具类(getBean()) 代码】SpringUtils工具类(getBean()) 阅读详情

1、根据Bean名称查找

(1)创建实例类

package org.binsoft.thinking.in.spring.ioc.overview.domain;

/**
 * TODO
 *
 * @author Administrator
 * @version 1.0
 * @date 2021/1/1 12:05
 */
public class User {

    private Long id;
    private String name;


    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

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

(2)在类路径下的resources创建目录 META-INF,并创建spring的xml配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="user" class="org.binsoft.thinking.in.spring.ioc.overview.domain.User">
        <property name="id" value="1"/>
        <property name="name" value="彬少"/>
    </bean>
</beans>

(3)根据名称实时查找

beanFactory.getBean

package org.binsoft.thinking.in.spring.ioc.overview.dependency.lookup;

import org.binsoft.thinking.in.spring.ioc.overview.annotation.Super;
import org.binsoft.thinking.in.spring.ioc.overview.domain.User;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.ListableBeanFactory;
import org.springframework.beans.factory.ObjectFactory;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.util.Map;

/**
 * 依赖查找实例
 * 1. 通过名称的方式来查找
 *
 * @author binsoft
 * @version 1.0
 * @date 2021/1/1 11:53
 */
public class DependencyLookupDemo {
    public static void main(String[] args) {
        // 配置 XML 配置文件
        // 启动 Spring 应用上下文
        BeanFactory beanFactory = new ClassPathXmlApplicationContext("classpath:/META-INF/dependency-lookup-context.xml");
        lookupInRealTime(beanFactory);

    }

    private static void lookupInRealTime(BeanFactory beanFactory) {
        User user = (User) beanFactory.getBean("user");
        System.out.println("实时查找:" + user);
    }
}

(4)根据名称延迟查找

主要通过ObjectFactory接口实现:

 

主要实现的FactoryBean为:

org.springframework.beans.factory.config.ObjectFactoryCreatingFactoryBean

通过源码分析,此类有两个重要的地方:

  • 目标Bean名称,需要外部进行配置指定

   @Nullable
	private String targetBeanName;

实现ObjectFactory接口的私有静态内部类TargetBeanObjectFactory,代理BeanFactory来进行Bean实例的查找:

/**
 * Independent inner class - for serialization purposes.
 */
@SuppressWarnings("serial")
private static class TargetBeanObjectFactory implements ObjectFactory<Object>, Serializable {

   private final BeanFactory beanFactory;

   private final String targetBeanName;

   public TargetBeanObjectFactory(BeanFactory beanFactory, String targetBeanName) {
      this.beanFactory = beanFactory;
      this.targetBeanName = targetBeanName;
   }

   @Override
   public Object getObject() throws BeansException {
      return this.beanFactory.getBean(this.targetBeanName);
   }
}

在配置文件中,对ObjectFactoryCreatingFactoryBean进行配置:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="user" class="org.binsoft.thinking.in.spring.ioc.overview.domain.User">
        <property name="id" value="1"/>
        <property name="name" value="彬少"/>
    </bean>

    <bean id="objectFactory" class="org.springframework.beans.factory.config.ObjectFactoryCreatingFactoryBean">
        <property name="targetBeanName" value="user"/>
    </bean>

</beans>

 

通过ObjectFactory的 T getObject() throws BeansException; 方法来查找Bean实例。

package org.binsoft.thinking.in.spring.ioc.overview.dependency.lookup;

import org.binsoft.thinking.in.spring.ioc.overview.annotation.Super;
import org.binsoft.thinking.in.spring.ioc.overview.domain.User;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.ListableBeanFactory;
import org.springframework.beans.factory.ObjectFactory;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.util.Map;

/**
 * 依赖查找实例
 * 1. 通过名称的方式来查找
 *
 * @author binsoft
 * @version 1.0
 * @date 2021/1/1 11:53
 */
public class DependencyLookupDemo {
    public static void main(String[] args) {
        // 配置 XML 配置文件
        // 启动 Spring 应用上下文
        BeanFactory beanFactory = new ClassPathXmlApplicationContext("classpath:/META-INF/dependency-lookup-context.xml");
        lookupInLazy(beanFactory);
    }

    private static void lookupInLazy(BeanFactory beanFactory) {
        ObjectFactory<User> objectFactory = (ObjectFactory<User>) beanFactory.getBean("objectFactory");
        User user = objectFactory.getObject();
        System.out.println("延迟查找:" + user);
    }


}

 

从此过程中,可以看出, ObjectFactory 对象并不是直接返回了实际的Bean,而是一个Bean的查找代理。当得到ObjectFactory对象时,相当于Bean没有被创建,只有当调用getObject()方法时,才会触发Bean实例化等生命周期 。

 

2、根据Bean类型查找

(1)单个Bean对象

主要通过BeanFactory的

<T> T getBean(Class<T> requiredType) throws BeansException;

方法来实现,因为涉及到泛型,因此要求Spring的版本为3.0及以上:

并通过注释,可以看出,需要利用ListableBeanFactory:

package org.binsoft.thinking.in.spring.ioc.overview.dependency.lookup;

import org.binsoft.thinking.in.spring.ioc.overview.annotation.Super;
import org.binsoft.thinking.in.spring.ioc.overview.domain.User;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.ListableBeanFactory;
import org.springframework.beans.factory.ObjectFactory;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.util.Map;

/**
 * 依赖查找实例
 * 1. 通过名称的方式来查找
 *
 * @author binsoft
 * @version 1.0
 * @date 2021/1/1 11:53
 */
public class DependencyLookupDemo {
    public static void main(String[] args) {
        // 配置 XML 配置文件
        // 启动 Spring 应用上下文
        BeanFactory beanFactory = new ClassPathXmlApplicationContext("classpath:/META-INF/dependency-lookup-context.xml");
        //按照类型查找
        lookupByType(beanFactory);
    }

    private static void lookupByType(BeanFactory beanFactory) {
        User user = beanFactory.getBean(User.class);
        System.out.println("实时查找:" + user);
    }

}

 

(2)集合Bean对象

主要通过ListableBeanFactory接口的

<T> Map<String, T> getBeansOfType(@Nullable Class<T> type) throws BeansException;

方法

package org.binsoft.thinking.in.spring.ioc.overview.dependency.lookup;

import org.binsoft.thinking.in.spring.ioc.overview.annotation.Super;
import org.binsoft.thinking.in.spring.ioc.overview.domain.User;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.ListableBeanFactory;
import org.springframework.beans.factory.ObjectFactory;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.util.Map;

/**
 * 依赖查找实例
 * 1. 通过名称的方式来查找
 *
 * @author binsoft
 * @version 1.0
 * @date 2021/1/1 11:53
 */
public class DependencyLookupDemo {
    public static void main(String[] args) {
        // 配置 XML 配置文件
        // 启动 Spring 应用上下文
        BeanFactory beanFactory = new ClassPathXmlApplicationContext("classpath:/META-INF/dependency-lookup-context.xml");
        //按照类型查找集合对象
        lookupCollectionByType(beanFactory);
    }

    private static void lookupCollectionByType(BeanFactory beanFactory) {
        if (beanFactory instanceof ListableBeanFactory) {
            ListableBeanFactory listableBeanfactory = (ListableBeanFactory) beanFactory;
            Map<String, User> users = listableBeanfactory.getBeansOfType(User.class);
            System.out.println("查找到的所有的 User 集合对象:" + users);
        }
    }



}

 

3、根据Bean名称+类型查找

主要通过BeanFactory接口的

<T> T getBean(String name, Class<T> requiredType) throws BeansException;

方法来实现,最主要的一点是,此方法会进行一定程度的类型安全检查:会抛出异常:BeanNotOfRequiredTypeException

 

4、根据Java注解查找

主要通过ListableBeanFactory接口的

Map<String, Object> getBeansWithAnnotation(Class<? extends Annotation> annotationType) throws BeansException;

方法来实现:

(1)创建一个注解Super

package org.binsoft.thinking.in.spring.ioc.overview.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Super {
}

 

(2)创建SuperUser对象并继承自User,并为Super对象标注注解@Super

package org.binsoft.thinking.in.spring.ioc.overview.domain;

import org.binsoft.thinking.in.spring.ioc.overview.annotation.Super;

/**
 * TODO
 *
 * @author Administrator
 * @version 1.0
 * @date 2021/1/1 13:14
 */

@Super
public class SuperUser extends User {

    private String address;

    public String getAddress() {
        return address;
    }

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

    @Override
    public String toString() {
        return "SuperUser{" +
                "address='" + address + '\'' +
                "} " + super.toString();
    }
}

 

(3)通过Spring XML文件配置Super对象,并指定属性:parent="user"和 primary="true"

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="user" class="org.binsoft.thinking.in.spring.ioc.overview.domain.User">
        <property name="id" value="1"/>
        <property name="name" value="彬少"/>
    </bean>

    <bean id="superUser" class="org.binsoft.thinking.in.spring.ioc.overview.domain.SuperUser" parent="user"
          primary="true">
        <property name="address" value="北京"/>
    </bean>

    <bean id="objectFactory" class="org.springframework.beans.factory.config.ObjectFactoryCreatingFactoryBean">
        <property name="targetBeanName" value="user"/>
    </bean>

</beans>

 

(4)通过getBeansWithAnnotation方法类查找:

package org.binsoft.thinking.in.spring.ioc.overview.dependency.lookup;

import org.binsoft.thinking.in.spring.ioc.overview.annotation.Super;
import org.binsoft.thinking.in.spring.ioc.overview.domain.User;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.ListableBeanFactory;
import org.springframework.beans.factory.ObjectFactory;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.util.Map;

/**
 * 依赖查找实例
 * 1. 通过名称的方式来查找
 *
 * @author binsoft
 * @version 1.0
 * @date 2021/1/1 11:53
 */
public class DependencyLookupDemo {
    public static void main(String[] args) {
        // 配置 XML 配置文件
        // 启动 Spring 应用上下文
        BeanFactory beanFactory = new ClassPathXmlApplicationContext("classpath:/META-INF/dependency-lookup-context.xml");
        //按照注解查找
        lookupByAnnotationType(beanFactory);
    }

    private static void lookupByAnnotationType(BeanFactory beanFactory) {
        if (beanFactory instanceof ListableBeanFactory) {
            ListableBeanFactory listableBeanFactory = (ListableBeanFactory) beanFactory;
            Map<String, Object> users = listableBeanFactory.getBeansWithAnnotation(Super.class);
            System.out.println("查找标注 @Super 的所有User集合对象:" + users);

        }
    }


}

 

机器人中的数值优化(十三)——QP二次规划 本系列文章主要是我在学习《数值优化》过程中的一些笔记和相关思考,主要的学习资料是深蓝学院的课程《机器人中的数值优化》和高立编著的《数值最优化方法》等,本系列文章篇数较多,不定期更新,上半部分介绍无约束优化,下半部分介绍带约束的优化,中间会穿插一些路径规划方面的应用实例 阅读详情

相关推荐

黑金ZYNQ7010开发板开箱实测:从接线到串口通信的保姆级指南

本文提供黑金ZYNQ7010开发板从开箱到串口通信的完整实操指南。详细介绍了硬件连接、驱动安装、启动模式设置及串口终端配置等关键步骤,并针对常见问题提供排查思路,帮助FPGA开发者快速上手ZYNQ平台,建立稳定的调试通道。

weixin_29266749的博客 467

spring中getBeansWithAnnotation(Class<? extends Annotation> annotationType)方法

spring中可以通过getBeansWithAnnotation来获取ioc容器中使用了某个注解的所有bean,这个方法底层原理:我们知道可以通过反射来获取一个类中所有的注解,然后通过遍历spring容器中所有bean就能获取需要的结果。 //自定义@Auditable注解 package com.yk.annotation; import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import ja

yks的博客 7491

android广告SDK原理详解(附源码)

广大的开发者吃糠咽菜开发了一两款APP,获取了一些流量后自然就会想到流量变现,一般情况下大家会选择到百度联盟或者Google Admob这些广告服务提供商注册开发者账号,在自己的APP里面加上几行广告位代码,集成他们的广告SDK包。然后谋事在人,成事在天,只有每天看报表查查收益。   也有一些开发者为了能够提高自己的变现水平,同时接入了好几家的sdk,哪家出的收益高一点我就出哪家的广告,但是这

rmcgogo的博客 1万+

关于Spring的两三事:神奇的注解

在之前的学习中我们介绍了注解实际上起到的是标记和注释的作用,其本身并不提供任何的逻辑处理能力。也就是说如果想让注解能够实现预期的作用,就必须给注解搭配一个能够读取并处理该注解的方法,这里为了方便描述我将这样一个方法定义为注解处理器。基于这样一个认知,我们学习的重心就需要放在理解Spring中不同注解的注解处理器是如何生效的以及Spring提供了哪些自定义注解处理器实现的扩展点上面。

BASK2311的博客 1034

Outlook日历同步全攻略:Win10+安卓+iOS三端无缝衔接(附常见问题解决)

本文提供了一份详尽的Outlook日历同步指南,帮助用户在Windows 10、安卓和iOS三端实现无缝衔接。文章深入解析了Exchange ActiveSync等核心同步原理,并给出了从账户创建到各设备(特别是华为手机)的具体配置步骤、进阶管理技巧以及针对同步失败、事件重复等常见问题的实战解决方案,旨在彻底解决跨平台日程管理的痛点。

l3m4n的博客 557

高效爬取懂车帝车型数据:从静态解析到动态反爬实战

本文详细解析了如何高效爬取懂车帝车型数据,从静态HTML解析到动态接口反爬的完整实战路径。文章重点介绍了使用浏览器开发者工具定位数据、应对CSS混淆与参数加密等反爬策略,并提供了整合静态与动态抓取逻辑的Python代码示例,帮助开发者稳健地获取结构化车型信息。

wind6的博客 938

applicationContext.getBeansWithAnnotation();

ApplicationContext 应用上下文getBeansWithAnnotation()根据注解类型获取的对应的 bean名称 和 bean对象 /** * 找到所有具有提供的{@link Annotation}类型的{@code Class}的bean,返回具有相应bean实例的bean名称映射。 */ Map<String, Object> getBean...

Pazz 1万+

Python深度学习基于Tensorflow(17)基于Transformer的图像处理实例VIT和Swin-T

定义窗口注意力机制,与普通的注意力机制不同,其是在各个窗口中执行注意力机制。从中可以看到,其创新点主要是将图片进行拆分作为序列数据带入。差不多,主要实现的是一个下采样的算法过程;相同位置的像素绑定到一起构成一张新的。模型定义完毕后,初始化模型并开始训练。由于层之间重复性出现,可以定义一个。中,这里先实现拆分图片类。进行操作时我们定义三个类。定义一个多头注意力机制类。的数据,导入数据如下。导入数据,这里同样用。

bigcrab的博客 1636

Spring中如何获取Bean方法上的自定义注解

Spring中获取Bean方法上的自定义注解引发的一些思考

徐小陌的博客 5400

WblockCloneObjects克隆一个图纸内的实体包括块参照,同名块参照的处理

public static void HeBingTu2(double lieJu, List<string> filePaths) { Document doc = Application.DocumentManager.MdiActiveDocument; Database db = doc.Database; using (DocumentLock docLock = doc.Lock...

1108

华为OD技术面八股_C++_05

汇总华为OD技术面C++方向技术面八股文,提供详细解答。

qq_45776114的博客 413

Spring系列-01-IOC的依赖查找和依赖注入

假定现在有一下需求, 开始使用的数据源是MySQL, 后续数据源变动为Oracle, 那么我们的代码就需要改动每次切数据源都需要改动, 那么进行优化。

weixin_51918722的博客 1097

5、模糊风险评估

本文介绍了基于模糊逻辑的风险评估方法,探讨了如何在不确定、不完整信息环境下进行高效的风险分析。文章涵盖了模糊集合与隶属度函数的基本概念、模糊推理系统的流程,并结合犯罪风险、金融风险和医疗诊断等实际案例,展示了模糊风险评估的应用价值和技术细节。此外,还介绍了模糊贝叶斯网络、模糊综合评价等进阶工具与方法,为多领域风险管理提供了理论支持和实践指导。

mango的博客 183

Spring 01:IoC、Bean与依赖注入

从Spring开始重新了解SpringBoot,关于IoC、Bean与依赖注入

dfraetaem的博客 1948

RU DOS版、EFI版32bit/64bit BIOS常用工具

DOS版、EFI版的RU工具,可用来查看IO、MEM、PCI、SMBIOS等资源。亲测在EFI SHELL下可用。

大中型超市收银系统(可直接运行)

光步前台收银系统系统功能:商品销售、商品退货、挂单、收银员权限、会员销售、单品取消、整单取消、商品查询、脱机销售、脱机数据上传,基本资料下载,开钱箱、小票打印、收款结算,支持多币种付款方式(现金、储值卡、礼券、微信等),支持多种促销。运行环境:.net 4.0登陆信息用户名:1001 密码:123456内置商品信息,商品编码可输入00001000 - 00010000,测试效果相关功能键F5 结算 F9挂单 F11商品查询 F8退货 Insert单品取消 Del整单取消 F12开钱箱F2 会员 Ctrl+Z退出系统 Home 锁屏 相关源码待公开

狂神说Spring01:概述及IOC理论推导

狂神说Spring系列连载课程,通俗易懂,基于Spring最新版本,欢迎各位狂粉转发关注学习。禁止随意转载,转载记住贴出B站视频链接及公众号链接!Spring概述简介Spring : 春...

狂神说 2万+

Devexpress16.2.6破解工具

Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具

Spring学习01:控制反转(IOC)与依赖注入(DI)

控制反转 程序的耦合和解耦 耦合: 程序间的依赖关系.在开发中,应该做到解决编译期依赖,即编译期不依赖,运行时才依赖. 解耦的思路: 使用反射来创建对象,而避免使用new关键字,并通过读取配置文件来获取要创建的对象全限定类名. 下面以两个例子来说明如何解耦. 解耦实例1: JDBC驱动注册 JDBC操作中注册驱动时,我们不使用DriverManager的register方法,而采用Class.fo...

ncepu_Chen的博客 1万+

假人有限元模型

假人模型,车辆碰撞假人有限元模型,适合做乘员安全的研究者利用

Spring Framework(二)IOC和依赖查找

IOC IoC,Inversion of Control,控制反转,是面向对象编程中的一种设计原则,用来降低代码的耦合度。最通俗易懂的理解就是,本来由程序员写代码创建和组装类及依赖对象的控制权,反转交给容器去控制。 IoC 并非 Spring Framework 特有,也有一些其他的 IoC 开源框架如 Apache Avalon、PicoContainer、Google Guice;只是 Spring 被大量使用,其 IoC 的功能也被熟知。 IoC 的实现策略有很多,但最主要的两种方式就是依赖查找和依赖

CS技术栈 363

【spring01】Spring 管理 Bean-IOC,基于 XML 配置 bean

Spring 最大的价值,通过配置,给程序提供需要使用的web 层

qq_74232707的博客 2658

【死磕Spring】| Spring IoC依赖查找:依赖注入还不够吗?依赖查找存在的价值几何?

文章目录Spring IoC依赖查找:依赖注入还不够吗?依赖查找存在的价值几何?00、代码实现参考包的路径01、根据Bean名称进行查找1.1、实时查找1.2、延迟查找02、根据Bean类型进行查找2.1、单个Bean对象2.2、集合Bean对象03、根据Java注解查找 Spring IoC依赖查找:依赖注入还不够吗?依赖查找存在的价值几何? 00、代码实现参考包的路径 1、DependencyLookUpDemo.java 2、User.java 3、SuperUser.java 4、context-

MarkusZhang的博客 282

SpringFramework-01_Spring IoC

SpringFramework-01_Spring IoC

m0_62036548的博客 1636

Spring01——Spring简介、Spring Framework架构、Spring核心概念、IOC入门案例、DI入门案例

Spring01——Spring简介、Spring Framework架构、Spring核心概念、IOC入门案例、DI入门案例

后端小白个人学习记录 1591

01.01 Spring核心|IoC容器深度解析

Spring IoC容器深度解析 本文深入剖析Spring框架的核心机制IoC容器,主要内容包括: 控制反转原理:通过依赖注入实现松耦合,对比传统紧耦合方式的劣势,展示IoC在解耦、可测试性和灵活性方面的优势。 容器层次结构:详细解析BeanFactory和ApplicationContext两大核心接口的差异,包括特性对比和使用场景建议。 Bean定义与注册:介绍三种Bean定义方式(XML配置、注解配置和自动配置)及其适用场景,分析容器启动的核心流程。 实战应用:通过订单服务案例展示IoC在实际开发中的

u010105645的专栏 1215

Spring_01 Spring家族 Spring系统架构 Spring解决的问题 IOC、IOC容器、Bean、DI

🏫中北大学软件学院 🥇Spring是什么 🥇IOC 🥇DI 文章目录Spring家族Spring系统架构Spring解决的问题IOC、IOC容器、Bean、DI核心概念小结 Spring家族 Spring发展到今天已经形成了一种开发的生态圈,Spring提供了若干个项目,每个项目用于完成特定的功能。 Spring已形成了完整的生态圈,也就是说我们可以完全使用Spring技术完成整个项目的构建、设计与开发。 Spring有若干个项目,可以根据需要自行选择,把这些个项目组合起来,起了一个名称叫全家桶,如下图.

绿色水杯 873

Spring IOC-01

IoC的英文是Inversion of Control ,他是面向对象中的一种编程设计思想。其翻译成中文的意思是“控制反转”,那么如何解释控制反转呢?那么我们需要先回到原生的开发过程中,加入我们的A类依赖B类,那我们就要主动去创建B的对象和属性赋值,然后才能使用这个对象。但是对于IoC这种方式,像创建对象,属性赋值这些细节工作都交由IoC容器来完成,我们只需关注对象的使用,通过这种方式达到解藕。 那么,把对象都交给了IoC容器管理,那A类想使用B类的时候怎么使用呢?Spri...

dingfengen的专栏 220

Spring-IOC【01】

文章目录非IOC方式获取user对象通过IOC的方式获取User对象通过name属性获取User对象通过类对象获取仅仅通过类对象获取静态工厂注入动态工厂注入 非IOC方式获取user对象 package com.sxt.pojo; public class User { public void run(){ System.out.println("run方法"); } public ...

慕北丶 402

【SSM - Spring入门篇】 01Spring介绍 SpringIOC入门 IOC模式 spirng依赖注入以及Dao依赖注入和注解注入

SpringIOC入门,使用SpringIOC创建容器,获取JavaBean对象Spring的介绍Spring架构体系Spring的IOC理论 Spring的介绍 (1)Spring是什么? Spring 是分层的 Java SE/EE 应用 full-stack 轻量级开源框架 full-stack Service Dao web 》轻量级 按需添加模块 》开源 可以获取源代码 以 IOC- (Inverse Of Control:反转控制)和 AOP- (Aspect Oriented Programm

mighty_Jon的博客 828
上一篇: Spring Framework 研究框架搭建
下一篇: NSQD中的log 设计
DreamCatcher
博客等级 码龄20年 23粉丝 151原创
评论 2
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

DreamCatcher

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值