同步操作将从 bison-fork/actix-web 强制同步,此操作会覆盖自 Fork 仓库以来所做的任何修改,且无法恢复!!!
确定后同步将在后台操作,完成时将刷新页面,请耐心等待。
The return type for ServiceRequest::app_data::<T>()
was changed from returning a Data<T>
to
simply a T
. To access a Data<T>
use ServiceRequest::app_data::<Data<T>>()
.
Cookie handling has been offloaded to the cookie
crate:
USERINFO_ENCODE_SET
is no longer exposed. Percent-encoding is still supported; check docs.The time crate was updated to v0.2
, a major breaking change to the time crate, which affects
any actix-web
method previously expecting a time v0.1 input.
Setting a cookie's SameSite property, explicitly, to SameSite::None
will now
result in SameSite=None
being sent with the response Set-Cookie header.
To create a cookie without a SameSite attribute, remove any calls setting same_site.
actix-http support for Actors messages was moved to actix-http crate and is enabled
with feature actors
content_length function is removed from actix-http. You can set Content-Length by normally setting the response body or calling no_chunking function.
BodySize::Sized64
variant has been removed. BodySize::Sized
now receives a
u64
instead of a usize
.
Code that was using path.<index>
to access a web::Path<(A, B, C)>
s elements now needs to use
destructuring or .into_inner()
. For example:
// Previously:
async fn some_route(path: web::Path<(String, String)>) -> String {
format!("Hello, {} {}", path.0, path.1)
}
// Now (this also worked before):
async fn some_route(path: web::Path<(String, String)>) -> String {
let (first_name, last_name) = path.into_inner();
format!("Hello, {} {}", first_name, last_name)
}
// Or (this wasn't previously supported):
async fn some_route(web::Path((first_name, last_name)): web::Path<(String, String)>) -> String {
format!("Hello, {} {}", first_name, last_name)
}
middleware::NormalizePath
can now also be configured to trim trailing slashes instead of always keeping one.
It will need middleware::normalize::TrailingSlash
when being constructed with NormalizePath::new(...)
,
or for an easier migration you can replace wrap(middleware::NormalizePath)
with wrap(middleware::NormalizePath::new(TrailingSlash::MergeOnly))
.
HttpServer::maxconn
is renamed to the more expressive HttpServer::max_connections
.
HttpServer::maxconnrate
is renamed to the more expressive HttpServer::max_connection_rate
.
HttpServer::start()
renamed to HttpServer::run()
. It also possible to
.await
on run
method result, in that case it awaits server exit.
App::register_data()
renamed to App::app_data()
and accepts any type T: 'static
.
Stored data is available via HttpRequest::app_data()
method at runtime.
Extractor configuration must be registered with App::app_data()
instead of App::data()
Sync handlers has been removed. .to_async()
method has been renamed to .to()
replace fn
with async fn
to convert sync handler to async
actix_http_test::TestServer
moved to actix_web::test
module. To start
test server use test::start()
or test_start_with_config()
methods
ResponseError
trait has been reafctored. ResponseError::error_response()
renders
http response.
Feature rust-tls
renamed to rustls
instead of
actix-web = { version = "2.0.0", features = ["rust-tls"] }
use
actix-web = { version = "2.0.0", features = ["rustls"] }
Feature ssl
renamed to openssl
instead of
actix-web = { version = "2.0.0", features = ["ssl"] }
use
actix-web = { version = "2.0.0", features = ["openssl"] }
Cors
builder now requires that you call .finish()
to construct the middleware
Cors middleware has been moved to actix-cors
crate
instead of
use actix_web::middleware::cors::Cors;
use
use actix_cors::Cors;
Identity middleware has been moved to actix-identity
crate
instead of
use actix_web::middleware::identity::{Identity, CookieIdentityPolicy, IdentityService};
use
use actix_identity::{Identity, CookieIdentityPolicy, IdentityService};
Extractor configuration. In version 1.0 this is handled with the new Data
mechanism for both setting and retrieving the configuration
instead of
#[derive(Default)]
struct ExtractorConfig {
config: String,
}
impl FromRequest for YourExtractor {
type Config = ExtractorConfig;
type Result = Result<YourExtractor, Error>;
fn from_request(req: &HttpRequest, cfg: &Self::Config) -> Self::Result {
println!("use the config: {:?}", cfg.config);
...
}
}
App::new().resource("/route_with_config", |r| {
r.post().with_config(handler_fn, |cfg| {
cfg.0.config = "test".to_string();
})
})
use the HttpRequest to get the configuration like any other Data
with req.app_data::<C>()
and set it with the data()
method on the resource
#[derive(Default)]
struct ExtractorConfig {
config: String,
}
impl FromRequest for YourExtractor {
type Error = Error;
type Future = Result<Self, Self::Error>;
type Config = ExtractorConfig;
fn from_request(req: &HttpRequest, payload: &mut Payload) -> Self::Future {
let cfg = req.app_data::<ExtractorConfig>();
println!("config data?: {:?}", cfg.unwrap().role);
...
}
}
App::new().service(
resource("/route_with_config")
.data(ExtractorConfig {
config: "test".to_string(),
})
.route(post().to(handler_fn)),
)
Resource registration. 1.0 version uses generalized resource
registration via .service()
method.
instead of
App.new().resource("/welcome", |r| r.f(welcome))
use App's or Scope's .service()
method. .service()
method accepts
object that implements HttpServiceFactory
trait. By default
actix-web provides Resource
and Scope
services.
App.new().service(
web::resource("/welcome")
.route(web::get().to(welcome))
.route(web::post().to(post_handler))
Scope registration.
instead of
let app = App::new().scope("/{project_id}", |scope| {
scope
.resource("/path1", |r| r.f(|_| HttpResponse::Ok()))
.resource("/path2", |r| r.f(|_| HttpResponse::Ok()))
.resource("/path3", |r| r.f(|_| HttpResponse::MethodNotAllowed()))
});
use .service()
for registration and web::scope()
as scope object factory.
let app = App::new().service(
web::scope("/{project_id}")
.service(web::resource("/path1").to(|| HttpResponse::Ok()))
.service(web::resource("/path2").to(|| HttpResponse::Ok()))
.service(web::resource("/path3").to(|| HttpResponse::MethodNotAllowed()))
);
.with()
, .with_async()
registration methods have been renamed to .to()
and .to_async()
.
instead of
App.new().resource("/welcome", |r| r.with(welcome))
use .to()
or .to_async()
methods
App.new().service(web::resource("/welcome").to(welcome))
Passing arguments to handler with extractors, multiple arguments are allowed
instead of
fn welcome((body, req): (Bytes, HttpRequest)) -> ... {
...
}
use multiple arguments
fn welcome(body: Bytes, req: HttpRequest) -> ... {
...
}
.f()
, .a()
and .h()
handler registration methods have been removed.
Use .to()
for handlers and .to_async()
for async handlers. Handler function
must use extractors.
instead of
App.new().resource("/welcome", |r| r.f(welcome))
use App's to()
or to_async()
methods
App.new().service(web::resource("/welcome").to(welcome))
HttpRequest
does not provide access to request's payload stream.
instead of
fn index(req: &HttpRequest) -> Box<Future<Item=HttpResponse, Error=Error>> {
req
.payload()
.from_err()
.fold((), |_, chunk| {
...
})
.map(|_| HttpResponse::Ok().finish())
.responder()
}
use Payload
extractor
fn index(stream: web::Payload) -> impl Future<Item=HttpResponse, Error=Error> {
stream
.from_err()
.fold((), |_, chunk| {
...
})
.map(|_| HttpResponse::Ok().finish())
}
State
is now Data
. You register Data during the App initialization process
and then access it from handlers either using a Data extractor or using
HttpRequest's api.
instead of
App.with_state(T)
use App's data
method
App.new()
.data(T)
and either use the Data extractor within your handler
use actix_web::web::Data;
fn endpoint_handler(Data<T>)){
...
}
.. or access your Data element from the HttpRequest
fn endpoint_handler(req: HttpRequest) {
let data: Option<Data<T>> = req.app_data::<T>();
}
AsyncResponder is removed, use .to_async()
registration method and impl Future<>
as result type.
instead of
use actix_web::AsyncResponder;
fn endpoint_handler(...) -> impl Future<Item=HttpResponse, Error=Error>{
...
.responder()
}
.. simply omit AsyncResponder and the corresponding responder() finish method
Middleware
instead of
let app = App::new()
.middleware(middleware::Logger::default())
use .wrap()
method
let app = App::new()
.wrap(middleware::Logger::default())
.route("/index.html", web::get().to(index));
HttpRequest::body()
, HttpRequest::urlencoded()
, HttpRequest::json()
, HttpRequest::multipart()
method have been removed. Use Bytes
, String
, Form
, Json
, Multipart
extractors instead.
instead of
fn index(req: &HttpRequest) -> Responder {
req.body()
.and_then(|body| {
...
})
}
use
fn index(body: Bytes) -> Responder {
...
}
actix_web::server
module has been removed. To start http server use actix_web::HttpServer
type
StaticFiles and NamedFile have been moved to a separate crate.
instead of use actix_web::fs::StaticFile
use use actix_files::Files
instead of use actix_web::fs::Namedfile
use use actix_files::NamedFile
Multipart has been moved to a separate crate.
instead of use actix_web::multipart::Multipart
use use actix_multipart::Multipart
Response compression is not enabled by default.
To enable, use Compress
middleware, App::new().wrap(Compress::default())
.
Session middleware moved to actix-session crate
Actors support have been moved to actix-web-actors
crate
Custom Error
Instead of error_response method alone, ResponseError now provides two methods: error_response and render_response respectively. Where, error_response creates the error response and render_response returns the error response to the caller.
Simplest migration from 0.7 to 1.0 shall include below method to the custom implementation of ResponseError:
fn render_response(&self) -> HttpResponse {
self.error_response()
}
The ' '
character is not percent decoded anymore before matching routes. If you need to use it in
your routes, you should use %20
.
instead of
fn main() {
let app = App::new().resource("/my index", |r| {
r.method(http::Method::GET)
.with(index);
});
}
use
fn main() {
let app = App::new().resource("/my%20index", |r| {
r.method(http::Method::GET)
.with(index);
});
}
If you used AsyncResult::async
you need to replace it with AsyncResult::future
Route::with_config()
/Route::with_async_config()
always passes configuration objects as tuple
even for handler with one parameter.HttpRequest
does not implement Stream
anymore. If you need to read request payload
use HttpMessage::payload()
method.
instead of
fn index(req: HttpRequest) -> impl Responder {
req
.from_err()
.fold(...)
....
}
use .payload()
fn index(req: HttpRequest) -> impl Responder {
req
.payload() // <- get request payload stream
.from_err()
.fold(...)
....
}
Middleware
trait uses &HttpRequest
instead of &mut HttpRequest
.
Removed Route::with2()
and Route::with3()
use tuple of extractors instead.
instead of
fn index(query: Query<..>, info: Json<MyStruct) -> impl Responder {}
use tuple of extractors and use .with()
for registration:
fn index((query, json): (Query<..>, Json<MyStruct)) -> impl Responder {}
Handler::handle()
uses &self
instead of &mut self
Handler::handle()
accepts reference to HttpRequest<_>
instead of value
Removed deprecated HttpServer::threads()
, use
HttpServer::workers() instead.
Renamed client::ClientConnectorError::Connector
to
client::ClientConnectorError::Resolver
Route::with()
does not return ExtractorConfig
, to configure
extractor use Route::with_config()
instead of
fn main() {
let app = App::new().resource("/index.html", |r| {
r.method(http::Method::GET)
.with(index)
.limit(4096); // <- limit size of the payload
});
}
use
fn main() {
let app = App::new().resource("/index.html", |r| {
r.method(http::Method::GET)
.with_config(index, |cfg| { // <- register handler
cfg.limit(4096); // <- limit size of the payload
})
});
}
Route::with_async()
does not return ExtractorConfig
, to configure
extractor use Route::with_async_config()
Path<T>
extractor return ErrorNotFound
on failure instead of ErrorBadRequest
ws::Message::Close
now includes optional close reason.
ws::CloseCode::Status
and ws::CloseCode::Empty
have been removed.
HttpServer::threads()
renamed to HttpServer::workers()
.
HttpServer::start_ssl()
and HttpServer::start_tls()
deprecated.
Use HttpServer::bind_ssl()
and HttpServer::bind_tls()
instead.
HttpRequest::extensions()
returns read only reference to the request's Extension
HttpRequest::extensions_mut()
returns mutable reference.
Instead of
use actix_web::middleware::{ CookieSessionBackend, CookieSessionError, RequestSession, Session, SessionBackend, SessionImpl, SessionStorage};
use actix_web::middleware::session
use actix_web::middleware::session{CookieSessionBackend, CookieSessionError, RequestSession, Session, SessionBackend, SessionImpl, SessionStorage};
FromRequest::from_request()
accepts mutable reference to a request
FromRequest::Result
has to implement Into<Reply<Self>>
Responder::respond_to()
is generic over S
Use Query
extractor instead of HttpRequest::query()`.
fn index(q: Query<HashMap<String, String>>) -> Result<..> {
...
}
or
let q = Query::<HashMap<String, String>>::extract(req);
Websocket operations are implemented as WsWriter
trait.
you need to use use actix_web::ws::WsWriter
HttpResponseBuilder::body()
, .finish()
, .json()
methods return HttpResponse
instead of Result<HttpResponse>
actix_web::Method
, actix_web::StatusCode
, actix_web::Version
moved to actix_web::http
module
actix_web::header
moved to actix_web::http::header
NormalizePath
moved to actix_web::http
module
HttpServer
moved to actix_web::server
, added new actix_web::server::new()
function,
shortcut for actix_web::server::HttpServer::new()
DefaultHeaders
middleware does not use separate builder, all builder methods moved to type itself
StaticFiles::new()
's show_index parameter removed, use show_files_listing()
method instead.
CookieSessionBackendBuilder
removed, all methods moved to CookieSessionBackend
type
actix_web::httpcodes
module is deprecated, HttpResponse::Ok()
, HttpResponse::Found()
and other HttpResponse::XXX()
functions should be used instead
ClientRequestBuilder::body()
returns Result<_, actix_web::Error>
instead of Result<_, http::Error>
Application
renamed to a App
actix_web::Reply
, actix_web::Resource
moved to actix_web::dev
此处可能存在不合适展示的内容,页面不予展示。您可通过相关编辑功能自查并修改。
如您确认内容无涉及 不当用语 / 纯广告导流 / 暴力 / 低俗色情 / 侵权 / 盗版 / 虚假 / 无价值内容或违法国家有关法律法规的内容,可点击提交进行申诉,我们将尽快为您处理。