JDBC

JDBC数据库操作

MYSQL数据库特点：开放源代码的关系型数据库系统，目前很多大公司都在使用。适用于所有平台，支持多线程，充分利用CPU资源，性能不错。价格便宜，对于大数据，包含5千万个记录的数据库使用mysql完全没有问题。

mysql命令行连接： mysql -hlocalhost -uroot -p123456

JDBC:为java开发者使用数据库提供了统一的编程接口，它由一组JAVA类和接口组成。凡是数据库想与JAVA进行连接的，数据库厂商必须实现JDBC这套接口，而数据库厂商的JDBC实现即是此数据库的数据库驱动。

访问数据库流程：1，加载JDBC驱动。2.建立数据库连接。3.发送SQL语句。4.查询结果

Statement接口。

用于执行静态SQL语句并返回它所生成结果的对象。

三种Statement类：

    statement:由createStatement创建，用于发送简单SQL，不带参数

    PreparedStatement:用于发送含有一个或多个参数的SQL语句，比statement效率更高，并可防止SQL注入，一般都使用

    CallableStatement:用于调用存储过程。

常用方法：

    execute():运行语句，返回是否有结果集

    executeQuery():运行select语句，返回ResultSet结果集。

    executeUpdate()运行insert/delete/update操作，返回更新的行数。

ResultSet结果集：：：：

1. package test;
2. import java.sql.Connection;
3. import java.sql.DriverManager;
4. import java.sql.PreparedStatement;
5. import java.sql.ResultSet;
6. import java.sql.Statement;
7. public class TEst {
8. public static void main(String[] args) throws Exception{
9. //加载驱动类，反射加载类,Driver接口
10. Class.forName("com.mysql.jdbc.Driver");
11. //DriverManager接口,建立连接.建立连接是比较耗时的操作，有时候能达到1s
12. //真正开发中，后期都通过连接池来做。为了提高效率。
13. Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test","root","root");
14. //Statement接口
15. Statement stmt = conn.createStatement();
16. String sql = "insert into user(age) values (1)";
17. stmt.execute(sql);
18. //测试SQL注入
19. String id = "5 or 1=1";//恶意代码SQL注入，也可以update
20. String sql2 = "delete from user where id="+id;
21. //为了避免SQL注入问题，使用PreparedStatement
22. String sql3 ="insert into user(age) values (?)";
23. PreparedStatement pstmt = conn.prepareStatement(sql3);
24. pstmt.setInt(1, 2);//第一个?
25. pstmt.execute();//是否有结果集对象
26. //
27. String sql4 = "select * from user";
28. pstmt = conn.prepareStatement(sql4);
29. ResultSet rs = pstmt.executeQuery();
30. while(rs.next()){
31. System.out.println(rs.getInt(1));//取出第一列
32. }
33. //关闭所有对象
34. rs.close();
35. pstmt.close();
36. conn.close();
37. }
38. }
批处理：：：：：
对于批量处理，建议使用statement,而不要使用preparedStatement。
1. public class TEst {
2. public static void main(String[] args) throws Exception{
3. //加载驱动类，反射加载类,Driver接口
4. Class.forName("com.mysql.jdbc.Driver");
5. //DriverManager接口,建立连接.建立连接是比较耗时的操作，有时候能达到1s
6. //真正开发中，后期都通过连接池来做。为了提高效率。
7. Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test","root","root");
8. //Statement接口
9. conn.setAutoCommit(false);//设置事务手动提交
10. Statement stmt = conn.createStatement();
11. for (int i = 0; i < 20000; i++) {
12. stmt.addBatch("insert in to user(age) values("+i+")");
13. }
14. stmt.executeBatch();
15. conn.commit();
16. }
17. }
时间类型：：：：：
java.util.Date
子类：java.sql.Date（年月日）    java.sql.Time（时分秒）    java.sql.Timestamp（年月日时分秒）
取出指定时间段内的记录：：
1. public class TEst {
2. public static void main(String[] args) throws Exception{
3. //加载驱动类，反射加载类,Driver接口
4. Class.forName("com.mysql.jdbc.Driver");
5. //DriverManager接口,建立连接.建立连接是比较耗时的操作，有时候能达到1s
6. //真正开发中，后期都通过连接池来做。为了提高效率。
7. Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test","root","root");
8. //Statement接口
9. PreparedStatement pstmt = conn.prepareStatement("select * from user where regTime > ?");
10. java.sql.Date date = new java.sql.Date(str2Date("2015-4-10 10:34:54"));
11. pstmt.setObject(1, date);
12. ResultSet rs = pstmt.executeQuery();
13. while (rs.next()) {
14. System.out.println(rs.getInt("id"));
15. }
16. }
17. public static long str2Date(String s){
18. DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
19. try {
20. return df.parse(s).getTime();
21. } catch (ParseException e) {
22. // TODO Auto-generated catch block
23. e.printStackTrace();
24. }
25. return 0L;
26. }
27. }

