SSM编写http接口返回JSON格式数据

最新推荐文章于 2024-05-27 19:59:50 发布

wh8_2011

最新推荐文章于 2024-05-27 19:59:50 发布

阅读量2.9k

点赞数

分类专栏： java

java 专栏收录该内容

27 篇文章 0 订阅

订阅专栏

由于前后端数据分离的强烈需要,现在越来越需要接口化的开发,特别是服务器端的开发和移动端后台的开发,前后端的数据交互自然不能使用之前直接传数据的方式,于是JSON便成了最佳的选择,JSON的底层是HashMap,键值对的方式可以生成或解析JavaBean,既能满足要求,又不失开发效率.下面开发一个简单的获取某个id数据的接口,给访问的前端返回JSON数据.

代码:

一.获取数据库中的数据

#数据模型层

 
   [java]  
   view plaincopy
package com.east.entity;  
  
import java.io.Serializable;  
import java.sql.Timestamp;  
  
public class Inform implements Serializable {  
    private Integer info_id;  
    private String  info_title;  
    private String  info_content;  
    private Timestamp info_time;  
    public Integer getInfo_id() {  
        return info_id;  
    }  
    public void setInfo_id(Integer info_id) {  
        this.info_id = info_id;  
    }  
    public String getInfo_title() {  
        return info_title;  
    }  
    public void setInfo_title(String info_title) {  
        this.info_title = info_title;  
    }  
    public String getInfo_content() {  
        return info_content;  
    }  
    public void setInfo_content(String info_content) {  
        this.info_content = info_content;  
    }  
    public Timestamp getInfo_time() {  
        return info_time;  
    }  
    public void setInfo_time(Timestamp info_time) {  
        this.info_time = info_time;  
    }  
    @Override  
    public String toString() {  
        return "Inform [info_id=" + info_id + ", info_title=" + info_title + ", info_content=" + info_content  
                + ", info_time=" + info_time + "]";  
    }  
      
}  

#数据访问层

 
   [java]  
   view plaincopy
package com.east.dao;  
  
import java.util.List;  
  
import org.apache.ibatis.annotations.Delete;  
import org.apache.ibatis.annotations.Insert;  
import org.apache.ibatis.annotations.Options;  
import org.apache.ibatis.annotations.Param;  
import org.apache.ibatis.annotations.Select;  
  
import com.east.entity.Inform;  
  
public interface InformDao {  
      
    /* 
     * 查询某个公告的信息 
     */  
    @Select("select * from inform where info_id = #{info_id}")  
    Inform findById(Integer info_id);  
}  

#业务逻辑层

 
   [java]  
   view plaincopy
package com.east.biz;  
  
import org.springframework.beans.factory.annotation.Autowired;  
import org.springframework.stereotype.Service;  
import org.springframework.transaction.annotation.Isolation;  
import org.springframework.transaction.annotation.Propagation;  
import org.springframework.transaction.annotation.Transactional;  
  
import com.east.dao.InformDao;  
import com.east.entity.Inform;  
  
@Transactional(propagation=Propagation.REQUIRED,isolation=Isolation.DEFAULT)  
@Service("informBiz")  
public class InformBiz {  
    /* 
     * 自动注入InformDao 
     */  
    @Autowired  
    private InformDao informDao;  
      
    public Inform findById(Integer info_id){  
        return informDao.findById(info_id);  
    }  
}  

二.JSON操作相关的对象类

 
   [java]  
   view plaincopy
package com.east.util;  
  
import java.util.Date;  
  
/* 
 * 建立AbstractJSON(JSON数据的响应基类 ) 
 */  
public class AbstractJSON {  
    private String code;                            //响应状态码   
    private String msg;                             //响应状态描述    
    private Long time = new Date().getTime();       //时间戳    
  
    public String getCode() {  
        return code;  
    }  
  
    public void setCode(String code) {  
        this.code = code;  
    }  
  
    public String getMsg() {  
        return msg;  
    }  
  
    public void setMsg(String msg) {  
        this.msg = msg;  
    }  
  
    public Long getTime() {  
        return time;  
    }  
  
    public void setTime(Long time) {  
        this.time = time;  
    }  
  
    public void setContent(String code, String msg) {  
        this.code = code;  
        this.msg = msg;  
    }  
  
    public void setStatusObject(StatusObject statusObject) {  
        this.code = statusObject.getCode();  
        this.msg = statusObject.getMsg();  
    }  
}  

 
   [java]  
   view plaincopy
package com.east.util;  
  
import java.io.FileReader;  
import java.io.FileWriter;  
import java.io.IOException;  
import java.io.StringWriter;  
  
