Java Web基础

B/S

C/S

Web资源介绍

静态资源和动态资源区别

访问Web资源

<% Java语句 %>

JSP 脚本可以包含任意数量的 Java 语句，变量、方法和表达式。
JSP 脚本会把包含的内容插入到 Servlet 的 service() 方法中。  脚本不可以写方法 方法不能套方法

不能声明方法 只能生命变量（局部变量）

脚本写入到servlet中的service方法里

<%! 声明语句 %>

JSP 声明语句用于声明一个或多个变量、方法，以供后面的 Java 代码使用。
您必须先对变量和方法进行声明，才能使用它们

可能声明方法 变量（成员方法 成员变量）

声明内容添加到servlet类中 方法常量

<%= 表达式 %>

JSP 表达式可以把变量或者表达式输出到网页上，不需要 out.print() 就能输出数据。
通常用于打印变量和方法的值。

编译

初始化

执行

销毁

<%@ page ... %>

<%@ include ... %>

<%@ taglib ... %>

include动作

forward动作

param动作

useBean动作

setProperty和getProperty动作

JSP 内置对象只能在脚本和表达式中使用，在声明中不能使用。

JSP 内置对象又称为隐式对象，它们由容器实现和管理。在 JSP 页面中，这些内置对象不需要预先声明，也不需要进行实例化，我们可以直接在脚本和表达式中使用。

由 JSP 规范提供，不用编写者实例化；
通过 Web 容器实现和管理；
所有 JSP 页面均可使用；
只有在脚本元素的表达式或代码段中才能使用。

四大域对象

response

out

config

page

exception

获取参数

子主题

规范

属性

与import导入区别

实例化javabean<jsp:useBean id="student" class="web.webtest.jsp.jsp07.StudentBean" scope="page">

设置属性:<jsp:setProperty name="student" property="add" value="黑龙江"/>
读取属性:<jsp:getProperty name="student" property="add"/>

ME打开Chrome乱码的解决

什么是JSP页面？

.JSP请求是如何被处理的？

JSP有什么优点？

什么是JSP指令(Directive)？JSP中有哪些不同类型的指令？

什么是JSP动作(JSP action)？

什么是Scriptlets？

声明(Decalaration)在哪里？

什么是表达式(Expression)？

隐含对象是什么意思？有哪些隐含对象？

Servlet是用来处理客户端请求并产生动态网页内容的Java类。Servlet主要是用来处理或者是存储HTML表单提交的数据，产生动态内容，在无状态的HTTP协议下管理状态信息。

sendRedirect()方法会创建一个新的请求，而forward()方法只是把请求转发到一个新的目标上。重定向(redirect)以后，之前请求作用域范围以内的对象就失效了，因为会产生一个新的请求，而转发(forwarding)以后，之前请求作用域范围以内的对象还是能访问的。一般认为sendRedirect()比forward()要慢。

浏览器和Servlet通信使用的是HTTP协议。

ServletRequest类可以找出客户端机器的IP地址或者是主机名。getRemoteAddr()方法获取客户端主机的IP地址，getRemoteHost()可以获取主机名。

Servlet链是把一个Servlet的输出发送给另一个Servlet的方法。第二个Servlet的输出可以发送给第三个Servlet，依次类推。链条上最后一个Servlet负责把响应发送给客户端。

服务端包含(SSI)是一种简单的解释型服务端脚本语言，大多数时候仅用在Web上，用servlet标签嵌入进来。SSI最常用的场景把一个或多个文件包含到Web服务器的一个Web页面中。当浏览器访问Web页面的时候，Web服务器会用对应的servlet产生的文本来替换Web页面中的servlet标签。

Web应用程序是对Web或者是应用服务器的动态扩展。有两种类型的Web应用：面向表现的和面向服务的。面向表现的Web应用程序会产生包含了很多种标记语言和动态内容的交互的web页面作为对请求的响应。而面向服务的Web应用实现了Web服务的端点(endpoint)。一般来说，一个Web应用可以看成是一组安装在服务器URL名称空间的特定子集下面的Servlet的集合。

doGet：GET方法会把名值对追加在请求的URL后面。因为URL对字符数目有限制，进而限制了用在客户端请求的参数值的数目。并且请求中的参数值是可见的，因此，敏感信息不能用这种方式传递。

doPOST：POST方法通过把请求参数值放在请求体中来克服GET方法的限制，因此，可以发送的参数的数目是没有限制的。最后，通过POST请求传递的敏感信息对外部客户端是不可见的。

对每一个客户端的请求，Servlet引擎载入Servlet，调用它的init()方法，完成Servlet的初始化。然后，Servlet对象通过为每一个请求单独调用service()方法来处理所有随后来自客户端的请求，最后，调用Servlet(译者注：这里应该是Servlet而不是server)的destroy()方法把Servlet删除掉。

