Spring3(一) 控制反转(IoC)和依赖注入(DI)

几个常用框架之间的关系

1       spring框架概述

1.1   什么是spring

Spring是一个开源、轻量级的Java 开发框架。框架的主要优势之一就是其分层架构,分层架构允许使用者选择使用哪一个组件,同时为 J2EE 应用程序开发提供集成的框架。Spring的核心是控制反转(IoC)和面向切面(AOP)。

  • 轻量级指的是:与EJB对比,依赖资源少,销毁的资源少。
  • 分层: 一站式,每一个层都提供了解决方案;但是又可以只选择其中一层

    web层:struts,spring-MVC

    service层:spring

    dao层:hibernate,mybatis , jdbcTemplate  --> spring-data

  • 什么是IOC?这篇博客讲的很清楚 ,https://www.cnblogs.com/xdp-gacl/p/4249939.html
  • 控制反转,到底哪些方面的控制被反转了呢? 获得依赖对象的过程被反转了。控制被反转之后,获得依赖对象的过程由自身管理变为了由IOC容器主动注入。“控制反转”有一个更合适的名字叫做“依赖 注入(Dependency Injection)”。实现IOC的方法:注入。所谓依赖注入,就是由IOC容器在运行期间,动态地将某种依赖关系注入到对象之中。参考 https://www.cnblogs.com/xdp-gacl/p/3707631.html

1.2   spring优点

l  方便解耦,简化开发  (高内聚低耦合)

  • 高内聚:比如都是操作数据库的东西放在一起,方便管理;
  • 低耦合:两个组件之间能不调用就不调用;
  • Spring就是一个大工厂(容器),可以将所有对象创建和依赖关系维护,交给Spring管理
  • spring工厂是用于生成bean。Bean的含义是可重复使用的Java组件。

l I AOP编程的支持

  • Spring提供面向切面编程,可以方便的实现对程序进行权限拦截、运行监控等功能

lII  声明式事务的支持

  • 只需要通过配置就可以完成对事务的管理,而无需手动编程

lV  方便程序的测试

  • Spring对Junit4支持,可以通过注解方便的测试Spring程序

V 方便集成各种优秀框架

  • Spring不排斥各种优秀的开源框架,其内部提供了对各种优秀框架(如:Struts、Hibernate、MyBatis、Quartz等)的直接支持

Vl  降低JavaEE API的使用难度

  • Spring 对JavaEE开发中非常难用的一些API(JDBC、JavaMail、远程调用等),都提供了封装,使这些API应用难度大大降低

1.3   spring体系结构

core

  core部分包含4个模块

  1. spring-core:依赖注入IoC与DI的最基本实现
  2. spring-beans:Bean工厂与bean的装配
  3. spring-context:spring的context上下文即IoC容器
  4. spring-expression:spring表达式语言

aop

  aop部分包含4个模块

  1. spring-aop:面向切面编程
  2. spring-aspects:集成AspectJ
  3. spring-instrument:提供一些类级的工具支持和ClassLoader级的实现,用于服务器
  4. spring-instrument-tomcat:针对tomcat的instrument实现

data access

  data access部分包含5个模块

  1. spring-jdbc:jdbc的支持
  2. spring-tx:事务控制
  3. spring-orm:对象关系映射,集成orm框架
  4. spring-oxm:对象xml映射
  5. spring-jms:java消息服务

web

  web部分包含4个模块

  1. spring-web:基础web功能,如文件上传
  2. spring-webmvc:mvc实现
  3. spring-webmvc-portlet:基于portlet的mvc实现
  4. spring-struts:与struts的集成,不推荐,spring4不再提供

2       入门案例:IoC

2.1   导入jar包

  • 4 + 1  : 4个核心(beans、core、context、expression) + 1个依赖(commons-loggins...jar)

需要导入的是字节码的jar包。

2.2  目标类

l  提供UserService接口和实现类

lI  获得UserService实现类的实例

在之前开发中,直接new一个对象即可。

在spring中,由Spring创建对象实例--> IoC 控制反转(Inverse of  Control)

之后需要实例对象时,从spring工厂(容器)中获得,需要将实现类的全限定名称配置到xml文件中

3      入门案例:DI

DI Dependency Injection ,依赖注入。

class B {

private A a;   //B类依赖A类

}

依赖:一个对象需要使用另一个对象

注入:(IoC容器)通过setter方法进行另一个对象实例设置。

例如:

//  B类(BookServiceImpl,是个service实现类),里面需要A类(BookDaoImpl,是个Dao实现类)来实现,

