您的位置: 首页  >  文章  >  好程序员Java干货分享Spring框架之IOC原理

好程序员Java干货分享Spring框架之IOC原理

分类: 文章 • 2025-06-11 17:40:33

好程序员Java干货分享Spring框架之IOC原理，前言：Spring框架是我们进行企业级开发的最常用框架，本章我们将了解Spring框架，并学习Spring的IOC特性以及IOC的实现原理：注解和反射。

Spring框架简介

　　Spring是一种轻量级的控制反转（IOC）和面向切面编程（AOP）的容器框架，能够为企业级开发提供一站式服务。

　　Spring的优点有

　　1.方便解耦，简化开发

　　通过Spring提供的IoC容器，我们可以将对象之间的依赖关系交由Spring进行控制，避免硬编码所造成的过度程序耦合。有了Spring，用户不必再为单实例模式类、属性文件解析等这些很底层的需求编写代码，可以更专注于上层的应用。

　　2.AOP编程的支持

　　通过Spring提供的AOP功能，方便进行面向切面的编程，许多不容易用传统OOP实现的功能可以通过AOP轻松应付。

　　3.声明式事务的支持

　　在Spring中，我们可以从单调烦闷的事务管理代码中解脱出来，通过声明式方式灵活地进行事务的管理，提高开发效率和质量。

　　4.方便程序的测试

　　可以用非容器依赖的编程方式进行几乎所有的测试工作，在Spring里，测试不再是昂贵的操作，而是随手可做的事情。例如：Spring对Junit4支持，可以通过注解方便的测试Spring程序。

　　5.方便集成各种优秀框架

　　Spring不排斥各种优秀的开源框架，相反，Spring可以降低各种框架的使用难度，Spring提供了对各种优秀框架（如Struts,Hibernate、Hessian、Quartz）等的直接支持。

　　6.降低Java EE API的使用难度

　　Spring对很多难用的Java EE API（如JDBC，JavaMail，远程调用等）提供了一个薄薄的封装层，通过Spring的简易封装，这些Java EE API的使用难度大为降低。

　　

Spring的组成

好程序员Java干货分享Spring框架之IOC原理

　　Spring Core：Spring 框架的核心。Spring其它组件都依赖于核心组件，主要通过BeanFactory提供IOC等服务。

　　Spring Context：Sprin上下文是一个配置文件，向 Spring框架提供上下文信息。Spring 上下文包括企业服务，例如JNDI、EJB、电子邮件、国际化、校验和调度功能。

　　Spring AOP：通过配置管理特性，Spring AOP 模块直接将面向切面的编程功能集成到了 Spring 框架中。

　　Spring ORM：Spring 框架插入了若干个ORM框架，从而提供了 ORM 的对象关系工具，其中包括JDO、Hibernate和iBatisSQL Map。所有这些都遵从 Spring 的通用事务和 DAO 异常层次结构。

　　Spring DAO:  DAO抽象层提供了有意义的异常层次结构，可用该结构来管理异常处理和不同数据库供应商抛出的错误消息。异常层次结构简化了错误处理，并且极大地降低了需要编写的异常代码数量（例如打开和关闭连接）。Spring DAO 的面向 JDBC 的异常遵从通用的 DAO 异常层次结构。

　　Spring Web:  Web 上下文模块建立在应用程序上下文模块之上，为基于 Web 的应用程序提供了上下文。所以，Spring框架支持与 Jakarta Struts 的集成。Web 模块还简化了处理多部分请求以及将请求参数绑定到域对象的工作。

　　Spring Web MVC: 为 web 应用提供了模型视图控制（MVC）和 REST Web 服务的实现。Spring 的 MVC 框架可以使领域模型代码和 web 表单完全地分离，且可以与 Spring 框架的其它所有功能进行集成。

　　

IOC和DI

　　IOC（Inverse Of Control）是控制反转的意思，作用是降低对象之间的耦合度。

　　一般情况下我们直接在对象内部通过new进行创建对象，是程序主动去创建依赖对象；而IoC是有专门一个容器来创建这些对象，即由Ioc容器来控制对象的创建；这样就是由容器来控制对象，而不是由我们的对象来控制，这样就完成了控制反转。

