IOC 容器

最新推荐文章于 2023-02-03 15:20:22 发布
最新推荐文章于 2023-02-03 15:20:22 发布
阅读量85 收藏
点赞数
分类专栏： SSM 文章标签： spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/asdfghsadg/article/details/120496289
版权

IOC 容器

IOC的概念

（1）控制反转，把对象创建和对象之间的调用过程，交给 Spring 进行管理

（2）使用 IOC 目的：为了耦合度降低

（3）做入门案例就是 IOC 实现

IOC 底层原理

（1）xml 解析、工厂模式、反射

IOC容器的演变过程（图解）

目的：降低耦合度

在这里插入图片描述

原始方式方法之间的调用耦合度非常高，只要一个发生变化就全体发生变化

在这里插入图片描述

工厂模式对Service和Dao类进行解耦操作，降低了耦合度；但是又多了与工厂的耦合度

在这里插入图片描述

IOC过程进一步降低了耦合度

IOC（BeanFactory 接口）

1、IOC 思想基于 IOC 容器完成，IOC 容器底层就是对象工厂

2、Spring 提供 IOC 容器实现两种方式：（两个接口）

  1. BeanFactory：IOC 容器基本实现，是 Spring 内部的使用接口，不提供开发人员进行使用
    • 加载配置文件时候不会创建对象，在获取对象（使用）才去创建对象
  2. ApplicationContext：BeanFactory 接口的子接口，提供更多更强大的功能，一般由开发人员进行使用
    • 加载配置文件时候就会把在配置文件对象进行创建

3、ApplicationContext 接口实现类的说明

在这里插入图片描述

  • FileSystemXmlApplicationContext() 类里写的是xml文件的全路径，也就是绝对路径
  • ClassPathXmlApplicationContext() 类里写的是xml文件相对于当前src下的路径

IOC 操作 Bean 管理

1、什么是 Bean 管理

Bean 管理指的是两个操作

  • Spring 创建对象
  • Spirng 注入属性

2、Bean 管理操作的两种方式

  • 基于 xml 配置文件方式实现
  • 基于注解方式实现

基于 xml 方式

1、基于 xml 方式创建对象

在 spring 配置文件中，使用 bean 标签，标签里面添加对应属性，就可以实现对象创建

在 bean 标签有很多属性，介绍常用的属性

  • id 属性：唯一标识
  • class 属性：类全路径（包类路径）

创建对象时候，默认也是执行无参数构造方法完成对象创建

<!--配置User对象创建-->
<bean id="user" class="spring5.User"></bean>
2、基于 xml 方式注入属性

DI：依赖注入，就是注入属性

属性注入的方式一：使用set方法进行注入

（1）创建类，定义属性和对应的 set 方法

public class Book {
    //创建属性
    private String bookName;
    private String boonAuthor;

    //创建属性对应的set()方法
    public void setBookName(String bookName) {
        this.bookName = bookName;
    }

    public void setBoonAuthor(String boonAuthor) {
        this.boonAuthor = boonAuthor;
    }
    
    //该方法做测试用
    public void test(){
        System.out.println(boonAuthor + ":" + bookName);
    }
}

（2）在 spring 配置文件配置对象创建，配置属性注入

<bean id="book" class="spring5.Testdemo.Book">
    <!--
    使用property完成属性注入
        name：类里面的属性名
        value：向属性注入的值
    -->
    <property name="bookName" value="平凡的世界"></property>
    <property name="boonAuthor" value="路遥"></property>
</bean>

调用并测试：

@Test
public void testBook(){
    //1.加载Spring配置文件
    ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
    //2.获取配置文件创建的对象
    Book book = context.getBean("book", Book.class);

    System.out.println(book);
    book.test();
}

在这里插入图片描述

属性注入的方式二：使用有参构造器进行注入

（1）创建类，定义属性，创建属性对应有参数构造方法

public class Order {
    private String orderName;
    private Integer orderId;

