java架构学习——6. 数据交换格式与SpringIOC底层实现

最新推荐文章于 2023-12-04 09:59:19 发布
最新推荐文章于 2023-12-04 09:59:19 发布
阅读量168 收藏
点赞数
分类专栏： java架构学习 文章标签： json转换 xml解析 java反射 SpringIOC底层实现
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wmq_fly/article/details/83548371
版权

本篇博文主要包含：

  • JSON简单使用，Java对象、json字符串对象和json对象互转
  • XML简单使用，Dom4j解析XML
  • XML与JSON区别
  • Java反射机制
  • 反射机制获取类的方法
    -Class.class
    -Class.forName()
    -.getClass()
  • 利用反射给私有属性赋值
  • 利用反射手写springIOC原理：dom4j+反射机制

一、数据交换格式

  1. JSON简单使用
    JSON(JavaScript Object Notation)是一种轻量级的数据交换格式，相比于xml这种数据交换格式来说，因为解析xml比较的复杂，而且需要编写大段的代码，所以客户端和服务器的数据交换格式往往通过JSON来进行交换。
    常用JSON解析框架：
    fastjson(阿里)、gson(谷歌)、jackson(SpringMVC自带)

以下案例使用fastjson解析json：
1.1 添加jar fastjson-1.1.43 或引入maven依赖

		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>fastjson</artifactId>
			<version>1.1.43</version>
		</dependency>

1.2 将json字符串转化为json对象

public static void jsonStrToJsonObject() {
		String jsonStr = "{\"sites\":[{\"name\":\"三多\",\"url\":\"不抛弃\"},{\"name\":\"史今\",\"url\":\"不放弃\"}]}";
		JSONObject jsonObject = new JSONObject();
		// 将json字符串转为jsonbject
		JSONObject jsonStrObject = jsonObject.parseObject(jsonStr);
		//将数组转化为json数组
		JSONArray jsonArray = jsonStrObject.getJSONArray("sites");
		for (Object object : jsonArray) {
			JSONObject stObject = (JSONObject) object;
			String name = stObject.getString("name");
			String url = stObject.getString("url");
			System.out.println(name + "---" + url);
		}
	}

运行结果：
在这里插入图片描述

1.3 将json字符串转化为java对象
User和Item类

class Item {
	private String itemId;
	private String itemName;

	public String getItemId() {

		return itemId;
	}

	public void setItemId(String itemId) {

		this.itemId = itemId;
	}

	public String getItemName() {

		return itemName;
	}

	public void setItemName(String itemName) {

		this.itemName = itemName;
	}

	@Override
	public String toString() {
		return "Item [itemId=" + itemId + ", itemName=" + itemName + "]";
	}
}

class User {
	private String id;
	private String name;
	private List<Item> items;

	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 List<Item> getItems() {

		return items;
	}

	public void setItems(List<Item> items) {

		this.items = items;
	}

	@Override
	public String toString() {
		return "User [id=" + id + ", name=" + name + ", items=" + items + "]";
	}
}

将json字符串转化为对象的方法：

	public static void jsonStrToObject() {
		String jsonStr = "{\"name\":\"不抛弃，不放弃\",\"id\":\"0\",\"items\":[{\"itemName\":\"三多\",\"itemId\":\"1\"},{\"itemName\":\"史今\",\"itemId\":\"2\"}]}";
		//使用java反射机制 对应生成对象
		User user = new JSONObject().parseObject(jsonStr, User.class);
		System.out.println("user:" + user.toString());
	}

运行结果：
在这里插入图片描述
1.4 Json api封装json

public static void toJsonObject() {
		JSONObject root = new JSONObject();
		root.put("id", "1");
		root.put("name", "成才");
		//定义一个json数组
		JSONArray arrayList = new JSONArray();
		JSONObject object1 = new JSONObject();
		object1.put("itemId", "2");
		object1.put("itemName", "醒悟");
		JSONObject object2 = new JSONObject();
		object2.put("itemId", "3");
		object2.put("itemName", "成长");
		arrayList.add(object1); 
		arrayList.add(object2);
		root.put("items", arrayList);
		System.out.println(root.toJSONString());
	}

运行结果：
在这里插入图片描述
1.5 将对象转换成json字符串

public static void ObjectToJsonObjectStr() {
		User user = new User();
		user.setId("1");
		user.setName("六一");
		List<Item> items =new ArrayList<Item>();
		Item item1 = new Item();
		item1.setItemId("2");
		item1.setItemName("坚韧");
		Item item2 = new Item();
		item2.setItemId("3");
		item2.setItemName("优秀");
		items.add(item1);
		items.add(item2);
		user.setItems(items);
		System.out.println(new JSONObject().toJSONString(user));
	}

