22-05-29 西安 javaweb(11) ajax、axios、gson/jackson/fastjson

ajax  异步的JavaScript和XML

js中的一个技术，实现前后端分离，前后端分离就是分服务器部署，彻底舍弃了thymeleaf。

ajax中必须使用响应浏览器数据，不能是请求转发和重定向

---

浏览器兼容性问题 xmlHttpRequest

原生的ajax有浏览器的兼容问题
ie：xmlHttpRequest这个对象被继承到activex插件

ajax是分为原生ajax 和 封装后的ajax【axios】，axios不需要考虑浏览器的兼容问题

---

同步请求与异步请求

超链接，表单提交，地址栏输入回车，刷新都是同步请求

同步特点：
1、同步请求伴随着页面的刷新或跳转，实现全局更新
2、多个同步请求，请求会按照顺序依次执行，前面的请求没有执行完，后面的请求将处于阻塞状态

异步特点：
1.异步请求是在页面不刷新或跳转的情况下，与服务交互，实现局部刷新
2.异步请求一旦发送，其后面的代码继续执行，并不会等到ajax请求处理完毕（请求和响应都处理完毕）再执行

---

axios 最流行的前端ajax框架

ajax数据原生js的一部分,axios封装了ajax的技术。axios使用的时候要引入axios.js

<script type="text/javascript" src="static/script/axios.js"></script>

axios使用的完整格式：

"params"设置的请求参数都会拼接在请求地址后，不管get还是post

“data”里的请求参数一定不会去拼接，data冒号后面什么样，传的参数就长什么样

axios({
    url:"",//设置请求路径
    method:"",//设置请求方式
    params:{},//设置请求参数，name=value&name=value
    data:{}//设置请求参数，以json格式将数据在请求体中传输到服务器
}).then(function(response){
    //当前的ajax请求处理成功后执行then中的函数
    //response封装了服务器响应到浏览器的数据，其中response.data是服务器响应到浏览器的数据
}).catch(function(){
    //当前的ajax请求处理失败后执行catch中的函数
});

---

ES6 的箭头函数：

可以将回调函数简写为箭头函数

function (){}-----()=>{}
function (response){}-----response=>{}
function (a,b){}-----(a,b)=>{}      

这要就可以把then里改成这样了，好处是 可以使用this了。

• 如果this写在function(){}，this就不是vue对象了
• 如果this写在()=>{}，this就一定是vue对象

then(response => {
   this.message = response.data
})

在idea中需要设置一下，使得支持ES6的语法

---

axios使用的简化格式：

get提交方式没有请求体，不能和data搭配,不能传json格式的数据

axios.get("请求地址");
axios.post("请求地址",{相当于data属性，传输一个json格式的请求参数});

axios.post("TestAxiosServlet?method=testGetJson",{
    username:"admin",
    password:"123456",
    age:"23"
}).then(response=>{
    console.log(response.data);
});

data里的json格式的数据，在服务端是不能使用下面俩个方法获取的

request.getParameter(name)、request.getParameterValues(name)

---

获取请求体中的json 字符串

封装一段公共的的通用的代码，来获取请求体中的内容

//1.获取请求体
BufferedReader reader = request.getReader();
StringBuilder sb = new StringBuilder();
String line = "";
//2. 从requestReader中循环读取拼接字符串
while((line = reader.readLine()) != null){
    sb.append(line);
}
//3. 将stringBuilder转成字符串，这个字符串就是Json请求体
String jsonParam = sb.toString();

这样就可以原样获取请求体中的json字符串了：

---

json处理工具

首先创建一个简单的类，例如：User

@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {
    private Integer id;
    private String username;
    private String password;
    private Integer age;
}

1、gson.jar

 <!-- Gson -->
 <dependency>
     <groupId>com.google.code.gson</groupId>
     <artifactId>gson</artifactId>
     <version>2.8.6</version>
 </dependency>

Gson是Google研发的一款非常优秀的JSON数据解析和生成工具，它可以帮助我们将数据在JSON字符串和Java对象之间互相转换。

转换普通对象Bean：将JavaBean转换为json，或将json字符串转换为JavaBean。

fromJson（）方法        

1.java中实体类对象转为json字符串（gson序列化）

User user = new User(1001,"root1","123456",30);
//调用Gson的String toJson(Object)方法将Bean转换为json字符串
String jsonStr = gson.toJson(user);

2.json字符串解析转成实体类对象（gson反序列）

Gson gson = new Gson();
//调用Gson的 <T> t fromJson(String, Class)方法，将Json串转换为对象
User user = gson.fromJson(jsonParam, User.class);

总结：能用实体类则用实体类，没有实体类再用map

转换Map集合：将Map集合转换为json，或将json转换为Map集合。

1.map转集合为json字符串

