Android之jdbc的学习

2021-10-29 14:07:06

1.什么是jdbc:
根据Sun的声明，JDBC是一个商标的术语，并非Java DataBase Connectivity。但将其当成Java DataBase Connectivity更容易理解。jdbc是java程序访问数据库的一套接口，它结合了SQL语句。因为市场上有多种数据库，他们的访问协议不同，因此数据访问方式不同。针对于这种情况，java提供了驱动管理器与数据库驱动的概念，访问方式有数据库驱动提供，是具体的数据库厂商写的。而java程序需要哪种方式访问数据库，只需要将这种数据库的驱动注册到驱动管理器就ok了(这样java程序才知道以何种方式访问数据库)。
2.jdbc的操作步骤
（1）注册jdbc驱动：向java驱动管理器注册使用的数据库驱动。
（2）连接数据库：建立通信，先接通才能操作数据库。
（3）操作数据库：增，删，改，查等。
（4）关闭数据库。
以MySql为例：
1.先要下载mysql数据库的驱动：
http://pan.baidu.com/share/link?shareid=1725761810&uk=3056808396
将其加载到编写的java工程中，刚测试了下载Android无法使用jdbc访问数据，报一大堆错误，看*上说建议使用webservice访问数据库。


2.编写代码：
（1）注册jdbc驱动

 

[java] view plaincopy
 
  1. // 向驱动管理器注册一个jdbc驱动  
  2.             Class.forName(driver).newInstance();  
  3.             System.out.println("驱动注册成功");  


（2）连接数据库：建立通信，先接通才能操作数据库。

[java] view plaincopy
 
  1. conn = DriverManager.getConnection(url, username, password);  
  2.             System.out.println("获取链接成功");  


(3)操作数据库：增，删，改，查等。

