diff --git a/Cargo.toml b/Cargo.toml
index 9666c4b33..54e7ec57f 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -73,16 +73,16 @@ name = "client"
 required-features = ["rustls"]
 
 [dependencies]
-actix-codec = "0.3.0"
-actix-service = "1.0.6"
-actix-utils = "2.0.0"
+actix-codec = "0.4.0-beta.1"
+actix-service = "2.0.0-beta.1"
+actix-utils = "3.0.0-beta.1"
 actix-router = "0.2.4"
-actix-rt = "1.1.1"
-actix-server = "1.0.0"
-actix-testing = "1.0.0"
+actix-rt = "2.0.0-beta.1"
+actix-server = "2.0.0-beta.1"
+#actix-testing = "1.0.0"
 actix-macros = "0.1.0"
 actix-threadpool = "0.3.1"
-actix-tls = "2.0.0"
+actix-tls = "3.0.0-beta.1"
 
 actix-web-codegen = "0.4.0"
 actix-http = "2.2.0"
@@ -91,7 +91,6 @@ awc = { version = "2.0.3", default-features = false }
 bytes = "1"
 derive_more = "0.99.5"
 encoding_rs = "0.8"
-futures-channel = { version = "0.3.7", default-features = false }
 futures-core = { version = "0.3.7", default-features = false }
 futures-util = { version = "0.3.7", default-features = false }
 fxhash = "0.2.1"
@@ -134,16 +133,10 @@ actix-files = { path = "actix-files" }
 awc = { path = "awc" }
 
 # FIXME: remove these override
-actix = { git = "https://github.com/fakeshadow/actix.git", branch = "tokio-0.3" }
-actix-rt = { git = "https://github.com/fakeshadow/actix-net.git", branch = "mio-0.7.3" }
-actix-server = { git = "https://github.com/fakeshadow/actix-net.git", branch = "mio-0.7.3" }
-actix-tls = { git = "https://github.com/fakeshadow/actix-net.git", branch = "mio-0.7.3" }
-#actix-connect = { git = "https://github.com/fakeshadow/actix-net.git", branch = "mio-0.7.3" }
-actix-connect = { path = "../actix-net-fs/actix-connect" }
-actix-utils = { git = "https://github.com/fakeshadow/actix-net.git", branch = "mio-0.7.3" }
-actix-codec = { git = "https://github.com/fakeshadow/actix-net.git", branch = "mio-0.7.3" }
+actix-tls = { git = "https://github.com/actix/actix-net.git", branch = "fix/actix-tls" }
+actix-service = { path = "../actix-net/actix-service" }
 
-http = { git = "https://github.com/fakeshadow/http.git" }
+#http = { git = "https://github.com/fakeshadow/http.git" }
 trust-dns-proto = { git = "https://github.com/messense/trust-dns.git", branch = "tokio-1" }
 trust-dns-resolver = { git = "https://github.com/messense/trust-dns.git", branch = "tokio-1" }
 
diff --git a/actix-http-test/Cargo.toml b/actix-http-test/Cargo.toml
index 4b1bd7d9f..b55f2933e 100644
--- a/actix-http-test/Cargo.toml
+++ b/actix-http-test/Cargo.toml
@@ -29,13 +29,13 @@ default = []
 openssl = ["open-ssl", "awc/openssl"]
 
 [dependencies]
-actix-service = "1.0.6"
-actix-codec = "0.3.0"
-actix-connect = "2.0.0"
-actix-utils = "2.0.0"
-actix-rt = "1.1.1"
-actix-server = "1.0.0"
-actix-testing = "1.0.0"
+actix-service = "2.0.0-beta.1"
+actix-codec = "0.4.0-beta.1"
+#actix-connect = "2.0.0"
+actix-utils = "3.0.0-beta.1"
+actix-rt = "2.0.0-beta.1"
+actix-server = "2.0.0-beta.1"
+#actix-testing = "1.0.0"
 awc = "2.0.0"
 
 base64 = "0.13"
diff --git a/actix-http/Cargo.toml b/actix-http/Cargo.toml
index e6af20694..9c861586e 100644
--- a/actix-http/Cargo.toml
+++ b/actix-http/Cargo.toml
@@ -25,10 +25,10 @@ path = "src/lib.rs"
 default = []
 
 # openssl
-openssl = ["actix-tls/openssl", "actix-connect/openssl"]
+openssl = ["actix-tls/openssl"]
 
 # rustls support
-rustls = ["actix-tls/rustls", "actix-connect/rustls"]
+rustls = ["actix-tls/rustls"]
 
 # enable compressison support
 compress = ["flate2", "brotli2"]
@@ -40,13 +40,12 @@ secure-cookies = ["cookie/secure"]
 actors = ["actix"]
 
 [dependencies]
-actix-service = "1.0.6"
-actix-codec = "0.3.0"
-actix-connect = "2.0.0"
-actix-utils = "2.0.0"
-actix-rt = "1.0.0"
+actix-service = "2.0.0-beta.1"
+actix-codec = "0.4.0-beta.1"
+actix-utils = "3.0.0-beta.1"
+actix-rt = "2.0.0-beta.1"
 actix-threadpool = "0.3.1"
-actix-tls = { version = "2.0.0", optional = true }
+actix-tls = { version = "3.0.0-beta.1" }
 actix = { version = "0.10.0", optional = true }
 
 base64 = "0.13"
@@ -58,8 +57,8 @@ derive_more = "0.99.2"
 either = "1.5.3"
 encoding_rs = "0.8"
 futures-channel = { version = "0.3.5", default-features = false }
-futures-core = { version = "0.3.5", default-features = false }
-futures-util = { version = "0.3.5", default-features = false, features = ["sink"] }
+futures-core = { version = "0.3.7", default-features = false }
+futures-util = { version = "0.3.7", default-features = false, features = ["sink"] }
 fxhash = "0.2.1"
 h2 = "0.3.0"
 http = "0.2.2"
@@ -86,15 +85,14 @@ brotli2 = { version="0.3.2", optional = true }
 flate2 = { version = "1.0.13", optional = true }
 
 [dev-dependencies]
-actix-server = "1.0.1"
-actix-connect = { version = "2.0.0", features = ["openssl"] }
+actix-server = "2.0.0-beta.1"
 actix-http-test = { version = "2.0.0", features = ["openssl"] }
 actix-tls = { version = "2.0.0", features = ["openssl"] }
 criterion = "0.3"
 env_logger = "0.7"
 serde_derive = "1.0"
 open-ssl = { version="0.10", package = "openssl" }
-rust-tls = { version="0.18", package = "rustls" }
+rust-tls = { version="0.19", package = "rustls" }
 
 [[bench]]
 name = "content-length"
diff --git a/actix-http/src/builder.rs b/actix-http/src/builder.rs
index b28c69761..de8f7ad03 100644
--- a/actix-http/src/builder.rs
+++ b/actix-http/src/builder.rs
@@ -20,7 +20,7 @@ use crate::{ConnectCallback, Extensions};
 ///
 /// This type can be used to construct an instance of [`HttpService`] through a
 /// builder-like pattern.
