Xin lỗi vì một câu hỏi dài như vậy, nhưng xin vui lòng thông cảm, tôi đã cố gắng làm cho câu hỏi của mình dễ hiểu nhất có thể. Nếu bạn nghĩ nó có thể ngắn gọn hơn, xin vui lòng chỉnh sửa nó.

Tôi có một hệ thống máy khách-máy chủ trong đó máy khách gửi các loại yêu cầu khác nhau đến máy chủ và dựa trên yêu cầu đó sẽ nhận được phản hồi.

Mã trong hệ thống máy khách là:

 int requestTypeA() {
      Yêu cầu yêu cầu = Yêu cầu mới (TypeA);
      Phản hồi phản hồi = request.execute();
      // phản hồi cho yêu cầu của TypeA chứa int
      trả về phản hồi.getIntResponse();
 }

 Chuỗi requestTypeB() {
      Yêu cầu yêu cầu = Yêu cầu mới (TypeB);
      Phản hồi phản hồi = request.execute();
      // phản hồi cho yêu cầu của TypeB chứa Chuỗi
      trả về phản hồi.getStringResponse();
 }

Để đoạn mã trên chạy chính xác,Lời yêu cầu Các lớp học là:

 Yêu cầu lớp {
       Loại loại;
       Yêu cầu(Loại loại) {
           this.type = loại;
        }

        Thực thi phản hồi() {
              nếu (loại == LoạiA) { 
                  // làm việc gì đó
                  trả về Phản hồi mới (someInt);
              }
              khác nếu (loại == LoạiB) {
                  // làm việc gì đó
                  trả về Phản hồi mới("someString");
              }
              khác nếu...
        }
 }

VàPhản ứng是这样的:

 Phản hồi của lớp {
      int someInt;
      Chuỗi someString;

      Phản hồi(int someInt) {
          this.someInt = someInt;
      }

      Phản hồi(Chuỗi someString) {
          this.someString = someString;
      }

      int getIntResponse() {
           trả lại một sốInt;
      }

      Chuỗi getStringResponse() {
          trả về một sốString;
      }
 }

Có hai vấn đề với giải pháp trên:

1. thi hành phương thức sẽ được lấp đầy với nếu như,khác nếu khối.
2. Có thể khi một phản hồi lỗi được trả về, chẳng hạn như một một số chuỗi Ví dụ, khi nó không được khởi tạo, nó sẽ bị nhầm lẫn với phản hồi cho yêu cầu lớp A.

Về vấn đề đầu tiên, giải pháp tôi nghĩ đến là sử dụng tính đa hình. Vậy là có một lớp cha Lời yêu cầu và đối với mỗi loại yêu cầu có một Lời yêu cầu lớp con của , vì vậy có một Loại yêu cầuA Và Loại yêu cầuB. Tất cả các lớp được bảo hiểm thi hành 方法。

Về câu hỏi 2. Tôi chỉ có một ý tưởng khả thi về cách giải quyết nó: với Lời yêu cầu Thích, tạo từ phản hồi Phản ứng lớp con và có một cái gì đó tương tự như thế này.

 Phản hồi giao diện {
 }

 lớp Phản hồiA {
     ResponseTypeA(int i) { ... }
     int getIntResponse() { ... }
 }

 lớp Loại phản hồiB {
     ResponseTypeB(String s) { ... xác minh s là hợp lệ ... }
     Chuỗi getStringResponse() { ... }
 }

Bây giờ tôi có thể xác định xem loại phản hồi có phải là Loại phản hồiB, sẽ chứa một chuỗi hợp lệ. Và tôi có thể viết mã máy khách như thế này:

Chuỗi requestTypeB() {
    Yêu cầu yêu cầu = Yêu cầu mới (TypeB);
    Phản hồi ResponseTypeB = (ResponseTypeB) request.execute();
    trả về phản hồi.getStringResponse();
 }

bây giờ tôi phải thi hành Thực hiện chuyển đổi kiểu trên kiểu trả về.

Câu hỏi chính của tôi là: có cách nào để tránh chuyển đổi loại trong tình huống trên không? Hoặc bạn có biết giải pháp nào tốt hơn (mẫu thiết kế?) cho vấn đề trên không?

câu trả lời hay nhất

Cố gắng tách biệt yêu cầu khỏi phản hồi là vô ích. Họ thông qua API - Rr = f(Q) Gắn kết với nhau.

Bạn có một sự trở lại int của Yêu cầuA và sự trở lại String của Yêu cầuB. Rõ ràng bạn có thể làm một cái gì đó như thế này:

Cuộc trò chuyện trong lớp {
    Yêu cầu R (Q q, Lớp rType) {
        // Gửi truy vấn (Q) và nhận phản hồi R
    }
}