[java] view plaincopy
 
  1. //实现增删改  
  2. public boolean updateDB(String sql, List<Object> params)  
  3.     {  
  4.         boolean retFlag = false;  
  5.         try  
  6.         {  
  7.             pstm = conn.prepareStatement(sql);  
  8.             // notice:if(params !=null && !params.equals(""))这个要加上，避免params为空  
  9.             if (params != null && !params.equals(""))  
  10.             {  
  11.                 for (int i = 0; i < params.size(); i++)  
  12.                 {  
  13.                     pstm.setObject(i + 1, params.get(i));  
  14.                 }  
  15.             }  
  16.             return pstm.executeUpdate() > 0 ? true : false;  
  17.         }  
  18.         catch (SQLException e)  
  19.         {  
  20.             e.printStackTrace();  
  21.         }  
  22.           
  23.         return retFlag;  
  24.     }  
  25.     //实现查询  
  26.     public Map<String, Object> QueryDB(String sql, List<Object> params)  
  27.     {  
  28.         Map<String, Object> map = null;  
  29.         try  
  30.         {  
  31.             pstm = conn.prepareStatement(sql);  
  32.             if (params != null && !params.equals(""))  
  33.             {  
  34.                 for (int i = 0; i < params.size(); i++)  
  35.                 {  
  36.                     pstm.setObject(i + 1, params.get(i));  
  37.                 }  
  38.             }  
  39.             rs = pstm.executeQuery();  
  40.             ResultSetMetaData rsMetaData = rs.getMetaData();  
  41.             while (rs.next())  
  42.             {  
  43.                 map = new HashMap<String, Object>();  
  44.                 for (int i = 0; i < rsMetaData.getColumnCount(); i++)  
  45.                 {  
  46.                     String columnName = rsMetaData.getColumnName(i + 1);  
  47.                     Object columnVal = rs.getObject(i + 1);  
  48.                     // 数据库中的值可能为空  
  49.                     if (columnVal == null)  
  50.                     {  
  51.                         columnVal = "";  
  52.                     }  
  53.                     map.put(columnName, columnVal);  
  54.                 }  
  55.                   
  56.             }  
  57.         }  
  58.         catch (SQLException e)  
  59.         {  
  60.             // TODO Auto-generated catch block  
  61.             e.printStackTrace();  
  62.         }  
  63.           
  64.         return map;  
  65.           
  66.     }  
  67.       
  68.     // 这个完全可以代替单个查询  
  69.     public List<Map<String, Object>> QueryMoreDB(String sql, List<Object> params)  
  70.     {  
  71.         List<Map<String, Object>> retList = new ArrayList<Map<String, Object>>();  
  72.         try  
  73.         {  
  74.             pstm = conn.prepareStatement(sql);  
  75.             if (params != null && !params.equals(""))  
  76.             {  
  77.                 for (int i = 0; i < params.size(); i++)  
  78.                 {  
  79.                     pstm.setObject(i + 1, params.get(i));  
  80.                 }  
  81.             }  
  82.               
  83.             ResultSet rs = pstm.executeQuery();  
  84.             ResultSetMetaData rsMetaData = rs.getMetaData();  
  85.             while (rs.next())  
  86.             {  
  87.                 Map<String, Object> map = new HashMap<String, Object>();  
  88.                 for (int i = 0; i < rsMetaData.getColumnCount(); i++)  
  89.                 {  
  90.                     String columnName = rsMetaData.getColumnName(i + 1);  
  91.                     Object columnVal = rs.getObject(i + 1);  
  92.                     if (columnVal == null)  
  93.                     {  
  94.                         columnVal = "";  
  95.                     }  
  96.                     map.put(columnName, columnVal);  
  97.                 }  
  98.                 retList.add(map);  
  99.             }  
  100.         }  
  101.         catch (SQLException e)  
  102.         {  
  103.             e.printStackTrace();  
  104.         }  
  105.         return retList;  
  106.     }  
  107.       
  108.     // 利用反射机制实现数据库的操作  
  109.     public <T> T QueryDBObj(String sql, List<Object> params, Class<T> cls)  
  110.     {  
  111.         T t = null;  
  112.         try  
  113.         {  
  114.             pstm = conn.prepareStatement(sql);  
  115.             if (params != null && !params.equals(""))  
  116.             {  
  117.                 for (int i = 0; i < params.size(); i++)  
  118.                 {  
  119.                     pstm.setObject(i + 1, params.get(i));  
  120.                 }  
  121.             }  
  122.             rs = pstm.executeQuery();  
  123.             ResultSetMetaData rsMetaData = rs.getMetaData();  
  124.             while (rs.next())  
  125.             {  
  126.                 t = cls.newInstance();  
  127.                 for (int i = 0; i < rsMetaData.getColumnCount(); i++)  
  128.                 {  
  129.                     String columnName = rsMetaData.getColumnName(i + 1);  
  130.                     Object columnVal = rs.getObject(i + 1);  
  131.                     // 这个field是类加载器级别的，用于管理其类的属性  
  132.                     Field field = cls.getDeclaredField(columnName);  
  133.                       
  134.                     field.setAccessible(true);  
  135.                     field.set(t, columnVal);  
  136.                 }  
  137.             }  
  138.             return t;  
  139.         }  
  140.         catch (SQLException e)  
  141.         {  
  142.             e.printStackTrace();  
  143.         }  
  144.         catch (InstantiationException e)  
  145.         {  
  146.             e.printStackTrace();  
  147.         }  
  148.         catch (IllegalAccessException e)  
  149.         {  
  150.             // TODO Auto-generated catch block  
  151.             e.printStackTrace();  
  152.         }  
  153.         catch (SecurityException e)  
  154.         {  
  155.             // TODO Auto-generated catch block  
  156.             e.printStackTrace();  
  157.         }  
  158.         catch (NoSuchFieldException e)  
  159.         {  
  160.             // TODO Auto-generated catch block  
  161.             e.printStackTrace();  
  162.         }  
  163.           
  164.         return t;  
  165.     }  
  166.       
  167.     // 利用反射机制实现数据库的操作,知道其cls的结构  
  168.     public <T> List<T> QueryDBMoreObj(String sql, List<Object> params, Class<T> cls)  
  169.     {  
  170.         List<T> rstList = new ArrayList<T>();  
  171.         try  
  172.         {  
  173.             pstm = conn.prepareStatement(sql);  
  174.             if (params != null && !params.equals(""))  
  175.             {  
  176.                 for (int i = 0; i < params.size(); i++)  
  177.                 {  
  178.                     pstm.setObject(i + 1, params.get(i));  
  179.                 }  
  180.             }  
  181.             rs = pstm.executeQuery();  
  182.             ResultSetMetaData rsMetaData = rs.getMetaData();  
  183.             while (rs.next())  
  184.             {  
  185.                 T t = cls.newInstance();  
  186.                 for (int i = 0; i < rsMetaData.getColumnCount(); i++)  
  187.                 {  
  188.                     String columnName = rsMetaData.getColumnName(i + 1);  
  189.                     Object columnVal = rs.getObject(i + 1);  
  190.                     // 这个field是类加载器级别的，用于管理其类的属性  
  191.                     Field field = cls.getDeclaredField(columnName);  
  192.                     // 应用Fied  
  193.                     field.setAccessible(true);  
  194.                     field.set(t, columnVal);  
  195.                 }  
  196.                 rstList.add(t);  
  197.             }  
  198.             return rstList;  
  199.         }  
  200.         catch (SQLException e)  
  201.         {  
  202.             e.printStackTrace();  
  203.         }  
  204.         catch (InstantiationException e)  
  205.         {  
  206.             e.printStackTrace();  
  207.         }  
  208.         catch (IllegalAccessException e)  
  209.         {  
  210.             // TODO Auto-generated catch block  
  211.             e.printStackTrace();  
  212.         }  
  213.         catch (SecurityException e)  
  214.         {  
  215.             // TODO Auto-generated catch block  
  216.             e.printStackTrace();  
  217.         }  
  218.         catch (NoSuchFieldException e)  
  219.         {  
  220.             // TODO Auto-generated catch block  
  221.             e.printStackTrace();  
  222.         }  
  223.           
  224.         return rstList;  
  225.     }  
  226.       


