Spring-IOC(控制反转详解及demo)

最新推荐文章于 2024-07-22 09:40:42 发布
最新推荐文章于 2024-07-22 09:40:42 发布
阅读量567 收藏 1
点赞数
分类专栏： java spring 文章标签： JAVA spring IOC详解
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/h_r_f/article/details/79122299
版权

IOC(控制反转):对象的创建交给外部容器完成。

DI(依赖注入):处理对象的依赖关系。

两者区别:

控制反转:解决对象的创建问题。

依赖注入:在创建完对象之后，对象的关系的处理(set方法的注入).

 

用到的jar包:

spring-beans.jar,

spring-core.jar,

spring-expression.jar,

spring-context.jar,

spring-aop.jar

commons-logging.

Spring3.x之后所有的依赖包，不包含需要时，另外下载。



（一） IOC容器装配Bean(xml配置方式)

User.java

package com.hrf;


public class User {

 private int id;

private String name;

}


Application.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

        http://www.springframework.org/schema/beans/spring-beans.xsd">

  <!—id标识 class类的完全限定名-—>

 <bean id="user" class="com.hrf.User"></bean>

</beans>


测试:

package com.hrf;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class App {


public static void main(String[] args) {

     //得到IOC容器

ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");

       //原先User user=new User();

     //从容器中获取对象

        User user=(User)applicationContext.getBean("user");

        System.out.println(user);

}

}

测试结果为:

com.hrf.User@1810399e



补充:对象的创建分为单例和双例。

scope=”singleton”,默认值为单例; 再启动容器时，创建bean,整个应用只有一个对象。

scope=”prototype”,多例; 在使用到对象时才被创建。


列如:

public class User {

 private int id;

private String name;


public User() {

System.out.println("调用无参构造方法");

}

}


application.xml

<bean id="user" class="com.hrf.User" scope="prototype"></bean>



      public class App {


public static void main(String[] args) {

     //得到IOC容器

ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");

       //原先User user=new User();

     System.out.println("哈哈哈!");

     //从容器中获取对象

        User user=(User)applicationContext.getBean("user");

        }

}

测试结果为:

哈哈哈!

调用无参构造方法


若改为scope=”singleton”,测试结果为:

调用无参构造方法

哈哈哈!


思考:那么我们怎么把singleton效果变为prototype效果?这就涉及到延迟创建

lazy-init=”default” 默认为false,不延迟，启动时创建。

lazy-init=”true”延迟，启动时不创建，使用时创建。

此时我们只要这样做即可

<bean id="user" class="com.hrf.User" scope="singleton" lazy-init="true"></bean>


（二） SpringIOC容器。

作用:创建对象，处理对象依赖关系。

IOC容器创建对象几种方式:

1. 调用无参构造

2. 带参数构造

3. 工厂创建对象

1） 静态方法创建对象

2） 非静态方法创建对象

1)

public class User {

private int id;

private String name;

public User() {

super();

System.out.println("调用无参构造方法");

}

}

<!-- 1.调用无参构造 -->

   <bean id="user1" class="com.hrf.User"></bean>


2)

public class User {

private int id;

private String name;

public User() {

super();

System.out.println("调用无参构造方法");

}

public User(int id, String name) {

this.id = id;

this.name = name;

System.out.println("调用带参构造方法");

}

}


<!-- 2.调用有参构造 -->

    <bean id="user2" class="com.hrf.User">

      <constructor-arg value="01" index="0" type="int"></constructor-arg>

      <constructor-arg value="hrf" index="1" type="java.lang.String"></constructor-arg>

    </bean>



<!-- 3.调用有参构造，引用其它对象 -->

    <bean id="s" class="java.lang.String">

       <constructor-arg value="hrf2"></constructor-arg>

    </bean>

    <bean id="user3" class="com.hrf.User">

      <constructor-arg value="02" index="0" type="int"></constructor-arg>

      <constructor-arg ref="s" index="1" type="java.lang.String"></constructor-arg>

</bean>

3)

package com.hrf;

public class UserFactory {

  public User getInstance(){

 return new User(001,"hrf001");

 }

 public static User getStaticInstance(){

return new User(002,"hrf002");

 }

}


<!-- 工厂创建对象 -->

    <!-- 工厂的实例 -->

    <bean id="userFactory" class="com.hrf.UserFactory"></bean>

    <!-- 使用非静态方法创建对象 -->

    <bean id="user4" factory-bean="userFactory" factory-method="getInstance"></bean>

    <!-- 使用静态方法创建对象 -->

    <bean id="user5" class="com.hrf.UserFactory"  factory-method="getStaticInstance"></bean>


（三） 对象的依赖关系,DI依赖注入.

1. 通过构造

2. 通过set方法对属性注入

3. P名称空间

4. 自动装配（了解）


1）<!-- 通过set方法对属性注入 -->

    <bean id="user6" class="com.hrf.User">

      <property name="id" value="1001"></property>

      <property name="name" value="hrf1001"></property>

</bean>


2）


package com.hrf.second;

public class UserDao {