lớp ConversationA mở rộng Hội thoại {

}
lớp ConversationB mở rộng Hội thoại {

}

Một phiên bản xác thực hơn có thể trông như thế này:

Kiểm tra lớp công khai {

    // Mở rộng điều này để có được toString giống như JSON một cách kỳ diệu.
    giao diện tĩnh công cộng JSONObject {

        Chuỗi công khai asJSON();
    }

    lớp Yêu cầuA triển khai JSONObject {

        @Ghi đè
        Chuỗi công khai asJSON() {
            trả về "RequestA {}";
        }
    }

    lớp Yêu cầuB triển khai JSONObject {

        @Ghi đè
        Chuỗi công khai asJSON() {
            trả về "Yêu cầuB {}";
        }
    }

    lớp tĩnh Hội thoại {

        // Nhà máy phân tích cú pháp.
        Nhà máy JsonFactory tĩnh cuối cùng = new JsonFactory();

        // Truy vấn chung của trang web Lấy một đối tượng thuộc loại Q và trả về một đối tượng thuộc lớp R.
        truy vấn R công khai (Chuỗi urlBase, Chuỗi op, Q q, Class r) ném IOException {
            // Chuẩn bị bài.
            HttpPost postRequest = HttpPost mới(urlBase + op);
            // Đưa tất cả vào một chuỗi JSON.
            Đầu vào StringEntity = StringEntity mới(q.asJSON());
            input.setContentType("application/json");
            postRequest.setEntity(đầu vào);
            // Đăng nó và chờ đợi.
            trả về requestResponse(postRequest, r);
        }

        riêng tư  R requestResponse(HttpRequestBase request, Class r) ném IOException {
            // Bắt đầu một cuộc trò chuyện.
            CloseableHttpClient httpclient = HttpClients.createDefault();
            Phản hồi CloseableHttpResponse = httpclient.execute(request);
            // Nhận câu trả lời.
            trả về readResponse(response, r);
        }

        riêng tư  R readResponse(Phản hồi CloseableHttpResponse, Class r) ném IOException {
            // Những gì đã được đọc.
            R đỏ = null;
            thử {
                // Chuyện gì đã xảy ra thế?
                if (response.getStatusLine().getStatusCode() == 200) {
                    // Công bố kết quả
                    Thực thể HttpEntity = reply.getEntity();
                    if (thực thể != null) {
                        // Luôn đảm bảo nội dung được đóng.
                        thử (InputStream nội dung = thực thể.getContent()) {
                            red = parsAs(nội dung, r);
                        }
                    }
                } khác {
                    // Phần cuối cùng bên dưới sẽ dọn sạch.
                    ném IOException mới ("Phản hồi HTTP: " + reply.getStatusLine().getStatusCode());
                }
            } finally {
                // Luôn đóng phản hồi.
                phản hồi.close();
            }

            trả lại màu đỏ;
        }

        riêng tư  R parsAs(nội dung InputStream, Class r) ném IOException {
            JsonParser rsp;
            // Cuộn nó trực tiếp từ luồng phản hồi.
            rsp = Factory.createJsonParser(nội dung);
            // Mang lại phản hồi.
            trả về rsp.readValueAs(r);
        }
    }

    lớp tĩnh ConversationA mở rộng Hội thoại {

    }

    lớp tĩnh ConversationB mở rộng Hội thoại {

    }

    public void test() ném IOException {
        Số nguyên a = new ConversationA().query("http://host/api", "JSON", newRequestA(), Integer.class);
        Chuỗi b = new ConversationB().query("http://host/api", "JSON", newRequestB(), String.class);
    }

    public static void main(String args[]) {
        thử {
            Thử nghiệm mới().test();
        } bắt (Ném được t) {
            t.printStackTrace(System.err);
        }
    }
}

Điều này xuất phát từ JSON và Apache HttpClient Sử dụng thực tế - tuy nhiên, nó có thể không hoạt động như đã đăng vì tôi đã loại bỏ hầu hết các cơ chế xử lý lỗi và thử lại để đơn giản. Điều này chủ yếu là để chứng minh việc sử dụng cơ chế gợi ý.

Lưu ý rằng mặc dù không có diễn viên nào trong mã này (theo yêu cầu của câu hỏi), nhưng trong rsp.readValueAs(r) Có thể có dàn diễn viên đang diễn ra ở hậu trường mà bạn không thể bỏ quaJSON.

Về java - đa hình, làm cách nào để tránh chuyển đổi kiểu? , chúng tôi đã tìm thấy một câu hỏi tương tự trên Stack Overflow: https://stackoverflow.com/questions/26151838/