4.关闭数据库

[java] view plaincopy
 
  1. public void releaseJdbc()  
  2.     {  
  3.           
  4.         try  
  5.         {  
  6.             // 后生成的先释放掉  
  7.             if (rs != null)  
  8.             {  
  9.                 rs.close();  
  10.             }  
  11.             if (pstm != null)  
  12.             {  
  13.                 pstm.close();  
  14.             }  
  15.             if (conn != null)  
  16.             {  
  17.                 conn.close();  
  18.             }  
  19.         }  
  20.         catch (SQLException e)  
  21.         {  
  22.             e.printStackTrace();  
  23.         }  
  24.           
  25.     }  


完整源码：
jdbcUtil.java

[java] view plaincopy
 
  1. package utl;  
  2.   
  3. import java.lang.reflect.Field;  
  4. import java.sql.Connection;  
  5. import java.sql.DriverManager;  
  6. import java.sql.PreparedStatement;  
  7. import java.sql.ResultSet;  
  8. import java.sql.ResultSetMetaData;  
  9. import java.sql.SQLException;  
  10. import java.util.ArrayList;  
  11. import java.util.HashMap;  
  12. import java.util.List;  
  13. import java.util.Map;  
  14.   
  15. public class jdbcUtil  
  16. {  
  17.     private String url = "jdbc:mysql://localhost:3306/moondatabase";  
  18.       
  19.     private String username = "root";  
  20.       
  21.     private String password = "byd";  
  22.       
  23.     private String driver = "com.mysql.jdbc.Driver";  
  24.       
  25.     private String driver1 = "org.gjt.mm.mysql.Driver";  
  26.       
  27.     // 预定义声明对象，用于操作数据库  
  28.     PreparedStatement pstm;  
  29.       
  30.     // java程序与数据库建立的链接  
  31.     Connection conn;  
  32.       
  33.     // 查询数据库返回的对象  
  34.     ResultSet rs;  
  35.       
  36.     public jdbcUtil(String url, String username, String password)  
  37.     {  
  38.         super();  
  39.         this.url = url;  
  40.         this.username = username;  
  41.         this.password = password;  
  42.         try  
  43.         {  
  44.             // 向驱动管理器注册一个jdbc驱动  
  45.             Class.forName(driver).newInstance();  
  46.             System.out.println("驱动注册成功");  
  47.         }  
  48.         catch (ClassNotFoundException e)  
  49.         {  
  50.             e.printStackTrace();  
  51.         }  
  52.         catch (InstantiationException e)  
  53.         {  
  54.             e.printStackTrace();  
  55.         }  
  56.         catch (IllegalAccessException e)  
  57.         {  
  58.             // TODO Auto-generated catch block  
  59.             e.printStackTrace();  
  60.         }  
  61.     }  
  62.       
  63.     public jdbcUtil()  
  64.     {  
  65.         try  
  66.         {  
  67.             // 向驱动管理器注册一个jdbc驱动  
  68.             Class.forName(driver1);  
  69.             System.out.println("驱动注册成功");  
  70.         }  
  71.         catch (ClassNotFoundException e)  
  72.         {  
  73.             e.printStackTrace();  
  74.         }  
  75.     }  
  76.       
  77.     public void getConnection()  
  78.     {  
  79.         try  
  80.         {  
  81.             conn = DriverManager.getConnection(url, username, password);  
  82.             System.out.println("获取链接成功");  
  83.         }  
  84.         catch (SQLException e)  
  85.         {  
  86.             e.printStackTrace();  
  87.         }  
  88.     }  
  89.       
  90.     public boolean updateDB(String sql, List<Object> params)  
  91.     {  
  92.         boolean retFlag = false;  
  93.         try  
  94.         {  
  95.             pstm = conn.prepareStatement(sql);  
  96.             // notice:if(params !=null && !params.equals(""))这个要加上，避免params为空  
  97.             if (params != null && !params.equals(""))  
  98.             {  
  99.                 for (int i = 0; i < params.size(); i++)  
  100.                 {  
  101.                     pstm.setObject(i + 1, params.get(i));  
  102.                 }  
  103.             }  
  104.             return pstm.executeUpdate() > 0 ? true : false;  
  105.         }  
  106.         catch (SQLException e)  
  107.         {  
  108.             e.printStackTrace();  
  109.         }  
  110.           
  111.         return retFlag;  
  112.     }  
  113.       
  114.     public Map<String, Object> QueryDB(String sql, List<Object> params)  
  115.     {  
  116.         Map<String, Object> map = null;  
  117.         try  
  118.         {  
  119.             pstm = conn.prepareStatement(sql);  
  120.             if (params != null && !params.equals(""))  
  121.             {  
  122.                 for (int i = 0; i < params.size(); i++)  
  123.                 {  
  124.                     pstm.setObject(i + 1, params.get(i));  
  125.                 }  
  126.             }  
  127.             rs = pstm.executeQuery();  
  128.             ResultSetMetaData rsMetaData = rs.getMetaData();  
  129.             while (rs.next())  
  130.             {  
  131.                 map = new HashMap<String, Object>();  
  132.                 for (int i = 0; i < rsMetaData.getColumnCount(); i++)  
  133.                 {  
  134.                     String columnName = rsMetaData.getColumnName(i + 1);  
  135.                     Object columnVal = rs.getObject(i + 1);  
  136.                     // 数据库中的值可能为空  
  137.                     if (columnVal == null)  
  138.                     {  
  139.                         columnVal = "";  
  140.                     }  
  141.                     map.put(columnName, columnVal);  
  142.                 }  
  143.                   
  144.             }  
  145.         }  
  146.         catch (SQLException e)  
  147.         {  
  148.             // TODO Auto-generated catch block  
  149.             e.printStackTrace();  
  150.         }  
  151.           
  152.         return map;  
  153.           
  154.     }  
  155.       
  156.     // 这个完全可以代替单个查询  
  157.     public List<Map<String, Object>> QueryMoreDB(String sql, List<Object> params)  
  158.     {  
  159.         List<Map<String, Object>> retList = new ArrayList<Map<String, Object>>();  
  160.         try  
  161.         {  
  162.             pstm = conn.prepareStatement(sql);  
  163.             if (params != null && !params.equals(""))  
  164.             {  
  165.                 for (int i = 0; i < params.size(); i++)  
  166.                 {  
  167.                     pstm.setObject(i + 1, params.get(i));  
  168.                 }  
  169.             }  
  170.               
  171.             ResultSet rs = pstm.executeQuery();  
  172.             ResultSetMetaData rsMetaData = rs.getMetaData();  
  173.             while (rs.next())  
  174.             {  
  175.                 Map<String, Object> map = new HashMap<String, Object>();  
  176.                 for (int i = 0; i < rsMetaData.getColumnCount(); i++)  
  177.                 {  
  178.                     String columnName = rsMetaData.getColumnName(i + 1);  
  179.                     Object columnVal = rs.getObject(i + 1);  
  180.                     if (columnVal == null)  
  181.                     {  
  182.                         columnVal = "";  
  183.                     }  
  184.                     map.put(columnName, columnVal);  
  185.                 }  
  186.                 retList.add(map);  
  187.             }  
  188.         }  
  189.         catch (SQLException e)  
  190.         {  
  191.             e.printStackTrace();  
  192.         }  
  193.         return retList;  
  194.     }  
  195.       
  196.     // 利用反射机制实现数据库的操作  
  197.     public <T> T QueryDBObj(String sql, List<Object> params, Class<T> cls)  
  198.     {  
  199.         T t = null;  
  200.         try  
  201.         {  
  202.             pstm = conn.prepareStatement(sql);  
  203.             if (params != null && !params.equals(""))  
  204.             {  
  205.                 for (int i = 0; i < params.size(); i++)  
  206.                 {  
  207.                     pstm.setObject(i + 1, params.get(i));  
  208.                 }  
  209.             }  
  210.             rs = pstm.executeQuery();  
  211.             ResultSetMetaData rsMetaData = rs.getMetaData();  
  212.             while (rs.next())  
  213.             {  
  214.                 t = cls.newInstance();  
  215.                 for (int i = 0; i < rsMetaData.getColumnCount(); i++)  
  216.                 {  
  217.                     String columnName = rsMetaData.getColumnName(i + 1);  
  218.                     Object columnVal = rs.getObject(i + 1);  
  219.                     // 这个field是类加载器级别的，用于管理其类的属性  
  220.                     Field field = cls.getDeclaredField(columnName);  
  221.                       
  222.                     field.setAccessible(true);  
  223.                     field.set(t, columnVal);  
  224.                 }  
  225.             }  
  226.             return t;  
  227.         }  
  228.         catch (SQLException e)  
  229.         {  
  230.             e.printStackTrace();  
  231.         }  
  232.         catch (InstantiationException e)  
  233.         {  
  234.             e.printStackTrace();  
  235.         }  
  236.         catch (IllegalAccessException e)  
  237.         {  
  238.             // TODO Auto-generated catch block  
  239.             e.printStackTrace();  
  240.         }  
  241.         catch (SecurityException e)  
  242.         {  
  243.             // TODO Auto-generated catch block  
  244.             e.printStackTrace();  
  245.         }  
  246.         catch (NoSuchFieldException e)  
  247.         {  
  248.             // TODO Auto-generated catch block  
  249.             e.printStackTrace();  
  250.         }  
  251.           
  252.         return t;  
  253.     }  
  254.       
  255.     // 利用反射机制实现数据库的操作,知道其cls的结构  
  256.     public <T> List<T> QueryDBMoreObj(String sql, List<Object> params, Class<T> cls)  
  257.     {  
  258.         List<T> rstList = new ArrayList<T>();  
  259.         try  
  260.         {  
  261.             pstm = conn.prepareStatement(sql);  
  262.             if (params != null && !params.equals(""))  
  263.             {  
  264.                 for (int i = 0; i < params.size(); i++)  
  265.                 {  
  266.                     pstm.setObject(i + 1, params.get(i));  
  267.                 }  
  268.             }  
  269.             rs = pstm.executeQuery();  
  270.             ResultSetMetaData rsMetaData = rs.getMetaData();  
  271.             while (rs.next())  
  272.             {  
  273.                 T t = cls.newInstance();  
  274.                 for (int i = 0; i < rsMetaData.getColumnCount(); i++)  
  275.                 {  
  276.                     String columnName = rsMetaData.getColumnName(i + 1);  
  277.                     Object columnVal = rs.getObject(i + 1);  
  278.                     // 这个field是类加载器级别的，用于管理其类的属性  
  279.                     Field field = cls.getDeclaredField(columnName);  
  280.                     // 设置这个属性可以访问  
  281.                     field.setAccessible(true);  
  282.                     field.set(t, columnVal);  
  283.                 }  
  284.                 rstList.add(t);  
  285.             }  
  286.             return rstList;  
  287.         }  
  288.         catch (SQLException e)  
  289.         {  
  290.             e.printStackTrace();  
  291.         }  
  292.         catch (InstantiationException e)  
  293.         {  
  294.             e.printStackTrace();  
  295.         }  
  296.         catch (IllegalAccessException e)  
  297.         {  
  298.             // TODO Auto-generated catch block  
  299.             e.printStackTrace();  
  300.         }  
  301.         catch (SecurityException e)  
  302.         {  
  303.             // TODO Auto-generated catch block  
  304.             e.printStackTrace();  
  305.         }  
  306.         catch (NoSuchFieldException e)  
  307.         {  
  308.             // TODO Auto-generated catch block  
  309.             e.printStackTrace();  
  310.         }  
  311.           
  312.         return rstList;  
  313.     }  
  314.       
  315.     public void releaseJdbc()  
  316.     {  
  317.           
  318.         try  
  319.         {  
  320.             //后生成的先释放掉  
  321.             if (rs != null)  
  322.             {  
  323.                 rs.close();  
  324.             }  
  325.             if (pstm != null)  
  326.             {  
  327.                 pstm.close();  
  328.             }  
  329.             if (conn != null)  
  330.             {  
  331.                 conn.close();  
  332.             }  
  333.         }  
  334.         catch (SQLException e)  
  335.         {  
  336.             e.printStackTrace();  
  337.         }  
  338.           
  339.     }  
  340. }  


