NewEngine.git - Gitblit

package databases;
 
import java.io.*;
import java.sql.*;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Locale;
import java.util.Map;
import java.util.MissingResourceException;
import java.util.Properties;
import java.util.PropertyResourceBundle;
import java.util.ResourceBundle;
 
import window.Windows;
 
import java.util.Enumeration;
import java.util.HashMap;
import java.util.List;
import java.util.Collections;
import java.util.ArrayList;
import java.util.Arrays;
 
public class DBConnector {
    // ÅäÖÃ²ÎÊý
    private static String dbUser;
    private static String dbPass;
    private static String dbPort;
    private static String dbAddress;
    private static final String DB_NAME = "hxzk";
    static Connection conn;
    
    // ÓïÑÔÉèÖÃ£¨Ä¬ÈÏÖÐÎÄ£©
    private static Locale currentLocale = Locale.SIMPLIFIED_CHINESE;
    private static ResourceBundle messages;
    
    // ÎÄ¼þÂ·¾¶
    private static final String CONFIG_PATH = "systemfile/system.txt";
    private static final String LOG_DIR = "systemfile/";
    private static final String LANG_DIR = "systemfile/";
    
    static {
        // ¼ÓÔØÄ¬ÈÏÓïÑÔ
        setLanguage("zh");
        // ¼ÓÔØÅäÖÃÎÄ¼þ
        loadConfig();
    }
 
    // ÉèÖÃÓïÑÔ - ´Ó systemfile ÎÄ¼þ¼Ð¼ÓÔØ
    public static void setLanguage(String langCode) {
        if ("en".equalsIgnoreCase(langCode)) {
            currentLocale = Locale.ENGLISH;
        } else {
            currentLocale = Locale.SIMPLIFIED_CHINESE;
        }
        
        // ³¢ÊÔ´Ó systemfile ¼ÓÔØÓïÑÔÎÄ¼þ
        messages = loadResourceBundle(currentLocale);
    }
 
    // ´ÓÎÄ¼þÏµÍ³¼ÓÔØ×ÊÔ´°ü
    private static ResourceBundle loadResourceBundle(Locale locale) {
        String langSuffix = locale.getLanguage();
        String fileName = "Messages_" + langSuffix + ".properties";
        File langFile = new File(LANG_DIR + fileName);
        
        // È·±£Ä¿Â¼´æÔÚ
        File langDir = new File(LANG_DIR);
        if (!langDir.exists()) {
            langDir.mkdirs();
        }
        
        // ³¢ÊÔ¼ÓÔØÎÄ¼þ
        if (langFile.exists()) {
            try (InputStream is = new FileInputStream(langFile)) {
                return new PropertyResourceBundle(is);
            } catch (IOException e) {
                System.err.println("ÓïÑÔÎÄ¼þ¼ÓÔØÊ§°Ü: " + e.getMessage());
            }
        }
        
        // ÎÄ¼þ²»´æÔÚÊ±Ê¹ÓÃÄÚÖÃÄ¬ÈÏÖµ
        System.err.println("¾¯¸æ£ºÎ´ÕÒµ½ÓïÑÔÎÄ¼þ " + fileName + "£¬Ê¹ÓÃÄÚÖÃÄ¬ÈÏÏûÏ¢");
        return new ResourceBundle() {
            @Override
            protected Object handleGetObject(String key) {
                switch (key) {
                    case "CONFIG_READ_ERROR":return "ÅäÖÃÎÄ¼þ¶ÁÈ¡´íÎó";
                    case "INCOMPLETE_CONFIG":return "Êý¾Ý¿âÅäÖÃÐÅÏ¢²»ÍêÕû";
                    case "DB_CONNECTION_FAIL":return "Êý¾Ý¿âÁ¬½ÓÊ§°Ü";
                    case "LOG_WRITE_FAIL":return "ÈÕÖ¾ÎÄ¼þÐ´ÈëÊ§°Ü";
                    case "DB_UPDATE_ERROR": return "Êý¾Ý¸üÐÂÊ§°Ü";
                    case "DB_INSERT_ERROR": return "Êý¾Ý²åÈëÊ§°Ü";
                    case "DB_DELETE_ERROR": return "Êý¾ÝÉ¾³ýÊ§°Ü";
                    case "DB_TRUNCATE_ERROR": return "Çå¿Õ±íÊý¾ÝÊ§°Ü";
                    case "FIELD_VALIDATION_FAIL": return "×Ö¶ÎÑéÖ¤Ê§°Ü";
                    case "DEVICE_ID_EXISTS": return "Éè±¸±àºÅÒÑ´æÔÚ";
                    case "INVALID_NUMBER_FORMAT": return "ÎÞÐ§µÄÊý×Ö¸ñÊ½"; 
                    // Ìí¼ÓÈ±Ê§µÄ¼ü
                    case "DB_QUERY_ERROR": return "Êý¾Ý¿â²éÑ¯Ê§°Ü";
                    default: 
                        return key;
                }
            }
            
            @Override
            public Enumeration<String> getKeys() {
                return Collections.enumeration(
                    Arrays.asList(
                            "CONFIG_READ_ERROR", 
                            "INCOMPLETE_CONFIG", 
                            "DB_CONNECTION_FAIL", 
                            "LOG_WRITE_FAIL",
                            "DB_UPDATE_ERROR",
                            "DB_INSERT_ERROR",
                            "DB_DELETE_ERROR",
                            "DB_TRUNCATE_ERROR",
                            "FIELD_VALIDATION_FAIL",
                            "DEVICE_ID_EXISTS",
                            "INVALID_NUMBER_FORMAT",
                            "DB_QUERY_ERROR"  // Ìí¼ÓÈ±Ê§µÄ¼ü
                    )
                );
            }
        };
    }
 
