数据库连接 简单飞扬

//数据库连接 2个类
////////////////////////////////////////////////////////////////////////////////////
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import java.sql.PreparedStatement;


/**
 *
 *
 *
 *
 *
 *
 * */
public class Jc {

    private static String url = "jdbc:mysql://localhost:3306/jav";

    private static String user = "root";

    private static String pass = "";
    
    private static String ForName = "com.mysql.jdbc.Driver";

    private static ResultSet rs;

    private static Connection con;

    private static PreparedStatement p;

    /**
     *  数据库连接
     * @return
     */
    public static Connection getConnection()  {
        try {
            Class.forName(ForName);
            con = DriverManager.getConnection(url, user, pass);
            
        } catch (Exception e) {
            System.err.println("数据库连接失败+++++++++++++++"+e);
        }
        return con;
    }

    /**
     * 获得数据库操作对象 PreparedStatement
     * @param sql
     * @return
     */
    public static PreparedStatement getPrepareStatement(String sql) {
        try {
            p = getConnection().prepareStatement(sql);
        } catch (Exception e) {
        }
        return p;
    }

    /**
     * 除查询以外的数据库操作
     * @param sql
     */
    public static void noSelect(String sql)  {
        try {
            getConnection().prepareStatement(sql).executeUpdate();
        } catch (Exception e) {
            System.err.println("数据库操作失败"+e);
        }
    }

    /**
     * 获取数据库查询结果
     * @param sql
     * @return
     */
    public static ResultSet getResultSet(String sql)  {
        try {
            rs = getConnection().prepareStatement(sql).executeQuery();
        } catch (Exception e) {
            System.err.println("获取查询结果失败！"+e);
        }
        return rs;
    }

    /**
     * 获取数据库查询结果 并装进数组 再装进list 返回
     * @param sql
     * @param table
     * @return
     * @throws Exception
     */
    public static List getResult(String sql,String table) throws Exception {
        List list = new ArrayList();
        String s = sql.trim().toLowerCase();
        String[] str = new F().getArray(table);

        if (s.startsWith("select")) {
            ResultSet rs = getResultSet(sql);
            while (rs.next()) {
                String[] a=new String[str.length];
                for (int i = 0; i < str.length; i++) {
                    a[i]=rs.getString(str[i]);
                }
                list.add(a);
            }
            return list;
        } else {
            noSelect(sql);
            return null;
        }
    }

    public static void main(String[] args) {
        
        String sql = "insert into asdf(sdf,sdfs) values(4,'撒旦')";
        noSelect(sql);
        
    }
    
    
    /**
     *
     *
     * 把Jc和F结合起来－ ： 直接连接数据库 得到rs 同时 调用F的方法 取代 数据库表的 domain -－－ －－然后，如果是
     * 查询数据库，就返回查询结果list ----－－如果是其他数据库操作，就返回null
     *
     *
     *
     */


    /**
     *
     * @param pass
     */
    public void setPass(String pass) {
        this.pass = pass;
    }

    /**
     *
     * @param user
     */
    public  void setUser(String user) {
        this.user = user;
    }
    
    /**
     *
     *     关闭数据库连接
     */
    public static void closeConnect(){
        if(con!=null){
            try {
                con.close();
            } catch (Exception e) {
                System.err.println("关闭数据库连接失败！"+e);
            }
        }
    }
    
    /**
     *
     *        关闭数据库查询结果
     */
    public static void closeResultSet(){
        if(rs!=null){
            try {
            rs.close();
            } catch (Exception e) {
                System.err.println("关闭数据库查询结果失败！"+e);
            }
        }
    }
    
    /**
     *
     *        关闭PreparedStatement
     */
    public static void closePreparedStatement(){
        if(p!=null){
            try {
            p.close();
            } catch (Exception e) {
                System.err.println("关闭PreparedStatement失败！"+e);
            }
        }
    }
    
    /**
     *
     *        关闭所有连接
     */
    public static void close(){
        closeResultSet();
        closePreparedStatement();
        closeConnect();
    }
    
}


////////////////////////////////////////////////////////////////////////////////////////

package action;

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

