Jboot v3.7.3 发布，全网最优雅的 Json 接收和注入

栏目: 软件资讯 · 发布时间: 5年前

内容简介：Jboot 是一个基于 JFinal、JFinal-Undertow、Dubbo、Seata、Sentinel、ShardingSphere、Nacos 等开发的微服务框架，帮助开发者降低微服务开发门槛。同时完美支持在 idea、eclipse 下多 maven 模块，对 java 代码、...

Jboot 是一个基于 JFinal、JFinal-Undertow、Dubbo、Seata、Sentinel、ShardingSphere、Nacos 等开发的微服务框架，帮助开发者降低微服务开发门槛。同时完美支持在 idea、eclipse 下多 maven 模块，对 java 代码、html、css、js 等资源文件进行热加载。爽爽开发，快乐生活。

到目前为止，Jboot 已经开源超过了 4 年的时间，迭代了 160+ 个版本，已经被超过 1000+ 公司在使用，其中包含了多个知名的上市公司。

Jboot V3.7.3 增强了和前端的 JSON 交互能力，可能是全网最为优雅、简单的接收方式。

1、接收 Java Bean。

在 Controller 中接收 Java Bean 可能是最为常见的方式，在 SpringMVC 中也内置了支持。

比如，前端传入的是：

{  
    "id":"abc",         
    "age":17,         
    "amount":123
 }

我们可以定义一个如下的 Java Bean 来接收。

public class MyBean {    
    private String id;    
    private int age;    
    private BigInteger amount;  
  
    //getter setter
}

在 Jboot（JFinal）的 Controller 中，我们如下的代码可以正常的接收。

public void bean(@JsonBody() MyBean bean) {    
    System.out.println("bean--->" + bean);    
    renderText("ok");
}

但是，如果我们需要接收的数据，是放在 JSON 的实体内部，比如：

{  
  "aaa":{     
        "bbb":{         
            "id":"abc",         
            "age":17,         
            "amount":123
      }
   }
 }

在 Controller 中，我们依然可以通过如下的方法进行接收：

public void bean(@JsonBody("aaa.bbb") MyBean bean) {    
    System.out.println("bean--->" + bean);    
    renderText("ok");
}

没错，值需要给 @JsonBody 添加 ”aaa.bbb“ 前缀。

2、接收 Java Map

在 Controller 中，我们接收 Map 的场景也是非常常见的，接收 Map 和接收 Java Bean 对我们来说，学习成本是 0。在如上的代码中，我们只需要把 MyBean 的参数缓存 Map 就可以了。

比如前端传入的是：

{  
    "id":"abc",         
    "age":17,         
    "amount":123
 }

Controller 后端通过如下的方式接收：

public void action(@JsonBody() Map map) {    
    System.out.println("map--->" + map);    
    renderText("ok");
}

而且，这里支持了更多的功能，在 Map 中我们可以给 Map 指定泛型来进行接收，比如：

public void action(@JsonBody() Map<String,String> map) {    
    System.out.println("map--->" + map);    
    renderText("ok");
}

那么，所有的 value 都会自动转换为 String 类型存放在 Map 里。而且，此处的 Map，你可以换成 HashMap、ConcurrentHashMap 都是没问题的。如果前端传入的 JSON 如下：

{  
  "aaa":{     
        "bbb":{         
            "id":"abc",         
            "age":17,         
            "amount":123
      }
   }
 }

和接收 Bean 一样。我们只需要在 Controller 给 @JsonBody 添加前缀即可：

public void action(@JsonBody("aaa.bbb") Map map) {    
    System.out.println("map--->" + map);    
    renderText("ok");
}

3、接收数组和集合（List、Set、Queue、Vector、Stack、Deque ）

和接收 Bean、Map 一样，当前端传入的是一个Json 数组的时候，我们一样轻松接收。比如，前端传入的 Json 内容如下：

[1,2,3]

我们可以轻松的把前端转换成为一个 int[] 数组：

//通过 int[] 数组来接收
public void method1(@JsonBody() int[] beans) {        
     System.out.println("beans--->" + beans);        
     renderText("ok");
}

当然，通过 List、Set 等集合来接收都是没问题的：

//通过 List 来接收
public void method3(@JsonBody() List beans) {        
    System.out.println("beans--->" + beans);        
    renderText("ok");
} 
 
