Spring：概述及IOC理论推导

Spring：概述及IOC理论推导

一、简介

  • Spring: 春天

  • 2002年，Rod Jahnson首次推出Spring框架雏形interface21框架

  • 2004年3月24日，Spring框架以interface21框架为基础，经过重新设计，发布了1.0正式版

  • Rod Jahnson是音乐学博士

  • Spring理念：使先有的技术更加实用，本身就是一个大杂烩，整合现有的框架技术

  • 官网：http://spring.io/

  • 官方下载地址：https://repo.spring.io/libs-release-local/org/springframework/spring/

  • GitHub : https://github.com/spring-projects

    SPring依赖
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.3.4</version>
</dependency>

1.1 优点

  1. Spring是一个开源的免费的框架，容器

  2. Spring是一个轻量级框架，非入侵式；

  3. 控制反转（IOC），面向切面编程（Aop）

  4. 对事物的支持，对框架的支持；

一句话概括：

Spring是一个轻量级的控制反转（IOC）和面向切面（AOP）的容器（框架）

1.2 组成

Spring 框架是一个分层架构，由 7 个定义良好的模块组成。Spring 模块构建在核心容器之上，核心容器定义了创建、配置和管理 bean 的方式 .

  • 核心容器：核心容器提供 Spring 框架的基本功能。核心容器的主要组件是 BeanFactory，它是工厂模式的实现。BeanFactory 使用控制反转（IOC） 模式将应用程序的配置和依赖性规范与实际的应用程序代码分开。

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

  • Spring AOP：通过配置管理特性，Spring AOP 模块直接将面向切面的编程功能 , 集成到了 Spring 框架中。所以，可以很容易地使 Spring 框架管理任何支持 AOP的对象。Spring AOP 模块为基于 Spring 的应用程序中的对象提供了事务管理服务。通过使用 Spring AOP，不用依赖组件，就可以将声明性事务管理集成到应用程序中。

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

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

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

  • Spring MVC 框架：MVC 框架是一个全功能的构建 Web 应用程序的 MVC 实现。通过策略接口，MVC 框架变成为高度可配置的，MVC 容纳了大量视图技术，其中包括 JSP、Velocity、Tiles、iText 和 POI。

二、IOC理论推导

传统方式根据mvc设计模式：

  1. 新建maven项目

  2. 删除父工程src包，创建子模块，先写一个UserDao接口；

    public interface UserDao {
    void getUser();
}

  3. 再写一个UserDao实现类；

    public class UserDaoImpl implements UserDao{
​
    @Override
    public void getUser() {
        System.out.println("获取用户数据");
    }
}

  4. 再写一个UserService的接口；

    public interface UserService {
    void getUser();
}

  5. 再写一个UserService的实现类；

    public class UserServiceImpl implements UserService{
    private  UserDao userDao = new UserDaoImpl();
    @Override
    public void getUser() {
        userDao.getUser();
    }
}

  6. 测试。

    @Test
public void testUserDao(){
    UserService userService = new UserServiceImpl();
    userService.getUser();
}

这样可能看起来效果并不明显，现在我们增加几个UserDao接口的实现类：

public class UserDaoMysqlImpl implements UserDao{
    @Override
    public void getUser() {
        System.out.println("获取Mysql用户数据");
    }
}
​
public class UserDaoOracleImpl implements UserDao{
    @Override
    public void getUser() {
        System.out.println("获取Oracle用户数据");
    }
}

现在如果要实现调用新建的两个类的方法就需要在UserService实现类中new 这两个类，想象一下如果新建的实现类多，则每一次调用不同的实现类都需要修改代码，这样大大的增加了程序员的负担，现在我们把代码稍作修改再看一下：

public class UserServiceImpl implements UserService{
    private  UserDao userDao;
​
    @Override
    public void getUser() {
        userDao.getUser();
    }
​
    @Override
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }
}
public class MyTest {
    @Test
    public void testUserDao(){
         UserService userService = new UserServiceImpl();
         userService.setUserDao(new UserDaoOracleImpl());
         userService.getUser();
    }
}

 

这里已经发生了根本性的变化 , 很多地方都不一样了 .