public class F {
//    F f = new F();

    public String getA(String sql) throws Exception {/**从查询语句中截取结果所在的列名*/
        String s1 = sql.trim().toLowerCase();
        return s1.substring(6, s1.indexOf("from")).trim();
    }

    public String getB(String sql) {/**从查询语句中截取表名*/
        String la = "";
        String sq = sql.trim().toLowerCase();
        if (sq.contains("where")) {
            la = (sq.substring(sq.indexOf("from") + 4, sq.indexOf("where"))
                    .trim());

        } else if (sq.contains("limit")) {
            la = (sq.substring(sq.indexOf("from") + 4, sq.indexOf("limit"))
                    .trim());

        } else if (sq.contains("top")) {
            la = (sq.substring(sq.indexOf("from") + 4, sq.indexOf("top"))
                    .trim());
        } else {
            la = sq.substring(sq.indexOf("from") + 4).trim();
        }
        return la;
    }

    public String getLName(String sql) throws Exception {
        String ld = "";
        String lc = "";
        String s1 = sql.trim().toLowerCase();
        ld = s1.substring(6, s1.indexOf("from")).trim();
        if (ld.startsWith("max")) {
            ld = ld.substring(ld.indexOf("("), ld.indexOf(")"));
            if (ld.contains(".")) {
                ld = ld.substring(ld.indexOf(".") + 1);
                lc = ld;
            }
        } else if (ld.contains("*")) {
            ResultSet rs = Jc.getResultSet("desc " + getTName(sql));
            while (rs.next()) {
                lc += rs.getString("Field") + ",";
            }
        } else if (ld.contains(".")) {
            ld = ld.substring(ld.indexOf(".") + 1);
            lc = ld;
        } else {
            lc = ld;
        }
        return lc;
    }

    public String getTName(String sql) {
        String[] c2 = getB(sql).split(" ");
        return c2[0];
    }

    /**
     * 根据传进来的sql语句 得出所有查询结果所在列的列名 把结果以数组的形式返回
     * 这个方法 主要是处理复合查询 －当查询结果两个或更多表中时 对其进行处理
     *开始时候 是想返回一条包含了所有查询结果的字符串     并且 不同的查询结果之间，不同表的查询结果  之间 以一定的形式隔开
     *
     *但是，后来发现 查询结果在多个表中的情况并不常见   在这时 返回结果中包含表名的话 反而 罗嗦   索性就把返回的 表名删掉了
     *同时  数组形式的数据     在网页中不容易显示 就把这个方法改动了
     *
     *最后检查时 才发现 ，最初写这个方法时 所要处理的问题 和  这个方法里 大部分的逻辑处理  都被 闲置了！都成了无用的东西。。
     *
     *
     *应对新的需求 返回的结果显的罗嗦   方法的内容有点多余
     *应对之前的需求   此方法已经不能胜任－-－>现在 这个方法 已经彻底被 改废了
     *
     *
     */
    public String[] getL(String str) {

        List list = new ArrayList();
        String lf = "";
        try {
            String sql = new String(str).trim().toLowerCase();
            // 如果查询结果不在一张表内
            if (sql.contains(",")) {
                // 得到基础字段
                String a = getA(sql);
                String b = getB(sql);
                // 得到单一字段
                String[] a0 = a.trim().split(",");
                String[] b0 = b.trim().split(",");
                /**  双循环 遍历 比较2个数组 中的字段 把相同的一起取出---
                // 把表后面写的别名与 列名前面写的别名 比较－－－找到，就放在一起*/
                for (int i = 0; i < a0.length; i++) {
                    for (int k = 0; k < b0.length; k++) {
                        if (a0[i].contains("max") || a0[i].contains("min")) {
                            a0[i] = a0[i].substring(a0[i].indexOf("(") + 1,
                                    a0[i].indexOf(")"));
                        }
                        // 列名前的别名
                        String aa = a0[i].substring(0, a0[i].indexOf("."))
                                .trim();
                        // 列名
                        String ab = a0[i].substring(a0[i].indexOf(".") + 1)
                                .trim();
                        // 表名后的别名
                        String bb = b0[k].substring(b0[k].indexOf(" ")).trim();
                        // 表名
                        String ba = b0[k].substring(0, b0[k].indexOf(" "))
                                .trim();
                        if ((aa).equals(bb)) {
                            if (ab.contains("*")) {
                                ResultSet rs = Jc.getResultSet("desc " + ba);
                                ab = "";
                                while (rs.next()) {
                                    ab += rs.getString("Field") + ",";
                                }
                            }
                            lf = ab.trim();
                        }
                    }    
                }
            } else
                lf += getLName(sql);
        } catch (Exception e) {
        } finally {
            return lf.split(",");
        }
    }

/**
 *
 *  传进表名 返回此表所 对应的所有列名
 * @param table
 * @return List
 */
    public List getList(String table) {
        List list = new ArrayList();
        try {
            ResultSet rs = Jc.getResultSet("desc " + table);
            while (rs.next()) {
                if(rs.getString("Field")==null||rs.getString("Field")=="")
                    continue;
                list.add(rs.getString("Field"));
            }
        } catch (Exception e) {
            System.err.println("数据库查询列名出错" + e);
        }
        if (list == null || list.size() == 0) {
            throw new RuntimeException("没有查到此表名所对应的列名");
        }
        return list;
    }
    

