Spring框架核心
Spring框架核心
在项目中我们用到的Spring重要功能主要有两个：IOC和AOP，这里大致讲下这两个概念。
IOC 控制反转
我们知道，一般来说要想实现一个功能，需要多个类协助才行。其中类A中，可能就需要类B、类C中的方法。为了能调用别的类的方法，首先得取得这个类的实例，即在类A中new一个类B、再new一个类C，也就是说调用者负责创建被调用者的实例。试想想下面这两种情形：
1. 若类A中还需要其他很多类协助；
2. 类B、类C还需要协助很多其他类处理业务。
如此一来，会造成类A中越来越臃肿，越来越不好管理；类B、类C需要不断的创建。
而采用Spring框架后，就不用这么麻烦了。创建类A、类B、类C的实例以及维护类A和类B、类C之间关系的责任就交给了Spring，它负责这些工作。也就是说本来是类A控制这些实例的创建，现在交由Spring框架了，所以控制反转(IOC)了。
还有一个相关概念 DI（Dependency Injection依赖注入），有说DI只是IOC的另一种说法，准确的说，DI是IOC的实现方式。类A依赖类B、类C，现在三个类都已经交给Spring管理了（控制反转），那类A怎么获得类B、类C的实例呢，这就是依赖注入。常见的依赖注入的方式有三种：setter方法，构造器方法，注解AutoWired方式。
AOP 面向切面编程
程序在执行具体业务逻辑前、后，可能需要加入一些额外的东西，譬如：日志，事务等。在很多地方都需要加入这些额外的元素，但是这些方面和具体的业务逻辑并没有直接的关系。于是乎，就将这些额外的元素抽出来，加以封装，在特定的位置横切到方法的业务逻辑前后等位置。将业务和非业务的分开，极大程度解耦。
举个例子，当你的程序写好后，需要在所有的业务操作中添加一条日志，传统的做法是直接改造每个方法，但是这样势必让代码变糟糕，要是以后扩展起来那就更乱了。而AOP的思想就让你能从一个切面的角度来看待这些插入问题，AOP允许你以一种统一的方式在运行时期在想要的地方插入这些逻辑。
专业一点的说法，什么是面向切面编程？
这种在运行时，动态地将代码切入到类的指定方法、指定位置上的编程思想就是面向切面的编程。
Spring框架原理
示例
讲原理前，先看个例子：
小汽车类Car
package com.example;
public class Car {
private String name;
private double price;
// 省略getter，setter
@Override
public String toString() {
return "Car{" +
"name='" + name + '\'' +
", price=" + price +
'}';
}
public void carInfo() {
System.out.println("i have this car: " + name);
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
汽车拥有者类:Person
package com.example;
public class Person {
private String name;
private int age;
private Car car;
// 省略getter，setter
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
", car=" + car +
'}';
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
Spring配置文件spring-config.xml
<?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="car" class="com.example.Car">
<property name="name" value="hongqi"/>
<property name="price" value="1000000.0"/>
</bean>
<bean id="person" class="com.example.Person">
<property name="name" value="zhaangsan"/>
<property name="age" value="27"/>
<property name="car" ref="car"/>
</bean>
</beans>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
测试类SpringMain
package com.example;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class SpringMain {
public static void main(String[] args) {
// 创建IOC容器
ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
// 通过getBean获取Car的实例，这里利用了反射
Car car = (Car) context.getBean("car");
car.carInfo();
System.out.println(car.toString());
Person person = (Person) context.getBean("person");
System.out.println(person.toString());
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
执行结果：
i have this car: hongqi
Car{name='hongqi', price=1000000.0}
Person{name='zhaangsan', age=27, car=Car{name='hongqi', price=1000000.0}}
1
2
3
原理分析
当执行new ClassPathXmlApplicationContext(“spring-config.xml”)这个动作时，Spring容器也即IOC容器随即创建。容器创建时，加载了保存所有bean信息的配置文件spring-config.xml，此时bean被创建，并保存到了内存中；随即通过context.getBean(“car”);获取相应的bean的实例，这里的car是配置文件中< bean id=”car” …>。
我们通过debug模式可以看到，
在执行：
ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
1
时，就已经将对应的属性值设置到对象中了，这里调用了setter方法或者构造器等。
这里我们来简单分析下，如何利用反射获取到了实例。
在Spring配置文件spring-config.xml中：
<bean id="car" class="com.example.Car">
<property name="name" value="hongqi"/>
<property name="price" value="1000000.0"/>
</bean>
1
2
3
4
首先容器读取到了< bean … />节点，
1. 读取id属性值，得到字符串“car”：
String idStr = "car";
1
2. 读取class属性，得到全限定名字符串“com.example.Car”：
String classStr = "com.example.Car";
1
3. 利用反射，通过全限定名获取Class对象：
Class<?> clz = Class.forName(classStr);
1
4. 接着实例化对象
Object obj = clz.newInstance();
1
5. 加入到Spring容器中
// springContainer --> Map
springContainer.put(idStr, obj);
1
2
而若一个类需要另一个类时，如下：
<bean id="person" class="com.example.Person">
...
<property name="car" ref="car"/>
</bean>
1
2
3
4
解析< property …/>元素
1. 获取name属性值car：
String nameStr = "car";
1
2. 获取ref属性值car：
String refStr = "car";
1
3. 生成将要调用setter方法名 ：
String setterName = "set" + nameStr.substring(0, 1).toUpperCase() + nameStr.substring(1);
1
4. 获取Spring容器中名为refStr的Bean
Object carBean = springContainer.get(refStr);
1
5. 获取setter方法的Method类，此处的clz是前面实例通过Class.forName()获得的类对象
下面是Person类中的setCar(Car)方法
public void setCar(Car car) {
this.car = car;
}
1
2
3
通过反射，第一个参数是方法名，第二个参数是方法参数类型
Method setter = clz.getMethod(setterName, carBean.getClass());
1
6. 调用invoke()方法，此处的obj是刚才反射代码得到的Object对象
public Object invoke(Object obj, Object... args){...}
1
反射方法invoke中的参数，
obj：从中调用底层方法的对象（简单的说就是调用谁的方法用谁的对象）；
args：用于方法调用的参数，所以：
setter.invoke(obj, carBean);
1
原文链接：https://blog.csdn.net/kingyxfly/article/details/79826333
浙公网安备 33010602011771号