数据交换格式json与spring ioc的原理（手写demo）

最新推荐文章于 2022-07-04 10:30:00 发布

黑人小笼包

最新推荐文章于 2022-07-04 10:30:00 发布

阅读量192

点赞数

分类专栏：架构师学习之路

本文链接：https://blog.csdn.net/huangwei18351/article/details/100045600

版权

架构师学习之路专栏收录该内容

0 篇文章 1 订阅

订阅专栏

1.数据交换格式

由于服务端（现在趋于提供接口），使用接口通信，故现在通信过程中，针对电脑端和移动端的请求，都是以http+json格式进行传输，即RestFul API。

xml与json的区别，为什么现在主要用json不是用xml？

xml是重量级的语言，占带宽比较大，在传输中效率不高，一般在webservice与银行项目中使用；

json是轻量级的数据交换格式，占带宽比较小，在传输效率上会比xml高，互联网项目一般都用json。

常用json解析框架

fastjson（阿里），gson（谷歌），jackson（Springmvc自带）

使用fastjson解析json

2. java反射机制

2.1什么是java反射？

正在运行，动态获取这个类的所有信息。

2.2反射的作用？

反编译： .class –>java

通过反射机制，访问java对象的属性，方法，构造方法等；

2.3反射机制的应用场景

jdbc加载驱动、spring IoC、框架

2.4 反射机制获取类的三种方法

package classforname;

import entity.UserEntity;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

/**
 * @Description TODO
 * @Author haydon
 * @Date 2019/8/22 19:46
 */
public class ClassForName {
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {
        //①使用无参构造器进行创建对象
        //1.除了new创建对象，还可以使用反射机制创建对象
        //2.forName必须传入class类的全限定类名
        Class<?> aClass = Class.forName("entity.UserEntity");
        //3.newInstance使用无参构造器创建对象实例
        Object o = aClass.newInstance();
        UserEntity userEntity = (UserEntity) o;
        userEntity.setId(123);
        System.out.println(userEntity);
        /*
            使用反射技术创建对象和new哪个效率高？
            new效率高，因为反射还需要解析类的全限定类名，然后再创建实例；而new只需要再堆里直接创建对象就可以。
         */

        //②使用有参构造器进行创建对象
        Constructor<?> constructor = aClass.getConstructor(String.class);
        Object hw = constructor.newInstance("hw");
        UserEntity entity = (UserEntity) hw;
        System.out.println(entity);

        //③获取该类的所有方法
        Method[] declaredMethods = aClass.getDeclaredMethods();
        for(Method method : declaredMethods){
            System.out.println(method.getName() + "-----" + method.getReturnType());
        }

        //④获取所有的属性
        Field[] declaredFields = aClass.getDeclaredFields();
        for(Field field : declaredFields){
            System.out.println(field.getName());
        }

        Field name = aClass.getDeclaredField("name");
        //允许访问私有成员变量
        name.setAccessible(true);
        name.set(userEntity, "hhh");
        System.out.println(userEntity);
    }
}

UserEntity

package entity;

/**
 * @Description TODO
 * @Author haydon
 * @Date 2019/8/22 19:44
 */
public class UserEntity {
    private int id;
    private String name;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public UserEntity(){
        System.out.println("无参构造器");
    }

    public UserEntity(String name){
        this.name = name;
        System.out.println("有参构造器" + name);
    }

    @Override
    public String toString() {
        return "UserEntity{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
}

3.spring IoC概述

反射+dom4j

3.1 引入依赖

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-web</artifactId>
    <version>5.1.9.RELEASE</version>
</dependency>

<dependency>
    <groupId>dom4j</groupId>
    <artifactId>dom4j</artifactId>
    <version>1.6.1</version>
</dependency>

3.2 创建实体类对象

package springdemo;

/**
 * @Description TODO
 * @Author huangwei
 * @Date 2019/8/23 19:43
 */
public class UserBean {
    private String id;
    private String name;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public UserBean(){
        System.out.println("无参构造器");
    }

    @Override
    public String toString() {
        return "UserBean{" +
                "id='" + id + '\'' +
                ", name='" + name + '\'' +
                '}';
    }
}

3.3 创建xml文件

<?xml version="1.0" encoding="UTF-8" ?>
<beans>
    <bean id="user1" class="springdemo.UserBean">
        <property name="id" value="111"></property>
        <property name="name" value="hw"></property>
    </bean>
    <bean id="user2" class="springdemo.UserBean">
        <property name="id" value="2221"></property>
        <property name="name" value="hw2"></property>
    </bean>
</beans>

3.4 创建spring的容器context

package springdemo;

import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

import java.lang.reflect.Field;
import java.util.List;

/**
 * @Description TODO
 * @Author huangwei
 * @Date 2019/8/23 19:49
 */
public class ClasspathApplicationContextDemo {
    private String xmlPath;

    public ClasspathApplicationContextDemo(String xmlPath) {
        this.xmlPath = xmlPath;
    }

    public Object getBean(String beanId) throws DocumentException, ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchFieldException {
        //spring加载过程或者spring ioc 原理

        //1.读取xml配置文件
        //1.1获取xml解析器,解析xmlPath下的xml文件
        SAXReader saxReader = new SAXReader();
        //this.getClass().getClassLoader().getResourceAsStream获取当前项目路径
        Document read = saxReader.read(this.getClass().getClassLoader().getResourceAsStream(xmlPath));
        Element rootElement = read.getRootElement();
        //1.2得到所有的bean配置
        List<Element> elements = rootElement.elements();
        Object o = null;
        for (Element e : elements) {
            //2.获取每个bean配置，如果beanId匹配，那么获取class地址,生成对象实例
            String id = e.attributeValue("id");
            if (!beanId.equals(id)) {
                continue;
            }
            String classPath = e.attributeValue("class");
            Class<?> userClass = Class.forName(classPath);
            o = userClass.newInstance();
            //2.1获取property节点中的name和value属性值，然后使用反射为私有属性赋值
            List<Element> sons = e.elements();
            for (Element son : sons) {
                String fieldName = son.attributeValue("name");
                String fieldValue = son.attributeValue("value");
                Field declaredField = userClass.getDeclaredField(fieldName);
                declaredField.setAccessible(true);
                declaredField.set(o, fieldValue);
            }
        }
        return o;
    }
}

3.5编写测试类

package springdemo;

import org.dom4j.DocumentException;

/**
 * @Description TODO
 * @Author huangwei
 * @Date 2019/8/23 20:15
 */
public class TestIoC {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, InstantiationException, DocumentException, IllegalAccessException {
        ClasspathApplicationContextDemo cac = new ClasspathApplicationContextDemo("user.xml");
        UserBean user = (UserBean)cac.getBean("user1");
        System.out.println(user);
    }
}