仿微信开发笔记（第七章）

1.准备工作

1.1导入处理响应消息的类 BMoocJSONResult.class

  作用：提供给门户，ios，安卓，微信商城用的 ， 门户接受此类数据后需要使用本类的方法转换成对于的数据类型格式（类，或者list）

package com.bmooc.utils;
/*自定义响应数据结构
 * 				这个类是提供给门户，ios，安卓，微信商城用的
 * 				门户接受此类数据后需要使用本类的方法转换成对于的数据类型格式（类，或者list）
 * 				其他自行处理
 * 				200：表示成功
 * 				500：表示错误，错误信息在msg字段中
 * 				501：bean验证错误，不管多少个错误都以map形式返回
 * 				502：拦截器拦截到用户token出错
 * 				555：异常抛出信息
 *
 */
public class BMoocJSONResult {
    // 响应业务状态, 响应消息,响应中的数据
    private Integer status;
    private String msg;
    private Object data;
    private String ok;	// 不使用
    //构造函数：1.空构造器  2.响应业务状态, 响应消息,响应中的数据
               3.如果只有数据，那么肯定能调用，状态200+ok
    public BMoocJSONResult() {}
    public BMoocJSONResult(Integer status, String msg, Object data) {
        this.status = status;
        this.msg = msg;
        this.data = data;
    }
    public BMoocJSONResult(Object data) {
        this.status = 200;
        this.msg = "OK";
        this.data = data;
    }
    //判断状态是否ok
    public Boolean isOK() {
        return this.status == 200;
    }
    //构造函数：get+set函数
    public Integer getStatus() {
        return status;
    }
    public void setStatus(Integer status) {
        this.status = status;
    }
    public String getMsg() {
        return msg;
    }
    public void setMsg(String msg) {
        this.msg = msg;
    }
    public Object getData() {
        return data;
    }
    public void setData(Object data) {
        this.data = data;
    }
    public String getOk() {
        return ok;
    }
    public void setOk(String ok) {
        this.ok = ok;
    }

    public static BMoocJSONResult build(Integer status, String msg, Object data) {
        return new BMoocJSONResult(status, msg, data);
    }

    public static BMoocJSONResult ok(Object data) {
        return new BMoocJSONResult(data);
    }

    public static BMoocJSONResult ok() {
        return new BMoocJSONResult(null);
    }
    //500：表示错误，错误信息在msg字段中
    public static BMoocJSONResult errorMsg(String msg) {
        return new BMoocJSONResult(500, msg, null);
    }
    //501：bean验证错误，不管多少个错误都以map形式返回
    public static BMoocJSONResult errorMap(Object data) {
        return new BMoocJSONResult(501, "error", data);
    }
    //502：拦截器拦截到用户token出错
    public static BMoocJSONResult errorTokenMsg(String msg) {
        return new BMoocJSONResult(502, msg, null);
    }
    //555：异常抛出信息
    public static BMoocJSONResult errorException(String msg) {
        return new BMoocJSONResult(555, msg, null);
    }
}

1.2 对字符串进行md5加密

package com.bmooc.utils;
import org.apache.commons.codec.binary.Base64;
import java.security.MessageDigest;
/**
 * @Description: 对字符串进行md5加密
 */
public class MD5Utils {
    public static String getMD5Str(String strValue) throws Exception {
        //MessageDigest.getInstance:返回实现"MD5"的MessageIgigest对象。
        MessageDigest md5 = MessageDigest.getInstance("MD5");
        //这里传进来的是被md5计算过的散列值
        String newstr = Base64.encodeBase64String(md5.digest(strValue.getBytes()));
        return newstr;
    }

    public static void main(String[] args) {
        try {
            String md5 = getMD5Str("bmooc");
            System.out.println(md5);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

1.3 JSON和对象的互换

  Jackson处理一般的JavaBean和Json之间的转换只要使用ObjectMapper对象的readValue(反序列化JSON)和 writeValueAsString(序列化成字符串)。
    但是对于复杂类型Collection如 List<YourBean>，需要先反序列化复杂类型为泛型的Collection Type。
    如果是ArrayList<YourBean>那么使用ObjectMappergetTypeFactory().constructParametricType(
                                                                    collectionClass泛型的Collection,elementClasses);
    如果是HashMap<String,YourBean>那么ObjectMappergetTypeFactory().constructParametricType(HashMap.class, String.class,YourBean.class);

package com.bmooc.utils;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
/**
 * @Description: 自定义响应结构, 转换类
 */
public class JSonUtils {
    // 定义jackson对象
    private static final ObjectMapper MAPPER = new ObjectMapper();
    /**
     * 将对象转换成json字符串。
     */
    //Jackson处理一般的JavaBean和Json之间的转换只要使用ObjectMapper对象的readValue(反序列化JSON)和
    //                                                             writeValueAsString(序列化成字符串)。
    // 要转换复杂类型Collection如 List<YourBean>，就需要先反序列化复杂类型为泛型的Collection Type。
    // 如果是ArrayList<YourBean>那么使用ObjectMapper的getTypeFactory().constructParametricType(
    //                                                            collectionClass泛型的Collection,elementClasses);
    //如果是HashMap<String,YourBean>那么ObjectMapper的getTypeFactory().constructParametricType(HashMap.class,
    //                                                                           String.class, YourBean.class);

    public static String objectToJson(Object data) {
        try {
            String string = MAPPER.writeValueAsString(data);
            return string;
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
        return null;
    }
    /**
     * 将json结果集转化为对象
     */
    public static <T> T jsonToPojo(String jsonData, Class<T> beanType) {
        try {
            T t = MAPPER.readValue(jsonData, beanType);
            return t;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
    /**
     * 将json数据转换成pojo对象list
     *  method for constructing JavaType that represents a parameterized type.
     *  List<Set<Integer>>:
     *         JavaType inner = TypeFactory.constructParametricType(Set.class, Set.class, Integer.class);
     *         return TypeFactory.constructParametricType(ArrayList.class, List.class, inner);
     * ArrayList<Integer>: TypeFactory.constructParametricType(ArrayList.class, List.class, Integer.class);
     */

    public static <T> List<T> jsonToList(String jsonData, Class<T> beanType) {
        //反序列化复杂类型为泛型的Collection Type。
        JavaType javaType = MAPPER.getTypeFactory().constructParametricType(List.class, beanType);
        //
        try {
            List<T> list = MAPPER.readValue(jsonData, javaType);
            return list;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

}