运行结果：
在这里插入图片描述

  1. XML简单使用
    XML 全称为可扩展的标记语言。它是一种重量级的数据交换格式。XML 文档的根元素被称为文档元素，它和在其外部出现的处理指令、注释等作为文档实体的子节点，根元素本身和其内部的子元素也是一棵树。

XML 文档在逻辑上主要由一下 5 个部分组成：

  • XML 声明：指明所用 XML 的版本、文档的编码、文档的独立性信息
  • 文档类型声明：指出 XML 文档所用的 DTD
  • 元素：由开始标签、元素内容和结束标签构成
  • 注释：以结束，用于对文档中的内容起一个说明作用
  • 处理指令：通过处理指令来通知其他应用程序来处理非 XML 格式的数据。

XML解析方式有：Dom4j、Sax、Pull

2.1 Dom4j与Sax区别
dom4j不适合大文件的解析，因为它是一下子将文件加载到内存中，所以有可能出现内存溢出，sax是基于事件来对xml进行解析的，所以他可以解析大文件的xml，也正是因为如此，所以dom4j可以对xml进行灵活的增删改查和导航，而sax没有这么强的灵活性，所以sax经常是用来解析大型xml文件，而要对xml文件进行一些灵活（crud）操作就用dom4j。

  1. 以下案例使用dom4j解析xml
    3.1 引入maven依赖
		<dependency>
			<groupId>org.dom4j</groupId>
			<artifactId>dom4j</artifactId>
			<version>2.0.0</version>
		</dependency>

3.2 stu.xml配置（本次放在项目根目录下）

<?xml version="1.0" encoding="UTF-8"?>
<students>
	<student1 id="001">
		<微信公众号>每特学院</微信公众号>
		<学号>20140101</学号>
		<地址>北京海淀区</地址>
		<座右铭>要么强大，要么听话</座右铭>
	</student1>
	<student2 id="002">
		<新浪微博>蚂蚁课堂</新浪微博>
		<学号>20140102</学号>
		<地址>北京朝阳区</地址>
		<座右铭>在哭泣中学会坚强</座右铭>
	</student2>
</students>

3.3 解析代码

public class Dom4jDemo {
	public static void main(String[] args) throws DocumentException {
		SAXReader saxReader = new SAXReader();
		//读取xml配置文件
		Document read = saxReader.read(new File("C:\\ww\\workSpace\\zbm\\zbm\\stu.xml"));
		// 获取根节点
		Element rootElement = read.getRootElement();
		getNodes(rootElement);

	}

	static public void getNodes(Element rootElement) {
		//获取节点名称
		System.out.println("当前节点名称:" + rootElement.getName());
		// 获取属性ID
		List<Attribute> attributes = rootElement.attributes();
		for (Attribute attribute : attributes) {
			System.out.println("属性:" + attribute.getName() + "---" + attribute.getText());
		}
		//获取节点中的值
		if (!rootElement.getTextTrim().equals("")) {
			System.out.println(rootElement.getName() + "--" + rootElement.getText());
		}
		// 使用迭代器遍历
		Iterator<Element> elementIterator = rootElement.elementIterator();
		while (elementIterator.hasNext()) {
			Element next = elementIterator.next();
			getNodes(next);
		}
	}
}

运行结果：
在这里插入图片描述
this.getClass().getClassLoader().getResourceAsStream(xmlPath) 可以获取当前项目路径。

  1. XML与JSON区别
    xml是重量级数据交换格式，占宽带比较大。
    JSON是轻量级交换格式，xml占宽带小。
    所有很多互联网公司都会使用json作为数据交换格式
    很多银行项目，大多数还是在使用xml。

二、Java反射机制

  1. 什么是Java反射
    就是正在运行，动态获取这个类的所有信息。
  2. 反射机制的作用
    通过反射机制访问java对象的属性，方法，构造方法等。
  3. 反射机制的应用场景
    Jdbc 加载驱动
    Spring ioc
    框架
  4. 禁止使用反射机制初始化？
    将构造函数为私有化
  5. 反射机制获取类有三种方法
    1）Class.class 的形式会使 JVM 将使用类装载器将类装入内存（前提是类还没有装入内存），不做类的初始化工作，返回 Class 对象。

代码演示：
ReflectUser类

public class ReflectUser {
	
	private String name;
	
	private String addr;

	public ReflectUser() {
		System.out.println("调用无参函数了，哈哈哈。。。。");
	}
	
	public ReflectUser(String name, String addr) {
		super();
		System.out.println("调用有参函数了，咦咦咦.....");
		this.name = name;
		this.addr = addr;
	}

