Spring 入门容器以及反转控制IOC

Spring

1、Spring 简介

Spring 是于 2003 年兴起的一个轻量级的 Java 开发框架，它是为了解决企业应用开发的复杂性而创建的。Spring 的核心是控制反转（IoC）和面向切面编程（AOP）。简单来说，Spring 是一个分层的 Java SE/EE full-stack(一站式)轻量级开源框架。

概述

Spring 的主要作用就是为代码“解耦”，降低代码间的耦合度。

根据功能的不同，可以将一个系统中的代码分为 主业务逻辑 与 系统级业务逻辑 两类。它们各自具有鲜明的特点：主业务代码间逻辑联系紧密，有具体的专业业务应用场景，复用性相对较低；系统级业务相对功能独立，没有具体的专业业务应用场景，主要是为主业务提供系统级服务，如日志、安全、事务等，复用性强。

Spring 根据代码的功能特点，将降低耦合度的方式分为了两类：IoC 与 AOP。

IoC 使得主业务在相互调用过程中，不用再自己维护关系了，即不用再自己创建要使用的对象了。而是由 Spring 容器统一管理，自动“注入”。

而 AOP 使得系统级服务得到了最大复用，且不用再由程序员手工将系统级服务“混杂”到主业务逻辑中了，而是由 Spring 容器统一完成“织入”。

Spring 是于 2003 年兴起的一个轻量级的 Java 开发框架，它是为了解决企业应用开发的复杂性而创建的。

Spring 的核心是控制反转（IoC）和面向切面编程（AOP）。

简单来说，Spring 是一个分层的 Java SE/EE full-stack(一站式)轻量级开源框架。

Spring框架也称为胶水框架

Spring 主要作用

Spring 是为了解决企业级开发的复杂度问题。

系统开发过程中：

1. 主业务逻辑：例如有：银行业务，保险业务，电商业务，物流业务

2. 系统级业务逻辑，交叉业务逻辑。

   • JDBC 连接数据库：

     1. 加载驱动 Driver

     2. 创建连接

     3. 开启事务

     4. SQL操作 具体业务

     5. 提交事务

     6. 释放链接

2 、Spring体系结构

概述

image

Spring 由 20 多个模块组成，它们可以分为数据访问/集成（Data Access/Integration）、Web、面向切面编程（AOP, Aspects）、应用服务器设备管理（Instrumentation）、消息发送（Messaging）、核心容器（Core Container）和测试（Test）。

数据访问/集成（Data Access/Integration）：

1. JDBC：Spring对JDBC的轻量级实现，自己实现了JDBC事务。

2. ORM： 对象关系映射。如 Mybatis，Hibernate，Mybatis-plus等。

3. OXM：O/X映射器这个概念并不新鲜，O代表Object，X代表XML。它的目的是在Java对象（几乎总是一个plainoldJavaobject，或简写为POJO）和XML文档之间来回转换。

Web：

1. WebSocket：WebSocket是一种在单个TCP连接上进行全双工通信的协议。WebSocket使得客户端和服务器之间的数据交换变得更加简单，允许服务端主动向客户端推送数据。在WebSocket API中，浏览器和服务器只需要完成一次握手，两者之间就直接可以创建持久性的连接，并进行双向数据传输。

2. Servlet：

3. Web：SpringMVC。

4. Portlet：Portlet是基于Java的Web组件，由Portlet容器管理，并由容器处理请求，生产动态内容。有portlet完成组件的拼接。

面向切面编程（AOP, Aspects）：

1. AOP：AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。

2. Aspects：切面。

核心容器（Core Container）：

假如没有核心容器的话就不能搭建上层的实现。

3、Spring的特点

非侵入式

所谓非侵入式是指，Spring 框架的 API 不会在业务逻辑上出现，即业务逻辑是 POJO。由于业务逻辑中没有 Spring 的 API，所以业务逻辑可以从 Spring 框架快速的移植到其他框架， 即与环境无关。

例如：做JAVA Web时候 需要引入 Servlet javax.servlet-api 需要继承：HTTPServlet。这就是侵入式。

容器

Spring 作为一个容器，可以管理对象的生命周期、对象与对象之间的依赖关系。可以通过配置文件，来定义对象，以及设置与其他对象的依赖关系。

IoC

