Spring 是什么
- Spring 是 Java 世界应用的事实标准。（事实标准是指非由标准化组织制定的，而是由处于技术领先地位的企业、企业集团制定，由市场实际接纳的技术标准）
- 没有 Spring 的年代我们怎么开发 Java 应用？
1.一个 main 程序打天下，这么做规模上来以后难以维护，就是异常灾难。
2.根据功能拆分为多个模块，拆分并且手动管理所有的依赖，依赖关系纷繁复杂。 - Spring 容器就是一个 IoC 容器。
- Spring MVC 基于 Spring 和 Servlet 的 Web 应⽤框架。Servlet 就是一个小服务器，假如我们开发一个 Web 应用，一个进程必须去监听某个端口，世界上所有的人都可以通过这个端口来访问你的程序。我们将这种最底层的，处理交互的东西叫做 Servlet（Java 中大名鼎鼎的 Servlet 容器有 Tomcat 和 Jetty）。Servlet 的功能就是把外界的HTTP请求封装成一个对象交给上层的 WebApp（Java 中 WebApp 的事实标准就是 Spring），WebApp 处理完后交给 Servlet，然后 Servlet 帮你发送出去。所谓的 Spring MVC 就是支持 Servlet 和网络请求的这么一个 Spring 程序，换一句话说，Spring MVC 就是在 Spring 容器之上的一个功能更强大的应用
- Spring Boot 集成度和⾃动化程度更⾼。（Spring Boot 内嵌了一个 Servlet 容器，操作更加傻瓜了）Spring Boot 是近年来才火起来的，高度集成化。给我们开发人员的直观感受就是，减少了很多配置工作，但是我们丧失了对于底层的所有控制权。
- 总的来说，Spring 的出现解放了我们的双手。
Spring 容器核心概念
下面我们演示一个最精简的 Spring 程序，模拟一个简单的订单服务。
OrderDao 主要完成一些数据库操作。
public class OrderDao {
public void select() {
System.out.println("select from database");
}
}
OrderSerive 提供对外的服务。
public class OrderService {
private OrderDao orderDao;
public void doSomething() {
System.out.println("do some thing");
}
}
首先需要引入一个第三方类库 Spring Context（这里对于 context 比较好的解释应该是“环境”，“上下文”总觉得怪怪的）。现在，用的比较多的是 Spring Boot，在上古年代，人们使用 spring xml 来配置 Spring 容器。在 src/main/resource 下新建 config.xml 文件。我们从官网抄来了配置文件，根据自己的需求，添加了两个 bean。现在解释一下 bean 是什么。程序员都是非常浪漫的，Java 是咖啡，而 Bean 是咖啡豆。一个 Bean 可以去依赖其他 Bean，本质上，Bean 就是一个 Java 对象（其实 Spring 整个程序，也是一个 Java 对象，只不过容器给我们的概念是一个很大的盒子）。
<?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 definitions here -->
<bean id="orderDao" class="com.github.lazyben.OrderDao"/>
<bean id="orderService" class="com.github.lazyben.OrderService"/>
</beans>
容器是什么呢？其实就是 BeanFactory。现在我们可以去完成一些操作了。发现了没有整个程序我们没有手工去处理依赖关系。
public class SpringMain {
public static void main(String[] args) {
BeanFactory beanFactory = new ClassPathXmlApplicationContext("classpath:config.xml");
final OrderService orderService = (OrderService) beanFactory.getBean("orderService");
final OrderDao orderDao = (OrderDao) beanFactory.getBean("orderDao");
System.out.println(orderService);
orderService.doSomething();
}
}
此时报了一个空指针异常。因为此时 orderService 中的 orderDao 是 null。怎么办呢？
com.github.lazyben.OrderService@57f23557
Exception in thread "main" java.lang.NullPointerException
at com.github.lazyben.OrderService.doSomething(OrderService.java:7)
at com.github.lazyben.SpringMain.main(SpringMain.java:11)
最简单的就是基于注解的，我们可以添加注解 @Inject（注入）或 @Resource（资源）或 @Autowired（自动装配）。为什么我们添加一个注解就能完成注入依赖的工作呢？这个注解其实本身没什么卵用，只是在运行时被扫描到有这个注解，并完成了工作。这里就不多赘述了，这不是本篇所要讨论的内容。另外，我们还需要在 config.xml 中加入一行配置 <context:annotation-config/>。多说一句，这里比较推荐使用 @Inject 注解，不仅Spring能识别它，Google 的 Guice 也能识别它。
Spring 也支持构造器注入。我们可以把这些注解写在构造器上（称为构造器注入），在属性上写注解有一个很要命的问题，一旦脱离 Spring 就无法工作了，而写在构造器上我们可以在没有 Spring 的情况下通过构造器的方式传入属性（就和写原生 Java 代码一样），写单元测试也更加的方便。构造器注入是一种更好的实践。
public class OrderService {
// @Inject
// @Resource
@Autowired
private OrderDao orderDao;
public void doSomething() {
orderDao.select();
}
}
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.1.xsd">
<context:annotation-config/>
<!-- bean definitions here -->
<bean id="orderDao" class="com.github.lazyben.OrderDao"/>
<bean id="orderService" class="com.github.lazyben.OrderService"/>
</beans>
打上断点，神奇的事情发生了，orderService 中的 orderDao，和 orderDao 居然还是同一个对象。为什么上文说 Spring 解放了我们的双手？道理就在这里。
这里我们回顾一下上文中提到的一些 Spring 的核心概念：
- Bean
容器中的最⼩⼯作单元，通常为⼀个 Java 对象。 - BeanFactory/ApplicationContext
它们都是容器本身对应的Java对象。
容器本身对应的 Java 对象。 - 依赖注⼊ Dependency Injection（DI）
容器负责注⼊所有的依赖。 - 控制反转 Inverse of Control（IoC）
⽤户将控制权交给了容器。
手写一个最精简的 IoC 容器
无非是以下几个步骤。定义Bean、加载 Bean 的定义、实例化 Bean、查找依赖实现自动注入。
- 为了简单，我们使用 .properties 格式文件作为配置文件，在 src/main/resources 下创建配置文件 ioc.properties。propweties 使用等号划分一个键值对。
orderDao=com.github.lazyben.OrderDao
orderService=com.github.lazyben.OrderServicew
- 使用一个古老的 Java 类 Properties 可以解析 properties 文件，于是我们拿到了配置文件。
public class MyIoCContainer {
public static void main(String[] args) throws IOException {
Properties properties = new Properties();
properties.load(MyIoCContainer.class.getResourceAsStream("/ioc.properties"));
System.out.println("properties = " + properties);
}
}
- 根据拿到的配置，使用反射生成实例。
Map<String, Object> beans = new HashMap<>();
properties.forEach((beanName, beanFullyQualifiedClassName) -> {
try {
Class<?> klass = Class.forName((String) beanFullyQualifiedClassName);
Object newInstance = klass.getConstructor().newInstance();
beans.put((String) beanName, newInstance);
} catch (Exception e) {
throw new RuntimeException(e);
}
});
- 依赖注入。对于每一个实例，获取它的所有带
@Autowired注解的属性，在 beans 中找到相应的实例，并注入依赖。值得注意的是 private 属性，我们不能直接用反射直接设置，需要设置权限field.setAccessible(true);。
beans.forEach((beanName, beanInstance) -> dependencyInject(beanInstance, beans));
private static void dependencyInject(Object beanInstance, Map<String, Object> beans) {
final List<Field> fieldsToBeAutoWired = Stream.of(beanInstance.getClass().getDeclaredFields())
.filter(bean -> bean.getAnnotation(Autowired.class) != null)
.collect(Collectors.toList());
fieldsToBeAutoWired.forEach(field -> {
try {
final Object dependencyBeanInstance = beans.get(field.getName());
field.setAccessible(true);
field.set(beanInstance, dependencyBeanInstance);
} catch (IllegalAccessException e) {
throw new RuntimeException(e);
}
});
}
- 源码
public class MyIoCContainer {
public static void main(String[] args) throws IOException {
Properties properties = new Properties();
properties.load(MyIoCContainer.class.getResourceAsStream("/ioc.properties"));
Map<String, Object> beans = new HashMap<>();
properties.forEach((beanName, beanFullyQualifiedClassName) -> {
try {
Class<?> klass = Class.forName((String) beanFullyQualifiedClassName);
Object newInstance = klass.getConstructor().newInstance();
beans.put((String) beanName, newInstance);
} catch (Exception e) {
throw new RuntimeException(e);
}
});
beans.forEach((beanName, beanInstance) -> dependencyInject(beanInstance, beans));
final OrderService orderService = (OrderService) beans.get("orderService");
orderService.doSomething();
}
private static void dependencyInject(Object beanInstance, Map<String, Object> beans) {
final List<Field> fieldsToBeAutoWired = Stream.of(beanInstance.getClass().getDeclaredFields())
.filter(bean -> bean.getAnnotation(Autowired.class) != null)
.collect(Collectors.toList());
fieldsToBeAutoWired.forEach(field -> {
try {
final Object dependencyBeanInstance = beans.get(field.getName());
field.setAccessible(true);
field.set(beanInstance, dependencyBeanInstance);
} catch (IllegalAccessException e) {
throw new RuntimeException(e);
}
});
}
}