import com.fasterxml.jackson.core.JsonFactory;  
import com.fasterxml.jackson.core.JsonGenerator;  
import com.fasterxml.jackson.core.JsonParseException;  
import com.fasterxml.jackson.databind.JsonMappingException;  
import com.fasterxml.jackson.databind.ObjectMapper;  
  
public class JsonWriter {  
    private static ObjectMapper om = new ObjectMapper();  
    private static JsonFactory jf = new JsonFactory();  
  
    public static <T> Object fromJson(String jsonAsString, Class<T> pojoClass) {  
        try {  
            return om.readValue(jsonAsString, pojoClass);  
        } catch (JsonParseException e) {  
            throw new IllegalStateException(e.getMessage(), e);  
        } catch (JsonMappingException e) {  
            throw new IllegalStateException(e.getMessage(), e);  
        } catch (IOException e) {  
            throw new IllegalStateException(e.getMessage(), e);  
        }  
    }  
  
    public static <T> Object fromJson(FileReader fr, Class<T> pojoClass) {  
        try {  
            return om.readValue(fr, pojoClass);  
        } catch (JsonParseException e) {  
            throw new IllegalStateException(e.getMessage(), e);  
        } catch (JsonMappingException e) {  
            throw new IllegalStateException(e.getMessage(), e);  
        } catch (IOException e) {  
            throw new IllegalStateException(e.getMessage(), e);  
        }  
    }  
  
    public static String toJson(Object pojo, boolean prettyPrint) {  
        try {  
            StringWriter sw = new StringWriter();  
            JsonGenerator jg = jf.createGenerator(sw);  
  
            if (prettyPrint) {  
                jg.useDefaultPrettyPrinter();  
            }  
            om.writeValue(jg, pojo);  
            return sw.toString();  
        } catch (JsonParseException e) {  
            throw new IllegalStateException(e.getMessage(), e);  
        } catch (JsonMappingException e) {  
            throw new IllegalStateException(e.getMessage(), e);  
        } catch (IOException e) {  
            throw new IllegalStateException(e.getMessage(), e);  
        }  
    }  
  
    public static void toJson(Object pojo, FileWriter fw, boolean prettyPrint) {  
        try {  
            JsonGenerator jg = jf.createGenerator(fw);  
            if (prettyPrint) {  
                jg.useDefaultPrettyPrinter();  
            }  
            om.writeValue(jg, pojo);  
        } catch (JsonParseException e) {  
            throw new IllegalStateException(e.getMessage(), e);  
        } catch (JsonMappingException e) {  
            throw new IllegalStateException(e.getMessage(), e);  
        } catch (IOException e) {  
            throw new IllegalStateException(e.getMessage(), e);  
        }  
    }  
  
    public static String toJson(Object pojo) {  
        return toJson(pojo, false);  
    }  
  
}  

 
   [java]  
   view plaincopy
package com.east.util;  
  
import java.util.List;  
  
/* 
 * 建立JSON数组类ListObject 
 */  
public class ListObject extends AbstractJSON {  
  
    private List<?> items;                       // 列表对象  
  
    public List<?> getItems() {  
        return items;  
    }  
  
    public void setItems(List<?> items) {  
        this.items = items;  
    }  
      
}  

 
   [java]  
   view plaincopy
package com.east.util;  
  
import com.fasterxml.jackson.databind.ObjectMapper;  
  
/* 
 * JsonUtils生成json数据和解析json数据 
 */  
public class JsonUtils {  
    static ObjectMapper objectMapper;  
  
