逆向学习 SDK 篇：通过封装来简化代码编写，提高代码复用性

原创

web安全工具库 2024-06-16 18:49:19 ©著作权

©著作权归作者所有：来自51CTO博客作者web安全工具库的原创作品，请联系作者获取转载授权，否则将追究法律责任

本节课在线学习视频（网盘地址，保存后即可免费观看）：

https://pan.quark.cn/s/83dbb1700946

在软件开发中，封装是面向对象编程的重要特性之一。通过封装，我们可以将复杂的实现细节隐藏起来，对外提供简洁的接口，从而简化代码编写，提高代码的复用性和可维护性。本文将详细介绍通过封装来简化代码编写的技术方法，并通过多个代码案例展示如何实现高效的代码复用。

1. 什么是封装

封装是一种将数据和操作数据的方法绑定在一起，并隐藏对象的内部实现细节的技术。通过封装，类的内部实现对外部是不可见的，只有类提供的公共接口可以访问。

2. 为什么需要封装

封装的主要优点包括：

提高代码可读性：通过封装，复杂的实现细节被隐藏起来，对外提供简洁明了的接口，使代码更容易理解。
提高代码复用性：通过封装，通用的功能可以被抽象成类或方法，从而在多个地方复用，减少代码冗余。
提高代码可维护性：封装使得代码模块化，各模块独立开发、测试和维护，降低了修改代码时引入错误的风险。

3. 封装的基本方法

封装的基本方法包括：

将数据成员封装为私有：通过将类的数据成员声明为私有（private）来隐藏内部数据。
提供公共访问方法：通过提供公共的访问方法（例如 getters 和 setters）来访问和修改私有数据。
抽象公共功能：将通用的功能抽象成独立的方法或类，以提高代码的复用性。

4. 代码案例

案例1：封装数据库连接

数据库操作是一个常见的任务，通过封装数据库连接和操作，可以简化代码编写。

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

public class DatabaseHelper {
    private String url;
    private String user;
    private String password;

    public DatabaseHelper(String url, String user, String password) {
        this.url = url;
        this.user = user;
        this.password = password;
    }

    private Connection connect() throws SQLException {
        return DriverManager.getConnection(url, user, password);
    }

    public ResultSet executeQuery(String query) throws SQLException {
        Connection conn = connect();
        PreparedStatement stmt = conn.prepareStatement(query);
        return stmt.executeQuery();
    }

    public int executeUpdate(String query) throws SQLException {
        Connection conn = connect();
        PreparedStatement stmt = conn.prepareStatement(query);
        return stmt.executeUpdate();
    }

    // 关闭连接
    public void closeConnection(Connection conn) {
        if (conn != null) {
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        DatabaseHelper dbHelper = new DatabaseHelper("jdbc:mysql://localhost:3306/testdb", "user", "password");
        try {
            ResultSet rs = dbHelper.executeQuery("SELECT * FROM users");
            while (rs.next()) {
                System.out.println("User: " + rs.getString("username"));
            }

            int rowsAffected = dbHelper.executeUpdate("UPDATE users SET password = 'newpassword' WHERE username = 'john'");
            System.out.println("Rows affected: " + rowsAffected);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

在这个例子中，我们通过封装数据库连接和操作，简化了数据库访问的代码，使其更加简洁和易于复用。

案例2：封装网络请求

网络请求是另一个常见的任务，通过封装网络请求，可以提高代码复用性。

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;

public class HttpHelper {
    private static final String USER_AGENT = "Mozilla/5.0";

    public static String sendGet(String url) throws Exception {
        URL obj = new URL(url);
        HttpURLConnection con = (HttpURLConnection) obj.openConnection();
        con.setRequestMethod("GET");
        con.setRequestProperty("User-Agent", USER_AGENT);

        int responseCode = con.getResponseCode();
        System.out.println("GET Response Code :: " + responseCode);

        if (responseCode == HttpURLConnection.HTTP_OK) {
            BufferedReader in = new BufferedReader(new InputStreamReader(con.getInputStream()));
            String inputLine;
            StringBuilder response = new StringBuilder();

            while ((inputLine = in.readLine()) != null) {
                response.append(inputLine);
            }
            in.close();

            return response.toString();
        } else {
            return "GET request not worked";
        }
    }

    public static String sendPost(String url, String urlParameters) throws Exception {
        URL obj = new URL(url);
        HttpURLConnection con = (HttpURLConnection) obj.openConnection();
        con.setRequestMethod("POST");
        con.setRequestProperty("User-Agent", USER_AGENT);
        con.setDoOutput(true);

        con.getOutputStream().write(urlParameters.getBytes());

        int responseCode = con.getResponseCode();
        System.out.println("POST Response Code :: " + responseCode);

        if (responseCode == HttpURLConnection.HTTP_OK) {
            BufferedReader in = new BufferedReader(new InputStreamReader(con.getInputStream()));
            String inputLine;
            StringBuilder response = new StringBuilder();

            while ((inputLine = in.readLine()) != null) {
                response.append(inputLine);
            }
            in.close();

            return response.toString();
        } else {
            return "POST request not worked";
        }
    }

    public static void main(String[] args) {
        try {
            String url = "https://jsonplaceholder.typicode.com/posts";
            String response = HttpHelper.sendGet(url);
            System.out.println("GET Response: " + response);

            String urlParameters = "userId=1&title=foo&body=bar";
            response = HttpHelper.sendPost(url, urlParameters);
            System.out.println("POST Response: " + response);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

在这个例子中，我们通过封装GET和POST请求，使得网络请求的代码更加简洁和易于复用。

案例3：封装日志记录

日志记录是另一个常见的任务，通过封装日志记录，可以提高代码复用性和可维护性。

import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.text.SimpleDateFormat;
import java.util.Date;

public class Logger {
    private String logFile;

    public Logger(String logFile) {
        this.logFile = logFile;
    }

    public void log(String message) {
        try (PrintWriter out = new PrintWriter(new FileWriter(logFile, true))) {
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            String timestamp = sdf.format(new Date());
            out.println(timestamp + " - " + message);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        Logger logger = new Logger("app.log");
        logger.log("Application started");
        logger.log("An example log message");
        logger.log("Application ended");
    }
}

在这个例子中，我们通过封装日志记录功能，使得日志记录的代码更加简洁和易于复用。