    // ¼ÓÔØÅäÖÃÎÄ¼þ
    private static void loadConfig() {
        File configFile = new File(CONFIG_PATH);
        if (!configFile.exists()) {
            logError("CONFIG_READ_ERROR", "ÅäÖÃÎÄ¼þ²»´æÔÚ: " + CONFIG_PATH);
            return;
        }
        
        try (BufferedReader reader = new BufferedReader(new FileReader(configFile))) {
            String line;
            while ((line = reader.readLine()) != null) {
                if (line.startsWith("dbName:")) {
                    dbUser = line.substring(7).trim();
                } else if (line.startsWith("dbPass:")) {
                    dbPass = line.substring(7).trim();
                } else if (line.startsWith("databaseport:")) {
                    dbPort = line.substring(13).trim();
                } else if (line.startsWith("databaseadress:")) {
                    dbAddress = line.substring(15).trim();
                }
            }
        } catch (IOException e) {
            logError("CONFIG_READ_ERROR", e.getMessage());
        }
    }
 
       
    private static void logError(String errorCode, String detail) {
        String logFileName = LOG_DIR + new SimpleDateFormat("yyyyMMdd").format(new Date()) + "log.txt";
        
        // È·±£ÈÕÖ¾Ä¿Â¼´æÔÚ
        File logDir = new File(LOG_DIR);
        if (!logDir.exists()) {
            logDir.mkdirs();
        }
        
        try (PrintWriter writer = new PrintWriter(new FileWriter(logFileName, true))) {
            String timestamp = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());
            
            // °²È«»ñÈ¡×ÊÔ´×Ö·û´®£¬±ÜÃâMissingResourceException
            String message;
            try {
                message = messages.getString(errorCode);
            } catch (MissingResourceException e) {
                message = errorCode; // Ê¹ÓÃ´íÎó´úÂë×÷Îª»ØÍËÏûÏ¢
            }
            
            if (detail != null) {
                message += ": " + detail;
            }
            
            writer.println("[" + timestamp + "] " + message);
        } catch (IOException e) {
            System.err.println("ÈÕÖ¾Ð´ÈëÊ§°Ü: " + e.getMessage());
        }
    }
 
    // Êý¾Ý¿âÁ¬½Ó·½·¨ - Ìí¼ÓUTF-8×Ö·û¼¯Ö§³Ö
    public static Connection connectToDatabase() {
        // ¼ì²éÅäÖÃÍêÕûÐÔ
        if (dbUser == null || dbPass == null || dbPort == null || dbAddress == null) {
            logError("INCOMPLETE_CONFIG", null);
            return null;
        }
 
        // Ìí¼Ó×Ö·û¼¯²ÎÊý£ºuseUnicode=true&characterEncoding=UTF-8
        String url = "jdbc:mysql://" + dbAddress + ":" + dbPort + "/" + DB_NAME + 
                     "?useUnicode=true&characterEncoding=UTF-8";
        
        Properties properties = new Properties();
        properties.setProperty("user", dbUser);
        properties.setProperty("password", dbPass);
        properties.setProperty("useSSL", "false");
        properties.setProperty("serverTimezone", "UTC");
 
        try {
           conn = DriverManager.getConnection(url, properties);
            return conn;
        } catch (SQLException e) {
            logError("DB_CONNECTION_FAIL", e.getMessage());
            return null;
        }
    }
    
    /**
     * ²éÑ¯Ö¸¶¨±íµÄËùÓÐÊý¾Ý
     * @param tableName Òª²éÑ¯µÄ±íÃû
     * @return °üº¬±íÖÐËùÓÐÊý¾ÝµÄList£¬Ã¿¸öÔªËØÊÇÒ»¸öMap±íÊ¾Ò»ÐÐÊý¾Ý
     */
    public static ResultSet queryTableData(String tableName) {            
        Statement stmt = null;
        ResultSet rs = null;
        
        // ÑéÖ¤±íÃûÓÐÐ§ÐÔ
        if (tableName == null || tableName.trim().isEmpty()) {
            logError("DB_QUERY_ERROR", "ÎÞÐ§µÄ±íÃû: " + tableName);
            return rs;
        }
        
        try {
            conn = connectToDatabase();
            if (conn == null) {
                logError("DB_CONNECTION_FAIL", "ÎÞ·¨Á¬½Óµ½Êý¾Ý¿â");
                return rs;
            }
            
            stmt = conn.createStatement();
            String sql = "SELECT * FROM " + tableName;
            rs = stmt.executeQuery(sql);            
            
        } catch (SQLException e) {
            logError("DB_QUERY_ERROR", "²éÑ¯±í[" + tableName + "]Ê§°Ü: " + e.getMessage());
            e.printStackTrace();
        } 
        
        return rs;
    }
    
    public static void lianjieshujuku() {
         // ÉèÖÃÓïÑÔ£¨Ä¬ÈÏÎªÖÐÎÄ£¬¿ÉÇÐ»»ÎªÓ¢ÎÄ£©
        String language = "zh"; // Ä¬ÈÏÖÐÎÄ
        // String language = "en"; // ÇÐ»»ÎªÓ¢ÎÄ
        
        DBConnector.setLanguage(language);
        
        System.out.println("ÕýÔÚÁ¬½ÓÊý¾Ý¿â...");
        Connection conn = DBConnector.connectToDatabase();
        
        if (conn != null) {
            System.out.println("Êý¾Ý¿âÁ¬½Ó³É¹¦£¡");
            
            // ´´½¨²¢ÏÔÊ¾´°Ìå
            java.awt.EventQueue.invokeLater(() -> {
                Locale locale = "en".equals(language) ? Locale.ENGLISH : Locale.SIMPLIFIED_CHINESE;
                Windows window = new Windows("¶¨Î»¹ÜÀíÏµÍ³", conn, locale);
                window.setVisible(true);
            });
            
            // Ê¾Àý£ºÖ´ÐÐ¼òµ¥²éÑ¯
            try (java.sql.Statement stmt = conn.createStatement();
                 java.sql.ResultSet rs = stmt.executeQuery("SELECT VERSION()")) {
                
                if (rs.next()) {
                    System.out.println("MySQL°æ±¾: " + rs.getString(1));                   
                }
                
            } catch (Exception e) {
                System.err.println("²éÑ¯Ê§°Ü: " + e.getMessage());
            }
        } else {
            System.out.println("Êý¾Ý¿âÁ¬½ÓÊ§°Ü£¬Çë¼ì²éÈÕÖ¾ÎÄ¼þ");
        }
    }
    
    // 1. ÐÞ¸ÄÊý¾Ý¿âÄÚÈÝ
    public static int updateData(String tableName, Map<String, String> fieldValues, int id) {
        if (fieldValues == null || fieldValues.isEmpty()) {
            return 0;
        }
        
        StringBuilder sql = new StringBuilder("UPDATE " + tableName + " SET ");
        List<String> values = new ArrayList<>();
        
        // ¹¹½¨SET×Ó¾ä
        for (Map.Entry<String, String> entry : fieldValues.entrySet()) {
            sql.append(entry.getKey()).append(" = ?, ");
            values.add(entry.getValue());
        }
        sql.delete(sql.length() - 2, sql.length()); // É¾³ý×îºóµÄ¶ººÅºÍ¿Õ¸ñ
        sql.append(" WHERE id = ?");
        
        try (Connection conn = connectToDatabase();
             PreparedStatement pstmt = conn.prepareStatement(sql.toString())) {
            
            // ÉèÖÃ²ÎÊý
            int index = 1;
            for (String value : values) {
                pstmt.setString(index++, value);
            }
            pstmt.setInt(index, id);
            
            return pstmt.executeUpdate();
        } catch (SQLException e) {
            logError("DB_UPDATE_ERROR", "±í: " + tableName + ", ID: " + id + ", ´íÎó: " + e.getMessage());
            return 0;
        }
    }
    
    // ÐÂÔö£º¸üÐÂÏµÍ³ÅäÖÃ×Ö¶Î
    // ÐÞ¸Ä¸üÐÂ·½·¨
    public static int updateSystemConfiguration(String field, String value) {
        String column = camelToUnderline(field); // ×ª»»×Ö¶ÎÃû
        Map<String, String> fieldValues = new HashMap<>();
        fieldValues.put(column, value);
        return updateData("system_configuration", fieldValues, 1);
    }
    // 2. ÐÂÔöÊý¾Ý¿âÄÚÈÝ
    public static int insertData(String tableName, Map<String, String> fieldValues) {
        if (fieldValues == null || fieldValues.isEmpty()) {
            return 0;
        }
        
        StringBuilder columns = new StringBuilder("(");
        StringBuilder placeholders = new StringBuilder("(");
        List<String> values = new ArrayList<>();
        
        // ¹¹½¨ÁÐÃûºÍÕ¼Î»·û
        for (Map.Entry<String, String> entry : fieldValues.entrySet()) {
            columns.append(entry.getKey()).append(", ");
            placeholders.append("?, ");
            values.add(entry.getValue());
        }
        columns.delete(columns.length() - 2, columns.length()).append(")");
        placeholders.delete(placeholders.length() - 2, placeholders.length()).append(")");
        
        String sql = "INSERT INTO " + tableName + " " + columns + " VALUES " + placeholders;
        
        try (Connection conn = connectToDatabase();
             PreparedStatement pstmt = conn.prepareStatement(sql)) {
            
            // ÉèÖÃ²ÎÊý
            for (int i = 0; i < values.size(); i++) {
                pstmt.setString(i + 1, values.get(i));
            }
            
            return pstmt.executeUpdate();
        } catch (SQLException e) {
            logError("DB_INSERT_ERROR", "±í: " + tableName + ", ´íÎó: " + e.getMessage());
            return 0;
        }
    }
 
    // 3. É¾³ýÖ¸¶¨Êý¾Ý
    public static int deleteDataById(String tableName, int id) {
        String sql = "DELETE FROM " + tableName + " WHERE id = ?";
        
        try (Connection conn = connectToDatabase();
             PreparedStatement pstmt = conn.prepareStatement(sql)) {
            
            pstmt.setInt(1, id);
            return pstmt.executeUpdate();
        } catch (SQLException e) {
            logError("DB_DELETE_ERROR", "±í: " + tableName + ", ID: " + id + ", ´íÎó: " + e.getMessage());
            return 0;
        }
    }
 
    // 4. É¾³ýËùÓÐÊý¾Ý
    public static int truncateTable(String tableName) {
        String sql = "DELETE FROM " + tableName; // Ê¹ÓÃDELETE¶ø·ÇTRUNCATE
        
        try (Connection conn = connectToDatabase();
             Statement stmt = conn.createStatement()) {
            
            return stmt.executeUpdate(sql); // ·µ»ØÉ¾³ýµÄÐÐÊý
        } catch (SQLException e) {
            logError("DB_TRUNCATE_ERROR", "±í: " + tableName + ", ´íÎó: " + e.getMessage());
            return 0;
        }
    }
 
    /**
     * Ö´ÐÐSQL²éÑ¯Óï¾ä
     * @param sql ÒªÖ´ÐÐµÄSQL²éÑ¯Óï¾ä
     * @return ²éÑ¯½á¹û¼¯ResultSet
     */
    public static ResultSet executeQuery(String sql) {
        Connection conn = null;
        Statement stmt = null;
        ResultSet rs = null;
        
        try {
            conn = connectToDatabase();
            if (conn == null) {
                logError("DB_CONNECTION_FAIL", "ÎÞ·¨Á¬½Óµ½Êý¾Ý¿â");
                return null;
            }
            
            stmt = conn.createStatement();
            rs = stmt.executeQuery(sql);
            return rs;
            
        } catch (SQLException e) {
            logError("DB_QUERY_ERROR", "Ö´ÐÐSQL²éÑ¯Ê§°Ü: " + e.getMessage() + "\nSQL: " + sql);
            e.printStackTrace();
            return null;
        }
        // ×¢Òâ£ºµ÷ÓÃÕßÐèÒª×ÔÐÐ¹Ø±ÕResultSet¡¢StatementºÍConnection
    }
    
    /**
     * Ö´ÐÐ¶¯Ì¬¹¹½¨µÄSQL²éÑ¯
     * @param tableName ±íÃû
     * @param columns ²éÑ¯µÄÁÐ£¨¶ººÅ·Ö¸ô£¬null±íÊ¾ËùÓÐÁÐ£©
     * @param whereClause WHEREÌõ¼þ£¨¿Énull£©
     * @param orderBy ORDER BY×Ó¾ä£¨¿Énull£©
     * @return ²éÑ¯½á¹û¼¯ResultSet
     */
    public static ResultSet executeQuery(String tableName, String columns, String whereClause, String orderBy) {
        // ÑéÖ¤±íÃûÓÐÐ§ÐÔ
        if (tableName == null || tableName.trim().isEmpty()) {
            logError("DB_QUERY_ERROR", "ÎÞÐ§µÄ±íÃû: " + tableName);
            return null;
        }
        
        // ¹¹½¨SQLÓï¾ä
        StringBuilder sqlBuilder = new StringBuilder("SELECT ");
        sqlBuilder.append(columns != null ? columns : "*")
                  .append(" FROM ")
                  .append(tableName);
        
        if (whereClause != null && !whereClause.trim().isEmpty()) {
            sqlBuilder.append(" WHERE ").append(whereClause);
        }
        
        if (orderBy != null && !orderBy.trim().isEmpty()) {
            sqlBuilder.append(" ORDER BY ").append(orderBy);
        }
        
        // µ÷ÓÃÍ¨ÓÃ²éÑ¯·½·¨
        return executeQuery(sqlBuilder.toString());
    }
    
    /**
     * Ö´ÐÐ´ø²ÎÊýµÄSQL¸üÐÂ²Ù×÷£¨INSERT, UPDATE, DELETE£©
     * @param sql ´ø²ÎÊýµÄSQLÓï¾ä
     * @param params ²ÎÊýÁÐ±í
     * @return ÊÜÓ°ÏìµÄÐÐÊý
     * @throws SQLException Èç¹ûÊý¾Ý¿â²Ù×÷Ê§°Ü
     */
    public static int executeUpdate(String sql, Object... params) throws SQLException {
        try (Connection conn = connectToDatabase();
             PreparedStatement pstmt = conn.prepareStatement(sql)) {
            
            // ÉèÖÃ²ÎÊý
            for (int i = 0; i < params.length; i++) {
                pstmt.setObject(i + 1, params[i]);
            }
            
            return pstmt.executeUpdate();
        } catch (SQLException e) {
            logError("DB_UPDATE_ERROR", "Ö´ÐÐSQL¸üÐÂÊ§°Ü: " + e.getMessage() + "\nSQL: " + sql);
            throw e;
        }
    }
   
 // ÐÂÔö·½·¨£ºÍÕ·å×ªÏÂ»®Ïß
    public static String camelToUnderline(String camel) {
        if (camel == null || camel.isEmpty()) return camel;
        StringBuilder sb = new StringBuilder();
        for (char c : camel.toCharArray()) {
            if (Character.isUpperCase(c)) {
                sb.append('_').append(Character.toLowerCase(c));
            } else {
                sb.append(c);
            }
        }
        return sb.toString();
    }
 
 // Ìí¼Ó²ÎÊý»¯²éÑ¯·½·¨
    public static ResultSet executeQuery(String sql, Object... params) throws SQLException {
        Connection conn = connectToDatabase();
        if (conn == null) {
            throw new SQLException("ÎÞ·¨Á¬½Óµ½Êý¾Ý¿â");
        }
        PreparedStatement pstmt = conn.prepareStatement(sql);
        for (int i = 0; i < params.length; i++) {
            pstmt.setObject(i + 1, params[i]);
        }
        return pstmt.executeQuery();
    }
    
}