  public void add(){

 System.out.println("---------将数据保存到数据库-----------");

  }

}



package com.hrf.second;


public class UserService {

private UserDao userDao;

public UserDao getUserDao() {

return userDao;

}


public void setUserDao(UserDao userDao) {

this.userDao = userDao;

}

public void add(){

userDao.add();

} 

}


package com.hrf.second;

public class UserAction {

   private UserService userService;

   public UserService getUserService() {

  return userService;

   }


   public void setUserService(UserService userService) {

  this.userService = userService;

   }

    public String add(){

  userService.add();

  return null;

    }

}


<!-- userDao -->

     <bean id="userDao" class="com.hrf.second.UserDao"></bean>-->

     <!-- userService 

     <bean id="userService" class="com.hrf.second.UserService">

        <property name="userDao" ref="userDao"></property>

     </bean>

     

     <!-- userAction -->

     <bean id="userAction" class="com.hrf.second.UserAction">

        <property name="userService" ref="userService"></property>

     </bean>

3）<!-- 内部bean   -->

     <bean id="userAction2" class="com.hrf.second.UserAction">

         <property name="userService">

            <bean class="com.hrf.second.UserService">

              <property name="userDao">

                <bean class="com.hrf.second.UserDao"></bean>

              </property>

            </bean>

         </property>

     </bean>

   


4） <!-- p名称空间 -->

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

    xmlns:p="http://www.springframework.org/schema/p"

    xsi:schemaLocation="http://www.springframework.org/schema/beans

    http://www.springframework.org/schema/beans/spring-beans.xsd">

     <bean id="userDao" class="com.hrf.second.UserDao"></bean>

     <bean id="userService" class="com.hrf.second.UserService" p:userDao-ref="userDao"></bean>

     <bean id="userAction3" class="com.hrf.second.UserAction" p:userService-ref="userService"></bean>

</beans>

 


(四)注解方式，可以简化springIOC容器的配置

使用注解步骤:

1) 引入context名称空间

2) 开启注释扫描

使用注释:

把对象加入IOC容器@Component后面不写会默认类名相同，但第一个字母小写。

处理对象的依赖关系@Resource，不同set方法了。

@Repository 在持久层使用 （Dao层）

@Service 在业务逻辑层使用 （Service层）

@Controller 在控制层 （Action层）


package com.hrf.third;

import org.springframework.stereotype.Component;

import org.springframework.stereotype.Repository;


//三种方式都可以

//@Component("userDao")  相当于<bean id="userDao" class="com.hrf.third.UserDao"></bean>

//@Component

@Repository

public class UserDao {

public void add(){

System.out.println("---------将数据保存到数据库-----------");

}

}



package com.hrf.third;

import javax.annotation.Resource;

import org.springframework.stereotype.Component;

import org.springframework.stereotype.Service;

//@Component("userService")

//@Component

@Service

public class UserService {

//@Resource(name="userDao")  相当于<property name="userDao" ref="userDao"></property>

@Resource

private UserDao userDao;

public void add(){

userDao.add();

}

}


package com.hrf.third;

import javax.annotation.Resource;

import org.springframework.stereotype.Component;

import org.springframework.stereotype.Controller;

//@Component("userAction")

//@Component

@Controller

public class UserAction {

//@Resource(name="userService")

@Resource

private UserService userService;

public String add(){

userService.add();

return null;

}

}


beans4.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"

    xmlns:context="http://www.springframework.org/schema/context"

    xsi:schemaLocation="http://www.springframework.org/schema/beans

        http://www.springframework.org/schema/beans/spring-beans.xsd

        http://www.springframework.org/schema/context

        http://www.springframework.org/schema/context/spring-context.xsd">

     <context:component-scan base-package="com.hrf.third"></context:component-scan>

</beans>

package com.hrf.third;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class App {
public static void main(String[] args) {
ApplicationContext applicationContext=new ClassPathXmlApplicationContext("beans4.xml");
               UserAction userAction=(UserAction)applicationContext.getBean("userAction");
               userAction.add();    
}


}

 