//  所以BookServiceImpl类依赖于BookDaoImpl类

 class BookServiceImpl{

        //之前的开发:接口 = 实现类  (service和dao耦合)

              //private BookDao bookDao = new BookDaoImpl();

             //spring之后 (解耦:service实现类使用dao接口,不知道具体的实现类)

              private BookDao bookDao;

              setter方法
   }

模拟一下spring的执行过程:

创建service实例:BookService bookService = new BookServiceImpl()         -->IoC容器来创建对象  <bean>来配置

创建dao实例:BookDao bookDao = new BookDaoImple()                          -->IoC  容器来创建对象

将dao设置给service:bookService.setBookDao(bookDao);                          -->DI  <property>来配置,由IoC容器来注入依赖关系

3.1   目标类

  • 创建BookService接口和实现类
  • 创建BookDao接口和实现类
  • 将dao和service配置 xml文件
  • 使用api测试

3.1.1   dao

//Dao接口
public interface BookDao {

    public void addBook();

}

//Dao的实现类
public class BookDaoImpl implements BookDao {

    @Override
    public void addBook() {
        System.out.println("di  add book");
    }

}

3.1.2   service

//service的接口
public interface BookService {

    public abstract void addBook();

}

//service的实现类
public class BookServiceImpl implements BookService {

    // 方式1:之前,接口=实现类
//    private BookDao bookDao = new BookDaoImpl();
    // 方式2:接口 + setter
    private BookDao bookDao;
    public void setBookDao(BookDao bookDao) {
        this.bookDao = bookDao;
    }

    @Override
    public void addBook(){
        this.bookDao.addBook();
    }

}

3.2   配置文件

<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">
    <!--
    模拟spring执行过程
        创建service实例:BookService bookService = new BookServiceImpl()    IoC  <bean>
        创建dao实例:BookDao bookDao = new BookDaoImpl()            IoC
        将dao设置给service:bookService.setBookDao(bookDao);        DI   <property>

        <property> 用于进行属性注入
            name: bean的属性名,通过setter方法获得              name属性名的获得:setBookDao方法去掉“set” ##> BookDao 将其首字母小写 ##> bookDao(即得到name)
            ref :另一个bean的id值的引用(BookServiceImpl(B类)依赖于BookDaoImpl(A类))
     -->

    <!-- 创建service -->
    <bean id="bookServiceId" class="com.itheima.b_di.BookServiceImpl">
        <property name="bookDao" ref="bookDaoId"></property>
    </bean>

    <!-- 创建dao实例 -->
    <bean id="bookDaoId" class="com.itheima.b_di.BookDaoImpl"></bean>

</beans>

3.3  测试

@Test
    public void demo01(){
        //从spring容器获得
        String xmlPath = "com/itheima/b_di/beans.xml";
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext(xmlPath);
        BookService bookService = (BookService) applicationContext.getBean("bookServiceId");

        bookService.addBook();

    }

要创建bookService的实现,其执行过程:

先根据路径加载配置文件;读取配置文件,发现<property>中需要其他的东西,这里是需要Dao,spring容器就先new一个Dao出来,再回到new一个service,然后去执行其中的方法。

原文地址:https://www.cnblogs.com/JohnTeslaaa/p/10253346.html

时间: 2024-10-14 06:44:39

Spring3(一) 控制反转(IoC)和依赖注入(DI)的相关文章

iOS控制反转(IoC)与依赖注入(DI)的实现

背景 最近接触了一段时间的SpringMVC,对其控制反转(IoC)和依赖注入(DI)印象深刻,此后便一直在思考如何使用OC语言较好的实现这两个功能.Java语言自带的注解特性为IoC和DI带来了极大的方便,要在OC上较好的实现这两个功能,需要一些小小的技巧. 控制反转和依赖注入 控制反转 简单来说,将一个类对象的创建由手动new方式改为从IOC容器内获取,就是一种控制反转,例如我们现在要创建一个ClassA类,则常规方法为 ClassA *a = [ClassA new]; 如果使用控制反转,

控制反转IOC与依赖注入DI

1. IoC理论的背景我们都知道,在采用面向对象方法设计的软件系统中,它的底层实现都是由N个对象组成的,所有的对象通过彼此的合作,最终实现系统的业务逻辑. 图1:软件系统中耦合的对象 如果我们打开机械式手表的后盖,就会看到与上面类似的情形,各个齿轮分别带动时针.分针和秒针顺时针旋转,从而在表盘上产生正确的时间.图1中描述的就是这样的一个齿轮组,它拥有多个独立的齿轮,这些齿轮相互啮合在一起,协同工作,共同完成某项任务.我们可以看到,在这样的齿轮组中,如果有一个齿轮出了问题,就可能会影响到整个齿轮组

控制反转(Ioc)和依赖注入(DI)

