JAVA 连数据库一般操作

主类

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;


public class Main
{
    public static void main(String[] args)
    {
        connect_db mytest= new connect_db();
        Connection con;
        con =mytest.Db_Conn();

        PreparedStatement pst = null;
        ResultSet rs = null;
        String sql = "select * from etl_job_dependency";
        /**
         * 该方法用到的技术是通过结果集的列属性的性质得到，没有用到反射机制  
         * 这个测试用例也是把查询的结果集放到List集合  
         * 里面的元素是集合Map,key是数据库中的字段类型，value是  
         * 字段类型对应的值，
         */
      /*  try {
            List list=DBUtil.executeQuery(con, sql);
            System.out.println(list);
        } catch (SQLException e) {
            e.printStackTrace();
        }*/
        /**
         * 这个测试用例只是把查询的结果集中的某一条记录映射到了dao对象中，
         */  
     try {
            pst = con.prepareStatement(sql);  
            rs = pst.executeQuery();  
            while(rs.next()){
                dependency r = (dependency) DBUtil.getFirstObjectFromRs(rs, dependency.class);
                System.out.println("Dependency:" + r);
            }  
        } catch (SQLException e) {  
            e.printStackTrace();  
        }finally{  
            DBUtil.closeRs(rs);  
            DBUtil.closePst(pst);  
            DBUtil.closeCon(con);  
        }
        /**
         * 方法是用的反射机制  
         * 这个测试用例是测试executeQuery函数，把查询的结果集放到List集合  
         * 并且集合元素存放的是dao对象，一条数据库记录对应一个dao对象，  
         * 打印出来的结果如：  
         * [vehicle_id: 2 numberPlate: 苏B10001 deleteDate: null,   
         * vehicle_id: 3 numberPlate: 苏B90003 deleteDate: null]  
         *
         */  
    /*  try {  
            List list=DBUtil.executeQuery(con, sql,Vehicle.class);  
            System.out.println(list);  
        } catch (SQLException e) {  
            // TODO Auto-generated catch block  
            e.printStackTrace();  
        }*/
    }
}  

DBUtil工具类

import java.lang.reflect.*;
import java.sql.*;
import java.util.*;
/*** 
 * 注意利用查询出数据库的一条记录映射到相应的dao中，写相应的dao一定要注意字段，一定 
 * 要与数据库的记录字段相对应，大小写可以忽略，但是字段不一致就返回错误的数据 
 *
 * private static Object getValueFromRs(ResultSet rs, String fieldName, Type t) throws SQLException 
 * 此接口有个小的问题就是如果，获取的字段值是空值或者为null，而你自己的需求就是想要获取的字段为一个 
 * 默认的值，那就只需要客户该写这个方法，进行判断就可以 
 * @author Administrator
 *
 */