CLOB：：：：：文本大对象，用于存储大量的文本数据。大字段有些特殊，大字段的操作通常是以流的方式处理。
相关类型：TINYTEXT:最大长度为255字符的TEXT列
                  TEXT：65535字符
                  MEDIUMTEXT:16777215字符
                  LONGTEXT:4GB字符
1. public static void main(String[] args) throws Exception{
2. //加载驱动类，反射加载类,Driver接口
3. Class.forName("com.mysql.jdbc.Driver");
4. //DriverManager接口,建立连接.建立连接是比较耗时的操作，有时候能达到1s
5. //真正开发中，后期都通过连接池来做。为了提高效率。
6. Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test","root","root");
7. //Statement接口
8. PreparedStatement pstmt = conn.prepareStatement("insert into user(age,myInfo) values(?,?)");
9. pstmt.setInt(1, 10);
10. pstmt.setClob(2, new FileReader(new File("d:/a.txt")));//将文本文件内容直接输入到数据库中
11. //添加字符串
12. pstmt.setClob(1, new BufferedReader(new InputStreamReader(new ByteArrayInputStream("aaaabbbbb".getBytes()))));
13. //把CLOB数据读出来
14. pstmt = conn.prepareStatement("select * from user where id =?");
15. pstmt.setObject(1, 1);
16. ResultSet rs = pstmt.executeQuery();
17. while (rs.next()) {
18. Clob c = rs.getClob("myInfo");
19. Reader reader = c.getCharacterStream();
20. int temp = 0;
21. while ((temp = reader.read()) != -1) {
22. System.out.println((char)temp);
23. }
24. }
25. }
BLOB:二进制大对象
实际开发，会把大的文件，视频，音乐放到文件服务器上。
1. public static void main(String[] args) throws Exception{
2. //加载驱动类，反射加载类,Driver接口
3. Class.forName("com.mysql.jdbc.Driver");
4. //DriverManager接口,建立连接.建立连接是比较耗时的操作，有时候能达到1s
5. //真正开发中，后期都通过连接池来做。为了提高效率。
6. Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test","root","root");
7. //Statement接口
8. PreparedStatement pstmt = conn.prepareStatement("insert into user(age,myInfo) values(?,?)");
9. pstmt.setInt(1, 10);
10. pstmt.setBlob(2, new FileInputStream(new File("d:/a.jpg")));//将文本文件内容直接输入到数据库中
11. //添加字符串
12. //pstmt.setClob(1, new BufferedReader(new InputStreamReader(new ByteArrayInputStream("aaaabbbbb".getBytes()))));
13. //把CLOB数据读出来
14. pstmt = conn.prepareStatement("select * from user where id =?");
15. pstmt.setObject(1, 1);
16. ResultSet rs = pstmt.executeQuery();
17. while (rs.next()) {
18. Blob c = rs.getBlob("myInfo");
19. InputStream is = c.getBinaryStream();
20. OutputStream os = new FileOutputStream(new File("d:/b.jpg"));
21. os.write(c.getBytes(0, (int) c.length()));
22. }
23. }
经典JDBC代码总结：：
1. public class TEst {
2. static Properties pros = null;
3. static{
4. pros = new Properties();
5. try {
6. pros.load(Thread.currentThread().getContextClassLoader().getResourceAsStream("db.properties"));//真正在bin目录下去读
7. } catch (IOException e) {
8. e.printStackTrace();
9. }
10. }
11. public static void main(String[] args) throws Exception{
12. //加载驱动类，反射加载类,Driver接口
13. Class.forName(pros.getProperty("mysqlDriver"));
14. //DriverManager接口,建立连接.建立连接是比较耗时的操作，有时候能达到1s
15. //真正开发中，后期都通过连接池来做。为了提高效率。
16. Connection conn = DriverManager.getConnection(pros.getProperty("mysqlURL"),"root","root");
17. //Statement接口
18. PreparedStatement pstmt = conn.prepareStatement("insert into user(age,myInfo) values(?,?)");
19. pstmt.setInt(1, 10);
20. }
21. }
1. userName=root
2. mysqlDriver=com.mysql.jdbc.Driver
3. mysqlURL=jdbc\:mysql\://localhost\:3306/test
ORM基本思想：：
表结构和类对应，表中字段和类的属性对应。表中记录和对象对应。
让JAVABEAN的属性名和类型尽量与数据库保持一致。
一条记录对应一个对象，将这些查询到的对象放到容器中。(list,set,map)