    public Order(String orderName, Integer orderId) {
        this.orderName = orderName;
        this.orderId = orderId;
    }

	//
    public void test() {
        System.out.println(orderId + ":" + orderName);
    }
}

（2）在 spring 配置文件中进行配置

<bean id="order" class="spring5.Testdemo.Order">
    <constructor-arg name="orderId" value="123"></constructor-arg>
    <constructor-arg name="orderName" value="qwert"></constructor-arg>
</bean>

<bean id="order1" class="spring5.Testdemo.Order">
    <constructor-arg index="0" value="yuiop"></constructor-arg>
    <constructor-arg index="1" value="456"></constructor-arg>
</bean>

上面的index对应的索引为该类有参构造器的索引，比如以上类索引0为orderName,索引1为orderId

测试：

@Test
public void testOrder(){
    ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
    Order order = context.getBean("order", Order.class);
    Order order1 = context.getBean("order1", Order.class);

    order.test();
    order1.test();
}

在这里插入图片描述

p 名称空间注入（了解）

使用 p 名称空间注入，可以简化基于 xml 配置方式

第一步 添加 p 名称空间在配置文件中


第二步 进行属性注入，在 bean 标签里面进行操作

<bean id="book" class="spring5.Testdemo.Book" p:bookName="挪威的森林" p:boonAuthor="村上春树"></bean>
xml 注入其他类型属性
1、字面量

（1）null 值

<!--null 值-->
<property name="address">
 <null/>
</property>

（2）属性值包含特殊符号

<!--属性值包含特殊符号
 1 把<>进行转义 &lt; &gt;
 2 把带特殊符号内容写到 CDATA
-->
<property name="address" value="&lt;江西&gt;"></property>
<property name="address">
   <value><![CDATA[<南昌>]]></value>
</property>
2、注入属性-外部 bean

（1）创建两个类 service 类和 dao 类

（2）在 service 调用 dao 里面的方法

public class UserService {
    private UserDao userDao;

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public void add(){
        System.out.println("service add.....");
        userDao.update();
    }
}

public class UserdaoImpl implements UserDao{
    @Override
    public void update() {
        System.out.println("dao update.....");
    }
}

（3）在 spring 配置文件中进行配置

<bean id="userService" class="spring5.service.UserService">
    <!--注入 userDao 对象
 		name 属性：类里面属性名称
 		ref 属性：创建 userDao 对象 bean 标签 id 值
 	-->
    <property name="userDao" ref="userDao"></property>
</bean>
<bean id="userDao" class="spring5.dao.UserdaoImpl"></bean>

测试：

ApplicationContext context = new ClassPathXmlApplicationContext("bean2.xml");
UserService userService = context.getBean("userService", UserService.class);
userService.add();

在这里插入图片描述

3、注入属性-内部 bean

就是对于一对多关系的类进行联系，例如部门和员工类，在员工类中加入部门属性

（1）编写员工类和部门类

//部门类
public class Dept {
    private String dname;

    public void setDname(String dname) {
        this.dname = dname;
    }

    @Override
    public String toString() {
        return "Dept{" +
                "dname='" + dname + '\'' +
                '}';
    }
}

//员工类
public class Emp {
    private String ename;
    private String gender;
    //员工属于某一个部门，使用对象形式表示
    private Dept dept;

    public void setDept(Dept dept) {
        this.dept = dept;
    }