　　DI(Dependency Injection）即“依赖注入”：是组件之间依赖关系由容器在运行期决定，形象的说，即由容器动态的将某个依赖关系注入到组件之中。依赖注入的目的并非为软件系统带来更多功能，而是为了提升组件重用的频率，并为系统搭建一个灵活、可扩展的平台。通过依赖注入机制，我们只需要通过简单的配置，而无需任何代码就可指定目标需要的资源，完成自身的业务逻辑，而不需要关心具体的资源来自何处，由谁实现。

　　

IOC的原理：注解+反射

下面的案例讲解了IOC的原理，模拟为电脑配置不同的CPU和内存，CPU有AMD和INTEL两种，内存有DDR8G和DDR16G两种

  1. /**
  2. * CPU接口
  3. */
  4. public interface Cpu {
  5.  
  6. void run();
  7. }
  8. /**
  9. * 内存接口
  10. */
  11. public interface Memory {
  12.  
  13. void read();
  14. void write();
  15. }
  16. /**
  17. * AMD的CPU
  18. */
  19. public class AMDCpu implements Cpu {
  20.  
  21. public void run() {
  22. System.out.println("AMD的CPU正在运行....");
  23. }
  24. }
  25. /**
  26. * Intel的CPU
  27. */
  28. public class IntelCpu implements Cpu{
  29.  
  30. public void run() {
  31. System.out.println("Intel的CPU正在运行....");
  32. }
  33. }
  34. /**
  35. * DDR8G的内存
  36. */
  37. public class DDR8GMemory implements Memory {
  38. public void read() {
  39. System.out.println("使用DDR8G的内存读取数据....");
  40. }
  41.  
  42. public void write() {
  43. System.out.println("使用DDR8G的内存写入数据....");
  44. }
  45. }
  46. /**
  47. * DDR16G的内存
  48. */
  49. public class DDR16GMemory implements Memory {
  50. public void read() {
  51. System.out.println("使用DDR16G的内存读取数据....");
  52. }
  53.  
  54. public void write() {
  55. System.out.println("使用DDR16G的内存写入数据....");
  56. }
  57. }
  58. public class TestComputer {
  59.  
  60. @Test
  61. public void testComputer(){
  62. //硬编码方式创建对象
  63. Computer computer = new Computer();
  64. Cpu cpu = new IntelCpu();
  65. Memory memory = new DDR16GMemory();
  66. computer.setCpu(cpu);
  67. computer.setMemory(memory);
  68. computer.start();
  69. }
  70. }

 

上面是使用硬编码方式创建电脑的CPU和内存属性，代码和具体的子类紧密耦合，不利于后期的维护和扩展。

修改的思路是：不由让程序主动创建去创建CPU和内存对象，而是通过注解方式标记CPU和内存的类型，使用反射将CPU和内存的对象注入到电脑的属性中。

添加代码：

  1. /**
  2. * 电脑组件的注解
  3. */
  4. @Retention(RetentionPolicy.RUNTIME)
  5. @Target(ElementType.FIELD)
  6. public @interface MyComponent {
  7. /**
  8. * 组件类型
  9. * @return
  10. */
  11. Class componentClass();
  12. }
  13. /**
  14. * 电脑类
  15. */
  16. public class Computer {
  17.  
  18. @MyComponent(componentClass = IntelCpu.class)
  19. private Cpu cpu;
  20.  
  21. @MyComponent(componentClass = DDR8GMemory.class)
  22. private Memory memory;
  23.  
  24. ....}
  25.  
  26. public class TestComputer {
  27.  
  28. @Test
  29. public void testComputer(){
  30. //通过反射和注解，将cpu和memory属性注入进去
  31. try {
  32. //获得Computer类型
  33. Class<Computer> computerClass = Computer.class;
  34. //创建Computer对象
  35. Computer computer = computerClass.newInstance();
  36. //获得Computer对象的属性
  37. Field[] fields = computerClass.getDeclaredFields();
  38. //遍历属性
  39. for(Field field : fields){
  40. //获得属性上定义的MyComponent注解
  41. MyComponent anno = field.getDeclaredAnnotation(MyComponent.class);
  42. //获得配置的组件类型
  43. Class aClass = anno.componentClass();
  44. //创建该组件的对象
  45. Object comp = aClass.newInstance();
  46. //调用set方法赋值给属性
  47. String name = field.getName();
  48. name = "set" + name.substring(0,1).toUpperCase() + name.substring(1);
  49. //通过方法名和参数类型获得方法
  50. Method method = computerClass.getDeclaredMethod(name, field.getType());
  51. //调用方法
  52. method.invoke(computer,comp);
  53. }
  54. //启动电脑
  55. computer.start();
  56. } catch (Exception e) {
  57. e.printStackTrace();
  58. }
  59. }
  60. }

程序如上面修改后，后期如果需要修改电脑的配置，只需要修改注解配置的类型，就可以注入不同的电脑组件，这样就降低了代码间的耦合性，维护代码变得比较简单。

  @MyComponent(componentClass = AMDCpu.class)

    private Cpu cpu;

 

  @MyComponent(componentClass = DDR16GMemory.class)

   private Memory memory;

 

总结

IOC（控制反转）是Spring最重要的原理，它将创建对象的主动权交给Spring容器，Spring程序只需要进行一些配置，就可以使用不同的对象，极大的降低了代码耦合性，提高了程序的灵活性，IOC的实现原理是反射机制。

相关推荐