Test.java

[java] view plaincopy
 
  1. package test;  
  2.   
  3. import java.util.ArrayList;  
  4. import java.util.List;  
  5. import java.util.Map;  
  6.   
  7. import bean.User;  
  8.   
  9. import utl.jdbcUtil;  
  10.   
  11. public class Test  
  12. {  
  13.       
  14.     /** 
  15.      * @param args 
  16.      */  
  17.     public static void main(String[] args)  
  18.     {  
  19.         jdbcUtil jUtilTest = new jdbcUtil();  
  20.         jUtilTest.getConnection();  
  21.         // sql语句通配符对应的字段  
  22.         List<Object> params = new ArrayList<Object>();  
  23.         // 创建表  
  24.         String createTable =  
  25.             "create table if not exists userinfo (id int primary key auto_increment,username varchar(64),pswd varchar(64))";  
  26.         jUtilTest.updateDB(createTable, null);  
  27.           
  28.         // 插入数据  
  29.         for (int i = 0; i < 10; i++)  
  30.         {  
  31.             String insertOne = "insert into userinfo (username,pswd) values (?,?)";  
  32.             params.clear();  
  33.             params.add("byd" + i);  
  34.             params.add("123" + i);  
  35.             jUtilTest.updateDB(insertOne, params);  
  36.         }  
  37.           
  38.         // 删除一条数据,sql语句对大小写不敏感，delete/Delete/DELETE等均可  
  39.         String deleteOne = "DeLete from userinfo where username = ?";  
  40.         params.clear();  
  41.         params.add("byd0");  
  42.         jUtilTest.updateDB(deleteOne, params);  
  43.           
  44.         // 改变数据  
  45.         String updateOne = "update userinfo set pswd = ? where username =?";  
  46.         params.clear();  
  47.         params.add("bydxxoo");  
  48.         params.add("byd");  
  49.         jUtilTest.updateDB(updateOne, params);  
  50.           
  51.         // 查询一条数据  
  52.         String findOne = "select * from userinfo where username = ?";  
  53.         // notice:数据库的列下标是从1开始计数的  
  54.         params.clear();  
  55.         params.add("byd2");  
  56.         Map<String, Object> rstOne = jUtilTest.QueryDB(findOne, params);  
  57.         System.out.println("-->" + rstOne);  
  58.           
  59.         // 查询多条数据  
  60.         String findMore = "select * from userinfo";  
  61.         List<Map<String, Object>> rstMore = jUtilTest.QueryMoreDB(findMore, null);  
  62.         System.out.println("-->" + rstMore);  
  63.           
  64.         // 反射查询一条数据  
  65.         String findOneRefl = "select * from userinfo where username =?";  
  66.         params.clear();  
  67.         params.add("byd2");  
  68.         User userOne = jUtilTest.QueryDBObj(findOneRefl, params, User.class);  
  69.         System.out.println("-->" + userOne);  
  70.           
  71.         // 反射查询多条数据  
  72.         String findMoreRefl = "select * from userinfo";  
  73.         List<User> userMore = jUtilTest.QueryDBMoreObj(findMoreRefl, null, User.class);  
  74.         System.out.println("-->" + userMore);  
  75.           
  76.         // 删除表  
  77.         // String sql3 = "delete from userinfo";  
  78.         // jUtilTest.updateDB(sql3, null);  
  79.         // notice:断开数据库连接前，要释放一些资源  
  80.         jUtilTest.releaseJdbc();  
  81.     }  
  82.       
  83. }  


