Java 범용 Tclass 가져오기 해결 방법 (비동기식 요청 코드 최적화)

문제 배경

이런 장면을 상상하면 우리는 다른 걸음으로 서버의 데이터를 요청하고 서버와 json 형식으로 통신을 하고 리셋이 있을 때 메인 라인으로 전환해서 리셋을 주기로 약속합니다.프레임워크를 사용하지 않는 상황에서 우리는 어떻게 실현해야 합니까?
1 리셋 인터페이스를 추가하면 다음과 같은 일반적인 정의가 적용됩니다.

    public interface RequestCallBack{
        /**
         *  
         * @param data json 
         */
        void onResponse(String data);

        void onError(int errorCode,String errorDesp);
    }

2 비동기적으로 데이터를 요청하고 callBack을 저장합니다(실제로는 세션 관리, 스레드 탱크 관리 등이 필요합니다. 본고와 무관하며 설명하지 않습니다).

    private RequestCallBack mRequestCallBack;
    /**
     *  
     * @param requestData requestData
     * @param callBack  response 
     */
    public void requestData(String requestData, RequestCallBack callBack) {
        mRequestCallBack = callBack;
        //  request
        new Thread(){
            @Override
            public void run() {
                // do request
            }
        }.start();
    }

3 response를 받을 때 메인 라인으로 전환하여 리셋합니다.

    /**
     *  response
     * @param response
     */
    public void dispatchResponseOnUi(String response){
        mRequestCallBack.onResponse(response);
    }

그럼 우리가 정상적으로 요청하는 곳의 흔한 묘사법을 살펴보자.

    /**
     *  
     */
    public void requestNormal() {
        TestDemo testDemo = new TestDemo();
        testDemo.requestData("requestData", new RequestCallBack() {
            @Override
            public void onResponse(String data) {
                // fastJson  GSON json Bean 
                TestBean testBean = JSON.parseObject(data,TestBean.class);
                // do other things
            }

            @Override
            public void onError(int errorCode, String errorDesp) {
            }
        });
    }

문제점

이렇게 하는 것은 문제가 없을 것 같지만, 매번 요청한 반환 결과가 json이고 Bean류로 해석하여 후속 처리를 편리하게 하기를 희망하며, FastJson/Gson 등 프레임워크로 대응하는 BeanObject로 직접 해석할 수 있다면 왜 우리는 직접 통일하지 못하고 전환할 수 없습니까?매번 부탁하는 곳에서 단독으로 처리해야 하니 너무 번거롭죠. 그리고 나중에 만약에 수정이 필요하다면 곳곳마다 고쳐야 해요.응, 이 문제를 보고 첫 번째 반응은 틀림없이 범형이야.응, 하나의 범주형으로 해결할 수 있는 일인 것 같아. 우리가 Request Call Back 구현 클래스에 대응하는 Bean 클래스를 지정하고 onResponse 때 Bean 클래스를 넘기면 되잖아.그런데 정말 그런가요?방금 생각한 대로 개조해 봅시다. Request CallBack 개조는 다음과 같습니다.

    public abstract class RequestCallBack<T extends BaseBean>{
        public T t;
        /**
         *  
         * @param t  BeanObject
         */
        public abstract void onResponse(T t);

        public abstract void onError(int errorCode,String errorDesp);
    }

배포 응답은 다음 형식으로 변경됩니다.

    /**
     *  response
     * @param response
     */
    public void dispatchResponseOnUi(String response){
        mRequestCallBack.onResponse(JSON.parseObject(response, mRequestCallBack.t.getClass()));
    }

응, 문제 없을 것 같지만, 소년, 여기 t는 비어 있어!빈 포인터가 없는지 확인합니까?그럼 우리가 구성할 때 new T를 하나 만들면 되잖아요. 너무 순진하다고 할 수 밖에 없어요. IDE가 Type parameter'T'cannot be instantiated directly를 알려줄 거예요.생각해 보면 이런 방식은 통하지 않을 거야. 생각해 봐. 범형의 가장 큰 장점은 실행할 때 그의 구체적인 유형을 알게 되는 거야. 그런데 네가 지금 여기에 집행하지 않았을 때 그의 구체적인 유형을 알았으면 좋겠어. 비현실적일 거야. 반사를 통해 실제 운행 환경에 따라 실례화하지 않으면 반사가 번거롭더라도 그 자체의 집행 효율이 낮아.그럼 다른 방법이 없나요?

솔루션

내가 생각한 해결 방식은 만약에 다음과 같은 방식으로 이 문제를 해결한다면 매번 json을 해석하는 것을 피할 수 있고 반사적인 효율 문제를 피할 수 있다.1 RequestCallBack 개조는 다음과 같습니다.

    public abstract class RequestCallBack {

        /**
         *  json 
         * @param response json 
         */
        public void onResponse(String response) {
            onResponse(JSON.parseObject(response, getBeanClass()));
        }

        /**
         *  
         *
         * @param t  BeanObject
         */
        public abstract  void onResponse(T t);

        public abstract void onError(int errorCode, String errorDesp);

        /**
         *  bean 
         * @param 
         * @return
         */
        public abstract  Class getBeanClass();
    }

BeanClass를 가져오는 방법을 추가하고 json 문자열을 받은 후 내부적으로 해석한 다음 onResponse (T t) 에 나누어 줍니다.2 response를 나누어 주는 곳은 최초의 변하지 않고 onResponse에 나누어 줍니다(String response)

    /**
     *  response
     * @param response
     */
    public void dispatchResponseOnUi(String response){
        mRequestCallBack.onResponse(response);
    }

3 그러면 변경 후 요청한 쓰기 방법을 살펴보겠습니다.

    /**
     *  
     */
    public void requestNew() {
        TestDemo testDemo = new TestDemo();
        testDemo.requestData("requestData", new RequestCallBack() {
            @Override
            public  void onResponse(T t) {
                //  t
            }

            @Override
            public void onError(int errorCode, String errorDesp) {
            }

            @Override
            public Class extends BaseBean> getBeanClass() {
                return TestBean.class;
            }
        });
    }

자, 이렇게 해서 우리는 json의 해석을 집합시켰을 뿐만 아니라 반사로 인한 효율 문제도 피했다.읽어 주셔서 감사합니다. 도움이 되었으면 좋겠습니다.의문이 있으면 소통을 환영합니다.