H2数据库说明

     H2是一个文本数据库，你可以引用到自己的项目中，或在电脑上直接使用。好处在于不需要像Oracle或Mysql那样要安装软件，而且是轻量的。H2在使用时，只要引入h2*.jar文件，并指明JDBC驱动：org.h2.Driver，还有就是数据库的路径即可。H2在项目中使用时，你可以看作H2有一个服务平台，将你的项目web端和H2数据库连接起来。

 

电脑上使用H2

首先，在电脑上使用H2时，需要到官网上下载安装包http://www.h2database.com/html/main.html。下载All Platforms (zip, 8 MB)的文件。解压之后，你就可以看到如下的文件：

其次，如果是windows系统，点击bin目录下的h2.bat或h2w.bat都可以， 如果是linux系统，者执行 sh h2.sh.笔者是在自己的windows系统上运行，所以双击h2w.bat后，在电脑的右下角可以看到这个图标。，同时会弹出浏览器的登录窗口。访问的地址是：http://192.168.111.1:8082/login.jsp?jsessionid=d3de299ee67f8926edc84ffda951e248

注意，在测试的情况下，JDBC URL的路径最后要写上test.上图是笔者自己指定了数据库文件所放置的位置，所以写上了具体的路径，其实读者也可以直接写上jdbc:h2: test。test的密码都是sa。点击Connect，你将会看到如下的页面。

好了在上面的页面中，你就可以写上自己的SQL语句了。但是H2有好多在Oracle或Mysq中常用的函数是没有的，这样在开发中可能会带来麻烦。

 

