网站建设服务采购方案,后端开发是干什么的,想学学做网站,怎么查找网站的服务器Javalin
Javalin是一个轻量级http框架#xff0c;我们可以很容易的了解请求的处理过程及其设计#xff0c;具有较高的学习意义。
从demo说起
public static void main(String[] args) {Javalin app Javalin.create(config - {System.out.println(用户配置我们可以很容易的了解请求的处理过程及其设计具有较高的学习意义。
从demo说起
public static void main(String[] args) {Javalin app Javalin.create(config - {System.out.println(用户配置);});app.get(/, ctx - {System.out.println(do ctx.path());ctx.result(Hello World);});// 处理异常app.exception(Exception.class, (e, ctx) - {ctx.result(发生异常了);});// 处理异常状态app.error(404, ctx - {ctx.html(Generic 404 message);});// 测试异常app.get(/exception/{e}, ctx - {String msg ctx.pathParam(e);if (1.equals(msg)) {throw new InvalidAlgorithmParameterException(测试异常);} else if (2.equals(msg)) {throw new ClassNotFoundException(Invalid);} else if (3.equals(msg)) {ctx.status(404);} else {throw new Exception(Invalid algorithm parameter);}});//get请求{}参数解析app.get(/path/path, ctx - ctx.result(Hello Path2 ctx.pathParam(path)));//post请求app.post(/json, ctx - {MapString, String map new HashMap();map.put(name, 张三);ctx.json(map);});//get请求参数解析app.get(/name/{name}, ctx - {NaiveRateLimit.requestPerTimeUnit(ctx, 5, TimeUnit.MINUTES);ctx.result(Hello Path ctx.pathParam(name));});// webscoketapp.ws(/websocket/{path}, ws - {ws.onConnect(ctx - System.out.println(Connected));ws.onMessage(ctx - {System.out.println(收到消息 ctx.message());ctx.send(我收到了 ctx.message());});});// 前置处理器app.before(ctx - System.out.println(before ctx.path()));// 后置处理器app.after(ctx - System.out.println(after ctx.path()));// 启动app.start(7070);}创建Javalin实例
使用代码
Javalin app Javalin.create(config - {System.out.println(用户配置);});实现原理
实现源码 public static Javalin create(ConsumerJavalinConfig config) {// 初始化示例对象Javalin app new Javalin();// 加载用户配置JavalinConfig.applyUserConfig(app, app.cfg, config); // mutates app.config and app (adds http-handlers)// 延迟检测服务是否正常启动JettyUtil.maybeLogIfServerNotStarted(app.jettyServer);return app;}流程
get/post/websocket/before/after配置
使用方式 app.get(/, ctx - {System.out.println(do ctx.path());ctx.result(Hello World);});实现源码 public Javalin get(NotNull String path, NotNull Handler handler) {return addHandler(HandlerType.GET, path, handler);}public Javalin addHandler(NotNull HandlerType httpMethod, NotNull String path, NotNull Handler handler) {return addHandler(httpMethod, path, handler, new RouteRole[0]); // no roles set for this route (open to everyone with default access manager)}public Javalin addHandler(NotNull HandlerType handlerType, NotNull String path, NotNull Handler handler, NotNull RouteRole... roles) {SetRouteRole roleSet new HashSet(Arrays.asList(roles));javalinServlet.getMatcher().add(new HandlerEntry(handlerType, path, cfg.routing, roleSet, handler));eventManager.fireHandlerAddedEvent(new HandlerMetaInfo(handlerType, Util.prefixContextPath(cfg.routing.contextPath, path), handler, roleSet));return this;}添加流程 get/post/websocket/before/after处理器都是这个类型只是请求类型不一致, http支持的请求类型有
GET, POST, PUT, PATCH, DELETE, HEAD, TRACE, CONNECT, OPTIONS, BEFORE, AFTER, INVALID;websocket支持的请求类型有 WS_BEFORE, WEBSOCKET, WS_AFTERexceptionHandler配置
使用方式 // 处理异常app.exception(Exception.class, (e, ctx) - {ctx.result(发生异常了);});实现源码 public T extends Exception Javalin exception(NotNull ClassT exceptionClass, NotNull ExceptionHandler? super T exceptionHandler) {javalinServlet.getExceptionMapper().getHandlers().put(exceptionClass, (ExceptionHandlerException) exceptionHandler);return this;}添加流程
errorHandler配置
使用方式 // 处理异常状态app.error(404, ctx - {ctx.html(Generic 404 message);});实现源码 public Javalin error(int status, NotNull String contentType, NotNull Handler handler) {javalinServlet.getErrorMapper().addHandler(status, contentType, handler);return this;}添加流程
权限管理配置
使用方式
// Set the access-manager that Javalin should use
config.accessManager((handler, ctx, routeRoles) - {MyRole userRole getUserRole(ctx);if (routeRoles.contains(userRole)) {handler.handle(ctx);} else {ctx.status(401).result(Unauthorized);}
});Role getUserRole(Context ctx) {// determine user role based on request.// typically done by inspecting headers, cookies, or user session
}enum Role implements RouteRole {ANYONE, ROLE_ONE, ROLE_TWO, ROLE_THREE;
}app.get(/un-secured, ctx - ctx.result(Hello), Role.ANYONE);
app.get(/secured, ctx - ctx.result(Hello), Role.ROLE_ONE);实现源码 fun accessManager(accessManager: AccessManager) { pvt.accessManager accessManager }设置流程
启动流程
使用方式
// 启动
app.start(7070);源码 public Javalin start(int port) {// 设置端口号jettyServer.setServerPort(port);// 启动服务return start();}start()
public Javalin start() {// 记录启动开始时间long startupTimer System.currentTimeMillis();// 如果已经启动了就报错if (jettyServer.started) {String message Server already started. If you are trying to call start() on an instance of Javalin that was stopped using stop(), please create a new instance instead.;throw new IllegalStateException(message);}// 标识服务已经启动jettyServer.started true;// 检测日志组件是否引入Util.printHelpfulMessageIfLoggerIsMissing();// 触发服务启动中事件eventManager.fireEvent(JavalinEvent.SERVER_STARTING);try {// 打印服务启动中JavalinLogger.startup(Starting Javalin ...);// 启动jetty服务jettyServer.start(javalinJettyServlet);// 打印javlin和java版本Util.logJavalinVersion();// 打印服务已经启动和耗时JavalinLogger.startup(Javalin started in (System.currentTimeMillis() - startupTimer) ms \\o/);// 发布服务已启动事件eventManager.fireEvent(JavalinEvent.SERVER_STARTED);} catch (Exception e) {// 打印服务启动异常JavalinLogger.error(Failed to start Javalin);// 发布服务启动失败事件eventManager.fireEvent(JavalinEvent.SERVER_START_FAILED);// 如果jetty已启动成功了则停止服务if (Boolean.TRUE.equals(jettyServer.server().getAttribute(is-default-server))) {stop();// stop if server is default server; otherwise, the caller is responsible to stop}if (e.getMessage() ! null e.getMessage().contains(Failed to bind to)) {// 端口冲突throw new JavalinBindException(Port already in use. Make sure no other process is using port Util.getPort(e) and try again., e);} else if (e.getMessage() ! null e.getMessage().contains(Permission denied)) {// 权限不足throw new JavalinBindException(Port 1-1023 require elevated privileges (process must be started by admin)., e);}// 其他异常throw new JavalinException(e);}return this;}其中核心逻辑在jettyServer.start(javalinJettyServlet);中 jettyServer.start(javalinJettyServlet); fun start(wsAndHttpServlet: JavalinJettyServlet) {// 如果未设置端口则设置为8080端口if (serverPort -1 cfg.pvt.server null) {serverPort 8080JavalinLogger.startup(No port specified, starting on port $serverPort. Call start(port) to change ports.)}// 初始化默认sessionHandler管理sessioncfg.pvt.sessionHandler cfg.pvt.sessionHandler ?: defaultSessionHandler()val nullParent null // javalin handlers are orphans// 定义jetty请求处理器val wsAndHttpHandler object : ServletContextHandler(nullParent, Util.normalizeContextPath(cfg.routing.contextPath), SESSIONS) {override fun doHandle(target: String, jettyRequest: Request, request: HttpServletRequest, response: HttpServletResponse) {request.setAttribute(jetty-target-and-request, Pair(target, jettyRequest)) // used in JettyResourceHandlernextHandle(target, jettyRequest, request, response)}}.apply {this.sessionHandler cfg.pvt.sessionHandlercfg.pvt.servletContextHandlerConsumer?.accept(this)// 设置所有路径处理器addServlet(ServletHolder(wsAndHttpServlet), /*)// 初始化websocket处理器JettyWebSocketServletContainerInitializer.configure(this) { _, _ -/* we dont want to configure WebSocketMappings during ServletContext initialization phase */}}// 初始化jetty服务并设置处理器server().apply {handler if (handler null) wsAndHttpHandler else handler.attachHandler(wsAndHttpHandler)if (connectors.isEmpty()) { // user has not added their own connectors, we add a single HTTP connectorconnectors arrayOf(defaultConnector(this))}}.start()// 打印javalin logologJavalinBanner(cfg.showJavalinBanner)// 打印是否使用Loom(Java虚拟线程)LoomUtil.logIfLoom(server())// 初始化资源处理器(cfg.pvt.resourceHandler as? JettyResourceHandler)?.init() // we want to init this here to get logs in order// 打印服务使用的ip和端口server().connectors.filterIsInstanceServerConnector().forEach {JavalinLogger.startup(Listening on ${it.protocol}://${it.host ?: localhost}:${it.localPort}${cfg.routing.contextPath})}// 非http服务打印绑定的端口server().connectors.filter { it !is ServerConnector }.forEach {JavalinLogger.startup(Binding to: $it)}// 设置服务启动的端口号serverPort (server().connectors[0] as? ServerConnector)?.localPort ?: -1}启动流程
请求处理流程
处理请求的入口 JavalinJettyServlet.service 这个类既处理http也处理websocket
override fun service(req: HttpServletRequest, res: HttpServletResponse) { // this handles both http and websocket// 判断是否有websocket请求标识if (req.getHeader(Header.SEC_WEBSOCKET_KEY) null) { // this isnt a websocket request// http请求处理return httpServlet.service(req, res) // treat as normal HTTP request}// 去除项目路径前缀val requestUri req.requestURI.removePrefix(req.contextPath)// 查找url对应后端处理器val entry wsPathMatcher.findEndpointHandlerEntry(requestUri) ?: return res.sendError(404, WebSocket handler not found)// 构建请求处理的上下文val upgradeContext JavalinServletContext(req req,res res,cfg cfg,matchedPath entry.path,pathParamMap entry.extractPathParams(requestUri),)// 校验权限if (!allowedByAccessManager(entry, upgradeContext)) return res.sendError(HttpStatus.UNAUTHORIZED.code, HttpStatus.UNAUTHORIZED.message)// 设置上下文req.setAttribute(upgradeContextKey, upgradeContext)// 设置协议头setWsProtocolHeader(req, res)// 处理websocket请求super.service(req, res) // everything is okay, perform websocket upgrade}从源码可以知道http请求又调了JavalinServlet.service进行处理websocket 掉jetty进行处理会回调这个类型configure方法因为这类继承了JettyWebSocketServlet类。 接下来先介绍http请求处理部分 JavalinServlet.service
override fun service(request: HttpServletRequest, response: HttpServletResponse) {try {// 构建请求处理的上下文val ctx JavalinServletContext(req request, res response, cfg cfg)// 定义请求处理的任务列表添加函数添加到头部还是尾部val submitTask: (SubmitOrder, Task) - Unit { order, task -when (order) {FIRST - ctx.tasks.offerFirst(task)LAST - ctx.tasks.add(task)}}// 去除项目的上下文路径val requestUri ctx.path().removePrefix(ctx.contextPath())// 生成请求处理的任务列表生成任务的最终顺序如下表cfg.pvt.servletRequestLifecycle.forEach { it.createTasks(submitTask, this, ctx, requestUri) }// 处理请求ctx.handleSync()} catch (throwable: Throwable) {// 兜底异常处理exceptionMapper.handleUnexpectedThrowable(response, throwable)}}处理器类型是否跳过异常BEFORE是HTTP是ERROR否AFTER否
再看下处理请求部分 private fun JavalinServletContext.handleSync() {while (userFutureSupplier null tasks.isNotEmpty()) {// 取出第一个任务val task tasks.poll()// 判断是否发生过异常且是否跳过异常if (exceptionOccurred task.skipIfExceptionOccurred) {continue}// 处理任务handleTask(task.handler)}when {// 异步处理的请求userFutureSupplier ! null - handleUserFuture()// 非异步处理的请求写入结果并打印日志else - writeResponseAndLog()}}private fun R JavalinServletContext.handleTask(handler: TaskHandlerR): R? try {handler.handle()} catch (throwable: Throwable) {exceptionOccurred trueuserFutureSupplier nulltasks.offerFirst(Task(skipIfExceptionOccurred false) { exceptionMapper.handle(this, throwable) })null}然后在看下websocket的处理过程 首先调用configure完成连接初始化 JavalinJettyServlet.configure // websocket初始化连接override fun configure(factory: JettyWebSocketServletFactory) { // this is called once, before everythingcfg.pvt.wsFactoryConfig?.accept(factory)factory.setCreator(JettyWebSocketCreator { req, _ - // this is called when a websocket is created (after [service])val preUpgradeContext req.httpServletRequest.getAttribute(upgradeContextKey) as JavalinServletContextreq.httpServletRequest.setAttribute(upgradeContextKey, preUpgradeContext.changeBaseRequest(req.httpServletRequest))val session req.session as? Session?req.httpServletRequest.setAttribute(upgradeSessionAttrsKey, session?.attributeNames?.asSequence()?.associateWith { session.getAttribute(it) })// 初始化连接returnJettyWebSocketCreator WsConnection(wsPathMatcher, wsExceptionMapper, cfg.pvt.wsLogger)})}重点看下WsConnection类 OnWebSocketConnectfun onConnect(session: Session) {// websocket连接初始化val ctx WsConnectContext(sessionId, session)tryBeforeAndEndpointHandlers(ctx) { it.wsConfig.wsConnectHandler?.handleConnect(ctx) }tryAfterHandlers(ctx) { it.wsConfig.wsConnectHandler?.handleConnect(ctx) }wsLogger?.wsConnectHandler?.handleConnect(ctx)}OnWebSocketMessagefun onMessage(session: Session, message: String) {// 收到文本消息val ctx WsMessageContext(sessionId, session, message)tryBeforeAndEndpointHandlers(ctx) { it.wsConfig.wsMessageHandler?.handleMessage(ctx) }tryAfterHandlers(ctx) { it.wsConfig.wsMessageHandler?.handleMessage(ctx) }wsLogger?.wsMessageHandler?.handleMessage(ctx)}OnWebSocketMessagefun onMessage(session: Session, buffer: ByteArray, offset: Int, length: Int) {// 收到二进制消息val ctx WsBinaryMessageContext(sessionId, session, buffer, offset, length)tryBeforeAndEndpointHandlers(ctx) { it.wsConfig.wsBinaryMessageHandler?.handleBinaryMessage(ctx) }tryAfterHandlers(ctx) { it.wsConfig.wsBinaryMessageHandler?.handleBinaryMessage(ctx) }wsLogger?.wsBinaryMessageHandler?.handleBinaryMessage(ctx)}OnWebSocketClosefun onClose(session: Session, statusCode: Int, reason: String?) {// 连接关闭val ctx WsCloseContext(sessionId, session, statusCode, reason)tryBeforeAndEndpointHandlers(ctx) { it.wsConfig.wsCloseHandler?.handleClose(ctx) }tryAfterHandlers(ctx) { it.wsConfig.wsCloseHandler?.handleClose(ctx) }wsLogger?.wsCloseHandler?.handleClose(ctx)ctx.disableAutomaticPings()}OnWebSocketErrorfun onError(session: Session, throwable: Throwable?) {// 发生异常val ctx WsErrorContext(sessionId, session, throwable)tryBeforeAndEndpointHandlers(ctx) { it.wsConfig.wsErrorHandler?.handleError(ctx) }tryAfterHandlers(ctx) { it.wsConfig.wsErrorHandler?.handleError(ctx) }wsLogger?.wsErrorHandler?.handleError(ctx)}采用注解形式定义一系列websocket操作 请求处理流程
总结
至此主要处理流程都介绍完毕还有部分异步请求的处理下次再更新。最后附上Jetty核心组件结构图