将表中的一条记录封装到object数组中。
将表中的一条记录封装到map中。
将表中的一条记录封装到javabean对象中。
1. package test;
2. import java.io.IOException;
3. import java.sql.Connection;
4. import java.sql.DriverManager;
5. import java.sql.PreparedStatement;
6. import java.sql.ResultSet;
7. import java.util.ArrayList;
8. import java.util.List;
9. import java.util.Properties;
10. public class TEst {
11. static Properties pros = null;
12. static{
13. pros = new Properties();
14. try {
15. pros.load(Thread.currentThread().getContextClassLoader().getResourceAsStream("db.properties"));//真正在bin目录下去读
16. } catch (IOException e) {
17. e.printStackTrace();
18. } 
19. } 
20. public static void main(String[] args) throws Exception{
21. Class.forName(pros.getProperty("mysqlDriver"));
22. Connection conn = DriverManager.getConnection(pros.getProperty("mysqlURL"),"root","root");
23. PreparedStatement pstmt = conn.prepareStatement("select empname,salary,age from emp");
24. ResultSet rs = pstmt.executeQuery();
25. List<Object[]> list = new ArrayList<>();//所有记录放到一个list中0
26. Object[] obj = new Object[4];//一条记录放到一个object数组中
27. while (rs.next()) {
28. obj[1] = rs.getObject(1);
29. obj[3] = rs.getObject(2);
30. obj[2] = rs.getObject(3);
31. list.add(obj);
32. }
33. rs.close();
34. pstmt.close();
35. conn.close();
36. }
37. }
1. package test;
2. import java.io.IOException;
3. import java.sql.Connection;
4. import java.sql.DriverManager;
5. import java.sql.PreparedStatement;
6. import java.sql.ResultSet;
7. import java.util.ArrayList;
8. import java.util.HashMap;
9. import java.util.List;
10. import java.util.Map;
11. import java.util.Properties;
12. public class TEst {
13. static Properties pros = null;
14. static{
15. pros = new Properties();
16. try {
17. pros.load(Thread.currentThread().getContextClassLoader().getResourceAsStream("db.properties"));//真正在bin目录下去读
18. } catch (IOException e) {
19. e.printStackTrace();
20. } 
21. } 
22. public static void main(String[] args) throws Exception{
23. Class.forName(pros.getProperty("mysqlDriver"));
24. Connection conn = DriverManager.getConnection(pros.getProperty("mysqlURL"),"root","root");
25. PreparedStatement pstmt = conn.prepareStatement("select empname,salary,age from emp");
26. ResultSet rs = pstmt.executeQuery();
27. List<Map<String, Object>> list = new ArrayList<>();//所有记录放到一个list中0
28. Map<String, Object> row = new HashMap<String, Object>();
29. while (rs.next()) {
30. row.put("empname", rs.getObject(1));
31. row.put("salary", rs.getObject(2));
32. row.put("age", rs.getObject(3));
33. list.add(row);
34. for(String key : row.keySet()){
35. System.out.println(key+"----"+row.get(key));
36. }
37. }
38. System.out.println(list.size());
39. rs.close();
40. pstmt.close();
41. conn.close();
42. }