User.java

[java] view plaincopy
 
  1. package bean;  
  2. public class User  
  3. {  
  4.     private int id;  
  5.     private String username="";  
  6.     @Override  
  7.     public String toString()  
  8.     {  
  9.         return "User [id=" + id + ", username=" + username + ", pswd=" + pswd + "]";  
  10.     }  
  11.     private String pswd="";  
  12.     public int getId()  
  13.     {  
  14.         return id;  
  15.     }  
  16.     public void setId(int id)  
  17.     {  
  18.         this.id = id;  
  19.     }  
  20.     public String getUsername()  
  21.     {  
  22.         return username;  
  23.     }  
  24.     public void setUsername(String username)  
  25.     {  
  26.         this.username = username;  
  27.     }  
  28.     public String getPswd()  
  29.     {  
  30.         return pswd;  
  31.     }  
  32.     public void setPswd(String pswd)  
  33.     {  
  34.         this.pswd = pswd;  
  35.     }  
  36. }  


======================================================华丽的分隔符==============================================================

下面在说下安装mysql遇到的问题：

MySql安装包：http://pan.baidu.com/share/link?shareid=2375321572&uk=3056808396

1.安装MySQl-5.5.22老是最后一步开在start Service
安装的 MySQL 5.1.48 或是 MySQL 5.5.8，配置好最后点击 Execute 按钮了，但是进行不到 Start service 这一步。检查了下 MySQL 系统服务已添加，但是无法启动，手工也不行。这时候用事件查看器可以看到程序事件里有几个来自于 MySQL 的错误： 

