使用fastjson解析json
添加jar fastjson-1.1.43 或引入maven依赖
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.1.43</version>
</dependency>
使用fastjson api
public static final Object parse(String text); // 把JSON文本parse为JSONObject或者JSONArray
public static final JSONObject parseObject(String text); // 把JSON文本parse成JSONObject
public static final <T> T parseObject(String text, Class<T> clazz); // 把JSON文本parse为JavaBean
public static final JSONArray parseArray(String text); // 把JSON文本parse成JSONArray
public static final <T> List<T> parseArray(String text, Class<T> clazz); //把JSON文本parse成JavaBean集合
public static final String toJSONString(Object object); // 将JavaBean序列化为JSON文本
public static final String toJSONString(Object object, boolean prettyFormat); // 将JavaBean序列化为带格式的JSON文本
public static final Object toJSON(Object javaObject); 将JavaBean转换为JSONObject或者JSONArray。
解析json
Json转对象
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 + "]";
}
}
public 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转换对象api
// 2.使用java反射机制 对应生成对象
User user = new JSONObject().parseObject(json, User.class);
System.out.println("user:" + user.toString());
Json api封装json
// 1.json api 封装json
JSONObject root = new JSONObject();
root.put("id", "01");
root.put("name", "张三");
JSONArray arrayList = new JSONArray();
JSONObject object1 = new JSONObject();
object1.put("itemId", "20");
object1.put("itemName", "测试");
JSONObject object2 = new JSONObject();
object2.put("itemId", "30");
object2.put("itemName", "测试22");
arrayList.add(object1);
arrayList.add(object2);
root.put("items", arrayList);
System.out.println(root.toJSONString());
将对象转换成json字符串
User user = new User();
user.setId("01");
user.setName("张三");
List<Item> items =new ArrayList<Item>();
Item item1 = new Item();
item1.setItemId("20");
item1.setItemName("测试");
Item item2 = new Item();
item2.setItemId("30");
item2.setItemName("测试");
items.add(item1);
items.add(item2);
user.setItems(items);
System.out.println(new JSONObject().toJSONString(user));
xml
Dom4j与Sax区别
dom4j不适合大文件的解析,因为它是一下子将文件加载到内存中,所以有可能出现内存溢出,sax是基于事件来对xml进行解析的,所以他可以解析大文件的xml,也正是因为如此,所以dom4j可以对xml进行灵活的增删改查和导航,而sax没有这么强的灵活性,所以sax经常是用来解析大型xml文件,而要对xml文件进行一些灵活(crud)操作就用dom4j。
解析xml代码
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);
}
}
Java反射机制
禁用反射机制---将构造函数私有化(面)
//第一种方式:
Classc1 = Class.forName("Employee");
//第二种方式:
//java中每个类型都有class 属性.
Classc2 = Employee.class;
//第三种方式:
//java语言中任何一个java对象都有getClass 方法
Employeee = new Employee();
Classc3 = e.getClass(); //c3是运行时类 (e的运行时类是Employee)
反射创建对象的方式
Class<?> forName = Class.forName("com.itmayiedu.entity.User");
// 创建此Class 对象所表示的类的一个新实例 调用了User的无参数构造方法.
Object newInstance = forName.newInstance();
实例化有参构造函数
Class<?> forName = Class.forName("com.itmayiedu.entity.User");
Constructor<?> constructor = forName.getConstructor(String.class, String.class);
User newInstance = (User) constructor.newInstance("123", "123");
使用反射为类私有属性赋值
// 为user对象私有属性赋值
Class<?> classUser = Class.forName("com.itmayiedu.entity.User");
// 获取到当前的所有属性
Field[] fields = classUser.getDeclaredFields();
for (Field field : fields) {
System.out.println(field.getName());
}
// 获取当前所有的方法
Method[] declaredMethods = classUser.getDeclaredMethods();
for (Method method : declaredMethods) {
System.out.println(method.getName());
}
// 初始化对象
User user = (User) classUser.newInstance();
Field declaredField = classUser.getDeclaredField("id");
// 标记为true 允许反射赋值
declaredField.setAccessible(true);
declaredField.set(user, "20");
System.out.println("使用反射机制给id赋值为:"+user.getId());
什么是SpringIOC底层实现原理
1.读取bean的XML配置文件
2.使用beanId查找bean配置,并获取配置文件中class地址。
3.使用Java反射技术实例化对象
4.获取属性配置,使用反射技术进行赋值
建立实体类
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;
}
}
使用反射技术完成Java代码
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");
}
SAXReader saxReader = new SAXReader();
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();
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");
User user = (User) classPath.getBean("user2");
System.out.println(user.getUserId() + "---" + user.getUserName());
}
}
Maven坐标
<dependencies>
<!-- https://mvnrepository.com/artifact/org.apache.commons/commons-lang3 -->
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
<version>3.4</version>
</dependency>
<dependency>
<groupId>org.dom4j</groupId>
<artifactId>dom4j</artifactId>
<version>2.0.0</version>
</dependency>
</dependencies>