精华内容
下载资源
问答
  • java后端返回json给前端

    热门讨论 2013-03-12 10:02:20
    java后端返回json给前端,包含对象JsonObject,JsonConfig,JsonArray.
  • 本篇文章主要介绍了JAVA实现JSON后端向前端传递数据,这里整理了详细的代码,具有一定的参考价值,有需要的小伙伴可以参考下。
  • 主要介绍了Java 实现Redis存储复杂json格式数据返回给前端操作,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 面对当前多种的业务需求和杂乱无章的数据堆放,Java后台处理变得尤为重要。对于信息系统开发而言,归根到底是对数据的分类与处理。通过从服务器获取数据,客户出需求,形成怎样的表格,多样化的静态图和动态图,...

    背景分析:
    面对当前多种的业务需求和杂乱无章的数据堆放,Java后台处理变得尤为重要。对于信息系统开发而言,归根到底是对数据的分类与处理。通过从服务器获取数据,客户给出需求,形成怎样的表格,多样化的静态图和动态图,各种各样资源文件,这些需求都不是简单的从数据库中取出来就可以直接使用的,往往需要进行对应的算法归类,类别划分等。对于复杂的图标,借助开源的前段框架或者相应的画图插件即可完成,只需要直接调用即可。
    **问题导入:**借助CSDN为例子进行知识探讨,仅进行学习与技术探讨,如有侵权,请及时联系 QQ邮箱:1306131289@qq.com
    在这里插入图片描述
    通过简单的分析,上述网页的1,2,3这三个部分肯定不是来源于一个数据库,他们的格式,数据长短也大相径庭。但是它们有一个相同点,需要同时获取数据到本页面。从后台角度而言,用最简单的方式解决就是它们具有相同的接口,通过网址链接请求,再从服务器数据库中获取相应的数据,进行处理,整合在一个json或者其它传递格式返回到当前页面中来。
    后台具体思路:
    1.依据需求和接口文档,从数据库获取原数据在后台存储起来。其中需要用到
    ①从服务器获取json数据
    ②json数据与String,ArrayList等数据格式之间的转换
    2.分析需求,将数据转存为hashmap或者arraylist方便一起传输。其中注意需要进行算法处理时,对下标,对应名称要仔细检查。
    3.组合为一个字符串或者其它格式传递给前端。(每一个模块应有对应的名称,前端好直接获取处理)
    代码实例:
    1.从数据库连接路径获取数据(实测有用干货)

    /**
    	 * json数据转为字符串
    	 * @param url1  获取json数据的URL地址
    	 * @return messageString String类型的json字符串
    	 */
    	public String getHttpResult(String url1) {
    		String messageString = null;
    		try {
    			URL url = new URL(url1);
    			// 打开连接
    			HttpURLConnection urlConnection = (HttpURLConnection) url
    					.openConnection();
    			System.out.println(urlConnection);
    			urlConnection.setConnectTimeout(8000);//连接超时
    			urlConnection.setReadTimeout(8000);//读操作超时
    			
    			if (200 == urlConnection.getResponseCode()) {
    				// 得到输入流
    				InputStream is = urlConnection.getInputStream();
    				ByteArrayOutputStream baos = new ByteArrayOutputStream();
    				byte[] buffer = new byte[1024];
    				int len = 0;
    				while (-1 != (len = is.read(buffer))) {
    					baos.write(buffer, 0, len);
    					baos.flush();
    				}
    				// baos.toString("utf-8");
    				//System.out.println("获取数据" + baos.toString("utf-8"));
    				messageString = baos.toString("utf-8");
    				baos.close();
    			}
    		} catch (IOException e) {
    			e.printStackTrace();
    		}
    
    		return messageString;
    
    	}
    

    2.传递参数存储框架搭建
    分析:对于要传递四个模块的数据使用map存储方式用K,V将每一个内容和模块对应。

     //总仓库
    static HashMap<String, Map<Integer,Map<String, String>>>result = new HashMap<String,  Map<Integer,Map<String, String>>>();
    //分仓库
    Map<Integer,Map<String, String>> TMmap = new LinkedHashMap<Integer,Map<String, String>>();
    //仓库子内容
    Map<String, String> TMmap1 = new LinkedHashMap<String, String>();
    

    3.对封装好的数据进行类型转换进行传输(灵活使用gson)

    //其中BaseResponse类需要自己创建,依据需求设置类属性
    BaseResponse<HashMap<String, Map<Integer,Map<String, String>>>> mes = new BaseResponse<HashMap<String,Map<Integer,Map<String, String>>>>();
    mes.setCode(1);
    mes.setData(result);
    mes.setMsg("ok");
         
    Gson gson = new Gson();
    String json = gson.toJson(mes);
    return json;
    

    4.接口测试,数据如果有差异,进行适当修改即可。

    展开全文
  • 文章目录使用jackson类库使用springmvc的@RestController注解使用fastjson实现 ...-- json --> <dependency> <groupId>com.fasterxml.jackson.core</groupId> <arti...

    使用jackson类库

    1.引jar包

      <!-- json -->
        <dependency>
          <groupId>com.fasterxml.jackson.core</groupId>
          <artifactId>jackson-annotations</artifactId>
          <version>${jackson.version}</version>
        </dependency>
    
        <dependency>
          <groupId>com.fasterxml.jackson.core</groupId>
          <artifactId>jackson-core</artifactId>
          <version>${jackson.version}</version>
        </dependency>
    
        <dependency>
          <groupId>com.fasterxml.jackson.core</groupId>
          <artifactId>jackson-databind</artifactId>
          <version>${jackson.version}</version>
        </dependency>
    

    2.写一个将object转json,并通过response对象将json格式的数据返回给前端的方法

    public class BaseController{
    	protected static JsonFactory factory = mapper.getJsonFactory();
    	/**将对象转成json输出**/
    	protected void writeJSON(Object obj) throws IOException {
    		response.setContentType("text/html;charset=utf-8");
    		JsonGenerator responseJsonGenerator = factory.createJsonGenerator(response.getOutputStream(), JsonEncoding.UTF8);
    		responseJsonGenerator.writeObject(obj);
    	}
    

    3.后端调用与前端的接收

    public class Result implements Serializable{
      private static final long serialVersionUID = 2267751680865696851L;
    	/**是否成功**/
    	private Boolean success = false ;
    	/**返回消息**/
    	private String message;
    	/**返回数据**/
    	private Object data;
    	//省略getter和setter方法
    }
    
    @Controller
    @RequestMapping("/sysuser")
    public class SysUserController extends BaseController{
    @RequestMapping(value = "/login", method = { RequestMethod.POST, RequestMethod.GET })
    	public void login() throws IOException{
    Result result=new Result();
    result.setMessage("登录成功");
    		result.setSuccess(true);
    		super.writeJSON(result);
    }
    }
    
      submitHandler:function(form){
                $.ajax({
                    dataType : "json",
                    url : "sysuser/login.action",
                    type : "post",
                    data : $("#login_form").serialize(),
                    success : function(data) {
                        $.alert(data.message);
                        if(data.success){
                        //--------------------------------------------data.success
                            window.location.href = 'page/main.action';
                        }
                    },
                    error : function (e){
                        var d = e.responseJSON;
                        if(d){
                            $.alert(d.message);
                        }
                    }
                });
                return false; //阻止form提交
            }
    

    使用springmvc的@RestController注解

    public class Result {
        private static final int SUCCESS = 200;
        private static final int FAILED = 500;
        private int code;
        private String message;
        private Object data;
         public Result(int code, String message, Object data) {
            this.code = code;
            this.message = message;
            this.data = data;
        }
       public static Result ok(Object data) {
            return new Result(SUCCESS, "success", data);
        }
    
    @RestController
    @RequestMapping("/order")
    public class SysOrderController {
    @RequestMapping("/login")
    public Result login() {
       Result result=new Result();
       result.setMessage("登录成功");
       result.setSuccess(true);
       Map<String,String>map=new hashMap<>();
       map.put("content","i am content")
            return Result.ok(map);
        }
    }
    /**
    *@RestController是@ResponseBody和@Controller的组合注解
    @Controller是用来响应页面的,如果是string类型的方法,则springmvc会跳转到相应的页面(视图)
    @ResponseBody是用来响应数据的,如果是对象类型的方法,则springmvc会将结果对象转成json格式输出给前端
    本例中我使用的是@RestController注解,所以springmvc会将返回的对象Result自动转json返回给前端(底层默认是使用jsckson来实现数据格式转换的)
    */
    
    /**
    *public Result add(@RequestBody WegoUser user){}    @@RequestBody是将前端传来的json数据转对象。默认不用加(springmvc会自动完成数据的封装)
    */
    

    使用fastjson实现

    添加依赖:

      <dependency>
          <groupId>com.alibaba</groupId>
          <artifactId>fastjson</artifactId>
          <version>1.2.58</version>
        </dependency>
    
    @Controller
    @RequestMapping("/login")
    public class TestController {
        @RequestMapping("/test")
        public void test(HttpServletResponse response) throws IOException {
            SysUser sysUser=new SysUser();
            sysUser.setLoginPass("123456");
            sysUser.setLoginAccount("小明");
            System.out.println("dskfjdsfssdfdsfklkdfdsf");
            JSONObject jsonObject= (JSONObject) JSONObject.toJSON(sysUser);
            Map<String,String>map=new HashMap<>();
            map.put("phone","1223456");
            map.put("status","ok");
            jsonObject.put("info",map);
            response.setContentType("text/html;charset=utf-8");
            response.getWriter().write(jsonObject.toJSONString());
        }
    }
    //结果如下:
    //{"loginAccount":"小明","roles":[],"loginPass":"123456","info":{"phone":"1223456","status":"ok"}}
    
    展开全文
  • 主要介绍了JAVA后台转换成树结构数据返回给前端的实现方法,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • 一般来说web开发中,前台采用json数据提交后台,后台处理数据以后返回json数据给前台,前台解析json,显示数据。 总而言之,前后台直接交换的数据格式最常用的非json数据无疑了。 这里就总结一些json数据的前...

    后台返回json数据给前台和前台解析json数据(总结)

    一般来说web开发中,前台采用json数据提交给后台,后台处理数据以后返回json数据给前台,前台解析json,显示数据。
    总而言之,前后台直接交换的数据格式最常用的非json数据无疑了。
    这里就总结一些json数据的前后台处理方式。

    1.JSON数据

    JSON(JavaScript Object Notation, JS 对象简谱)

    是一种轻量级的数据交换格式,比xml更轻巧(由于 JSON 所使用的字符要比 XML 少得多,可以大大得节约传输数据所占用的带宽)。

    json是javascript原生格式,就是说在javascript中处理json数据,需要引用其他API或工具包。

    简洁和清晰的层次结构使得 JSON 成为理想的数据交换语言。 易于人阅读和编写,同时也易于机器解析和生成,并有效地提升网络传输效率。

    只需要记住!
    Json是一种文本字符串!被存储在responseText属性中,而读取json数据可以使用javascript的eval函数来解析json。

    2.json规则:

    在 JS 语言中,一切都是对象,对象是一个无序的 “键/值” 对集合
    因此,任何支持的类型都可以通过 JSON 来表示,例如字符串、数字、对象、数组等。但是对象和数组是比较特殊且常用的两种类型:
    • 对象表示为键值对.
    • 数据由逗号分隔.
    • 花括号{}保存对象.
    • 方括号[]保存数组.

    键/值对组合中的键名写在前面并用双引号 “” 包裹,使用冒号 : 分隔,然后紧接着值:

    {"firstName": "Json"}
    

    这很容易理解,等价于这条 JavaScript 语句:

    {firstName : "Json"}
    

    对象在 JS 中是使用花括号包裹 {} 起来的内容,数据结构为 {key1:value1, key2:value2, …} 的键值对结构。

    在面向对象的语言中,key 为对象的属性,value 为对应的值。

    键名可以使用整数和字符串来表示,值的类型可以是任意类型。

    数组在 JS 中是方括号 [] 包裹起来的内容,数据结构为 [“java”, “javascript”, “vb”, …] 的索引结构。

    在 JS 中,数组是一种比较特殊的数据类型,它也可以像对象那样使用键值对,但还是索引使用得多。同样,键名可以使用整数和字符串来表示,值的类型可以是任意类型。

    3.JSON 与 JS 对象的关系:

    很多人搞不清楚 JSON 和 Js 对象的关系,甚至连谁是谁都不清楚。其实,可以这么理解:
    JSON 是 JS 对象的字符串表示法,它使用文本表示一个 JS 对象的信息,本质是一个字符串
    如:

    var obj = {a: 'Hello', b: 'World'};    //这是一个对象,注意键名也是可以使用引号包裹的
    var json = '{"a": "Hello", "b": "World"}';  //这是一个 JSON 字符串,本质是一个字符串
    

    4.后台返回json数据

    一般来说,使用JsonObject来将Java类型数据转换成Json类型,首先要下载该库相关的jar包,下载地址如下:

    json-jar包下载

    JsonObject的使用:
    后台controller部分代码:

    JSONObject object = new JSONObject();  //创建Json对象
    object.put("username", "张三");         //设置Json对象的属性
    object.put("password", "123456");
    System.out.println(object.toString());  //调用toString方法将json对象转换成json字符串
    
    //把json数据返回给浏览器:
    PrintWriter out = cu.getWriterOut(response);
    out.print(object.toString());
    //或者
    response.getWriter().write(jsonObject.toString());
    
    

    5.在JavaScript代码中接收Json数据:

    假设result为浏览器得到的json数据,可以使用以下js代码可以将json对象转换为字符串。

    比如:

    通过$.get从后台获取了一段json串{“id”:“1”,“name”:“ww”},然后要拿到这里面的id和name值:

    注意!注意!注意!
    如果你直接这么写!

    $.get(url,
         function(data) {
           alert("ID:" + data.id + "\nName:" + data.name);
         });
    

    直接这样写的话,界面会alert提示undefined,因为没能正确解析返回的字符串。

    图示:
    在这里插入图片描述

    解决方案:

    1、 需要用eval()函数

    将返回的串转化成可用的strig串,eval(data),但是因为原串里面是以{}开始和结束的,会被认为是可执行方法,因此需要加上()包围起来,最终形成:

    var jsonobj= eval('(' + data + ')');  // 把JSON字符串解析为javascript对象
    

    然后再

    alert("ID:" + jsonobj.id + "\nName:" + jsonobj.name);
    

    各种正常的按key取值,就能正常显示了。

    2、获取的时候就直接表示返回的是json格式,用 . g e t J S O N 代 替 .getJSON代替 .getJSON.get,其他代码不变,也能正常获取。

    也可以直接获取json对象的属性,如下:console.log(result.username);

    前端js代码:

    $.ajax({
    url: url,
    type: "POST",
    data: parameters,
    dataType:"json",
    async: false,
    success: function(result){
    var newData = JSON.stringify(result);    //将json对象转换为字符串
    newData = eval("("+newData+")");   /解析json
    
    var annualDays = newData.annualDays;
    var entryDate = newData.entryDate;
    
    $("input[name='extendDataFormInfo.value(fd_shengyu_nianjia)']").val(annualDays);
    $("input[name='extendDataFormInfo.value(fd_ruzhi_date)']").val(entryDate);
    
    }});
    
    

    ps: 注意注释中的代码,如果少了这一句,那么直接alert(result);得到的结果会是

    在这里插入图片描述

    所以在这里stringfy()的作用是用于从一个对象解析出字符串
    加上了var newData = JSON.stringify(result);这句,然后你再alert(newData);
    得到的就会是你想要的结果,如下:
    在这里插入图片描述

    另外:
    如果返回的json数据格式不是很规范的解决办法:

    判断后台返回的数据格式是否字符串,是则转,不是则不转?

      var $obj = (typeof data.content == 'string') ? JSON.parse(data.content):data.content
    

    总结:

    1. 前台发送请求,并且设置数据为json格式‘
        $.ajax({
        url:"selectByid.",
        datatype:'json',
        data:{id:id}, // 发送数据 
    
    1. 数据回调函数
    success:function(data){
    alert(data);
    var json = eval("("+data+")");//将json类型字符串转换为json对象
    alert("hjf"+json.name);
    
    1. 给对应的input赋值:
    $("#id").val(json.id),
    $("#name").val(json.name),
    $("#age").val(json.age);
    
    1. 后台代码:返回json数据
    response.getWriter().print(str);    //将数据返回前台ajax
    

    6.前端ajax接不到json解决?

    在前台:

    async:false,                //加上这个属性就好了
    

    7.返回的json字符串中有转义符解决?

    比如:

    "result":"{\"id\":\"60\",\"qid\":\"1\",\"bazi\":\"baiz\",\"shenxiao\":\"\",\"xingzuo\":\"\",\"wuge\":\"\",\"jianyi\":\"\",\}"
    

    这样我们我们使用JSON.parse(result) ,直接转化为json的话是会报错的。

    解决方法:
    我们先把转义符用正则表达式去掉,

       var string = result.replace("/\\","");
       var getDataArray = JSON.parse(string)
    

    这样就OK了,不过要注意有时候也是需要指定返回数据类型的
    dataType:“json”

    8.使用其他的json依赖包方式:

    引入阿里巴巴的json依赖包:

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

    模拟后台:

        String params="{\"channelCode\":\"bbb\",\"accountNo\":\"121300000932\",\"message\":\"字符信息解密成功\",\"status\":\"1\"}";
        JSONObject pa=JSONObject.parseObject(params);
        System.out.println(pa.getString("message"));
    

    结果:
    在这里插入图片描述

    或者:
    引入net.sf.json-lib依赖包:

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

    后台:

    String params="{\"channelCode\":\"ccy\",\"accountNo\":\"121300000932\",\"message\":\"字符信息解密成功\",\"status\":\"1\"}";
    JSONObject pa=JSONObject.fromObject(params);
    String accountNo=pa.getString("accountNo");
    System.out.println(accountNo);
    

    结果:
    在这里插入图片描述

    9.后台对象转换json数据返回给前台

    List集合转换成json代码:

      List list = new ArrayList();
      list.add( "first" );
      list.add( "second" );
      JSONArray jsonArray2 = JSONArray.fromObject( list );
    

    Map集合转换成json代码:

       Map map = new HashMap();
      map.put("name", "json");
      map.put("bool", Boolean.TRUE);
      map.put("int", new Integer(1));
      map.put("arr", new String[] { "a", "b" });
      map.put("func", "function(i){ return this.arr[i]; }");
      JSONObject json = JSONObject.fromObject(map);
    

    或者在项目中加入引入JSON-lib包,JSON-lib包同时依赖于以下的JAR包:
    下载地址

      1.commons-lang.jar
      2.commons-beanutils.jar
      3.commons-collections.jar
      4.commons-logging.jar 
      5.ezmorph.jar
      6.json-lib-2.2.2-jdk15.jar
    

    用法同上

      JSONObject jsonObject = JSONObject.fromObject(message);
      getResponse().getWriter().write(jsonObject.toString());
    

    当把数据转为json后,用如上的方法发送到客户端。前端就可以取得json数据了。(可以参考最下面的实例)

    10.后台返回数据给前台,json中文乱码解决方法

    在实际运用场景中,当前台发起请求后,我们需要从后台返回数据给前台,这时,如果返回的数据中包含中文,则经常会出现在后台查询出来都是好好,但是传输回去就莫名的乱码了,而且即使在 web.xml 中进行编码过滤了,但还是乱码。

    解决办法:
    只需要在 spring-mvc.xml 配置文件中配置一次就好,省去了我们重复写的麻烦,配置内容如下:

    <!--自定义消息转换器的编码,解决后台传输json回前台时,中文乱码问题-->
        <mvc:annotation-driven >
            <mvc:message-converters register-defaults="true">
                <bean class="org.springframework.http.converter.StringHttpMessageConverter" >
                    <property name = "supportedMediaTypes">
                        <list>
                            <value>application/json;charset=utf-8</value>
                            <value>text/html;charset=utf-8</value>
                            <!-- application 可以在任意 form 表单里面 enctype 属性默认找到 -->
                            <value>application/x-www-form-urlencoded</value>
                        </list>
                    </property>
                </bean>
                <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter" ></bean>
            </mvc:message-converters>
        </mvc:annotation-driven>
    

    加上这段配置,保存重新运行,再次访问,会发现,原先的中文乱码都已经正常显示了。

    方法二:在后台的方法映射添加:

    @RequestMapping(value="/getphone",produces = “text/plain;charset=utf-8”)

    11.Spring MVC返回json数据的方式

    1. 采用@ResponseBody注解

    @ResponseBody 注解的作用是:

    将controller的方法返回的对象通过适当的转换器转换为指定的格式之后,写入到response对象的body区,通常用来返回JSON数据或者是XML数据,需要注意的呢,在使用此注解之后不会再走试图处理器,而是直接将数据写入到输入流中,他的效果等同于通过response对象输出指定格式的数据。

    使用举例:
    在这里插入图片描述

    使用@ResponseBody 注解返回响应体 直接将返回值序列化json
    优点:不需要自己再处理

    再举例:

    RequestMapping("/login")
      @ResponseBody
      public User login(User user){
        return user;
      }
    

    使用@ResponseBody 注解返回响应体 直接将返回值序列化json。

    User字段:userName pwd,那么在前台接收到的数据为:’{“userName”:“xxx”,“pwd”:“xxx”}’,效果等同于如下代码:

    @RequestMapping("/login")
    public void login(User user, HttpServletResponse response){
       response.getWriter.write(JSONObject.fromObject(user).toString());
    }
    
    

    需要在springmvc的配置文件xml中添加:

    <mvc:annotation-driven/>  
    

    2. 采用工具类,进行json格式转换带回

    JSON-lib包是一个beans,collections,maps,java arrays 和XML和JSON互相转换的包。在本例中,我们将使用JSONObject类创建JSONObject对象,然后我们打印这些对象的值。为了使用JSONObject对象,我们要引入"net.sf.json"包。为了给对象添加元素,我们要使用put()方法。

    要使程序可以运行必须引入JSON-lib包,JSON-lib包同时依赖于以下的JAR包:

    commons-lang.jar
    commons-beanutils.jar
    commons-collections.jar
    commons-logging.jar 
    ezmorph.jar
    json-lib-2.2.2-jdk15.jar
    

    效果:在这里插入图片描述

    工具类:
    ResponseUtil.java

    package com.zout.utils;
    import java.io.PrintWriter;
    import javax.servlet.http.HttpServletResponse;
    import net.sf.json.JSONArray;
    import net.sf.json.JSONObject;
    
    /**
     *@class_name:ResponseUtil  
     *@param: EasyUi-响应工具类
     *@return: 返回字符串格式数据、result是JSONObject对象(json对象)
     *@author:Zoutao
     *@createtime:2018年3月8日
     */
    public class ResponseUtil {
    	public static void write(HttpServletResponse response, Object result)
    			throws Exception {
    		response.setContentType("text/html;charset=utf-8");
    		response.addHeader("Access-Control-Allow-Origin", "*");
    		PrintWriter out = response.getWriter();
    		out.println(result.toString());
    		System.out.println("带回的json字符串为:"+result.toString()+"类型为:"+result.getClass().getName());
    		out.flush();
    		out.close();
    	}
    	
    	public static void main(String[] args) throws Exception {
    		/*在web运用控制层中调用如下:*/
    		JSONObject result = new JSONObject(); //创建json对象
    		JSONArray jsonArray = JSONArray.fromObject("name:zhangsan"); //字符串转为json数组
    		result.put("rows", jsonArray);  //放入json数组中,并起个名字
    		HttpServletResponse response = null; //jsp的response对象
    		ResponseUtil.write(response, result); //result写入response带回前台,jsp按名字拿取。
    	}
    }
    
    

    后台具体调用:

    	JSONObject result = new JSONObject();
    			if (resultTotal > 0) {		//处理结果
    				System.out.println("操作成功。");
    				result.put("success",true)
    				result.put("message","操作成功"); //消息语句
    			} else {
    				System.out.println("操作失败。");
    				result.put("success", false);			
    				result.put("message","操作失败");
    			}
    			ResponseUtil.write(response,result); //带回字符串+状态码
    			return null;
    

    图:
    在这里插入图片描述

    后台已经通过工具类封装为json字符串了,使用response带回需要的数据,使用result带回状态字符串或状态码。

    前台:
    这是当成返回一个json字符串,然后直接采取字符串截取的方式,取出消息语句message等消息。
    在这里插入图片描述

    这是另外一种写法:就是解析传回来的json字符串我js的对象,然后按照key/value的取值。

      function (data) {
              var data=eval("("+data+")");  //解析json
             //alert(data.message)
                $.messager.show({
                  title:'消息',
                  msg:data.message,  //按key取值
                  timeout:1000,
                  showType:'slide',
                  height:120,
                 width:200
         });
     });
    

    推荐这种方式。
    效果图:
    在这里插入图片描述


    以上都是后台返回json数据给前台和前台解析json数据的一些总结,还有json数据的封装,工具类的使用等等,东西有点复杂有点多,挑选自己需要的地方即可。

    另外的一些常用的web开发json:

    Json–Java数据类型对照表(映射)表

    展开全文
  • 以下是数据访问对象接口文件 StudentDAO.java 的内容: package com . tutorialspoint ; import java . util . List ; import javax . sql . DataSource ; public interface StudentDAO { /** ...

    Spring简介:

    Spring 框架是一个分层架构,由 7 个定义良好的模块组成。Spring 模块构建在核心容器之上,核心容器定义了创建、配置和管理 bean 的方式,如图 1 所示。

    图 1. Spring 框架的 7 个模块

    在这里插入图片描述

    Spring 框架图示

      组成 Spring 框架的每个模块(或组件)都可以单独存在,或者与其他一个或多个模块联合实现。每个模块的功能如下:

    核心容器:核心容器提供 Spring 框架的基本功能。核心容器的主要组件是 BeanFactory,它是工厂模式的实现。BeanFactory 使用控制反转 (IOC) 模式将应用程序的配置和依赖性规范与实际的应用程序代码分开。
    Spring 上下文:Spring 上下文是一个配置文件,向 Spring 框架提供上下文信息。Spring 上下文包括企业服务,例如 JNDI、EJB、电子邮件、国际化、校验和调度功能。 Spring
    AOP:通过配置管理特性,Spring AOP 模块直接将面向方面的编程功能集成到了 Spring 框架中。所以,可以很容易地使 Spring 框架管理的任何对象支持 AOP。Spring AOP 模块为基于 Spring 的应用程序中的对象提供了事务管理服务。通过使用 Spring AOP,不用依赖 EJB 组件,就可以将声明性事务管理集成到应用程序中。
    Spring DAO:JDBC DAO 抽象层提供了有意义的异常层次结构,可用该结构来管理异常处理和不同数据库供应商抛出的错误消息。异常层次结构简化了错误处理,并且极大地降低了需要编写的异常代码数量(例如打开和关闭连接)。Spring DAO 的面向 JDBC 的异常遵从通用的 DAO 异常层次结构。
    Spring ORM:Spring 框架插入了若干个 ORM 框架,从而提供了 ORM 的对象关系工具,其中包括 JDO、Hibernate 和 iBatis SQL Map。所有这些都遵从 Spring 的通用事务和 DAO 异常层次结构。
    Spring Web 模块:Web 上下文模块建立在应用程序上下文模块之上,为基于 Web 的应用程序提供了上下文。所以,Spring 框架支持与 Jakarta Struts 的集成。Web 模块还简化了处理多部分请求以及将请求参数绑定到域对象的工作。
    Spring MVC 框架:MVC 框架是一个全功能的构建 Web 应用程序的 MVC 实现。通过策略接口,MVC 框架变成为高度可配置的,MVC 容纳了大量视图技术,其中包括 JSP、Velocity、Tiles、iText 和 POI。
      Spring 框架的功能可以用在任何 J2EE 服务器中,大多数功能也适用于不受管理的环境。Spring 的核心要点是:支持不绑定到特定 J2EE 服务的可重用业务和数据访问对象。毫无疑问,这样的对象可以在不同 J2EE 环境 (Web 或 EJB)、独立应用程序、测试环境之间重用。

    Servlet简介:

    Java Servlet 是运行在 Web 服务器或应用服务器上的程序,它是作为来自 Web 浏览器或其他 HTTP 客户端的请求和 HTTP 服务器上的数据库或应用程序之间的中间层。

    使用 Servlet,您可以收集来自网页表单的用户输入,呈现来自数据库或者其他源的记录,还可以动态创建网页。

    Java Servlet 通常情况下与使用 CGI(Common Gateway Interface,公共网关接口)实现的程序可以达到异曲同工的效果。但是相比于 CGI,Servlet 有以下几点优势:

    性能明显更好。
    Servlet 在 Web 服务器的地址空间内执行。这样它就没有必要再创建一个单独的进程来处理每个客户端请求。
    Servlet 是独立于平台的,因为它们是用 Java 编写的。
    服务器上的 Java 安全管理器执行了一系列限制,以保护服务器计算机上的资源。因此,Servlet 是可信的。
    Java 类库的全部功能对 Servlet 来说都是可用的。它可以通过 sockets 和 RMI 机制与 applets、数据库或其他软件进行交互。

    下图显示了 Servlet 在 Web 应用程序中的位置。
    在这里插入图片描述

    一、Spring JDBC 读取数据库示例

    Spring JDBC 示例
    想要理解带有 jdbc 模板类的 Spring JDBC 框架的相关概念,让我们编写一个简单的示例,来实现下述 Student 表的所有 CRUD 操作。

    CREATE TABLE Student(
       ID   INT NOT NULL AUTO_INCREMENT,
       NAME VARCHAR(20) NOT NULL,
       AGE  INT NOT NULL,
       PRIMARY KEY (ID)
    );
    

    在继续之前,让我们适当地使用 Eclipse IDE 并按照如下所示的步骤创建一个 Spring 应用程序:

    步骤描述
    1创建一个名为 dbtest的项目,并在创建的项目中的 src 文件夹下创建包 com.tutorialspoint。
    2使用 Add External JARs 选项添加必需的 Spring 库,解释见 Spring Hello World Example 章节。
    3在项目中添加 Spring JDBC 指定的最新的库 mysql-connector-java.jar,org.springframework.jdbc.jar 和 org.springframework.transaction.jar。如果这些库不存在,你可以下载它们。
    4创建 DAO 接口 StudentDAO 并列出所有必需的方法。尽管这一步不是必需的而且你可以直接编写 StudentJDBCTemplate 类,但是作为一个好的实践,我们最好还是做这一步。
    5在 com.tutorialspoint 包下创建其他的必需的 Java 类 Student,StudentMapper,StudentJDBCTemplate 和 MainApp 。
    6确保你已经在 TEST 数据库中创建了 Student 表。并确保你的 MySQL 服务器运行正常,且你可以使用给出的用户名和密码读/写访问数据库。
    7在 src 文件夹下创建 Beans 配置文件 Beans.xml。
    8最后一步是创建所有的 Java 文件和 Bean 配置文件的内容并按照如下所示的方法运行应用程序。

    以下是数据访问对象接口文件 StudentDAO.java 的内容:

    package com.tutorialspoint;
    import java.util.List;
    import javax.sql.DataSource;
    public interface StudentDAO {
       /** 
        * This is the method to be used to initialize
        * database resources ie. connection.
        */
       public void setDataSource(DataSource ds);
       /** 
        * This is the method to be used to create
        * a record in the Student table.
        */
       public void create(String name, Integer age);
       /** 
        * This is the method to be used to list down
        * a record from the Student table corresponding
        * to a passed student id.
        */
       public Student getStudent(Integer id);
       /** 
        * This is the method to be used to list down
        * all the records from the Student table.
        */
       public List<Student> listStudents();
       /** 
        * This is the method to be used to delete
        * a record from the Student table corresponding
        * to a passed student id.
        */
       public void delete(Integer id);
       /** 
        * This is the method to be used to update
        * a record into the Student table.
        */
       public void update(Integer id, Integer age);
    }
    

    下面是 Student.java 文件的内容:

    package com.tutorialspoint;
    public class Student {
       private Integer age;
       private String name;
       private Integer id;
       public void setAge(Integer age) {
          this.age = age;
       }
       public Integer getAge() {
          return age;
       }
       public void setName(String name) {
          this.name = name;
       }
       public String getName() {
          return name;
       }
       public void setId(Integer id) {
          this.id = id;
       }
       public Integer getId() {
          return id;
       }
    }
    
    

    以下是 StudentMapper.java 文件的内容:

    package com.tutorialspoint;
    import java.sql.ResultSet;
    import java.sql.SQLException;
    import org.springframework.jdbc.core.RowMapper;
    public class StudentMapper implements RowMapper<Student> {
       public Student mapRow(ResultSet rs, int rowNum) throws SQLException {
          Student student = new Student();
          student.setId(rs.getInt("id"));
          student.setName(rs.getString("name"));
          student.setAge(rs.getInt("age"));
          return student;
       }
    }
    

    下面是为定义的 DAO 接口 StudentDAO 的实现类文件 StudentJDBCTemplate.java:

    
    package com.tutorialspoint;
    import java.util.List;
    import javax.sql.DataSource;
    import org.springframework.jdbc.core.JdbcTemplate;
    public class StudentJDBCTemplate implements StudentDAO {
       private DataSource dataSource;
       private JdbcTemplate jdbcTemplateObject; 
       public void setDataSource(DataSource dataSource) {
          this.dataSource = dataSource;
          this.jdbcTemplateObject = new JdbcTemplate(dataSource);
       }
       public void create(String name, Integer age) {
          String SQL = "insert into Student (name, age) values (?, ?)";     
          jdbcTemplateObject.update( SQL, name, age);
          System.out.println("Created Record Name = " + name + " Age = " + age);
          return;
       }
       public Student getStudent(Integer id) {
          String SQL = "select * from Student where id = ?";
          Student student = jdbcTemplateObject.queryForObject(SQL, 
                            new Object[]{id}, new StudentMapper());
          return student;
       }
       public List<Student> listStudents() {
          String SQL = "select * from Student";
          List <Student> students = jdbcTemplateObject.query(SQL, 
                                    new StudentMapper());
          return students;
       }
       public void delete(Integer id){
          String SQL = "delete from Student where id = ?";
          jdbcTemplateObject.update(SQL, id);
          System.out.println("Deleted Record with ID = " + id );
          return;
       }
       public void update(Integer id, Integer age){
          String SQL = "update Student set age = ? where id = ?";
          jdbcTemplateObject.update(SQL, age, id);
          System.out.println("Updated Record with ID = " + id );
          return;
       }
    }
    

    以下是 MainApp.java 文件的内容:

    
    package com.tutorialspoint;
    import java.util.List;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    import com.tutorialspoint.StudentJDBCTemplate;
    public class MainApp {
       public static void main(String[] args) {
          ApplicationContext context = 
                 new ClassPathXmlApplicationContext("Beans.xml");
          StudentJDBCTemplate studentJDBCTemplate = 
          (StudentJDBCTemplate)context.getBean("studentJDBCTemplate");    
          System.out.println("------Records Creation--------" );
          studentJDBCTemplate.create("Zara", 11);
          studentJDBCTemplate.create("Nuha", 2);
          studentJDBCTemplate.create("Ayan", 15);
          System.out.println("------Listing Multiple Records--------" );
          List<Student> students = studentJDBCTemplate.listStudents();
          for (Student record : students) {
             System.out.print("ID : " + record.getId() );
             System.out.print(", Name : " + record.getName() );
             System.out.println(", Age : " + record.getAge());
          }
          System.out.println("----Updating Record with ID = 2 -----" );
          studentJDBCTemplate.update(2, 20);
          System.out.println("----Listing Record with ID = 2 -----" );
          Student student = studentJDBCTemplate.getStudent(2);
          System.out.print("ID : " + student.getId() );
          System.out.print(", Name : " + student.getName() );
          System.out.println(", Age : " + student.getAge());      
       }
    }
    

    下述是配置文件 Beans.xml 的内容:

    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
        xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-3.0.xsd ">
    
       <!-- Initialization for data source -->
       <bean id="dataSource" 
          class="org.springframework.jdbc.datasource.DriverManagerDataSource">
          <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
          <property name="url" value="jdbc:mysql://localhost:3306/TEST"/>
          <property name="username" value="root"/>
          <property name="password" value="password"/>
       </bean>
    
       <!-- Definition for studentJDBCTemplate bean -->
       <bean id="studentJDBCTemplate" 
          class="com.tutorialspoint.StudentJDBCTemplate">
          <property name="dataSource"  ref="dataSource" />    
       </bean>
    
    </beans>
    

    当你完成创建源和 bean 配置文件后,运行应用程序。右键点击MainApp.java–>运行方式–>java应用程序(如下图所示):
    在这里插入图片描述
    如果你的应用程序一切运行顺利的话,将会输出如下所示的消息:

    ------Records Creation--------
    Created Record Name = Zara Age = 11
    Created Record Name = Nuha Age = 2
    Created Record Name = Ayan Age = 15
    ------Listing Multiple Records--------
    ID : 1, Name : Zara, Age : 11
    ID : 2, Name : Nuha, Age : 2
    ID : 3, Name : Ayan, Age : 15
    ----Updating Record with ID = 2 -----
    Updated Record with ID = 2
    ----Listing Record with ID = 2 -----
    ID : 2, Name : Nuha, Age : 20
    

    二、 Spring JDBC+Servlet 返回json数据

    在上面Spring JDBC的基础上加入servlet程序,提供web前端的访问接口(返回json数据)。
    导入以下json依赖包(到WebContent\WEB-INF\lib目录下):

    commons-logging-1.0.4.jar  
    commons-lang-2.3.jar  
    commons-collections-3.2.jar  
    commons-beanutils-1.7.0.jar  
    json-lib-2.2.1-jdk15.jar  
    

    1、在src目录下创建com.yfw包,在该包下创建DatabaseAccess类。
    在这里插入图片描述
    DatabaseAccess类程序如下:

    package com.yfw;
    
    import java.io.PrintWriter;
    import java.io.IOException;
    import java.util.List;
    
    import javax.servlet.ServletException;
    import javax.servlet.annotation.WebServlet;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    import com.tutorialspoint.Student;
    import com.tutorialspoint.StudentJDBCTemplate;
    import net.sf.json.JSONArray;
    import net.sf.json.JSONObject;
    /**
     * Servlet implementation class DatabaseAccess
     */
    @WebServlet("/DatabaseAccess")
    public class DatabaseAccess extends HttpServlet {
        private static final long serialVersionUID = 1L;
        /**
         * @see HttpServlet#HttpServlet()
         */
        public DatabaseAccess() {
            super();
            // TODO Auto-generated constructor stub
        }
    
        /**
         * @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)
         */
        protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        	ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
        	StudentJDBCTemplate studentJDBCTemplate =  (StudentJDBCTemplate)context.getBean("studentJDBCTemplate");    
    
            response.setContentType("text/json; charset=utf-8");
             PrintWriter out = response.getWriter();	
        	JSONArray jsonarray = new JSONArray();  
            JSONObject jsonobj = new JSONObject(); 
             List<Student> students = studentJDBCTemplate.listStudents();
             for (Student record : students) {
    
                 jsonobj.put("ID", record.getId());  
                 jsonobj.put("Name",  record.getName());  
                 jsonobj.put("Age", record.getAge());                           
                                      
                 jsonarray.add(jsonobj);             
                
             }
             out = response.getWriter();                  
             out.println(jsonarray);
             
    
           
            }
           
        /**
         * @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)
         */
        protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
            // TODO Auto-generated method stub
            doGet(request, response);
        }
    }
    
    

    2、用Tomcat启动程序,浏览器访问http://localhost/dbtest/DatabaseAccess,会看到如下界面:
    在这里插入图片描述

    对比数据库内容:
    在这里插入图片描述

    可以看到数据库中的数据,全部被转成了json格式发送给了,并输出到前端显示。

    下载源码

    展开全文
  • 在controller中,调用的方法上加这样一条,可以把json格式改为UTF-8,问题就解决了 @RequestMapping(value=“xxx”,produces = {“application/json;charset=UTF-8”}) @RequestMapping(value = "/xxx",produces = {...
  • /** * * @param request * @return */ @RequestMapping(value = "linkCity", method = RequestMethod.POST) @ResponseBody public String linkCity(HttpServletRequest request){ ...
  • Servlet返回Json数据前端

    千次阅读 2019-11-10 00:46:28
    1.首先需要在javaEE项目中导入jsonObject需要的6个包,需要的包在这里就不作讲述了。 2.RegisterServlet.java 3.register.jsp
  • 2. RestResult.java 3. ResultCode.java 4. ResultGenerator .java 1. 在pom文件中加入依赖 <groupId>com.alibaba</groupId> <artifactId>fastjson <version>1.2.30 2. RestResult.java package ...
  • Java处理JSON数据返回前端的反斜杠

    万次阅读 2018-10-28 20:26:53
    在写后端返回JSON数据前端的时候,遇到了前端一直无法获得后端传输的数据,但实际已经后端已经传输到前端了。在看前端获取到后端返回的数据的时候发现JSON中含有反斜杠,如下图 想必一定是这个转义符导致前端...
  • 本篇文章主要介绍了java web SpringMVC后端传json数据前端页面实例代码,具有一定的参考价值,感兴趣的小伙伴们可以参考一下。
  • import org.spring... } } 解决问题的方式: 在controller类中,调用的方法上加这样一条,可以把json格式改为UTF-8,问题就解决了 @RequestMapping(value=“xxx”,produces = {“application/json;charset=UTF-8”})
  • 原生Servlet 请求头 content-Type:application/json;chartset=utf-8 ... * 接收json数据方式1: * 请求头 content-Type: application/json * 返回json对象 * * 推荐使用 * @param request ...
  • java 接口返回json数据封装

    千次阅读 2020-04-30 16:22:45
    首先,采用的是springboot,在controller中使用了@RestController或者@ResponseBody注解,返回数据本身就是json格式。但是这样的json串在前后端分离使用中并不满足实际的效果,因此需要进行相应的封装,以满足前端...
  • // 客户端返回一个json对象 StringBuilder sb = new StringBuilder("{"); sb.append("\"name\"").append(":").append(user.getName()); sb.append(","); sb.append("\"gender\"").append(":").append(user....
  • 后台将对象数组转化为json格式数据返回到前台JSONArray jsonarray = JSONArray.fromObject(object);response.setContentType("text/html;charset=UTF-8");try { response.getWriter().print(jsonarray);...
  • Java Web程序实现返回JSON字符串的方法总结 Java Web程序实现返回JSON字符串的方法总结
  • 1)后端返回JSON数据: Map map = salesysActivityService.getSalesysActivityByPage(keys, pageSize, pageIndex, 1); return JSONObject.fromObject(map); 2)map中带有空值:null 例如:   map中包含一个...
  • 本篇文章主要介绍了解决SpringMVC 返回Java8 时间JSON数据的格式化问题处理,小编觉得挺不错的,现在分享大家,也大家做个参考。一起跟随小编过来看看吧
  • 1.前端返回数据 function getDatainitBarView(){ var url="${contextPath}/customer/findResultByIndicatorCodesAndCycleType"; var indicatorCodes=[{"code": "003002003003...
  • 前言:最近需要实现的任务是:写若干个接口,并且接口中的请求数据是json格式,然后按照请求参数读取前端提前整理好的json数据,并且将json数据返回到服务器端。 主要的工具:Gson 2.8.2 项目支撑:springboot ...
  • 这个问题有两个原因 1.90%的可能性,后台没有jackson的jar包,不再多说,加上对应的jar包就ok,我们主要...然后controller中的方法添加了@ResponseBody注解,返回的类型可能是String,也可能是其他java类型,导致前...
  • Java调用HTTP接口及返回json数据讲解

    千次阅读 2020-12-17 17:17:42
    本文主要为了总结一下Java常用基础中关于http接口调用以及前后端json数据返回方式,案例如下,如有误区或不足,还请大佬多多指教。话不多说,直接码 一,Java调用http接口 在我们开发代码的过程中常常会涉及到调用...
  • ![图片说明](https://img-ask.csdn.net/upload/201710/07/1507346819_471654.png) 其他浏览器直接跳到一个空页面显示json格式数据,怎么办,后台用的springboot
  • 这两天一直被这个问题困扰,解决的过程倒学到了不少东西.本打算写一篇总结,但发现网上这一篇写的已经很好了.十分推荐你们看一下
  • Response返回JSON数据到前台页面

    万次阅读 2018-12-17 17:25:31
    使用的类是net.sf.json.JSONObject,传入response对象和返回的显示类,修改response,返回前台JSON格式数据 代码: /** * 以JSON格式输出 * @param response */ protected void responseOutWithJson(...
  • 最近项目的网关会做鉴权操作,鉴权失败想直接给前端请求返回json数据,但是response对象中好像没有直接操作response的方法,借鉴各位大佬的经验,发现想要response加上json数据,涉及到流的知识,这以后也得巩固...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 60,872
精华内容 24,348
关键字:

java返回json数据给前端

java 订阅