//通过 Set 来接收
public void method4(@JsonBody() Set beans) {        
    System.out.println("beans--->" + beans);        
    renderText("ok");
} 
 
//通过 List 指定泛型 Integer 来接收
public void method5(@JsonBody() List<Integer> beans) {        
    System.out.println("beans--->" + beans);        
    renderText("ok");
} 
 
//通过 Set 指定泛型 Integer 来接收
public void method6(@JsonBody() Set<Integer> beans) {        
    System.out.println("beans--->" + beans);        
    renderText("ok");
}

不仅仅可以通过 int 类型来接收，通过 long、float、double、bigInteger 甚至 String 都是没问题的，比如：

 //通过 List 指定泛型 String 来接收
public void method7(@JsonBody() List<String> beans) {        
    System.out.println("beans--->" + beans);        
    renderText("ok");
} 
 
 //通过 Set 指定泛型 String 来接收
public void method8(@JsonBody() Set<String> beans) {        
    System.out.println("beans--->" + beans);        
    renderText("ok");
}

除此之外、我们还可以把集合中的 List、Set 修改为 Queue、Vector、Stack、Deque 等其他数据类型，一样优雅完美。

前端传入的是一个数组的 Java Bean：

[
      {                
      "id":"abc",                
      "age":17,                
      "amount":123
      },
      {                
      "id":"abc",                
      "age":17,                
      "amount":123
      }
  ]

拍拍屁股就知道如何在 Controller 写代码接收了：

public void array(@JsonBody() MyBean[] beans) {        
    System.out.println("array--->" + beans);        
    renderText("ok");
}

或者：

public void list(@JsonBody() List<MyBean> list) {        
      System.out.println("list--->" + list);        
      renderText("ok");
  }

如果 Java Bean 的数组放在 Json 多层的实体里：

{    
"aaa":{        
    "bbb":[
            {                
            "id":"abc",                
            "age":17,                
            "amount":123
            },
            {                
            "id":"abc",                
            "age":17,                
            "amount":123
            }
        ]
    }
}

我们只需要在 @JsonBody 添加参数即可：

public void list(@JsonBody("aaa.bbb") List<MyBean> list) {        
      System.out.println("list--->" + list);        
      renderText("ok");
  }

4、接收基本数据

在上述例子中，已经能接收 Java Bean、Map、数组和集合、接收基本数据自然不在话下。

例如，前端传入的内容如下：

{  "aaa":{     
        "bbb":{         
            "id":"abc",         
            "age":17,         
            "amount":123
      }
   }
 }

此时，如果我们想获取 age 的值，代码如下：

public void age(@JsonBody("aaa.bbb.age") int age) {        
      System.out.println("age--->" + age);        
      renderText("ok");
  }

当然，这个 age 在方法里定义的是 int 类型，我们可以随便定义成 Integer/long/float/double/BigInteger/String 等等都没问题。

5、自动拆装

如果 Jboot 以上的能力让你拍手叫好，那么 Jboot 特有的自动拆装绝对让你更加拍案叫绝。

比如前段传入的内容如下：

{    
"aaa":{        
    "bbb":[
            {                
            "id":"abc",                
            "age":17,                
            "amount":123
            },
            {                
            "id":"abc",                
            "age":17,                
            "amount":123
            }
        ]
    }
}

在非常多的场景下，我们只想获取 bbb 数组里的所有对象的 id 值，并不想获取其他内容，那么，如下的代码就可以帮你轻易的拆装：

public void array(@JsonBody("aaa.bbb[id]") String[] ids) {        
    System.out.println("array--->" + ids);        
    renderText("ok");
}


public void array(@JsonBody("aaa.bbb[id]") List<String> ids) {        
    System.out.println("array--->" + ids);        
    renderText("ok");
}

或者，我们想获取 bbb 数组的第一个对象，并转换为 Java Bean：

public void bean(@JsonBody("aaa.bbb[0]") MyBean bean) {        
    System.out.println("bean--->" + bean);        
    renderText("ok");
}

有或者说，我们想获取 bbb 数组的第一个对象的 age 值：

public void age(@JsonBody("aaa.bbb[0].age") long age) {
    renderText("age--->" + age);
}

我们来到更加复杂的，比如说如下的 JSON：

