共计 8066 个字符，预计需要花费 21 分钟才能阅读完成。
spring 初识
1、框架
框架就是一些类和接口的汇合，通过这些类和接口协调来实现一系列的程序实现。JAVA 框架能够分为三层：表示层，业务层和物理层。框架又叫做开发中的半成品，它不能提供整个 WEB 应用程序的所有货色，然而有了框架，咱们就能够集中精力进行业务逻辑的开发而不必去关怀它的技术实现以及一些辅助的业务逻辑。大家熟知的 Structs 和 Spring 就是表示层和业务层框架的强力代表。（说的太官网了）
人话：
框架就是某些集体或者组织定义了一系列的类或者接口，提前定义好了一些实现，用户能够在这些类和接口的根底之上，应用这些类来迅速的造成某个畛域或者某个行业的解决方案，简化开发的过程，进步开发的效率。就好比：你要盖一座房子，先把柱子，房梁等先建设好，而后只须要向房子中填充就能够了，能够依照本人的需要进行设计，其实咱们做的我的项目、零碎都是相似的形式，如果所有的代码全副都须要本人实现，那么这个工程就太宏大了，所以能够先创立出一些根底的模板框架，开发人员只须要依照本人的需要向架子中填充内容，实现本人独特需要即可，这就是框架存在的意义。其实咱们之前定义的简略的工具类这些货色也是相似的原理，只不过比拟繁多简略而已，因而，在当初的很多我的项目零碎开发的过程中都是利用框架进行开发。
2、spring（春天）
架构设计
随着互联网的倒退，网站利用的规模不断扩大，惯例的垂直利用架构已无奈应答，分布式服务架构以及流动计算架构势在必行，亟需一个治理零碎确保架构井井有条的演进。
繁多利用架构
当网站流量很小时，只需一个利用，将所有性能都部署在一起，以缩小部署节点和老本。此时，用于简化增删改查工作量的数据拜访框架 (ORM) 是要害。
垂直利用架构
当访问量逐步增大，繁多利用减少机器带来的加速度越来越小，晋升效率的办法之一是将利用拆成互不相干的几个利用，以晋升效率。此时，用于减速前端页面开发的 Web 框架 (MVC) 是要害。
分布式服务架构
当垂直利用越来越多，利用之间交互不可避免，将外围业务抽取进去，作为独立的服务，逐步造成稳固的服务中心，使前端利用能更疾速的响应多变的市场需求。此时，用于进步业务复用及整合的分布式服务框架 (RPC) 是要害。
流动计算架构
当服务越来越多，容量的评估，小服务资源的节约等问题逐步浮现，此时需减少一个调度核心基于拜访压力实时治理集群容量，进步集群利用率。此时，用于进步机器利用率的资源调度和治理核心 (SOA) 是要害。
Java 支流框架演变之路
1、JSP+Servlet+JavaBean
2、MVC 三层架构
3、应用 EJB 进行利用的开发，然而 EJB 是重量级框架（在应用的时候，过多的接口和依赖，侵入性强），在应用上比拟麻烦
4、Struts1/Struts2+Hibernate+Spring
5、SpringMVC+Mybatis+Spring
6、SpringBoot 开发，约定大于配置
Spring 官网
官网地址：https://spring.io/projects/spring-framework#overview
压缩包下载地址：https://repo.spring.io/release/org/springframework/spring/
源码地址：https://github.com/spring-projects/spring-framework
Spring makes it easy to create Java enterprise applications. It provides everything you need to embrace the Java language in an enterprise environment, with support for Groovy and Kotlin as alternative languages on the JVM, and with the flexibility to create many kinds of architectures depending on an application’s needs. As of Spring Framework 5.1, Spring requires JDK 8+ (Java SE 8+) and provides out-of-the-box support for JDK 11 LTS. Java SE 8 update 60 is suggested as the minimum patch release for Java 8, but it is generally recommended to use a recent patch release.
Spring supports a wide range of application scenarios. In a large enterprise, applications often exist for a long time and have to run on a JDK and application server whose upgrade cycle is beyond developer control. Others may run as a single jar with the server embedded, possibly in a cloud environment. Yet others may be standalone applications (such as batch or integration workloads) that do not need a server.
Spring is open source. It has a large and active community that provides continuous feedback based on a diverse range of real-world use cases. This has helped Spring to successfully evolve over a very long time.
Spring 使创立 Java 企业应用程序变得更加容易。它提供了在企业环境中承受 Java 语言所需的所有,，并反对 Groovy 和 Kotlin 作为 JVM 上的代替语言，并可依据应用程序的须要灵便地创立多种体系结构。从 Spring Framework 5.0 开始，Spring 须要 JDK 8(Java SE 8+)，并且曾经为 JDK 9 提供了现成的反对。
Spring 反对各种利用场景，在大型企业中, 应用程序通常须要运行很长时间，而且必须运行在 jdk 和应用服务器上，这种场景开发人员无法控制其降级周期。其余可能作为一个独自的 jar 嵌入到服务器去运行，也有可能在云环境中。还有一些可能是不须要服务器的独立应用程序(如批处理或集成的工作工作)。
Spring 是开源的。它领有一个宏大而且沉闷的社区，提供不同范畴的，实在用户的继续反馈。这也帮忙 Spring 一直地改良, 一直倒退。
外围解释
spring 是一个开源框架。
spring 是为了简化企业开发而生的，使得开发变得更加优雅和简洁。
spring 是一个 IOC 和AOP的容器框架。
IOC：管制反转
AOP：面向切面编程
容器：蕴含并治理利用对象的生命周期，就好比用桶装水一样，spring 就是桶，而对象就是水
应用 spring 的长处
1、Spring 通过 DI、AOP 和打消样板式代码来简化企业级 Java 开发
2、Spring 框架之外还存在一个构建在外围框架之上的宏大生态圈，它将 Spring 扩大到不同的畛域，如 Web 服务、REST、挪动开发以及 NoSQL
3、低侵入式设计，代码的净化极低
4、独立于各种应用服务器，基于 Spring 框架的利用，能够真正实现 Write Once,Run Anywhere 的承诺
5、Spring 的 IoC 容器升高了业务对象替换的复杂性，进步了组件之间的解耦
6、Spring 的 AOP 反对容许将一些通用工作如平安、事务、日志等进行集中式解决，从而提供了更好的复用
7、Spring 的 ORM 和 DAO 提供了与第三方长久层框架的的良好整合，并简化了底层的数据库拜访
8、Spring 的高度开放性，并不强制利用齐全依赖于 Spring，开发者可自在选用 Spring 框架的局部或全副
如何简化开发
基于 POJO 的轻量级和最小侵入性编程
通过依赖注入和面向接口实现松耦合
基于切面和常规进行申明式编程
通过切面和模板缩小样板式代码
spring 的模块划分图
模块解释：
Test:Spring 的单元测试模块
Core Container: 外围容器模块
AOP+Aspects: 面向切面编程模块
Instrumentation: 提供了 class instrumentation 反对和类加载器的实现来在特定的应用服务器上应用, 简直不必
Messaging: 包含一系列的用来映射音讯到办法的注解, 简直不必
Data Access/Integration: 数据的获取 / 整合模块，包含了 JDBC,ORM,OXM,JMS 和事务模块
Web: 提供面向 web 整合个性
3、IOC（Inversion of Control）: 管制反转
为什么要引入 IOC
创立一个一般的 java 我的项目，实现下述性能
UserDao.java
package com.mashibing.dao;
public interface UserDao {
public void getUser();
}
UserDaoImpl.java
package com.mashibing.dao.impl;
import com.mashibing.dao.UserDao;
public class UserDaoImpl implements UserDao {
@Override
public void getUser() {
System.out.println(“ 获取用户数据 ”);
}
}
UserService.java
package com.mashibing.service;
public interface UserService {
public void getUser();
}
UserServiceImpl.java
package com.mashibing.service.impl;
import com.mashibing.dao.UserDao;
import com.mashibing.dao.impl.UserDaoImpl;
import com.mashibing.dao.impl.UserDaoMysqlImpl;
import com.mashibing.service.UserService;
public class UserServiceImpl implements UserService {
private UserDao userDao = new UserDaoImpl();
@Override
public void getUser() {
userDao.getUser();
}
}
SpringDemoTest.java
package com.mashibing.test;
import com.mashibing.service.UserService;
import com.mashibing.service.impl.UserServiceImpl;
public class SpringDemoTest {
public static void main(String[] args) {
UserService service = new UserServiceImpl();
service.getUser();
}
}
在之前的代码编写过程中，咱们都是这么实现咱们的性能的，然而如果减少一个 UserDao 的实现类呢？
UserDaoMysqlImpl.java
package com.mashibing.dao.impl;
import com.mashibing.dao.UserDao;
public class UserDaoMysqlImpl implements UserDao {
@Override
public void getUser() {
System.out.println(“mysql”);
}
}
如果咱们想要应用 mysql 的话，那么就必须要批改 UserServiceImpl.java 的代码：
package com.mashibing.service.impl;
import com.mashibing.dao.UserDao;
import com.mashibing.dao.impl.UserDaoImpl;
import com.mashibing.dao.impl.UserDaoMysqlImpl;
import com.mashibing.service.UserService;
public class UserServiceImpl implements UserService {
private UserDao userDao = new UserDaoImpl();
@Override
public void getUser() {
userDao.getUser();
}
}
然而如果咱们再减少一个 oracle 的类呢？
UserDaoOracleImpl.java
package com.mashibing.dao.impl;
import com.mashibing.dao.UserDao;
public class UserDaoOracleImpl implements UserDao {
@Override
public void getUser() {
System.out.println(“oracle”);
}
}
此时 UserService 还是要持续批改，很显然这样的形式曾经不适用于咱们的需要了，那么怎么解决呢，能够应用如下的形式
UserServiceImpl.java
package com.mashibing.service.impl;
import com.mashibing.dao.UserDao;
import com.mashibing.dao.impl.UserDaoImpl;
import com.mashibing.service.UserService;
public class UserServiceImpl implements UserService {
private UserDao userDao;
public void setUserDao(UserDao userDao){
this.userDao = userDao;
}
@Override
public void getUser() {
userDao.getUser();
}
}
测试类 SpringDemoTest.java
package com.mashibing.test;
import com.mashibing.dao.impl.UserDaoMysqlImpl;
import com.mashibing.dao.impl.UserDaoOracleImpl;
import com.mashibing.service.UserService;
import com.mashibing.service.impl.UserServiceImpl;
public class SpringDemoTest {
public static void main(String[] args) {
UserServiceImpl userService = new UserServiceImpl();
userService.setUserDao(new UserDaoMysqlImpl());
userService.getUser();
userService.setUserDao(new UserDaoOracleImpl());
userService.getUser();
}
}
其实从刚刚的代码中，大家应该能领会解耦的重要性了，上面咱们就开始学习 Spring 的 IOC。
IOC 初始
想要搞明确 IOC，那么须要搞清楚如下几个问题：
1、谁管制谁
2、管制什么
3、什么是反转
4、哪些方面被反转
基本概念
IoC is also known as dependency injection (DI). It is a process whereby objects define their dependencies (that is, the other objects they work with) only through constructor arguments, arguments to a factory method, or properties that are set on the object instance after it is constructed or returned from a factory method. The container then injects those dependencies when it creates the bean. This process is fundamentally the inverse (hence the name, Inversion of Control) of the bean itself controlling the instantiation or location of its dependencies by using direct construction of classes or a mechanism such as the Service Locator pattern.
IOC 与大家熟知的依赖注入同理，. 这是一个通过依赖注入对象的过程 也就是说，它们所应用的对象，是通过结构函数参数，工厂办法的参数或这是从工厂办法的构造函数或返回值的对象实例设置的属性，而后容器在创立 bean 时注入这些须要的依赖。这个过程绝对一般创建对象的过程是反向的（因而称之为 IoC），bean 自身通过间接结构类来管制依赖关系的实例化或地位，或提供诸如服务定位器模式之类的机制。
如果这个过程比拟难了解的话，那么能够设想本人找女朋友和婚介公司找女朋友的过程。如果这个过程可能想明确的话，那么咱们当初答复下面的问题：
1、谁管制谁：在之前的编码过程中，都是须要什么对象本人去创立什么对象，有程序员本人来管制对象，而有了 IOC 容器之后，就会变成由 IOC 容器来管制对象，
2、管制什么：在实现过程中所须要的对象及须要依赖的对象
3、什么是反转：在没有 IOC 容器之前咱们都是在对象中被动去创立依赖的对象，这是正转的，而有了 IOC 之后，依赖的对象间接由 IOC 容器创立后注入到对象中，由被动创立变成了被动承受，这是反转
4、哪些方面被反转：依赖的对象
DI 与 IOC
很多人把 IOC 和 DI 说成一个货色，抽象来说的话是没有问题的，然而实质上还是有所区别的, 心愿大家可能谨严一点，IOC 和 DI 是从不同的角度形容的同一件事，IOC 是从容器的角度形容，而 DI 是从应用程序的角度来形容，也能够这样说，IOC 是设计思维，而 DI 是具体的实现形式
4、总结
在此处总结中，心愿大家可能可能明确两件事：
1、解耦
在面向对象设计的软件系统中，底层的实现都是由 N 个对象组成的，所有的对象通过彼此的单干，最终实现零碎的业务逻辑。
须要留神的是，在这样的组合关系中，一旦某一个对象呈现了问题，那么其余对象必定回有所影响，这就是耦合性太高的缘故，然而对象的耦合关系是无奈防止的，也是必要的。随着应用程序越来越宏大，对象的耦合关系可能越来越简单，常常须要多重依赖关系，因而，无论是架构师还是程序员，在面临这样的场景的时候，都须要缩小这些对象的耦合性。
耦合的关系不仅仅是对象与对象之间，也会呈现在软件系统的各个模块之间，是咱们须要重点解决的问题。而为了解决对象之间的耦合度过高的问题，咱们就能够通过 IOC 来实现对象之间的解耦，spring 框架就是 IOC 实践最最宽泛的利用。
从上图中能够看到，当引入了第三方的容器之后，几个对象之间就没有了耦合关系，全副对象都交由容器来管制，这个容器就相当于粘合剂，将零碎的对象粘合在一起发挥作用。
2、生态
任何一个语言或者任何一个框架想要立于不败之地，那么很重要的就是它的生态。
