因此，我开发了一个系统，只要用户尝试保存并且数据库连接不存在，就会将数据库插入/更新命令保存到文本文件中。文件中的每一行都是一个插入或更新命令。但是，我似乎遇到了一个问题。
有些文件似乎不想通过第一行读取。所有这些都有一个共同点 - 因为数据库中有与第一个插入对应的数据，我跳过它，因为输入后不允许更改该信息。但是，当我尝试读取下一行时，它会引导，因为readLine()命令返回null（这导致其余代码按预期失败）。
我尝试在下一个while(!ready() Thread.sleep(500))之前添加readLine()，但它只是无限期地停留在那里（我让它在杀死JVM之前大约需要10分钟）。我还尝试过只添加一个else块来检查数据库中是否存在数据，该数据暂停2秒，但问题仍然存在。
请注意，任何以不存在的数据插入开头的文件都可以正常工作。
有没有人对如何解决这个问题有任何想法？
编辑：这是从顶部到等待准备的代码
private static boolean loadExistingData()
{
File dir = new File(Configuration.DBOutputDataLocation);
// Attempt to create the directory in case it doesn't exist.
if(!dir.exists())
{
if(!dir.mkdir())
{
return false;
}
}
String[] existingFiles = dir.list();
System.out.println(existingFiles.length);
if(existingFiles == null || existingFiles.length == 0)
{
return false;
}
else
{
BufferedReader fileReader = null;
DatabaseAccessor dba = DatabaseAccessor.getInstance();
// Pull out the files, submit each one.
for(int i = 0; i < existingFiles.length; i++)
{
try
{
fileReader = new BufferedReader(new FileReader(new File(Configuration.DBOutputDataLocation + existingFiles[i])));
}
catch(FileNotFoundException e)
{
System.err.println("ERROR Reading From File: " + existingFiles[i]);
e.printStackTrace();
}
// Recreate much of Util.saveToDB();
if(dba.isConnected())
dba.disconnect();
if(!dba.connect(Configuration.dbUser, Configuration.dbPass, Configuration.dbURL))
return false;
String sqlUpdate;
String serialNum = "";
int testNum;
/**
* Sensor Information {serial number, type, capacity, etc.} Data
*/
try
{
// Read Line for the Sensor data.
sqlUpdate = fileReader.readLine();
}
catch(IOException e)
{
System.err.println("ERROR Reading From File: " + existingFiles[i]);
e.printStackTrace();
try
{
fileReader.close();
}
catch(IOException e1)
{
e1.printStackTrace();
}
return false;
}
try
{
int serialNumBegin = sqlUpdate.indexOf("'") + 1;
int serialNumEnd = sqlUpdate.indexOf("'", serialNumBegin);
serialNum = sqlUpdate.substring(serialNumBegin, serialNumEnd);
System.out.println("Sensor sqlUpdate: " + sqlUpdate);
if(!dba.contains("sensor", "serial_number = '" + serialNum + "'"))
{
try
{
// please work, please work, please work...
dba.executeUpdate(sqlUpdate);
}
catch(SQLException e)
{
// gaa! ok, give user moderately descriptive error. What could
// they do about it anyway? Reconfigure the SQL server?
e.printStackTrace();
System.out.println("failed sensor entry @ update");
try
{
fileReader.close();
}
catch(IOException e1)
{
e1.printStackTrace();
}
return false;
}
}
else
{
System.out.println("Sensor Exists, skipping.");
}
}
catch(SQLException e1)
{
e1.printStackTrace();
System.out.println("failed sensor entry");
try
{
fileReader.close();
}
catch(IOException e2)
{
e1.printStackTrace();
}
return false;
}
/**
* Sensor Test xref
*/
try
{
int k = 0;
while(!fileReader.ready())
{
Thread.sleep(500);
System.out.println("Slept : " + k++);
}
}
catch(IOException e3)
{
e3.printStackTrace();
}
catch(InterruptedException e)
{
// TODO Auto-generated catch block::: Problem with file not being
// ready!!111oneoneoneeleventyeleven
e.printStackTrace();
}
try
{
// Read Line for the Sensor test data.
sqlUpdate = fileReader.readLine();
}
catch(IOException e)
{
System.err.println("ERROR Reading From File: " + existingFiles[i]);
e.printStackTrace();
try
{
fileReader.close();
}
catch(IOException e1)
{
e1.printStackTrace();
}
}
System.out.println("Sensor Test Xref: " + sqlUpdate);
// Locate the test number
int serialNumBegin = sqlUpdate.indexOf("'") + 1;
int serialNumEnd = sqlUpdate.indexOf("'", serialNumBegin);
int testNumBegin = serialNumEnd + 2;
int testNumEnd = sqlUpdate.indexOf(",", testNumBegin);
testNum = Integer.parseInt(sqlUpdate.substring(testNumBegin, testNumEnd));
if(testNum == -1)
{
// increments until it finds an unused test #
try
{
while(dba.contains("sensor_test_xref", "serial_number = '" + serialNum + "' and test_no = " + (++testNum)));
}
catch(SQLException e1)
{
e1.printStackTrace();
JOptionPane.showMessageDialog(new JFrame(), "Error saving test information (date, test number, station...) to database",
"DB Error", JOptionPane.ERROR_MESSAGE);
System.out.println("failed sensor_test_xref");
try
{
fileReader.close();
}
catch(IOException e2)
{
e1.printStackTrace();
}
return false;
}
System.out.println("settled on test# " + testNum);
// Splice test number back in
// Gets me the beginning up to the comma before the test number
String firstPartOfUpdate = sqlUpdate.substring(0, testNumBegin);
// Gets me the last part of it, from the comma to the end.
String lastPartOfUpdate = sqlUpdate.substring(testNumEnd);
// Piece everything back together...
sqlUpdate = firstPartOfUpdate + testNum + lastPartOfUpdate;
try
{
dba.executeUpdate(sqlUpdate);
}
catch(SQLException e)
{
e.printStackTrace();
// obviously a good entry was not made
testNum = -1;
System.out.println("failed sensor_test_xref");
try
{
fileReader.close();
}
catch(IOException e1)
{
e1.printStackTrace();
}
return false;
}
System.out.println("sensor_test_xref success");
}
/**
* Temperature Point Data.
*/
try
{
// Need a loop because there should be one line for each temp. point.
while(fileReader.ready())
{
try
{
sqlUpdate = fileReader.readLine();
}
catch(IOException e)
{
System.err.println("ERROR Reading From File: " + existingFiles[i]);
e.printStackTrace();
try
{
fileReader.close();
}
catch(IOException e1)
{
e1.printStackTrace();
}
return false;
}
// Locate the temp point
int serialNumBegin1 = sqlUpdate.indexOf("'") + 1;
int serialNumEnd1 = sqlUpdate.indexOf("'", serialNumBegin1);
int testNumBegin1 = serialNumEnd1 + 2;
int testNumEnd1 = sqlUpdate.indexOf(",", testNumBegin1);
int tempPointBegin = testNumEnd1 + 2;
int tempPointEnd = sqlUpdate.indexOf("'", tempPointBegin);
String tempPoint = sqlUpdate.substring(tempPointBegin, tempPointEnd);
// the unique key for a temperature point entry
String condition =
"serial_number = '" + serialNum + "' and test_no = " + testNum + " and temp_point = '" + tempPoint + "'";
// if an entry already exists delete it
try
{
if(dba.contains("sensor_temp_point", condition))
{
try
{
dba.executeUpdate("delete from sensor_temp_point where " + condition);
}
catch(SQLException e)
{
e.printStackTrace();
try
{
fileReader.close();
}
catch(IOException e1)
{
e1.printStackTrace();
}
return false;
}
}
}
catch(HeadlessException e1)
{
e1.printStackTrace();
try
{
fileReader.close();
}
catch(IOException e2)
{
e1.printStackTrace();
}
return false;
}
catch(SQLException e1)
{
e1.printStackTrace();
try
{
fileReader.close();
}
catch(IOException e2)
{
e1.printStackTrace();
}
return false;
}
// Splice test number and temperature point back in
// Gets me the beginning up to the comma before the test number
String firstPartOfUpdate = sqlUpdate.substring(0, testNumBegin1);
// Gets me the last part of it, from the comma to the end.
String lastPartOfUpdate = sqlUpdate.substring(tempPointEnd);
// Piece everything back together...
sqlUpdate = firstPartOfUpdate + testNum + ",'" + tempPoint + lastPartOfUpdate;
System.out.println("Temp Point sqlUpdate: " + sqlUpdate);
try
{
dba.executeUpdate(sqlUpdate);
}
catch(Exception e)
{
e.printStackTrace();
System.out.println("failed to save temp. point data : " + i);
try
{
fileReader.close();
}
catch(IOException e1)
{
e1.printStackTrace();
}
return false;
}
}
}
catch(IOException e)
{
System.err.println("ERROR Reading From File: " + existingFiles[i]);
e.printStackTrace();
try
{
fileReader.close();
}
catch(IOException e1)
{
e1.printStackTrace();
}
return false;
}
System.out.println("all successful");
// Close the file before deletion!
try
{
fileReader.close();
}
catch(IOException e1)
{
e1.printStackTrace();
}
try
{
new File(Configuration.DBOutputDataLocation + existingFiles[i]).delete();
}
catch(SecurityException e)
{
e.printStackTrace();
}
}
System.out.println("All Files Saved Successfully.");
dba.disconnect();
return true;
}
}
这是另一个示例文件的编辑。我剪切了数据部分以节省空间，只包含一个'sensor_temp_point'行（文件中有4个）。
insert into sensor (serial_number, sensor_type, amplification_id, sensor_max_capacity, unit_cd) values ;
insert into sensor_test_xref (serial_number, test_no, test_station, test_date, tester_initials, test_load) values ;
insert into sensor_temp_point (serial_number, test_no, temp_point, temp_val, excitation_val, linearity, temp_zero_shift_abs, temp_span_shift_abs, load_0_actual_val, load_0_raw_val, load_0_norm_val, load_50_actual_val, load_50_raw_val, load_50_norm_val, load_100_actual_val, load_100_raw_val, load_100_norm_val, load_0r_actual_val, load_0r_raw_val, load_0r_norm_val, last_reading_time) values ;
答案 0 :(得分：27)
readLine()到达文件末尾时，它将返回null。等待再次阅读是没有意义的 - 你应该在那时停下来。
目前尚不清楚究竟发生了什么，但一般来说，循环浏览文件的内容，我会用：
String line;
while ((line = reader.readLine()) != null)
{
// Use the line
}
当readLine返回null时，表示没有更多数据。我根本不会使用ready()。
一旦你重构了你的代码（只是使用finally块关闭文件将删除大约四分之一的方法 - 然后进一步重构）这对你来说会容易得多找出真正发生的事情。
答案 1 :(得分：2)
每当我需要阅读文件时，我都会搜索“java read text file”。 （对于许多您不想记住的任务，这是一个很好的做法。）有很多页面显示了阅读文本文件的基本技巧。
这是一个。 http://www.javapractices.com/topic/TopicAction.do?Id=42
答案 2 :(得分：0)
while（！ready（）Thread.sleep（500））
如果我理解正确，您试图说您希望您的代码与正在写入文件的进程（或线程）同时读取文本文件 ？如果是这样， 可能是您遇到的问题。
当程序向文件发出write()时，输出很可能在某处缓冲。在flush() - close()的程序{es}的输出文件之前，缓冲的数据不会写入实际文件。因此，您可能需要查看另一个程序，该程序会写入您要读取的数据。
当一个程序要与写入该数据的程序同时读取数据时，这两个程序必须具有一些并发控制。在Unix（POSIX）系统上，以这种方式通信的程序通常使用管道而不是文件，处理阻塞I / O的功能提供了并发控制。当你想使用文件时，事情变得棘手。您的阅读程序可以尝试轮询，直到它读取表明文本结尾的独特模式。您可以使用锁定方案，因此文件将被锁定，直到编写器完成对文件的写入。