控制反转IOC, 全称 “Inversion of Control”.依赖注入DI, 全称 “Dependency Injection”. 面向的问题:软件开发中,为了降低模块间.类间的耦合度,提倡基于接口的开发,那么在实现中必须面临最终是有“谁”提供实体类的问题.(将各层的对象以松耦合的方式组织起来,各层对象的调用面向接口.) 当一个类的实例需要另一个类的实例协助时,在传统的程序设计过程中,通常有调用者来创建被调用者的实例. 然后,采用依赖注入原则,创建被调用者的实例的工作不再由调用者完成,而

控制反转IOC与依赖注入DI - 理论篇

学无止境,精益求精 十年河东十年河西,莫欺少年穷 昨天是五一小长假归来上班的第一天,身体疲劳,毫无工作热情.于是就看看新闻,喝喝茶,荒废了一天 也就在昨天,康美同事张晶童鞋让我学习下IOC的理论及实现,毕竟是之前的好同事,好朋友,我也就抽时间百度了很多资料 在查阅网上资料的过程中,我发现大多技术篇幅都是IOC的代码实现,并没有一篇介绍IOC理论的篇幅!这显然不是我想要的. 我知道要想搞明白IOC,就必须要弄明白什么是IOC(控制反转)?为什么叫IOC(控制反转)?为什么之后又可以称为DI(依赖注

控制反转(IoC)与依赖注入(DI)

1.控制反转(Inversion of Control)与依赖注入(Dependency Injection) 控制反转即IoC (Inversion of Control),它把传统上由程序代码直接操控的对象的调用权交给容器,通过容器来实现对象组件的装配和管理.所谓的“控制反转”概念就是对组件对象控制权的转移,从程序代码本身转移到了外部容器. IoC是一个很大的概念,可以用不同的方式来实现.其主要实现方式有两种:<1>依赖查找(Dependency Lookup):容器提供回调接口和上下文环

spring中的控制反转IoC和依赖注入DI

原文:http://blog.163.com/[email protected]/blog/static/50639037200721345218382/ IoC(Inversion of Control),这是spring的核心,贯穿始终.所谓IoC,对于spring框架来说,就是由spring来负责控制对象的生命周期和对象间的关 系.这是什么意思呢,举个简单的例子,我们是如何找女朋友的?常见的情况是,我们到处去看哪里有长得漂亮身材又好的mm,然后打听她们的兴趣爱好.qq 号.电话号.手机号.

Spring入门--控制反转(IOC)与依赖注入(DI)

    1.控制反转(Inversion of Control)与依赖注入(Dependency Injection) 控制反转即IoC (Inversion of Control),它把传统上由程序代码直接操控的对象的调用权交给容器,通过容器来实现对象组件的装配和管理.所谓的"控制反转"概念就是对组件对象控制权的转移,从程序代码本身转移到了外部容器. IoC是一个很大的概念,可以用不同的方式来实现.其主要实现方式有两种:<1>依赖查找(Dependency Lookup)

AutoFac (控制反转IOC 与依赖注入DI)

绝世好文  转:http://blog.csdn.net/fanbin168/article/details/51293218 1 IOC概念(很重要) 项目 先引入AutoFac 和AutoFac MVC两个程序集到项目中 然后我们在MVC(UI层)的App_Start文件夹下创建一个AutoFacConfig.cs类 [csharp] view plain copy using System; using System.Collections.Generic; using System.Li

控制反转IOC的依赖注入方式

引言: 项目中遇到关于IOC的一些内容,因为和正常的逻辑代码比较起来,IOC有点反常.因此本文记录IOC的一些基础知识,并附有相应的简单实例,而在实际项目中再复杂的应用也只是在基本应用的基础上扩展而来的.本文目的两个,一是记录学习过程,以便将来温故:二是请大牛对小弟指点一二. 概念: 控制反转(Inversion of Control,英文缩写为IoC)是一个重要的面向对象的法则来削减计算机程序的耦合问题,也是轻量级的Spring框架的核心. 控制反转一般分为两种类型,依赖注入(Dependen

依赖耦合、解耦、控制反转(IOC)、依赖注入

随着net的深入学习,出现了很多概念性的东西需要理解,现在统一记录一下. 1.依赖:现阶段在任何一个有请求作用的系统,都会出现A类调用B类的情况,这时候A类就依赖于B类,A类和B类存在依赖关系. 2.耦合.解耦:A类依赖于B类,这时对B类调用,一般通过A a=new B();的形式,不过这个时候如果B类重构(例如:增加了一个参数param1),要保证A类的正确使用,则必须重新new:A a=new B(param1); 则此时A类和B类就是耦合关系.不过带来了很多的不方便之处,如果B类频繁变动,