zoukankan      html  css  js  c++  java

  • Android之jdbc的学习

    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访问数据，报一大堆错误，看stackoverflow上说建议使用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”

    解决办法：

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

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

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

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

    本人技术很菜，如果文中存在错误，还请给位多多指出！
  • 相关阅读:
    mongodb分片集群报错261
    Galera集群安装报错Operation not permitted
    k8s部署php程序访问显示报错
    k8使用secret拉取镜像失败的问题
    nginx反向代理与负载均衡
    ---connet MPT device to PC under Ubuntu
    ----vysor
    ---su
    ---mysql utf8 设置
    ---Android logcat 记录日志
  • 原文地址：https://www.cnblogs.com/tfy1332/p/3655797.html
Copyright © 2011-2022 走看看