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

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

内容简介：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);
    }
}