JDBC连接(MySql)数据库步骤,以及查询、插入、删除、更新等十一个处理数据库信息的功能。...

主要内容:

  •  JDBC连接数据库步骤。
  • 一个简单详细的查询数据的例子。
  • 封装连接数据库,释放数据库连接方法。
  • 实现查询,插入,删除,更新等十一个处理数据库信息的功能。(包括事务处理,批量更新等)
  • 把十一个功能都放在一起。
  • 安装下载的数据库驱动程序jar,不同的数据库需要不同的驱动程序(这本该是第一步,但是由于属于安装类,所以我们放在最后)

 一.JDBC连接数据库(编辑)步骤(主要有六个步骤)。

       1.注册驱动: Class.forName("com.mysql.jdbc.Driver");显示的加载到JVM中

       2.获取连接:(1) param1:  要连接数据库的url-----》 String url="jdbc:mysql://localhost:3306/test?"+ "useUnicode=true&characterEncoding=UTF8";//防止乱码

                            param2:要连接数据库的用户名--》 String user="h4"; 

                            param3:要连接数据库的密码----》 String pass="111"; 

                            Connection conn=DriverManager.getConnection(url,user,pass);//DriverManager下的方法:getConnection(String url,String username,String password)

                       (2)接下来我们分析下url:"jdbc(这是协议以jdbc开头):mysql(这是子协议,数据库管理系统名称)://localhost(数据库来源地址):3306(目标端口)/test(要查询的表)?"

                                                   "useUnicode=true&characterEncoding=UTF8";添加这个是为了防止乱码,指定使用Unicode字符集 ,且使用UTF-8来编辑。

       3.创建一个Statement语句对象(主要三种方法): Statement stmt=conn.createStatement();//Connection接口下的方法:Statement createStatement()

                                                                               PreparedStatement pstmt = conn.PreparedStatement() ;

                                                                  CallableStatement cstmt =  conn.prepareCall("{CALL demoSp(? , ?)}") ;

                                     下面我们来分析下他们:(1) Statement PreparedStatement对象的区别,后者可以动态设置查询参数

                                                  (2)设置参数的方法 PreparedStatement.setXXXX(parameterIndex,value),如果数据库参数类型是varchar 则用setString,如果参数类型是Integer 则用setInt

                                                                                                    (3)CallableStatement.setXXXX(parameterIndex,value)   //按照参数的顺序设置value

                                                                                                          CallableStatement.setXXXX(parameterName,value)  //按照参数的名字来设置value,这个名字是在定义存储过程的时候的形式参数的名字

                                                                                (4)CallableStatement.registerOutParameter方法用于声明一个存储过程输出类型的参数,用以接收存储过程的输出值

        4.执行SQL语句: ResultSet rs=stmt.executeQuery(Sql);除了查询语句是executeQuery();其他全部是executeUpdate();

                           Statement接口下的方法:

                                                                      boolean     execute(String sql):执行SQL语句,如果返回值是结果集则为true,否则为false

                                                                       ResultSet  executeQuery(String sql):执行SQL语句,返回值为ResultSet

                                                                       int            executeUpdate(String sql):执行SQL语句,返回值为所影响的行数

        5.处理结果集:ResultSet对象的getXxxx方法,取决于数据库中表的字段的类型,例如:varchar2  对应方法是getString ,如果是 integer 对应方法是getInt/getLong

                               While(rs.next()){

                                     rs.getInt(columnIndex);  //通过列的序号来获取字段的值

                                            rs.getString(columnName);//通过列的名字来获取字段的值

              ResultSet接口下常见的方法:beforeFirst();将游标移动到ResultSet中第一条记录(的前面)

                                          afterLast();将游标移动到ResultSet中最后一条记录(的后面)

                                          absolute(intcolumn):将游标移动到相对于第一行的指定行,负数则为相对于最后一条记录

                                          previous():将游标上移一行

                                          next():将游标下移一行

                                                                   ResultSet.TYPE_SCROLL_SENSITIVE          结果集可以滚动

                                                                   ResultSet.CONCUR_READ_ONLY   结果集只读,不能修改

           6.关闭资源: 操作完以后要关闭jdbc来释放jdbc资源。但是顺序要和你定义对象的时候相反,就像关门一样,从里面先关,一直往外关。

                       如下示例:

                                     if(rs !=null){//1.关闭结果集
                                             try{
                                                    rs.close();
                                                } catch (SQLException e){
                                                     e.printStackTrace();
                                               }
                                           }
                                   if(stmt !=null){//2.关闭声明的对象
                                            try{
                                                  stmt.close();
                                              }catch(SQLException e){
                                                    e.printStackTrace();
                                                  }
                                           }
                                   if(conn !=null){//3.关闭连接 (记住一定要先关闭前面的1.2.然后在关闭连接)
                                           try{
                                                 conn.close();
                                           }catch(Exception e){
                                              e.printStackTrace();
                                             }
                                        }
       

 


                             
二.下面是一个简单的(详细的)查询数据的例子。

 1 package javacore1;//这是你建的一个包名。
 2 
 3 import java.sql.CallableStatement;
 4 import java.sql.Connection;
 5 import java.sql.DriverManager;
 6 import java.sql.PreparedStatement;
 7 import java.sql.ResultSet;         //左边这五个是你在写程序时要导入的包名,记住是要在java.sql下的包。
 8 import java.sql.SQLException;
 9 import java.sql.Statement;
10 public class jdbc { //定义一个类
11    public static void main(String[] args){ //主方法
12       try{
13           String driver="com.mysql.jdbc.Driver";              //1.定义驱动程序名为driver内容为com.mysql.jdbc.Driver
14           String url="jdbc:mysql://localhost:3306/test?"      //2.定义url;jdbc是协议;mysql是子协议:表示数据库系统管理名称;localhost:3306是你数据库来源的地址和目标端口;test是我本人建的表位置所在处,你以你的为标准。
15                   + "useUnicode=true&characterEncoding=UTF8"; //防止乱码;useUnicode=true表示使用Unicode字符集;characterEncoding=UTF8表示使用UTF-8来编辑的。
16           String user="h4";                                   //3.定义用户名,写你想要连接到的用户。
17           String pass="111";                                  //4.用户密码。
18           String querySql="select * from employees";          //5.你想要查找的表名。
19           Class.forName(driver);                              //6.注册驱动程序,用java.lang包下面的class类里面的Class.froName();方法 此处的driver就是1里面定义的driver,也可以  Class.forName("com.mysql.jdbc.Driver");
21           Connection conn=DriverManager.getConnection(url,user,pass);//7.获取数据库连接,使用java.sql里面的DriverManager的getConnectin(String url , String username ,String password )来完成
22                                                                              //括号里面的url,user,pass便是前面定义的2,3,4步骤内容;
23           Statement stmt=conn.createStatement();   //8.构造一个statement对象来执行sql语句:主要有Statement,PreparedStatement,CallableStatement三种实例来实现
24                                                    //    三种实现方法分别为:Statement stmt = con.createStatement() ;  
25                                                      //                   PreparedStatement pstmt = conn.prepareStatement(sql) ;   
26                                                      //                   CallableStatement cstmt =  conn.prepareCall("{CALL demoSp(? , ?)}") ;
27           ResultSet rs=stmt.executeQuery(querySql);//9.执行sql并返还结束 ;ResultSet executeQuery(String sqlString):用于返还一个结果集(ResultSet)对象。
28      while(rs.next()){    //10.遍历结果集 
29           System.out.println("人员编号:"+rs.getString("employee_id")+"工资:"+rs.getString("salary")+"姓名:"+rs.getString("last_name"));//使用getString()方法获取你表里的资料名
30            }
31      if(rs !=null){//11.关闭记录集
32           try{
33               rs.close();
34           } catch (SQLException e){
35             e.printStackTrace();
36            }
37          }
38      if(stmt !=null){//12.关闭声明的对象
39           try{
40               stmt.close();
41           }catch(SQLException e){
42            e.printStackTrace();
43            }
44          }
45      if(conn !=null){//13.关闭连接 (记住一定要先关闭前面的11.12.然后在关闭连接,就像关门一样,先关里面的,最后关最外面的)
46           try{
47               conn.close();
48           }catch(SQLException e){
49             e.printStackTrace();
50           }
51         }
52           }catch(Exception e){
53            e.printStackTrace();
54           }
55         }
56     }

 三.为了更加直观,我们把获取数据库连接和释放连接封装在方法里,以便于后面更好的操作。

 1 package javacore1;
 2 
 3 import java.sql.Connection;
 4 import java.sql.DriverManager;
 5 
 6 public class jdbc{
 7     public static void main(String[] args){
 8           
 9     Connection conn= getConnection("h4", "111"); //获取数据库连接
10 
11     /*,,,,此处为方法名来获取连接,例如 query(conn),,,,,*/
12     
13         releaseConnection(conn); // 释放数据库连接
14    }
15      
16     /*,,,,,,,,,,此处构建一个你想要的功能的方法,,,,,,,,,,,,*/
17 
18 
19 //数据库连接
20 public static Connection getConnection(String user, String pass) {
21              
22               Connection conn = null;//声明连接对象
23               String driver = "com.mysql.jdbc.Driver";// 驱动程序类名
24               String url = "jdbc:mysql://localhost:3306/test?" // 数据库URL
25                          + "useUnicode=true&characterEncoding=UTF8";// 防止乱码
26        try {
27             Class.forName(driver);// 注册(加载)驱动程序
28             conn = DriverManager.getConnection(url, user, pass);// 获取数据库连接
29            } catch (Exception e) {
30              e.printStackTrace();
31           }
32             return conn;
33          }
34 // 释放数据库连接
35 public static void releaseConnection(Connection conn) {
36          try {
37               if (conn != null)
38                    conn.close();
39              } catch (Exception e) {
40                e.printStackTrace();
41              }
42          }
43      }

四.实现查询、插入、删除、更新等十一个处理数据库信息的功能。

1.查询数据

 1 package javacore1;
 2 import java.sql.Connection;
 3 import java.sql.DriverManager;
 4 import java.sql.ResultSet;
 5 import java.sql.SQLException;
 6 import java.sql.Statement;
 7 public class Query {
 8     public static void main(String[] args) {
 9         Connection conn = getConnection("h4", "111");// 获取数据库连接
10             query(conn);     //方法名调用数据库连接
11         releaseConnection(conn);//释放数据库连接
12   }
13 //查询数据,定义的query方法
14 public static void query(Connection conn){
15         String Sql="select * from employees";
16         try{
17             Statement stmt=conn.createStatement(); //也可以使用PreparedStatement来做
18             ResultSet rs=stmt.executeQuery(Sql);//执行sql语句并返还结束
19                                                                        
20        while(rs.next()){//遍历结果集 ,向下一行                              
21             System.out.println("人员编号:"+rs.getString("employee_id")+"工资:"+rs.getString("salary"));
22             }
23           if(rs !=null){
24             try{
25                 rs.close();
26             } catch (SQLException e){
27             e.printStackTrace();
28            }
29         }
30         if(stmt !=null){
31             try{
32                stmt.close();
33             }catch(SQLException e){
34              e.printStackTrace();
35           }
36         }
37         if(conn !=null){
38             try{
39                 conn.close();
40                }catch(SQLException e){
41                 e.printStackTrace();
42             }
43         }
44      }catch(Exception e){
45        e.printStackTrace();
46      }
47  }
48 //数据库连接
49   public static Connection getConnection(String user, String pass) {
50             Connection conn = null;//声明连接对象
51             String driver = "com.mysql.jdbc.Driver";// 驱动程序类名
52             String url = "jdbc:mysql://localhost:3306/test?" // 数据库URL
53                        + "useUnicode=true&characterEncoding=UTF8";// 防止乱码
54      try {
55           Class.forName(driver);// 注册(加载)驱动程序
56           conn = DriverManager.getConnection(url, user, pass);// 获取数据库连接
57          } catch (Exception e) {
58            e.printStackTrace();
59         }
60           return conn;
61        }
62 //释放数据库连接
63   public static void releaseConnection(Connection conn) {
64        try {
65             if (conn != null)
66                  conn.close();
67            } catch (Exception e) {
68              e.printStackTrace();
69            }
70        }
71    }
//查询数据,结果倒着显示,倒序
package javacore1;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class Query {public static void main(String[] args) {Connection conn = getConnection("h4", "111");// 获取数据库连接query(conn);     //方法名调用数据库连接releaseConnection(conn);//释放数据库连接
  }
//查询数据,定义的query方法
public static void query(Connection conn){String Sql="select * from employees";try{Statement stmt=conn.createStatement(); //也可以使用PreparedStatement来做ResultSet rs=stmt.executeQuery(Sql);//执行sql语句并返还结束
            rs.afterLast();     //先跳到最后一行                                  while(rs.previous()){//遍历结果集 ,向上一行                              System.out.println("人员编号:"+rs.getString("employee_id")+"工资:"+rs.getString("salary"));}if(rs !=null){try{rs.close();} catch (SQLException e){e.printStackTrace();}}if(stmt !=null){try{stmt.close();}catch(SQLException e){e.printStackTrace();}}if(conn !=null){try{conn.close();}catch(SQLException e){e.printStackTrace();}}}catch(Exception e){e.printStackTrace();}}
//数据库连接public static Connection getConnection(String user, String pass) {Connection conn = null;//声明连接对象String driver = "com.mysql.jdbc.Driver";// 驱动程序类名String url = "jdbc:mysql://localhost:3306/test?" // 数据库URL+ "useUnicode=true&characterEncoding=UTF8";// 防止乱码try {Class.forName(driver);// 注册(加载)驱动程序conn = DriverManager.getConnection(url, user, pass);// 获取数据库连接} catch (Exception e) {e.printStackTrace();}return conn;}
//释放数据库连接public static void releaseConnection(Connection conn) {try {if (conn != null)conn.close();} catch (Exception e) {e.printStackTrace();}}}

 2.插入数据

 1 package javacore1;
 2 import java.sql.Connection;
 3 import java.sql.DriverManager;
 4 import java.sql.SQLException;
 5 import java.sql.Statement;
 6 public class Insert {
 7     public static void main(String[] args) {
 8         Connection conn = getConnection("h3", "111111");    // 获取数据库连接
 9             insert(conn);    //方法名调用数据库连接
10         releaseConnection(conn);// 释放数据库连接
11       }
12 //插入数据    
13      public static void insert(Connection conn) {  
14             try {  
15                   String sql = "insert into employees(employee_id,last_name,salary,department_id,userid)"  
16                         + " values ('100010', 'xiaogou', '7000','004','9')"; // 插入数据的sql语句  
17                   Statement stmt1 =conn.createStatement();    // 创建用于执行静态sql语句的Statement对象  
18                   int count = stmt1.executeUpdate(sql);  // 执行插入操作的sql语句,并返回插入数据的个数       
19                System.out.println("向biao中插入了 " + count + " 条数据"); //输出插入操作的处理结果  
20                conn.close();   //关闭数据库连接  
21                 } catch (SQLException e) {  
22                   e.printStackTrace(); 
23              }  
24         }      
25 //数据库连接
26     public static Connection getConnection(String user, String pass) {
27             Connection conn = null;//声明连接对象
28             String driver = "com.mysql.jdbc.Driver";// 驱动程序类名
29             String url = "jdbc:mysql://localhost:3306/test?" // 数据库URL
30                     + "useUnicode=true&characterEncoding=UTF8";// 防止乱码
31             try {
32                 Class.forName(driver);// 注册(加载)驱动程序
33                 conn = DriverManager.getConnection(url, user, pass);// 获取数据库连接
34             } catch (Exception e) {
35                 e.printStackTrace();
36             }
37              return conn;
38         }
39 //释放数据库连接
40     public static void releaseConnection(Connection conn) {
41             try {
42                 if (conn != null)
43                     conn.close();
44             } catch (Exception e) {
45                 e.printStackTrace();
46             }
47        }
48 }

3.删除数据

 1 package javacore1;
 2 import java.sql.Connection;
 3 import java.sql.DriverManager;
 4 import java.sql.SQLException;
 5 import java.sql.Statement;
 6 public class Delete {
 7     public static void main(String[] args) {
 8         Connection conn = getConnection("h3", "111111");    // 获取数据库连接
 9              delete(conn);    //方法名调用数据库连接;
10         releaseConnection(conn);// 释放数据库连接
11 }
12 //删除数据
13     public static void delete(Connection conn){
14         String Sql = "delete  from employees  where employee_id=100009";
15     try {
16          Statement stmt = conn.createStatement();// 或者用PreparedStatement方法
17          stmt.executeUpdate(Sql);//执行sql语句
18     if (stmt != null) {
19     try {
20          stmt.close();
21          } catch (SQLException e) {
22          e.printStackTrace();
23          }
24        }
25     } catch (SQLException e) {
26          e.printStackTrace();
27        }
28         
29     }
30 //数据库连接
31     public static Connection getConnection(String user, String pass) {
32         Connection conn = null;//声明连接对象
33         String driver = "com.mysql.jdbc.Driver";// 驱动程序类名
34         String url = "jdbc:mysql://localhost:3306/test?" // 数据库URL
35                 + "useUnicode=true&characterEncoding=UTF8";// 防止乱码
36         try {
37             Class.forName(driver);// 注册(加载)驱动程序
38             conn = DriverManager.getConnection(url, user, pass);// 获取数据库连接
39         } catch (Exception e) {
40             e.printStackTrace();
41         }
42         return conn;
43     }
44 // 释放数据库连接
45     public static void releaseConnection(Connection conn) {
46         try {
47             if (conn != null)
48                 conn.close();
49         } catch (Exception e) {
50             e.printStackTrace();
51         }
52     }
53 }

4.更新数据

 1 package javacore1;
 2 import java.sql.Connection;
 3 import java.sql.DriverManager;
 4 import java.sql.SQLException;
 5 import java.sql.Statement;
 6 public class Update {
 7     public static void main(String[] args) {
 8          Connection conn = getConnection("h3", "111111");    // 获取数据库连接
 9              update(conn);     //方法名调用数据库连接
10          releaseConnection(conn);// 释放数据库连接
11      }
12 //更新数据  
13   public static void update(Connection conn){
14           String Sql = "update  employees set salary=8000 where employee_id=100005";
15     try {
16          Statement stmt1 = conn.createStatement();//或者用PreparedStatement方法
17          stmt1.executeUpdate(Sql);//执行sql语句
18     if (stmt1 != null) {
19          try {
20             stmt1.close();
21          } catch (SQLException e) {
22             e.printStackTrace();
23          }
24      }
25         } catch (SQLException e) {
26            e.printStackTrace();
27          }
28       }
29 //数据库连接
30     public static Connection getConnection(String user, String pass) {
31         Connection conn = null;//声明连接对象
32         String driver = "com.mysql.jdbc.Driver";// 驱动程序类名
33         String url = "jdbc:mysql://localhost:3306/test?" // 数据库URL
34                 + "useUnicode=true&characterEncoding=UTF8";// 防止乱码
35         try {
36             Class.forName(driver);// 注册(加载)驱动程序
37             conn = DriverManager.getConnection(url, user, pass);// 获取数据库连接
38         } catch (Exception e) {
39             e.printStackTrace();
40         }
41          return conn;
42     }
43 // 释放数据库连接
44     public static void releaseConnection(Connection conn) {
45         try {
46             if (conn != null)
47                 conn.close();
48         } catch (Exception e) {
49             e.printStackTrace();
50         }
51     }
52 }

5.转账(事物处理)

JDBC处理事务通过关闭连接的自动提交实现的:

    Connection.setAutoCommit(false);
提交事务:
    Connection.commit();
回滚事务
    回滚部分:
       Connection.rollback(Savepoint);
   全部回滚:
      Connection.rollback();

 1 package javacore1;
 2 import java.sql.Connection;
 3 import java.sql.DriverManager;
 4 import java.sql.Statement;
 5 public class TransCash {
 6     public static void main(String[] args) {
 7         Connection conn = getConnection("h3", "111111");// 获取数据库连接
 8             transCash(conn);   //方法名调用数据库连接
 9         releaseConnection(conn);// 释放数据库连接
10   }
11 //转账(数据调换)(原来数据为100和500,实现这个功能后变成500和100,其实说白了就是更新数据,改数据)
12   public static void transCash(Connection conn){
13         Statement stmt = null;
14     try{
15           conn.setAutoCommit(false);//关闭自动提交
16             String sql = "update employees set salary=500 where employee_id=100001";
17             stmt = conn.createStatement();
18             stmt.executeUpdate(sql);            
19                   sql = "update employees set salary=100 where employee_id=100002";
20             stmt.executeUpdate(sql);//执行sql语句,上面的两个工资将会调换

//int i=1/0;如果这样,那么将不可以完成任务,因为这是一个完整的事物,有一点失败,将全部失败 21 conn.commit();//提交事务 22 }catch(Exception e){ 23 e.printStackTrace(); 24 }finally{ 25 try{ 26 if(stmt != null){ stmt.close(); 27 }catch(Exception e){ 28 e.printStackTrace(); 29 } 30 } 31 } 32 //数据库连接 33 public static Connection getConnection(String user, String pass) { 34 Connection conn = null;//声明连接对象 35 String driver = "com.mysql.jdbc.Driver";// 驱动程序类名 36 String url = "jdbc:mysql://localhost:3306/test?" // 数据库URL 37 + "useUnicode=true&characterEncoding=UTF8";// 防止乱码 38 try { 39 Class.forName(driver);// 注册(加载)驱动程序 40 conn = DriverManager.getConnection(url, user, pass);// 获取数据库连接 41 } catch (Exception e) { 42 e.printStackTrace(); 43 } 44 return conn; 45 } 46 //释放数据库连接 47 public static void releaseConnection(Connection conn) { 48 try { 49 if (conn != null) 50 conn.close(); 51 } catch (Exception e) { 52 e.printStackTrace(); 53 } 54 } 55 }

6.查找存储过程无参数的

 1 package javacore1;
 2 import java.sql.CallableStatement;
 3 import java.sql.Connection;
 4 import java.sql.DriverManager;
 5 import java.sql.SQLException;
 6 public class ExecProc {
 7     public static void main(String[] args) {
 8         Connection conn = getConnection("h3", "111111");    // 获取数据库连接
 9            execProc(conn);//方法名调用数据库连接
10         releaseConnection(conn);// 释放数据库连接
11     }
12 //调用无参存储过程;
13       public static void execProc(Connection conn){
14                String sql = "{call raisesalary}";
15           try {
16               CallableStatement cstmt = conn.prepareCall(sql);
17               cstmt.executeUpdate();
18           } catch (SQLException e) {
19             e.printStackTrace();
20           }
21        }
22 //数据库连接
23         public static Connection getConnection(String user, String pass) {
24                 Connection conn = null;//声明连接对象
25                 String driver = "com.mysql.jdbc.Driver";// 驱动程序类名
26                 String url = "jdbc:mysql://localhost:3306/test?" // 数据库URL
27                         + "useUnicode=true&characterEncoding=UTF8";// 防止乱码
28                 try {
29                     Class.forName(driver);// 注册(加载)驱动程序
30                     conn = DriverManager.getConnection(url, user, pass);// 获取数据库连接
31                 } catch (Exception e) {
32                     e.printStackTrace();
33                 }
34                  return conn;
35             }
36 // 释放数据库连接
37         public static void releaseConnection(Connection conn) {
38                 try {
39                     if (conn != null)
40                         conn.close();
41                 } catch (Exception e) {
42                     e.printStackTrace();
43                 }
44            }
45     }

7.查找存储过程有参数的  

 1 package javacore1;
 2 import java.sql.CallableStatement;
 3 import java.sql.Connection;
 4 import java.sql.DriverManager;
 5 import java.sql.Types;
 6 public class GetMulti {
 7     public static void main(String[] args) {
 8          Connection conn = getConnection("h3", "111111");    // 获取数据库连接
 9             int cnt = getMulti(conn);            //查找存储过程;   
10             System.out.println("人员编号:" + cnt); 
11          releaseConnection(conn);// 释放数据库连接
12     }
13 //查找存储过程有参
14     public static int getMulti(Connection conn) {
15            int dept_id = 100001;
16            int cnt = 0;
17            String sql = "{call calc_emp_count(?,?)}";
18         try {
19               CallableStatement cstmt = conn.prepareCall(sql);//初始化Statement对象
20               cstmt.setInt(1, dept_id);//CallableStatement.setxxx(参数,值)或者(数字,值),而PreparedStatement.setxxx(数字,值)只能这样
21               cstmt.setInt(2, cnt);    //
22               cstmt.registerOutParameter(2, Types.INTEGER);//声明输出参数
23               cstmt.executeUpdate();//执行sql语句
24               cnt = cstmt.getInt(2);//获取结果
25           if (cstmt != null) {
26                 cstmt.close();// 释放Statement对象
27               }
28             } catch (Exception e) {
29               e.printStackTrace();
30           }
31            return cnt;
32       }
33 //数据库连接
34     public static Connection getConnection(String user, String pass) {
35             Connection conn = null;//声明连接对象
36             String driver = "com.mysql.jdbc.Driver";// 驱动程序类名
37             String url = "jdbc:mysql://localhost:3306/test?" // 数据库URL
38                     + "useUnicode=true&characterEncoding=UTF8";// 防止乱码
39             try {
40                 Class.forName(driver);// 注册(加载)驱动程序
41                 conn = DriverManager.getConnection(url, user, pass);// 获取数据库连接
42             } catch (Exception e) {
43                 e.printStackTrace();
44             }
45              return conn;
46         }
47 //释放数据库连接
48     public static void releaseConnection(Connection conn) {
49             try {
50                 if (conn != null)
51                     conn.close();
52             } catch (Exception e) {
53                 e.printStackTrace();
54             }
55        }
56 }

8.普通处理

 1 package javacore1;
 2 import java.sql.Connection;
 3 import java.sql.Date;
 4 import java.sql.DriverManager;
 5 import java.sql.PreparedStatement;
 6 import java.sql.SQLException;
 7 public class PlanInsert {
 8     public static void main(String[] args) {
 9         Connection conn = getConnection("h3", "111111");    // 获取数据库连接
10            planInsert(conn);    //方法名调用数据库连接
11         releaseConnection(conn);// 释放数据库连接
12       }
13 //普通处理
14      public static void planInsert(Connection conn) {  
15          try {  
16                String sql = "insert into test_user1(userid,username,loadingtime)"  
17                      + " values (?,?,?)"; // 插入数据的sql语句  
18                PreparedStatement pstmt=conn.prepareStatement(sql);
19                long startTime=System.currentTimeMillis();
20              for(int i=0;i<1000;i++){
21                  pstmt.setLong(1, i);
22                  pstmt.setString(2, "user"+i);
23                  pstmt.setDate(3, new Date(System.currentTimeMillis()));
24                  pstmt.executeUpdate();
25              }
26          System.out.println("总共耗时:"+(System.currentTimeMillis() - startTime));
27                pstmt.close();   //关闭数据库连接  
28            } catch (SQLException e) {  
29              e.printStackTrace(); 
30          } 
31      }    
32 //数据库连接
33     public static Connection getConnection(String user, String pass) {
34             Connection conn = null;//声明连接对象
35             String driver = "com.mysql.jdbc.Driver";// 驱动程序类名
36             String url = "jdbc:mysql://localhost:3306/test?" // 数据库URL
37                     + "useUnicode=true&characterEncoding=UTF8";// 防止乱码
38             try {
39                 Class.forName(driver);// 注册(加载)驱动程序
40                 conn = DriverManager.getConnection(url, user, pass);// 获取数据库连接
41             } catch (Exception e) {
42                 e.printStackTrace();
43             }
44              return conn;
45         }
46 //释放数据库连接
47     public static void releaseConnection(Connection conn) {
48             try {
49                 if (conn != null)
50                     conn.close();
51             } catch (Exception e) {
52                 e.printStackTrace();
53             }
54        }
55 }

9.批量处理

获得原来JDBC事务的模式:

boolean currentTransactionModle = con.getAutoCommit();

设置成事务模式(关闭自动提交):
con.setAutoCommit(false);
Statement stm = con.createStatement();
三个异构的sql语句:
String sql1 = "delete from user where id = 8";
String sql2 = "update user set name='java' where id = 7";
String sql3 = "insert into user(name,password) values('jdbc','jdbc')";
添加到Statement的批量处理缓冲区中:
stm.addBatch(sql1);
stm.addBatch(sql2);
stm.addBatch(sql3);
执行批量更新:
stm.executeBatch();
提交本次批量更新的事务:
con.commit();
回复原来的事务模式:
con.setAutoCommit(currentTransactionModle);

 1 package javacore1;
 2 import java.sql.Connection;
 3 import java.sql.Date;
 4 import java.sql.DriverManager;
 5 import java.sql.PreparedStatement;
 6 import java.sql.SQLException;
 7 public class BatchInsert {
 8     public static void main(String[] args) {
 9         Connection conn = getConnection("h3", "111111");    // 获取数据库连接
10            batchInsert(conn);    //方法名调用数据库连接
11         releaseConnection(conn);// 释放数据库连接
12       }
13 //批量插入的速度要比普通处理的速度快
14      public static void batchInsert(Connection conn) {  
15          try {  
16                String sql = "insert into test_user1(userid,username,loadingtime)"  
17                      + " values (?,?,?)"; // 插入数据的sql语句  
18                PreparedStatement pstmt=conn.prepareStatement(sql);
19                long startTime=System.currentTimeMillis();
20              for(int i=0;i<1000;i++){
21                  pstmt.setLong(1, i);
22                  pstmt.setString(2, "user"+i);
23                  pstmt.setDate(3, new Date(System.currentTimeMillis()));
24                  pstmt.addBatch();//添加到批量处理
25              }
26              int[] result=pstmt.executeBatch();
27           System.out.println("总共耗时:"+(System.currentTimeMillis() - startTime));
28              pstmt.close();   //关闭数据库连接  
29           } catch (SQLException e) {  
30              e.printStackTrace(); 
31          } 
32      }    
33 //数据库连接
34     public static Connection getConnection(String user, String pass) {
35             Connection conn = null;//声明连接对象
36             String driver = "com.mysql.jdbc.Driver";// 驱动程序类名
37             String url = "jdbc:mysql://localhost:3306/test?" // 数据库URL
38                     + "useUnicode=true&characterEncoding=UTF8";// 防止乱码
39             try {
40                 Class.forName(driver);// 注册(加载)驱动程序
41                 conn = DriverManager.getConnection(url, user, pass);// 获取数据库连接
42             } catch (Exception e) {
43                 e.printStackTrace();
44             }
45              return conn;
46         }
47 //释放数据库连接
48     public static void releaseConnection(Connection conn) {
49             try {
50                 if (conn != null)
51                     conn.close();
52             } catch (Exception e) {
53                 e.printStackTrace();
54             }
55        }
56 }

10.分页显示

 1 package javacore1;
 2 import java.sql.Connection;
 3 import java.sql.DriverManager;
 4 import java.sql.PreparedStatement;
 5 import java.sql.ResultSet;
 6 import java.sql.SQLException;
 7 public class Paging {
 8     public static void main(String[] args) {
 9         Connection conn = getConnection("h3", "111111");    // 获取数据库连接
10             paging(conn,1,3);//方法名调用数据库连接,且定义显示第几行到第几行
11         releaseConnection(conn);// 释放数据库连接
12    }
13 //分页查询
14     public static void paging(Connection conn,int startIndex,int total){
15         try{
16             String sql="select * from employees limit ?,?";
17             PreparedStatement pstmt=conn.prepareStatement(sql);
18             pstmt.setInt(1, startIndex);
19             pstmt.setInt(2, total);
20             ResultSet rs=pstmt.executeQuery();
21         while(rs.next()){
22                 System.out.print("工号:"+rs.getInt(1));
23                System.out.println("部门编号:"+rs.getInt("department_id"));
24             }rs.close();
25             pstmt.close();
26           }catch(SQLException e){
27             e.printStackTrace();
28         }
29     }
30 //数据库连接
31     public static Connection getConnection(String user, String pass) {
32             Connection conn = null;//声明连接对象
33             String driver = "com.mysql.jdbc.Driver";// 驱动程序类名
34             String url = "jdbc:mysql://localhost:3306/test?" // 数据库URL
35                     + "useUnicode=true&characterEncoding=UTF8";// 防止乱码
36             try {
37                 Class.forName(driver);// 注册(加载)驱动程序
38                 conn = DriverManager.getConnection(url, user, pass);// 获取数据库连接
39             } catch (Exception e) {
40                 e.printStackTrace();
41             }
42              return conn;
43         }
44 // 释放数据库连接
45     public static void releaseConnection(Connection conn) {
46             try {
47                 if (conn != null)
48                     conn.close();
49             } catch (Exception e) {
50                 e.printStackTrace();
51             }
52        }
53 }

11.结果集可以滚动

 1 package javacore1;
 2 import java.sql.Connection;
 3 import java.sql.DriverManager;
 4 import java.sql.PreparedStatement;
 5 import java.sql.ResultSet;
 6 import java.sql.SQLException;
 7 public class ScrpllResult {
 8     public static void main(String[] args) {
 9           Connection conn = getConnection("h3", "111111");    // 获取数据库连接
10              scrpllResult(conn);//方法名调用数据库连接
11           releaseConnection(conn);// 释放数据库连接
12       }
13 //结果集滚动显示
14     public static void scrpllResult(Connection conn){
15         try{
16             String sql="select * from employees";                         //结果集可以滚动      //并发性,结果集只读,不可以修改
17             PreparedStatement pstmt=conn.prepareStatement(sql, ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_READ_ONLY);
18             ResultSet rs=pstmt.executeQuery();
19         while(rs.next()){  //向下一行遍历
20                 System.out.print("工号:"+rs.getLong(1));
21                 System.out.println("名字"+rs.getString("last_name"));
22            }while(rs.previous()){//向上一行遍历
23                 System.out.print("工号:"+rs.getLong(1));
24                 System.out.println("工资"+rs.getInt("salary"));
25              }
26                rs.absolute(6);//表示直接跳到第几行
27             if(rs.next()){
28                 System.out.print("工号:"+rs.getLong(1));
29                 System.out.println("..........部门编号:"+rs.getString("department_id"));
30               }
31                 rs.close();
32                 pstmt.close();
33             }catch(SQLException e){
34                 e.printStackTrace();
35             }
36         }    
37 //数据库连接
38     public static Connection getConnection(String user, String pass) {
39             Connection conn = null;//声明连接对象
40             String driver = "com.mysql.jdbc.Driver";// 驱动程序类名
41             String url = "jdbc:mysql://localhost:3306/test?" // 数据库URL
42                     + "useUnicode=true&characterEncoding=UTF8";// 防止乱码
43             try {
44                 Class.forName(driver);// 注册(加载)驱动程序
45                 conn = DriverManager.getConnection(url, user, pass);// 获取数据库连接
46             } catch (Exception e) {
47                 e.printStackTrace();
48             }
49              return conn;
50         }
51 // 释放数据库连接
52     public static void releaseConnection(Connection conn) {
53             try {
54                 if (conn != null)
55                     conn.close();
56             } catch (Exception e) {
57                 e.printStackTrace();
58             }
59        }
60 }

五.把上面十一个放在一起当然最方便省事。(需要用谁,只需把前面的注释打开便行)

  1 package javacore1;
  2 import java.sql.CallableStatement;
  3 import java.sql.Connection;
  4 import java.sql.Date;
  5 import java.sql.DriverManager;
  6 import java.sql.PreparedStatement;
  7 import java.sql.ResultSet;
  8 import java.sql.SQLException;
  9 import java.sql.Statement;
 10 import java.sql.Types;
 11 public class jdbcMySql {
 12 public static void main(String[] args) {
 13     Connection conn = getConnection("h3", "111111");    // 获取数据库连接
 14            //query(conn); //1.查询数据
 15            //insert(conn);//2.插入数据
 16            //delete(conn);//3.删除数据
 17            //update(conn);//4.更新数据
 18            //transCash(conn);//5.转账
 19            //execProc(conn);//6.查找存储过程无参数的
 20            //int cnt = getMulti(conn);//7.查找存储过程有参数的   
 21            //System.out.println("人员编号:" + cnt);//查找存储过程有参数的
 22            //planInsert(conn);//8.普通处理
 23            //batchInsert(conn);//9.批量处理
 24            // paging(conn,1,3);//10.分页显示
 25            //scrpllResult(conn);//11.结果集可以滚动
 26         releaseConnection(conn);// 释放数据库连接
 27      }
 28 //1.查询数据,定义的query方法
 29 public static void query(Connection conn){
 30         String Sql="select * from employees";
 31         try{
 32             Statement stmt=conn.createStatement(); //也可以使用PreparedStatement来做
 33           ResultSet rs=stmt.executeQuery(Sql);//执行sql语句并返还结束
 34                                                    
 35      while(rs.next()){//遍历结果集                               
 36             System.out.println("人员编号:"+rs.getString("employee_id")+"工资:"+rs.getString("salary"));
 37             }
 38           if(rs !=null){
 39             try{
 40                 rs.close();
 41             } catch (SQLException e){
 42             e.printStackTrace();
 43            }
 44         }
 45         if(stmt !=null){
 46             try{
 47                stmt.close();
 48             }catch(SQLException e){
 49              e.printStackTrace();
 50           }
 51         }
 52         if(conn !=null){
 53             try{
 54                 conn.close();
 55                }catch(SQLException e){
 56                 e.printStackTrace();
 57             }
 58         }
 59      }catch(Exception e){
 60        e.printStackTrace();
 61      }
 62 }
 63 //2.插入数据    
 64      public static void insert(Connection conn) {  
 65             try {  
 66                   String sql = "insert into employees(employee_id,last_name,salary,department_id,userid)"  
 67                         + " values ('100010', 'xiaogou', '7000','004','9')"; // 插入数据的sql语句  
 68                   Statement stmt1 =conn.createStatement();    // 创建用于执行静态sql语句的Statement对象  
 69                   int count = stmt1.executeUpdate(sql);  // 执行插入操作的sql语句,并返回插入数据的个数       
 70                System.out.println("向biao中插入了 " + count + " 条数据"); //输出插入操作的处理结果  
 71                conn.close();   //关闭数据库连接  
 72                 } catch (SQLException e) {  
 73                   e.printStackTrace(); 
 74              }  
 75         }
 76 //3.删除数据
 77     public static void delete(Connection conn){
 78             String Sql = "delete  from employees  where employee_id=100009";
 79         try {
 80              Statement stmt = conn.createStatement();// 或者用PreparedStatement方法
 81              stmt.executeUpdate(Sql);//执行sql语句
 82         if (stmt != null) {
 83         try {
 84              stmt.close();
 85              } catch (SQLException e) {
 86              e.printStackTrace();
 87              }
 88            }
 89         } catch (SQLException e) {
 90              e.printStackTrace();
 91            }
 92             
 93         }
 94 //4.更新数据  
 95     public static void update(Connection conn){
 96               String Sql = "update  employees set salary=8000 where employee_id=100005";
 97         try {
 98              Statement stmt1 = conn.createStatement();//或者用PreparedStatement方法
 99              stmt1.executeUpdate(Sql);//执行sql语句
100         if (stmt1 != null) {
101              try {
102                 stmt1.close();
103              } catch (SQLException e) {
104                 e.printStackTrace();
105              }
106          }
107             } catch (SQLException e) {
108                e.printStackTrace();
109              }
110           }    
111 //5.转账(数据调换)(原来数据为100和500,实现这个功能后变成500和100,其实说白了就是更新数据,改数据)
112   public static void transCash(Connection conn){
113             Statement stmt = null;
114         try{
115               conn.setAutoCommit(false);//关闭自动提交
116                 String sql = "update employees set salary=500 where employee_id=100001";
117                 stmt = conn.createStatement();
118                 stmt.executeUpdate(sql);            
119                       sql = "update employees set salary=100 where employee_id=100002";
120                 stmt.executeUpdate(sql);//执行sql语句,上面的两个工资将会调换
121               conn.commit();//提交事务
122            }catch(Exception e){
123              e.printStackTrace();
124            }finally{
125         try{
126              if(stmt != null)stmt.close();
127                 }catch(Exception e){
128                   e.printStackTrace();
129                 }
130               }
131             }
132 //6.调用无参存储过程;
133   public static void execProc(Connection conn){
134            String sql = "{call raisesalary}";
135       try {
136           CallableStatement cstmt = conn.prepareCall(sql);
137           cstmt.executeUpdate();
138       } catch (SQLException e) {
139         e.printStackTrace();
140       }
141    } 
142 //7.查找存储过程有参
143   public static int getMulti(Connection conn) {
144            int dept_id = 100001;
145            int cnt = 0;
146            String sql = "{call calc_emp_count(?,?)}";
147         try {
148               CallableStatement cstmt = conn.prepareCall(sql);//初始化Statement对象
149               cstmt.setInt(1, dept_id);//CallableStatement.setxxx(参数,值)或者(数字,值),而PreparedStatement.setxxx(数字,值)只能这样
150               cstmt.setInt(2, cnt);    //
151               cstmt.registerOutParameter(2, Types.INTEGER);//声明输出参数
152               cstmt.executeUpdate();//执行sql语句
153               cnt = cstmt.getInt(2);//获取结果
154           if (cstmt != null) {
155                 cstmt.close();// 释放Statement对象
156               }
157             } catch (Exception e) {
158               e.printStackTrace();
159           }
160            return cnt;
161       }
162 //8.普通处理
163      public static void planInsert(Connection conn) {  
164          try {  
165                String sql = "insert into test_user1(userid,username,loadingtime)"  
166                      + " values (?,?,?)"; // 插入数据的sql语句  
167                PreparedStatement pstmt=conn.prepareStatement(sql);
168                long startTime=System.currentTimeMillis();
169              for(int i=0;i<1000;i++){
170                  pstmt.setLong(1, i);
171                  pstmt.setString(2, "user"+i);
172                  pstmt.setDate(3, new Date(System.currentTimeMillis()));
173                  pstmt.executeUpdate();
174              }
175          System.out.println("总共耗时:"+(System.currentTimeMillis() - startTime));
176                pstmt.close();   //关闭数据库连接  
177            } catch (SQLException e) {  
178              e.printStackTrace(); 
179          } 
180      } 
181 //9.批量插入的速度要比普通处理的速度快
182     public static void batchInsert(Connection conn) {  
183              try {  
184                    String sql = "insert into test_user1(userid,username,loadingtime)"  
185                          + " values (?,?,?)"; // 插入数据的sql语句  
186                    PreparedStatement pstmt=conn.prepareStatement(sql);
187                    long startTime=System.currentTimeMillis();
188                  for(int i=0;i<1000;i++){
189                      pstmt.setLong(1, i);
190                      pstmt.setString(2, "user"+i);
191                      pstmt.setDate(3, new Date(System.currentTimeMillis()));
192                      pstmt.addBatch();//添加到批量处理
193                  }
194                  int[] result=pstmt.executeBatch();
195               System.out.println("总共耗时:"+(System.currentTimeMillis() - startTime));
196                  pstmt.close();   //关闭数据库连接  
197               } catch (SQLException e) {  
198                  e.printStackTrace(); 
199              } 
200          }
201 //10.分页查询
202    public static void paging(Connection conn,int startIndex,int total){
203             try{
204                 String sql="select * from employees limit ?,?";
205                 PreparedStatement pstmt=conn.prepareStatement(sql);
206                 pstmt.setInt(1, startIndex);
207                 pstmt.setInt(2, total);
208                 ResultSet rs=pstmt.executeQuery();
209             while(rs.next()){
210                     System.out.print("工号:"+rs.getInt(1));
211                    System.out.println("部门编号:"+rs.getInt("department_id"));
212                 }rs.close();
213                 pstmt.close();
214               }catch(SQLException e){
215                 e.printStackTrace();
216             }
217         }
218 //11.结果集滚动显示
219      public static void scrpllResult(Connection conn){
220          try{
221              String sql="select * from employees";                         //结果集可以滚动                                               //并发性,结果集只读,不可以修改
222              PreparedStatement pstmt=conn.prepareStatement(sql, ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_READ_ONLY);
223              ResultSet rs=pstmt.executeQuery();
224          while(rs.next()){  //向下一行遍历
225                  System.out.print("工号:"+rs.getLong(1));
226                  System.out.println("名字"+rs.getString("last_name"));
227             }while(rs.previous()){//向上一行遍历
228                  System.out.print("工号:"+rs.getLong(1));
229                  System.out.println("工资"+rs.getInt("salary"));
230               }
231                 rs.absolute(6);//表示直接跳到第几行
232              if(rs.next()){
233                  System.out.print("工号:"+rs.getLong(1));
234                  System.out.println("..........部门编号:"+rs.getString("department_id"));
235                }
236                  rs.close();
237                  pstmt.close();
238              }catch(SQLException e){
239                  e.printStackTrace();
240              }
241          } 
242 //数据库连接
243 public static Connection getConnection(String user, String pass) {
244           Connection conn = null;//声明连接对象
245           String driver = "com.mysql.jdbc.Driver";// 驱动程序类名
246           String url = "jdbc:mysql://localhost:3306/test?" // 数据库URL
247                      + "useUnicode=true&characterEncoding=UTF8";// 防止乱码
248    try {
249         Class.forName(driver);// 注册(加载)驱动程序
250         conn = DriverManager.getConnection(url, user, pass);// 获取数据库连接
251        } catch (Exception e) {
252          e.printStackTrace();
253       }
254         return conn;
255      }
256 //释放数据库连接
257 public static void releaseConnection(Connection conn) {
258      try {
259           if (conn != null)
260                conn.close();
261          } catch (Exception e) {
262            e.printStackTrace();
263          }
264      }
265  }

 六.安装下载的数据库驱动程序jar包,不同的数据库需要不同的驱动程序(但是安装方法都是一样的)

在使用JDBC编程时需要连接数据库,导入JAR包是必须的,导入其它的jar包方法同样如此,导入的方法是 

打开eclipse
1.右击要导入jar包的项目,点properties 

2.左边选择java build path,右边选择libraries 

3.选择add External jars 

4.选择jar包的按照路径下的
确定后就行了。

Java连接MySQL的最新驱动包下载地址 

http://www.mysql.com/downloads/connector/j

 

1.鼠标放在你建的根目录上面。右击,然后选择最下面的properties

 

2.然后左边选择java build path,右边选择libraries ,在选择右边的add External jars ,选择jar包的路径,点击确定就可以了

 

3.装好后,图如下出现你要添加的包。

 

转载于:https://www.cnblogs.com/wuziyue/p/4827295.html

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/news/375503.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

C++学习笔记25,析构函数总是会宣布virtual

为了永远记住析构函数声明virtual----><<effective c>> 为这句话不一定对,但无需质疑的是这句话是非常实用的. 查看以下的样例: #include <iostream> #include <string> using namespace std; class B{ public:~B(){cout<<"base is dest…

各大互联网公司2014前端笔试面试题–JavaScript篇

很多面试题是我自己面试BAT亲身经历碰到的。整理分享出来希望更多的前端er共同进步吧&#xff0c;不仅适用于求职者&#xff0c;对于巩固复习js更是大有裨益。 而更多的题目是我一路以来收集的&#xff0c;也有往年的&#xff0c;答案不确保一定正确&#xff0c;如有错误或有更…

iOS:苹果企业证书通过网页分发安装app

本文转载至 http://blog.sina.com.cn/s/blog_6afb7d800101fa16.html 苹果的企业级证书发布的应用&#xff0c;是不用设备授权即可直接安装&#xff0c;并且不限设备上限。为了方便分发&#xff0c;苹果有协议实现通过网页链接直接下载安装企业级的应用。 基本的原理就是在生成企…

这道题很难

请编写一个函数&#xff0c;使其可以删除某个链表中给定的&#xff08;非末尾&#xff09;节点。传入函数的唯一参数为 要被删除的节点 。 现有一个链表 – head [4,5,1,9]&#xff0c;它可以表示为: 示例 1&#xff1a; 输入&#xff1a;head [4,5,1,9], node 5 输出&a…

设计模式学习笔记-基础知识篇

1. 设计模式的重要性 1.1 设计模式解决的是在软件过程中如何来实现具体的软件功能。实现同一个功能的方法有很多&#xff0c;哪个设计容易扩展&#xff0c;容易复用&#xff0c;松耦合&#xff0c;可维护&#xff1f;设计模式指导我们找到最优方案。 1.2 设计中往往会存在设计缺…

内心的平静就是财富本身-Cell组件-用友华表的由来-T君

时至今日&#xff0c;Cell组件仍是应用广泛的商业报表组件 作者&#xff1a;人生三毒 编者注&#xff1a;本文作者人生三毒为知名网站及网页游戏公司创始人&#xff0c;此前曾为IT类媒体资深编辑&#xff0c;见证了中国互联网早期的发展。 认识T君之前先认识的是他的软件&#…

C++实现一个http服务器

一个简单的博客后端服务器 github地址&#xff0c;持续更新 设计参考 #define MYSQLPP_MYSQL_HEADERS_BURIED #include "httplib.h" #include "rapidjson/document.h" #include <mysql/mysql.h> #include <iostream> #include <string>…

KMP算法的java实现

package com.trs.utils;public class KMPStr {/** 在KMP算法中&#xff0c;最难求的就是next函数&#xff0c;如何理解next函数是一个难题&#xff0c;特别是knext[k]&#xff0c;这里* 需要指出的是当p[i]!p[j]时&#xff0c;我们只有通过回溯将k的值逐渐减小&#xff0c;貌似…

线段分割法实现微信抢红包

无意间看到的一种实现抢红包的方法&#xff0c;于是用C实现了一下。 将一个红包分成 n 份 具体的思路是&#xff0c;将一个红包看作是一个线段&#xff0c;线段的长就是红包总金额&#xff0c;然后在这个线段上随机切 n-1 刀&#xff0c;分成 n 份&#xff0c;然后抢红包的人依…

C++雪花算法实现

看来一下雪花算法的实现方法&#xff0c;用 c试着实现了一下&#xff0c;这里仅仅是实现了算法的流程&#xff0c;但是具体的细节&#xff0c;如并发、多线程访问等等没有具体考虑。 雪花算法的简单讲解参考 #include <sys/select.h> #include <iostream> #includ…

CAlayer层的属性

iOS开发UI篇—CAlayer层的属性 一、position和anchorPoint 1.简单介绍 CALayer有2个非常重要的属性&#xff1a;position和anchorPoint property CGPoint position; 用来设置CALayer在父层中的位置 以父层的左上角为原点(0, 0) property CGPoint anchorPoint; 称为“定位点”、…

Odoo9发行说明

2015年10月1日&#xff0c;期待已久的Odoo9正式发布。本文是Odoo9正式版发行说明&#xff0c;基于官网资料翻译。 译者: 苏州-微尘原文地址&#xff1a;https://www.odoo.com/page/odoo-9-release-notes译文地址&#xff1a;http://blog.csdn.net/wangnan537/article/details/4…

揭秘史上最完美一步到位的搭建Andoriod开发环境

Windows环境下Android开发环境搭建虽然不难而且网上资料众多&#xff0c;但是众多资料如出一折 忽略了很多细节&#xff0c;最终还是没能达到满意效果。 基本步骤如下&#xff1a;JDK安装、环境变量配置、Eclipse下载、AndoriodSDK下载安装、下载配置ADT但是到这里还不算完美搞…

【SQL】服务器环境下的SQL

一、大型数据库的三层体系结构 web服务器&#xff1a;比如在淘宝页面上&#xff0c;输入“牛肉干”&#xff0c;就是web服务器来处理&#xff0c;提交给应用服务器。 应用服务器&#xff1a;在获取到“牛肉干”这个请求后&#xff0c;应用服务器决定如何汇集结果&#xff0c;并…

即时聊天IM之二 openfire 整合现有系统用户

合肥程序员群&#xff1a;49313181。 合肥实名程序员群&#xff1a;128131462 (不愿透露姓名和信息者勿加入) Q Q:408365330 E-Mail:egojitqq.com 综述&#xff1a; 每天利用中午时间更新下这个知识点的的博客如果感兴趣的觉得更新慢了也别介意&#xff08;其它时间还是…

C#在ASP.NET4.5框架下的首次网页应用

运行效果预览: 先看实践应用要求: 1&#xff0e;编写一个函数&#xff0c;用于计算1&#xff01;2&#xff01;3&#xff01;4&#xff01;5&#xff01;&#xff0c;在控制台或页面输出运行结果。 2&#xff0e;在控制台或页面输出九九乘法表。 3&#xff0e;输入10个以内的整…

Android-Universal-Image-Loader三大组件DisplayImageOptions、ImageLoader、ImageLoaderConfiguration详解...

转 一、介绍 Android-Universal-Image-Loader是 一个开源的UI组件程序&#xff0c;该项目的目的是提供一个可重复使用的仪器为异步图像加载&#xff0c;缓存和显示。所以&#xff0c;如果你的程序里需要这个功能的话&#xff0c;那么不妨试试它。 因为已经封装好了一些类和方法…

Java小知识

内部类分为: 成员内部类、静态嵌套类、方法内部类、匿名内部类。(1)、内部类仍然是一个独立的类&#xff0c;在编译之后内部类会被编译成独立的.class文件&#xff0c;但是前面冠以外部类的类名和$符号。(2)、内部类不能用普通的方式访问。成员变量成员变量静态成员变量。List遍…

初识EL

一、EL函数库介绍 由于在JSP页面中显示数据时&#xff0c;经常需要对显示的字符串进行处理&#xff0c;SUN公司针对于一些常见处理定义了一套EL函数库供开发者使用。  这些EL函数在JSTL开发包中进行描述&#xff0c;因此在JSP页面中使用SUN公司的EL函数库&#xff0c;需要导入…

Scala学习笔记-环境搭建以及简单语法

关于环境的搭建&#xff0c;去官网下载JDK8和Scala的IDE就可以了&#xff0c;Scala的IDE是基于Eclipse的。 下面直接上代码&#xff1a; 这是项目目录&#xff1a; A是scala写的&#xff1a; package first import scala.collection.mutable.ListBufferobject A {def main(args…