	public String getName() {
		return name;
	}

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

	public String getAddr() {
		return addr;
	}

	public void setAddr(String addr) {
		this.addr = addr;
	}
	
	public String say(String str) {
		return str;
	}
	
	@Override
	public String toString() {
		return "ReflectUser [name=" + name + ", addr=" + addr + "]";
	}

2）Class.forName() 的形式会装入类并做类的静态初始化，返回 Class 对象。

forNameDemo()方法：

static void forNameDemo() throws ClassNotFoundException, InstantiationException, IllegalAccessException, 
				NoSuchMethodException, SecurityException, IllegalArgumentException, InvocationTargetException {
		//创建此Class 对象所表示的类的一个新实例
		Class<?> forName = Class.forName("wmq.fly.reflection.ReflectUser");
		
		//调用了User的无参数构造方法.
		ReflectUser reflectUser = (ReflectUser) forName.newInstance();
		reflectUser.setName("铁军");
		reflectUser.setAddr("七连");
		System.out.println(reflectUser.toString());
		
		//调用了User的有参数构造方法.
		Constructor<?> constructor = forName.getConstructor(String.class,String.class);
		ReflectUser reflectUser2 = (ReflectUser) constructor.newInstance("小宁","七连");
		System.out.println(reflectUser2.toString());
	}

运行结果：
在这里插入图片描述
3）.getClass() 的形式会对类进行静态初始化、非静态初始化，返回引用运行时真正所指的对象（因为子对象的引用可能会赋给父对象的引用变量中）所属的类的 Class 对象。
代码演示：

static void getClassDemo() throws NoSuchMethodException, SecurityException, IllegalAccessException, 
					IllegalArgumentException, InvocationTargetException {
		ReflectUser reflectUser = new ReflectUser();
		//调用了User的无参数构造方法.
		Class user = reflectUser.getClass();
		Method method = user.getMethod("say", String.class);
		Object invoke = method.invoke(reflectUser, "老刘");
		System.out.println(invoke);
	}

运行结果：
在这里插入图片描述

静态属性初始化是在加载类的时候初始化，而非静态属性初始化是 new 类实例对象的时候初始化。他们三种情况在生成 Class 对象的时候都会先判断内存中是否已经加载此类。

  1. 利用反射给私有属性赋值

代码演示：

static void assignmentValueToPrivate() throws ClassNotFoundException, InstantiationException, 
									IllegalAccessException, NoSuchFieldException, SecurityException {
		//创建此Class 对象所表示的类的一个新实例
		Class<?> forName = Class.forName("wmq.fly.reflection.ReflectUser");
		//获取当前类的所有属性
		Field[] fields = forName.getDeclaredFields();
		System.out.println("属性：");
		for(Field field : fields ) {
			System.out.println(field.getName());
		}
		
		//获取当前类的所有属性
		Method[] methods = forName.getDeclaredMethods();
		System.out.println("方法：");
		for(Method method : methods ) {
			System.out.println(method.getName());
		}
		
		//使用java的反射机制给私有属性赋值
		Object newInstance = forName.newInstance();
		Field fieldName = forName.getDeclaredField("name");
		//允许反射操作私有属性
		fieldName.setAccessible(true);
		fieldName.set(newInstance,"一乐");
		
		Field fieldAdrr = forName.getDeclaredField("addr");
		//允许反射操作私有属性
		fieldAdrr.setAccessible(true);
		fieldAdrr.set(newInstance,"下榕树");
		ReflectUser reflectUser = (ReflectUser)newInstance;
		System.out.println(reflectUser.toString());
	}

运行结果：
在这里插入图片描述

三、利用反射手写springIOC
实现原理：

  1. 利用传入的参数获取xml文件的流,并且利用dom4j解析成Document对象
  2. 对于Document对象获取根元素对象后对下面的标签进行遍历,判断是否有符合的id.
  3. 如果找到对应的id,相当于找到了一个Element元素,开始创建对象,先获取class属性,根据属性值利用反射建立对象.
  4. 遍历标签下的property标签,并对属性赋值.注意,需要单独处理int,float类型的属性.因为在xml配置中这些属性都是以字符串的形式来配置的,因此需要额外处理.
  5. 如果属性property标签有ref属性,说明某个属性的值是一个对象,那么根据id(ref属性的值)去获取ref对应的对象,再给属性赋值.
  6. 返回建立的对象,如果没有对应的id,或者下没有子标签都会返回null

代码实现：
1.引入jar包