    public void setEname(String ename) {
        this.ename = ename;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public void test() {
        System.out.println(ename + ":" + gender + ":" + dept);
    }
}

（2）在spring配置文件中进行配置

<bean id="emp" class="spring5.bean.Emp">
    <property name="ename" value="张三"></property>
    <property name="gender" value="男"></property>
    <!--设置对象类型属性-->
    <property name="dept">
        <bean id="dept" class="spring5.bean.Dept">
            <property name="dname" value="纪检部"></property>
        </bean>
    </property>
</bean>
4、注入属性-级联赋值

（1）第一种写法

和外部bean一样

<bean id="emp" class="spring5.bean.Emp">
    <property name="ename" value="张三"></property>
    <property name="gender" value="男"></property>
    <!--设置对象类型属性-->
    <property name="dept" ref="dept1"></property>
</bean>
<bean id="dept1" class="spring5.bean.Dept">
    <property name="dname" value="校风部"></property>
</bean>

（2）第二种写法

首先要在员工类中加上部门的get方法，以便在配置文件中获取部门对象
在这里插入图片描述

<bean id="emp" class="spring5.bean.Emp">
    <property name="ename" value="张三"></property>
    <property name="gender" value="男"></property>
    <!--设置对象类型属性-->
    <property name="dept" ref="dept"></property>
    <property name="dept.dname" value="保卫部">
    </property>
</bean>
<bean id="dept" class="spring5.bean.Dept"></bean>

这样就可以直接用点的方式对属性赋值，但要注意得先把部门的bean也写上

xml 注入集合属性

1、注入数组类型属性

2、注入 List 集合类型属性

3、注入 Map 集合类型属性

（1）创建类，定义数组、list、map、set 类型属性，生成对应 set 方法

在这里插入图片描述
（2）在 spring 配置文件进行配置

<bean id="student" class="spring5.collectiontype.Student">
    <property name="arr">
        <array>
            <value>arr1</value>
            <value>arr2</value>
            <value>arr3</value>
        </array>
    </property>
    <property name="list">
        <list>
            <value>lsit1</value>
            <value>lsit2</value>
            <value>lsit3</value>
        </list>
    </property>
    <property name="map">
        <map>
            <entry key="mapkey1" value="mapvalue1"></entry>
            <entry key="mapkey2" value="mapvalue2"></entry>
            <entry key="mapkey3" value="mapvalue3"></entry>
        </map>
    </property>
    <property name="set">
        <set>
            <value>set1</value>
            <value>set2</value>
        </set>
    </property>
</bean>
在集合里面设置对象类型值

在这里插入图片描述

先写一个对象类，然后在xml文件用bean标签来获取并给他的属性赋值；再在另外一个类中的集和属性中用list标签赋值，用ref标签来获取对象类，bean属性值对应对象类的id值

把集合注入部分提取出来

（1）在 spring 配置文件中引入名称空间 util

在这里插入图片描述
（2）使用 util 标签完成 list 集合注入提取

<util:list id="bookName">
    <value>图书1</value>
    <value>图书2</value>
    <value>图书3</value>
</util:list>

<bean id="book" class="spring5.collectiontype.Book">
    <property name="list" ref="bookName"></property>
</bean>

上面的ref一样是对应util的id值

FactoryBean
  1. Spring 有两种类型 bean，一种普通 bean，另外一种工厂 bean（FactoryBean）
  2. 普通 bean：在配置文件中定义 bean 类型就是返回类型
  3. 工厂 bean：在配置文件定义 bean 类型可以和返回类型不一样

第一步 创建类，让这个类作为工厂 bean，实现接口 FactoryBean

第二步 实现接口里面的方法，在实现的方法中定义返回的 bean 类型

public class Mybean implements FactoryBean<Course> {
    @Override
    public Course getObject() throws Exception {
        return new Course();
    }

    @Override
    public Class<?> getObjectType() {
        return null;
    }

    @Override
    public boolean isSingleton() {
        return false;
    }
}

<bean id="mybean" class="spring5.bean.Mybean">
</bean>

ApplicationContext context =new ClassPathXmlApplicationContext("bean2.xml");
Course mybean = context.getBean("mybean", Course.class);
bean 作用域

在 spring 配置文件 bean 标签里面有属性（scope）用于设置单实例还是多实例

  • 默认值，singleton，表示是单实例对象

  • prototype，表示是多实例对象

<bean id="book" class="spring5.collectiontype.Book" scope="prototype">
</bean>

singleton 和 prototype 区别：