    /**
     *
     *  传进表名 返回此表所 对应的所有列名
     *  
     * @param table
     * @return String[]
     */
    public String[] getArray(String table) {
        String k="";
        try {
            ResultSet rs = Jc.getResultSet("desc " + table);
            while (rs.next()) {
                if(rs.getString("Field")==null||rs.getString("Field")=="")
                    continue;
                k+=rs.getString("Field")+",";
            }
        } catch (Exception e) {
            System.err.println("数据库查询列名出错" + e);
        }
        if ( k == "") {
            throw new RuntimeException("没有查到此表名所对应的列名");
        }
    
        return k.split(",");
    }
    
    public static void main(String[] args) throws Exception {
        String sql = "SELECT * FROM ls.department where de_name like '%d%'";
        F f = new F();
        String[] a = (f
                .getL("SELECT * FROM ls.department where de_name like '%d%'"));
        for (int i = 0; i < a.length; i++) {
            System.err.println("a[" + i + "] = " + a[i]);
            System.out.println("a.length = " + a.length);
        }
    }
    
    
    public String[] getColumns(String str) {

        List list = new ArrayList();
        String lf = "";
        try {
            String sql = new String(str).trim().toLowerCase();
            // 如果查询结果不在一张表内
            if (sql.contains(",")) {
                
                String a = getA(sql);
                String b = getB(sql);
                
                String[] a0 = a.trim().split(",");
                String[] b0 = b.trim().split(",");
                /**  双循环 遍历 比较2个数组 中的字段 把相同的一起取出---
                // 把表后面写的别名与 列名前面写的别名 比较－－－找到，就放在一起*/
                for (int i = 0; i < a0.length; i++) {
                    for (int k = 0; k < b0.length; k++) {
                        if (a0[i].contains("max") || a0[i].contains("min")) {
                            a0[i] = a0[i].substring(a0[i].indexOf("(") + 1,
                                    a0[i].indexOf(")"));
                        }
                        // 列名前的别名
                        String aa = a0[i].substring(0, a0[i].indexOf("."))
                                .trim();
                        // 列名
                        String ab = a0[i].substring(a0[i].indexOf(".") + 1)
                                .trim();
                        // 表名后的别名
                        String bb = b0[k].substring(b0[k].indexOf(" ")).trim();
                        // 表名
                        String ba = b0[k].substring(0, b0[k].indexOf(" "))
                                .trim();
                        if ((aa).equals(bb)) {
                            if (ab.contains("*")) {
                                ResultSet rs = Jc.getResultSet("desc " + ba);
                                ab = "";
                                while (rs.next()) {
                                    ab += rs.getString("Field") + ",";
                                }
                            }
                            lf = ab.trim();
                        }
                    }    
                }
            } else
                lf += getLName(sql);
        } catch (Exception e) {
        } finally {
            return lf.split(",");
        }
    }

    
    
}