Plugin ‘InnoDB‘ registration as a STORAGE ENGINE failed. 
Unknown/unsupported table type: INNODB 

原来是因为这两版本的 MySQL 默认使用了支持事物的 INNODB 引擎，打开 my.ini 文件，在 MySQL 的安装文件夹, 如 c:program filesMySQL 中，看到： 

 

default-storage-engine=INNODB 
解决办法是把该设置改为 

default-storage-engine=MYISAM 

 

仍然使用 MyISAM 作为默认的数据库引擎，保存 my.ini 文件，然后手工启动 MySQL 服务，成功；再把刚刚的配置窗口关掉就行了。 
你完全可以在创建数据库时指定所创建数据库所用的数据库引擎，或创建表时所用的数据库引擎，或者创建后再更改都可以。 
你可以再次回忆一下刚刚配置的过程： 
安装的最后一个步骤，在点 Finish 按钮时，可以选择 Configure the MySQL Server now，或者是从开始菜单里直接运行 MySQL 的 MySQL Server Instance Configuration Wizard 来进行配置数据库，在选择 database usage 时有三个选项： 

1) Multifunctional Database 
2) Transactional Database Only 
3) No-Transactional Database Only 

默认是第一项，选第二项也会让数据库默认的引擎为 INNODB，生成的 my.ini 文件里都会是 default-storage-engine=INNODB。至于在 my.ini 中注释掉了 --skip-innodb 并不太会影响到数据库的启动，只是决定了数据库的事物特性。 