控制反转（Inversion of Control），即创建被调用者的实例不是由调用者完成，而是由 Spring 容器完成，并注入调用者。

当应用了 IoC，一个对象依赖的其它对象会通过被动的方式传递进来，而不是这个对象自己创建或者查找依赖对象。即，不是对象从容器中查找依赖，而是容器在对象初始化时不等对象请求就主动将依赖传递给它。

AOP

面向切面编程（AOP，Aspect Orient Programming），是一种编程思想，是面向对象编程 OOP 的补充。很多框架都实现了对 AOP 编程思想的实现。Spring 也提供了面向切面编程的丰富支持，允许通过分离应用的业务逻辑与系统级服务（例如日志和事务管理）进行开发。应用对象只实现它们应该做的——完成业务逻辑——仅此而已。它们并不负责其它的系统级关注点，例如日志或事务支持。

我们可以把日志、安全、事务管理等服务理解成一个“切面”，那么以前这些服务一直是直接写在业务逻辑的代码当中的，这有两点不好：首先业务逻辑不纯净；其次这些服务被很多业务逻辑反复使用，完全可以剥离出来做到复用。那么 AOP 就是这些问题的解决方案， 可以把这些服务剥离出来形成一个“切面”，以期复用，然后将“切面”动态的“织入”到业务逻辑中，让业务逻辑能够享受到此“切面”的服务。

4、Spring 与 IoC

概述

控制反转（IoC，Inversion of Control），是一个概念，是一种思想。指将传统上由程序代码直接操控的对象调用权交给容器，通过容器来实现对象的装配和管理。控制反转就是对对象控制权的转移，从程序代码本身反转到了外部容器。

IoC 是一个概念，是一种思想，其实现方式多种多样。当前比较流行的实现方式有两种： 依赖注入和依赖查找。依赖注入方式应用更为广泛。

• 依赖查找：Dependency Lookup，DL，容器提供回调接口和上下文环境给组件，程序代码则需要提供具体的查找方式。比较典型的是依赖于 JNDI 系统的查找。

• 依赖注入：Dependency Injection，DI，程序代码不做定位查询，这些工作由容器自行完成。

依赖注入 DI 是指程序运行过程中，若需要调用另一个对象协助时，无须在代码中创建被调用者，而是依赖于外部容器，由外部容器创建后传递给程序。

Spring 的依赖注入对调用者与被调用者几乎没有任何要求，完全支持 POJO 之间依赖关系的管理。

依赖注入是目前最优秀的解耦方式。依赖注入让 Spring 的 Bean 之间以配置文件的方式组织在一起，而不是以硬编码的方式耦合在一起的。

5、 第一个Spring 应用

POM

创建一个工程名为 hello-spring 的项目，pom.xml 文件如下：

    4.0.0

    com.funtl
    hello-spring
    1.0.0-SNAPSHOT
    jar

    
        
            org.springframework
            spring-context
            4.3.17.RELEASE
        
    

主要增加了 org.springframework:spring-context 依赖

创建接口与实现

创建 UserService 接口

public interface UserService {
 public void sayHi();
}

创建 UserServiceImpl 实现

import com.funtl.hello.spring.service.UserService;
​
public class UserServiceImpl implements UserService {
 public void sayHi() {
 System.out.println("Hello Spring");
 }
}

创建 Spring 配置文件

在 src/main/resources 目录下创建 spring-context.xml 配置文件，从现在开始类的实例化工作交给 Spring 容器管理（IoC），配置文件如下：

​
 

• ：用于定义一个实例对象。一个实例对应一个 bean 元素。

• id：该属性是 Bean 实例的唯一标识，程序通过 id 属性访问 Bean，Bean 与 Bean 间的依赖关系也是通过 id 属性关联的。

• class：指定该 Bean 所属的类，注意这里只能是类，不能是接口。

测试 Spring IoC

创建一个 MyTest 测试类，测试对象是否能够通过 Spring 来创建，代码如下：

package com.funtl.hello.spring;
​
import com.funtl.hello.spring.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
​
public class MyTest {
​
 public static void main(String[] args) {
 // 获取 Spring 容器
 ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-context.xml");

 // 从 Spring 容器中获取对象
 UserService userService = (UserService) applicationContext.getBean("userService");
 userService.sayHi();
 }
}

上述代码就是控制反转与依赖注入。