    /* 
     * 解析json 
     */  
    public static <T> T fromJson(String content, Class<T> valueType) {  
        if (objectMapper == null) {  
            objectMapper = new ObjectMapper();  
        }  
        try {  
            return objectMapper.readValue(content, valueType);  
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
        return null;  
    }  
  
    /* 
     * 生成json 
     */  
    public static String toJson(Object object) {  
        if (objectMapper == null) {  
            objectMapper = new ObjectMapper();  
        }  
        try {  
            return objectMapper.writeValueAsString(object);  
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
        return null;  
    }  
}  

 
   [java]  
   view plaincopy
package com.east.util;  
  
/* 
 * 建立JSON对象类SingleObject 
 */  
public class SingleObject extends AbstractJSON {  
    private Object object;  
  
    public Object getObject() {  
        return object;  
    }  
  
    public void setObject(Object object) {  
        this.object = object;  
    }   
      
}  

 
   [java]  
   view plaincopy
package com.east.util;  
  
/* 
 * 定义状态码 
 */  
public class StatusCode {  
  
    public static String CODE_SUCCESS = "ok";          //访问成功   
  
    public static String CODE_ERROR = "0001";          //访问错误   
  
    public static String CODE_ERROR_PARAMETER = "0002";//参数错误  
  
    public static String CODE_ERROR_PROGRAM = "0003";  //程序异常  
  
    public static String CODE_ERROR_NO_LOGIN_OR_TIMEOUT = "0004";  //未登录或登录超时,请重新登录   
  
    public static String CODE_ERROR_EXIST_OPERATION = "0005";      //已操作  
  
}  

 
   [java]  
   view plaincopy
package com.east.util;  
  
import java.io.IOException;  
  
import javax.servlet.http.HttpServletResponse;  
  
/* 
 * 响应处理 
 */  
public class ResponseUtils {  
  
    /* 
     * 返回json串 
     */  
    public static void renderJson(HttpServletResponse response, String text) {  
        // System.out.print(text);  
        render(response, "text/plain;charset=UTF-8", text);  
    }  
  
    /* 
     * 返回文本 
     */  
    public static void renderText(HttpServletResponse response, String text) {  
        render(response, "text/plain;charset=UTF-8", text);  
    }  
  
    /* 
     * 发送内容,使用UTF-8编码 
     */  
    public static void render(HttpServletResponse response, String contentType, String text) {  
        response.setContentType(contentType);  
        response.setCharacterEncoding("utf-8");  
        response.setHeader("Pragma", "No-cache");  
        response.setHeader("Cache-Control", "no-cache");  
        response.setDateHeader("Expires", 0);  
        try {  
            response.getWriter().write(text);  
        } catch (IOException e) {  
        }  
    }  
      
    /* 
     * 页面异步回调返回Json 
     */  
    public static void outputJson(HttpServletResponse response, Object obj) {  
        String s = JsonWriter.toJson(obj, false);  
        response.setContentType("text/plain;charset=UTF-8");  
        response.setHeader("Pragma", "No-cache");  
        response.setHeader("Cache-Control", "no-cache");  
        response.setDateHeader("Expires", 0);  
        try {  
            response.getWriter().write(s);  
        } catch (IOException e) {  
            e.printStackTrace();  
        }  
    }  
}  

三.控制层(前端请求的路径)

 
   [java]  
   view plaincopy
package com.east.action;  
  
import java.util.ArrayList;  
import java.util.List;  
  
import javax.servlet.http.HttpServletRequest;  
import javax.servlet.http.HttpServletResponse;  
  
import org.springframework.beans.factory.annotation.Autowired;  
import org.springframework.beans.factory.annotation.Qualifier;  
import org.springframework.stereotype.Controller;  
import org.springframework.web.bind.annotation.RequestMapping;  
  
import com.east.biz.InformBiz;  
import com.east.entity.Inform;  
import com.east.util.JsonUtils;  
import com.east.util.ListObject;  
import com.east.util.ResponseUtils;  
import com.east.util.StatusCode;  
  
/* 
 * 处理用户请求的控制器 
 */  
@Controller  
public class InformAction {  
    // 自动注入UserService  
    @Autowired  
    @Qualifier("informBiz")  
    private InformBiz informBiz;  
  
    /* 
     * 获取指定id的公告 
     */  
    @RequestMapping(value = "/findById")  
    public void findById(String info_id, HttpServletRequest request, HttpServletResponse response) {  
        Integer id = Integer.parseInt(info_id);  
        Inform inform = informBiz.findById(id);  
        List<Inform> list = new ArrayList<Inform>();  
        list.add(inform);  
        ListObject listObject = new ListObject();  
        listObject.setItems(list);  
        listObject.setCode(StatusCode.CODE_SUCCESS);  
        listObject.setMsg("访问成功");  
        ResponseUtils.renderJson(response, JsonUtils.toJson(listObject));  
    }  
}  

四.到此,接口开发圆满完成,看看效果

接口的链接为:http://localhost:8098/InterfaceTest/findById?info_id=1

wh8_2011

关注

0
点赞
踩
10

收藏

觉得还不错? 一键收藏
1
评论
SSM编写http接口返回JSON格式数据

由于前后端数据分离的强烈需要,现在越来越需要接口化的开发,特别是服务器端的开发和移动端后台的开发,前后端的数据交互自然不能使用之前直接传数据的方式,于是JSON便成了最佳的选择,JSON的底层是HashMap,键值对的方式可以生成或解析JavaBean,既能满足要求,又不失开发效率.下面开发一个简单的获取某个id数据的接口,给访问的前端返回JSON数据.代码:一.获取数据库中的数据#数据模型层[j...
复制链接

扫一扫

专栏目录