Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器（框架）。
Spring : 春天 ---> 给软件行业带来了春天
2002年，
Rod Jahnson首次推出了Spring框架雏形interface21框架。2004年3月24日，Spring框架以interface21框架为基础，经过重新设计，发布了1.0正式版。
很难想象Rod Johnson的学历 , 他是悉尼大学的博士，然而他的专业不是计算机，而是音乐学。
使现有技术更加实用 . 本身就是一个大杂烩 , 整合现有的框架技术
官网 : http://spring.io/
官方下载地址 : https://repo.spring.io/libs-release-local/org/springframework/spring/
GitHub : https://github.com/spring-projects
<dependencies>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.2.0.RELEASE</version>
</dependency>
</dependencies>
Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器（框架）。
Spring框架是一种非侵入式的轻量级框架——摘自《Spring框架技术》
- 非侵入式的技术体现
- 允许在应用系统中自由选择和组装Spring框架的各个功能模块，并且不强制要求应用系统的类必须从Spring框架的系统API的某个类来继承或者实现某个接口。
- 如何实现非侵入式的设计目标的
- 1）应用反射机制，通过动态调用的方式来提供各方面的功能，建立核心组间BeanFactory
- 2）配合使用Spring框架中的BeanWrapper和BeanFactory组件类最终达到对象的实例创建和属性注入
- 3）优点：允许所开发出来的应用系统能够在不用的环境中自由移植，不需要修改应用系统中的核心功能实现的代码
现代化的Java开发（即，基于Spring的开发）！！！
Spring Boot
Spring Cloud
现在大多数公司都在使用SpringBoot进行快速开发。
承上启下：学习SpringBoot的前提，是完全掌握Spring以及SpringMVC！！！
1、先写一个UserDao接口
public interface UserDao {
public void getUser();
}
2、再去写Dao的实现类
public class UserDaoImpl implements UserDao {
@Override
public void getUser() {
System.out.println("获取用户数据");
}
}
3、然后去写UserService的接口
public interface UserService {
public void getUser();
}
4、最后写Service的实现类
public class UserServiceImpl implements UserService {
private UserDao userDao = new UserDaoImpl();
@Override
public void getUser() {
userDao.getUser();
}
}
5、测试一下
@Test
public void test(){
UserService service = new UserServiceImpl();
service.getUser();
}
这是我们原来的方式 , 开始大家也都是这么去写的对吧 . 那我们现在修改一下 .
把Userdao的实现类增加一个 .
public class UserDaoMySqlImpl implements UserDao {
@Override
public void getUser() {
System.out.println("MySql获取用户数据");
}
}
紧接着我们要去使用MySql的话 , 我们就需要去service实现类里面修改对应的实现
public class UserServiceImpl implements UserService {
private UserDao userDao = new UserDaoMySqlImpl();
@Override
public void getUser() {
userDao.getUser();
}
}
在假设, 我们再增加一个Userdao的实现类 .
public class UserDaoOracleImpl implements UserDao {
@Override
public void getUser() {
System.out.println("Oracle获取用户数据");
}
}
那么我们要使用Oracle , 又需要去service实现类里面修改对应的实现 . 假设我们的这种需求非常大 , 这种方式就根本不适用了, 甚至反人类吧 .
用户的需求可能会影响我们原来的代码
我们需要根据用户的需求去修改原代码！
如果程序代码量十分大，修改一次的成本代价十分昂贵！
根据每次变动 , 都需要修改大量代码 !
这种设计的耦合性太高了, 牵一发而动全身 !
我们可以在需要用到他的地方 , 不去实现它 , 而是留出一个接口 , 利用一个set接口 , 我们去代码里修改下 :
public class UserServiceImpl implements UserService {
private UserDao userDao;
//利用set实现值的动态注入
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
@Override
public void getUser() {
userDao.getUser();
}
}
现在去我们的测试类里 , 进行测试 ;
@Test
public void test(){
UserServiceImpl service = new UserServiceImpl();
service.setUserDao( new UserDaoMySqlImpl() );
service.getUser();
//那我们现在又想用Oracle去实现呢
service.setUserDao( new UserDaoOracleImpl() );
service.getUser();
}
发现了区别没有？
他们已经发生了根本性的变化 , 很多地方都不一样了。
这种思想 , 从本质上解决了问题 , 我们程序员不再去管理对象的创建了 , 更多的去关注业务的实现 . 耦合性大大降低 . 这也就是IOC的原型 !
没有IoC的程序中 , 我们使用面向对象编程 , 对象的创建与对象间的依赖关系完全硬编码在程序中，对象的创建由程序自己控制，控制反转后将对象的创建转移给第三方，个人认为所谓控制反转就是：获得依赖对象的方式反转了。
Spring容器在初始化时先读取配置文件，
根据配置文件或元数据创建与组织对象存入容器中，
程序使用时再从Ioc容器中取出需要的对象。
原文：https://www.cnblogs.com/melodyjerry/p/13378588.html