项目中使用H2

  以上只是笔者简单的对H2的使用，也只能说是带读者入门吧。如果想要了解更多H2的使用，可到官网上找资料，或下载使用文档http://www.h2database.com/h2.pdf 。

  1. 项目中使用H2,需要引入h2*.jar。这就好比在Oracle和Mysql中引入相应的jar文件是一样的。但是H2不需要在电脑上安装任何的软件，除非你是要在浏览器中使用，那就需要上面介绍的那样了。
  2. 在项目中创建一个类，名为H2ConnectionPool，这个是连接池的方法。在连接池中你需要指名H2数据库文本所要放置的路径，一般在项目中都是直接写上："jdbc:h2:~/test”，这是说明放置到项目的同等路径下。笔者为了项目中好查看数据库的数据，所以指明子路径是：E:/workspace/SelfMonitor/SelfMonitor/data/test。还有需要注意的是，在同一电脑上，只能有一个H2是开着，也就是说如果你用h2w.bat启用了H2,而在项目中还想使用h2，这是不请允许的，项目启动或浏览器连接都会报在使用中。另外，在项目中可能会有多个线程在操作数据库，有时候会引起线程使用上的冲突，即一个线程在连接数据库后关闭，导致另一个线程在使用时出现异常。在这种的情况下，你需要加上MVCC=TRUE的设置。代码如下。 
    1.   package com.owen.h2.database2;
    2.  
    3. import java.sql.Connection;
    4. import java.sql.SQLException;
    5.  
    6. import org.h2.jdbcx.JdbcConnectionPool;
    7.  
    8. /**
    9.  *H2数据库操作
    10.  * 
    11.  * @author owen
    12.  * @DATE 20190228
    13.  *
    14.  */
    15. public class H2ConnectionPool
    16. {
    17.  
    18. 	private static H2ConnectionPool cp = null;
    19. 	private JdbcConnectionPool jdbcCP = null;
    20.  
    21. 	private H2ConnectionPool()
    22. 	{
    23. 		String dbPath = "E:/workspace/SelfMonitor/SelfMonitor/data/test";
    24. 		jdbcCP = JdbcConnectionPool.create("jdbc:h2:" + dbPath+";MVCC=TRUE", "sa", "");		jdbcCP.setMaxConnections(50);
    25. 	}
    26.  
    27. 	public static H2ConnectionPool getInstance()
    28. 	{
    29. 		if (cp == null)
    30. 		{
    31. 			cp = new H2ConnectionPool();
    32. 		}
    33. 		return cp;
    34. 	}
    35.  
    36. 	public Connection getConnection() throws SQLException
    37. 	{
    38. 		return jdbcCP.getConnection();
    39. 	}
    40. }

     

  3. 有了以上的这个连接池，接下就可以对H2数据库进行操作。以下是提供几个常用的增删改查的方法封装。 
    1.  package com.dc.bd.dao;
    2.  
    3. import java.sql.Connection;
    4. import java.sql.DatabaseMetaData;
    5. import java.sql.PreparedStatement;
    6. import java.sql.ResultSet;
    7. import java.sql.SQLException;
    8. import java.sql.Statement;
    9. import java.util.ArrayList;
    10. import java.util.HashMap;
    11. import java.util.List;
    12. import java.util.Map;
    13. import java.util.Set;
    14. import java.util.UUID;
    15.  
    16. import org.apache.commons.lang3.StringUtils;
    17. import org.slf4j.Logger;
    18. import org.slf4j.LoggerFactory;
    19.  
    20.  
    21. import com.dc.bd.entity.Event;
    22. import com.dc.bd.entity.KpiInfo;
    23.  
    24. /**
    25.  * H2数据库操作
    26.  * 
    27.  * @author owen
    28.  * @DATE 20190228
    29.  *
    30.  */
    31.  
    32. public class H2CommonDao
    33. {
    34.  
    35. 	private  static Logger logger = LoggerFactory.getLogger(H2CommonDao.class);
    36. 	/**
    37. 	 * 建表方法
    38. 	 * 
    39. 	 * @param tableName
    40. 	 * @param items
    41. 	 * @return
    42. 	 * @throws SQLException
    43. 	 */
    44. 	public static Boolean crateTable(String tableName, String[] items) throws SQLException
    45. 	{
    46. 		Connection conn = null;
    47. 		Statement stmt = null;
    48. 		try
    49. 		{
    50. 			conn = H2ConnectionPool.getInstance().getConnection();
    51. 			DatabaseMetaData meta = conn.getMetaData();
    52.  
    53. 			ResultSet rsTables = meta.getTables(null, null, tableName, new String[] { "TABLE" });
    54. 			if (!rsTables.next())
    55. 			{
    56. 				stmt = conn.createStatement();
    57.  
    58. 				StringBuilder sql = new StringBuilder();
    59. 				sql.append(" CREATE TABLE IF NOT EXISTS ");
    60. 				if (StringUtils.isNotEmpty(tableName))
    61. 				{
    62. 					sql.append(tableName);
    63. 				}
    64. 				if (items != null && items.length > 0)
    65. 				{
    66. 					sql.append(" ( ");
    67. 					sql.append(" hid VARCHAR(1024), ");
    68. 					for (int i = 0; i < items.length; i++)
    69. 					{
    70. 						sql.append(items[i]);
    71. 						sql.append(" VARCHAR(5000), ");
    72. 					}
    73. 					sql.append("PRIMARY KEY(hid)) ");
    74. 				}
    75.  
    76. 				stmt.execute(sql.toString());
    77. 			}
    78. 			rsTables.close();
    79. 			return true;
    80. 		} finally
    81. 		{
    82. 			releaseConnection(conn, stmt, null);
    83. 		}
    84. 	}
    85. 	
    86. 	
    87. 	/**
    88. 	 * 建表方法
    89. 	 * 
    90. 	 * @param tableName
    91. 	 * @param items
    92. 	 * @return
    93. 	 * @throws SQLException
    94. 	 */
    95. 	public static Boolean crateTables(Map<String,String[]> tables) throws SQLException
    96. 	{
    97. 		Connection conn = null;
    98. 		Statement stmt = null;
    99. 		try
    100. 		{
    101. 			conn = H2ConnectionPool.getInstance().getConnection();
    102. 			DatabaseMetaData meta = conn.getMetaData();
    103.             for(Map.Entry<String,String[]> table : tables.entrySet())
    104.             {
    105.             	String tableName = table.getKey();
    106.             	logger.info("******创建数据库表："+tableName);
    107.             	String[] items= table.getValue();
    108.             	ResultSet rsTables = meta.getTables(null, null, tableName, new String[] { "TABLE" });
    109.     			if (!rsTables.next())
    110.     			{
    111.     				stmt = conn.createStatement();
    112.  
    113.     				StringBuilder sql = new StringBuilder();
    114.     				sql.append(" CREATE TABLE IF NOT EXISTS ");
    115.     				if (StringUtils.isNotEmpty(tableName))
    116.     				{
    117.     					sql.append(tableName);
    118.     				}
    119.     				if (items != null && items.length > 0)
    120.     				{
    121.     					sql.append(" ( ");
    122.     					sql.append(" hid VARCHAR(1024), ");
    123.     					for (int i = 0; i < items.length; i++)
    124.     					{
    125.     						sql.append(items[i]);
    126.     						sql.append(" VARCHAR(5000), ");
    127.     					}
    128.     					sql.append("PRIMARY KEY(hid)) ");
    129.     				}
    130.  
    131.     				stmt.execute(sql.toString());
    132.     			}
    133.     			rsTables.close();
    134.             }
    135. 			
    136. 			return true;
    137. 		} finally
    138. 		{
    139. 			releaseConnection(conn, stmt, null);
    140. 		}
    141. 	}
    142.  
    143. 	/**
    144. 	 * h2数据库插入数据
    145. 	 * 
    146. 	 * @param tableName
    147. 	 * @param items
    148. 	 * @param values
    149. 	 * @return
    150. 	 * @throws SQLException
    151. 	 */
    152. 	public static Boolean insertH2(String tableName, String[] items, String[] values) throws SQLException
    153. 	{
    154. 		Connection conn = null;
    155. 		PreparedStatement stmt = null;
    156. 		ResultSet rs = null;
    157. 		try
    158. 		{
    159. 			conn = H2ConnectionPool.getInstance().getConnection();
    160. 			StringBuilder sql = new StringBuilder();
    161. 			sql.append(" INSERT INTO ");
    162. 			if (StringUtils.isNotEmpty(tableName))
    163. 			{
    164. 				sql.append(tableName);
    165. 			}
    166. 			if (items != null && items.length > 0)
    167. 			{
    168. 				sql.append(" ( ");
    169. 				sql.append(" hid, ");
    170. 				String strItems = StringUtils.join(items, ",");
    171. 				sql.append(strItems);
    172. 				sql.append(" ) ");
    173. 				sql.append(" VALUES( ?,");
    174. 				for (int i = 0; i < items.length; i++)
    175. 				{
    176. 					sql.append("? ");
    177. 					if (i < items.length - 1)
    178. 					{
    179. 						sql.append(", ");
    180. 					}
    181. 				}
    182. 				sql.append(") ");
    183. 			}
    184.  
    185. 			stmt = conn.prepareStatement(sql.toString());
    186. 			// values
    187. 			stmt.setString(1, getUuid());
    188. 			if (values != null && values.length > 0)
    189. 			{
    190. 				for (int i = 0; i < values.length; i++)
    191. 				{
    192. 					stmt.setString(i + 2, values[i]);
    193. 				}
    194. 			}
    195. 			return stmt.execute();
    196. 		} finally
    197. 		{
    198. 			conn.commit();
    199. 			releaseConnection(conn, stmt, rs);
    200. 		}
    201. 	}
    202.  
    203. 	/**
    204. 	 * h2数据库插入数据
    205. 	 * 
    206. 	 * @param tableName
    207. 	 * @param items
    208. 	 * @param values
    209. 	 * @return
    210. 	 * @throws SQLException
    211. 	 */
    212. 	public static Boolean insertH2(String tableName, String[] items, Map<String, String[]> values) throws SQLException
    213. 	{
    214. 		Connection conn = null;
    215. 		PreparedStatement stmt = null;
    216. 		ResultSet rs = null;
    217. 		Boolean result = false;
    218. 		try
    219. 		{
    220. 			conn = H2ConnectionPool.getInstance().getConnection();
    221. 			for (Map.Entry<String, String[]> value : values.entrySet())
    222. 			{
    223. 				// String kpiCode = value.getKey();
    224. 				String[] kpiValue = value.getValue();
    225. 				StringBuilder sql = new StringBuilder();
    226. 				sql.append(" INSERT INTO ");
    227. 				if (StringUtils.isNotEmpty(tableName))
    228. 				{
    229. 					sql.append(tableName);
    230. 				}
    231. 				if (items != null && items.length > 0)
    232. 				{
    233. 					sql.append(" ( ");
    234. 					sql.append(" hid, ");
    235. 					String strItems = StringUtils.join(items, ",");
    236. 					sql.append(strItems);
    237. 					sql.append(" ) ");
    238. 					sql.append(" VALUES( ?,");
    239. 					for (int i = 0; i < items.length; i++)
    240. 					{
    241. 						sql.append("? ");
    242. 						if (i < items.length - 1)
    243. 						{
    244. 							sql.append(", ");
    245. 						}
    246. 					}
    247. 					sql.append(") ");
    248. 				}
    249.  
    250. 				stmt = conn.prepareStatement(sql.toString());
    251. 				// values
    252. 				stmt.setString(1, getUuid());
    253. 				if (kpiValue != null && kpiValue.length > 0)
    254. 				{
    255. 					for (int i = 0; i < kpiValue.length; i++)
    256. 					{
    257. 						stmt.setString(i + 2, kpiValue[i]);
    258. 					}
    259. 				}
    260. 				result = stmt.execute();
    261. 			}
    262. 			return result;
    263. 		} finally
    264. 		{
    265. 			conn.commit();
    266. 			releaseConnection(conn, stmt, rs);
    267. 		}
    268. 	}
    269. 	
    270. 	
    271. 	
    272. 	
    273. 	
    274. 	
    275. 	/**
    276. 	 * h2数据库更新数据
    277. 	 * 
    278. 	 * @param tableName
    279. 	 * @param items
    280. 	 * @param values
    281. 	 * @return
    282. 	 * @throws SQLException
    283. 	 */
    284. 	public static Boolean updateH2(String tableName, String[] items, Map<String, String[]> values,Map<String,String> params) throws SQLException
    285. 	{
    286. 		Connection conn = null;
    287. 		PreparedStatement stmt = null;
    288. 		ResultSet rs = null;
    289. 		Boolean result = false;
    290. 		try
    291. 		{
    292. 			conn = H2ConnectionPool.getInstance().getConnection();
    293. 			for (Map.Entry<String, String[]> value : values.entrySet())
    294. 			{
    295. 				String[] kpiValue = value.getValue();
    296. 				StringBuilder sql = new StringBuilder();
    297. 				StringBuilder dealSql =  new StringBuilder();
    298. 				sql.append(" UPDATE ");
    299. 				if (StringUtils.isNotEmpty(tableName))
    300. 				{
    301. 					sql.append(tableName);
    302. 				}
    303. 				if (items != null && items.length > 0)
    304. 				{
    305. 					sql.append(" SET ");
    306. 					for (int i = 0; i < items.length; i++)
    307. 					{
    308. 						sql.append(items[i] + "=?, ");
    309. 					}
    310. 					String strSql = sql.toString().trim();
    311. 					dealSql = new StringBuilder(strSql.substring(0, strSql.length()-1));
    312. 					dealSql.append("  WHERE ");
    313. 					
    314. 					for(Map.Entry<String, String> param : params.entrySet())
    315. 					{
    316. 						dealSql.append(param.getKey() + "='" + param.getValue()+"'");
    317. 					}
    318. 					
    319. 				}
    320.                
    321. 				
    322. 				logger.info(dealSql.toString());
    323. 				stmt = conn.prepareStatement(dealSql.toString());
    324. 				// values
    325. 				if (kpiValue != null && kpiValue.length > 0)
    326. 				{
    327. 					for (int i = 0; i < kpiValue.length; i++)
    328. 					{
    329. 						stmt.setString(i + 1, kpiValue[i]);
    330. 					}
    331. 				}
    332. 				result = stmt.execute();
    333. 			}
    334. 			return result;
    335. 		} finally
    336. 		{
    337. 			conn.commit();
    338. 			releaseConnection(conn, stmt, rs);
    339. 		}
    340. 	}
    341.  
    342. 	/**
    343. 	 * 查询方法
    344. 	 * 
    345. 	 * @param tableName
    346. 	 * @param items
    347. 	 * @param params
    348. 	 * @return
    349. 	 * @throws SQLException
    350. 	 */
    351. 	public static List<Map<String, String>> selectH2(String tableName, String[] items, Map<String, String> params)
    352. 			throws SQLException
    353. 	{
    354. 		Connection conn = null;
    355. 		PreparedStatement stmt = null;
    356. 		ResultSet rs = null;
    357. 		List<Map<String, String>> result = new ArrayList<Map<String, String>>();
    358. 		try
    359. 		{
    360. 			conn = H2ConnectionPool.getInstance().getConnection();
    361. 			StringBuilder sql = new StringBuilder();
    362. 			sql.append(" Select ");
    363. 			if (items != null && items.length > 0)
    364. 			{
    365. 				String strItems = StringUtils.join(items, ",");
    366. 				sql.append(strItems);
    367. 			}
    368. 			sql.append(" FROM ");
    369. 			if (StringUtils.isNotEmpty(tableName))
    370. 			{
    371. 				sql.append(tableName);
    372. 			}
    373. 			// 存在查询条件
    374. 			if (params != null && params.size() > 0)
    375. 			{
    376.  
    377. 				sql.append(" WHERE ");
    378. 				Set<String> kSet = params.keySet();
    379. 				for (String key : kSet)
    380. 				{
    381. 					sql.append(key);
    382. 					sql.append(" = ? and ");
    383. 				}
    384. 				sql.append("1 = 1");
    385. 			}
    386. 			stmt = conn.prepareStatement(sql.toString());
    387.  
    388. 			// 存在查询条件
    389. 			if (params != null && params.size() > 0)
    390. 			{
    391.  
    392. 				Set<String> kSet = params.keySet();
    393. 				Integer index = 1;
    394. 				for (String key : kSet)
    395. 				{
    396. 					stmt.setString(index, params.get(key));
    397. 					index++;
    398. 				}
    399. 			}
    400. 			rs = stmt.executeQuery();
    401. 			while (rs.next())
    402. 			{
    403.  
    404. 				Map<String, String> resultMap = new HashMap<String, String>();
    405. 				for (int i = 0; i < items.length; i++)
    406. 				{
    407. 					resultMap.put(items[i], rs.getString(items[i]));
    408. 				}
    409. 				result.add(resultMap);
    410. 			}
    411. 			return result;
    412. 		} finally
    413. 		{
    414. 			releaseConnection(conn, stmt, rs);
    415. 		}
    416. 	}
    417.  
    418. 	/**
    419. 	 * 自定义sql
    420. 	 * 
    421. 	 * @param sql
    422. 	 * @param items
    423. 	 * @param params
    424. 	 * @return
    425. 	 * @throws SQLException
    426. 	 */
    427. 	public static List<Map<String, String>> selectH2BySql(String sql, List<String> items, List<String> params)
    428. 			throws SQLException
    429. 	{
    430. 		Connection conn = null;
    431. 		PreparedStatement stmt = null;
    432. 		ResultSet rs = null;
    433. 		List<Map<String, String>> result = new ArrayList<Map<String, String>>();
    434. 		try
    435. 		{
    436. 			conn = H2ConnectionPool.getInstance().getConnection();
    437.  
    438. 			stmt = conn.prepareStatement(sql);
    439.  
    440. 			// 存在查询条件
    441. 			if (params != null && params.size() > 0)
    442. 			{
    443. 				for (int i = 0; i < params.size(); i++)
    444. 				{
    445. 					stmt.setString(i + 1, params.get(i));
    446. 				}
    447. 			}
    448. 			rs = stmt.executeQuery();
    449. 			while (rs.next())
    450. 			{
    451.  
    452. 				Map<String, String> resultMap = new HashMap<String, String>();
    453. 				for (int i = 0; i < items.size(); i++)
    454. 				{
    455. 					resultMap.put(items.get(i), rs.getString(items.get(i)));
    456. 				}
    457. 				result.add(resultMap);
    458. 			}
    459. 			return result;
    460. 		} finally
    461. 		{
    462. 			releaseConnection(conn, stmt, rs);
    463. 		}
    464. 	}
    465. 	
    466. 	
    467. 	/**
    468. 	 * 自定义sql
    469. 	 * 
    470. 	 * @param sql
    471. 	 * @param items
    472. 	 * @param params
    473. 	 * @return
    474. 	 * @throws SQLException
    475. 	 */
    476. 	public static boolean h2BySql(String sql)
    477. 			throws SQLException
    478. 	{
    479. 		Connection conn = null;
    480. 		PreparedStatement stmt = null;
    481. 		
    482. 		try
    483. 		{
    484. 			conn = H2ConnectionPool.getInstance().getConnection();
    485.  
    486. 			stmt = conn.prepareStatement(sql);
    487. 			
    488. 			return stmt.execute();
    489. 		} finally
    490. 		{
    491. 			releaseConnection(conn, stmt, null);
    492. 		}
    493. 	}
    494. 	
    495. 	
    496. 	/**
    497. 	 * 自定义sql
    498. 	 * 
    499. 	 * @param sql
    500. 	 * @param items
    501. 	 * @param params
    502. 	 * @return
    503. 	 * @throws SQLException
    504. 	 */
    505. 	public static boolean h2BySqls(List<String> sqls)
    506. 			throws SQLException
    507. 	{
    508. 		Connection conn = null;
    509. 		PreparedStatement stmt = null;
    510. 		
    511. 		try
    512. 		{
    513. 			conn = H2ConnectionPool.getInstance().getConnection();
    514.            
    515. 			boolean result = false;
    516. 			for(String sql : sqls)
    517. 			{
    518. 				stmt = conn.prepareStatement(sql);
    519. 				result = stmt.execute();
    520. 			}
    521. 			
    522. 			
    523. 			return result;
    524. 		} finally
    525. 		{
    526. 			releaseConnection(conn, stmt, null);
    527. 		}
    528. 	}
    529.  
    530. 	private static void releaseConnection(Connection conn, Statement stmt, ResultSet rs) throws SQLException
    531. 	{
    532. 		if (rs != null)
    533. 		{
    534. 			rs.close();
    535. 		}
    536. 		if (stmt != null)
    537. 		{
    538. 			stmt.close();
    539. 		}
    540. 		if (conn != null)
    541. 		{
    542. 			conn.close();
    543. 		}
    544. 	}
    545.  
    546. 	/**
    547. 	 * 删除表
    548. 	 * 
    549. 	 * @param tableName
    550. 	 * @param items
    551. 	 * @return
    552. 	 * @throws SQLException
    553. 	 */
    554. 	public static Boolean dropTable(String tableName) throws SQLException
    555. 	{
    556. 		Connection conn = null;
    557. 		Statement stmt = null;
    558. 		try
    559. 		{
    560. 			conn = H2ConnectionPool.getInstance().getConnection();
    561. 			DatabaseMetaData meta = conn.getMetaData();
    562.  
    563. 			ResultSet rsTables = meta.getTables(null, null, tableName, new String[] { "TABLE" });
    564. 			if (!rsTables.next())
    565. 			{
    566. 				stmt = conn.createStatement();
    567.  
    568. 				StringBuilder sql = new StringBuilder();
    569. 				sql.append(" DROP TABLE ");
    570. 				if (StringUtils.isNotEmpty(tableName))
    571. 				{
    572. 					sql.append(tableName);
    573. 				}
    574.                  sql.append("   IF EXISTS");
    575. 				stmt.execute(sql.toString());
    576. 			}
    577. 			rsTables.close();
    578. 			return true;
    579. 		} finally
    580. 		{
    581. 			releaseConnection(conn, stmt, null);
    582. 		}
    583. 	}
    584.  
    585. 	public static String getUuid()
    586. 	{
    587. 		return UUID.randomUUID().toString().replace("-", "");
    588. 	}
    589. }

     

    总结

以上只是笔者简单的对H2的使用，也只能说是带读者入门吧。如果想要了解更多H2的使用，可到官网上找资料，或下载使用文档http://www.h2database.com/h2.pdf 。