仔细去思考一下 , 以前所有东西都是由程序去进行控制创建 , 而现在是由我们自行控制创建对象 , 把主动权交给了调用者 . 程序不用去管怎么创建,怎么实现了 . 它只负责提供一个接口 .

这就是粗浅来讲的控制反转。

下面修改我们第一个程序：

<?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">
​
    <bean id="UserDaoImpl" class="com.aishimin.dao.UserDaoImpl"/>
    <bean id="UserDaoMysqlImpl" class="com.aishimin.dao.UserDaoMysqlImpl"/>
    <bean id="UserDaoOracleImpl" class="com.aishimin.dao.UserDaoOracleImpl"/>
    <bean id="UserServiceImpl" class="com.aishimin.service.UserServiceImpl">
        <property name="userDao" ref="UserDaoMysqlImpl"/>
    </bean>
​
</beans>
public class MyTest {
    @Test
    public void testUserDao(){
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        UserServiceImpl userServiceImpl = (UserServiceImpl) context.getBean("UserServiceImpl");
        userServiceImpl.getUser();
    }
​
}

可以看出，现在不需要在程序中去改动，要实现不同的操作，只需要在xml配置文件中进行修改。即：对象由Spring来创建，管理和装配。

 

三、Ioc的本质

3.1 Ioc是什么

Ioc，即控制反转，不是什么技术，而是一种设计思想。在java开发中，我们将设计好的对象交给容器去控制，而不是传统的在对对象内部直接控制。

核心问题为：谁控制了谁？控制了什么？为何被叫做控制反转？

  • 谁控制了谁，控制了什么：传统的程序设计，我们直接在对象内部通过new创建新对象，是程序主动去依赖对象；而Ioc意味着将设计好的对象交给容器控制，而不是传统的在对象内部直接控制。谁控制谁？当然是Ioc容器控制对象；控制了什么？那就是主要控制了外部资源的获取。

  • 为何被叫做控制反转？：传统的应用程序，我们直接在对象内部主动控制去获取依赖对象，这称为正转；而反转则是由容器帮忙创建及注入依赖对象。因为由容器帮我们查找及注入依赖，对象只是被动的接受依赖对象，所以被叫做反转。所谓的反转就是获取对象的依赖方式反转了。

Spring容器在初始化时先读取配置文件，根据配置文件或元数据创建与组织对象存入容器中，程序使用时再从Ioc容器中取出需要的对象。

控制反转是一种通过描述（XML或注解）并通过第三方去生产或获取特定对象的方式。在Spring中实现控制反转的是IoC容器，其实现方法是依赖注入（Dependency Injection,DI）。

3.2 Ioc能做什么

传统的应用程序，我们需要在对象内部通过new创建新对象是主动的创建依赖对象，从而导致类与类之间的高耦合，难于测试；有了Ioc容器之后，我们将创建和查找依赖对象的控制权交给容器，对容器内进行注入组合对象，所以对象与对象之间是松散耦合的，方便测试。

采用了Ioc容器，发生了“主从换位”的变化。应用程序原本是老大，要获取什么资源都是主动出击，但是在Ioc思想下，应用程序就变得被动了，被动的等待Ioc容器来创建并注入他所需要的资源。

Ioc很好的体现了——“别找我们，我们找你”。即由Ioc容器帮对象找相应的依赖对象并注入，而不是对象主动去找。

3.3 自己关于Ioc的理解

在传统的java程序中，根据Mvc设计模式，如果我们要完成一项业务的话，需要业务逻辑层（Service）、数据处理层（Dao）一起组合完成，业务逻辑层需要创建Dao对象，并调用方法。这就代表Service类依赖Dao类，这样的代码具有高耦合性。当我们引入Spring时，在开发之前，Spring已经创建了Dao对象，并存放到Ioc容器中，当Service对象需要使用到Dao对象时，只需要从容器中取出来，就可以使用Dao对象及他的资源。

控制反转表示创建对象的权利转移了，现在把权利全部转移到Ioc容器上，有了Ioc容器，依赖关系就变了，全部都依赖Ioc容器了，通过Ioc容器来建立关系。

posted @ 2021-02-22 18:28  aishimin  阅读(93)  评论(0)    收藏  举报