		<dependency>
			<groupId>org.dom4j</groupId>
			<artifactId>dom4j</artifactId>
			<version>2.0.0</version>
		</dependency>
		<dependency>
			<groupId>org.apache.commons</groupId>
			<artifactId>commons-lang3</artifactId>
			<version>3.4</version>
		</dependency>

2.applicationContext.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"
	xmlns:p="http://www.springframework.org/schema/p"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:mvc="http://www.springframework.org/schema/mvc"
	xmlns:task="http://www.springframework.org/schema/task"
	xsi:schemaLocation="
	http://www.springframework.org/schema/beans 
	http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
	
	http://www.springframework.org/schema/context 
	http://www.springframework.org/schema/context/spring-context-3.2.xsd
	
	http://www.springframework.org/schema/tx 
	http://www.springframework.org/schema/tx/spring-tx-3.2.xsd
	
	http://www.springframework.org/schema/mvc 
	http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd
	
	http://www.springframework.org/schema/task 
    http://www.springframework.org/schema/task/spring-task.xsd
     ">
     
	<bean id="reflectUser" class="wmq.fly.reflection.ReflectUser">
		<property name="name" value="二和"></property>
		<property name="addr" value="下榕树"></property>
	</bean>	
</beans>

3.解析applicationContext.xml实现springIOC：

public class ClassPathXmlApplicationContext {
	private String pathXml = null;

	public ClassPathXmlApplicationContext(String pathXml) {
		this.pathXml = pathXml;
	}

	public Object getBean(String beanId) throws Exception {
		if (StringUtils.isEmpty(beanId)) {
			throw new Exception("beanId is null");
		}
		//解析xml
		SAXReader saxReader = new SAXReader();
		//this.getClass().getClassLoader().getResource(pathXml)表示获取resource下的xml路径
		Document read = saxReader.read(this.getClass().getClassLoader().getResource(pathXml));
		// 获取到根节点
		Element rootElement = read.getRootElement();
		// 根节点下所有的子节点
		List<Element> elements = rootElement.elements();
		for (Element element : elements) {
			// 获取到节点上的属性
			String id = element.attributeValue("id");
			if (StringUtils.isEmpty(id)) {
				continue;
			}
			if (!id.equals(beanId)) {
				continue;
			}
			// 使用java反射机制初始化对象
			String beanClass = element.attributeValue("class");
			Class<?> forName = Class.forName(beanClass);
			Object newInstance = forName.newInstance();
			List<Element> propertyElementList = element.elements();
			//使用java的反射机制给私有属性赋值
			for (Element el : propertyElementList) {
				String name = el.attributeValue("name");
				String value = el.attributeValue("value");
				Field declaredField = forName.getDeclaredField(name);
				declaredField.setAccessible(true);
				declaredField.set(newInstance, value);
			}
			return newInstance;
		}
		return null;
	}

