                     loadCache(responseObjectArray: cacheResponse)
                     let isSendRequest = customCacheRequest.shouldSendRequest(self, cacheResponse: cacheResponse)
                     if isSendRequest {
-                        self.request?.validate().responseArray(queue: self.responseQueue, keyPath: self.responseObjectKeyPath, context: self.responseObjectContext, completionHandler: { (objectArrayResponse: DataResponse<[T],AFError>) in
+                        self.request?.validate({ (request:URLRequest?, response:HTTPURLResponse, data:Data?) -> DataRequest.ValidationResult in
+                            validateResponse(request: request, response: response, data: data)
+                        }).responseArray(queue: self.responseQueue, keyPath: self.responseObjectKeyPath, context: self.responseObjectContext, completionHandler: { (objectArrayResponse: DataResponse<[T],AFError>) in
                             let isUpdateCache = customCacheRequest.shouldUpdateCache(self, response: objectArrayResponse)
                             if isUpdateCache {
-                                var response = objectArrayResponse
-                                switch response.result {
-                                case .success(let obj):
-                                    let validate = self.validateResponseWhenRequestSuccess(obj)
-                                    if !validate.0 {
-                                        response = generateValidateFailResponse(response, serverError: validate.1)
-                                    }
-                                case .failure(_):
-                                    break
-                                }
-                                self.requestFilter(response, shouldSaveCache: true)
-                                completionHandler(false,response)
+                                self.requestFilter(objectArrayResponse, shouldSaveCache: true)
+                                completionHandler(false,objectArrayResponse)
                             }
                         })
                     }

            completionHandler(true,responseObject)
        }
        
        func responseObjectFromRequest() {
            self.request?.validate().responseObject(queue: self.responseQueue, keyPath: self.responseObjectKeyPath, mapToObject: object, context: self.responseObjectContext, completionHandler: { objectResponse in
                var response = objectResponse
                switch response.result {
                case .success(let obj):
                    let validate = self.validateResponseWhenRequestSuccess(obj)
                    if !validate.0 {
                        response = generateValidateFailResponse(response, serverError: validate.1)
                    }
                case .failure(_):
                    break
                }
                self.requestFilter(response, shouldSaveCache: true)
                completionHandler(false,response)
            })
        }
        
        func generateValidateFailResponse(_ objectResponse: DataResponse<T,AFError>, serverError: Error?) -> DataResponse<T,AFError> {
            return DataResponse(request: objectResponse.request, response: objectResponse.response, data: objectResponse.data, metrics: objectResponse.metrics, serializationDuration: objectResponse.serializationDuration, result: .failure(self.generateValidationFailureError(serverError)))
        }
        
        switch responseDataSource {
        case .server:
            self.request?.validate().responseObject(queue: self.responseQueue, keyPath: self.responseObjectKeyPath, mapToObject: object, context: self.responseObjectContext, completionHandler: { objectResponse in
                var response = objectResponse
                switch response.result {
                case .success(let obj):
                    let validate = self.validateResponseWhenRequestSuccess(obj)
                    if !validate.0 {
                        response = generateValidateFailResponse(response, serverError: validate.1)
                    }
                case .failure(_):
                    break
                }
                self.requestFilter(response)
                completionHandler(false,response)
            })
        case .cacheIfPossible:
            self.responseObjectFromCache(completionHandler: { (loadCacheData: () throws -> DataResponse<T,AFError>) in
                do {

                    loadCache(responseObject: cacheResponse)
                    let isSendRequest = customCacheRequest.shouldSendRequest(self, cacheResponse: cacheResponse)
                    if isSendRequest {
                        self.request?.validate({ (request:URLRequest?, response:HTTPURLResponse, data:Data?) -> DataRequest.ValidationResult in
                            validateResponse(request: request, response: response, data: data)
                        }).responseObject(queue: self.responseQueue, keyPath: self.responseObjectKeyPath, mapToObject: object, context: self.responseObjectContext, completionHandler: { objectResponse in
                            let isUpdateCache = customCacheRequest.shouldUpdateCache(self, response: objectResponse)
                            if isUpdateCache {
                                self.requestFilter(objectResponse, shouldSaveCache: true)
                                completionHandler(false,objectResponse)
                            }
                        })
                    }