GenericServlet是一个通用的协议无关的Servlet，它实现了Servlet和ServletConfig接口。继承自GenericServlet的Servlet应该要覆盖service()方法。最后，为了开发一个能用在网页上服务于使用HTTP协议请求的Servlet，你的Servlet必须要继承自HttpServlet。这里有Servlet的例子。

Applet是运行在客户端主机的浏览器上的客户端Java程序。而Servlet是运行在web服务器上的服务端的组件。applet可以使用用户界面类，而Servlet没有用户界面，相反，Servlet是等待客户端的HTTP请求，然后为请求产生响应。

所有的Servlet都必须要实现的核心的接口是javax.servlet.Servlet。每一个Servlet都必须要直接或者是间接实现这个接口，或者是继承javax.servlet.GenericServlet或者javax.servlet.http.HTTPServlet。最后，Servlet使用多线程可以并行的为多个请求服务。

J2EE的体系结构可以分为四层

【客户端层】

【服务器端组件层】

【EJB层】

【企业信息系统层】

在J2EE规范中，J2EE平台包括有一整套的服务、应用编程接口和协议，可用于开发一般的多层应用和基于WEB的多层应用，是J2EE的核心和基础。

它还提供了EJB、Java Servlets API、JSP和XML技术的全面支持等。

交给Spring代理？

action更重一些？

validatorForm

图解

1、 用户发送请求至前端控制器DispatcherServlet

2、 HandlerMapping寻找处理器

3、 调用处理器Controller

4、 Controller调用业务逻辑处理后，返回ModelAndView

5、DispatcherServlet查询ModelAndView

6、 ModelAndView反馈浏览器HTTP

@Controller
@RestController

HttpServletRequest
HttpServletResponse

@Compoent

@RequestMapping

@RequestParam

@Autowired

@Resource

图解常用注解

1.加载和实例化

2.初始化

3.请求处理

4.服务终止

Spring的模型-视图-控制器（MVC）框架是围绕一个DispatcherServlet来设计的，

这个Servlet会把请求分发给各个处理器，并支持可配置的处理器映射、视图渲染、本地化、时区与主题渲染等，甚至还能支持文件上传。

SpingMVC如何加过滤器？

SpringMVC如何实现拦截器和过滤器？

SpringMVC的工作原理与大致的过程+1

SpringMVC如何做参数校验？

SpringMVC的常用注解有哪些？

模板引擎（这里特指用于Web开发的模板引擎）

是为了使用户界面与业务数据（内容）分离而产生的，

它可以生成特定格式的文档，用于网站的模板引擎就会生成一个标准的HTML文档。

模板的诞生是为了将显示与数据分离，模板技术多种多样，但其本质是将模板文件和数据通过模板引擎生成最终的HTML代码。

图解模板引擎

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>

赋值<span th:text="${book.author.name}">

循环<li th:each="book : ${books}" th:text="${book.title}">En las Orillas del Sar</li>

带URL的链接值<a th:href="@{/order/details(id=${orderId},type=${orderType})}">...</a>

If条件判断

Switch Case

RESTful 框架

轻量WebService框架

Jersey RESTful 框架是开源的RESTful框架, 实现了JAX-RS (JSR 311 & JSR 339) 规范。

它扩展了JAX-RS 参考实现， 提供了更多的特性和工具， 可以进一步地简化 RESTful service 和 client 开发。

很少一部分人去关注Jersey

非常不错的框架

优秀的文档和例子
快速
超级容易的路由
平滑的 JUnit 集成
就个人而言, 当开发 RESTful service 时, JAX-RS 实现要好于 MVC 框架。
可以集成到其它库/框架 (Grizzly, Netty). 这也可能是很多产品使用它的原因。
支持异步链接
不喜欢 servlet container? 使用Jersey的时候可以不用它们。
WADL, XML/JSON support
包含在Glassfish中

Jersey 2.0+使用了有些复杂的依赖注入实现
可能不是一件坏事。Jersey 1.X 使用较老的 JAX-RS 实现
一大堆第三方库只支持 Jersey 1.X， 在 Jersey 2.X 不可用

package org.glassfish.jersey.examples.helloworld;
 
import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
 
@Path("helloworld")
public class HelloWorldResource {
    public static final String CLICHED_MESSAGE = "Hello World!";
 
@GET
@Produces("text/plain")
    public String getHello() {
        return CLICHED_MESSAGE;
    }
}

