目录
第三步：准备myspring.xml配置文件和log4j2.xml配置文件
第五步：编写ClassPathXmlApplicationContext
11、手写Spring框架
第一步：创建模块myspring
打包方式采用jar，并且引入dom4j和jaxen的依赖，因为要使用它解析XML文件，还有junit依赖。
pom.xml：
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>org.myspringframework</groupId>
<artifactId>myspring</artifactId>
<version>1.0.0</version>
<packaging>jar</packaging>
<!--依赖-->
<dependencies>
<!--dom4j是一个能够解析XML文件的Java组件-->
<dependency>
<groupId>org.dom4j</groupId>
<artifactId>dom4j</artifactId>
<version>2.1.3</version>
</dependency>
<dependency>
<groupId>jaxen</groupId>
<artifactId>jaxen</artifactId>
<version>1.2.0</version>
</dependency>
<!--单元测试-->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
<!--log4j2的依赖-->
<dependency>
<groupId>org.apache.logging.log4j</groupId>
<artifactId>log4j-core</artifactId>
<version>2.19.0</version>
</dependency>
<dependency>
<groupId>org.apache.logging.log4j</groupId>
<artifactId>log4j-slf4j2-impl</artifactId>
<version>2.19.0</version>
</dependency>
</dependencies>
<properties>
<maven.compiler.source>19</maven.compiler.source>
<maven.compiler.target>19</maven.compiler.target>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
</project>第二步：准备好我们要管理的Bean
- 准备好我们要管理的Bean（这些Bean在将来开发完框架之后是要删除的）
- 注意包名，不要用org.myspringframework包，因为这些Bean不是框架内置的。是将来使用我们框架的程序员提供的。
User.java:
package com.dong.myspring.bean;
public class User {
private String name;
private int age;
public void setName(String name) {
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
UserDao.java:
package com.dong.myspring.bean;
public class UserDao {
public void insert(){
System.out.println("MySql数据库正在保存用户信息。");
}
}
UserService.java:
package com.dong.myspring.bean;
public class UserService {
private UserDao userDao;
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
public void save(){
userDao.insert();
}
}
第三步：准备myspring.xml配置文件和log4j2.xml配置文件
- 将来在框架开发完毕之后，这个文件也是要删除的。因为这个配置文件的提供者应该是使用这个框架的程序员。
- 文件名随意，我们这里叫做：myspring.xml
- 文件放在类路径当中即可，我们这里把文件放到类的根路径下。
myspring.xml:
<?xml version="1.0" encoding="UTF-8"?>
<!--这个配置文件也是使用myspring框架的开发人员提供的-->
<beans>
<bean id="user" class="com.dong.myspring.bean.User">
<property name="name" value="张三"></property>
<property name="age" value="30"></property>
</bean>
<bean id="userService" class="com.dong.myspring.bean.UserService">
<property name="userDao" ref="userDaoBean"/>
</bean>
<bean id="userDaoBean" class="com.dong.myspring.bean.UserDao"></bean>
</beans>使用value给简单属性赋值。使用ref给非简单属性赋值。
记录日志---log4j2.xml:
<?xml version="1.0" encoding="UTF-8"?>
<configuration>
<loggers>
<!--
level指定⽇志级别，从低到⾼的优先级：
ALL < TRACE < DEBUG < INFO < WARN < ERROR < FATAL < OFF
-->
<root level="DEBUG">
<appender-ref ref="spring6log"/>
</root>
</loggers>
<appenders>
<!--输出⽇志信息到控制台-->
<console name="spring6log" target="SYSTEM_OUT">
<!--控制⽇志输出的格式-->
<PatternLayout pattern="%d{yyyy-MM-dd HH:mm:ss SSS} [%t] %-3le
vel %logger{1024} - %msg%n"/>
</console>
</appenders>
</configuration>
第四步：编写ApplicationContext接口
- ApplicationContext接口中提供一个getBean()方法，通过该方法可以获取Bean对象。
- 注意包名：这个接口就是myspring框架中的一员了。
package org.myspringframework.core;
/**
* MySpring框架应用上下文接口
*/
public interface ApplicationContext {
/**
* 根据bean的名称获取对应的bean对象
* @param beanName myspring配置文件中bean标签的id
* @return 对应的单例bean对象
*/
Object getBean(String beanName);
}
第五步：编写ClassPathXmlApplicationContext
- ClassPathXmlApplicationContext是ApplicationContext接口的实现类。该类从类路径当中加载myspring.xml配置文件。
package org.myspringframework.core;
/**
* @author dong
* @version 1.0
* @className ClassPathXmlApplicationContext
* @since 1.0
**/
public class ClassPathXmlApplicationContext implements ApplicationContext{
@Override
public Object getBean(String beanId) {
return null;
}
}
第六步：确定采用Map集合存储Bean
- 确定采用Map集合存储Bean实例。Map集合的key存储beanId，value存储Bean实例。Map<String,Object>
- 在ClassPathXmlApplicationContext类中添加Map<String,Object>属性。
- 并且在ClassPathXmlApplicationContext类中添加构造方法，该构造方法的参数接收myspring.xml文件。
- 同时实现getBean方法。
package org.myspringframework.core;
import java.util.HashMap;
import java.util.Map;
/**
* @author dong
* @version 1.0
* @className ClassPathXmlApplicationContext
* @since 1.0
**/
public class ClassPathXmlApplicationContext implements ApplicationContext{
/**
* 存储bean的Map集合
*/
private Map<String,Object> beanMap = new HashMap<>();
/**
* 在该构造方法中，解析myspring.xml文件，创建所有的Bean实例，并将Bean实例存放到Map集合中。
* @param resource 配置文件路径（要求在类路径当中）
*/
public ClassPathXmlApplicationContext(String resource) {
}
@Override
public Object getBean(String beanId) {
return beanMap.get(beanId);
}
}
第七步：解析配置文件实例化所有Bean
在ClassPathXmlApplicationContext的构造方法中解析配置文件，获取所有bean的类名，通过反射机制调用无参数构造方法创建Bean。并且将Bean对象存放到Map集合中。
/**
* 在该构造方法中，解析myspring.xml文件，创建所有的Bean实例，并将Bean实例存放到Map集合中。
* @param resource 配置文件路径（要求在类路径当中）
*/
public ClassPathXmlApplicationContext(String resource) {
try {
SAXReader reader = new SAXReader();
Document document = reader.read(ClassLoader.getSystemClassLoader().getResourceAsStream(resource));
// 获取所有的bean标签
List<Node> beanNodes = document.selectNodes("//bean");
// 遍历集合
beanNodes.forEach(beanNode -> {
Element beanElt = (Element) beanNode;
// 获取id
String id = beanElt.attributeValue("id");
// 获取className
String className = beanElt.attributeValue("class");
try {
// 通过反射机制创建对象
Class<?> clazz = Class.forName(className);
Constructor<?> defaultConstructor = clazz.getDeclaredConstructor();
Object bean = defaultConstructor.newInstance();
// 存储到Map集合
beanMap.put(id, bean);
} catch (Exception e) {
e.printStackTrace();
}
});
} catch (Exception e) {
e.printStackTrace();
}
}第八步：测试能否获取到Bean
编写测试程序。
package com.dong.myspring.Test;
import com.dong.myspring.bean.UserService;
import org.myspringframework.core.ApplicationContext;
import org.myspringframework.core.ClassPathXmlApplicationContext;
public class Test {
@org.junit.Test
public static void main(String[] args) {
ApplicationContext applicationContext=new ClassPathXmlApplicationContext("myspring.xml");
Object user = applicationContext.getBean("user");
System.out.println(user);
UserService userService = (UserService) applicationContext.getBean("userService");
userService.save();
}
}
第九步：给Bean的属性赋值
- 通过反射机制调用set方法，给Bean的属性赋值。
- 继续在ClassPathXmlApplicationContext构造方法中编写代码。
package org.myspringframework.core;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.Node;
import org.dom4j.io.SAXReader;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.InputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class ClassPathXmlApplicationContext implements ApplicationContext {
private static final Logger logger = LoggerFactory.getLogger(ClassPathXmlApplicationContext.class);
private Map<String, Object> singletonObject = new HashMap<>();
/**
* 解析myspring的配置文件，然后初始化所有的Bean对象
*
* @param configLocation ：spring的配置文件路径。注意：使用ClassPathXmlApplicationContext，配置文件应当放在类路径下
*/
public ClassPathXmlApplicationContext(String configLocation) {
try {
//解析myspring.xml文件，然后实例化Bean，将Bean存放到singletonObject集合当中。
//这是dom4j解析XML文件的核心对象
SAXReader reader = new SAXReader();
//获取一个输入流
InputStream in = ClassLoader.getSystemClassLoader().getResourceAsStream(configLocation);
//读文件
Document document = reader.read(in);
//获取所有Bean标签
List<Node> nodes = document.selectNodes("//bean");
//遍历bean标签
nodes.forEach(node -> {
try {
//向下转型的目的是为了使用Element接口立更多的方法
Element beanElt = (Element) node;
//获取id属性
String id = beanElt.attributeValue("id");
//获取class属性
String className = beanElt.attributeValue("class");
logger.info("beanName=" + id);
logger.info("beanClassName=" + className);
//通过反射机制创建对象，将其放到Map集合中，提前曝光
//获取Class
Class<?> aClass = Class.forName(className);
//获取无参数构造方法
Constructor<?> defaultCon = aClass.getDeclaredConstructor();
//调用无参数构造方法实例化Bean
Object bean = defaultCon.newInstance();
//将Bean曝光，加入Map集合
singletonObject.put(id, bean);
//记录日志
logger.info(singletonObject.toString());
} catch (Exception e) {
e.printStackTrace();
}
//再次重新把所有的bean标签遍历一次，这一次主要是给对象的属性赋值
nodes.forEach(node1 -> {
try {
Element beanElt = (Element) node1;
//获取id
String id = beanElt.attributeValue("id");
//获取className
String className = beanElt.attributeValue("class");
//获取Class
Class<?> aClass = Class.forName(className);
//获取该bean下的所有属性property标签
List<Element> properties = beanElt.elements("property");
//遍历所有的属性标签
properties.forEach(property -> {
try {
//获取属性名
String propertyName = property.attributeValue("name");
//获取属性类型
Field field = aClass.getDeclaredField(propertyName);
logger.info("属性名：" + propertyName);
//获取set方法名
String setMethodName = "set" + propertyName.toUpperCase().charAt(0) + propertyName.substring(1);
//获取set方法
Method setMethod = aClass.getDeclaredMethod(setMethodName, field.getType());
//获取具体的值
String value = property.attributeValue("value");
Object actualValue = null;//真值
String ref = property.attributeValue("ref");
if (value != null) {
//说明这个值为简单类型
//调用set方法(set方法没有返回值)
/*
我们myspring框架声明一下：我们只支持这些类型为简单类型
byte short int long float double boolean char
Byte Short Integer Long Float Double Boolean Character
String
*/
//获取属性类型名
String propertyTypeSimpleName = field.getType().getSimpleName();
switch (propertyTypeSimpleName) {
case "byte":
actualValue = Byte.parseByte(value);
break;
case "Byte":
actualValue = Byte.valueOf(value);
break;
case "short":
actualValue = Short.parseShort(value);
break;
case "Short":
actualValue = Short.valueOf(value);
break;
case "int":
actualValue = Integer.parseInt(value);
break;
case "Integer":
actualValue = Integer.valueOf(value);
break;
case "long":
actualValue = Long.parseLong(value);
break;
case "Long":
actualValue = Long.valueOf(value);
break;
case "float":
actualValue = Float.parseFloat(value);
break;
case "Float":
actualValue = Float.valueOf(value);
break;
case "double":
actualValue = Double.parseDouble(value);
break;
case "Double":
actualValue = Double.valueOf(value);
break;
case "boolean":
actualValue = Boolean.parseBoolean(value);
break;
case "Boolean":
actualValue = Boolean.valueOf(value);
break;
case "char", "Character":
actualValue = value.charAt(0);
break;
case "String":
actualValue = value;
break;
}
setMethod.invoke(singletonObject.get(id), actualValue);
}
if (ref != null) {
//说明这个值为非简单类型
//调用set方法(set方法没有返回值)
if (singletonObject.get(ref) != null) {
setMethod.invoke(singletonObject.get(id), singletonObject.get(ref));
}
/*
setMethod.invoke(singletonObject.get(id), singletonObject.get(ref));
//出现空指针问题，增加一个非空判断，再访问对象。
*/
}
} catch (Exception e) {
e.printStackTrace();
}
});
} catch (Exception e) {
e.printStackTrace();
}
});
});
} catch (Exception e) {
e.printStackTrace();
}
}
@Override
public Object getBean(String beanName) {
return singletonObject.get(beanName);
}
}
执行测试程序：
第十步：打包发布
将多余的类以及配置文件删除，使用maven打包发布。
删得只剩下：
打包：
找到仓库:
第十一步：站在程序员角度使用myspring框架
新建模块：myspring-test
引入myspring框架的依赖（我们自己手写的）：
<!--用spring框架，需要引入依赖--> <dependency> <groupId>org.myspringframework</groupId> <artifactId>myspring</artifactId> <version>1.0.0</version> </dependency>
pom.xml:
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.dong</groupId>
<artifactId>myspring-test</artifactId>
<version>1.0-SNAPSHOT</version>
<dependencies>
<!--用spring框架，需要引入依赖-->
<dependency>
<groupId>org.myspringframework</groupId>
<artifactId>myspring</artifactId>
<version>1.0.0</version>
</dependency>
<!--单元测试-->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
</dependencies>
<properties>
<maven.compiler.source>19</maven.compiler.source>
<maven.compiler.target>19</maven.compiler.target>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
</project>编写Bean
Vip.java
package com.dong.myspring.bean;
public class Vip {
private String name;
private int age;
private double height;
@Override
public String toString() {
return "Vip{" +
"name='" + name + '\'' +
", age=" + age +
", height=" + height +
'}';
}
public void setName(String name) {
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
public void setHeight(double height) {
this.height = height;
}
}
OrderDao.java
package com.dong.myspring.bean;
public class OrderDao {
public void insert(){
System.out.println("正在保存订单信息。。。。。");
}
}
OrderService.java
package com.dong.myspring.bean;
public class OrderService {
private OrderDao orderDao;
public void setOrderDao(OrderDao orderDao) {
this.orderDao = orderDao;
}
public void generate(){
orderDao.insert();
}
}
编写myspring.xml文件
<?xml version="1.0" encoding="UTF-8"?>
<beans>
<bean id="vip" class="com.dong.myspring.bean.Vip">
<property name="name" value="jackson"></property>
<property name="age" value="30"></property>
<property name="height" value="1.83"></property>
</bean>
<bean id="orderDaoBean" class="com.dong.myspring.bean.OrderDao"></bean>
<bean id="orderService" class="com.dong.myspring.bean.OrderService">
<property name="orderDao" ref="orderDaoBean"></property>
</bean>
</beans>编写测试程序
package com.dong.myspring.test;
import com.dong.myspring.bean.OrderService;
import org.myspringframework.core.ApplicationContext;
import org.myspringframework.core.ClassPathXmlApplicationContext;
public class Test {
@org.junit.Test
public static void main(String[] args) {
ApplicationContext applicationContext=new ClassPathXmlApplicationContext("myspring.xml");
Object vip = applicationContext.getBean("vip");
System.out.println(vip);
OrderService orderService = (OrderService) applicationContext.getBean("orderService");
orderService.generate();
}
}
运行结果：
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
