‘壹’ 如果将json格式数据存储到类似mysql这样的关系型数据库中，怎么查
在MySQL与PostgreSQL的对比中，PG的JSON格式支持优势总是不断被拿来比较。其实早先MariaDB也有对非结构化的数据进行存储的方案，称为dynamic column，但是方案是通过BLOB类型的方式来存储。这样导致的问题是查询性能不高，不能有效建立索引，与一些文档数据库对比，优势并不大，故在社区的反应其实比较一般。当然，MariaDB的dynamic column功能还不仅限于非结构化数据的存储，但不在本文进行展开。
MySQL 5.7.7 labs版本开始InnoDB存储引擎已经原生支持JSON格式，该格式不是简单的BLOB类似的替换。原生的JSON格式支持有以下的优势：
JSON数据有效性检查：BLOB类型无法在数据库层做这样的约束性检查
查询性能的提升：查询不需要遍历所有字符串才能找到数据
支持索引：通过虚拟列的功能可以对JSON中的部分数据进行索引
首先我们来看如何在MySQL中使用原生的JSON格式：
mysql> create table user ( uid int auto_increment,
-> data json,primary key(uid))engine=innodb;
Query OK, 0 rows affected (0.01 sec)
mysql> insert into user values (NULL,
-> '{"name":"David","mail":"[email protected]","address":"Shangahai"}');
Query OK, 1 row affected (0.00 sec)
mysql> insert into user values (NULL,'{"name":"Amy","mail":"[email protected]"}');
Query OK, 1 row affected (0.00 sec)
可以看到我们新建了表user，并且将列data定义为了JSON类型。这意味着我们可以对插入的数据做JSON格式检查，确保其符合JSON格式的约束，如插入一条不合法的JSON数据会报如下错误：
mysql> insert into user values (NULL,"test");
ERROR 3130 (22032): Invalid JSON text: "Invalid value" at position 2 in value (or column) 'test'.
此外，正如前面所说的，MySQL 5.7提供了一系列函数来高效地处理JSON字符，而不是需要遍历所有字符来查找，这不得不说是对MariaDB dynamic column的巨大改进：
mysql> select jsn_extract(data, '$.name'),jsn_extract(data,'$.address') from user;
+-----------------------------+-------------------------------+
| jsn_extract(data, '$.name') | jsn_extract(data,'$.address') |
+-----------------------------+-------------------------------+
| "David" | "Shangahai" |
| "Amy" | NULL |
+-----------------------------+-------------------------------+
2 rows in set (0.00 sec)
当然，最令人的激动的功能应该是MySQL 5.7的虚拟列功能，通过传统的B+树索引即可实现对JSON格式部分属性的快速查询。使用方法是首先创建该虚拟列，然后在该虚拟列上创建索引：
mysql> ALTER TABLE user ADD user_name varchar(128)
-> GENERATED ALWAYS AS (jsn_extract(data,'$.name')) VIRTUAL;
Query OK, 0 rows affected (0.01 sec)
Records: 0 Duplicates: 0 Warnings: 0
mysql> select user_name from user;
+-----------+
| user_name |
+-----------+
| "Amy" |
| "David" |
+-----------+
2 rows in set (0.00 sec)
mysql> alter table user add index idx_username (user_name);
Query OK, 2 rows affected (0.01 sec)
Records: 2 Duplicates: 0 Warnings: 0
然后可以通过添加的索引对用户名进行快速的查询，这和普通类型的列查询一样。而通过explain可以验证优化器已经选择了在虚拟列上创建的新索引：
mysql> explain select * from user where user_name='"Amy"'\G
*************************** 1. row ***************************
id: 1
select_type: SIMPLE
table: user
partitions: NULL
type: ref
possible_keys: idx_username
key: idx_username
key_len: 131
ref: const
rows: 1
filtered: 100.00
Extra: NULL
1 row in set, 1 warning (0.00 sec)
可以发现MySQL 5.7对于JSON格式堪称完美，相信PostgreSQL阵营需要寻找新的策略来“攻击”MySQL了吧。如无意外，还是会停留在优化器这块，毕竟这块是目前MySQL必须要克服的最大问题，好在MySQL团队已经在重构优化器代码，相信更好的优化器将会在下一个版本中全面爆发。而一大堆文档数据库们已经哭晕在厕所了吧。
‘贰’ 如何把获取的json数据插入数据库
直接varchar或者text之类的类型即可插入。在Mysql5.7或以上可以支持JSON数据类型。其他的数据库你可以参考他的不同版本，考虑是否支持JSON数据类型，如果不支持就用字符串类型。但是要考虑长度。
PS：如果是用客户端链接，那么就算数据库支持，那客户端也得是最新版支持JSON的，要不然数据库支持，工具以为不支持！
‘叁’ 从jsp页面上传 excel文件 存到数据库 用json做
不明白为啥指定json，我的建议是：
1、STRUTS文件标签选择并上传EXCEL文件，示例代码：
<html:form action="/uploadExcelFile/UploadExcelFileAction.go" enctype="multipart/form-data" method="post" onsubmit="return confirm_save()">
<table border="0" cellpadding="0" cellspacing="5" align="center" style="margin:50">
<tr>
<td align="right" nowrap > 请选择Excel文件(.<%=excelType%>)：</td>
<td align="right" colspan="3" valign="middle" nowrap ><html:file property="aircraftExcel" size="200" style="width:400;height:25" value=""></html:file></td>
</tr><tr>
<td></td>
<td align="right">Excel文件中樱吵锋标题(表头)占行：</td>
<td align="left"><input name="topicRow" value="0" style="width:50" onKeyUp="value=value.replace(/[\D]/g,'')"/></td>
<TD align="right" nowrap title="上传"><html:submit value="开始更新" style="height:25; width:70"></html:submit></TD>
</tr>
</table>
</html:form>
2、UploadExcelFileAction接收、写入后台指定目录（脊晌局部代码）
FileOutputStream fos = null;
try {
//得到文件数据（数组）
byte[] fileDate = ff.getFileData();
//得到服务碰慎器硬盘文件夹的绝对路径
ServletContext application = this.getServlet().getServletContext();
String realPath = application.getRealPath("/");
if(excelType==null||excelType.equals("xlsx"))//默认生成2007以后版本格式
fos = new FileOutputStream(realPath+"aircraftExcelTable.xlsx");
else
fos = new FileOutputStream(realPath+"aircraftExcelTable.xls");
fos.write(fileDate);
fos.close();
if(excelType==null||excelType.equals("xlsx"))//默认生成2007以后版本格式
num=ReadExcelSaveToDB.ReadAndSaveNew(realPath+"aircraftExcelTable.xlsx",topicNumber);
else
num=ReadExcelSaveToDB.ReadAndSave(realPath+"aircraftExcelTable.xls",topicNumber);
if(num==-1){
session.setAttribute("forwardPage", currentPage);
session.setAttribute("prompt", "文件传输失败或无法连接数据库！");
return mapping.findForward("promptpage");
}else if(num==-2){
session.setAttribute("forwardPage", currentPage);
session.setAttribute("prompt", "Excel文件大于1000条或不能识别！重新制作Excel文件。");
return mapping.findForward("promptpage");
}else if(num==-3){
session.setAttribute("forwardPage", currentPage);
session.setAttribute("prompt", "Excel文件中包含非法字符（非数字），请修正后重试。");
return mapping.findForward("promptpage");
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally{
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
3、解析读取表数据（POI）并存入数据库（局部代码）
public static int ReadAndSave(String path,String topicNumber){
try {
File file=new File(path);
FileInputStream fs=new FileInputStream(file);
@SuppressWarnings("resource")
HSSFWorkbook workbook=new HSSFWorkbook(fs);
//一共有几张表
int sheet_num=workbook.getNumberOfSheets();
setSheetNumber(0);
setProcess(0);//开始
//循环每个表
for(int i=0;i<sheet_num;i++){
HSSFSheet sheet=workbook.getSheetAt(i);
setSheetNumber(i+1);
if(sheet!=null&&sheet.getPhysicalNumberOfRows()!=0){
int topicNumberNum=Integer.parseInt(topicNumber);//越过首行的标题（如果有）
totalNumber=sheet.getPhysicalNumberOfRows()-topicNumberNum;
//循环各个行
for(int j=sheet.getFirstRowNum()+topicNumberNum;j<=sheet.getPhysicalNumberOfRows();j++){
HSSFRow row=sheet.getRow(j);
String aircraft=null;
//String aircraftType=null;
Double takeoffWeight=0.00;
Double payloadMax2=0.00;
int seatNumberMax2=0;
if(row!=null&&row.getPhysicalNumberOfCells()!=0){
switch(row.getCell(0).getCellType()){
case Cell.CELL_TYPE_STRING:
aircraft=(row.getCell(0).getStringCellValue()).trim();
break;
case Cell.CELL_TYPE_NUMERIC:
aircraft=String.valueOf(row.getCell(0).getNumericCellValue()).trim();
break;
}
//继续处理其他单元格、行
｝
//存入数据库
AircraftTableActionForm atb=new AircraftTableActionForm();
if(aircraft!=null&&!aircraft.equals("")){
atb.setAircraft(aircraft);
//set其他值
updateByExcel(atb)!=-1
}
｝
‘肆’ 数据库存json 缺点
json数据仅仅只能用于展示display，如果用于条件查询，数据更新其效率是很低的，而且难于优化，不要尝试在json字段上进行查询优化。
虽然mysql5.7支持了json类型，但mysql作为关系型数据库，对标准化的column-per-value支持更好，包括数据类型限制、长度限制，唯一索引限制，查询索引优化，外键关联，关联查询支持，运算支持等，这些都是json中key无法达到的。
将常用的查询字段从json数据中剥离出来形成单独的字段，虽然可以改善查询问题，但你最好有先见之明，如果后期进行剥离就会涉及代码修改和数据迁移，遇到多版本的话，还可能出现数据冗余的问题，处理不好还会出现数据不一致问题，并不仅仅这么简单，一定慎用。
存储json的text类型性能并不乐观。
大JSON的解析性能同样不乐观，而且对于中文数据，纯JSON太占空间了。
‘伍’ LowDB 轻量级 JSON 本地数据库
作为轻量级的本地存储方式，对于构建不依赖服务斗旁器的小型项空雀橡目，用LowDB存储和管理数据是十分理想的选择。在Nodejs, Electron and browser等一些小型项目中经常能看到LowDB的身影。
https://github.com/typicode/lowdb
npm install lowdb
或者：
yarn add lowdb
const low = require('lowdb');
const FileSync = require('lowdb/adapters/FileSync'); // 有多种适配器可选择
const adapter = new FileSync('db.json'); // 申明一个适配器
const db = low(adapter);
db.defaults({posts: [], user: {}, count: 0})
.write();
db.get('posts')
.push({id: 1, title: 'lowdb is awesome'})
.write()
db.set('user.name', 'typicode')
.write()
db.update('count', n => n + 1)
.write()
运行程序会在项目中添加db.json文件，里面存储了添加的数据：
{
"posts": [
{
"id": 1,
"title": "lowdb is awesome"
}
],
"user": {
"name": "typicode"
},
"count": 1
}
lowdb是基于lodash构建的，所以可以使用任何lodash强大的函数，比如: _.get() 和 _.find()，并且可以串联地使用：
db.get('users')
.find({sex: 'male'})
.value()
函数 功能
low(adapter) 返回一个具有特定属性和功能的 lodash chain
db.[...].write() / .value() 写 / 读数据
db.getState() / .setState() 获取 / 设置数据库的状态
db._ 数据库lodash的实例，可以利用这个添加自己的函数或者第三方的mixins,比如lodash-id
db._.mixin({
second: function(array) {
return array[1]
}
})
db.get('posts')
.second()
.value()
针对lowdb自带的适配器：FileSync、FileAsync 和 LocalBrowser，有以下可选岁轿参数：
defaultValue: 文件不存在时的默认值；
serialize/deserialize: 写之前和读之后的操作。
const adapter = new FilSync('db.json',{
serialize: (data) => encrypt(JSON.stringify(data)),
deserialize: (data) => JSON.parse(decrypt(data))
})
可以直接使用lodash的函数进行查询。需要注意的是有些操作可能会导致原数据被修改，为了避免这种误操作，需要使用 .cloneDeep()，操作都是惰性的，只有调用 .value()或 .write()后才会正式执行。
检查users是是否存在
db.has('users')
.value()
设置users
db.set('users', [])
.write()
排序、选择
db.get('users')
.filter({sex: 'male'})
.sortBy('age')
.take(5)
.value()
获取特定字段
db.get('users')
.map('name')
.value()
获取数量
db.get('users')
.size()
.value()
获取特定信息
db.get('users[0].name')
.value()
更新信息
db.get('users')
.find({name: 'Tom'})
.assign({name: 'Tim'})
.write()
删除信息
db.get('users')
.remove({name: 'Time'})
.write()
移除属性
db.unset('users.name)
.write()
深拷贝
db.get('users')
.cloneDeep()
.value()
可以使用 shortid 和 lodash-id 为数据库中的每一条记录创建唯一的id索引，然后通过id检索操作记录：
const shortid = require('shortid')
const postId = db
.get('posts')
.push({ id: shortid.generate(), title: 'low!' })
.write()
.id
const post = db
.get('posts')
.find({ id: postId })
.value()
const lodashId = require('lodash-id')
const FileSync = require('lowdb/adapters/FileSync')
const adapter = new FileSync('db.json')
const db = low(adapter)
db._.mixin(lodashId)
// We need to set some default values, if the collection does not exist yet
// We also can store our collection
const collection = db
.defaults({ posts: [] })
.get('posts')
// Insert a new post...
const newPost = collection
.insert({ title: 'low!' })
.write()
// ...and retrieve it using its id
const post = collection
.getById(newPost.id)
.value()
low( ) 函数接受自定义的Adapter
class MyStorage {
constructor() {
// ...
}
read() {
// Should return data (object or array) or a Promise
}
write(data) {
// Should return nothing or a Promise
}
}
const adapter = new MyStorage(args)
const db = low(adapter);
==============================================
英文官网介绍，更加简洁
Lowdb 3 is a pure ESM package. If you're having trouble importing it in your project, please read this.
You can use TypeScript to type check your data.
You can also add lodash or other utility libraries to improve lowdb.
For CLI, server and browser usage, see examples/ directory.
Lowdb has two classes (for asynchronous and synchronous adapters).
Calls adapter.read() and sets db.data .
Note: JSONFile and JSONFileSync adapters will set db.data to null if file doesn't exist.
Calls adapter.write(db.data) .
Holds your db content. If you're using the adapters coming with lowdb, it can be any type supported by JSON.stringify .
For example:
Adapters for reading and writing JSON files.
In-memory adapters. Useful for speeding up unit tests.
Synchronous adapter for window.localStorage .
Adapters for reading and writing text. Useful for creating custom adapters.
If you've published an adapter for lowdb, feel free to create a PR to add it here.
You may want to create an adapter to write db.data to YAML, XML, encrypt data, a remote storage, ...
An adapter is a simple class that just needs to expose two methods:
For example, let's say you have some async storage and want to create an adapter for it:
See src/adapters/ for more examples.
To create an adapter for another format than JSON, you can use TextFile or TextFileSync .
For example:
Lowdb doesn't support Node's cluster mole.
If you have large JavaScript objects ( ~10-100MB ) you may hit some performance issues. This is because whenever you call db.write , the whole db.data is serialized using JSON.stringify and written to storage.
Depending on your use case, this can be fine or not. It can be mitigated by doing batch operations and calling db.write only when you need it.
If you plan to scale, it's highly recommended to use databases like PostgreSQL or MongoDB instead.
‘陆’ json 存储在数据库中用什么格式
JSON的格式非常简单：名称/键值。之前MySQL版本里面要实现这样的存储，要么用VARCHAR要么用TEXT大文本。 MySQL5.7发布后，专门设计了JSON数据类型以及关于这种类型的检索以及其他函数解析。我们先看看MySQL老版本的JSON存取。
‘柒’ 如何将json数据转化为数据库文件
从json数组中得到java数组，可以对该数组进行肢缺野转化，如将JSONArray转化为String型、Long型、Double型历喊、Integer型、Date型等等。扮察
分别采用jsonArray下的getString(index)、getLong(index)、getDouble(index)、getInt(index)等方法。
同样，如果要获取java数组中的元素，只需要遍历该数组。
Java代码 收藏代码
/**
* 将json数组转化为Long型
* @param str
* @return
*/
public static Long[] getJsonToLongArray(String str) {
JSONArray jsonArray = JSONArray.fromObject(str);
Long[] arr=new Long[jsonArray.size()];
for(int i=0;i<jsonArray.size();i++){
arr[i]=jsonArray.getLong(i);
System.out.println(arr[i]);
}
return arr;
}
/**
* 将json数组转化为String型
* @param str
* @return
*/
public static String[] getJsonToStringArray(String str) {
JSONArray jsonArray = JSONArray.fromObject(str);
String[] arr=new String[jsonArray.size()];
for(int i=0;i<jsonArray.size();i++){
arr[i]=jsonArray.getString(i);
System.out.println(arr[i]);
}
return arr;
}
/**
* 将json数组转化为Double型
* @param str
* @return
*/
public static Double[] getJsonToDoubleArray(String str) {
JSONArray jsonArray = JSONArray.fromObject(str);
Double[] arr=new Double[jsonArray.size()];
for(int i=0;i<jsonArray.size();i++){
arr[i]=jsonArray.getDouble(i);
}
return arr;
}
/**
* 将json数组转化为Date型
* @param str
* @return
*/
public static Date[] getJsonToDateArray(String jsonString) {
JSONArray jsonArray = JSONArray.fromObject(jsonString);
Date[] dateArray = new Date[jsonArray.size()];
String dateString;
Date date;
SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
for (int i = 0; i < jsonArray.size(); i++) {
dateString = jsonArray.getString(i);
try {
date=sdf.parse(dateString);
dateArray[i] = date;
} catch (Exception e) {
e.printStackTrace();
}
}
return dateArray;
}
public static void main(String[] args) {
JSONArray jsonLongs = new JSONArray();
jsonLongs.add(0, "111");
jsonLongs.add(1, "222.25");
jsonLongs.add(2, new Long(333));
jsonLongs.add(3, 444);
Long[] log=getJsonToLongArray(jsonLongs.toString());
for(int i=0;i<log.length;i++){
System.out.println(log[i]);
}
JSONArray jsonStrs = new JSONArray();
jsonStrs.add(0, "2011-01-01");
jsonStrs.add(1, "2011-01-03");
jsonStrs.add(2, "2011-01-04 11:11:11");
Date[] d=getJsonToDateArray(jsonStrs.toString());
for(int i=0;i<d.length;i++){
System.out.println(d[i]);
}
}
/*结果如下：
* 111
* 222
* 333
* 444
*
* Sat Jan 01 00:00:00 CST 2011
* Mon Jan 03 00:00:00 CST 2011
* Tue Jan 04 00:00:00 CST 2011
*/
‘捌’ 如何将从接口取到的json数据存入mysql数据库
mysql数据库建立表，存储json字段用text类型
然后从接口中获取JSON数据，转成STRING格式，直接插入到这个字段就可以了。
‘玖’ java解析json格式文件，再保存在数据库怎么做
java解析json格式文件，再保存在数据库的方法：
1:定义一个实体类
2:用json lib将json字符串转为Java对象
3:用jdbc或hibernate将java对象存入数据库
直接读写文件，再把读出来的文件内容格式化成json，再用JDBC、Mybatis或者其他框架将json数据存入数据库。
假设实体类是这样的：
publicclassElectSet{
publicStringxueqi;
publicStringxuenian;
publicStringstartTime;
publicStringendTime;
publicintmenshu;
publicStringisReadDB;
//{"xueqi":,"xuenian":,"startTime":,"endTime":,"renshu":,"isReadDB":}
publicStringgetXueqi(){
returnxueqi;
}
publicvoidsetXueqi(Stringxueqi){
this.xueqi=xueqi;
}
publicStringgetXuenian(){
returnxuenian;
}
publicvoidsetXuenian(Stringxuenian){
this.xuenian=xuenian;
}
publicStringgetStartTime(){
returnstartTime;
}
publicvoidsetStartTime(StringstartTime){
this.startTime=startTime;
}
publicStringgetEndTime(){
returnendTime;
}
publicvoidsetEndTime(StringendTime){
this.endTime=endTime;
}
publicintgetMenshu(){
returnmenshu;
}
publicvoidsetMenshu(intmenshu){
this.menshu=menshu;
}
publicStringgetIsReadDB(){
returnisReadDB;
}
publicvoidsetIsReadDB(StringisReadDB){
this.isReadDB=isReadDB;
}
}有一个json格式的文件，存的信息如下：
Sets.json:
{"xuenian":"2007-2008","xueqi":"1","startTime":"2009-07-1908:30","endTime":"2009-07-2218:00","menshu":"10","isReadDB":"Y"}
具体操作：
/*
*取出文件内容，填充对象
*/
publicElectSetfindElectSet(Stringpath){
ElectSetelectset=newElectSet();
Stringsets=ReadFile(path);//获得json文件的内容
JSONObjectjo=JSONObject.fromObject(sets);//格式化成json对象
//System.out.println("------------"jo);
//Stringname=jo.getString("xuenian");
//System.out.println(name);
electset.setXueqi(jo.getString("xueqi"));
electset.setXuenian(jo.getString("xuenian"));
electset.setStartTime(jo.getString("startTime"));
electset.setEndTime(jo.getString("endTime"));
electset.setMenshu(jo.getInt("menshu"));
electset.setIsReadDB(jo.getString("isReadDB"));
returnelectset;
}
//设置属性，并保存
publicbooleansetElect(Stringpath,Stringsets){
try{
writeFile(path,sets);
returntrue;
}catch(IOExceptione){
//TODOAuto-generatedcatchblock
e.printStackTrace();
returnfalse;
}
}
//读文件，返回字符串
publicStringReadFile(Stringpath){
Filefile=newFile(path);
BufferedReaderreader=null;
Stringlaststr="";
try{
//System.out.println("以行为单位读取文件内容，一次读一整行：");
reader=newBufferedReader(newFileReader(file));
StringtempString=null;
intline=1;
//一次读入一行，直到读入null为文件结束
while((tempString=reader.readLine())!=null){
//显示行号
System.out.println("line"line":"tempString);
laststr=laststrtempString;
line;
}
reader.close();
}catch(IOExceptione){
e.printStackTrace();
}finally{
if(reader!=null){
try{
reader.close();
}catch(IOExceptione1){
}
}
}
returnlaststr;
}
将获取到的字符串，入库即可。
‘拾’ 数据库基础——JSON
存储JSON文档所需的空间与LONGBLOB或LONGTEXT大致相同；存储在JSON列中的任何JSON文档的大小都限制为max_allowed_packet系统变量的值。可以使用JSON_STORAGE_SIZE( )函数获取存储JSON文档所需的空间量。
["ade", 12, null, true, false]
{"k1": "value", "k2": 2}
[99, [78, "e"], {"k1": 1, "k2": "a"}, "de"]
{"k1": 1, "k2": [10, "s"]}
使用JSON路径表达式选择JSON文档中的值。