那么在最后一步 Processing configuration ... 里写完 my.ini 文件后，进行到 Start service 就不动了，也就是启动不了 MySQL 服务，在系统服务里已经加了 MySQL 服务名。 

如果你这一步选择的是第三项，不使用支持事件的数据库，那么在 my.ini 文件里就是 default-storage-engine=MYISAM，那么你也很幸运，能顺利配置成功，并启动好数据库。不过这将使你不能使用 INNODB 引擎（ERROR 1286 (42000): Unknown table engine ‘InnoDB‘），其实也就是把 my.ini 中的 skip-innodb 给启用了，你可以把它再次注释掉试试事物。 

作者 mywaylife

如果还是不能解决可以参考下面的方法：

安装MySQL时无法启动服务(could not start the service ) 

1、建议使用360卸载已经安装的mysql数据库，因为360会查看相关的注册信息，卸载比较彻底。 
2、检查3306端口是否已经占用，如果已经占有，杀死此进程。 
3、查看服务列表中，是否还有mysql的服务进程。 
4、要确保安装目录的访问权限是everyone，这里我建议不要把mysql安装的c盘中，因为xp有时候为了系统安全，会限制文件夹的访问权限。 
5、建议安装在干净的文件夹里，如果安装在上次安装过的文件夹，建议删除文件夹下的所有文件。 