  1. singleton 单实例，prototype 多实例
    • 设置 scope 值是 singleton 时候，加载 spring 配置文件时候就会创建单实例对象
    • 设置 scope 值是 prototype 时候，不是在加载 spring 配置文件时候创建对象，在调用 getBean 方法时候创建多实例对象
bean 生命周期

（1）通过构造器创建 bean 实例（无参数构造）

（2）为 bean 的属性设置值和对其他 bean 引用（调用 set 方法）

（3）调用 bean 的初始化的方法（需要进行配置初始化的方法）

（4）bean 可以使用了（对象获取到了）

（5）当容器关闭时候，调用 bean 的销毁的方法（需要进行配置销毁的方法）

public class Person {
    private String name;

    public Person() {
        System.out.println("第一步 执行无参数构造创建 bean 实例");
    }

    public void setName(String name) {
        this.name = name;
        System.out.println("第二步 调用 set 方法设置属性值");
    }


    public void initMethod(){
        System.out.println("第三步 执行初始化的方法");
    }
    public void destroyMethod(){
        System.out.println("第五步 执行销毁的方法");
    }

}

<bean id="person" class="spring5.bean.Person" init-method="initMethod" destroy-method="destroyMethod">
    <property name="name" value="cxdthd"></property>
</bean>

测试：

ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean3.xml");
Person person = context.getBean("person", Person.class);
System.out.println("第四步 获取创建 bean 实例对象");
context.close();

在这里插入图片描述

bean 的后置处理器，bean 生命周期有七步

（1）通过构造器创建 bean 实例（无参数构造）

（2）为 bean 的属性设置值和对其他 bean 引用（调用 set 方法）

（3）把 bean 实例传递 bean 后置处理器的方法 postProcessBeforeInitialization

（4）调用 bean 的初始化的方法（需要进行配置初始化的方法）

（5）把 bean 实例传递 bean 后置处理器的方法 postProcessAfterInitialization

（6）bean 可以使用了（对象获取到了）

（7）当容器关闭时候，调用 bean 的销毁的方法（需要进行配置销毁的方法）

后置处理器的创建：只需要创建一个实现接口 BeanPostProcessor的类即可

public class MyBeanPost  implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("postProcessBeforeInitialization方法");
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("postProcessAfterInitialization方法");
        return bean;
    }
}

<!--后置处理器-->
<bean id="myBeanPost" class="spring5.bean.MyBeanPost"></bean>

在这个xml中创建了后置处理器会对当前xml所有的bean标签都有效，不需要再有其他操作

在这里插入图片描述

xml 自动装配

根据指定装配规则（属性名称或者属性类型），Spring 自动将匹配的属性值进行注入

bean 标签属性 autowire，配置自动装配 autowire

  • byName 根据属性名称注入 ，注入值 bean 的 id 值和类属性名称一样
  • byType 根据属性类型注入
<bean id="emp" class="spring5.autowire.Emp" autowire="byName"></bean>
<bean id="dept" class="spring5.autowire.Dept" ></bean>

会自动识别Emp类里面的Dept类型的属性；当使用byType时需要注意当我们创建了两个Dept类的bean标签时，会报错，因为它不知道我们需要的是哪一个，而使用byName时是直接匹配bean标签的id值

外部属性文件（数据库连接池）

（1）引入德鲁伊连接池依赖 jar 包
在这里插入图片描述
（2）创建外部属性文件，properties 格式文件，写数据库信息

在这里插入图片描述

等号左边可以随便取，加上prop.是为了更好的区分

（3）把外部 properties 属性文件引入到 spring 配置文件中

  • 引入 context 名称空间
    在这里插入图片描述
  • 在 spring 配置文件使用标签引入外部属性文件
<!--引入外部属性文件-->
<context:property-placeholder location="classpath:jdbc.properties" />
<!--配置连接池-->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
    <property name="driverClassName" value="${prop.driverClass}"></property>
    <property name="url" value="${prop.url}"></property>
    <property name="username" value="${prop.userName}"></property>
    <property name="password" value="${prop.password}"></property>
</bean>

测试：