_小点
关注
专栏目录
Spring——Spring核心（IoC）控制反转详细说明
Java_zhujia的博客
11-15 509
控制反转IoC(Inversion of Control） 是一个概念，是一种思想。指将传统上由程序代码直接操控的对象调用权交给容器，通过容器来实现对象的装配和管理。控制反转就是对对象控制权的转移，从程序代码本身反转到了外部容器。通过容器实现对象的创建，属性赋值， 依赖的管理。IoC 是一个概念，是一种思想，其实现方式多种多样。当前比较流行的实现方式是依赖注入。应用广泛。
Spring Ioc(控制反转)以及DI(依赖注入)详解
Lzc的博客
06-16 1505
Struts2：web层，比较简单（难点：ValueStack值栈、拦截器） Hibernate：dao层，知识点杂（学了不用，默认设置够用了） Spring：service层，重要，（讲多少用多少） Spring课程概述： Spring day01：基础（IoC控制反转、DI依赖注入）、整合JUnit、整合Web Spring day02：AOP切面编程、JDBCTemplate Sp...
一个简单的spring IOC演示demo
02-07
一个简单的spring IOC演示demo 包含spring所需的基本jar包，代码。经过测试，可以正常使用
【Spring】IOC控制反转-demo
千千
04-15 308
一、JMeter是什么？ JMeter是一个软件，使负载测试或业绩为导向的业务（功能）测试不同的协议或技术。 Apache软件基金会的Stefano Mazzocchi JMeter的最初的开发。他写道：它主要对 Apache JServ（现在称为如Apache Tomcat项目）的性能进行测试。Apache后来重新设计JMeter 增强的图形用户界面和添加功能测试能力。 这是一个具有
Spring IoC详解
最新发布
2302_79392547的博客
07-22 967
对于同一个类,如何定义多个对象呢?我们看下@Bean的使用@Component@Bean@Bean定义了多个对象的话,我们根据类型获取兑现,获取的是哪个对象呢?运行结果:报错信息显示: 期望只有一个匹配,结果发现了两个,user1,user2接下来我们根据名称来获取bean对象运行结果:可以看到,@Bean可以针对同一个类,定义多个对象.
SpringIOC经典Demo
11-19
SpringIOC经典Demo,绝对的经典.
spring详解（二）---控制反转
Y_BlueBlack的博客
09-06 527
目录 1、什么是 IOC？ 2、分享Bromon的blog上对IoC与DI浅显易懂的讲解 3、Spring 容器创建对象的三种方式 4、Spring 容器创建对象的时机 5、spring的bean中的scope："singleton/prototype/request/session/global session"  5、Spring 容器生命周期   　　我相信提到 Spring，...
SpringFramework之IOC(控制反转)详解
console的博客
08-02 247
SpringFramework是Spring框架的核心，其他模块都依赖于SpringFramework。Spring两大特点：Ioc（控制反转）和Aop(面向切面编程) 。虽然SpringMVC，SpringBoot等使用了Spring的两大特性，但是Spring这两个特性不仅仅局限于Web应用开发。本篇通过案例，介绍了Spring当中之所以出现Ioc的原因和带来的好处。值得注意的是，文中的案例只有关键代码，包名和文档注释等没有体现，读者阅读时需要注意，根据个人习惯建立相应包结构。
spring-demo:春天简单示例
03-21
1. "Spring框架IOC详解"：这篇文章详细解释了Spring的IOC容器及其工作原理。 2. "Spring Bean实例化全过程"：深入分析Bean的生命周期和实例化过程。 3. "Spring属性注入的多种方式"：全面介绍Spring的注入机制，包括...
Spring框架系列(8) - Spring IOC实现原理详解之Bean实例化(生命周期,循环依赖等)
www_xuhss_com的博客
06-29 528
本文主要研究如何从IOC容器已有的BeanDefinition信息，实例化出Bean对象；这里还会包括三块重点内容： 初步的思考 上文我们已经分析了IoC初始化的流程，最终的将Bean的定义即BeanDefinition放到beanDefinitionMap中，本质上是一个；并且BeanDefinition接口中包含了这个类的Class信息以及是否是单例等；这样我们初步有了实现这个方法的思路：由于BeanDefinition还有单例的信息，如果是无参构造函数的实例还可以放在一个缓存中，这样下次获取这个单例的
JavaEE框架Spring的配置与IOC（控制反转）的demo（案例、实例），适合初学者
05-31
JavaEE框架Spring的配置与IOC（控制反转）的demo（案例、实例），适合初学者。 Blog: http://blog.csdn.net/zhangxichao100/article/details/72725471 http://blog.csdn.net/zhangxichao100/article/details/72726085
Spring控制反转(IoC)的理解
04-03
NULL 博文链接：https://hgxs-org.iteye.com/blog/1469237
springIOC实例
04-28
该资源包含了一个springIOC的简单实例代码，简单易懂。
Spring IOC实现原理demo
03-10
Spring容器的原理 其实就是通过解析xml文件 通过反射创建出我们所需要的bean 再将这些bean挨个放到集合中 然后对外提供一个getBean 方法 以便我们获得这bean
Java——Spring的控制反转（一文详解IOC）
xdx_dili的博客
10-26 785
Java——Spring的控制反转（一文详解IOC）
spring IOC 控制反转详解
leigelg的博客
02-28 571
spring IOC 控制反转详解
spring IOC 反射加载demo
qq_35809876的博客
03-04 413
spring IOC 反射加载demo 简单的demo 用于更清楚的了解 spring的注入原理。spring IOC都知道通过JAVA的反射 但是具体的反射 ，怎么实现的？。。。相信就是已经工作的小伙伴好多也不知道他的具体实现方式 结构图 model 当做service 简单的demo 没有太规范 xml配置文件
SpringIOC Demo
Jack
05-01 361
1、设计目标：通过一个例子简单了解springIOC 2、实现步骤： （1）使用MyEclipse自动添加spring支持 （2）从网上下载lombok（可以使代码看起来更加简洁） （3）编写配置文件：applicationContext.xml （4）编写实体类或接口 （5）测试 3、代码：
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值