public class DBUtil {
    /**
     * 对操作的数据库回滚 
     * @param con 对数据库操作所得到的链接 
     */
    public static void rollBack(Connection con){
        try {
            con.rollback();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    /*** 
     *
     * @param con 数据库jdbc链接 
     * @param sql 执行的sql语句 
     * @return 返回查询的记录数，记录存储在集合List里面， 
     * 里面的元素是集合Map,key是数据库中的字段类型，value是 
     * 字段类型对应的值 
     * @throws SQLException
     */
    public static List<Map<String, Object>> executeQuery(Connection con, String sql) throws SQLException{
        PreparedStatement pst = null;
        ResultSet rs = null;
        try {
            pst = con.prepareStatement(sql);
            rs = pst.executeQuery();
            return getListFromRsLowerCase(rs);
        }finally{
            closeRs(rs);
            closePst(pst);
        }
    }
    /*** 
     *  执行sql语句,把结果集存放到List集合里，集合的元素是dao对象 
     * @param con 数据库得到的链接 
     * @param sql 执行查询的sql语句 
     * @param c   把一条条记录要映射的dao类中的对象中去 
     * @return
     * @throws SQLException
     */
    public static List<Object> executeQuery(Connection con, String sql, Class<?> c) throws SQLException{
        PreparedStatement pst = null;
        ResultSet rs = null;
        try {
            pst = con.prepareStatement(sql);
            rs = pst.executeQuery();
            return getListFromRs(rs, c);
        }finally{
            closeRs(rs);
            closePst(pst);
        }
    }
    /**
     * 得到结果集存储到list中 
     * @param rs 查询的结果集 
     * @return
     * @throws SQLException
     */
    public static List<Map<String, Object>> getListFromRs(ResultSet rs) throws SQLException{
        ResultSetMetaData md = rs.getMetaData();//得到结果集列的属性  
        int columns = md.getColumnCount();//得到记录有多少列  
        int i;
        List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
        while(rs.next()){
            Map<String, Object> map = new HashMap<String, Object>();
            for(i = 0; i < columns; i++){
                map.put(md.getColumnName(i + 1), getValueByType(rs, md.getColumnType(i + 1), md.getColumnName(i + 1)));
            }
            list.add(map);
        }
        return list;
    }
    /**
     * 这个与getListFromRs(ResultSet rs)差不多，只是把数据库的字段变成小写 
     *
     * @param rs
     * @return
     * @throws SQLException
     */
    public static List<Map<String, Object>> getListFromRsLowerCase(ResultSet rs) throws SQLException{
        ResultSetMetaData md = rs.getMetaData();
        int columns = md.getColumnCount();
        int i;
        List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
        while(rs.next()){
            Map<String, Object> map = new HashMap<String, Object>();
            for(i = 0; i < columns; i++){
                map.put(md.getColumnName(i + 1).toLowerCase(), getValueByType(rs, md.getColumnType(i + 1), md.getColumnName(i + 1)));
            }
            list.add(map);
        }
        return list;
    }
    /**
     * 这个与getListFromRs(ResultSet rs)功能一样，只是把数据库的字段变成大写 
     * @param rs
     * @return
     * @throws SQLException
     */
    public static List<Map<String, Object>> getListFromRsUpperCase(ResultSet rs) throws SQLException{
        ResultSetMetaData md = rs.getMetaData();
        int columns = md.getColumnCount();
        int i;
        List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
        while(rs.next()){
            Map<String, Object> map = new HashMap<String, Object>();
            for(i = 0; i < columns; i++){
                map.put(md.getColumnName(i + 1).toUpperCase(), getValueByType(rs, md.getColumnType(i + 1), md.getColumnName(i + 1)));
            }
            list.add(map);
        }
        return list;
    }
    /*** 
     *
     * @param rs 查询的结果集 
     * @param c  集合元素存放的dao对象 
     * @return
     * @throws SQLException
     */
    public static List<Object> getListFromRs(ResultSet rs, Class<?> c) throws SQLException{
        List<Object> list = new ArrayList<Object>();
        try {
            while(rs.next()){
                Object o = initObjectFromRsIfExist(rs, c);
                list.add(o);
            }
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        }
        return list;
    }
    /**
     *
     * @param rs 查询的结果集 
     * @param c 结果集一条记录，而一条记录所对应的dao类 
     * @return
     * @throws SQLException
     */
    public static Object getFirstObjectFromRs(ResultSet rs, Class<?> c) throws SQLException{
        Object o = null;
        try {
            o = initObjectFromRsIfExist(rs, c);
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        return o;
    }
    /*** 
     *
     * @param rs 查询出来的结果集 
     * @param type SQL type from java.sql.Types 
     * @param name 数据库记录所对应的字段名称 
     * @return 返回一条记录的一个列值
     * @throws SQLException
     */
    private static Object getValueByType(ResultSet rs, int type, String name) throws SQLException{
        switch(type){
            case Types.NUMERIC:
                return rs.getLong(name);
            case Types.VARCHAR:
                //if(rs.getString(name)==null){  
                //return "";
                //}  
                return rs.getString(name);
            case Types.DATE:
                //if(rs.getDate(name)==null){  
                //return System.currentTimeMillis();
                //  }
                return rs.getDate(name);
            case Types.TIMESTAMP:
                return rs.getTimestamp(name).toString().substring(0,rs.getTimestamp(name).toString().length()-2);
            case Types.INTEGER:
                return rs.getInt(name);
            case Types.DOUBLE:
                return rs.getDouble(name);
            case Types.FLOAT:
                return rs.getFloat(name);
            case Types.BIGINT:
                return rs.getLong(name);
            default:
                return rs.getObject(name);
        }
    }
    /*** 
     * 查询dao映射的字段是否在记录在数据库包含的字段 
     * @param rs 查询的记录集 
     * @param fieldName dao映射的字段 
     * @return 如果包含在数据库记录集里面，返回true，否则false 
     * @throws SQLException
     */
    private static boolean rsContainsFields(ResultSet rs, String fieldName) throws SQLException{
        ResultSetMetaData md = rs.getMetaData();
        for(int i = 0; i < md.getColumnCount(); i++){
            if(md.getColumnName(i + 1).equalsIgnoreCase(fieldName)){
                return true;
            }
        }
        return false;
    }
    /*** 
     * 这个函数与initObjectFromRsIfExist函数实现的功能是一样，只是 
     * 没有判断dao中的字段是否与数据库记录所定义的字段是一样的, 
     * 没有判断时如果自己设置的dao字段与数据库的字段不一致就会报异常 
     * @param rs
     * @param c
     * @return
     * @throws InstantiationException
     * @throws SQLException
     * @throws IllegalAccessException
     */
    private static Object initObjectFromRs(ResultSet rs, Class<?> c) throws InstantiationException, SQLException, IllegalAccessException{
        Object o = c.newInstance();
        Method[] methods = o.getClass().getMethods();
        for(Method m: methods){
            if(m.getName().startsWith("set")){
                try {
                    m.invoke(o, getParamValueFromRs(rs, m));
                } catch (IllegalArgumentException e) {
                    throw new RuntimeException("IllegalArgumentException:" + e + "\nMethods:" + m.getName());
                } catch (InvocationTargetException e) {
                    throw new RuntimeException("InvocationTargetException:" + e + "\nMethods:" + m.getName());
                }
            }
        }
        return o;
    }
    /*** 
     *
     * 把数据库的一条记录映射到相应的dao对象中， 
     * 如果dao中的字段与数据库字段不一致，返回的就是dao数据类型定义的默认值 
     * 如：dao的字段long vehicleID;而数据库的字段是vehicle_id，那么返回的 
     * 就定义的默认值0. 
     * @param rs 查询的结果集 
     * @param c 结果集一条记录，而一条记录所对应的dao类 
     * @return
     * @throws SQLException
     * @throws IllegalAccessException
     * @throws InstantiationException
     */
    private static Object initObjectFromRsIfExist(ResultSet rs, Class<?> c) throws SQLException, IllegalAccessException, InstantiationException{
        Object o = c.newInstance();//一条记录的dao，新建对象  
        Method[] methods = o.getClass().getMethods();//dao对象所有的方法  
        String field;
        for(Method m: methods){
            //得到dao字段，如getRegdate,转换成Regdate  
            field = m.getName().substring(3);
            //查询dao映射的字段是否在记录在数据库包含的字段,dao方法对set开头的方法进行处理  
            //因为要将结果集映射到dao里面  
            if(m.getName().startsWith("set") && rsContainsFields(rs, field)){
                try {
                    m.invoke(o, getParamValueFromRs(rs, m));
                } catch (IllegalArgumentException e) {
                    throw new RuntimeException("IllegalArgumentException:" + e + "\nMethods:" + m.getName());
                } catch (InvocationTargetException e) {
                    throw new RuntimeException("InvocationTargetException:" + e + "\nMethods:" + m.getName());
                }
            }
        }
        return o;
    }
    /*** 
     *
     * @param rs 查询的结果集 
     * @param m  dao映射字段对应的一个set方法 
     * @return
     * @throws SQLException
     */
    private static Object getParamValueFromRs(ResultSet rs, Method m) throws SQLException
    {
        String fieldName = m.getName().substring(3);
        Type type = m.getGenericParameterTypes()[0];//获取set方法参数的类型        
        return getValueFromRs(rs, fieldName, type);
    }
    /**
     * 获取数据库一条记录的一个列值 
     * @param rs 查询的结果集 
     * @param fieldName dao数据字段，也就是数据库记录的数据字段类型 
     * @param t 参数的数据类型 
     * @return
     * @throws SQLException
     */
    private static Object getValueFromRs(ResultSet rs, String fieldName, Type t) throws SQLException{
        String type = t.toString();
        try{
            if(type.equals("int") || type.equals("class java.lang.Integer")){
                return rs.getInt(fieldName);
            }else if(type.equals("float") || type.equals("class java.lang.Float")){
                return rs.getFloat(fieldName);
            }else if(type.equals("double") || type.equals("class java.lang.Double")){
                return rs.getDouble(fieldName);
            }else if(type.equals("long") || type.equals("class java.lang.Long")){
                return rs.getLong(fieldName);
            }else if(type.equals("class java.lang.String")){
                return rs.getString(fieldName);
            }else if(type.equals("class java.sql.Timestamp")){
                return rs.getTimestamp(fieldName);
            }else if(type.equals("class java.sql.Date")){
                return rs.getDate(fieldName);
            }else if(type.equals("class java.sql.Time")){
                return rs.getTime(fieldName);
            }
        }catch(SQLException e){
            throw new SQLException("SQLException when get field:" + fieldName + "\n" + e);
        }
        throw new RuntimeException("getValueFromRsByField fail, field type is:" + type + ",field name is:" + fieldName);
    }
    /*** 
     * 关闭数据库多个结果集 
     * @param rss
     */
    public static void closeRs(ResultSet... rss){
        for(ResultSet rs: rss){
            if(rs != null){
                try {
                    rs.close();
                } catch (SQLException e) {
                }
            }
        }
    }
    /**
     * 关闭数据库多个psts 
     * @param psts
     */
    public static void closePst(Statement... psts){
        for(Statement pst: psts){
            if(pst != null){
                try {
                    pst.close();
                } catch (SQLException e) {
                }
            }
        }
    }
    /**
     * 关闭数据库所得到的多个链接 
     * @param cons
     */
    public static void closeCon(Connection... cons){
        for(Connection con: cons){
            if(con != null)
            {
                try {
                    con.close();
                } catch (SQLException e) {
                }
            }
        }
    }
}  

dependence  dao类

import java.sql.Date;
import java.util.ArrayList;
import java.util.List;


public class dependency{

    private String etl_system;//系统名
    private String etl_job;//任务名
    private String dependency_system;//依赖系统名
    private String dependency_job;//依赖任务名
    private String description;//描述
    private String enable;//使能状态
    private String dep_mode;//依赖模式

    public String get_enable() {
        return enable;
    }

    public void set_enable(String remark) {
        this.enable = enable;
    }
    public String toString(){
        return "这个依赖的状态是: "+this.enable+" 代表:哈哈！ ";
    }
    //@Override  
    public String tagetTableName() {
        return "ETL_JOB_DEPENDENCY";
    }

    //@Override  
    public List<String> unEditFields() {
        List<String> list = new ArrayList<String>();
        list.add("remark");
        return list;
    }

    public String getEtl_system() {
        return etl_system;
    }

    public void setEtl_system(String etl_system) {
        this.etl_system = etl_system;
    }

    public String getEtl_job() {
        return etl_job;
    }

    public void setEtl_job(String etl_job) {
        this.etl_job = etl_job;
    }

    public String getDependency_system() {
        return dependency_system;
    }

    public void setDependency_system(String number_dependency_systemplate_type_id) {
        this.dependency_system = dependency_system;
    }

    public String getDependency_job() {
        return dependency_job;
    }

    public void setDependency_job(String dependency_job) {
        this.dependency_job = dependency_job;
    }

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }

    public String getDep_mode() {
        return dep_mode;
    }

    public void setColor(String dep_mode) {
        this.dep_mode = dep_mode;
    }
}  

连接数据库类connect_db

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.PrintStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.List;
public class connect_db {

    //这里是SqlConnection 类

    /*
     *java连接mysql数据库
     *1、加载驱动程序
     *2、数据库连接字符串"jdbc:mysql://localhost:3306/数据库名?"
     *3、数据库登录名
     *3、数据库登录密码
     */

    private static final String URL="jdbc:mysql://192.168.31.161:3306/pelt";//数据库连接字符串
    //private static final String URL="jdbc:mysql://192.168.31.161:3306/pelt?useUnicode\=true&characterEncoding\=UTF-8&zeroDateTimeBehavior\=convertToNull";
    private static final String NAME="root";//登录名
    private static final String PASSWORD="123456";//密码
    //声明Connection对象
    Connection conn = null;
    Statement stmt = null;

    public Connection Db_Conn(){
        Connection c = null;
        try {
            Class.forName("com.mysql.jdbc.Driver");
            conn = DriverManager.getConnection(URL, NAME, PASSWORD);
            if(!conn.isClosed())
                System.out.println("Succeeded connecting to the Database!");
            System.out.println("获取数据库连接成功！");
        } catch (ClassNotFoundException e) {
            System.out.println("未能成功加载驱动程序，请检查是否导入驱动程序！");
            //添加一个println，如果加载驱动异常，检查是否添加驱动，或者添加驱动字符串是否错误
            e.printStackTrace();
        } catch ( Exception e ) {
            System.err.println( e.getClass().getName()+": "+ e.getMessage() );
            System.exit(0);
        }
        return conn;
    }
    public Statement Db_Stat(Connection c){
        Statement stmt=null;
        try {
            stmt = c.createStatement();
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return stmt;
    }
    public void Db_Stat_Closed(Statement stmt){
        try {
            stmt.close();
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            throw new RuntimeException(e);
        }
    }
    public void Db_Conn_Closed(Connection c){
        try {
            c.close();

        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            throw new RuntimeException(e);
        }
    }
    public String Return_sql(String sql,String tar_db){
        conn=Db_Conn();
        stmt=Db_Stat(conn);
        ResultSet resultSet=null;
        int columnCount=0;
        try {
            resultSet = stmt.executeQuery(sql);
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        ResultSetMetaData rsmd = null;
        try {
            rsmd = resultSet.getMetaData();
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        try {
            columnCount = rsmd.getColumnCount();
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        String result="";
        String result1="";
        String insert="insert into "+tar_db+" values(";
        //stmt.executeUpdate(sql1);
        //stmt.executeUpdate(sql2);
        try {
            while(resultSet.next()){
                //取出列值
                for(int i=1;i<=columnCount;i++)
                {
                    if(i==1){
                        String name = resultSet.getString(i);
                        if(name==null){
                            name="0";
                        }
                        result=insert+"'"+name+"'";
                    }else if(i==columnCount){
                        String name = resultSet.getString(i);
                        if(name==null){
                            name="0";
                        }
                        result=result+",'"+name+"');\n";
                    }else{
                        String name = resultSet.getString(i);
                        if(name==null){
                            name="0";
                        }
                        result=result+",'"+name+"'";
                    }

                }
                result1=result1+result;
            }
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally{
            Db_Stat_Closed(stmt);
            Db_Conn_Closed(conn);
        }

        return result1;

    }

   
    public void WriteStringToFile(String result) {
        try {
            File file = new File("aaa.txt");
            PrintStream ps = new PrintStream(new FileOutputStream(file));
            ps.print(result);// 往文件里写入字符串
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    public void InsertintoDb(String sql){
        conn=Db_Conn();
        stmt=Db_Stat(conn);
        int rel=-1;
        try {
            rel=stmt.executeUpdate(sql);
            if(rel>0){
                System.out.println(sql+" successful!!");
            }else{
                System.out.println(sql+" unsuccessful!!");
            }
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally{
            Db_Stat_Closed(stmt);
            Db_Conn_Closed(conn);
        }


    }
    public void exectedroptable(String tablename){
        conn=Db_Conn();
        stmt=Db_Stat(conn);
        String sql="drop table "+tablename;
        int rel=-1;
        try {
            rel=stmt.executeUpdate(sql);
            if(rel>0){
                System.out.println("drop"+tablename+" successful!!");
            }else{
                System.out.println("drop"+tablename+" unsuccessful!!");
            }
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally{
            Db_Stat_Closed(stmt);
            Db_Conn_Closed(conn);
        }


    }

    public  List<String> queryList(String sql){
        ResultSet resultSet=null;
        conn=Db_Conn();
        stmt=Db_Stat(conn);
        List<String>  dataList = new ArrayList<String>();
        try {
            resultSet=stmt.executeQuery(sql);
            try{
                while(resultSet.next()){
                    String name = resultSet.getString(1);
                    dataList.add(name);
                }
            }catch(SQLException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }finally{
                Db_Stat_Closed(stmt);
                Db_Conn_Closed(conn);
            }

        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        return  dataList;
    }
}