Map<String, Object> map = new HashMap<>();
map.put("id", "10086");
map.put("username", "admin");
map.put("password", "123456");
String jsonStr = gson.toJson(map);

2.json字符串解析转成Map集合

Gson gson = new Gson();
Map map = gson.fromJson(jsonParam, Map.class);

转换List集合：将List集合转换为json，或将json转换为List集合。

1.将list集合转为json数组

GSON提供了一个漂亮的打印选项，可以在其中打印JSON，以便于更加方便阅读。

public static void main(String[] args) {
    List<User> list = new ArrayList<User>();
    list.add(new User(1001, "root1", "123", 10));
    list.add(new User(1002, "root2", "123", 10));
    //美化json字符串打印
    Gson gson = new GsonBuilder()
            .setPrettyPrinting()
            .create();
    String jsonStr = gson.toJson(list);
    System.out.println(jsonStr);
}

2.将json字符串转换为List集合（反序列化）

 //...此处延续以上代码
 // 调用Gson的 T fromJson(String, Type)将List集合的json串反序列化为List对象
 List<User> ulist = gson.fromJson(jsonStr, new TypeToken<List<User>>(){}.getType());

JsonParser：类提供3种方法来提供JSON作为源并将其解析为JsonElements树。

• JsonElement parse（JsonReader json）–使用JsonReader读取JSON作为令牌流，并从JSON流中返回下一个值作为分析树。
• JsonElement parse（java.io.Reader json）–使用指定的阅读器读取JSON并将JSON字符串解析为解析树。
• JsonElement parse（java.lang.String json）–将指定的JSON字符串解析为解析树。

如果指定的文本不是有效的JSON，则这三个方法都将抛出JsonParseException和JsonSyntaxException。

-------------------------------------

JsonElement, JsonObject 和JsonArray

在JsonElement树中解析了JSON字符串后，我们就可以使用它的各种方法来访问JSON数据元素。

例如，使用一种类型检查方法找出它代表什么类型的JSON元素：

jsonElement.isJsonObject();
jsonElement.isJsonArray();
jsonElement.isJsonNull();
jsonElement.isJsonPrimitive();

我们可以使用相应的方法将JsonElement转换为JsonObject和JsonArray：

JsonObject jsonObject = jsonElement.getAsJsonObject();
JsonArray jsonArray = jsonElement.getAsJsonArray();

一旦有了JsonObject或JsonArray实例，就可以使用其get（）方法从中提取字段。

JsonParser使用举例

JsonObject jobj=null;
if(StringUtils.isNotBlank(param)) {//如果存在参数
	JsonParser parser=new JsonParser();
	jobj=parser.parse(param).getAsJsonObject();
}

---

2、jackson  

是Java中比较常用的JSON解析的工具包 ，SpringMVC和SpringBoot中默认支持的就是jackson

readValue()  //json字符串转为对象或者map

ObjectMapper mapper = new ObjectMapper();
User user = mapper.readValue(jsonParam, User.class);

writeValueAsString（）//对象或map转为json字符串

//将实体类转换为json字符串
ObjectMapper mapper = new ObjectMapper();
String jsonstr=mapper.writeValueAsString(user);

//将map集合转换为json字符串
Map<String, Object> map = new HashMap<>();
map.put("id", "10086");
map.put("username", "admin");
map.put("password", "123456");
String jsonStr = mapper.writeValueAsString(map);  

@JsonFormat注解是jackson包里面的一个注解

@JsonFormat注解是一个时间格式化注解，比如我们存储在mysql中的数据是date类型的，当我们读取出来封装在实体类中的时候，就会变成英文时间格式，而不是yyyy-MM-dd HH:mm:ss这样的中文时间，因此我们需要用到JsonFormat注解来格式化我们的时间。

@JsonFormat只会在类似@ResponseBody返回json数据的时候，才会返回格式化的yyyy-MM-dd HH:mm:ss时间，你直接使用System.out.println()输出的话，仍然是类似“Fri Dec 01 21:05:20 CST 2017”这样的时间样式。

/**
* 创建时间
*/
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone="GMT+8")
private Date createTime;

/**
* 更新时间
*/
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone="GMT+8")
private Date updateTime;

---

3、fastjson.jar

pom.xml引入依赖

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

json字符串转为Java对象互相转换

//对象转json字符串 toJSONString（）
User user = new User(1001, "海月", "123456", "18");
String jsonString = JSON.toJSONString(user);
System.out.println(jsonString);

//json字符串转对象
User parse_user = JSON.parseObject(jsonString, User.class);
System.out.println(parse_user);

控制台打印

json字符串转为对象数组互相转换

User user1 = new User(1001, "海月", "123456", "18");
User user2 = new User(1002, "帝俊", "123456", "20");
List<User> users = new ArrayList<User>();
users.add(user1);
users.add(user2);

//对象数组转json字符串 toJSONString（）
String jsonString = JSON.toJSONString(users);
System.out.println(jsonString);

