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

时间 2019-12-06

标签程序员 java 干货分享 spring 框架 ioc 原理栏目快乐工作繁體版

原文原文链接

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

Spring框架简介

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

Spring的优势有数据库

1.方便解耦，简化开发编程

　　经过Spring提供的IoC容器，咱们能够将对象之间的依赖关系交由Spring进行控制，避免硬编码所形成的过分程序耦合。有了Spring，用户没必要再为单实例模式类、属性文件解析等这些很底层的需求编写代码，能够更专一于上层的应用。框架

2.AOP编程的支持工具

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

3.声明式事务的支持测试

　　在Spring中，咱们能够从单调烦闷的事务管理代码中解脱出来，经过声明式方式灵活地进行事务的管理，提升开发效率和质量。编码

4.方便程序的测试spa

　　能够用非容器依赖的编程方式进行几乎全部的测试工做，在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的组成

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两种

/**
* CPU接口
*/
public interface Cpu {
void run();
}
/**
* 内存接口
*/
public interface Memory {
void read();
void write();
}
/**
* AMD的CPU
*/
public class AMDCpu implements Cpu {
public void run() {
System.out.println("AMD的CPU正在运行....");
}
}
/**
* Intel的CPU
*/
public class IntelCpu implements Cpu{
public void run() {
System.out.println("Intel的CPU正在运行....");
}
}
/**
* DDR8G的内存
*/
public class DDR8GMemory implements Memory {
public void read() {
System.out.println("使用DDR8G的内存读取数据....");
}
public void write() {
System.out.println("使用DDR8G的内存写入数据....");
}
}
/**
* DDR16G的内存
*/
public class DDR16GMemory implements Memory {
public void read() {
System.out.println("使用DDR16G的内存读取数据....");
}
public void write() {
System.out.println("使用DDR16G的内存写入数据....");
}
}
public class TestComputer {
@Test
public void testComputer(){
//硬编码方式建立对象
Computer computer = new Computer();
Cpu cpu = new IntelCpu();
Memory memory = new DDR16GMemory();
computer.setCpu(cpu);
computer.setMemory(memory);
computer.start();
}
}

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

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

添加代码：

/**
* 电脑组件的注解
*/
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface MyComponent {
/**
* 组件类型
* @return
*/
Class componentClass();
}
/**
* 电脑类
*/
public class Computer {
@MyComponent(componentClass = IntelCpu.class)
private Cpu cpu;
@MyComponent(componentClass = DDR8GMemory.class)
private Memory memory;
....}
public class TestComputer {
@Test
public void testComputer(){
//经过反射和注解，将cpu和memory属性注入进去
try {
//得到Computer类型
Class<Computer> computerClass = Computer.class;
//建立Computer对象
Computer computer = computerClass.newInstance();
//得到Computer对象的属性
Field[] fields = computerClass.getDeclaredFields();
//遍历属性
for(Field field : fields){
//得到属性上定义的MyComponent注解
MyComponent anno = field.getDeclaredAnnotation(MyComponent.class);
//得到配置的组件类型
Class aClass = anno.componentClass();
//建立该组件的对象
Object comp = aClass.newInstance();
//调用set方法赋值给属性
String name = field.getName();
name = "set" + name.substring(0,1).toUpperCase() + name.substring(1);
//经过方法名和参数类型得到方法
Method method = computerClass.getDeclaredMethod(name, field.getType());
//调用方法
method.invoke(computer,comp);
}
//启动电脑
computer.start();
} catch (Exception e) {
e.printStackTrace();
}
}
}

程序如上面修改后，后期若是须要修改电脑的配置，只须要修改注解配置的类型，就能够注入不一样的电脑组件，这样就下降了代码间的耦合性，维护代码变得比较简单。

@MyComponent(componentClass = AMDCpu.class)

private Cpu cpu;

@MyComponent(componentClass = DDR16GMemory.class)

private Memory memory;

总结

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