数据交换格式与SpringIOC底层实现
- 目标
XML和JSON
Java反射机制
手写SpringIOC
- 什么是数据交换格式
客户端与服务器常用数据交换格式xml、json、html
- 数据交换格式用场景
移动端(安卓、IOS)通讯方式采用http协议+JSON格式 走restful风格。
很多互联网项目都采用Http协议+JSON
因为xml比较重WebService服务采用http+xml格式 银行项目使用比较多
4.1JSON简单使用
4.1.1.什么是JSON
JSON(JavaScript Object Notation)是一种轻量级的数据交换格式，相比于xml这种数据交换格式来说，因为解析xml比较的复杂，而且需要编写大段的代码，所以客户端和服务器的数据交换格式往往通过JSON来进行交换。
样例:
| { "sites": [ { "name": "蚂蚁课堂", "url": "www.itmayiedu.com" }, { "name": "每特教育", "url": "http://meiteedu.com/" } ] } |
JSON：JavaScript 对象表示法（JavaScript Object Notation）。
JSON的形式是用大括号“{}”包围起来的项目列表，每一个项目间用逗号（,）分隔，而项目就是用冒号（:）分隔的属性名和属性值。这是典型的字典表示形式，也再次表明javascript里的对象就是字典结构。不管多么复杂的对象，都可以用一句JSON代码来创建并赋值。在JSON中，名称 / 值对包括字段名称（在双引号中），后面写一个冒号，然后是值
4.1.2.JSON格式的分类
JSON有两种结构
json简单说就是javascript中的对象和数组，所以这两种结构就是对象和数组两种结构，通过这两种结构可以表示各种复杂的结构
1、对象：对象在js中表示为“{}”括起来的内容，数据结构为 {key：value,key：value,...}的键值对的结构，在面向对象的语言中，key为对象的属性，value为对应的属性值，所以很容易理解，取值方法为 对象.key 获取属性值，这个属性值的类型可以是 数字、字符串、数组、对象几种。
2、数组：数组在js中是中括号“[]”括起来的内容，数据结构为 ["java","javascript","vb",...]，取值方式和所有语言中一样，使用索引获取，字段值的类型可以是 数字、字符串、数组、对象几种。
经过对象、数组2种结构就可以组合成复杂的数据结构了。
4.1.3.常用JSON解析框架
fastjson(阿里)、gson(谷歌)、jackson(SpringMVC自带)
4.1.4.使用fastjson解析json
添加jar fastjson-1.1.43 或引入maven依赖
| <dependency> <groupId>com.alibaba</groupId> <artifactId>fastjson</artifactId> <version>1.1.43</version> </dependency> |
4.1.5.使用fastjson api
| public static final Object parse(String text); // 把JSON文本parse为JSONObject或者JSONArray |
4.1.6.解析json
| static String jsonStr = "{\"sites\":[{\"name\":\"aa\",\"url\":\"www.itmayiedu.com\"},{\"name\":\"ss\",\"url\":\"http://meiteedu.com/\"}]}";
public static void main(String[] args) { JSONObject jsonObject = new JSONObject(); // 将json字符串转为jsonbject JSONObject jsonStrObject = jsonObject.parseObject(jsonStr); 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); } } |
4.1.6.组装json
| JSONObject jsonObject = new JSONObject(); JSONArray jsonArray = new JSONArray(); JSONObject stObject = new JSONObject(); stObject.put("name", "dd"); stObject.put("url", "http://www.baidu.com"); jsonArray.add(stObject); jsonObject.put("sites", jsonArray); System.out.println(jsonObject.toJSONString()); |
4.2XML简单使用
4.2.1什么是XML？
它是可扩展标记语言（Extensible Markup Language，简称XML），是一种标记语言。
XML 全称为可扩展的标记语言。主要用于描述数据和用作配置文件。
XML 文档在逻辑上主要由一下 5 个部分组成：
XML 声明：指明所用 XML 的版本、文档的编码、文档的独立性信息
文档类型声明：指出 XML 文档所用的 DTD
元素：由开始标签、元素内容和结束标签构成
注释：以结束，用于对文档中的内容起一个说明作用
处理指令：通过处理指令来通知其他应用程序来处理非 XML 格式的数据，格式为
XML 文档的根元素被称为文档元素，它和在其外部出现的处理指令、注释等作为文档实体的子节点，根元素本身和其内部的子元素也是一棵树。
4.2.2 XML样例？
| <?xml version="1.0" encoding="UTF-8"?> <students> <student1 id="001"> <微信公众号>@ss</微信公众号> <学号>20140101</学号> <地址>北京海淀区</地址> <座右铭>要么强大，要么听话</座右铭> </student1> <student2 id="002"> <新浪微博>@ss</新浪微博> <学号>20140102</学号> <地址>北京朝阳区</地址> <座右铭>在哭泣中学会坚强</座右铭> </student2> </students> |
<?xml version="1.0" encoding="UTF-8"?>作用
xml文件头部要写的话，说明了xml的版本和编码，utf-8一般是网络传输用的编码
4.2.3XML解析方式？
Dom4j、Sax、Pull
4.2.3Dom4j与Sax区别
dom4j不适合大文件的解析，因为它是一下子将文件加载到内存中，所以有可能出现内存溢出，sax是基于事件来对xml进行解析的，所以他可以解析大文件的xml，也正是因为如此，所以dom4j可以对xml进行灵活的增删改查和导航，而sax没有这么强的灵活性，所以sax经常是用来解析大型xml文件，而要对xml文件进行一些灵活（crud）操作就用dom4j。
4.2.4 使用dom4j解析xml
解析XML过程是通过获取Document对象，然后继续获取各个节点以及属性等操作，因此获取Document对象是第一步，大体说来，有三种方式：
1.自己创建Document对象
| Document document = DocumentHelper.createDocument(); Element root = document.addElement("students"); |
其中students是根节点，可以继续添加其他节点等操作。
2.自己创建Document对象
| // 创建SAXReader对象 SAXReader reader = new SAXReader(); // 读取文件 转换成Document Document document = reader.read(new File("XXXX.xml")); |
3.读取XML文本内容获取Document对象
| String xmlStr = "<students>......</students>"; Document document = DocumentHelper.parseText(xmlStr); |
4.2.5 解析xml代码
Xml配置:
| <?xml version="1.0" encoding="UTF-8"?> <students> <student1 id="001"> <微信公众号>@残缺的孤独</微信公众号> <学号>20140101</学号> <地址>北京海淀区</地址> <座右铭>要么强大，要么听话</座右铭> </student1> <student2 id="002"> <新浪微博>@残缺的孤独</新浪微博> <学号>20140102</学号> <地址>北京朝阳区</地址> <座右铭>在哭泣中学会坚强</座右铭> </student2> </students> |
Java代码
| public static void main(String[] args) throws DocumentException { SAXReader saxReader = new SAXReader(); Document read = saxReader.read(new File("E://work//spring-ioc//src//main//resources//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) 获取当前项目路径xmlfsfs
4.2 XML与JSON区别
Xml是重量级数据交换格式，占宽带比较大。
JSON是轻量级交换格式，xml占宽带小。
所有很多互联网公司都会使用json作为数据交换格式
很多银行项目，大多数还是在使用xml。
- Java反射机制
5.1 什么是Java反射
就是正在运行，动态获取这个类的所有信息。
5.2 反射机制的作用
1，反编译：.class-->.java
2．通过反射机制访问java对象的属性，方法，构造方法等；
5.3 反射机制的应用场景
Jdbc 加载驱动-----
Spring ioc
框架
5.4反射机制获取类有三种方法
| //第一种方式： Classc1 = Class.forName("Employee"); //第二种方式： //java中每个类型都有class 属性. Classc2 = Employee.class;
//第三种方式： //java语言中任何一个java对象都有getClass 方法 Employeee = new Employee(); Classc3 = e.getClass(); //c3是运行时类 (e的运行时类是Employee) |
5.5反射创建对象的方式
| Class<?> forName = Class.forName("com.itmayiedu.entity.User"); // 创建此Class 对象所表示的类的一个新实例 调用了User的无参数构造方法. Object newInstance = forName.newInstance(); |
实例化有参构造函数
| Class<?> forName = Class.forName("com.baidu.entity.User"); Constructor<?> constructor = forName.getConstructor(String.class, String.class); User newInstance = (User) constructor.newInstance("123", "123"); |
5.6 反射创建api
| 方法名称 | 作用 |
| getDeclaredMethods [] | 获取该类的所有方法 |
| getReturnType() | 获取该类的返回值 |
| getParameterTypes() | 获取传入参数 |
| getDeclaredFields() | 获取该类的所有字段 |
| setAccessible | 允许访问私有成员 |
5.7 使用反射为类私有属性赋值
| // 获取当前类class地址 Class<?> forName = Class.forName("com.liu.entity.User"); // 使用反射实例化对象 无参数构造函数 Object newInstance = forName.newInstance(); // 获取当前类的 userId字段 Field declaredField = forName.getDeclaredField("userId"); // 允许操作私有成员 declaredField.setAccessible(true); // 设置值 declaredField.set(newInstance, "123"); User user = (User) newInstance; System.out.println(user.getUserId()); |
- 手写SpringIOC框架
6.1什么是SpringIOC
什么是SpringIOC，就是把每一个bean(实体类)与bean(实体了)之间的关系交给第三方容器进行管理。
Xml配置:
| <beans> <bean id="user1" class="com.itmayiedu.entity.UserEntity"> <property name="userId" value="0001"></property> <property name="userName" value="dd"></property> </bean> <bean id="user2" class="com.liu.entity.UserEntity"> <property name="userId" value="0002"></property> <property name="userName" value="张三"></property> </bean> </beans> |
Java代码:
| //1.读取springxml配置 ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext( "applicationContext.xml"); //2.获取bean对象 TestService testService = (TestService) classPathXmlApplicationContext.getBean("testService"); System.out.println(testService.test());
|
6.2什么是SpringIOC底层实现原理
1.读取bean的XML配置文件
2.使用beanId查找bean配置，并获取配置文件中class地址。
3.使用Java反射技术实例化对象
4.获取属性配置，使用反射技术进行赋值。
详细步骤
| 1.利用传入的参数获取xml文件的流,并且利用dom4j解析成Document对象 2.对于Document对象获取根元素对象<beans>后对下面的<bean>标签进行遍历,判断是否有符合的id. 3.如果找到对应的id,相当于找到了一个Element元素,开始创建对象,先获取class属性,根据属性值利用反射建立对象. 4.遍历<bean>标签下的property标签,并对属性赋值.注意,需要单独处理int,float类型的属性.因为在xml配置中这些属性都是以字符串的形式来配置的,因此需要额外处理. 5.如果属性property标签有ref属性,说明某个属性的值是一个对象,那么根据id(ref属性的值)去获取ref对应的对象,再给属性赋值. 6.返回建立的对象,如果没有对应的id,或者<beans>下没有子标签都会返回null |
6.3建立实体类
| public class User {
private String userId; private String userName; public String getUserId() { return userId; } public void setUserId(String userId) { this.userId = userId; } public String getUserName() { return userName; } public void setUserName(String userName) { this.userName = userName; } } |
6.4 使用反射技术完成Java代码
| import java.lang.reflect.Field; import java.util.List;
import org.apache.commons.lang3.StringUtils; import org.dom4j.Document; import org.dom4j.Element; import org.dom4j.io.SAXReader;
public class ClassPathXmlApplicationContext { private String xmlPath;
/** * * @param xmlPath * spring xml 配置路径 */ public ClassPathXmlApplicationContext(String xmlPath) { this.xmlPath = xmlPath; }
public Object getBean(String beanId) throws Exception {
// 解析xml器 SAXReader saxReader = new SAXReader(); Document read = null; try { // 从项目根目录路径下 读取 read = saxReader.read(this.getClass().getClassLoader().getResourceAsStream(xmlPath)); } catch (Exception e) { e.printStackTrace(); } if (read == null) { return null; } // 获取根节点资源 Element root = read.getRootElement(); List<Element> elements = root.elements(); if (elements.size() <= 0) { return null; } Object oj = null; for (Element element : elements) { String id = element.attributeValue("id"); if (StringUtils.isEmpty(id)) { return null; } if (!id.equals(beanId)) { continue; // throw new Exception("使用beanId:" + beanId + ",未找到该bean"); } // 获取实体bean class地址 String beanClass = element.attributeValue("class"); // 使用反射实例化bean Class<?> forNameClass = Class.forName(beanClass); oj = forNameClass.newInstance(); // 获取子类对象 List<Element> attributes = element.elements(); if (attributes.size() <= 0) { return null; } for (Element et : attributes) { // 使用反射技术为方法赋值 String name = et.attributeValue("name"); String value = et.attributeValue("value"); Field field = forNameClass.getDeclaredField(name); field.setAccessible(true); field.set(oj, value);
}
} return oj; // 1.使用beanId查找配置文件中的bean。 // 2.获取对应bean中的classpath配置 // 3.使用java反射机制实体化对象 }
public static void main(String[] args) throws Exception { ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext( "applicationContext.xml"); User bean = (User) applicationContext.getBean("user2"); System.out.println("使用反射获取bean" + bean.getUserId() + "---" + bean.getUserName());
} }
|
扫一扫
2440
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