//json字符串转对象数组
List<User> userList = JSON.parseArray(jsonString, User.class);
System.out.println(userList);

控制台打印

JSONObject的数据是用 {  } 来表示的

JSONArray，顾名思义是由JSONObject构成的数组，用  [ { } , { } , ......  , { } ]  来表示

---

4、json-lib.jar

net.sf.json的json包，转换功能一般。

需要对引入的json-lib的jdk版本进行区分。

<!-- net.sf.json包 -->
<dependency>
    <groupId>net.sf.json-lib</groupId>
    <artifactId>json-lib</artifactId>
    <version>2.4</version>
    <classifier>jdk15</classifier>
</dependency>

jsonString和jsonObject和javaBean和map

package net.sf.json;
//JSONObject类本身是一个Map
public final class JSONObject extends AbstractJSON implements JSON, Map, Comparable {

}

    public static void main(String[] args) {

        String data = "{'name':'xym','age':1}";

        //jsonString转jsonObject
        JSONObject jsonObject = JSONObject.fromObject(data);
        //获取属性
        String name = jsonObject.getString("name");
        int age = jsonObject.getInt("age");

        //jsonObject转jsonString
        String jsonString = jsonObject.toString();
        System.out.println("jsonObject转jsonString:\t"+jsonString);

        //jsonObject转javaBean
        UserBean bean = (UserBean) JSONObject.toBean(jsonObject, UserBean.class);
        System.out.println("jsonObject转javaBean:\t"+bean);

        //javaBean转jsonObject
        UserBean lulu = new UserBean("lulu", 10);
        JSONObject jsonObject1 = JSONObject.fromObject(lulu);
        System.out.println("javaBean转jsonObject:\t"+jsonObject1.toString());


        //map转jsonObject
        HashMap<String, Object> map = new HashMap<>();
        map.put("height","100");
        map.put("length",80);
        map.put("width",30);
        JSONObject jsonObject2 = JSONObject.fromObject(map);
        System.out.println("map转jsonObject:\t"+jsonObject2.toString());

        //jsonObject转map
        Map<String, Object> mapBean = (Map) JSONObject.toBean(jsonObject2, Map.class,map);
        System.out.println("jsonObject转map:\t"+mapBean.get("length"));
    }

控制台输出如下：

----------------------------------------------

jsonObject转jsonString:    {"name":"xym","age":1}

jsonObject转javaBean:    UserBean(name=xym, age=1)
javaBean转jsonObject:    {"age":10,"name":"lulu"}
map转jsonObject:    {"length":80,"width":30,"height":"100"}
jsonObject转map:    80

-----------------------------------------------

List转jsonArray

Game game1 = new Game(1l, "王者荣耀", "大仙不闹", 99);
Game game2 = new Game(2l, "明日之后", "快手杨帅", 99);
List<Game> List = Arrays.asList(game1, game2);
JSONArray jsonArray= JSONArray.fromObject(List);

JSONArray转list

List<Game> list = JSONArray.toList(jsonArray, Game.class);
System.out.println(list);

JSONSerializer

JSONSerializer可以任何java对象转换为JSON, 这样就能够方法JSONObject和JSONArray使用了。 

        UserBean zaizai = new UserBean("zaizai", 8);

        //JavaBean-》JSON
        JSON json = JSONSerializer.toJSON(zaizai);
        System.out.println(json);

如果将一个java对象传给Json可以使用JSONSerializer.toJSON()，

将一个合法的json传给一个Java对象可以使用JSONSerializer.toJava()

XMLSerializer

处理XML，获

---

取XML对应的JSON对象

---

序列化

1、fastjson

/**
 * 序列化接口类
 */
public interface Serializer {
    /**
     * java 对象转换成二进制
     */
    byte[] serialize(Object object);

    /**
     * 二进制转换成 java 对象
     */
    <T> T deserialize(Class<T> clazz, byte[] bytes);
}

fastjson实现

import com.alibaba.fastjson.JSON;

public class JSONSerializer implements Serializer {
    @Override
    public byte[] serialize(Object object) {
        return JSON.toJSONBytes(object);
    }

    @Override
    public <T> T deserialize(Class<T> clazz, byte[] bytes) {
        return JSON.parseObject(bytes,clazz);
    }
}

测试：

@Slf4j
public class Test01 {
    public static void main(String[] args) {
        Address address = new Address("陕西省", "西安市", "雁塔区");
        User user = new User(1, "小羽毛", "123456", address);
        //序列化为二进制数据
        JSONSerializer jsonSerializer = new JSONSerializer();
        byte[] content = jsonSerializer.serialize(user);

        //中间经过网络传输...

        //反序列化
        User user1 = jsonSerializer.deserialize(User.class, content);
        log.info("user1:{}", user1);
    }
}