ApplicationContext context = new ClassPathXmlApplicationContext("bean5.xml");
DataSource dataSource = context.getBean("dataSource", DataSource.class);
Connection connection = dataSource.getConnection();
System.out.println(connection);

基于注解方式（重要）

注解的定义：

  1. 注解是代码特殊标记，格式：@注解名称(属性名称=属性值, 属性名称=属性值…)
  2. 使用注解，注解作用在类上面，方法上面，属性上面
  3. 使用注解目的：简化 xml 配置

Spring 针对 Bean 管理中创建对象提供注解

  • @Component（字面意思就是组件），它在你确定不了事哪一个层的时候使用。
  • @Service业务逻辑层，就是我们的service或者manager层
  • @Controller控制层，就是我们的action层
  • @Repository持久层，就是我们常说的DAO层

上面四个注解功能是一样的，都可以用来创建 bean 实例

基于注解方式实现对象创建

第一步 引入依赖

spring-aop的jar包
在这里插入图片描述
第二步 开启组件扫描

这里需要配置context空间，前面有就不复制了

<!--开启组件扫描
 1 如果扫描多个包，多个包使用逗号隔开
 2 扫描包上层目录
-->
<context:component-scan base-package="spring5"></context:component-scan>

第三步 创建类，在类上面添加创建对象注解

//在注解里面 value 属性值可以省略不写，
//默认值是类名称，首字母小写
//UserService -- userService
@Component(value = "userService")  //<bean id="userService" class=".."/>
public class UserService {
    public void add(){
        System.out.println("UserService add()....");
    }
}

测试：

ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
UserService userService = context.getBean("userService", UserService.class);
System.out.println(userService);
userService.add();

在这里插入图片描述

开启组件扫描细节配置
<!--示例 1
 use-default-filters="false" 表示现在不使用默认 filter，自己配置 filter
 context:include-filter ，设置扫描哪些内容
-->
<context:component-scan base-package="com.atguigu" use-default-filters="false">
 <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>

<!--示例 2
 下面配置扫描包所有内容
 context:exclude-filter： 设置哪些内容不进行扫描
-->
<context:component-scan base-package="com.atguigu">
 <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>
基于注解方式实现属性注入

  • @Autowired：根据属性类型进行自动装配

  • @Qualifier：根据名称进行注入

  • @Resource：可以根据类型注入，可以根据名称注入

  • @Value：注入普通类型属性

1、Autowired注解

第一步 把 service 和 dao 对象创建，在 service 和 dao 类添加创建对象注解

@Component
public class UserDaoImpl implements UserDao{
    @Override
    public void add() {
        System.out.println("UserDao add()....");
    }
}

第二步 在 service 注入 dao 对象，在 service 类添加 dao 类型属性，在属性上面使用注解

@Component(value = "userService")
public class UserService {
    //定义 dao 类型属性
    //不需要添加 set 方法
    //添加注入属性注解
    @Autowired
    private UserDao userDao;

    public void add(){
        System.out.println("UserService add()....");
        userDao.add();
    }
}

测试：

ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
UserService userService = context.getBean("userService", UserService.class);
System.out.println(userService);
userService.add();

在这里插入图片描述

2、Qualifier注解

这个@Qualifier 注解的使用，必须和上面@Autowired 一起使用

当如上的接口UserDao有不止一个实现类的时候，光用类型注解来获取程序就无法知道我们需要的是哪个实现类，所有便需要使用到Qualifier注解获取名字来获取我们需要的实现类

@Component(value = "userDao01")
public class UserDaoImpl implements UserDao{
    @Override
    public void add() {
        System.out.println("UserDao add()....");
    }
}

@Component(value = "userService")  //<bean id="userService" class=".."/>
public class UserService {
    //定义 dao 类型属性
    //不需要添加 set 方法
    //添加注入属性注解
    @Autowired
    @Qualifier(value = "userDao01")
    private UserDao userDao;