摘自[http://www.importnew.com/17138.html]

背景

Jersey

 Dropwizard

Restlet

Play Framework

Restx

Spark Framework 

 Ninja Web Framework

RestExpress

如果你想获得服务器数据库中的所有数据；那么你可以在浏览器或者利用Ajax的GET方法，将路径设置好；

例如：localhost:8080/Student(项目名称)/studentinfo(项目服务总体前缀)/student(处理student对象的签注)/getStudentInfo(最后前缀)。

这样就可以获取所有学生信息。你可以选择GET获取的数据的返回类型：JSON,XML,TEXT_HTML(String)..

获取之后，你可以通过JS将这些数据塞到html或者jsp页面上。

（摘自百度百科：https://baike.baidu.com/item/Jersey/17577306?fr=aladdin）

注解：

Filter和Interceptors：

媒体类型：

容器或运行环境：

服务端和客户端：

Table 2.1. Jersey Core

Table 2.2. Jersey Containers

Table 2.3. Jersey Connectors

Table 2.4. Jersey Media

Table 2.6. Jersey Test Framework

Table 2.7. Jersey Test Framework Providers

REST 中最重要的概念是资源（resources），使用全球 ID（通常使用 URI）标识。

客户端应用程序使用 HTTP 方法（GET/ POST/ PUT/ DELETE）操作资源或资源集。

RESTful Web 服务是使用 HTTP 和 REST 原理实现的Web 服务。

通常，RESTful Web 服务应该定义以下方面：

通过Maven构建模板创建示例项目示例

Jersey常用注解解释

常用注释的使用方法指导

Table 3.1. Resource scopes

展示一个比较全的可注入的使用方式：

HTTP server

Servlet-based Deployment

Servlet 3.x Container

创建方式：

基本使用

客户端异步获取资源

传输文件示例：

SSL Client创建方式

在服务端加入如下Feature：
HttpAuthenticationFeature feature = HttpAuthenticationFeature.basic("user", "superSecretPassword");
如需创建非抢占模式：
HttpAuthenticationFeature feature = HttpAuthenticationFeature.basicBuilder()
.nonPreemptive().credentials("user", "superSecretPassword").build();
当然，也可以创建没有任何凭证的Feature:
HttpAuthenticationFeature feature = HttpAuthenticationFeature.basicBuilder().build();
客户端需要使用如下方式进行访问：
Response response = client.target("http://localhost:8080/rest/homer/contact").request()
    .property(HTTP_AUTHENTICATION_BASIC_USERNAME, "homer")
    .property(HTTP_AUTHENTICATION_BASIC_PASSWORD, "p1swd745").get();

为了解决更加复杂的使用场景，一个请求的执行受到上一次或者上几次请求结果的影响，这样就可以使用Reactive Client Extension：
譬如有如下需求：
We also presume that the basic services we need to work with are:
 Customers service – provides information about customers of the travel agency.
 Destinations service – provides a list of visited and recommended destinations for an authenticated customer.
 Weather service – provides weather forecast for a given destination.
 Quoting service – provides price calculation for a customer to travel to a recommended destination.
The task is to create a publicly available feature that would, for an authenticated user, display a list of 10 last visited places and also display a list of 10 new recommended destinations including weather forecast and price calculations for the user. Notice that some of the requests (to retrieve data) depend on results of previous requests. E.g. getting recommended destinations depends on obtaining information about the authenticated user first. Obtaining weather forecast depends on destination information, etc. This relationship between some of the requests is an important part of the problem and an area where you can take a real advantage of the reactive programming model.
单纯的实现方法如下：
final WebTarget destination = ...;
final WebTarget forecast = ...;
 
// Obtain recommended destinations.
List<Destination> recommended = Collections.emptyList();
try {
    recommended = destination.path("recommended").request()
            // Identify the user.
            .header("Rx-User", "Sync")
            // Return a list of destinations.
            .get(new GenericType<List<Destination>>() {});
} catch (final Throwable throwable) {
    errors.offer("Recommended: " + throwable.getMessage());
}
 
// Forecasts. (depend on recommended destinations)
final Map<String, Forecast> forecasts = new HashMap<>();
for (final Destination dest : recommended) {
    try {
        forecasts.put(dest.getDestination(),
                forecast.resolveTemplate("destination", dest.getDestination()).request().get(Forecast.class));
    } catch (final Throwable throwable) {
        errors.offer("Forecast: " + throwable.getMessage());
    }
}
对应耗费时间如下：
 
如果使用如下方式，时间将会减少很多：
final WebTarget destination = ...;
final WebTarget forecast = ...;
 
// Obtain recommended destinations. (does not depend on visited ones)
destination.path("recommended").request()
        // Identify the user.
        .header("Rx-User", "Async")
        // Async invoker.
        .async()
        // Return a list of destinations.
        .get(new InvocationCallback<List<Destination>>() {
            @Override
            public void completed(final List<Destination> recommended) {
                final CountDownLatch innerLatch = new CountDownLatch(recommended.size());
 
                // Forecasts. (depend on recommended destinations)
                final Map<String, Forecast> forecasts = Collections.synchronizedMap(new HashMap<>());
                for (final Destination dest : recommended) {
                    forecast.resolveTemplate("destination", dest.getDestination()).request()
                            .async()
                            .get(new InvocationCallback<Forecast>() {
                                @Override
                                public void completed(final Forecast forecast) {
                                    forecasts.put(dest.getDestination(), forecast);
                                    innerLatch.countDown();
                                }
 
                                @Override
                                public void failed(final Throwable throwable) {
                                    errors.offer("Forecast: " + throwable.getMessage());
                                    innerLatch.countDown();
                                }
                            });
                }
 
                // Have to wait here for dependent requests ...
                try {
                    if (!innerLatch.await(10, TimeUnit.SECONDS)) {
                        errors.offer("Inner: Waiting for requests to complete has timed out.");
                    }
                } catch (final InterruptedException e) {
                    errors.offer("Inner: Waiting for requests to complete has been interrupted.");
                }
 
                // Continue with processing.
            }
 
            @Override
            public void failed(final Throwable throwable) {
                errors.offer("Recommended: " + throwable.getMessage());
            }
        });
使用如上方法后，调用时间情况如下：
 
Reactive Approach实现方式：
final WebTarget destination = ...;
final WebTarget forecast = ...;
 
// Recommended places.
CompletionStage<List<Destination>> recommended =
        destination.path("recommended")
                   .request()
                   // Identify the user.
                   .header("Rx-User", "CompletionStage")
                   // Reactive invoker.
                   .rx()
                   // Return a list of destinations.
                   .get(new GenericType<List<Destination>>() {})
                   .exceptionally(throwable -> {
                       errors.offer("Recommended: " + throwable.getMessage());
                       return Collections.emptyList();
                   });
 
// get Forecast for recommended destinations.
return recommended.thenCompose(destinations -> {
 
    List<CompletionStage<Recommendation>> recommendations = destinations.stream().map(destination -> {
    // For each destination, obtain a weather forecast ...
    final CompletionStage<Forecast> forecastResult =
            forecast.resolveTemplate("destination", destination.getDestination())
                    .request().rx().get(Forecast.class)
                    .exceptionally(throwable -> {
                        errors.offer("Forecast: " + throwable.getMessage());
                        return new Forecast(destination.getDestination(), "N/A");
                    });
 
                    //noinspection unchecked
                    return CompletableFuture.completedFuture(new Recommendation(destination))
                                            // Set forecast for recommended destination.
                                            .thenCombine(forecastResult, Recommendation::forecast)
                    }).collect(Collectors.toList());
 
                    // Transform List<CompletionStage<Recommendation>> to CompletionStage<List<Recommendation>>
                    return sequence(recommendations);
    });

Representations and Responses：

• All media types (*/*)

• XML media types (text/xml, application/xml and application/...+xml)

• Form content (application/x-www-form-urlencoded)

• Plain text (text/plain)

Server端

Client端

final URI uri = UriBuilder.fromUri("http://{host}/{path}?q={param}")
    .resolveTemplate("host", "localhost")
    .resolveTemplate("path", "myApp")
    .resolveTemplate("param", "value").build();
 
uri.toString(); // returns "http://localhost/myApp?q=value"

HTTP响应由三个部分组成：

状态码(Status Code)：描述了响应的状态。可以用来检查是否成功的完成了请求。请求失败的情况下，状态码可用来找出失败的原因。如果Servlet没有返回状态码，默认会返回成功的状态码HttpServletResponse.SC_OK。

HTTP头部(HTTP Header)：它们包含了更多关于响应的信息。比如：头部可以指定认为响应过期的过期日期，或者是指定用来给用户安全的传输实体内容的编码格式。如何在Serlet中检索HTTP的头部看这里。

主体(Body)：它包含了响应的内容。它可以包含HTML代码，图片，等等。主体是由传输在HTTP消息中紧跟在头部后面的数据字节组成的。

HTTP隧道是一种利用HTTP或者是HTTPS把多种网络协议封装起来进行通信的技术。因此，HTTP协议扮演了一个打通用于通信的网络协议的管道的包装器的角色。把其他协议的请求掩盖成HTTP的请求就是HTTP隧道。

URL编码是负责把URL里面的空格和其他的特殊字符替换成对应的十六进制表示，反之就是解码。

cookie是Web服务器发送给浏览器的一块信息。浏览器会在本地文件中给每一个Web服务器存储cookie。以后浏览器在给特定的Web服务器发请求的时候，同时会发送所有为该服务器存储的cookie。下面列出了session和cookie的区别：

无论客户端浏览器做怎么样的设置，session都应该能正常工作。客户端可以选择禁用cookie，但是，session仍然是能够工作的，因为客户端无法禁用服务端的session。
在存储的数据量方面session和cookies也是不一样的。session能够存储任意的Java对象，cookie只能存储String类型的对象。