手写orm框架事务交给spring管理 java手写spring框架

目录

11、手写Spring框架

第一步：创建模块myspring

第二步：准备好我们要管理的Bean

第三步：准备myspring.xml配置文件和log4j2.xml配置文件

第四步：编写ApplicationContext接口

第五步：编写ClassPathXmlApplicationContext

第六步：确定采用Map集合存储Bean

第七步：解析配置文件实例化所有Bean

第八步：测试能否获取到Bean

第九步：给Bean的属性赋值

执行测试程序：

 第十步：打包发布

删得只剩下：

打包： 

找到仓库: 

第十一步：站在程序员角度使用myspring框架 

新建模块：myspring-test

引入myspring框架的依赖（我们自己手写的）： 

编写Bean 

编写myspring.xml文件

编写测试程序

运行结果：

---

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();
    }
}

运行结果：