mysql安全设置后导致mysql无法运行，建议重置运行mysql服务的登陆用户名密码，然后进服务里面重新输入刚修改的用户名与密码，这样就可以了

如果还是不可以，我们可以通过查看错误日志的方法解决：

mysql错误日志位于mysql安装目录下的扩展名为.err的文件，复制一份通过记事本等工具打开即开，如果err日志过大建议不要用记事本，可以用editplus打开 

详细出处参考：http://www.jb51.net/article/30866.htm

 

2.利用Navigate for MySql工具查看数据库，保存数据库等操作时报  “can‘t creat/write to file”

解决办法：

Android之jdbc的学习打开MySql的安装路径：找到my.ini,在其中的[mysqld]下面添加 tmpdir="C:/Program Files/MySQL/MySQL Server 5.5/Temp"，后面指定的Temp路径，没有的话先自己建一个在指定，路径注意分隔符是否正确。

Android之jdbc的学习

或者：
1、C:\Windows\TEMP 文件夹权限不够，至少也要给出 USERS 组的可读可写权限；------------你的服务器装了 MCAFEE 杀毒软件，它的访问保护禁止了 TEMP 文件可写，修改访问保护设置；
2、C:\Windows\TEMP 文件夹的磁盘满了，文件写不进去了，清空 TEMP 文件夹；-------------------还是MCAFEE杀毒软件的问题，解决步骤：按访问扫描属性 - 所有进程 - 检测项 - 扫描文件（在写入磁盘时 ）勾去掉就好了。

3、第三方限制（如杀毒软件的限制）----------------------------关闭杀毒试试

====================================================================================================================================

本人技术很菜，如果文中存在错误，还请给位多多指出！

Android之jdbc的学习,布布扣,bubuko.com

Android之jdbc的学习

上一篇：Android之TextView组件学习


下一篇：Android来电拦截及来电转移