在学习Spring框架的时候, 第一件事情就是分析Spring的设计思想
在学习Spring的时候, 需要先了解耦合和解耦的概念
耦合: 简单来说, 在软件工程当中, 耦合是指对象之间的相互依赖
耦合的坏处: 耦合提升了代码的复杂度, 不利于开发和维护, 低耦合是软件系统架构设计的原则之一
为什么需要Spring?
Spring能够统一的管理bean对象, 当需要什么对象, 我们就去从Spring中获取对应的对象, 而不再需要去new新建出来, 大大的简化了对象的管理(创建, 调用和配置文件的读取)等工作!
Spring解决了耦合问题, 降低了对象之间的相互依赖关系
Spring解决了什么问题?
简单来说，就是处理对象的创建的、以及对象的依赖关系！
Spring的基本实现思路是什么样的?
1.第一步, 最原始的, 使用new()方法来创建对象
不足: 这导致了程序的高耦合性, 如果需要新建的对象还没有被实现, 那么就会报错, 不能进行后续的开发, 同时程序在编译时会报错. 有悖于软件架构设计的低耦合原则, 和单一功能原则.
// 1. 程序有强耦合关系: 使用mysql驱动的时候, 使用Driver类的对象
@Test
public void test1() {
try {
// 创建了一个Driver对象
// 使用registerDriver来添加mysql驱动到驱动管理器中
Driver driver = new com.mysql.jdbc.Driver();
DriverManager.registerDriver(driver);
} catch (SQLException e) {
e.printStackTrace();
}
}
2. 第二步, 反射 例如: Class.ForName("com.mysql.jdbc.Driver").newInstance()
通过反射机制, 在程序运行的时候, 来将需要的类进行加载并创建类的对象
// 2. 把代码中的强关系, 转换为了弱关系
String driver = "com.mysql.jdbc.Driver";
try {
Class.forName(driver);
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
3. 第三步, 配置 例如: db.properties和web.xml
通过配置文件, 在程序运行的时候, 读取配置文件中的内容, 通过配置文件来加载类, 并创建类的实例
/**
* 通过配置文件来实现解耦
*/
@Test
public void test3() {
// db.properties文件位置在src下
// 编译完成后, src目录下的配置文件会拷贝一份到classes目录
ClassLoader classLoader = TestMySQL.class.getClassLoader();
InputStream resourceAsStream = classLoader.getResourceAsStream("db.properties");
Properties properties = new Properties();
try {
properties.load(resourceAsStream);
System.out.println(properties.get("driver"));
String driver = (String)properties.get("driver");
Class.forName(driver);
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
4. 第四步, 通过Bundle来加载配置文件,简化配置文件的加载过程, 然后创建出对象
// 使用bundle
@Test
public void test4() {
// ResourceBundle是专门用来读取配置文件的工具类
// bundle只能读取properties类型的文件, 读取的时候只需要文件名, 不需要后缀
// bundle还提供了迭代的方法读取所有配置
ResourceBundle db = ResourceBundle.getBundle("db");
db.getString("driver");
Enumeration<String> keys = db.getKeys();
while(keys.hasMoreElements()) {
String key = keys.nextElement();
System.out.println(key +": " + db.getString(key));
}
}
5. 第五步, 通过Bean工厂来管理所有的类的对象的管理, 直接从Bean工厂中获取对象
public class BeanFactory {
// 在bean的工厂中准备一个容器,将bean都反射后添加进来,随用随取
private static Map<String,Object> beanMap = null;
static {
beanMap = new HashMap<>();
ResourceBundle bean = ResourceBundle.getBundle("bean");
Enumeration<String> keys = bean.getKeys();
while(keys.hasMoreElements()) {
String key = keys.nextElement();
String classPath = bean.getString(key);
try {
Object object = Class.forName(classPath).newInstance();
beanMap.put(key,object);
} catch (InstantiationException | IllegalAccessException | ClassNotFoundException e) {
e.printStackTrace();
}
}
}
/**
* 使用Object的基础类来接受获取的对象
* @param key
* @return
*/
public static Object getBean(String key) {
Object o = null;
ResourceBundle bean = ResourceBundle.getBundle("bean");
String classPath = bean.getString(key);
try {
o = Class.forName(classPath).newInstance();
} catch (InstantiationException | IllegalAccessException | ClassNotFoundException e) {
e.printStackTrace();
}
return o;
}
/**
* 使用泛型方法来获取对象(推荐)
* @param key
* @param clazz
* @param <T>
* @return
*/
public static<T> T getBean(String key, Class<T> clazz) {
return (T) beanMap.get(key);
}
那么再程序中对新建对象的调用就变成了如下的代码
UserService userService = BeanFactory.getBean("userService", UserService.class);
userService.register(user);
Spring的核心思想:
就是通过一个BeanFactory的工厂来统一管理所有的对象
在bean的工厂中准备一个容器,将bean都反射后添加进来,随用随取
参考文章: https://www.cnblogs.com/hello-liyb/p/8252029.html
https://blog.csdn.net/weixin_37243717/article/details/79673502
https://www.cnblogs.com/poilk/p/7015929.html
https://www.ibm.com/developerworks/cn/java/j-lo-spring-principle/
https://www.cnblogs.com/wade-luffy/p/6000277.html
原文地址：https://www.cnblogs.com/zjulanjian/p/10929976.html