JAVA 数据库操作工具类----mysql

封装了一个JAVA操作mysql的工具类，如果有需要的，可以直接使用。

1、MysqlHelper类，包括对数据库的CRUD操作,其中查询有单记录返回和多记录返回。另外，我使用了反射封装类，希望和大家多多交流。

/**
 * 数据库操作类，包括增删改查
 * @author yangliucheng
 * @serialData 2015-3-25
 * @category class of mysql operation
 * @version v1.0
 */
class mysqlHelper
{
    //加载驱动
    private final String DRIVER = "com.mysql.jdbc.Driver";
    //定义数据库账号
    private final String USERNAME = "root";
    //定义数据库密码
    private final String PASSWORD = "root";
    //访问的地址
    private final String URL = "jdbc:mysql://localhost:3306/smart_home";
    //定义数据库的连接
    private Connection connection;
    //定义sql语句的执行对象
    private PreparedStatement pStatement;
    //定义查询返回的结果集合
    private ResultSet resultset;

    public mysqlHelper()
    {
        try {
            Class.forName(DRIVER);//注册驱动
            connection = DriverManager.getConnection(URL,USERNAME,PASSWORD);//定义连接
        } catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
        }
    }
    /**
     * 完成对数据库的增删改操作
     * @param sql语句
     * @param 传入的占位符，List集合
     * @return SQL语句执行成功返回true,否则返回false
     * @throws SQLException
     */
    public boolean addDeleteModify(String sql,List<Object>params) throws SQLException
    {
        int result = -1;//设置为
        pStatement = connection.prepareStatement(sql);  //填充占位符
        int index = 1; //从第一个开始添加
        if(params != null && !params.isEmpty())
        {
            for(int i = 0;i<params.size();i++)
            {
                pStatement.setObject(index++,params.get(i));//填充占位符
            }
        }
        result = pStatement.executeUpdate();//执行成功将返回大于0的数
        return  result>0 ? true : false;
    }
   /**
    * 数据库查询操作，返回单条记录
    * @param sql语句
    * @param 传入的占位符
    * @return 返回Map集合类型，包含查询的结果
    * @throws SQLException
    */
    public Map<String,Object> returnSimpleResult(String sql,List<Object>params) throws SQLException
    {
        Map<String, Object> map = new HashMap<String, Object>();
        int index = 1;//从1开始设置占位符
        pStatement = connection.prepareStatement(sql);
        if(params != null && !params.isEmpty()) /*判断参数是否为空*/
        { 
            for(int i = 0;i<params.size();i++) /*循环填充占位符*/
            {
                pStatement.setObject(index++, params.get(i));
            }
        }
        resultset = pStatement.executeQuery(sql);
        /*  将查询结果封装到map集合*/
        ResultSetMetaData metaDate = resultset.getMetaData();//获取resultSet列的信息
        int columnLength = metaDate.getColumnCount();//获得列的长度
        while(resultset.next())
        {
            for(int i = 0;i<columnLength;i++)
            {
                String metaDateKey = metaDate.getColumnName(i+1);//获得列名
                Object resultsetValue = resultset.getObject(metaDateKey);//通过列名获得值
                if(resultsetValue == null)
                {
                    resultsetValue = "";//转成String类型
                }
                map.put(metaDateKey, resultsetValue);//添加到map集合（以上代码是为了将从数据库返回的值转换成map的key和value）
            }
        }
        return map;
    }
    /**
     * 查询数据库，返回多条记录
     * @param sql语句
     * @param 占位符
     * @return list集合，包含查询的结果
     * @throws SQLException 
     */
    public List<Map<String,Object>> returnMultipleResult(String sql,List<Object>params) throws SQLException
    {
        List<Map<String,Object>> list = new ArrayList<Map<String,Object>>();
        //填充占位符
        int index = 1;
        pStatement = connection.prepareStatement(sql);
        if(params != null && !params.isEmpty())
        {
            for(int i = 0;i<params.size();i++)
            {
                pStatement.setObject(index++, params.get(i));
            }
        }
        //执行SQL语句
        resultset = pStatement.executeQuery();
        //封装resultset成map类型
        ResultSetMetaData metaDate = resultset.getMetaData();//获取列信息,交给metaDate
        int columnlength = metaDate.getColumnCount();
        while(resultset.next())
        {
            Map<String, Object> map = new HashMap<String, Object>();
            for(int i = 0;i<columnlength;i++)
            {
                String metaDateKey = metaDate.getColumnName(i+1);//获取列名
                Object resultsetValue = resultset.getObject(metaDateKey);
                if(resultsetValue == null)
                {
                    resultsetValue = "";
                }
                map.put(metaDateKey, resultsetValue);
            }
            list.add(map);
        }
        return list;
    }
    /**
     * 应用反射机制返回单条记录
     * @param sql语句
     * @param 占位符
     * @param javabean类，这里我用的是（SmartHome_mysql.class）
     *        javabean，我理解的是一个高度封装组件，成员为私有属性，只能
     *        通过set/get方法赋值和取值
     * @return 泛型
     * @throws SQLException
     */
    public <T> T returnSimpleResult_Ref(String sql,List<Object>params,Class<T> tJavabean) throws Exception
    {
        T tResult = null;
        int index = 1;
        pStatement = connection.prepareStatement(sql);
        if(params != null && !params.isEmpty())
        {
            for(int i = 0;i<params.size();i++)
            {
                pStatement.setObject(index++, params.get(i));   
            }
        }
        resultset = pStatement.executeQuery(sql);
        //封装resultset
        ResultSetMetaData metaData = resultset.getMetaData();//获得列的信息
        int columnLength = metaData.getColumnCount();//获得列的长度
        while(resultset.next())//循环取值
        {
            tResult = tJavabean.newInstance();//通过反射机制创建一个实例
            for(int i = 0;i<columnLength;i++)
            {
                String metaDateKey = metaData.getColumnName(i+1);
                Object resultsetValue = resultset.getObject(metaDateKey);
                if(resultsetValue == null)
                {
                    resultsetValue = "";
                }
                //获取列的属性，无论是公有。保护还是私有，都可以获取
                Field field = tJavabean.getDeclaredField(metaDateKey);
                field.setAccessible(true);//打开javabean的访问private权限
                field.set(tResult, resultsetValue);//给javabean对应的字段赋值
            }
        }
        return tResult;
    }
    /**
     * 通过反射机制访问数据库，并返回多条记录
     * @param sql语句
     * @param 占位符
     * @param javabean,会执行javabean类里面的toString方法
     * @return
     * @throws Exception
     */
    public <T> List<T> returnMultipleResult_Ref(String sql,List<Object>params,Class<T> tJavabean) throws Exception
    {
        List<T> list = new ArrayList<T>();
        int index = 1;
        pStatement = connection.prepareStatement(sql);
        if(params != null && !params.isEmpty())
        {
            for(int i = 0;i<params.size();i++)
            {
                pStatement.setObject(index, params.get(i));
            }           
        }
        resultset = pStatement.executeQuery(sql);
        //封装resultset
        ResultSetMetaData metaData = resultset.getMetaData();//取出列的信息
        int columnLength = metaData.getColumnCount();//获取列数
        while(resultset.next())
        {
            T tResult = tJavabean.newInstance();//通过反射机制创建一个对象
            for(int i = 0;i<columnLength;i++)
            {
                String metaDataKey = metaData.getColumnName(i+1);
                Object resultsetValue = resultset.getObject(metaDataKey);
                if(resultsetValue == null)
                {
                    resultsetValue = "";
                }
                Field field = tJavabean.getDeclaredField(metaDataKey);
                field.setAccessible(true);
                field.set(tResult, resultsetValue);
            }
            list.add(tResult);
        }
        return list;
    }
    /**
     * 注意在finally里面执行以下方法，关闭连接
     */
    public void closeconnection()
    {
        if(resultset != null)
        {
            try {
                resultset.close();
            } catch (SQLException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        if(pStatement != null)
        {
            try {
                pStatement.close();
            } catch (SQLException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        if(connection != null)
        {
            try {
                connection.close();
            } catch (SQLException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
}

2、javabean类

package com.example.mysql;

import java.io.Serializable;

public class SmartHome_mysql implements Serializable{
    /**
     * 
     */
    private static final long serialVersionUID = 1L;
    /*  数据库字段，更具自己的需要而设置（必须和你数据库中的字段一样，需要查什么，就写什么），并生成set,get,toString方法  */
    private int lightNo;
    private String lightName;
    private String lighPosition;
    @Override
    public String toString() {
        return "SmartHome_mysql [lightNo=" + lightNo + ", lightName="
                + lightName + ", lighPosition=" + lighPosition + "]";
    }
    public int getLightNo() {
        return lightNo;
    }
    public void setLightNo(int lightNo) {
        this.lightNo = lightNo;
    }
    public String getLightName() {
        return lightName;
    }
    public void setLightName(String lightName) {
        this.lightName = lightName;
    }
    public String getLighPosition() {
        return lighPosition;
    }
    public void setLighPosition(String lighPosition) {
        this.lighPosition = lighPosition;
    }
    public static long getSerialversionuid() {
        return serialVersionUID;
    }   
}

3、测试

public class AndroidServer {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        mysqlHelper mysql = new mysqlHelper();
        String sql = "select * from smart";
//      List<Object> params = new ArrayList<Object>();
//      params.add(1);
        try {
            SmartHome_mysql shmysql = mysql.returnSimpleResult_Ref(sql, null, SmartHome_mysql.class);
            System.out.println(shmysql);
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally
        {
            mysql.closeconnection();
        }
    }
}

4、我这里生成了一个帮助文档，需要的朋友可以在以下地址下载：
工具类