-pub struct HttpServiceBuilder<T, S, X = ExpectHandler, U = UpgradeHandler<T>> {
+pub struct HttpServiceBuilder<T, S, X = ExpectHandler, U = UpgradeHandler> {
     keep_alive: KeepAlive,
     client_timeout: u64,
     client_disconnect: u64,
@@ -31,15 +31,15 @@ pub struct HttpServiceBuilder<T, S, X = ExpectHandler, U = UpgradeHandler<T>> {
     // DEPRECATED: in favor of on_connect_ext
     on_connect: Option<Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
     on_connect_ext: Option<Rc<ConnectCallback<T>>>,
-    _t: PhantomData<(T, S)>,
+    _t: PhantomData<S>,
 }
 
-impl<T, S> HttpServiceBuilder<T, S, ExpectHandler, UpgradeHandler<T>>
+impl<T, S> HttpServiceBuilder<T, S, ExpectHandler, UpgradeHandler>
 where
-    S: ServiceFactory<Config = (), Request = Request>,
+    S: ServiceFactory<Request, Config = ()>,
     S::Error: Into<Error> + 'static,
     S::InitError: fmt::Debug,
-    <S::Service as Service>::Future: 'static,
+    <S::Service as Service<Request>>::Future: 'static,
 {
     /// Create instance of `ServiceConfigBuilder`
     pub fn new() -> Self {
@@ -60,18 +60,18 @@ where
 
 impl<T, S, X, U> HttpServiceBuilder<T, S, X, U>
 where
-    S: ServiceFactory<Config = (), Request = Request>,
+    S: ServiceFactory<Request, Config = ()>,
     S::Error: Into<Error> + 'static,
     S::InitError: fmt::Debug,
-    <S::Service as Service>::Future: 'static,
-    X: ServiceFactory<Config = (), Request = Request, Response = Request>,
+    <S::Service as Service<Request>>::Future: 'static,
+    X: ServiceFactory<Request, Config = (), Response = Request>,
     X::Error: Into<Error>,
     X::InitError: fmt::Debug,
-    <X::Service as Service>::Future: 'static,
-    U: ServiceFactory<Config = (), Request = (Request, Framed<T, Codec>), Response = ()>,
+    <X::Service as Service<Request>>::Future: 'static,
+    U: ServiceFactory<(Request, Framed<T, Codec>), Config = (), Response = ()>,
     U::Error: fmt::Display,
     U::InitError: fmt::Debug,
-    <U::Service as Service>::Future: 'static,
+    <U::Service as Service<(Request, Framed<T, Codec>)>>::Future: 'static,
 {
     /// Set server keep-alive setting.
     ///
@@ -127,11 +127,11 @@ where
     /// request will be forwarded to main service.
     pub fn expect<F, X1>(self, expect: F) -> HttpServiceBuilder<T, S, X1, U>
     where
-        F: IntoServiceFactory<X1>,
-        X1: ServiceFactory<Config = (), Request = Request, Response = Request>,
+        F: IntoServiceFactory<X1, Request>,
+        X1: ServiceFactory<Request, Config = (), Response = Request>,
         X1::Error: Into<Error>,
         X1::InitError: fmt::Debug,
-        <X1::Service as Service>::Future: 'static,
+        <X1::Service as Service<Request>>::Future: 'static,
     {
         HttpServiceBuilder {
             keep_alive: self.keep_alive,
@@ -153,15 +153,11 @@ where
     /// and this service get called with original request and framed object.
     pub fn upgrade<F, U1>(self, upgrade: F) -> HttpServiceBuilder<T, S, X, U1>
     where
-        F: IntoServiceFactory<U1>,
-        U1: ServiceFactory<
-            Config = (),
-            Request = (Request, Framed<T, Codec>),
-            Response = (),
-        >,
+        F: IntoServiceFactory<U1, (Request, Framed<T, Codec>)>,
+        U1: ServiceFactory<(Request, Framed<T, Codec>), Config = (), Response = ()>,
         U1::Error: fmt::Display,
         U1::InitError: fmt::Debug,
-        <U1::Service as Service>::Future: 'static,
+        <U1::Service as Service<(Request, Framed<T, Codec>)>>::Future: 'static,
     {
         HttpServiceBuilder {
             keep_alive: self.keep_alive,
@@ -208,7 +204,7 @@ where
     pub fn h1<F, B>(self, service: F) -> H1Service<T, S, B, X, U>
     where
         B: MessageBody,
-        F: IntoServiceFactory<S>,
+        F: IntoServiceFactory<S, Request>,
         S::Error: Into<Error>,
         S::InitError: fmt::Debug,
         S::Response: Into<Response<B>>,
@@ -232,11 +228,11 @@ where
     pub fn h2<F, B>(self, service: F) -> H2Service<T, S, B>
     where
         B: MessageBody + 'static,
-        F: IntoServiceFactory<S>,
+        F: IntoServiceFactory<S, Request>,
         S::Error: Into<Error> + 'static,
         S::InitError: fmt::Debug,
         S::Response: Into<Response<B>> + 'static,
-        <S::Service as Service>::Future: 'static,
+        <S::Service as Service<Request>>::Future: 'static,
     {
         let cfg = ServiceConfig::new(
             self.keep_alive,
@@ -255,11 +251,11 @@ where
     pub fn finish<F, B>(self, service: F) -> HttpService<T, S, B, X, U>
     where
         B: MessageBody + 'static,
-        F: IntoServiceFactory<S>,
+        F: IntoServiceFactory<S, Request>,
         S::Error: Into<Error> + 'static,
         S::InitError: fmt::Debug,
         S::Response: Into<Response<B>> + 'static,
-        <S::Service as Service>::Future: 'static,
+        <S::Service as Service<Request>>::Future: 'static,
     {
         let cfg = ServiceConfig::new(
             self.keep_alive,
diff --git a/actix-http/src/client/connector.rs b/actix-http/src/client/connector.rs
index e1aed6382..b638336f7 100644
--- a/actix-http/src/client/connector.rs
+++ b/actix-http/src/client/connector.rs
@@ -3,11 +3,11 @@ use std::marker::PhantomData;
 use std::time::Duration;
 
 use actix_codec::{AsyncRead, AsyncWrite};
-use actix_connect::{
+use actix_rt::net::TcpStream;
+use actix_service::{apply_fn, Service, ServiceExt};
+use actix_tls::connect::{
     default_connector, Connect as TcpConnect, Connection as TcpConnection,
 };
-use actix_rt::net::TcpStream;
-use actix_service::{apply_fn, Service};
 use actix_utils::timeout::{TimeoutError, TimeoutService};
 use http::Uri;
 
@@ -18,10 +18,10 @@ use super::pool::{ConnectionPool, Protocol};
 use super::Connect;
 
 #[cfg(feature = "openssl")]
-use actix_connect::ssl::openssl::SslConnector as OpensslConnector;
+use actix_tls::connect::ssl::openssl::SslConnector as OpensslConnector;
 
 #[cfg(feature = "rustls")]
-use actix_connect::ssl::rustls::ClientConfig;
+use actix_tls::connect::ssl::rustls::ClientConfig;
 #[cfg(feature = "rustls")]
 use std::sync::Arc;
 
@@ -62,9 +62,9 @@ impl Connector<(), ()> {
     #[allow(clippy::new_ret_no_self, clippy::let_unit_value)]
     pub fn new() -> Connector<
         impl Service<
-                Request = TcpConnect<Uri>,
+                TcpConnect<Uri>,
                 Response = TcpConnection<Uri, TcpStream>,
-                Error = actix_connect::ConnectError,
+                Error = actix_tls::connect::ConnectError,
             > + Clone,
         TcpStream,
     > {
@@ -79,7 +79,7 @@ impl Connector<(), ()> {
     // Build Ssl connector with openssl, based on supplied alpn protocols
     #[cfg(feature = "openssl")]
     fn build_ssl(protocols: Vec<Vec<u8>>) -> SslConnector {
-        use actix_connect::ssl::openssl::SslMethod;
+        use actix_tls::connect::ssl::openssl::SslMethod;
         use bytes::{BufMut, BytesMut};
 
         let mut alpn = BytesMut::with_capacity(20);
@@ -102,7 +102,7 @@ impl Connector<(), ()> {
         config.set_protocols(&protocols);
         config
             .root_store
-            .add_server_trust_anchors(&actix_tls::rustls::TLS_SERVER_ROOTS);
+            .add_server_trust_anchors(&actix_tls::accept::rustls::TLS_SERVER_ROOTS);
         SslConnector::Rustls(Arc::new(config))
     }
 
@@ -117,9 +117,9 @@ impl<T, U> Connector<T, U> {
     where
         U1: AsyncRead + AsyncWrite + Unpin + fmt::Debug,
         T1: Service<
-                Request = TcpConnect<Uri>,
+                TcpConnect<Uri>,
                 Response = TcpConnection<Uri, U1>,
-                Error = actix_connect::ConnectError,
+                Error = actix_tls::connect::ConnectError,
             > + Clone,
     {
         Connector {
@@ -135,9 +135,9 @@ impl<T, U> Connector<T, U>
 where
     U: AsyncRead + AsyncWrite + Unpin + fmt::Debug + 'static,
     T: Service<
-            Request = TcpConnect<Uri>,
+            TcpConnect<Uri>,
             Response = TcpConnection<Uri, U>,
-            Error = actix_connect::ConnectError,
+            Error = actix_tls::connect::ConnectError,
         > + Clone
         + 'static,
 {
@@ -241,8 +241,8 @@ where
     /// its combinator chain.
     pub fn finish(
         self,
-    ) -> impl Service<Request = Connect, Response = impl Connection, Error = ConnectError>
-           + Clone {
+    ) -> impl Service<Connect, Response = impl Connection, Error = ConnectError> + Clone
+    {
         #[cfg(not(any(feature = "openssl", feature = "rustls")))]
         {
             let connector = TimeoutService::new(
@@ -268,11 +268,11 @@ where
         #[cfg(any(feature = "openssl", feature = "rustls"))]
         {
             const H2: &[u8] = b"h2";
-            #[cfg(feature = "openssl")]
-            use actix_connect::ssl::openssl::OpensslConnector;
-            #[cfg(feature = "rustls")]
-            use actix_connect::ssl::rustls::{RustlsConnector, Session};
             use actix_service::{boxed::service, pipeline};
+            #[cfg(feature = "openssl")]
+            use actix_tls::connect::ssl::openssl::OpensslConnector;
+            #[cfg(feature = "rustls")]
+            use actix_tls::connect::ssl::rustls::{RustlsConnector, Session};
 
             let ssl_service = TimeoutService::new(
                 self.config.timeout,
@@ -363,8 +363,7 @@ mod connect_impl {
     pub(crate) struct InnerConnector<T, Io>
     where
         Io: AsyncRead + AsyncWrite + Unpin + 'static,
-        T: Service<Request = Connect, Response = (Io, Protocol), Error = ConnectError>
-            + 'static,
+        T: Service<Connect, Response = (Io, Protocol), Error = ConnectError> + 'static,
     {
         pub(crate) tcp_pool: ConnectionPool<T, Io>,
     }
@@ -372,8 +371,7 @@ mod connect_impl {
     impl<T, Io> Clone for InnerConnector<T, Io>
     where
         Io: AsyncRead + AsyncWrite + Unpin + 'static,
-        T: Service<Request = Connect, Response = (Io, Protocol), Error = ConnectError>
-            + 'static,
+        T: Service<Connect, Response = (Io, Protocol), Error = ConnectError> + 'static,
     {
         fn clone(&self) -> Self {
             InnerConnector {
@@ -382,17 +380,15 @@ mod connect_impl {
         }
     }
 
-    impl<T, Io> Service for InnerConnector<T, Io>
+    impl<T, Io> Service<Connect> for InnerConnector<T, Io>
     where
         Io: AsyncRead + AsyncWrite + Unpin + 'static,
-        T: Service<Request = Connect, Response = (Io, Protocol), Error = ConnectError>
-            + 'static,
+        T: Service<Connect, Response = (Io, Protocol), Error = ConnectError> + 'static,
     {
-        type Request = Connect;
         type Response = IoConnection<Io>;
         type Error = ConnectError;
         type Future = Either<
-            <ConnectionPool<T, Io> as Service>::Future,
+            <ConnectionPool<T, Io> as Service<Connect>>::Future,
             Ready<Result<IoConnection<Io>, ConnectError>>,
         >;
 
@@ -428,8 +424,8 @@ mod connect_impl {
     where
         Io1: AsyncRead + AsyncWrite + Unpin + 'static,
         Io2: AsyncRead + AsyncWrite + Unpin + 'static,
-        T1: Service<Request = Connect, Response = (Io1, Protocol), Error = ConnectError>,
-        T2: Service<Request = Connect, Response = (Io2, Protocol), Error = ConnectError>,
+        T1: Service<Connect, Response = (Io1, Protocol), Error = ConnectError>,
+        T2: Service<Connect, Response = (Io2, Protocol), Error = ConnectError>,
     {
         pub(crate) tcp_pool: ConnectionPool<T1, Io1>,
         pub(crate) ssl_pool: ConnectionPool<T2, Io2>,
@@ -439,10 +435,8 @@ mod connect_impl {
     where
         Io1: AsyncRead + AsyncWrite + Unpin + 'static,
         Io2: AsyncRead + AsyncWrite + Unpin + 'static,
-        T1: Service<Request = Connect, Response = (Io1, Protocol), Error = ConnectError>
-            + 'static,
-        T2: Service<Request = Connect, Response = (Io2, Protocol), Error = ConnectError>
-            + 'static,
+        T1: Service<Connect, Response = (Io1, Protocol), Error = ConnectError> + 'static,
+        T2: Service<Connect, Response = (Io2, Protocol), Error = ConnectError> + 'static,
     {
         fn clone(&self) -> Self {
             InnerConnector {
@@ -452,16 +446,13 @@ mod connect_impl {
         }
     }
 
-    impl<T1, T2, Io1, Io2> Service for InnerConnector<T1, T2, Io1, Io2>
+    impl<T1, T2, Io1, Io2> Service<Connect> for InnerConnector<T1, T2, Io1, Io2>
     where
         Io1: AsyncRead + AsyncWrite + Unpin + 'static,
         Io2: AsyncRead + AsyncWrite + Unpin + 'static,
-        T1: Service<Request = Connect, Response = (Io1, Protocol), Error = ConnectError>
-            + 'static,
-        T2: Service<Request = Connect, Response = (Io2, Protocol), Error = ConnectError>
-            + 'static,
+        T1: Service<Connect, Response = (Io1, Protocol), Error = ConnectError> + 'static,
+        T2: Service<Connect, Response = (Io2, Protocol), Error = ConnectError> + 'static,
     {
-        type Request = Connect;
         type Response = EitherConnection<Io1, Io2>;
         type Error = ConnectError;
         type Future = Either<
@@ -491,18 +482,16 @@ mod connect_impl {
     pub(crate) struct InnerConnectorResponseA<T, Io1, Io2>
     where
         Io1: AsyncRead + AsyncWrite + Unpin + 'static,
-        T: Service<Request = Connect, Response = (Io1, Protocol), Error = ConnectError>
-            + 'static,
+        T: Service<Connect, Response = (Io1, Protocol), Error = ConnectError> + 'static,
     {
         #[pin]
-        fut: <ConnectionPool<T, Io1> as Service>::Future,
+        fut: <ConnectionPool<T, Io1> as Service<Connect>>::Future,
         _t: PhantomData<Io2>,
     }
 
     impl<T, Io1, Io2> Future for InnerConnectorResponseA<T, Io1, Io2>
     where
-        T: Service<Request = Connect, Response = (Io1, Protocol), Error = ConnectError>
-            + 'static,
+        T: Service<Connect, Response = (Io1, Protocol), Error = ConnectError> + 'static,
         Io1: AsyncRead + AsyncWrite + Unpin + 'static,
         Io2: AsyncRead + AsyncWrite + Unpin + 'static,
     {
@@ -520,18 +509,16 @@ mod connect_impl {
     pub(crate) struct InnerConnectorResponseB<T, Io1, Io2>
     where
         Io2: AsyncRead + AsyncWrite + Unpin + 'static,
-        T: Service<Request = Connect, Response = (Io2, Protocol), Error = ConnectError>
-            + 'static,
+        T: Service<Connect, Response = (Io2, Protocol), Error = ConnectError> + 'static,
     {
         #[pin]
-        fut: <ConnectionPool<T, Io2> as Service>::Future,
+        fut: <ConnectionPool<T, Io2> as Service<Connect>>::Future,
         _t: PhantomData<Io1>,
     }
 
     impl<T, Io1, Io2> Future for InnerConnectorResponseB<T, Io1, Io2>
     where
-        T: Service<Request = Connect, Response = (Io2, Protocol), Error = ConnectError>
-            + 'static,
+        T: Service<Connect, Response = (Io2, Protocol), Error = ConnectError> + 'static,
         Io1: AsyncRead + AsyncWrite + Unpin + 'static,
         Io2: AsyncRead + AsyncWrite + Unpin + 'static,
     {
diff --git a/actix-http/src/client/error.rs b/actix-http/src/client/error.rs
index 0af1555ae..a5f1b2e8e 100644
--- a/actix-http/src/client/error.rs
+++ b/actix-http/src/client/error.rs
@@ -1,10 +1,10 @@
 use std::io;
 
-use actix_connect::resolver::ResolveError;
+use actix_tls::connect::resolver::ResolveError;
 use derive_more::{Display, From};
 
 #[cfg(feature = "openssl")]
-use actix_connect::ssl::openssl::SslError;
+use actix_tls::accept::openssl::SslError;
 
 use crate::error::{Error, ParseError, ResponseError};
 use crate::http::{Error as HttpError, StatusCode};
@@ -21,10 +21,6 @@ pub enum ConnectError {
     #[display(fmt = "{}", _0)]
     SslError(SslError),
 
-    // /// SSL Handshake error
-    // #[cfg(feature = "openssl")]
-    // #[display(fmt = "{}", _0)]
-    // SslHandshakeError(SslError),
     /// Failed to resolve the hostname
     #[display(fmt = "Failed resolving hostname: {}", _0)]
     Resolver(ResolveError),
@@ -56,25 +52,18 @@ pub enum ConnectError {
 
 impl std::error::Error for ConnectError {}
 
-impl From<actix_connect::ConnectError> for ConnectError {
-    fn from(err: actix_connect::ConnectError) -> ConnectError {
+impl From<actix_tls::connect::ConnectError> for ConnectError {
+    fn from(err: actix_tls::connect::ConnectError) -> ConnectError {
         match err {
-            actix_connect::ConnectError::Resolver(e) => ConnectError::Resolver(e),
-            actix_connect::ConnectError::NoRecords => ConnectError::NoRecords,
-            actix_connect::ConnectError::InvalidInput => panic!(),
-            actix_connect::ConnectError::Unresolved => ConnectError::Unresolved,
-            actix_connect::ConnectError::Io(e) => ConnectError::Io(e),
+            actix_tls::connect::ConnectError::Resolver(e) => ConnectError::Resolver(e),
+            actix_tls::connect::ConnectError::NoRecords => ConnectError::NoRecords,
+            actix_tls::connect::ConnectError::InvalidInput => panic!(),
+            actix_tls::connect::ConnectError::Unresolved => ConnectError::Unresolved,
+            actix_tls::connect::ConnectError::Io(e) => ConnectError::Io(e),
         }
     }
 }
 
-// #[cfg(feature = "openssl")]
-// impl<T: std::fmt::Debug> From<HandshakeError<T>> for ConnectError {
-//     fn from(err: HandshakeError<T>) -> ConnectError {
-//         ConnectError::SslHandshakeError(format!("{:?}", err))
-//     }
-// }
-
 #[derive(Debug, Display, From)]
 pub enum InvalidUrl {
     #[display(fmt = "Missing url scheme")]
diff --git a/actix-http/src/client/pool.rs b/actix-http/src/client/pool.rs
index d1125e4ea..f9973a850 100644
--- a/actix-http/src/client/pool.rs
+++ b/actix-http/src/client/pool.rs
@@ -50,8 +50,7 @@ pub(crate) struct ConnectionPool<T, Io: 'static>(Rc<RefCell<T>>, Rc<RefCell<Inne
 impl<T, Io> ConnectionPool<T, Io>
 where
     Io: AsyncRead + AsyncWrite + Unpin + 'static,
-    T: Service<Request = Connect, Response = (Io, Protocol), Error = ConnectError>
-        + 'static,
+    T: Service<Connect, Response = (Io, Protocol), Error = ConnectError> + 'static,
 {
     pub(crate) fn new(connector: T, config: ConnectorConfig) -> Self {
         let connector_rc = Rc::new(RefCell::new(connector));
@@ -90,13 +89,11 @@ impl<T, Io> Drop for ConnectionPool<T, Io> {
     }
 }
 
-impl<T, Io> Service for ConnectionPool<T, Io>
+impl<T, Io> Service<Connect> for ConnectionPool<T, Io>
 where
     Io: AsyncRead + AsyncWrite + Unpin + 'static,
-    T: Service<Request = Connect, Response = (Io, Protocol), Error = ConnectError>
-        + 'static,
+    T: Service<Connect, Response = (Io, Protocol), Error = ConnectError> + 'static,
 {
-    type Request = Connect;
     type Response = IoConnection<Io>;
     type Error = ConnectError;
     type Future = LocalBoxFuture<'static, Result<IoConnection<Io>, ConnectError>>;
@@ -438,7 +435,7 @@ where
 impl<T, Io> Future for ConnectorPoolSupport<T, Io>
 where
     Io: AsyncRead + AsyncWrite + Unpin + 'static,
-    T: Service<Request = Connect, Response = (Io, Protocol), Error = ConnectError>,
+    T: Service<Connect, Response = (Io, Protocol), Error = ConnectError>,
     T::Future: 'static,
 {
     type Output = ();
diff --git a/actix-http/src/cloneable.rs b/actix-http/src/cloneable.rs
index 0e77c455c..5f0b1ea28 100644
--- a/actix-http/src/cloneable.rs
+++ b/actix-http/src/cloneable.rs
@@ -10,22 +10,21 @@ use actix_service::Service;
 /// CloneableService might panic with some creative use of thread local storage.
 /// See https://github.com/actix/actix-web/issues/1295 for example
 #[doc(hidden)]
-pub(crate) struct CloneableService<T: Service>(Rc<RefCell<T>>);
+pub(crate) struct CloneableService<T>(Rc<RefCell<T>>);
 
-impl<T: Service> CloneableService<T> {
+impl<T> CloneableService<T> {
     pub(crate) fn new(service: T) -> Self {
         Self(Rc::new(RefCell::new(service)))
     }
 }
 
-impl<T: Service> Clone for CloneableService<T> {
+impl<T> Clone for CloneableService<T> {
     fn clone(&self) -> Self {
         Self(self.0.clone())
     }
 }
 
-impl<T: Service> Service for CloneableService<T> {
-    type Request = T::Request;
+impl<T: Service<Req>, Req> Service<Req> for CloneableService<T> {
     type Response = T::Response;
     type Error = T::Error;
     type Future = T::Future;
@@ -34,7 +33,7 @@ impl<T: Service> Service for CloneableService<T> {
         self.0.borrow_mut().poll_ready(cx)
     }
 
-    fn call(&mut self, req: T::Request) -> Self::Future {
+    fn call(&mut self, req: Req) -> Self::Future {
         self.0.borrow_mut().call(req)
     }
 }
diff --git a/actix-http/src/error.rs b/actix-http/src/error.rs
index 1c0b1355e..daf8677ba 100644
--- a/actix-http/src/error.rs
+++ b/actix-http/src/error.rs
@@ -178,7 +178,7 @@ impl ResponseError for FormError {}
 
 #[cfg(feature = "openssl")]
 /// `InternalServerError` for `openssl::ssl::Error`
-impl ResponseError for actix_connect::ssl::openssl::SslError {}
+impl ResponseError for actix_tls::accept::openssl::SslError {}
 
 // #[cfg(feature = "openssl")]
 // /// `InternalServerError` for `openssl::ssl::HandshakeError`
diff --git a/actix-http/src/h1/codec.rs b/actix-http/src/h1/codec.rs
index c9a62dc30..d5035df26 100644
--- a/actix-http/src/h1/codec.rs
+++ b/actix-http/src/h1/codec.rs
@@ -111,8 +111,8 @@ impl Decoder for Codec {
     type Error = ParseError;
 
     fn decode(&mut self, src: &mut BytesMut) -> Result<Option<Self::Item>, Self::Error> {
-        if self.payload.is_some() {
-            Ok(match self.payload.as_mut().unwrap().decode(src)? {
+        if let Some(ref mut payload) = self.payload {
+            Ok(match payload.decode(src)? {
                 Some(PayloadItem::Chunk(chunk)) => Some(Message::Chunk(Some(chunk))),
                 Some(PayloadItem::Eof) => {
                     self.payload.take();
diff --git a/actix-http/src/h1/dispatcher.rs b/actix-http/src/h1/dispatcher.rs
index 92e77620c..d144fc58c 100644
--- a/actix-http/src/h1/dispatcher.rs
+++ b/actix-http/src/h1/dispatcher.rs
@@ -52,12 +52,12 @@ bitflags! {
 /// Dispatcher for HTTP/1.1 protocol
 pub struct Dispatcher<T, S, B, X, U>
 where
-    S: Service<Request = Request>,
+    S: Service<Request>,
     S::Error: Into<Error>,
     B: MessageBody,
-    X: Service<Request = Request, Response = Request>,
+    X: Service<Request, Response = Request>,
     X::Error: Into<Error>,
-    U: Service<Request = (Request, Framed<T, Codec>), Response = ()>,
+    U: Service<(Request, Framed<T, Codec>), Response = ()>,
     U::Error: fmt::Display,
 {
     #[pin]
@@ -70,12 +70,12 @@ where
 #[pin_project(project = DispatcherStateProj)]
 enum DispatcherState<T, S, B, X, U>
 where
-    S: Service<Request = Request>,
+    S: Service<Request>,
     S::Error: Into<Error>,
     B: MessageBody,
-    X: Service<Request = Request, Response = Request>,
+    X: Service<Request, Response = Request>,
     X::Error: Into<Error>,
-    U: Service<Request = (Request, Framed<T, Codec>), Response = ()>,
+    U: Service<(Request, Framed<T, Codec>), Response = ()>,
     U::Error: fmt::Display,
 {
     Normal(#[pin] InnerDispatcher<T, S, B, X, U>),
@@ -85,12 +85,12 @@ where
 #[pin_project(project = InnerDispatcherProj)]
 struct InnerDispatcher<T, S, B, X, U>
 where
-    S: Service<Request = Request>,
+    S: Service<Request>,
     S::Error: Into<Error>,
     B: MessageBody,
-    X: Service<Request = Request, Response = Request>,
+    X: Service<Request, Response = Request>,
     X::Error: Into<Error>,
-    U: Service<Request = (Request, Framed<T, Codec>), Response = ()>,
+    U: Service<(Request, Framed<T, Codec>), Response = ()>,
     U::Error: fmt::Display,
 {
     service: CloneableService<S>,
@@ -126,8 +126,8 @@ enum DispatcherMessage {
 #[pin_project(project = StateProj)]
 enum State<S, B, X>
 where
-    S: Service<Request = Request>,
-    X: Service<Request = Request, Response = Request>,
+    S: Service<Request>,
+    X: Service<Request, Response = Request>,
     B: MessageBody,
 {
     None,
@@ -138,8 +138,8 @@ where
 
 impl<S, B, X> State<S, B, X>
 where
-    S: Service<Request = Request>,
-    X: Service<Request = Request, Response = Request>,
+    S: Service<Request>,
+    X: Service<Request, Response = Request>,
     B: MessageBody,
 {
     fn is_empty(&self) -> bool {
@@ -169,13 +169,13 @@ impl PartialEq for PollResponse {
 impl<T, S, B, X, U> Dispatcher<T, S, B, X, U>
 where
     T: AsyncRead + AsyncWrite + Unpin,
-    S: Service<Request = Request>,
+    S: Service<Request>,
     S::Error: Into<Error>,
     S::Response: Into<Response<B>>,
     B: MessageBody,
-    X: Service<Request = Request, Response = Request>,
+    X: Service<Request, Response = Request>,
     X::Error: Into<Error>,
-    U: Service<Request = (Request, Framed<T, Codec>), Response = ()>,
+    U: Service<(Request, Framed<T, Codec>), Response = ()>,
     U::Error: fmt::Display,
 {
     /// Create HTTP/1 dispatcher.
@@ -264,13 +264,13 @@ where
 impl<T, S, B, X, U> InnerDispatcher<T, S, B, X, U>
 where
     T: AsyncRead + AsyncWrite + Unpin,
-    S: Service<Request = Request>,
+    S: Service<Request>,
     S::Error: Into<Error>,
     S::Response: Into<Response<B>>,
     B: MessageBody,
-    X: Service<Request = Request, Response = Request>,
+    X: Service<Request, Response = Request>,
     X::Error: Into<Error>,
-    U: Service<Request = (Request, Framed<T, Codec>), Response = ()>,
+    U: Service<(Request, Framed<T, Codec>), Response = ()>,
     U::Error: fmt::Display,
 {
     fn can_read(&self, cx: &mut Context<'_>) -> bool {
@@ -758,13 +758,13 @@ where
 impl<T, S, B, X, U> Future for Dispatcher<T, S, B, X, U>
 where
     T: AsyncRead + AsyncWrite + Unpin,
-    S: Service<Request = Request>,
+    S: Service<Request>,
     S::Error: Into<Error>,
     S::Response: Into<Response<B>>,
     B: MessageBody,
-    X: Service<Request = Request, Response = Request>,
+    X: Service<Request, Response = Request>,
     X::Error: Into<Error>,
-    U: Service<Request = (Request, Framed<T, Codec>), Response = ()>,
+    U: Service<(Request, Framed<T, Codec>), Response = ()>,
     U::Error: fmt::Display,
 {
     type Output = Result<(), DispatchError>;
@@ -1007,21 +1007,19 @@ mod tests {
         }
     }
 
-    fn ok_service() -> impl Service<Request = Request, Response = Response, Error = Error>
-    {
+    fn ok_service() -> impl Service<Request, Response = Response, Error = Error> {
         fn_service(|_req: Request| ready(Ok::<_, Error>(Response::Ok().finish())))
     }
 
-    fn echo_path_service(
-    ) -> impl Service<Request = Request, Response = Response, Error = Error> {
+    fn echo_path_service() -> impl Service<Request, Response = Response, Error = Error> {
         fn_service(|req: Request| {
             let path = req.path().as_bytes();
             ready(Ok::<_, Error>(Response::Ok().body(Body::from_slice(path))))
         })
     }
 
-    fn echo_payload_service(
-    ) -> impl Service<Request = Request, Response = Response, Error = Error> {
+    fn echo_payload_service() -> impl Service<Request, Response = Response, Error = Error>
+    {
         fn_service(|mut req: Request| {
             Box::pin(async move {
                 use futures_util::stream::StreamExt as _;
diff --git a/actix-http/src/h1/expect.rs b/actix-http/src/h1/expect.rs
index b89c7ff74..9cb8c34a7 100644
--- a/actix-http/src/h1/expect.rs
+++ b/actix-http/src/h1/expect.rs
@@ -8,9 +8,8 @@ use crate::request::Request;
 
 pub struct ExpectHandler;
 
-impl ServiceFactory for ExpectHandler {
+impl ServiceFactory<Request> for ExpectHandler {
     type Config = ();
-    type Request = Request;
     type Response = Request;
     type Error = Error;
     type Service = ExpectHandler;
@@ -22,8 +21,7 @@ impl ServiceFactory for ExpectHandler {
     }
 }
 
-impl Service for ExpectHandler {
-    type Request = Request;
+impl Service<Request> for ExpectHandler {
     type Response = Request;
     type Error = Error;
     type Future = Ready<Result<Self::Response, Self::Error>>;
diff --git a/actix-http/src/h1/service.rs b/actix-http/src/h1/service.rs
index 26ff5292f..663949007 100644
--- a/actix-http/src/h1/service.rs
+++ b/actix-http/src/h1/service.rs
@@ -25,26 +25,26 @@ use super::dispatcher::Dispatcher;
 use super::{ExpectHandler, UpgradeHandler};
 
 /// `ServiceFactory` implementation for HTTP1 transport
-pub struct H1Service<T, S, B, X = ExpectHandler, U = UpgradeHandler<T>> {
+pub struct H1Service<T, S, B, X = ExpectHandler, U = UpgradeHandler> {
     srv: S,
     cfg: ServiceConfig,
     expect: X,
     upgrade: Option<U>,
     on_connect: Option<Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
     on_connect_ext: Option<Rc<ConnectCallback<T>>>,
-    _t: PhantomData<(T, B)>,
+    _t: PhantomData<B>,
 }
 
 impl<T, S, B> H1Service<T, S, B>
 where
-    S: ServiceFactory<Config = (), Request = Request>,
+    S: ServiceFactory<Request, Config = ()>,
     S::Error: Into<Error>,
     S::InitError: fmt::Debug,
     S::Response: Into<Response<B>>,
     B: MessageBody,
 {
     /// Create new `HttpService` instance with config.
-    pub(crate) fn with_config<F: IntoServiceFactory<S>>(
+    pub(crate) fn with_config<F: IntoServiceFactory<S, Request>>(
         cfg: ServiceConfig,
         service: F,
     ) -> Self {
@@ -62,19 +62,15 @@ where
 
 impl<S, B, X, U> H1Service<TcpStream, S, B, X, U>
 where
-    S: ServiceFactory<Config = (), Request = Request>,
+    S: ServiceFactory<Request, Config = ()>,
     S::Error: Into<Error>,
     S::InitError: fmt::Debug,
     S::Response: Into<Response<B>>,
     B: MessageBody,
-    X: ServiceFactory<Config = (), Request = Request, Response = Request>,
+    X: ServiceFactory<Request, Config = (), Response = Request>,
     X::Error: Into<Error>,
     X::InitError: fmt::Debug,
-    U: ServiceFactory<
-        Config = (),
-        Request = (Request, Framed<TcpStream, Codec>),
-        Response = (),
-    >,
+    U: ServiceFactory<(Request, Framed<TcpStream, Codec>), Config = (), Response = ()>,
     U::Error: fmt::Display + Into<Error>,
     U::InitError: fmt::Debug,
 {
@@ -82,8 +78,8 @@ where
     pub fn tcp(
         self,
     ) -> impl ServiceFactory<
+        TcpStream,
         Config = (),
-        Request = TcpStream,
         Response = (),
         Error = DispatchError,
         InitError = (),
@@ -100,22 +96,23 @@ where
 mod openssl {
     use super::*;
 
-    use actix_tls::openssl::{Acceptor, SslAcceptor, SslStream};
-    use actix_tls::{openssl::Error as SslError, TlsError};
+    use actix_service::ServiceFactoryExt;
+    use actix_tls::accept::openssl::{Acceptor, SslAcceptor, SslError, SslStream};
+    use actix_tls::accept::TlsError;
 
     impl<S, B, X, U> H1Service<SslStream<TcpStream>, S, B, X, U>
     where
-        S: ServiceFactory<Config = (), Request = Request>,
+        S: ServiceFactory<Request, Config = ()>,
         S::Error: Into<Error>,
         S::InitError: fmt::Debug,
         S::Response: Into<Response<B>>,
         B: MessageBody,
-        X: ServiceFactory<Config = (), Request = Request, Response = Request>,
+        X: ServiceFactory<Request, Config = (), Response = Request>,
         X::Error: Into<Error>,
         X::InitError: fmt::Debug,
         U: ServiceFactory<
+            (Request, Framed<SslStream<TcpStream>, Codec>),
             Config = (),
-            Request = (Request, Framed<SslStream<TcpStream>, Codec>),
             Response = (),
         >,
         U::Error: fmt::Display + Into<Error>,
@@ -126,8 +123,8 @@ mod openssl {
             self,
             acceptor: SslAcceptor,
         ) -> impl ServiceFactory<
+            TcpStream,
             Config = (),
-            Request = TcpStream,
             Response = (),
             Error = TlsError<SslError, DispatchError>,
             InitError = (),
@@ -149,23 +146,24 @@ mod openssl {
 #[cfg(feature = "rustls")]
 mod rustls {
     use super::*;
-    use actix_tls::rustls::{Acceptor, ServerConfig, TlsStream};
-    use actix_tls::TlsError;
+    use actix_service::ServiceFactoryExt;
+    use actix_tls::accept::rustls::{Acceptor, ServerConfig, TlsStream};
+    use actix_tls::accept::TlsError;
     use std::{fmt, io};
 
     impl<S, B, X, U> H1Service<TlsStream<TcpStream>, S, B, X, U>
     where
-        S: ServiceFactory<Config = (), Request = Request>,
+        S: ServiceFactory<Request, Config = ()>,
         S::Error: Into<Error>,
         S::InitError: fmt::Debug,
         S::Response: Into<Response<B>>,
         B: MessageBody,
-        X: ServiceFactory<Config = (), Request = Request, Response = Request>,
+        X: ServiceFactory<Request, Config = (), Response = Request>,
         X::Error: Into<Error>,
         X::InitError: fmt::Debug,
         U: ServiceFactory<
+            (Request, Framed<TlsStream<TcpStream>, Codec>),
             Config = (),
-            Request = (Request, Framed<TlsStream<TcpStream>, Codec>),
             Response = (),
         >,
         U::Error: fmt::Display + Into<Error>,
@@ -176,8 +174,8 @@ mod rustls {
             self,
             config: ServerConfig,
         ) -> impl ServiceFactory<
+            TcpStream,
             Config = (),
-            Request = TcpStream,
             Response = (),
             Error = TlsError<io::Error, DispatchError>,
             InitError = (),
@@ -198,7 +196,7 @@ mod rustls {
 
 impl<T, S, B, X, U> H1Service<T, S, B, X, U>
 where
-    S: ServiceFactory<Config = (), Request = Request>,
+    S: ServiceFactory<Request, Config = ()>,
     S::Error: Into<Error>,
     S::Response: Into<Response<B>>,
     S::InitError: fmt::Debug,
@@ -206,7 +204,7 @@ where
 {
     pub fn expect<X1>(self, expect: X1) -> H1Service<T, S, B, X1, U>
     where
-        X1: ServiceFactory<Request = Request, Response = Request>,
+        X1: ServiceFactory<Request, Response = Request>,
         X1::Error: Into<Error>,
         X1::InitError: fmt::Debug,
     {
@@ -223,7 +221,7 @@ where
 
     pub fn upgrade<U1>(self, upgrade: Option<U1>) -> H1Service<T, S, B, X, U1>
     where
-        U1: ServiceFactory<Request = (Request, Framed<T, Codec>), Response = ()>,
+        U1: ServiceFactory<(Request, Framed<T, Codec>), Response = ()>,
         U1::Error: fmt::Display,
         U1::InitError: fmt::Debug,
     {
@@ -254,27 +252,27 @@ where
     }
 }
 
-impl<T, S, B, X, U> ServiceFactory for H1Service<T, S, B, X, U>
+impl<T, S, B, X, U> ServiceFactory<(T, Option<net::SocketAddr>)>
+    for H1Service<T, S, B, X, U>
 where
     T: AsyncRead + AsyncWrite + Unpin,
-    S: ServiceFactory<Config = (), Request = Request>,
+    S: ServiceFactory<Request, Config = ()>,
     S::Error: Into<Error>,
     S::Response: Into<Response<B>>,
     S::InitError: fmt::Debug,
     B: MessageBody,
-    X: ServiceFactory<Config = (), Request = Request, Response = Request>,
+    X: ServiceFactory<Request, Config = (), Response = Request>,
     X::Error: Into<Error>,
     X::InitError: fmt::Debug,
-    U: ServiceFactory<Config = (), Request = (Request, Framed<T, Codec>), Response = ()>,
+    U: ServiceFactory<(Request, Framed<T, Codec>), Config = (), Response = ()>,
     U::Error: fmt::Display + Into<Error>,
     U::InitError: fmt::Debug,
 {
-    type Config = ();
-    type Request = (T, Option<net::SocketAddr>);
     type Response = ();
     type Error = DispatchError;
-    type InitError = ();
+    type Config = ();
     type Service = H1ServiceHandler<T, S::Service, B, X::Service, U::Service>;
+    type InitError = ();
     type Future = H1ServiceResponse<T, S, B, X, U>;
 
     fn new_service(&self, _: ()) -> Self::Future {
@@ -296,13 +294,13 @@ where
 #[pin_project::pin_project]
 pub struct H1ServiceResponse<T, S, B, X, U>
 where
-    S: ServiceFactory<Request = Request>,
+    S: ServiceFactory<Request>,
     S::Error: Into<Error>,
     S::InitError: fmt::Debug,
-    X: ServiceFactory<Request = Request, Response = Request>,
+    X: ServiceFactory<Request, Response = Request>,
     X::Error: Into<Error>,
     X::InitError: fmt::Debug,
-    U: ServiceFactory<Request = (Request, Framed<T, Codec>), Response = ()>,
+    U: ServiceFactory<(Request, Framed<T, Codec>), Response = ()>,
     U::Error: fmt::Display,
     U::InitError: fmt::Debug,
 {
@@ -323,15 +321,15 @@ where
 impl<T, S, B, X, U> Future for H1ServiceResponse<T, S, B, X, U>
 where
     T: AsyncRead + AsyncWrite + Unpin,
-    S: ServiceFactory<Request = Request>,
+    S: ServiceFactory<Request>,
     S::Error: Into<Error>,
     S::Response: Into<Response<B>>,
     S::InitError: fmt::Debug,
     B: MessageBody,
-    X: ServiceFactory<Request = Request, Response = Request>,
+    X: ServiceFactory<Request, Response = Request>,
     X::Error: Into<Error>,
     X::InitError: fmt::Debug,
-    U: ServiceFactory<Request = (Request, Framed<T, Codec>), Response = ()>,
+    U: ServiceFactory<(Request, Framed<T, Codec>), Response = ()>,
     U::Error: fmt::Display,
     U::InitError: fmt::Debug,
 {
@@ -379,25 +377,30 @@ where
 }
 
 /// `Service` implementation for HTTP/1 transport
-pub struct H1ServiceHandler<T, S: Service, B, X: Service, U: Service> {
+pub struct H1ServiceHandler<T, S, B, X, U>
+where
+    S: Service<Request>,
+    X: Service<Request>,
+    U: Service<(Request, Framed<T, Codec>)>,
+{
     srv: CloneableService<S>,
     expect: CloneableService<X>,
     upgrade: Option<CloneableService<U>>,
     on_connect: Option<Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
     on_connect_ext: Option<Rc<ConnectCallback<T>>>,
     cfg: ServiceConfig,
-    _t: PhantomData<(T, B)>,
+    _t: PhantomData<B>,
 }
 
 impl<T, S, B, X, U> H1ServiceHandler<T, S, B, X, U>
 where
-    S: Service<Request = Request>,
+    S: Service<Request>,
     S::Error: Into<Error>,
     S::Response: Into<Response<B>>,
     B: MessageBody,
-    X: Service<Request = Request, Response = Request>,
+    X: Service<Request, Response = Request>,
     X::Error: Into<Error>,
-    U: Service<Request = (Request, Framed<T, Codec>), Response = ()>,
+    U: Service<(Request, Framed<T, Codec>), Response = ()>,
     U::Error: fmt::Display,
 {
     fn new(
@@ -420,19 +423,19 @@ where
     }
 }
 
-impl<T, S, B, X, U> Service for H1ServiceHandler<T, S, B, X, U>
+impl<T, S, B, X, U> Service<(T, Option<net::SocketAddr>)>
+    for H1ServiceHandler<T, S, B, X, U>
 where
     T: AsyncRead + AsyncWrite + Unpin,
-    S: Service<Request = Request>,
+    S: Service<Request>,
     S::Error: Into<Error>,
     S::Response: Into<Response<B>>,
     B: MessageBody,
-    X: Service<Request = Request, Response = Request>,
+    X: Service<Request, Response = Request>,
     X::Error: Into<Error>,
-    U: Service<Request = (Request, Framed<T, Codec>), Response = ()>,
+    U: Service<(Request, Framed<T, Codec>), Response = ()>,
     U::Error: fmt::Display + Into<Error>,
 {
-    type Request = (T, Option<net::SocketAddr>);
     type Response = ();
     type Error = DispatchError;
     type Future = Dispatcher<T, S, B, X, U>;
@@ -479,7 +482,7 @@ where
         }
     }
 
-    fn call(&mut self, (io, addr): Self::Request) -> Self::Future {
+    fn call(&mut self, (io, addr): (T, Option<net::SocketAddr>)) -> Self::Future {
         let deprecated_on_connect = self.on_connect.as_ref().map(|handler| handler(&io));
 
         let mut connect_extensions = Extensions::new();
diff --git a/actix-http/src/h1/upgrade.rs b/actix-http/src/h1/upgrade.rs
index 8615f27a8..007aff1bf 100644
--- a/actix-http/src/h1/upgrade.rs
+++ b/actix-http/src/h1/upgrade.rs
@@ -1,4 +1,3 @@
-use std::marker::PhantomData;
 use std::task::{Context, Poll};
 
 use actix_codec::Framed;
@@ -9,14 +8,13 @@ use crate::error::Error;
 use crate::h1::Codec;
 use crate::request::Request;
 
-pub struct UpgradeHandler<T>(pub(crate) PhantomData<T>);
+pub struct UpgradeHandler;
 
-impl<T> ServiceFactory for UpgradeHandler<T> {
-    type Config = ();
-    type Request = (Request, Framed<T, Codec>);
+impl<T> ServiceFactory<(Request, Framed<T, Codec>)> for UpgradeHandler {
     type Response = ();
     type Error = Error;
-    type Service = UpgradeHandler<T>;
+    type Config = ();
+    type Service = UpgradeHandler;
     type InitError = Error;
     type Future = Ready<Result<Self::Service, Self::InitError>>;
 
@@ -25,8 +23,7 @@ impl<T> ServiceFactory for UpgradeHandler<T> {
     }
 }
 
-impl<T> Service for UpgradeHandler<T> {
-    type Request = (Request, Framed<T, Codec>);
+impl<T> Service<(Request, Framed<T, Codec>)> for UpgradeHandler {
     type Response = ();
     type Error = Error;
     type Future = Ready<Result<Self::Response, Self::Error>>;
@@ -35,7 +32,7 @@ impl<T> Service for UpgradeHandler<T> {
         Poll::Ready(Ok(()))
     }
 
-    fn call(&mut self, _: Self::Request) -> Self::Future {
+    fn call(&mut self, _: (Request, Framed<T, Codec>)) -> Self::Future {
         ready(Ok(()))
     }
 }
diff --git a/actix-http/src/h2/dispatcher.rs b/actix-http/src/h2/dispatcher.rs
index b204afbb9..1be6157a9 100644
--- a/actix-http/src/h2/dispatcher.rs
+++ b/actix-http/src/h2/dispatcher.rs
@@ -30,9 +30,11 @@ const CHUNK_SIZE: usize = 16_384;
 
 /// Dispatcher for HTTP/2 protocol
 #[pin_project::pin_project]
-pub struct Dispatcher<T, S: Service<Request = Request>, B: MessageBody>
+pub struct Dispatcher<T, S, B>
 where
     T: AsyncRead + AsyncWrite + Unpin,
+    S: Service<Request>,
+    B: MessageBody,
 {
     service: CloneableService<S>,
     connection: Connection<T, Bytes>,
@@ -48,7 +50,7 @@ where
 impl<T, S, B> Dispatcher<T, S, B>
 where
     T: AsyncRead + AsyncWrite + Unpin,
-    S: Service<Request = Request>,
+    S: Service<Request>,
     S::Error: Into<Error>,
     // S::Future: 'static,
     S::Response: Into<Response<B>>,
@@ -96,7 +98,7 @@ where
 impl<T, S, B> Future for Dispatcher<T, S, B>
 where
     T: AsyncRead + AsyncWrite + Unpin,
-    S: Service<Request = Request>,
+    S: Service<Request>,
     S::Error: Into<Error> + 'static,
     S::Future: 'static,
     S::Response: Into<Response<B>> + 'static,
diff --git a/actix-http/src/h2/service.rs b/actix-http/src/h2/service.rs
index ab01d966b..fc1ace6fa 100644
--- a/actix-http/src/h2/service.rs
+++ b/actix-http/src/h2/service.rs
@@ -38,14 +38,14 @@ pub struct H2Service<T, S, B> {
 
 impl<T, S, B> H2Service<T, S, B>
 where
-    S: ServiceFactory<Config = (), Request = Request>,
+    S: ServiceFactory<Request, Config = ()>,
     S::Error: Into<Error> + 'static,
     S::Response: Into<Response<B>> + 'static,
-    <S::Service as Service>::Future: 'static,
+    <S::Service as Service<Request>>::Future: 'static,
     B: MessageBody + 'static,
 {
     /// Create new `HttpService` instance with config.
-    pub(crate) fn with_config<F: IntoServiceFactory<S>>(
+    pub(crate) fn with_config<F: IntoServiceFactory<S, Request>>(
         cfg: ServiceConfig,
         service: F,
     ) -> Self {
@@ -77,18 +77,18 @@ where
 
 impl<S, B> H2Service<TcpStream, S, B>
 where
-    S: ServiceFactory<Config = (), Request = Request>,
+    S: ServiceFactory<Request, Config = ()>,
     S::Error: Into<Error> + 'static,
     S::Response: Into<Response<B>> + 'static,
-    <S::Service as Service>::Future: 'static,
+    <S::Service as Service<Request>>::Future: 'static,
     B: MessageBody + 'static,
 {
     /// Create simple tcp based service
     pub fn tcp(
         self,
     ) -> impl ServiceFactory<
+        TcpStream,
         Config = (),
-        Request = TcpStream,
         Response = (),
         Error = DispatchError,
         InitError = S::InitError,
@@ -105,18 +105,18 @@ where
 
 #[cfg(feature = "openssl")]
 mod openssl {
-    use actix_service::{fn_factory, fn_service};
-    use actix_tls::openssl::{Acceptor, SslAcceptor, SslStream};
-    use actix_tls::{openssl::Error as SslError, TlsError};
+    use actix_service::{fn_factory, fn_service, ServiceFactoryExt};
+    use actix_tls::accept::openssl::{Acceptor, SslAcceptor, SslError, SslStream};
+    use actix_tls::accept::TlsError;
 
     use super::*;
 
     impl<S, B> H2Service<SslStream<TcpStream>, S, B>
     where
-        S: ServiceFactory<Config = (), Request = Request>,
+        S: ServiceFactory<Request, Config = ()>,
         S::Error: Into<Error> + 'static,
         S::Response: Into<Response<B>> + 'static,
-        <S::Service as Service>::Future: 'static,
+        <S::Service as Service<Request>>::Future: 'static,
         B: MessageBody + 'static,
     {
         /// Create ssl based service
@@ -124,8 +124,8 @@ mod openssl {
             self,
             acceptor: SslAcceptor,
         ) -> impl ServiceFactory<
+            TcpStream,
             Config = (),
-            Request = TcpStream,
             Response = (),
             Error = TlsError<SslError, DispatchError>,
             InitError = S::InitError,
@@ -149,16 +149,17 @@ mod openssl {
 #[cfg(feature = "rustls")]
 mod rustls {
     use super::*;
-    use actix_tls::rustls::{Acceptor, ServerConfig, TlsStream};
-    use actix_tls::TlsError;
+    use actix_service::ServiceFactoryExt;
+    use actix_tls::accept::rustls::{Acceptor, ServerConfig, TlsStream};
+    use actix_tls::accept::TlsError;
     use std::io;
 
     impl<S, B> H2Service<TlsStream<TcpStream>, S, B>
     where
-        S: ServiceFactory<Config = (), Request = Request>,
+        S: ServiceFactory<Request, Config = ()>,
         S::Error: Into<Error> + 'static,
         S::Response: Into<Response<B>> + 'static,
-        <S::Service as Service>::Future: 'static,
+        <S::Service as Service<Request>>::Future: 'static,
         B: MessageBody + 'static,
     {
         /// Create openssl based service
@@ -166,8 +167,8 @@ mod rustls {
             self,
             mut config: ServerConfig,
         ) -> impl ServiceFactory<
+            TcpStream,
             Config = (),
-            Request = TcpStream,
             Response = (),
             Error = TlsError<io::Error, DispatchError>,
             InitError = S::InitError,
@@ -191,21 +192,20 @@ mod rustls {
     }
 }
 
-impl<T, S, B> ServiceFactory for H2Service<T, S, B>
+impl<T, S, B> ServiceFactory<(T, Option<net::SocketAddr>)> for H2Service<T, S, B>
 where
     T: AsyncRead + AsyncWrite + Unpin,
-    S: ServiceFactory<Config = (), Request = Request>,
+    S: ServiceFactory<Request, Config = ()>,
     S::Error: Into<Error> + 'static,
     S::Response: Into<Response<B>> + 'static,
-    <S::Service as Service>::Future: 'static,
+    <S::Service as Service<Request>>::Future: 'static,
     B: MessageBody + 'static,
 {
-    type Config = ();
-    type Request = (T, Option<net::SocketAddr>);
     type Response = ();
     type Error = DispatchError;
-    type InitError = S::InitError;
+    type Config = ();
     type Service = H2ServiceHandler<T, S::Service, B>;
+    type InitError = S::InitError;
     type Future = H2ServiceResponse<T, S, B>;
 
     fn new_service(&self, _: ()) -> Self::Future {
@@ -221,22 +221,25 @@ where
 
 #[doc(hidden)]
 #[pin_project::pin_project]
-pub struct H2ServiceResponse<T, S: ServiceFactory, B> {
+pub struct H2ServiceResponse<T, S, B>
+where
+    S: ServiceFactory<Request>,
+{
     #[pin]
     fut: S::Future,
     cfg: Option<ServiceConfig>,
     on_connect: Option<Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
     on_connect_ext: Option<Rc<ConnectCallback<T>>>,
-    _t: PhantomData<(T, B)>,
+    _t: PhantomData<B>,
 }
 
 impl<T, S, B> Future for H2ServiceResponse<T, S, B>
 where
     T: AsyncRead + AsyncWrite + Unpin,
-    S: ServiceFactory<Config = (), Request = Request>,
+    S: ServiceFactory<Request, Config = ()>,
     S::Error: Into<Error> + 'static,
     S::Response: Into<Response<B>> + 'static,
-    <S::Service as Service>::Future: 'static,
+    <S::Service as Service<Request>>::Future: 'static,
     B: MessageBody + 'static,
 {
     type Output = Result<H2ServiceHandler<T, S::Service, B>, S::InitError>;
@@ -257,17 +260,20 @@ where
 }
 
 /// `Service` implementation for http/2 transport
-pub struct H2ServiceHandler<T, S: Service, B> {
+pub struct H2ServiceHandler<T, S, B>
+where
+    S: Service<Request>,
+{
     srv: CloneableService<S>,
     cfg: ServiceConfig,
     on_connect: Option<Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
     on_connect_ext: Option<Rc<ConnectCallback<T>>>,
-    _t: PhantomData<(T, B)>,
+    _t: PhantomData<B>,
 }
 
 impl<T, S, B> H2ServiceHandler<T, S, B>
 where
-    S: Service<Request = Request>,
+    S: Service<Request>,
     S::Error: Into<Error> + 'static,
     S::Future: 'static,
     S::Response: Into<Response<B>> + 'static,
@@ -289,16 +295,15 @@ where
     }
 }
 
-impl<T, S, B> Service for H2ServiceHandler<T, S, B>
+impl<T, S, B> Service<(T, Option<net::SocketAddr>)> for H2ServiceHandler<T, S, B>
 where
     T: AsyncRead + AsyncWrite + Unpin,
-    S: Service<Request = Request>,
+    S: Service<Request>,
     S::Error: Into<Error> + 'static,
     S::Future: 'static,
     S::Response: Into<Response<B>> + 'static,
     B: MessageBody + 'static,
 {
-    type Request = (T, Option<net::SocketAddr>);
     type Response = ();
     type Error = DispatchError;
     type Future = H2ServiceHandlerResponse<T, S, B>;
@@ -311,7 +316,7 @@ where
         })
     }
 
-    fn call(&mut self, (io, addr): Self::Request) -> Self::Future {
+    fn call(&mut self, (io, addr): (T, Option<net::SocketAddr>)) -> Self::Future {
         let deprecated_on_connect = self.on_connect.as_ref().map(|handler| handler(&io));
 
         let mut connect_extensions = Extensions::new();
@@ -333,7 +338,7 @@ where
     }
 }
 
-enum State<T, S: Service<Request = Request>, B: MessageBody>
+enum State<T, S: Service<Request>, B: MessageBody>
 where
     T: AsyncRead + AsyncWrite + Unpin,
     S::Future: 'static,
@@ -352,7 +357,7 @@ where
 pub struct H2ServiceHandlerResponse<T, S, B>
 where
     T: AsyncRead + AsyncWrite + Unpin,
-    S: Service<Request = Request>,
+    S: Service<Request>,
     S::Error: Into<Error> + 'static,
     S::Future: 'static,
     S::Response: Into<Response<B>> + 'static,
@@ -364,7 +369,7 @@ where
 impl<T, S, B> Future for H2ServiceHandlerResponse<T, S, B>
 where
     T: AsyncRead + AsyncWrite + Unpin,
-    S: Service<Request = Request>,
+    S: Service<Request>,
     S::Error: Into<Error> + 'static,
     S::Future: 'static,
     S::Response: Into<Response<B>> + 'static,
diff --git a/actix-http/src/service.rs b/actix-http/src/service.rs
index 8a581f4ba..af2be296e 100644
--- a/actix-http/src/service.rs
+++ b/actix-http/src/service.rs
@@ -23,7 +23,7 @@ use crate::response::Response;
 use crate::{h1, h2::Dispatcher, ConnectCallback, Extensions, Protocol};
 
 /// A `ServiceFactory` for HTTP/1.1 or HTTP/2 protocol.
-pub struct HttpService<T, S, B, X = h1::ExpectHandler, U = h1::UpgradeHandler<T>> {
+pub struct HttpService<T, S, B, X = h1::ExpectHandler, U = h1::UpgradeHandler> {
     srv: S,
     cfg: ServiceConfig,
     expect: X,
@@ -31,16 +31,16 @@ pub struct HttpService<T, S, B, X = h1::ExpectHandler, U = h1::UpgradeHandler<T>
     // DEPRECATED: in favor of on_connect_ext
     on_connect: Option<Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
     on_connect_ext: Option<Rc<ConnectCallback<T>>>,
-    _t: PhantomData<(T, B)>,
+    _t: PhantomData<B>,
 }
 
 impl<T, S, B> HttpService<T, S, B>
 where
-    S: ServiceFactory<Config = (), Request = Request>,
+    S: ServiceFactory<Request, Config = ()>,
     S::Error: Into<Error> + 'static,
     S::InitError: fmt::Debug,
     S::Response: Into<Response<B>> + 'static,
-    <S::Service as Service>::Future: 'static,
+    <S::Service as Service<Request>>::Future: 'static,
     B: MessageBody + 'static,
 {
     /// Create builder for `HttpService` instance.
@@ -51,15 +51,15 @@ where
 
 impl<T, S, B> HttpService<T, S, B>
 where
-    S: ServiceFactory<Config = (), Request = Request>,
+    S: ServiceFactory<Request, Config = ()>,
     S::Error: Into<Error> + 'static,
     S::InitError: fmt::Debug,
     S::Response: Into<Response<B>> + 'static,
-    <S::Service as Service>::Future: 'static,
+    <S::Service as Service<Request>>::Future: 'static,
     B: MessageBody + 'static,
 {
     /// Create new `HttpService` instance.
-    pub fn new<F: IntoServiceFactory<S>>(service: F) -> Self {
+    pub fn new<F: IntoServiceFactory<S, Request>>(service: F) -> Self {
         let cfg = ServiceConfig::new(KeepAlive::Timeout(5), 5000, 0, false, None);
 
         HttpService {
@@ -74,7 +74,7 @@ where
     }
 
     /// Create new `HttpService` instance with config.
-    pub(crate) fn with_config<F: IntoServiceFactory<S>>(
+    pub(crate) fn with_config<F: IntoServiceFactory<S, Request>>(
         cfg: ServiceConfig,
         service: F,
     ) -> Self {
@@ -92,11 +92,11 @@ where
 
 impl<T, S, B, X, U> HttpService<T, S, B, X, U>
 where
-    S: ServiceFactory<Config = (), Request = Request>,
+    S: ServiceFactory<Request, Config = ()>,
     S::Error: Into<Error> + 'static,
     S::InitError: fmt::Debug,
     S::Response: Into<Response<B>> + 'static,
-    <S::Service as Service>::Future: 'static,
+    <S::Service as Service<Request>>::Future: 'static,
     B: MessageBody,
 {
     /// Provide service for `EXPECT: 100-Continue` support.
@@ -106,10 +106,10 @@ where
     /// request will be forwarded to main service.
     pub fn expect<X1>(self, expect: X1) -> HttpService<T, S, B, X1, U>
     where
-        X1: ServiceFactory<Config = (), Request = Request, Response = Request>,
+        X1: ServiceFactory<Request, Config = (), Response = Request>,
         X1::Error: Into<Error>,
         X1::InitError: fmt::Debug,
-        <X1::Service as Service>::Future: 'static,
+        <X1::Service as Service<Request>>::Future: 'static,
     {
         HttpService {
             expect,
@@ -128,14 +128,10 @@ where
     /// and this service get called with original request and framed object.
     pub fn upgrade<U1>(self, upgrade: Option<U1>) -> HttpService<T, S, B, X, U1>
     where
-        U1: ServiceFactory<
-            Config = (),
-            Request = (Request, Framed<T, h1::Codec>),
-            Response = (),
-        >,
+        U1: ServiceFactory<(Request, Framed<T, h1::Codec>), Config = (), Response = ()>,
         U1::Error: fmt::Display,
         U1::InitError: fmt::Debug,
-        <U1::Service as Service>::Future: 'static,
+        <U1::Service as Service<(Request, Framed<T, h1::Codec>)>>::Future: 'static,
     {
         HttpService {
             upgrade,
@@ -166,31 +162,31 @@ where
 
 impl<S, B, X, U> HttpService<TcpStream, S, B, X, U>
 where
-    S: ServiceFactory<Config = (), Request = Request>,
+    S: ServiceFactory<Request, Config = ()>,
     S::Error: Into<Error> + 'static,
     S::InitError: fmt::Debug,
     S::Response: Into<Response<B>> + 'static,
-    <S::Service as Service>::Future: 'static,
+    <S::Service as Service<Request>>::Future: 'static,
     B: MessageBody + 'static,
-    X: ServiceFactory<Config = (), Request = Request, Response = Request>,
+    X: ServiceFactory<Request, Config = (), Response = Request>,
     X::Error: Into<Error>,
     X::InitError: fmt::Debug,
-    <X::Service as Service>::Future: 'static,
+    <X::Service as Service<Request>>::Future: 'static,
     U: ServiceFactory<
+        (Request, Framed<TcpStream, h1::Codec>),
         Config = (),
-        Request = (Request, Framed<TcpStream, h1::Codec>),
         Response = (),
     >,
     U::Error: fmt::Display + Into<Error>,
     U::InitError: fmt::Debug,
-    <U::Service as Service>::Future: 'static,
+    <U::Service as Service<(Request, Framed<TcpStream, h1::Codec>)>>::Future: 'static,
 {
     /// Create simple tcp stream service
     pub fn tcp(
         self,
     ) -> impl ServiceFactory<
+        TcpStream,
         Config = (),
-        Request = TcpStream,
         Response = (),
         Error = DispatchError,
         InitError = (),
@@ -206,39 +202,40 @@ where
 #[cfg(feature = "openssl")]
 mod openssl {
     use super::*;
-    use actix_tls::openssl::{Acceptor, SslAcceptor, SslStream};
-    use actix_tls::{openssl::Error as SSlError, TlsError};
+    use actix_service::ServiceFactoryExt;
+    use actix_tls::accept::openssl::{Acceptor, SslAcceptor, SslError, SslStream};
+    use actix_tls::accept::TlsError;
 
     impl<S, B, X, U> HttpService<SslStream<TcpStream>, S, B, X, U>
     where
-        S: ServiceFactory<Config = (), Request = Request>,
+        S: ServiceFactory<Request, Config = ()>,
         S::Error: Into<Error> + 'static,
         S::InitError: fmt::Debug,
         S::Response: Into<Response<B>> + 'static,
-        <S::Service as Service>::Future: 'static,
+        <S::Service as Service<Request>>::Future: 'static,
         B: MessageBody + 'static,
-        X: ServiceFactory<Config = (), Request = Request, Response = Request>,
+        X: ServiceFactory<Request, Config = (), Response = Request>,
         X::Error: Into<Error>,
         X::InitError: fmt::Debug,
-        <X::Service as Service>::Future: 'static,
+        <X::Service as Service<Request>>::Future: 'static,
         U: ServiceFactory<
+            (Request, Framed<SslStream<TcpStream>, h1::Codec>),
             Config = (),
-            Request = (Request, Framed<SslStream<TcpStream>, h1::Codec>),
             Response = (),
         >,
         U::Error: fmt::Display + Into<Error>,
         U::InitError: fmt::Debug,
-        <U::Service as Service>::Future: 'static,
+        <U::Service as Service<(Request, Framed<SslStream<TcpStream>, h1::Codec>)>>::Future: 'static,
     {
         /// Create openssl based service
         pub fn openssl(
             self,
             acceptor: SslAcceptor,
         ) -> impl ServiceFactory<
+            TcpStream,
             Config = (),
-            Request = TcpStream,
             Response = (),
-            Error = TlsError<SSlError, DispatchError>,
+            Error = TlsError<SslError, DispatchError>,
             InitError = (),
         > {
             pipeline_factory(
@@ -266,39 +263,42 @@ mod openssl {
 
 #[cfg(feature = "rustls")]
 mod rustls {
-    use super::*;
-    use actix_tls::rustls::{Acceptor, ServerConfig, Session, TlsStream};
-    use actix_tls::TlsError;
     use std::io;
 
+    use actix_tls::accept::rustls::{Acceptor, ServerConfig, Session, TlsStream};
+    use actix_tls::accept::TlsError;
+
+    use super::*;
+    use actix_service::ServiceFactoryExt;
+
     impl<S, B, X, U> HttpService<TlsStream<TcpStream>, S, B, X, U>
     where
-        S: ServiceFactory<Config = (), Request = Request>,
+        S: ServiceFactory<Request, Config = ()>,
         S::Error: Into<Error> + 'static,
         S::InitError: fmt::Debug,
         S::Response: Into<Response<B>> + 'static,
-        <S::Service as Service>::Future: 'static,
+        <S::Service as Service<Request>>::Future: 'static,
         B: MessageBody + 'static,
-        X: ServiceFactory<Config = (), Request = Request, Response = Request>,
+        X: ServiceFactory<Request, Config = (), Response = Request>,
         X::Error: Into<Error>,
         X::InitError: fmt::Debug,
-        <X::Service as Service>::Future: 'static,
+        <X::Service as Service<Request>>::Future: 'static,
         U: ServiceFactory<
+            (Request, Framed<TlsStream<TcpStream>, h1::Codec>),
             Config = (),
-            Request = (Request, Framed<TlsStream<TcpStream>, h1::Codec>),
             Response = (),
         >,
         U::Error: fmt::Display + Into<Error>,
         U::InitError: fmt::Debug,
-        <U::Service as Service>::Future: 'static,
+        <U::Service as Service<(Request, Framed<TlsStream<TcpStream>, h1::Codec>)>>::Future: 'static,
     {
         /// Create openssl based service
         pub fn rustls(
             self,
             mut config: ServerConfig,
         ) -> impl ServiceFactory<
+            TcpStream,
             Config = (),
-            Request = TcpStream,
             Response = (),
             Error = TlsError<io::Error, DispatchError>,
             InitError = (),
@@ -329,30 +329,26 @@ mod rustls {
     }
 }
 
-impl<T, S, B, X, U> ServiceFactory for HttpService<T, S, B, X, U>
+impl<T, S, B, X, U> ServiceFactory<(T, Protocol, Option<net::SocketAddr>)>
+    for HttpService<T, S, B, X, U>
 where
     T: AsyncRead + AsyncWrite + Unpin,
-    S: ServiceFactory<Config = (), Request = Request>,
+    S: ServiceFactory<Request, Config = ()>,
     S::Error: Into<Error> + 'static,
     S::InitError: fmt::Debug,
     S::Response: Into<Response<B>> + 'static,
-    <S::Service as Service>::Future: 'static,
+    <S::Service as Service<Request>>::Future: 'static,
     B: MessageBody + 'static,
-    X: ServiceFactory<Config = (), Request = Request, Response = Request>,
+    X: ServiceFactory<Request, Config = (), Response = Request>,
     X::Error: Into<Error>,
     X::InitError: fmt::Debug,
-    <X::Service as Service>::Future: 'static,
-    U: ServiceFactory<
-        Config = (),
-        Request = (Request, Framed<T, h1::Codec>),
-        Response = (),
-    >,
+    <X::Service as Service<Request>>::Future: 'static,
+    U: ServiceFactory<(Request, Framed<T, h1::Codec>), Config = (), Response = ()>,
     U::Error: fmt::Display + Into<Error>,
     U::InitError: fmt::Debug,
-    <U::Service as Service>::Future: 'static,
+    <U::Service as Service<(Request, Framed<T, h1::Codec>)>>::Future: 'static,
 {
     type Config = ();
-    type Request = (T, Protocol, Option<net::SocketAddr>);
     type Response = ();
     type Error = DispatchError;
     type InitError = ();
@@ -376,13 +372,12 @@ where
 
 #[doc(hidden)]
 #[pin_project]
-pub struct HttpServiceResponse<
-    T,
-    S: ServiceFactory,
-    B,
-    X: ServiceFactory,
-    U: ServiceFactory,
-> {
+pub struct HttpServiceResponse<T, S, B, X, U>
+where
+    S: ServiceFactory<Request>,
+    X: ServiceFactory<Request>,
+    U: ServiceFactory<(Request, Framed<T, h1::Codec>)>,
+{
     #[pin]
     fut: S::Future,
     #[pin]
@@ -400,20 +395,20 @@ pub struct HttpServiceResponse<
 impl<T, S, B, X, U> Future for HttpServiceResponse<T, S, B, X, U>
 where
     T: AsyncRead + AsyncWrite + Unpin,
-    S: ServiceFactory<Request = Request>,
+    S: ServiceFactory<Request>,
     S::Error: Into<Error> + 'static,
     S::InitError: fmt::Debug,
     S::Response: Into<Response<B>> + 'static,
-    <S::Service as Service>::Future: 'static,
+    <S::Service as Service<Request>>::Future: 'static,
     B: MessageBody + 'static,
-    X: ServiceFactory<Request = Request, Response = Request>,
+    X: ServiceFactory<Request, Response = Request>,
     X::Error: Into<Error>,
     X::InitError: fmt::Debug,
-    <X::Service as Service>::Future: 'static,
-    U: ServiceFactory<Request = (Request, Framed<T, h1::Codec>), Response = ()>,
+    <X::Service as Service<Request>>::Future: 'static,
+    U: ServiceFactory<(Request, Framed<T, h1::Codec>), Response = ()>,
     U::Error: fmt::Display,
     U::InitError: fmt::Debug,
-    <U::Service as Service>::Future: 'static,
+    <U::Service as Service<(Request, Framed<T, h1::Codec>)>>::Future: 'static,
 {
     type Output =
         Result<HttpServiceHandler<T, S::Service, B, X::Service, U::Service>, ()>;
@@ -459,26 +454,31 @@ where
 }
 
 /// `Service` implementation for http transport
-pub struct HttpServiceHandler<T, S: Service, B, X: Service, U: Service> {
+pub struct HttpServiceHandler<T, S, B, X, U>
+where
+    S: Service<Request>,
+    X: Service<Request>,
+    U: Service<(Request, Framed<T, h1::Codec>)>,
+{
     srv: CloneableService<S>,
     expect: CloneableService<X>,
     upgrade: Option<CloneableService<U>>,
     cfg: ServiceConfig,
     on_connect: Option<Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
     on_connect_ext: Option<Rc<ConnectCallback<T>>>,
-    _t: PhantomData<(T, B, X)>,
+    _t: PhantomData<B>,
 }
 
 impl<T, S, B, X, U> HttpServiceHandler<T, S, B, X, U>
 where
-    S: Service<Request = Request>,
+    S: Service<Request>,
     S::Error: Into<Error> + 'static,
     S::Future: 'static,
     S::Response: Into<Response<B>> + 'static,
     B: MessageBody + 'static,
-    X: Service<Request = Request, Response = Request>,
+    X: Service<Request, Response = Request>,
     X::Error: Into<Error>,
-    U: Service<Request = (Request, Framed<T, h1::Codec>), Response = ()>,
+    U: Service<(Request, Framed<T, h1::Codec>), Response = ()>,
     U::Error: fmt::Display,
 {
     fn new(
@@ -501,20 +501,20 @@ where
     }
 }
 
-impl<T, S, B, X, U> Service for HttpServiceHandler<T, S, B, X, U>
+impl<T, S, B, X, U> Service<(T, Protocol, Option<net::SocketAddr>)>
+    for HttpServiceHandler<T, S, B, X, U>
 where
     T: AsyncRead + AsyncWrite + Unpin,
-    S: Service<Request = Request>,
+    S: Service<Request>,
     S::Error: Into<Error> + 'static,
     S::Future: 'static,
     S::Response: Into<Response<B>> + 'static,
     B: MessageBody + 'static,
-    X: Service<Request = Request, Response = Request>,
+    X: Service<Request, Response = Request>,
     X::Error: Into<Error>,
-    U: Service<Request = (Request, Framed<T, h1::Codec>), Response = ()>,
+    U: Service<(Request, Framed<T, h1::Codec>), Response = ()>,
     U::Error: fmt::Display + Into<Error>,
 {
-    type Request = (T, Protocol, Option<net::SocketAddr>);
     type Response = ();
     type Error = DispatchError;
     type Future = HttpServiceHandlerResponse<T, S, B, X, U>;
@@ -561,7 +561,10 @@ where
         }
     }
 
-    fn call(&mut self, (io, proto, peer_addr): Self::Request) -> Self::Future {
+    fn call(
+        &mut self,
+        (io, proto, peer_addr): (T, Protocol, Option<net::SocketAddr>),
+    ) -> Self::Future {
         let mut connect_extensions = Extensions::new();
 
         let deprecated_on_connect = self.on_connect.as_ref().map(|handler| handler(&io));
@@ -600,14 +603,14 @@ where
 #[pin_project(project = StateProj)]
 enum State<T, S, B, X, U>
 where
-    S: Service<Request = Request>,
+    S: Service<Request>,
     S::Future: 'static,
     S::Error: Into<Error>,
     T: AsyncRead + AsyncWrite + Unpin,
     B: MessageBody,
-    X: Service<Request = Request, Response = Request>,
+    X: Service<Request, Response = Request>,
     X::Error: Into<Error>,
-    U: Service<Request = (Request, Framed<T, h1::Codec>), Response = ()>,
+    U: Service<(Request, Framed<T, h1::Codec>), Response = ()>,
     U::Error: fmt::Display,
 {
     H1(#[pin] h1::Dispatcher<T, S, B, X, U>),
@@ -628,14 +631,14 @@ where
 pub struct HttpServiceHandlerResponse<T, S, B, X, U>
 where
     T: AsyncRead + AsyncWrite + Unpin,
-    S: Service<Request = Request>,
+    S: Service<Request>,
     S::Error: Into<Error> + 'static,
     S::Future: 'static,
     S::Response: Into<Response<B>> + 'static,
     B: MessageBody + 'static,
-    X: Service<Request = Request, Response = Request>,
+    X: Service<Request, Response = Request>,
     X::Error: Into<Error>,
-    U: Service<Request = (Request, Framed<T, h1::Codec>), Response = ()>,
+    U: Service<(Request, Framed<T, h1::Codec>), Response = ()>,
     U::Error: fmt::Display,
 {
     #[pin]
@@ -645,14 +648,14 @@ where
 impl<T, S, B, X, U> Future for HttpServiceHandlerResponse<T, S, B, X, U>
 where
     T: AsyncRead + AsyncWrite + Unpin,
-    S: Service<Request = Request>,
+    S: Service<Request>,
     S::Error: Into<Error> + 'static,
     S::Future: 'static,
     S::Response: Into<Response<B>> + 'static,
     B: MessageBody,
-    X: Service<Request = Request, Response = Request>,
+    X: Service<Request, Response = Request>,
     X::Error: Into<Error>,
-    U: Service<Request = (Request, Framed<T, h1::Codec>), Response = ()>,
+    U: Service<(Request, Framed<T, h1::Codec>), Response = ()>,
     U::Error: fmt::Display,
 {
     type Output = Result<(), DispatchError>;
@@ -665,13 +668,13 @@ where
 impl<T, S, B, X, U> State<T, S, B, X, U>
 where
     T: AsyncRead + AsyncWrite + Unpin,
-    S: Service<Request = Request>,
+    S: Service<Request>,
     S::Error: Into<Error> + 'static,
     S::Response: Into<Response<B>> + 'static,
     B: MessageBody + 'static,
-    X: Service<Request = Request, Response = Request>,
+    X: Service<Request, Response = Request>,
     X::Error: Into<Error>,
-    U: Service<Request = (Request, Framed<T, h1::Codec>), Response = ()>,
+    U: Service<(Request, Framed<T, h1::Codec>), Response = ()>,
     U::Error: fmt::Display,
 {
     fn poll(
diff --git a/actix-http/src/ws/dispatcher.rs b/actix-http/src/ws/dispatcher.rs
index b114217a0..7be7cf637 100644
--- a/actix-http/src/ws/dispatcher.rs
+++ b/actix-http/src/ws/dispatcher.rs
@@ -11,7 +11,7 @@ use super::{Codec, Frame, Message};
 #[pin_project::pin_project]
 pub struct Dispatcher<S, T>
 where
-    S: Service<Request = Frame, Response = Message> + 'static,
+    S: Service<Frame, Response = Message> + 'static,
     T: AsyncRead + AsyncWrite,
 {
     #[pin]
@@ -21,17 +21,17 @@ where
 impl<S, T> Dispatcher<S, T>
 where
     T: AsyncRead + AsyncWrite,
-    S: Service<Request = Frame, Response = Message>,
+    S: Service<Frame, Response = Message>,
     S::Future: 'static,
     S::Error: 'static,
 {
-    pub fn new<F: IntoService<S>>(io: T, service: F) -> Self {
+    pub fn new<F: IntoService<S, Frame>>(io: T, service: F) -> Self {
         Dispatcher {
             inner: InnerDispatcher::new(Framed::new(io, Codec::new()), service),
         }
     }
 
-    pub fn with<F: IntoService<S>>(framed: Framed<T, Codec>, service: F) -> Self {
+    pub fn with<F: IntoService<S, Frame>>(framed: Framed<T, Codec>, service: F) -> Self {
         Dispatcher {
             inner: InnerDispatcher::new(framed, service),
         }
@@ -41,7 +41,7 @@ where
 impl<S, T> Future for Dispatcher<S, T>
 where
     T: AsyncRead + AsyncWrite,
-    S: Service<Request = Frame, Response = Message>,
+    S: Service<Frame, Response = Message>,
     S::Future: 'static,
     S::Error: 'static,
 {
diff --git a/actix-http/tests/test_ws.rs b/actix-http/tests/test_ws.rs
index 5d86605f4..e31f2745c 100644
--- a/actix-http/tests/test_ws.rs
+++ b/actix-http/tests/test_ws.rs
@@ -36,11 +36,10 @@ impl<T> Clone for WsService<T> {
     }
 }
 
-impl<T> Service for WsService<T>
+impl<T> Service<(Request, Framed<T, h1::Codec>)> for WsService<T>
 where
     T: AsyncRead + AsyncWrite + Unpin + 'static,
 {
-    type Request = (Request, Framed<T, h1::Codec>);
     type Response = ();
     type Error = Error;
     type Future = Pin<Box<dyn Future<Output = Result<(), Error>>>>;
@@ -50,7 +49,10 @@ where
         Poll::Ready(Ok(()))
     }
 
-    fn call(&mut self, (req, mut framed): Self::Request) -> Self::Future {
+    fn call(
+        &mut self,
+        (req, mut framed): (Request, Framed<T, h1::Codec>),
+    ) -> Self::Future {
         let fut = async move {
             let res = ws::handshake(req.head()).unwrap().message_body(());
 
diff --git a/actix-multipart/Cargo.toml b/actix-multipart/Cargo.toml
index 2bbf5c6e1..dd592f49d 100644
--- a/actix-multipart/Cargo.toml
+++ b/actix-multipart/Cargo.toml
@@ -17,8 +17,8 @@ path = "src/lib.rs"
 
 [dependencies]
 actix-web = { version = "3.0.0", default-features = false }
-actix-service = "1.0.6"
-actix-utils = "2.0.0"
+actix-service = "2.0.0-beta.1"
+actix-utils = "3.0.0-beta.1"
 
 bytes = "1"
 derive_more = "0.99.2"
diff --git a/awc/Cargo.toml b/awc/Cargo.toml
index 7e21a2318..d7b362688 100644
--- a/awc/Cargo.toml
+++ b/awc/Cargo.toml
@@ -37,10 +37,10 @@ rustls = ["rust-tls", "actix-http/rustls"]
 compress = ["actix-http/compress"]
 
 [dependencies]
-actix-codec = "0.3.0"
-actix-service = "1.0.6"
+actix-codec = "0.4.0-beta.1"
+actix-service = "2.0.0-beta.1"
 actix-http = "2.2.0"
-actix-rt = "1.0.0"
+actix-rt = "2.0.0-beta.1"
 
 base64 = "0.13"
 bytes = "1"
@@ -58,13 +58,13 @@ open-ssl = { version = "0.10", package = "openssl", optional = true }
 rust-tls = { version = "0.19.0", package = "rustls", optional = true, features = ["dangerous_configuration"] }
 
 [dev-dependencies]
-actix-connect = { version = "2.0.0", features = ["openssl"] }
+#actix-connect = { version = "2.0.0", features = ["openssl"] }
 actix-web = { version = "3.0.0", features = ["openssl"] }
 actix-http = { version = "2.0.0", features = ["openssl"] }
 actix-http-test = { version = "2.0.0", features = ["openssl"] }
-actix-utils = "2.0.0"
-actix-server = "1.0.0"
-actix-tls = { version = "2.0.0", features = ["openssl", "rustls"] }
+actix-utils = "3.0.0-beta.1"
+actix-server = "2.0.0-beta.1"
+#actix-tls = { version = "3", features = ["openssl", "rustls"] }
 brotli2 = "0.3.2"
 flate2 = "1.0.13"
 futures-util = { version = "0.3.7", default-features = false }
diff --git a/awc/src/builder.rs b/awc/src/builder.rs
index 7cd659c38..6be0112d8 100644
--- a/awc/src/builder.rs
+++ b/awc/src/builder.rs
@@ -51,7 +51,7 @@ impl ClientBuilder {
     /// Use custom connector service.
     pub fn connector<T>(mut self, connector: T) -> Self
     where
-        T: Service<Request = HttpConnect, Error = ConnectError> + 'static,
+        T: Service<HttpConnect, Error = ConnectError> + 'static,
         T::Response: Connection,
         <T::Response as Connection>::Future: 'static,
         T::Future: 'static,
diff --git a/awc/src/connect.rs b/awc/src/connect.rs
index c848b5c4d..8ee239f76 100644
--- a/awc/src/connect.rs
+++ b/awc/src/connect.rs
@@ -70,7 +70,7 @@ pub(crate) trait Connect {
 
 impl<T> Connect for ConnectorWrapper<T>
 where
-    T: Service<Request = ClientConnect, Error = ConnectError>,
+    T: Service<ClientConnect, Error = ConnectError>,
     T::Response: Connection,
     <T::Response as Connection>::Io: 'static,
     <T::Response as Connection>::Future: 'static,
diff --git a/src/app.rs b/src/app.rs
index 8dd86f7ec..d41d692ee 100644
--- a/src/app.rs
+++ b/src/app.rs
@@ -5,10 +5,11 @@ use std::marker::PhantomData;
 use std::rc::Rc;
 
 use actix_http::body::{Body, MessageBody};
-use actix_http::Extensions;
+use actix_http::{Extensions, Request};
 use actix_service::boxed::{self, BoxServiceFactory};
 use actix_service::{
-    apply, apply_fn_factory, IntoServiceFactory, ServiceFactory, Transform,
+    apply, apply_fn_factory, IntoServiceFactory, ServiceFactory, ServiceFactoryExt,
+    Transform,
 };
 use futures_util::future::FutureExt;
 
@@ -63,8 +64,8 @@ impl<T, B> App<T, B>
 where
     B: MessageBody,
     T: ServiceFactory<
+        ServiceRequest,
         Config = (),
-        Request = ServiceRequest,
         Response = ServiceResponse<B>,
         Error = Error,
         InitError = (),
@@ -268,10 +269,10 @@ where
     /// ```
     pub fn default_service<F, U>(mut self, f: F) -> Self
     where
-        F: IntoServiceFactory<U>,
+        F: IntoServiceFactory<U, ServiceRequest>,
         U: ServiceFactory<
+                ServiceRequest,
                 Config = (),
-                Request = ServiceRequest,
                 Response = ServiceResponse,
                 Error = Error,
             > + 'static,
@@ -353,8 +354,8 @@ where
         mw: M,
     ) -> App<
         impl ServiceFactory<
+            ServiceRequest,
             Config = (),
-            Request = ServiceRequest,
             Response = ServiceResponse<B1>,
             Error = Error,
             InitError = (),
@@ -364,7 +365,7 @@ where
     where
         M: Transform<
             T::Service,
-            Request = ServiceRequest,
+            ServiceRequest,
             Response = ServiceResponse<B1>,
             Error = Error,
             InitError = (),
@@ -420,8 +421,8 @@ where
         mw: F,
     ) -> App<
         impl ServiceFactory<
+            ServiceRequest,
             Config = (),
-            Request = ServiceRequest,
             Response = ServiceResponse<B1>,
             Error = Error,
             InitError = (),
@@ -447,12 +448,12 @@ where
     }
 }
 
-impl<T, B> IntoServiceFactory<AppInit<T, B>> for App<T, B>
+impl<T, B> IntoServiceFactory<AppInit<T, B>, Request> for App<T, B>
 where
     B: MessageBody,
     T: ServiceFactory<
+        ServiceRequest,
         Config = (),
-        Request = ServiceRequest,
         Response = ServiceResponse<B>,
         Error = Error,
         InitError = (),
diff --git a/src/app_service.rs b/src/app_service.rs
index e5f8dd9cf..f440ef548 100644
--- a/src/app_service.rs
+++ b/src/app_service.rs
@@ -30,8 +30,8 @@ type BoxResponse = LocalBoxFuture<'static, Result<ServiceResponse, Error>>;
 pub struct AppInit<T, B>
 where
     T: ServiceFactory<
+        ServiceRequest,
         Config = (),
-        Request = ServiceRequest,
         Response = ServiceResponse<B>,
         Error = Error,
         InitError = (),
@@ -47,22 +47,21 @@ where
     pub(crate) external: RefCell<Vec<ResourceDef>>,
 }
 
-impl<T, B> ServiceFactory for AppInit<T, B>
+impl<T, B> ServiceFactory<Request> for AppInit<T, B>
 where
     T: ServiceFactory<
+        ServiceRequest,
         Config = (),
-        Request = ServiceRequest,
         Response = ServiceResponse<B>,
         Error = Error,
         InitError = (),
     >,
 {
-    type Config = AppConfig;
-    type Request = Request;
     type Response = ServiceResponse<B>;
     type Error = T::Error;
-    type InitError = T::InitError;
+    type Config = AppConfig;
     type Service = AppInitService<T::Service, B>;
+    type InitError = T::InitError;
     type Future = AppInitResult<T, B>;
 
     fn new_service(&self, config: AppConfig) -> Self::Future {
@@ -133,7 +132,7 @@ where
 #[pin_project::pin_project]
 pub struct AppInitResult<T, B>
 where
-    T: ServiceFactory,
+    T: ServiceFactory<ServiceRequest>,
 {
     #[pin]
     endpoint_fut: T::Future,
@@ -156,8 +155,8 @@ where
 impl<T, B> Future for AppInitResult<T, B>
 where
     T: ServiceFactory<
+        ServiceRequest,
         Config = (),
-        Request = ServiceRequest,
         Response = ServiceResponse<B>,
         Error = Error,
         InitError = (),
@@ -215,7 +214,7 @@ where
 /// Service to convert `Request` to a `ServiceRequest<S>`
 pub struct AppInitService<T, B>
 where
-    T: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
+    T: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
 {
     service: T,
     rmap: Rc<ResourceMap>,
@@ -224,11 +223,10 @@ where
     pool: &'static HttpRequestPool,
 }
 
-impl<T, B> Service for AppInitService<T, B>
+impl<T, B> Service<Request> for AppInitService<T, B>
 where
-    T: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
+    T: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
 {
-    type Request = Request;
     type Response = ServiceResponse<B>;
     type Error = T::Error;
     type Future = T::Future;
@@ -265,7 +263,7 @@ where
 
 impl<T, B> Drop for AppInitService<T, B>
 where
-    T: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
+    T: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
 {
     fn drop(&mut self) {
         self.pool.clear();
@@ -277,9 +275,8 @@ pub struct AppRoutingFactory {
     default: Rc<HttpNewService>,
 }
 
-impl ServiceFactory for AppRoutingFactory {
+impl ServiceFactory<ServiceRequest> for AppRoutingFactory {
     type Config = ();
-    type Request = ServiceRequest;
     type Response = ServiceResponse;
     type Error = Error;
     type InitError = ();
@@ -388,8 +385,7 @@ pub struct AppRouting {
     default: Option<HttpService>,
 }
 
-impl Service for AppRouting {
-    type Request = ServiceRequest;
+impl Service<ServiceRequest> for AppRouting {
     type Response = ServiceResponse;
     type Error = Error;
     type Future = BoxResponse;
@@ -436,9 +432,8 @@ impl AppEntry {
     }
 }
 
-impl ServiceFactory for AppEntry {
+impl ServiceFactory<ServiceRequest> for AppEntry {
     type Config = ();
-    type Request = ServiceRequest;
     type Response = ServiceResponse;
     type Error = Error;
     type InitError = ();
diff --git a/src/config.rs b/src/config.rs
index 01959daa1..4ec36952a 100644
--- a/src/config.rs
+++ b/src/config.rs
@@ -105,10 +105,10 @@ impl AppService {
         factory: F,
         nested: Option<Rc<ResourceMap>>,
     ) where
-        F: IntoServiceFactory<S>,
+        F: IntoServiceFactory<S, ServiceRequest>,
         S: ServiceFactory<
+                ServiceRequest,
                 Config = (),
-                Request = ServiceRequest,
                 Response = ServiceResponse,
                 Error = Error,
                 InitError = (),
diff --git a/src/handler.rs b/src/handler.rs
index a5f65a8d9..678b9124e 100644
--- a/src/handler.rs
+++ b/src/handler.rs
@@ -82,14 +82,13 @@ where
     }
 }
 
-impl<F, T, R> ServiceFactory for HandlerService<F, T, R>
+impl<F, T, R> ServiceFactory<ServiceRequest> for HandlerService<F, T, R>
 where
     F: Handler<T, R>,
     T: FromRequest,
     R: Future,
     R::Output: Responder,
 {
-    type Request = ServiceRequest;
     type Response = ServiceResponse;
     type Error = Error;
     type Config = ();
@@ -103,14 +102,13 @@ where
 }
 
 // HandlerService is both it's ServiceFactory and Service Type.
-impl<F, T, R> Service for HandlerService<F, T, R>
+impl<F, T, R> Service<ServiceRequest> for HandlerService<F, T, R>
 where
     F: Handler<T, R>,
     T: FromRequest,
     R: Future,
     R::Output: Responder,
 {
-    type Request = ServiceRequest;
     type Response = ServiceResponse;
     type Error = Error;
     type Future = HandlerServiceFuture<F, T, R>;
@@ -119,7 +117,7 @@ where
         Poll::Ready(Ok(()))
     }
 
-    fn call(&mut self, req: Self::Request) -> Self::Future {
+    fn call(&mut self, req: ServiceRequest) -> Self::Future {
         let (req, mut payload) = req.into_parts();
         let fut = T::from_request(&req, &mut payload);
         HandlerServiceFuture::Extract(fut, Some(req), self.hnd.clone())
diff --git a/src/middleware/compress.rs b/src/middleware/compress.rs
index 7575d7455..faff5003a 100644
--- a/src/middleware/compress.rs
+++ b/src/middleware/compress.rs
@@ -51,16 +51,15 @@ impl Default for Compress {
     }
 }
 
-impl<S, B> Transform<S> for Compress
+impl<S, B> Transform<S, ServiceRequest> for Compress
 where
     B: MessageBody,
-    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
+    S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
 {
-    type Request = ServiceRequest;
     type Response = ServiceResponse<Encoder<B>>;
     type Error = Error;
-    type InitError = ();
     type Transform = CompressMiddleware<S>;
+    type InitError = ();
     type Future = Ready<Result<Self::Transform, Self::InitError>>;
 
     fn new_transform(&self, service: S) -> Self::Future {
@@ -76,12 +75,11 @@ pub struct CompressMiddleware<S> {
     encoding: ContentEncoding,
 }
 
-impl<S, B> Service for CompressMiddleware<S>
+impl<S, B> Service<ServiceRequest> for CompressMiddleware<S>
 where
     B: MessageBody,
-    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
+    S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
 {
-    type Request = ServiceRequest;
     type Response = ServiceResponse<Encoder<B>>;
     type Error = Error;
     type Future = CompressResponse<S, B>;
@@ -115,7 +113,7 @@ where
 #[pin_project]
 pub struct CompressResponse<S, B>
 where
-    S: Service,
+    S: Service<ServiceRequest>,
     B: MessageBody,
 {
     #[pin]
@@ -127,7 +125,7 @@ where
 impl<S, B> Future for CompressResponse<S, B>
 where
     B: MessageBody,
-    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
+    S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
 {
     type Output = Result<ServiceResponse<Encoder<B>>, Error>;
 
diff --git a/src/middleware/condition.rs b/src/middleware/condition.rs
index 9061c7458..87323e325 100644
--- a/src/middleware/condition.rs
+++ b/src/middleware/condition.rs
@@ -31,19 +31,18 @@ impl<T> Condition<T> {
     }
 }
 
-impl<S, T> Transform<S> for Condition<T>
+impl<S, T, Req> Transform<S, Req> for Condition<T>
 where
-    S: Service + 'static,
-    T: Transform<S, Request = S::Request, Response = S::Response, Error = S::Error>,
+    S: Service<Req> + 'static,
+    T: Transform<S, Req, Response = S::Response, Error = S::Error>,
     T::Future: 'static,
     T::InitError: 'static,
     T::Transform: 'static,
 {
-    type Request = S::Request;
     type Response = S::Response;
     type Error = S::Error;
-    type InitError = T::InitError;
     type Transform = ConditionMiddleware<T::Transform, S>;
+    type InitError = T::InitError;
     type Future = LocalBoxFuture<'static, Result<Self::Transform, Self::InitError>>;
 
     fn new_transform(&self, service: S) -> Self::Future {
@@ -66,12 +65,11 @@ pub enum ConditionMiddleware<E, D> {
     Disable(D),
 }
 
-impl<E, D> Service for ConditionMiddleware<E, D>
+impl<E, D, Req> Service<Req> for ConditionMiddleware<E, D>
 where
-    E: Service,
-    D: Service<Request = E::Request, Response = E::Response, Error = E::Error>,
+    E: Service<Req>,
+    D: Service<Req, Response = E::Response, Error = E::Error>,
 {
-    type Request = E::Request;
     type Response = E::Response;
     type Error = E::Error;
     type Future = Either<E::Future, D::Future>;
@@ -84,7 +82,7 @@ where
         }
     }
 
-    fn call(&mut self, req: E::Request) -> Self::Future {
+    fn call(&mut self, req: Req) -> Self::Future {
         use ConditionMiddleware::*;
         match self {
             Enable(service) => Either::Left(service.call(req)),
diff --git a/src/middleware/defaultheaders.rs b/src/middleware/defaultheaders.rs
index a6f1a4336..d648ad70f 100644
--- a/src/middleware/defaultheaders.rs
+++ b/src/middleware/defaultheaders.rs
@@ -93,12 +93,11 @@ impl DefaultHeaders {
     }
 }
 
-impl<S, B> Transform<S> for DefaultHeaders
+impl<S, B> Transform<S, ServiceRequest> for DefaultHeaders
 where
-    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
+    S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
     S::Future: 'static,
 {
-    type Request = ServiceRequest;
     type Response = ServiceResponse<B>;
     type Error = Error;
     type Transform = DefaultHeadersMiddleware<S>;
@@ -118,12 +117,11 @@ pub struct DefaultHeadersMiddleware<S> {
     inner: Rc<Inner>,
 }
 
-impl<S, B> Service for DefaultHeadersMiddleware<S>
+impl<S, B> Service<ServiceRequest> for DefaultHeadersMiddleware<S>
 where
-    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
+    S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
     S::Future: 'static,
 {
-    type Request = ServiceRequest;
     type Response = ServiceResponse<B>;
     type Error = Error;
     type Future = DefaultHeaderFuture<S, B>;
@@ -145,7 +143,7 @@ where
 }
 
 #[pin_project::pin_project]
-pub struct DefaultHeaderFuture<S: Service, B> {
+pub struct DefaultHeaderFuture<S: Service<ServiceRequest>, B> {
     #[pin]
     fut: S::Future,
     inner: Rc<Inner>,
@@ -154,7 +152,7 @@ pub struct DefaultHeaderFuture<S: Service, B> {
 
 impl<S, B> Future for DefaultHeaderFuture<S, B>
 where
-    S: Service<Response = ServiceResponse<B>, Error = Error>,
+    S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
 {
     type Output = <S::Future as Future>::Output;
 
diff --git a/src/middleware/errhandlers.rs b/src/middleware/errhandlers.rs
index c0cb9594e..9366a33bf 100644
--- a/src/middleware/errhandlers.rs
+++ b/src/middleware/errhandlers.rs
@@ -81,17 +81,16 @@ impl<B> ErrorHandlers<B> {
     }
 }
 
-impl<S, B> Transform<S> for ErrorHandlers<B>
+impl<S, B> Transform<S, ServiceRequest> for ErrorHandlers<B>
 where
-    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
+    S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
     S::Future: 'static,
     B: 'static,
 {
-    type Request = ServiceRequest;
     type Response = ServiceResponse<B>;
     type Error = Error;
-    type InitError = ();
     type Transform = ErrorHandlersMiddleware<S, B>;
+    type InitError = ();
     type Future = Ready<Result<Self::Transform, Self::InitError>>;
 
     fn new_transform(&self, service: S) -> Self::Future {
@@ -108,13 +107,12 @@ pub struct ErrorHandlersMiddleware<S, B> {
     handlers: Rc<FxHashMap<StatusCode, Box<ErrorHandler<B>>>>,
 }
 
-impl<S, B> Service for ErrorHandlersMiddleware<S, B>
+impl<S, B> Service<ServiceRequest> for ErrorHandlersMiddleware<S, B>
 where
-    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
+    S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
     S::Future: 'static,
     B: 'static,
 {
-    type Request = ServiceRequest;
     type Response = ServiceResponse<B>;
     type Error = Error;
     type Future = LocalBoxFuture<'static, Result<Self::Response, Self::Error>>;
diff --git a/src/middleware/logger.rs b/src/middleware/logger.rs
index 563cb6c32..2a543f66f 100644
--- a/src/middleware/logger.rs
+++ b/src/middleware/logger.rs
@@ -179,12 +179,11 @@ impl Default for Logger {
     }
 }
 
-impl<S, B> Transform<S> for Logger
+impl<S, B> Transform<S, ServiceRequest> for Logger
 where
-    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
+    S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
     B: MessageBody,
 {
-    type Request = ServiceRequest;
     type Response = ServiceResponse<StreamLog<B>>;
     type Error = Error;
     type InitError = ();
@@ -216,12 +215,11 @@ pub struct LoggerMiddleware<S> {
     service: S,
 }
 
-impl<S, B> Service for LoggerMiddleware<S>
+impl<S, B> Service<ServiceRequest> for LoggerMiddleware<S>
 where
-    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
+    S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
     B: MessageBody,
 {
-    type Request = ServiceRequest;
     type Response = ServiceResponse<StreamLog<B>>;
     type Error = Error;
     type Future = LoggerResponse<S, B>;
@@ -262,19 +260,19 @@ where
 pub struct LoggerResponse<S, B>
 where
     B: MessageBody,
-    S: Service,
+    S: Service<ServiceRequest>,
 {
     #[pin]
     fut: S::Future,
     time: OffsetDateTime,
     format: Option<Format>,
-    _t: PhantomData<(B,)>,
+    _t: PhantomData<B>,
 }
 
 impl<S, B> Future for LoggerResponse<S, B>
 where
     B: MessageBody,
-    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
+    S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
 {
     type Output = Result<ServiceResponse<StreamLog<B>>, Error>;
 
diff --git a/src/middleware/normalize.rs b/src/middleware/normalize.rs
index ad9f51079..4109364bf 100644
--- a/src/middleware/normalize.rs
+++ b/src/middleware/normalize.rs
@@ -91,16 +91,15 @@ impl NormalizePath {
     }
 }
 
-impl<S, B> Transform<S> for NormalizePath
+impl<S, B> Transform<S, ServiceRequest> for NormalizePath
 where
-    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
+    S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
     S::Future: 'static,
 {
-    type Request = ServiceRequest;
     type Response = ServiceResponse<B>;
     type Error = Error;
-    type InitError = ();
     type Transform = NormalizePathNormalization<S>;
+    type InitError = ();
     type Future = Ready<Result<Self::Transform, Self::InitError>>;
 
     fn new_transform(&self, service: S) -> Self::Future {
@@ -119,12 +118,11 @@ pub struct NormalizePathNormalization<S> {
     trailing_slash_behavior: TrailingSlash,
 }
 
-impl<S, B> Service for NormalizePathNormalization<S>
+impl<S, B> Service<ServiceRequest> for NormalizePathNormalization<S>
 where
-    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
+    S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
     S::Future: 'static,
 {
-    type Request = ServiceRequest;
     type Response = ServiceResponse<B>;
     type Error = Error;
     type Future = S::Future;
diff --git a/src/resource.rs b/src/resource.rs
index 24313e857..60e9521ab 100644
--- a/src/resource.rs
+++ b/src/resource.rs
@@ -9,7 +9,8 @@ use actix_http::{Error, Extensions, Response};
 use actix_router::IntoPattern;
 use actix_service::boxed::{self, BoxService, BoxServiceFactory};
 use actix_service::{
-    apply, apply_fn_factory, IntoServiceFactory, Service, ServiceFactory, Transform,
+    apply, apply_fn_factory, IntoServiceFactory, Service, ServiceFactory,
+    ServiceFactoryExt, Transform,
 };
 use futures_util::future::{ok, Either, LocalBoxFuture, Ready};
 
@@ -78,8 +79,8 @@ impl Resource {
 impl<T> Resource<T>
 where
     T: ServiceFactory<
+        ServiceRequest,
         Config = (),
-        Request = ServiceRequest,
         Response = ServiceResponse,
         Error = Error,
         InitError = (),
@@ -250,8 +251,8 @@ where
         mw: M,
     ) -> Resource<
         impl ServiceFactory<
+            ServiceRequest,
             Config = (),
-            Request = ServiceRequest,
             Response = ServiceResponse,
             Error = Error,
             InitError = (),
@@ -260,7 +261,7 @@ where
     where
         M: Transform<
             T::Service,
-            Request = ServiceRequest,
+            ServiceRequest,
             Response = ServiceResponse,
             Error = Error,
             InitError = (),
@@ -317,8 +318,8 @@ where
         mw: F,
     ) -> Resource<
         impl ServiceFactory<
+            ServiceRequest,
             Config = (),
-            Request = ServiceRequest,
             Response = ServiceResponse,
             Error = Error,
             InitError = (),
@@ -345,10 +346,10 @@ where
     /// default handler from `App` or `Scope`.
     pub fn default_service<F, U>(mut self, f: F) -> Self
     where
-        F: IntoServiceFactory<U>,
+        F: IntoServiceFactory<U, ServiceRequest>,
         U: ServiceFactory<
+                ServiceRequest,
                 Config = (),
-                Request = ServiceRequest,
                 Response = ServiceResponse,
                 Error = Error,
             > + 'static,
@@ -368,8 +369,8 @@ where
 impl<T> HttpServiceFactory for Resource<T>
 where
     T: ServiceFactory<
+            ServiceRequest,
             Config = (),
-            Request = ServiceRequest,
             Response = ServiceResponse,
             Error = Error,
             InitError = (),
@@ -398,11 +399,11 @@ where
     }
 }
 
-impl<T> IntoServiceFactory<T> for Resource<T>
+impl<T> IntoServiceFactory<T, ServiceRequest> for Resource<T>
 where
     T: ServiceFactory<
+        ServiceRequest,
         Config = (),
-        Request = ServiceRequest,
         Response = ServiceResponse,
         Error = Error,
         InitError = (),
@@ -425,13 +426,12 @@ pub struct ResourceFactory {
     default: Rc<RefCell<Option<Rc<HttpNewService>>>>,
 }
 
-impl ServiceFactory for ResourceFactory {
-    type Config = ();
-    type Request = ServiceRequest;
+impl ServiceFactory<ServiceRequest> for ResourceFactory {
     type Response = ServiceResponse;
     type Error = Error;
-    type InitError = ();
+    type Config = ();
     type Service = ResourceService;
+    type InitError = ();
     type Future = CreateResourceService;
 
     fn new_service(&self, _: ()) -> Self::Future {
@@ -520,8 +520,7 @@ pub struct ResourceService {
     default: Option<HttpService>,
 }
 
-impl Service for ResourceService {
-    type Request = ServiceRequest;
+impl Service<ServiceRequest> for ResourceService {
     type Response = ServiceResponse;
     type Error = Error;
     type Future = Either<
@@ -568,9 +567,8 @@ impl ResourceEndpoint {
     }
 }
 
-impl ServiceFactory for ResourceEndpoint {
+impl ServiceFactory<ServiceRequest> for ResourceEndpoint {
     type Config = ();
-    type Request = ServiceRequest;
     type Response = ServiceResponse;
     type Error = Error;
     type InitError = ();
diff --git a/src/route.rs b/src/route.rs
index 544612698..8a3d1da9f 100644
--- a/src/route.rs
+++ b/src/route.rs
@@ -18,7 +18,7 @@ use crate::HttpResponse;
 
 type BoxedRouteService = Box<
     dyn Service<
-        Request = ServiceRequest,
+        ServiceRequest,
         Response = ServiceResponse,
         Error = Error,
         Future = LocalBoxFuture<'static, Result<ServiceResponse, Error>>,
@@ -27,8 +27,8 @@ type BoxedRouteService = Box<
 
 type BoxedRouteNewService = Box<
     dyn ServiceFactory<
+        ServiceRequest,
         Config = (),
-        Request = ServiceRequest,
         Response = ServiceResponse,
         Error = Error,
         InitError = (),
@@ -63,9 +63,8 @@ impl Route {
     }
 }
 
-impl ServiceFactory for Route {
+impl ServiceFactory<ServiceRequest> for Route {
     type Config = ();
-    type Request = ServiceRequest;
     type Response = ServiceResponse;
     type Error = Error;
     type InitError = ();
@@ -117,8 +116,7 @@ impl RouteService {
     }
 }
 
-impl Service for RouteService {
-    type Request = ServiceRequest;
+impl Service<ServiceRequest> for RouteService {
     type Response = ServiceResponse;
     type Error = Error;
     type Future = LocalBoxFuture<'static, Result<Self::Response, Self::Error>>;
@@ -233,7 +231,7 @@ impl Route {
 
 struct RouteNewService<T>
 where
-    T: ServiceFactory<Request = ServiceRequest, Error = Error>,
+    T: ServiceFactory<ServiceRequest, Error = Error>,
 {
     service: T,
 }
@@ -241,33 +239,32 @@ where
 impl<T> RouteNewService<T>
 where
     T: ServiceFactory<
+        ServiceRequest,
         Config = (),
-        Request = ServiceRequest,
         Response = ServiceResponse,
         Error = Error,
     >,
     T::Future: 'static,
     T::Service: 'static,
-    <T::Service as Service>::Future: 'static,
+    <T::Service as Service<ServiceRequest>>::Future: 'static,
 {
     pub fn new(service: T) -> Self {
         RouteNewService { service }
     }
 }
 
-impl<T> ServiceFactory for RouteNewService<T>
+impl<T> ServiceFactory<ServiceRequest> for RouteNewService<T>
 where
     T: ServiceFactory<
+        ServiceRequest,
         Config = (),
-        Request = ServiceRequest,
         Response = ServiceResponse,
         Error = Error,
     >,
     T::Future: 'static,
     T::Service: 'static,
-    <T::Service as Service>::Future: 'static,
+    <T::Service as Service<ServiceRequest>>::Future: 'static,
 {
-    type Request = ServiceRequest;
     type Response = ServiceResponse;
     type Error = Error;
     type Config = ();
@@ -289,16 +286,15 @@ where
     }
 }
 
-struct RouteServiceWrapper<T: Service> {
+struct RouteServiceWrapper<T: Service<ServiceRequest>> {
     service: T,
 }
 
-impl<T> Service for RouteServiceWrapper<T>
+impl<T> Service<ServiceRequest> for RouteServiceWrapper<T>
 where
     T::Future: 'static,
-    T: Service<Request = ServiceRequest, Response = ServiceResponse, Error = Error>,
+    T: Service<ServiceRequest, Response = ServiceResponse, Error = Error>,
 {
-    type Request = ServiceRequest;
     type Response = ServiceResponse;
     type Error = Error;
     type Future = LocalBoxFuture<'static, Result<Self::Response, Self::Error>>;
diff --git a/src/scope.rs b/src/scope.rs
index 681d142be..86bc751db 100644
--- a/src/scope.rs
+++ b/src/scope.rs
@@ -9,7 +9,8 @@ use actix_http::{Extensions, Response};
 use actix_router::{ResourceDef, ResourceInfo, Router};
 use actix_service::boxed::{self, BoxService, BoxServiceFactory};
 use actix_service::{
-    apply, apply_fn_factory, IntoServiceFactory, Service, ServiceFactory, Transform,
+    apply, apply_fn_factory, IntoServiceFactory, Service, ServiceFactory,
+    ServiceFactoryExt, Transform,
 };
 use futures_util::future::{ok, Either, LocalBoxFuture, Ready};
 
@@ -89,8 +90,8 @@ impl Scope {
 impl<T> Scope<T>
 where
     T: ServiceFactory<
+        ServiceRequest,
         Config = (),
-        Request = ServiceRequest,
         Response = ServiceResponse,
         Error = Error,
         InitError = (),
@@ -285,10 +286,10 @@ where
     /// If default resource is not registered, app's default resource is being used.
     pub fn default_service<F, U>(mut self, f: F) -> Self
     where
-        F: IntoServiceFactory<U>,
+        F: IntoServiceFactory<U, ServiceRequest>,
         U: ServiceFactory<
+                ServiceRequest,
                 Config = (),
-                Request = ServiceRequest,
                 Response = ServiceResponse,
                 Error = Error,
             > + 'static,
@@ -318,8 +319,8 @@ where
         mw: M,
     ) -> Scope<
         impl ServiceFactory<
+            ServiceRequest,
             Config = (),
-            Request = ServiceRequest,
             Response = ServiceResponse,
             Error = Error,
             InitError = (),
@@ -328,7 +329,7 @@ where
     where
         M: Transform<
             T::Service,
-            Request = ServiceRequest,
+            ServiceRequest,
             Response = ServiceResponse,
             Error = Error,
             InitError = (),
@@ -383,8 +384,8 @@ where
         mw: F,
     ) -> Scope<
         impl ServiceFactory<
+            ServiceRequest,
             Config = (),
-            Request = ServiceRequest,
             Response = ServiceResponse,
             Error = Error,
             InitError = (),
@@ -410,8 +411,8 @@ where
 impl<T> HttpServiceFactory for Scope<T>
 where
     T: ServiceFactory<
+            ServiceRequest,
             Config = (),
-            Request = ServiceRequest,
             Response = ServiceResponse,
             Error = Error,
             InitError = (),
@@ -481,9 +482,8 @@ pub struct ScopeFactory {
     default: Rc<RefCell<Option<Rc<HttpNewService>>>>,
 }
 
-impl ServiceFactory for ScopeFactory {
+impl ServiceFactory<ServiceRequest> for ScopeFactory {
     type Config = ();
-    type Request = ServiceRequest;
     type Response = ServiceResponse;
     type Error = Error;
     type InitError = ();
@@ -602,8 +602,7 @@ pub struct ScopeService {
     _ready: Option<(ServiceRequest, ResourceInfo)>,
 }
 
-impl Service for ScopeService {
-    type Request = ServiceRequest;
+impl Service<ServiceRequest> for ScopeService {
     type Response = ServiceResponse;
     type Error = Error;
     type Future = Either<BoxedResponse, Ready<Result<Self::Response, Self::Error>>>;
@@ -652,13 +651,12 @@ impl ScopeEndpoint {
     }
 }
 
-impl ServiceFactory for ScopeEndpoint {
-    type Config = ();
-    type Request = ServiceRequest;
+impl ServiceFactory<ServiceRequest> for ScopeEndpoint {
     type Response = ServiceResponse;
     type Error = Error;
-    type InitError = ();
+    type Config = ();
     type Service = ScopeService;
+    type InitError = ();
     type Future = ScopeFactoryResponse;
 
     fn new_service(&self, _: ()) -> Self::Future {
diff --git a/src/server.rs b/src/server.rs
index 992e64f9a..688e71930 100644
--- a/src/server.rs
+++ b/src/server.rs
@@ -20,9 +20,9 @@ use actix_service::pipeline_factory;
 use futures_util::future::ok;
 
 #[cfg(feature = "openssl")]
-use actix_tls::openssl::{AlpnError, SslAcceptor, SslAcceptorBuilder};
+use actix_tls::accept::openssl::{AlpnError, SslAcceptor, SslAcceptorBuilder};
 #[cfg(feature = "rustls")]
-use actix_tls::rustls::ServerConfig as RustlsServerConfig;
+use actix_tls::accept::rustls::ServerConfig as RustlsServerConfig;
 
 use crate::config::AppConfig;
 
@@ -58,8 +58,8 @@ struct Config {
 pub struct HttpServer<F, I, S, B>
 where
     F: Fn() -> I + Send + Clone + 'static,
-    I: IntoServiceFactory<S>,
-    S: ServiceFactory<Config = AppConfig, Request = Request>,
+    I: IntoServiceFactory<S, Request>,
+    S: ServiceFactory<Request, Config = AppConfig>,
     S::Error: Into<Error>,
     S::InitError: fmt::Debug,
     S::Response: Into<Response<B>>,
@@ -77,12 +77,13 @@ where
 impl<F, I, S, B> HttpServer<F, I, S, B>
 where
     F: Fn() -> I + Send + Clone + 'static,
-    I: IntoServiceFactory<S>,
-    S: ServiceFactory<Config = AppConfig, Request = Request>,
+    I: IntoServiceFactory<S, Request>,
+    S: ServiceFactory<Request, Config = AppConfig> + 'static,
     S::Error: Into<Error> + 'static,
     S::InitError: fmt::Debug,
     S::Response: Into<Response<B>> + 'static,
-    <S::Service as Service>::Future: 'static,
+    <S::Service as Service<Request>>::Future: 'static,
+    S::Service: 'static,
     B: MessageBody + 'static,
 {
     /// Create new http server with application factory
@@ -171,7 +172,7 @@ where
     ///
     /// By default max connections is set to a 256.
     pub fn max_connection_rate(self, num: usize) -> Self {
-        actix_tls::max_concurrent_tls_connect(num);
+        actix_tls::accept::max_concurrent_tls_connect(num);
         self
     }
 
@@ -603,8 +604,8 @@ where
 impl<F, I, S, B> HttpServer<F, I, S, B>
 where
     F: Fn() -> I + Send + Clone + 'static,
-    I: IntoServiceFactory<S>,
-    S: ServiceFactory<Config = AppConfig, Request = Request>,
+    I: IntoServiceFactory<S, Request>,
+    S: ServiceFactory<Request, Config = AppConfig>,
     S::Error: Into<Error>,
     S::InitError: fmt::Debug,
     S::Response: Into<Response<B>>,
diff --git a/src/service.rs b/src/service.rs
index 189ba5554..85bc6123d 100644
--- a/src/service.rs
+++ b/src/service.rs
@@ -486,10 +486,10 @@ impl WebService {
     /// Set a service factory implementation and generate web service.
     pub fn finish<T, F>(self, service: F) -> impl HttpServiceFactory
     where
-        F: IntoServiceFactory<T>,
+        F: IntoServiceFactory<T, ServiceRequest>,
         T: ServiceFactory<
+                ServiceRequest,
                 Config = (),
-                Request = ServiceRequest,
                 Response = ServiceResponse,
                 Error = Error,
                 InitError = (),
@@ -514,8 +514,8 @@ struct WebServiceImpl<T> {
 impl<T> HttpServiceFactory for WebServiceImpl<T>
 where
     T: ServiceFactory<
+            ServiceRequest,
             Config = (),
-            Request = ServiceRequest,
             Response = ServiceResponse,
             Error = Error,
             InitError = (),
diff --git a/src/test.rs b/src/test.rs
index 0744984b2..b53627623 100644
--- a/src/test.rs
+++ b/src/test.rs
@@ -37,16 +37,14 @@ use crate::{Error, HttpRequest, HttpResponse};
 
 /// Create service that always responds with `HttpResponse::Ok()`
 pub fn ok_service(
-) -> impl Service<Request = ServiceRequest, Response = ServiceResponse<Body>, Error = Error>
-{
+) -> impl Service<ServiceRequest, Response = ServiceResponse<Body>, Error = Error> {
     default_service(StatusCode::OK)
 }
 
 /// Create service that responds with response with specified status code
 pub fn default_service(
     status_code: StatusCode,
-) -> impl Service<Request = ServiceRequest, Response = ServiceResponse<Body>, Error = Error>
-{
+) -> impl Service<ServiceRequest, Response = ServiceResponse<Body>, Error = Error> {
     (move |req: ServiceRequest| {
         ok(req.into_response(HttpResponse::build(status_code).finish()))
     })
@@ -77,12 +75,12 @@ pub fn default_service(
 /// ```
 pub async fn init_service<R, S, B, E>(
     app: R,
-) -> impl Service<Request = Request, Response = ServiceResponse<B>, Error = E>
+) -> impl Service<Request, Response = ServiceResponse<B>, Error = E>
 where
-    R: IntoServiceFactory<S>,
+    R: IntoServiceFactory<S, Request>,
     S: ServiceFactory<
+        Request,
         Config = AppConfig,
-        Request = Request,
         Response = ServiceResponse<B>,
         Error = E,
     >,
@@ -96,15 +94,12 @@ where
 /// Fallible version of init_service that allows testing data factory errors.
 pub(crate) async fn try_init_service<R, S, B, E>(
     app: R,
-) -> Result<
-    impl Service<Request = Request, Response = ServiceResponse<B>, Error = E>,
-    S::InitError,
->
+) -> Result<impl Service<Request, Response = ServiceResponse<B>, Error = E>, S::InitError>
 where
-    R: IntoServiceFactory<S>,
+    R: IntoServiceFactory<S, Request>,
     S: ServiceFactory<
+        Request,
         Config = AppConfig,
-        Request = Request,
         Response = ServiceResponse<B>,
         Error = E,
     >,
@@ -138,7 +133,7 @@ where
 /// ```
 pub async fn call_service<S, R, B, E>(app: &mut S, req: R) -> S::Response
 where
-    S: Service<Request = R, Response = ServiceResponse<B>, Error = E>,
+    S: Service<R, Response = ServiceResponse<B>, Error = E>,
     E: std::fmt::Debug,
 {
     app.call(req).await.unwrap()
@@ -171,7 +166,7 @@ where
 /// ```
 pub async fn read_response<S, B>(app: &mut S, req: Request) -> Bytes
 where
-    S: Service<Request = Request, Response = ServiceResponse<B>, Error = Error>,
+    S: Service<Request, Response = ServiceResponse<B>, Error = Error>,
     B: MessageBody + Unpin,
 {
     let mut resp = app
@@ -321,7 +316,7 @@ where
 /// ```
 pub async fn read_response_json<S, B, T>(app: &mut S, req: Request) -> T
 where
-    S: Service<Request = Request, Response = ServiceResponse<B>, Error = Error>,
+    S: Service<Request, Response = ServiceResponse<B>, Error = Error>,
     B: MessageBody + Unpin,
     T: DeserializeOwned,
 {
@@ -602,7 +597,7 @@ impl TestRequest {
     /// Complete request creation, calls service and waits for response future completion.
     pub async fn send_request<S, B, E>(self, app: &mut S) -> S::Response
     where
-        S: Service<Request = Request, Response = ServiceResponse<B>, Error = E>,
+        S: Service<Request, Response = ServiceResponse<B>, Error = E>,
         E: std::fmt::Debug,
     {
         let req = self.to_request();
@@ -639,12 +634,12 @@ impl TestRequest {
 pub fn start<F, I, S, B>(factory: F) -> TestServer
 where
     F: Fn() -> I + Send + Clone + 'static,
-    I: IntoServiceFactory<S>,
-    S: ServiceFactory<Config = AppConfig, Request = Request> + 'static,
+    I: IntoServiceFactory<S, Request>,
+    S: ServiceFactory<Request, Config = AppConfig> + 'static,
     S::Error: Into<Error> + 'static,
     S::InitError: fmt::Debug,
     S::Response: Into<HttpResponse<B>> + 'static,
-    <S::Service as Service>::Future: 'static,
+    <S::Service as Service<Request>>::Future: 'static,
     B: MessageBody + 'static,
 {
     start_with(TestServerConfig::default(), factory)
@@ -678,12 +673,12 @@ where
 pub fn start_with<F, I, S, B>(cfg: TestServerConfig, factory: F) -> TestServer
 where
     F: Fn() -> I + Send + Clone + 'static,
-    I: IntoServiceFactory<S>,
-    S: ServiceFactory<Config = AppConfig, Request = Request> + 'static,
+    I: IntoServiceFactory<S, Request>,
+    S: ServiceFactory<Request, Config = AppConfig> + 'static,
     S::Error: Into<Error> + 'static,
     S::InitError: fmt::Debug,
     S::Response: Into<HttpResponse<B>> + 'static,
-    <S::Service as Service>::Future: 'static,
+    <S::Service as Service<Request>>::Future: 'static,
     B: MessageBody + 'static,
 {
     let (tx, rx) = mpsc::channel();
@@ -788,8 +783,9 @@ where
                 }),
             },
         }
-        .unwrap()
-        .start();
+        .unwrap();
+
+        let srv = sys.block_on(async { srv.start() });
 
         tx.send((System::current(), srv, local_addr)).unwrap();
         sys.run()
diff --git a/src/web.rs b/src/web.rs
index 85e5f2e7b..39dfc450a 100644
--- a/src/web.rs
+++ b/src/web.rs
@@ -5,7 +5,6 @@ use std::future::Future;
 
 pub use actix_http::Response as HttpResponse;
 pub use bytes::{Buf, BufMut, Bytes, BytesMut};
-pub use futures_channel::oneshot::Canceled;
 
 use crate::error::BlockingError;
 use crate::extract::FromRequest;
diff --git a/tests/test_httpserver.rs b/tests/test_httpserver.rs
index 118640aca..54510b7d4 100644
--- a/tests/test_httpserver.rs
+++ b/tests/test_httpserver.rs
@@ -15,24 +15,27 @@ async fn test_start() {
     thread::spawn(move || {
         let sys = actix_rt::System::new("test");
 
-        let srv = HttpServer::new(|| {
-            App::new().service(
-                web::resource("/").route(web::to(|| HttpResponse::Ok().body("test"))),
-            )
-        })
-        .workers(1)
-        .backlog(1)
-        .max_connections(10)
-        .max_connection_rate(10)
-        .keep_alive(10)
-        .client_timeout(5000)
-        .client_shutdown(0)
-        .server_hostname("localhost")
-        .system_exit()
-        .disable_signals()
-        .bind(format!("{}", addr))
-        .unwrap()
-        .run();
+        let srv = sys.block_on(async {
+            HttpServer::new(|| {
+                App::new().service(
+                    web::resource("/")
+                        .route(web::to(|| HttpResponse::Ok().body("test"))),
+                )
+            })
+            .workers(1)
+            .backlog(1)
+            .max_connections(10)
+            .max_connection_rate(10)
+            .keep_alive(10)
+            .client_timeout(5000)
+            .client_shutdown(0)
+            .server_hostname("localhost")
+            .system_exit()
+            .disable_signals()
+            .bind(format!("{}", addr))
+            .unwrap()
+            .run()
+        });
 
         let _ = tx.send((srv, actix_rt::System::current()));
         let _ = sys.run();