{
    "aaa":{
        "bbb":[
            {
                "attr1":"abc",
                "beans":[
                    {
                        "id":"abc",
                        "age":17,
                        "amount":123
                    },
                    {
                        "id":"abc",
                        "age":17,
                        "amount":123
                    }
                ]
            },
            {
                "attr2":"abc"
            }
        ]
    }
}

我们的目标是为了获取 beans 下，并转换为 MyBean 数组（或者 List 等集合），代码如下：

public void array(@JsonBody("aaa.bbb[0].beans") MyBean[] beans) {
    System.out.println("array--->" + JsonKit.toJson(beans));
    renderText("ok");
}

又或者说我们想获取 beans 下的所有 id 值，得到一个 String 数组：

public void array(@JsonBody("aaa.bbb[0].beans[id]") String[] ids) {
    System.out.println("array--->" + JsonKit.toJson(ids));
    renderText("ok");
}

简单而优雅。

6、通过非注入的方式接收 JSON

在以上的示例中，都是通过 @JsonBody 注解的方式进行注入的，如果不通过注入的方式，也没问题，在 JbootController 中，已经内置了 getRawObject() 方法来辅助我们接收 JSON 数据。

比如，前端传入的内容如下：

{
    "aaa":{
        "bbb":[
            {
                "attr1":"abc",
                "beans":[
                    {
                        "id":"abc",
                        "age":17,
                        "amount":123
                    },
                    {
                        "id":"abc",
                        "age":17,
                        "amount":123
                    }
                ]
            },
            {
                "attr2":"abc"
            }
        ]
    }
}

我们想把 beans 接收成为一个数组，可以通过如下的代码：

public void array() {
    MyBean[] beans = getRawObject(MyBean[].class,"aaa.bbb[0].beans");
    System.out.println("array--->" + JsonKit.toJson(beans));
    renderText("ok");
}

如果我们想接收 List<MyBean>，需要借助 Jboot 内置的 TypeDef 来辅助接收，代码如下：

public void array() {
    List<MyBean> beans = getRawObject(new TypeDef<List<MyBean>>(){},"aaa.bbb[0].beans");
    System.out.println("array--->" + JsonKit.toJson(beans));
    renderText("ok");
}

当然，接收其他不同的数据，值需要定义 json 的前缀即可，比如说我们要接收一个 Set<String> 的 id。代码如下：

public void array() {
    Set<Strint> ids = getRawObject(new TypeDef<Set<String>>(){},"aaa.bbb[0].beans[id]");
    System.out.println("array--->" + JsonKit.toJson(ids));
    renderText("ok");
}

但是此处需要注意的是：由于前段传入的两个 Object JSON 数组中，他们的 id 值都是一样的，当我们使用 Set 来接收的时候，Set 里只有一个值。

当然还有更多的功能此处不再一一举例，欢迎给位小伙伴使用 Jboot 开发的时候爽起来。

开发文档：

https://jbootprojects.gitee.io/docs/

同时，Jboot 官方也推出了企业级开发框架 JbootAdmin，详情 https://jbootprojects.gitee.io/docs/jbootadmin/

maven 依赖：

<dependency>
    <groupId>io.jboot</groupId>
    <artifactId>jboot</artifactId>
    <version>3.7.3</version>
</dependency>

Hello World：

@RequestMapping("/")
public class HelloworldController extends JbootController {

    public void index(){
        renderText("hello world");
    }

    public static void main(String[] args){
        JbootApplication.run(args);
    }
}

以上就是本文的全部内容，希望本文的内容对大家的学习或者工作能带来一定的帮助，也希望大家多多支持码农网

查看所有标签

猜你喜欢:

本站部分资源来源于网络，本站转载出于传递更多信息之目的，版权归原作者或者来源机构所有，如转载稿涉及版权问题，请联系我们。

码农书籍

Data Structures and Algorithm Analysis in Java

Mark A. Weiss / Pearson / 2011-11-18 / GBP 129.99

Data Structures and Algorithm Analysis in Java is an “advanced algorithms” book that fits between traditional CS2 and Algorithms Analysis courses. In the old ACM Curriculum Guidelines, this course wa......一起来看看《Data Structures and Algorithm Analysis in Java》这本书的介绍吧!

码农工具