    public void add(){
        System.out.println("UserService add()....");
        userDao.add();
    }
}
3、Resource注解（不推荐使用）

这个注解既可以使用类型注入，也可以使用名称注入

  • @Resource时相当于@Autowired
  • @Resourse(value=“userDao01”)相当于@Qualifier(value=“userDao01”)
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import javax.annotation.Resource;

从上面可以看出Resourse注解是javax包下的，也就是java扩展包，其他两个注解是属于spring包下的，所有推荐使用的是上面两个注解，而不推荐使用扩展包的注解

4、Value注解
@Value(value = "张三")
private String name;

相当于给name属性赋初始化值为张三

完全注解开发

（1）创建配置类，替代 xml 配置文件

@Configuration //作为配置类，替代 xml 配置文件
@ComponentScan(basePackages = {"sping5"})
public class SpringConfig {
}

相当于：

<context:component-scan base-package="spring5"></context:component-scan>

（2）编写测试类

@Test
public void testService2() {
 //加载配置类
 ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
 UserService userService = context.getBean("userService", UserService.class);
 System.out.println(userService);
 userService.add();
}
cxdthd
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring5详解
qq_45592174的博客
07-13 5467
Spring5详解 文章目录Spring5详解概念Spring的特点1、轻量级2、控制反转3、面向切面4、容器5、框架Spring的优势1、方便解耦，简化开发2、AOP 编程的支持3、声明式事务的支持4、方便程序的测试5、方便集成各种优秀框架6、Java 源码是经典学习范例Spring 的体系结构Spring中的常用注解Spring IOC1、概念2、spring 中工厂的类结构图1、BeanFactory 和 ApplicationContext 的区别2、IOC 中 bean 标签和管理对象细节1、be
Spring5全面详解
weixin_45710998的博客
06-21 5862
Spring5所有对应的依赖jar包已经上传。十五万字符左右文章。描述了，入门案例，IOC,AOP(只会更详细，分了十几层小目录),JDBCTEMPLATE，事务操作。更新到事务操作。目前全书已经书写完整。代码结构和图片已经补充完整。文章目录分层明确。大纲细腻。欢迎大家评论。
Spring5框架新功能大全（详细）
weixin_51351637的博客
03-30 958
整个Spring5框架的代码基于Java8，运行时兼容JDK9，许多不建议使用的类和方法在代码库中删除 Spring5.0框架移除了Log4jConfigListener，官方建议使用Log4j2 并且Spring5已经对其进行了整合 第一步，引入jar包 第二步，创建log4j2.xml配置文件 （配置文件名是一个固定的名称，一定要是这个） <?xml version="1.0" encoding="UTF-8"?> <!--日志级别以及优先级排序:.
Spring5 框架——（一）简介
weixin_44005940的博客
06-27 299
Spring框架教程，Spring简介，Spring 5
详解Spring IOC 容器启动流程分析
08-25
Spring IOC 容器启动流程分析 Spring IOC 容器是 Java 企业级应用程序的核心组件之一，它提供了一个统一的依赖注入机制，使得应用程序的组件之间能够松耦合。Spring IOC 容器的启动流程是整个 Spring 框架的核心...
IOC容器简单实现
12-27
**IOC容器简单实现** IOC（Inversion of Control）容器是软件设计模式中的一种，它将对象的创建和管理权从代码本身转移到一个外部容器，即IOC容器。这种反转控制使得程序更加灵活，降低了组件之间的耦合性，提高了...
Spring为IOC容器注入Bean的五种方式详解
08-25
Spring为IOC容器注入Bean的五种方式详解 Spring 框架中，IOC（Inverse of Control，控制反转）容器是核心组件之一，用于管理 Bean 的生命周期。在 Spring 中，IOC 容器可以通过五种方式来注入 Bean，本文将对这五...
简单IOC容器demo
07-14
【标题】：“简单IOC容器demo”是一个演示性的项目，它旨在教授如何构建一个基础的控制反转（IOC）容器。这个容器使用注解来实现依赖注入，这是Spring框架的核心特性之一。 【描述】：该示例项目是学习过程的产物，...
基于Java反射技术实现简单IOC容器
08-18
基于Java反射技术实现简单IOC容器 Java反射技术是Java语言中一个非常重要的技术，通过反射技术可以在运行时检查和修改类的结构和行为。IOC容器是控制反转的缩写，全称是Inverse of Control，即控制反转。它是一种...
【狂神说Java】Spring5详细笔记(全)
Martin-share的博客
02-03 1791
【狂神说Java】Spring5详细笔记(全)
Spring5 框架新功能（Webflux）
热门推荐
m0_62946761的博客
01-31 1万+
介绍Spring5新的模块SpringWebflux，通过Java和Reator实现响应式编程
spring 5简单介绍
lai_zhe的博客
08-22 263
spring 5 简单介绍 spring 这个大家庭对于初学者肯定不知道从何学起，但是我们可以去spring的官方文档里面有详细的学习路径，首先是spring framework 然后spring boot 进一步深入的是spring cloud。 我在这里放一下官方文档的链接https://spring.io/projects，当然看文档是需要亿点英文水平，毕竟别人是国外的网站。如果不想看官方文档，可以跟着小编的思路去探索spring去全家桶。 咱们直接进入正题 spring 5 是spring fram
www.chinacdo.com
小熊的幸福
11-12 1191
服务器：ftp.chinacdo.com端口：9966用户名：www.chinacdo.com密码：www.chinacdo.com
什么是IOC容器
renxingzhadan的专栏
08-24 4368
https://blog.csdn.net/navyforce/article/details/108927826
长文详解Spring5架构教程，还不懂你打我
Trouvailless的博客
05-13 1322
一.Spring框架概述 1，Spring是一个 开源的 轻量级的 JavaEE框架。 轻量级：体积小，jar独立使用不需要依赖其他jar包， 开源：免费，可以提供源代码 框架：解决开发的复杂性，简化企业开发。 2，spring的两个核心部分：IOC，Aop IOC：控制反转，把创建对象的过程交给spring进行管理。 Aop：面向切面，在不修改源代码的情况下，进行功能的添加或增强。 3，spring框架的特点： 1），方便解耦，简化开发：对象与对象之间的关系依赖spring。 2），A
【Java框架】Spring5
a534563的博客
09-13 268
spring5
spring框架之Spring5新特性（总体第五篇）
热爱编写程序的药学在读书
03-22 2428
上一篇文章中已经学习到了我们的Spring事务问题，在更早些的文章中已经学习到我们的Spring的AOP，IOC，DI，整合JDBCTemplate等一系列问题的学习，本篇文章也是Spring框架的最后一篇，学习关于我们的Spring5的一些新特性。 一、大致介绍 整个Spring5框架的代码基于java8，运行兼容JDK9，许多建议不适用的类，都做了删除。 1、Spring5新功能之整合日志框架 （1）介绍 Spring5框架自带了通用的日志功能 Spring已经移除了Log4jConfigLi
入门IOC解析
m0_46405589的博客
08-13 241
前天总结了一下Spring框架中AOP的原理和作用，今天来总结一下另一核心—>IOC（控制反转） 废话不多说，直接进入正题 IOC（概念和原理） 1、什么是 IOC？ （1）控制反转，把对象创建和对象之间的调用过程，交给Spring 进行管理。 （2）使用 IOC 目的：为了代码耦合度降低 2、IOC 底层原理 xml 解析、工厂模式、反射 IOC（BeanFactory 接口） 1、IOC 思想基于 IOC 容器完成，IOC 容器底层就是对象工厂 2、Spring 提供 IOC 容器实现两种方式：
ioc 容器
最新发布
06-02
IoC （Inversion of Control，控制反转）是一种设计模式，它将程序中的控制权从代码中转移到了容器中，使得程序的可扩展性和可维护性更强。IoC 容器就是实现 IoC 模式的一个工具，它可以自动创建、装配和管理对象，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值