	public static void main(String[] args) throws Exception {
		ClassPathXmlApplicationContext classPath = new ClassPathXmlApplicationContext("applicationContext.xml");
		ReflectUser reflectUser = (ReflectUser) classPath.getBean("reflectUser");
		System.out.println(reflectUser.getName()+ "---" + reflectUser.getAddr());
	}
}

运行结果：
在这里插入图片描述

wmq_fly
关注
专栏目录
Java代码审计前置知识——SpringMVC基础
m0_61506558的博客
10-25 519
Model2这样不仅提高的代码的复用率与项目的扩展性，且大大降低了项目的维护成本。Model 1模式的实现比较简单，适用于快速开发小规模项目，Model1中JSP页面身兼View和Controller两种角色，将控制逻辑和表现逻辑混杂在一起，从而导致代码的重用性非常低，增加了应用的扩展性和维护的难度。Model2消除了Model1的缺点。1.4 回顾ServletSpring MVC是Spring Framework的一部分，是基于Java实现MVC的轻量级Web框架轻量级，简单易学。
核心重点，面试神技———《Java面试突击核心讲》
m0_55849656的博客
06-24 856
又是一年一度的 “金九银十” 秋招大热门，为助力广大程序员朋友 “面试造火箭”，今天给大家分享的便是这份核心内部的面试神技——1658页《Java面试突击核心讲》！
java 数据交换
记忆流年的博客
08-18 1648
摘要今天写了闲着没事，写了一个排序算法，其中一个写了一个交换的函数，发现并不起作用，后来想起来初学的时候同样犯过此错误，故在此将解决方法写下。
java:数据交换
Claire的博客
02-28 1217
java:数据交换 题目 问题描述 　　编写一个程序，输入两个整数，分别存放在变量x和y当中，然后使用自己定义的函数swap来交换这两个变量的值。 　　输入格式：输入只有一行，包括两个整数。 　　输出格式：输出只有一行，也是两个整数，即交换以后的结果。 　　要求：主函数负责数据的输入与输出，但不能直接交换这两个变量的值，必须通过调用单独定义的函数swap来完成，而swap函数只负责交换变量的值，不...
蓝桥杯算法训练 数据交换（Java解法）
Blank
01-11 1538
算法训练 数据交换
java 各类数据库的数据交换
iteye_19463的博客
12-31 227
这些天经常遇到要把mysql 数据库转到sql2000 要么就是反之 我觉的 在项目可能会用到，就在此共享出来,我只把主要的帖出来,源码下载即可 思路 其实就是 查询和插入 把要导入数据查出来,放到list 然后把list 的数据插入到目的数据库 DateChang newdate = new DateChang(); newdate.setDb("...
Java零基础——SpringSecurity篇
最新发布
m0_47946173的博客
12-04 2119
Spring Security是一个能够为基于Spring的企业应用系统提供声明式（注解）的安全访问控制解决方案的安全框架。它提供了一组可以在Spring应用上下文中配置的Bean，充分利用了Spring IoC，DI（控制反转Inversion of Control ,DI:Dependency Injection 依赖注入）和AOP（面向切面编程）功能，为应用系统提供声明式的安全访问控制功能，减少了为企业系统安全控制编写大量重复代码的工作。
Java牛客网社区项目——知识点&面试题
热门推荐
weixin_48610702的博客
04-19 3万+
请简要介绍一下你的项目？ 这个项目的整体结构来源于牛客网，主要使用了Springboot、Mybatis、MySQL、Redis、Kafka、等工具。主要实现了用户的注册、登录、发帖、点赞、系统通知、按热度排序、搜索等功能。另外引入了redis数据库来提升网站的整体性能，实现了用户凭证的存取、点赞关注的功能。基于 Kafka 实现了系统通知：当用户获得点赞、评论后得到通知。利用定时任务定期计算帖子的分数，并在页面上展现热帖排行榜。 什么是Spring框架？ 有很多模块组成，利用这些模块可以方便开发工作。这些
从腾讯T3-3程序员手上获得的Java架构进阶PDF文档，图文并茂，真香
m0_69804655的博客
02-26 153
但是整理成了一份详细的31份PDF文档：Linux+JVM+ Spring+MySQL+Mybatis+设计模式+分布式+微服务+多线程+ActiveMQ+Zookeeper+Dubbo+SpringCloud 微服务+Nginx+SpringBoot+NIO+线程池原理分析&锁的深度化，有需要的朋友可以在文末获取免费领取方式！比如，面试后端开发岗位时，面试官不仅考察基础能力，更会重点考察高并发、分布式等架构相关的技术背后的思考逻辑，比如：分布式，数据库，微服务，负载均衡，Redis，RPC等。
数据交换平台
04-10
江苏瑞中数据股份有限公司（China Realtime Database Co.,Ltd.）,简称CRD，是国网电力科学研究院/南京南瑞集团公司控股子公司，专业从事具有自主知识产权的大型通用实时数据库管理系统及数据管理软件的研究开发、项目实施和技术服务，注册资本为1亿元人民币。
java 四种数据交换经典
05-16
java 中四种整数数据的交换方法, 其中有两种方式为经典代码.
数据交换平台方案设计.pdf
05-04
数据交换平台方案设计.pdf
java数据交换,Java之数据的交换比较
weixin_32408723的博客
03-15 119
传统型：这需要用到第三方变量class Swap{public static void main(String[] args){int X = 3,Y = 4;int TEMP;TEMP = X;X = Y;Y = TEMP;}}而这种非传统模型；则不需通过第三方变量来存储数据，两个数据就能实现交换class ExclusiveOrDemo{public static void main(Stri...
Java数据交换格式
weixin_34370347的博客
02-24 137
2019独角兽企业重金招聘Python工程师标准>>> ...
【JAVA】数据交换,java方法参数
Tastill的博客
08-16 417
还是先看题吧： package test.java; public class test8 {     static String a = "yes";     static String b ="no";     public static void main(String[] args) {                  jh(a,b);         System.
数据交换java_java基础课程_数据交换三种方法
weixin_42411003的博客
02-20 117
//方法一int c = n;n=m;m=c;//测试System.out.println("n="+n+"\nm="+m);//方法 二用 +-做交换int x=10,y=5;x=x+y; //5+20y=x-y; //25-20x=x-y; //25-5System.out.println("x="+x+"\ny="+y);//方式三 异或效率最高int a=2,b=4;a=a^b;b=...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值