Web核心知识点总结

1. XML概述

1	Extensible Markup Language 可扩展标记语言，自定义标签，使用标记语言的特性描述数据结构，主要作为配置文件用于数据的存储以及传输。

语法特点：

文档后缀名：xml

第一行必须定义为文档声明

文档中有且仅有一个根标签，所有标签必须闭合，区分大小写

属性值必须加引号

文档声明：

格式：<?xml version="1.0" encoding = "UTF-8" standalone = "yes"?>

version 版本号是必须的属性；

encoding 告知解析引擎当前文档使用的字符集，默认值：ISO-8859-1 不支持汉

standalone 是否独立，取值yes为不依赖其他文件，取值no为依赖其他文件

指令：

结合CSS指令：< ?xml-stylesheet type="text/css" href="a.css" ?>

CDATA区（数据原样展示，不被解析）：<![CDATA[ 数据 ]]>

2. XML约束

1
2

规定xml文档的书写规则，不影响解析，主要有两种技术：
DTD:一种简单的约束技术，约束的内容较为简单；Schema:一种复杂的约束技术，约束的内容较为详细

DTD引入：

内部dtd：将约束规则定义在xml文档中
外部dtd：将约束的规则定义在外部的dtd文件中

本地：< !DOCTYPE 根标签名 SYSTEM "dtd文件的位置">

网络：< !DOCTYPE 根标签名 PUBLIC "dtd文件名字" "dtd文件的位置URL">

Schema引入：

> 1. 填写xml文档的根元素:
> 	<beans
> 2. 引入xsd约束的标准，并声明前缀xsi：
> 	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance
> 3. 给xsi的location参数赋值，说明引入的xsd文件路径，路径前是xsd文件的命名空间：
> 	xsi:schemaLocation="
>         http://www.springframework.org/schema/beans（命名空间） 		
>         http://www.springframework.org/schema/beans/spring-beans.xsd（文件路径）
>         http://www.springframework.org/schema/context （命名空间）
>         http://www.springframework.org/schema/context/spring-context.xsd（文件路径）
>         http://www.springframework.org/schema/mvc（命名空间）
>         http://www.springframework.org/schema/mvc/spring-mvc.xsd"（文件路径）
> 4. 为每一个xsd约束声明一个前缀，作为标识：
> 	xmlns="http://www.springframework.org/schema/beans"（无前缀为默认）
> 	xmlns:context="http://www.springframework.org/schema/context"（前缀context）
> 	xmlns:mvc="http://www.springframework.org/schema/mvc"（前缀mvc）>	
>

3. XML解析

1	操作xml文档，将文档中的数据读取到内存中

解析的方式：

DOM：将标记语言文档一次性加载进内存，在内存中形成一颗DOM树

优点：操作方便，可以对文档进行CRUD操作；缺点：占内存

SAX：逐行读取，基于事件驱动

优点：不占内存；缺点：只能读取，不能增删改

常见解析器：

JAXP：sun公司提供的解析器，支持dom和sax两种思想

DOM4J：一款非常优秀的解析器。应用广泛，对XPath支持度高

Jsoup：jsoup 是一款Java 的HTML解析器，可直接解析某个URL地址、HTML文本内容。它提供了一套非常省力的API，可通过DOM，CSS以及类似于jQuery的操作方法来取出和操作数据

PULL：Android操作系统内置的解析器，sax方式的

Jsoup解析器

Jsoup方法：
parse解析，返回Document：

parse(File in, String charsetName)：解析xml或html文件的

parse(String html)：解析xml或html字符串

parse(URL url, int timeoutMillis)：通过网络路径获取指定的html或xml的文档对象

通过Document的方法获取Elements对象：

getElementById(String id)：根据id属性值获取唯一的element对象

getElementsByTag(String tagName)：根据标签名称获取元素对象集合

getElementsByAttribute(String key)：根据属性名称获取元素对象集合

getElementsByAttributeValue(String key, String value)：根据属性名和属性值获取元素对象集合

通过Elements集合获取元素Element（Elements可当做ArrayList使用）：

String attr(String key)：根据属性名称获取属性值

String text():获取文本内容

String html():获取标签体的所有内容(包括子标签及其字符串内容)
selector选择器：
document.select(String cssQuery)，返回Elements
cssQuery语法参考Selector类中定义的语法：
1
2
3
>       //示例：获取student标签并且number属性值为heima_0001的age子标签
>      	document.select("student[number=\"heima_0001\"] > age");
>

//Jsoup使用步骤
//0.导入jar包：jsoup-1.11.2.jar
//1.获取要解析文件的路径
String path = Demo01Jsoup.class.getClassLoader().getResource("url").getPath();
//2.通过Jsoup的方法解析，加载文档进内存，获取Document对象
Document document = Jsoup.parse(new File(path), "utf-8");
//3.获取元素对象集合
Elements elements = document.getElementsByTag("name");
//4.获取单个元素对象
Element element = elements.get(1);
System.out.println(element.html());	//获取标签体的所有内容(包括子标签)
System.out.println(element.text());	//获取文本内容

Xpath路径语言

XPath即为XML路径语言，它是一种用来确定XML（标准通用标记语言的子集）文档中某部分位置的语言，使用Jsoup的Xpath需要额外导入jar包，Jsoup只支持XPath1.0。

//XPath使用演示：
//1.获取要解析文件的路径
String path = Demo01Jsoup.class.getClassLoader().getResource("url").getPath();
//2.通过Jsoup的方法解析，加载文档进内存，获取Document对象
Document document = Jsoup.parse(new File(path), "utf-8");
//3.根据document对象，创建JXDocument对象
JXDocument jxDocument = new JXDocument(document);
//4.结合xpath语法查询符合条件的结果并输出
List<JXNode> jxNodes = jxDocument.selN("条件");
for (JXNode jxNode : jxNodes) {
    System.out.println(jxNode);}
//条件示范：
//查询所有student标签：
jxDocument.selN("//student"); 
//查询所有student标签下的name标签：
jxDocument.selN("//student/name"); 
//查询student标签下带有id属性的name标签：
jxDocument.selN("//student/name[@id]"); 
//查询student标签下带有id属性的name标签，并且id属性值为itcast：
jxDocument.selN("//student/name[@id='itcast']");

4. web服务器软件

web服务器软件搭载在服务器上，可以部署web项目，让用户通过浏览器来访问这些项目
常见的java相关的web服务器软件：
	webLogic：oracle公司，大型的JavaEE服务器，支持所有的JavaEE规范，收费。
	webSphere：IBM公司，大型的JavaEE服务器，支持所有的JavaEE规范，收费。
	JBOSS：JBOSS公司的，大型的JavaEE服务器，支持所有的JavaEE规范，收费。
	Tomcat：Apache基金组织，中小型的JavaEE服务器，支持少量的JavaEE规范servlet/jsp，开源，免费。

Tomcat介绍

启动：打开bin/startup.bat

关闭：打开bin/shutdown.bat或在命令行ctrl+c

部署项目的三种方式：

将项目打包成war(zip)包，放到webapps目录下即可

war包会自动解压缩，若需部署多个项目，可以放到虚拟目录中区分不同的项目。

配置conf/server.xml文件

docBase:项目存放的路径

path：虚拟目录

在conf\Catalina\localhost创建xml文件

xml文件名为虚拟目录名

xml文件中编写

5. Servlet接口

1
2

Servlet就是一个接口，定义了Java类被浏览器访问到(tomcat识别)的规则。
Java类只要实现了这个接口，那么这个类就可以被浏览器访问到（让该类代码执行）。

访问原理

1. 当服务器接受到客户端浏览器的请求后，会解析请求URL路径，获取访问的Servlet的资源路径
查找web.xml文件，是否有对应的标签体内容。

如果有，则在找到对应的全类名

tomcat会将字节码文件加载进内存，并且通过反射机制创建其对象

调用其方法

使用步骤

创建JavaEE项目
定义一个类，实现Servlet接口public class ServletDemo1 implements Servlet
实现接口中的抽象方法

配置Servlet

>    //方法一： 
>    在web.xml中配置：
>    	<!--配置Servlet -->
>    	<servlet>
>    	        <servlet-name>demo1</servlet-name>
>    	        <servlet-class>cn.itcast.web.servlet.ServletDemo1</servlet-class>
>    	</servlet>
>    	
>    	<servlet-mapping>
>    		<servlet-name>demo1</servlet-name>
>    		<url-pattern>/demo1</url-pattern>
>    	</servlet-mapping>
>    	/*在<servlet>标签下配置 <load-on-startup>，赋值：
>    		值为负数：第一次被访问时创建
>    	    值为非负数：在服务器启动时创建*/    
>    //方法二：
>    在类上使用@WebServlet("/资源路径")注解，进行配置 (Servlet3.0版本以上)
>    //一个Servlet可以定义多个访问路径 ： @WebServlet({"/d4","/dd4","/ddd4"})
>    //路径定义规则：
>       1. /xxx/xxx:多层路径，目录结构
>       2. *.do：扩展名匹配(任何以.do结尾都可以匹配到)                             
>

内部方法

> @Override
> public void init(ServletConfig servletConfig) throws ServletException {
> 	//Servlet的init方法，只执行一次，说明一个Servlet在内存中只存在一个对象，Servlet是单例的
> }
> @Override
> public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
>     //每次访问Servlet时，Service方法都会被调用一次。
> }
> @Override
> public void destroy() {
> 	//destroy方法在Servlet服务器正常关闭之前才会执行，一般用于释放资源。
> }
> @Override
> public String getServletInfo() {   //不常用
>     return null;
> }
> @Override
> public ServletConfig getServletConfig() {   //不常用
>     return null;  
> }
>

体系结构

op1=>operation: Servlet -- 接口
op2=>operation: GenericServlet -- 抽象类
op3=>operation: HttpServlet  -- 抽象类
op1->op2->op3

GenericServlet：将Servlet接口中其他的方法做了默认空实现，只将service()方法作为抽象。继承后实现service()方法即可。

HttpServlet：对http协议的一种封装，简化操作。复写doGet/doPost方法。

6. HTTP协议

1 2	Hyper Text Transfer Protocol 超文本传输协议：定义了客户端和服务器端通信时，发送数据的格式客户端和服务器必须同时遵守HTTP协议，才能通信

特点：

基于TCP/IP的高级协议

默认端口号：80

基于请求/响应模型的：一次请求对应一次响应

无状态的：每次请求之间相互独立，不能交互数据

版本：

1.0：每一次请求响应都会建立新的连接Connection，较耗费资源

1.1：复用连接，Connection复用，省略了重复创建连接所耗费的资源

2.0：1.X版本都是使用文本传输数据，2.0开始使用字节传输，多路复用，速率提升

7. 请求消息数据格式

POST /login.html	HTTP/1.1  <!--1.请求行：请求方式+请求url+请求协议/版本-->
Host: localhost     <!--2.请求头：IP地址+User-Agent浏览器信息+Referer来源+...-->
User-Agent: Mozilla/5.0 (Windows NT 6.1; Win64; x64; rv:60.0) Gecko/20100101 Firefox/60.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,;q=0.8
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
Referer: http://localhost/login.html<!--告诉服务器请求的来源-->
Connection: keep-alive
Upgrade-Insecure-Requests: 1	<!--2.请求头-->
<!--3.请求空行：分割请求头和请求体-->
username=zhangsan	<!--4.请求体(正文)：封装POST请求消息的请求参数-->

常见的请求头：

User-Agent：浏览器告诉服务器，我访问你使用的浏览器版本信息。服务器端可以获取该信息，针对不同浏览器设置参数，解决浏览器的兼容性问题。

Referer：http://localhost/login.html：告诉服务器当前请求的来源。作用：防盗链，统计工作。

8. Request对象

1	request对象用来获取请求消息，response对象用来设置响应消息，request和response对象都是由服务器创建的。

request对象继承体系结构：

ServletRequest 接口
| 继承
HttpServletRequest 接口
| 实现
org.apache.catalina.connector.RequestFacade 类(tomcat)
在用户发出请求的时候会自动的创建RequestFacade对象

获取请求消息数据的方法

//获取请求方式 
String method = request.getMethod();	// GET
//获取虚拟目录 
String contextPath = request.getContextPath();	// day03
//获取Servlet路径 
String servletPath = request.getServletPath();	// /Demo01Servlet
//获取get方式请求参数 
String queryString = request.getQueryString();	// username=zhangsan
//获取请求URI、URL
String requestURI = request.getRequestURI();	// /day03/Demo01Servlet
StringBuffer requestURL = request.getRequestURL();
//http://localhost:8080/day03/Demo01Servlet
//获取协议及版本 
String protocol = request.getProtocol();	// HTTP/1.1
//获取客户机的IP地址 
String remoteAddr = request.getRemoteAddr();	// 0:0:0:0:0:0:0:1

URL：统一资源定位符：http://localhost/day14/demo1 （中华人民共和国）

URI：统一资源标识符：/day14/demo1 （共和国）

获取请求头数据的方法

String getHeader(String name):通过请求头的名称获取请求头的值
Enumeration<String> getHeaderNames():获取所有的请求头名称，封装为键值对
    //使用示范：
    Enumeration<String> headerNames = request.getHeaderNames();
        while (headerNames.hasMoreElements()) {
            String name = headerNames.nextElement();
            String value = request.getHeader(name);
            System.out.println(name + "------" + value);}
    /*输出结果：
    host------localhost:8080
    connection------keep-alive
    cache-control------max-age=0
    upgrade-insecure-requests------1
    user-agent------Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML,     like Gecko) Chrome/74.0.3729.108 Safari/537.36
    accept-----text/html,application/xhtml+xml,application/xml;
    accept-encoding------gzip, deflate, br
    accept-language------zh-CN,zh;q=0.9
    cookie------_xsrf=2|50c9000a|7b65bf12b3842e1198f0522667c61f08|1554439214; */

获取请求体数据的方法

//请求体：只有POST请求方式，才有请求体，在请求体中封装了POST请求的请求参数
//步骤：1. 获取流对象
	BufferedReader getReader()：获取字符输入流，只能操作字符数据
	ServletInputStream getInputStream()：获取字节输入流，可以操作所有类型数据
	//2. 再从流对象中拿数据

获取请求参数通用方式

1. String getParameter(String name):根据参数名称获取参数值 
2. String[] getParameterValues(String name):根据参数名称获取参数值的数组  
3. Enumeration<String> getParameterNames():获取所有请求的参数名称
4. Map<String,String[]> getParameterMap():获取所有参数的map集合

中文乱码问题：post方式会乱码，我们在获取前端传递的参数之前，都进行设置编码

request.setCharacterEncoding("utf-8");

请求转发的方法

1	request.getRequestDispatcher("String path").forward(request,response);

浏览器地址栏路径不发生变化

只能转发到当前服务器内部资源中

转发是一次请求，多个资源用的是同一个请求

共享数据的方法

1
2
3

1. void setAttribute(String name,Object obj):存储数据
2. Object getAttitude(String name):通过键获取值
3. void removeAttribute(String name):通过键移除键值对

域对象：一个有作用范围的对象，可以在范围内共享数据

request域：代表一次请求的范围，一般用于请求转发的多个资源中共享数据

9. BeanUtils工具类

1 2	用于封装标准JavaBean的工具类，按照属性进行映射。属性：setter和getter方法截取后的产物，例如：getUsername() --> Username--> username

方法：

setProperty()

getProperty()

populate(Object obj , Map map)：将map集合的键值对信息，封装到对应的JavaBean对象中

10. 响应消息数据格式

HTTP/1.1 200 OK  	<!--1.响应行：协议/版本+响应状态码+状态码描述-->
Content-Type: text/html;charset=UTF-8<!--2.响应头-->
Content-Length: 101
Date: Wed, 06 Jun 2018 07:08:42 GMT
	<!--3.响应空行-->
<html>			<!--4.响应体:传输的数据-->
	<head>
		<title>$Title$</title>
	</head>
	<body>
		hello , response
	</body>
</html>			<!--4.响应体:传输的数据-->

响应状态码：服务器告诉客户端浏览器本次请求和响应的一个状态，状态码都是3位数字。

1xx：服务器接收客户端消息，但没有接受完成，等待一段时间后，发送1xx多状态码

2xx：成功。代表：200

3xx：重定向。代表：302(重定向)，304(访问缓存)

4xx：客户端错误。代表：404(请求路径没有对应的资源)，405：(请求方式没有对应的doXxx方法)

5xx：服务器端错误。代表：500(服务器内部出现异常，写的代码有bug)

常见的响应头：

Content-Type：服务器告诉客户端本次响应体数据格式以及编码格式

Content-disposition：服务器告诉客户端以什么格式打开响应体数据

in-line：默认值，在当前页面内打开

attachment；filename=xxx：以附件形式打开响应体：文件下载

11. Response对象

1	request对象和response对象由tomcat创建，每次请求相互独立

Response方法：

设置状态码：setStatus(int sc)

设置响应头：setHeader(String name, String value)

设置响应体：

字符输出流：PrintWriter getWriter()

字节输出流：ServletOutputStream getOutputStream()

设置输出流的编码：response.setContentType("text/html;charset=utf-8");

setContentType方法同时起到两个作用：1. 设置该流的默认编码 2. 告诉浏览器响应体使用的编码

12. 重定向

重定向：资源跳转的方式
//基本的重定向方法：1. 设置状态码为302；2.设置响应头location
response.setStatus(302);
response.setHeader("location","/responseDemo2");
//简化的重定向方法：
response.sendRedirect("/responseDemo2");

转发(forward)和重定向(redirect)的特点：

转发的特点：

转发地址栏路径不变

转发只能访问当前服务器下的资源

转发是一次请求，可以使用request对象来共享数据

跳转路径不需要加虚拟目录

重定向的特点

重定向地址栏路径变化

重定向可以访问其他站点(服务器)的资源

重定向是两次独立的请求，不能使用request对象来共享数据

跳转路径需要加虚拟目录

13. ServletContext对象

1	代表整个web应用，可以和程序的容器(服务器)来通信

ServletContext方法：

获取ServletContext：

通过request对象获取：equest.getServletContext();

通过HttpServlet获取：this.getServletContext();

获取MIME类型：

MIME类型:在互联网通信过程中定义的一种文件数据类型（大类型/小类型：image/jpeg）

String getMimeType(String file)

域对象：共享数据（对象范围：所有用户所有请求的数据）

setAttribute(String name,Object value)

getAttribute(String name)

removeAttribute(String name)

（由于ServletContext域对象范围太大，一般不用）

获取文件的真实(服务器)路径：String getRealPath(String path)

获取web目录下资源：getRealPath("/a.txt");

获取WEB-INF目录下资源：getRealPath("/WEB-INF/a.txt");

获取src目录下资源：getRealPath("/WEB-INF/classes/a.txt");

14. 案例：文件下载

//获取请求参数中的文件名称，找到该文件的真实路径，关联给字节输入流
String filename = request.getParameter("filename");	
   ServletContext servletContext = this.getServletContext();
   String realPath = servletContext.getRealPath("/img/" + filename);
   FileInputStream fis = new FileInputStream(realPath);	

//设置response响应头的"content-type"参数为图片的Mime格式
   String mimeType = servletContext.getMimeType(filename);	
   response.setHeader("content-type", mimeType);

//通过工具将filename改造成对应浏览器能够解读的格式
   String userAgent = request.getHeader("user-agent");	
   filename = DownLoadUtils.getFileName(userAgent, filename);
//设置response响应头的"content-disposition"参数为附件形式
   response.setHeader("content-disposition","attachment;filename=" + filename);

   //将输入流的数据写出到输出流中
   ServletOutputStream sos = response.getOutputStream();
   byte[] buff = new byte[1024 * 8];
   int len = 0;
   while ((len = fis.read(buff)) != -1) {
       sos.write(buff, 0, len);
   }
   fis.close();

1	概念：客户端会话技术，将数据保存到客户端。基于响应头set-cookie和请求头cookie实现

方法：

创建Cookie对象，绑定数据：new Cookie(String name, String value)

发送Cookie对象：response.addCookie(Cookie cookie)

获取Cookie对象，拿到数据：request.getCookies()，返回Cookie[] 数组

持久化存储Cookie对象：setMaxAge(int seconds)(Cookie数据默认在览器关闭后被销毁)

正数：将Cookie数据写到硬盘的文件中，持久化存储，并指定cookie存活时间。

负数：默认值

零：删除cookie信息

共享：

同一服务器的Cookie共享：一个服务器中多个web项目默认无法共享Cookie对象，可以设置Cookie的获取范围：setPath(String path)。方法默认为当前虚拟目录，设置为”/“让一个服务器下所有项目共享

不同服务器的Cookie共享：setDomain(String path):如果设置一级域名相同，那么多个服务器之间cookie可以共享。(如setDomain(“.baidu.com”),那么tieba.baidu和news.baidu中cookie可以共享)

特点：

在tomcat 8 之前，cookie中不能直接存储中文数据。在tomcat 8 之后，cookie支持中文数据。特殊字符还是不支持，建议使用URL编码存储，URL解码解析。

URL编码：URLEncoder.encode(string, "utf-8");

URL解码：URLDecoder.decode(string, "utf-8");

cookie数据存储在客户端浏览器，一般情况下浏览器对单个cookie 的大小限制4kb，对同一个域名下的总cookie数量限制20个。

cookie一般用于存储少量的不太敏感的数据，用于不登录的情况下，完成服务器对客户端的身份识别。

16. Session

1	服务器端会话技术，在一次会话的多次请求间共享数据，将数据保存在服务器端的对象中,依赖于Cookie实现。

方法：

获取HttpSession对象：request.getSession();

使用HttpSession对象：

Object getAttribute(String name)

void setAttribute(String name, Object value)

void removeAttribute(String name)

存活：
客户端关闭后，服务器不关闭：

默认情况下两次获取session不是同一个。如果需要相同，则可以创建Cookie，键的名称一定为JSESSIONID，设置最大存活时间，让cookie持久化保存。
1
2
3
4
>    Cookie c = new Cookie("JSESSIONID",session.getId());
>    c.setMaxAge(60*60);
>    response.addCookie(c);
>

客户端不关闭，服务器关闭后：

两次获取的session不是同一个，但是要确保数据不丢失，tomcat自动完成以下工作：

session的钝化：关闭服务器的时候，生成保存sessuib数据的文件.ser

session的活化：再度开启服务器的时候，读取保存的.ser文件，并销毁文件

销毁：

服务器关闭时销毁

session对象调用invalidate() 方法时销毁

session默认失效时间 30分钟

session与Cookie的区别：
1. session存储数据在服务器端，Cookie在客户端
2. session没有数据大小限制，Cookie有
3. session数据安全，Cookie相对于不安全

17. JSP

1 2	Java Server Pages：java服务器端页面，既可以定义html标签，又可以使用java代码。 JSP本质上是一个Servlet，IDEA编译：jsp页面->Servlet.java文件->.class文件

脚本：

<% 代码 %>：定义的java代码，在service方法中。每一次访问该jsp都会执行此脚本中的代码

<%! 代码 %>：定义的java代码，在jsp转换后的java类的成员变量位置。

<%= 代码 %>：定义的java代码，会输出到页面上。（out.print方法的简写）

指令：用于配置JSP页面，导入资源文件，格式：<%@ 指令名称属性名1=属性值1 属性名2=属性值2 ... %>
page：
contentType：设置响应体的mime类型以及字符集，在高级IDE中可设置当前jsp页面的编码

import：导包

errorPage：当前页面发生异常后，会自动跳转到指定的错误页面
isErrorPage：标识当前页面是否是错误页面。(值为true，页面可使用内置对象exception)
1
2
3
4
5
6
7
>     <%--代码演示--%> 
>     <%@ page contentType="text/html;charset=gbk" errorPage="500.jsp"   pageEncoding="GBK" language="java" buffer="16kb" %>
>     
>     <%@ page contentType="text/html;charset=UTF-8" isErrorPage="true" language="java" %>
>     
>     <%@ page import="java.util.ArrayList" %>
>

include：导入其他页面的资源文件 <%@include file="top.jsp"%>

taglib：导入资源 <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>

注释：

html注释：会显示到网页源码中，只能注释html代码片段

<%– –%> jsp注释：不会显示到网页源码中，可以注释所有代码，推荐使用

内置对象：

变量名真实类型作用

pageContext PageContext 共享当前页面数据，还可以获取其他八个内置对象

request HttpServletRequest 共享一次请求访问的多个资源数据(转发)

session HttpSession 共享一次会话的多个请求间数据

application ServletContext 整个web项目，所有用户间共享数据

response HttpServletResponse 响应对象

page Object 当前页面(Servlet)的对象 this

out JspWriter 输出对象，数据输出到页面上

config ServletConfig Servlet的配置对象

exception Throwable 异常对象
1
2
> tomcat服务器，会先找response缓冲区数据，再找out缓冲区数据,所以response.getWriter()数据输出永远在out.write()之前，推荐使用：out.write()。
>

变量名	真实类型	作用
pageContext	PageContext	共享当前页面数据，还可以获取其他八个内置对象
request	HttpServletRequest	共享一次请求访问的多个资源数据(转发)
session	HttpSession	共享一次会话的多个请求间数据
application	ServletContext	整个web项目，所有用户间共享数据
response	HttpServletResponse	响应对象
page	Object	当前页面(Servlet)的对象 this
out	JspWriter	输出对象，数据输出到页面上
config	ServletConfig	Servlet的配置对象
exception	Throwable	异常对象

18. MVC开发模式

M：Model，模型。JavaBean 定义的标准的java描述类，用于完成具体的业务操作。

V：View，视图。JSP页面，用于展示数据。

C：Controller，控制器。Servlet：获取用户输入的数据；调用模型处理数据；将数据交给视图展示

优点：耦合性低，方便维护，可以利于分工协作，重用性高

缺点：使得项目架构变得复杂，对开发人员要求高

19. EL表达式

1 2	Expression Language 表达式语言，用于替换和简化jsp页面中java代码的编写 jsp默认支持EL表达式的，语法：${表达式}

方法：

${empty list}：判断字符串、集合、数组对象是否为null或者长度为0

${not empty str}：表示判断字符串、集合、数组对象是否不为null，并且长度>0

${域名称.键名}：从指定域中获取指定键的值，域名称有：

pageScope –> pageContext //当前页面

requestScope –> request //当前次请求

sessionScope –> session //当前次会话

applicationScope –> application（ServletContext） //整个web项目

${域名称.键名.属性名}：获取对象的属性值，不等于成员变量，本质上是调用对象的getter方法

${域名称.键名[索引]}：获取List集合的元素

${域名称.键名.key名称} ${域名称.键名["key名称"]}：获取Map集合的值

\${表达式}或设置JSP的page指令中isELIgnored="true"：忽略当前JSP页面中所有的EL表达式

隐式对象：

EL表达式中有11个隐式对象，我们需要使用pageContext获取其他对象

动态获取虚拟目录：${pageContext.request.contextPath}

20. JSTL

1 2	JavaServer Pages Tag Library：JSP标准标签库，由Apache组织提供的开源的免费的jsp标签用于简化和替换jsp页面上的java代码

使用步骤：

导入jstl相关jar包

引入标签库taglib指令：<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>

使用标签

常用标签：
if：test为必须属性，接受boolean表达式，表达式为true时展示标签内容，false则不展示
1
2
3
4
>   <c:if test="true">
>       <h2>I am true!</h2>
>   </c:if>
>

choose：相当于java代码的switch语句
foreach：相当于java代码的for语句
1
2
3
4
5
6
>   <c:forEach items="${list}" var="str" varStatus="s">
>       ${s.index}	<%--索引--%>
>       ${s.count}	<%--循环次数--%>
>       ${str}  	<%--元素--%>
>   </c:forEach>
>

21. 三层架构

1
2
3

1. 界面层(web层)：用户看的得界面，用户可以通过界面上的组件和服务器进行交互。
2. 业务逻辑层（service层）：处理业务逻辑的。
3. 数据访问层(dao层)：操作数据存储文件。

22. Filter 过滤器

1	当客户端访问服务器的资源时，过滤器可以将请求拦截下来，完成一些特殊的功能

实现步骤：

定义一个类，实现接口Filter（import javax.servlet.annotation.WebFilter;）

复写方法

配置拦截路径

配置拦截路径：
方式一：web.xml
1
2
3
4
5
6
7
8
9
>      
>

方式二：注解：@WebFilter("/*")

路径详解：

拦截具体文件：/index.jsp

拦截目录：/user/*

拦截后缀名：*.jsp

拦截所有资源：/*

配置拦截方法：

注解配置：设置dispatcherTypes属性

REQUEST：默认值。浏览器直接请求资源

FORWARD：转发访问资源

INCLUDE：包含访问资源

ERROR：错误跳转资源

ASYNC：异步访问资源

web.xml配置：设置<dispatcher> </dispatcher>标签即可

只有同时满足拦截路径&拦截方式的资源，才会被过滤器拦截

方法：

init()：在服务器启动后，会创建Filter对象，然后调用init方法，只执行一次，用于加载资源。

doFilter()：每一次请求被拦截资源时会执行，执行多次。

destroy()：服务器正常关闭后，Filter对象被销毁，执行destroy方法，只执行一次，用于释放资源。

filterChain.doFilter(servletRequest,servletResponse)：过滤放行

执行顺序：

注解配置执行顺序：过滤器1–>过滤器2–>资源执行–>过滤器2–> 过滤器1

按照类名的字符串比较规则比较，值小的先执行

web.xml配置执行顺序：<filter-mapping>谁定义在上边，谁先执行

//过滤未登录用户代码展示
public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws ServletException, IOException {
    //0.强制转换
    HttpServletRequest request = (HttpServletRequest) req;
    //1.获取资源请求路径
    String uri = request.getRequestURI();
    //2.排除和登录以及页面布局式样相关的路径
    if (uri.contains("/loginServlet") || uri.contains("/login.jsp") || 		
        uri.contains("/checkCodeServlet") ||uri.contains("/css/") || 
        uri.contains("/fonts/") || uri.contains("/js/")) {
        chain.doFilter(req, resp);
    } else {
        //3.从request中获取用户登录后封装的user对象
        Object user = request.getSession().getAttribute("user");
        if (user != null) {
            chain.doFilter(req, resp);
        } else {
            request.setAttribute("login_msg","您尚未登录，请您先登录");
            request.getRequestDispatcher("/login.jsp").forward(req, resp);
        }
    }
}

23. 代理模式

1
2
3

代理对象通过代理真实对象，达到增强真实对象功能的目的，代理对象有两种实现方式：
1. 静态代理：有一个类文件描述代理模式
2. 动态代理：在内存中形成代理类，通过Proxy.newProxyInstance()方法生成代理对象

//通过代理模式实现敏感词过滤代码展示
public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws ServletException, IOException {

//创建代理对象，三个参数：1.真实对象的类加载器；2.真实对象实现的接口； 3.实现动态代理的接口
HttpServletRequest request = (HttpServletRequest) Proxy.newProxyInstance
(req.getClass().getClassLoader(),req.getClass().getInterfaces(),new InvocationHandler() {
	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
	/*invoke方法的三个参数：
		* 1. proxy：真实的代理对象
		* 2. method：代理对象调用的方法，被封装为的对象
		* 3. args:代理对象调用的方法时，传递的实际参数
	*/
	//获取方法的名称
		if ("getParameter".equals(method.getName())) {
			String value = (String) method.invoke(req,args);
			//检测是否含敏感词
			if(value.contains("CNM")){
				value = value.replaceAll("CNM","***");
			}			
		//返回代理修改后的value
		return value;
		}
	//若不是"getParameter"方法，则直接返回，不修改
	return method.invoke(req,args);
}});
chain.doFilter(request, resp);}	//放行时参数要用代理对象的request，来替换原req

24. Listener 监听器

1	web三大组件之一，当事件源上发生某个事件后，执行监听器代码。

ServletContextListener：监听ServletContext对象的创建和销毁
@WebListener //注解
//1. 定义一个类，实现ServletContextListener接口
public class ContextLoaderListener implements ServletContextListener {
	//2. 对象创建后会调用该方法
	void contextInitialized(ServletContextEvent sce)：ServletContext
	//3. 对象被销毁之前会调用该方法
	void contextDestroyed(ServletContextEvent sce)：ServletContext

25. Maven

Maven是一个项目管理工具，它包含了：一个项目对象模型 (POM：Project Object Model)，一组标准集合，一个项目生命周期(Project Lifecycle)，一个依赖管理系统(Dependency Management System)，和用来运行定义在生命周期阶段(phase)中插件(plugin)目标(goal)的逻辑。

环境变量及相关配置

M2_HOME：C:\Java\maven\apache-maven-3.5.2

MAVEN_HOME：C:\Java\maven\apache-maven-3.5.2

/conf/settings.xml文件中<localRepository>标签中配置本地仓库位置

idea的maven配置：

Maven home directory：指定本地maven安装目录

User settings file：指定setting配置文件路径

Local respository：本地仓库的位置

创建maven的web工程时，选用archetype：maven-archetype-webapp

仓库的分类

本地仓库：通过maven下载的jar包会储存在本地仓库，项目会优先从本地仓库查找jar包

远程仓库：远程仓库可以在互联网内也可以在局域网内

中央仓库：maven中内置一个远程仓库：http://repo1.maven.org/maven2，服务于整个互联网，由Maven团队自己维护，里面存储了非常全的jar包，包含了世界上大部分的流行开源项目的构件。

maven插件

compile：maven工程的编译命令，将src/main/java的文件编译为class文件输出到target目录下。

test：maven工程的测试命令，会执行src/test/java下的单元测试类。

clean：maven工程的清理命令，执行 clean会删除target目录及内容。

package：maven工程的打包命令，对java工程执行package打成jar包，对web工程打成war包。

install：maven工程的安装命令，执行install将maven打成jar包或war包发布到本地仓库。

按上述插件排列顺序，当后面的命令执行时，前面的操作过程也都会自动执行。

Maven指令的生命周期

Clean Lifecycle：在进行真正的构建之前进行一些清理工作。

Default Lifecycle：构建的核心部分，编译，测试，打包，部署等等。

Site Lifecycle：生成项目报告，站点，发布站点。

上述三套生命周期相互独立

依赖范围

依赖范围编译时有效测试时有效运行时有效例子

compile(默认) √ √ √ spring-core

test - √ - Junit

provided √ √ - servlet-api

runtime - √ √ JDBC驱动

system √ √ - 不推荐使用

因为tomcat自带servlet和jsp的jar包，所以这两类api设定运行时无效，防止冲突
坐标定义
1
2
3
4
5
6
7
8
9
10
11
>   <dependency>
>      
>      <groupId>javax.servlet</groupId>
>      
>      <artifactId>javax.servlet-api</artifactId>
>      
>      <version>3.0.1</version>
>      
>      <scope>provided</scope>
>   </dependency>
>

依赖范围	编译时有效	测试时有效	运行时有效	例子
compile(默认)	√	√	√	spring-core
test	-	√	-	Junit
provided	√	√	-	servlet-api
runtime	-	√	√	JDBC驱动
system	√	√	-	不推荐使用

pom基本配置：Maven项目的核心配置文件

>   <project>：文件的根节点 
>   <modelversion>：pom.xml使用的对象模型版本 
>   <groupId>：项目名称，一般写项目的域名 
>   <artifactId>：模块名称，子项目名或模块名称 
>   <version>：产品的版本号 
>   <packaging>：打包类型，一般有jar、war、pom 等 
>   <name>：项目的显示名，常用于 Maven 生成的文档
>   <description>：项目描述，常用于 Maven 生成的文档
>   <dependencies>：项目依赖构件配置，配置项目依赖构件的坐标
>   <build>：项目构建配置，配置编译、运行插件等
>

26. 综合案例

BaseServlet

//让项目中所有的Servlet删除service方法，并继承BaseServlet，当浏览器访问时会调用父类的service方法
protected void service(HttpServletRequest req, HttpServletResponse resp)  {
    //获取请求路径
    String uri = req.getRequestURI();
    //获取方法名称
    String methodName = uri.substring(uri.lastIndexOf('/') + 1);
    //通过反射，调用子类的方法
    Method method = this.getClass().getMethod(methodName, 		                                       HttpServletRequest.class,HttpServletResponse.class);    
    method.invoke(this, req, resp);}

Jquery的serialize方法

1
2
3

$.get("user/regist", $(this).serialize(), function (data) {...});
//.serialize()可以将表单数据序列化为键值对的形式:username=eric&password=123...
//通常用于接收（登录、注册）用户提交的表单数据的序列化，便于getParameterMap()方法获取参数

Redis与数据库交互

public List<Category> findAll() {
    List<Category> cs = null;
    Jedis jedis = JedisUtil.getJedis();
    //zrangeWithScores方法可以获取值和对应的score，存入Tuple对象中。
    //Tuple对象含一个Double score和一个byte[] element 成员变量
    Set<Tuple> categorys = jedis.zrangeWithScores("category", 0, -1);
    if (categorys == null || categorys.size() == 0) {
        //redis缓存中没有数据，从数据库中读取
        cs = categoryDao.findAll();
        //将数据缓存到jedis内存中
        for (int i = 0; i < cs.size(); i++) {
            jedis.zadd("category", cs.get(i).getCid(), cs.get(i).getCname());
        }
    } else {
        //redis缓存中有数据，将数据格式统一转换为List格式返回
        cs = new ArrayList<>();
        for (Tuple tuple : categorys) {
            Category category = new Category();
            category.setCname(tuple.getElement());
            category.setCid((int) tuple.getScore());
            cs.add(category);
        }
    }
    return cs;
}

根据参数name获取对应的值

function getParameter(name) {
    var reg = new RegExp("(^|&)" + name + "=([^&]*)(&|$)","i");
    var r = location.search.substr(1).match(reg);
    if (r!=null) return (r[2]); 
    return null;
}

SQL语句的拼接

public int findTotalCount(int cid, String rname) {
    //定义模板代码
    String sql = "select count(*) from tab_route where TRUE ";
    StringBuilder sb = new StringBuilder(sql);//用于拼接不同条件
    ArrayList params = new ArrayList();//用于存放参数
    if (cid != 0) {
        sb.append(" and cid = ? ");
        params.add(cid);
    }
    if (rname != null && rname.length() != 0 && !rname.equals("null")) {
        sb.append(" and rname like ? ");
        params.add("%" + rname + "%");
    }
    sql = sb.toString();
    int count = -1;
    try {
        count = template.queryForObject(sql, Integer.class, params.toArray());
    } catch (Exception e) {

    }
    return count;
}

解决中文乱码的两种方式

第一种：在pom.xml下配置uriEncoding标签为utf-8

<configuration>
    <!-- 通过maven tomcat7:run运行项目时，访问项目的端口号 -->
    <port>80</port>
    <!-- 项目访问路径  本例：localhost:9090,  如果配置的aa， 则访问路径为localhost:9090/aa-->
    <path>/travel</path>
    <uriEncoding>utf-8</uriEncoding>
</configuration>

第二种：post提交方式下，request.setCharacterEncoding(“utf-8”);

三种前端往后端传参的方式

异步请求
表单提交
a标签

27. Linux

Linux是基于Unix的一种自由和开放源码的操作系统，存在着许多不同的Linux版本，但它们都使用了Linux内核。Linux的版本分为两种：内核版本和发行版本；内核版本是指在Linus领导下的内核小组开发维护的系统内核的版本号。

Linux常用命令

命令	功能
【cd】
cd app	切换到app目录（tab键可补全文件路径）
cd ..	切换到上一层目录
cd /	切换到系统根目录
cd ~	切换到用户主目录
cd -	切换到上一个所在目录
【ls】
ls	显示当前目录下的内容（在linux中以 . 开头的文件都是隐藏的文件）
ls -a	显示所有文件或目录（包含隐藏的文件）
ls -l (缩写ll)	显示当前目录下文件的详情信息
【dir】
mkdir app	在当前目录下创建app子目录
rmdir app	app
mkdir –p aaa/bbb	在当前目录下级联创建aaa/bbb子目录
【content】
cat	用于显示文件的内容
more	显示文件部分的内容，按空格显示下一页，回车显示下一行，q退出查看
less	用法和more类似，不同的是less可以通过PgUp、PgDn键来控制
tail -N	用于显示文件后N行的内容
tail -f	动态查看文件日志
【rm】
rm a.txt	删除文件（询问用户）
rm -f a.txt	直接删除（不询问用户）
rm -r a	询问递归删除
rm -rf a	不询问递归删除
rm -rf *	删除当前目录下所有文件
rm -rf /*	自杀式删除
【cp，mv】
cp a.txt b.txt	将a.txt复制成名为b.txt的文件
cp a.txt ../	将a.txt文件复制到上一层目录中
mv a.txt b.txt	将a.txt文件重命名为b.txt
mv a.txt ../	将a.txt文件移动到上一层目录中
【tar】
-c	创建一个新tar文件
-v	显示运行过程的信息
-f	指定文件名
-z	调用gzip压缩命令进行压缩
-t	查看压缩文件的内容
-x	解开tar文件
tar –cvf xxx.tar 打包文件	打包
tar –zcvf xxx.tar.gz 打包文件	打包并且压缩
tar –xvf xxx.tar	拆包
tar -zxvf xxx.tar.gz -C 目标路径	解压
【find】
find / -name “ins*”	查找文件名称是以ins开头的文件
find / –user itcast –ls	查找用户itcast的文件
find / –user itcast –type d –ls	查找用户itcast的目录
find /-perm -777 –type d-ls	查找权限是777的文件
【grep】
grep lang 文件名	在文件中查找lang
grep lang 文件名 –color	高亮显示
【other】
pwd	显示当前所在目录
touch a.txt	创建一个空文件
clear/ crtl + L	清屏
crtl + C	退出
ifconfig	查询IP地址

Vim编辑器

在Linux下一般使用vi编辑器来编辑文件，vi既可以查看文件也可以编辑文件。

vi有三种模式：命令行、插入、底行模式。

通过 vim 文件名 命令进入Vim编辑器，此时默认为命令行模式。

命令行模式—-按 i 、o、a键—->插入模式—-按Esc键—->命令行模式

命令行模式—-按 :（冒号）—->底行模式：退出：q；保存并退出：wq；不保存退出：q!

重定向输出

> 重定向输出，覆盖原有内容；>> 重定向输出，追加在原内容后；

示例：

cat /b.txt > a.txt 将b.txt文件中内容输出定向到a.txt中

ifconfig > ifconfig.txt 将网络配置信息输出定向到ifconfig.txt中

系统管理命令

ps 正在运行的某个进程的状态

ps –ef 查看所有进程

ps –ef | grep ssh 查找某一进程

kill 2868 杀掉2868编号的进程

kill -9 2868 强制杀死进程

管道 |

1
2
3

管道是Linux命令中重要的一个概念，其作用是将一个命令的输出用作另一个命令的输入。示例：
ls --help | more  分页查询帮助信息
ps –ef | grep java  查询名称中包含java的进程

Linux权限命令

文件权限

文件类型	user	user	user	group	group	group	other	other	other
-	r	w	x	r	w	x	r	w	x
score	4	2	1	4	2	1	4	2	1

user：属主权限

group：属组权限

other：其他用户权限

r：对文件是指可读取内容对目录是可以ls

w：对文件是指可修改文件内容，对目录是指可以在其中创建或删除子节点(目录或文件)

x：对文件是指是否可以运行这个文件，对目录是指是否可以cd进入这个目录

chmod 变更文件或目录的权限：chmod 755 a.txt chmod u=rwx,g=rx,o=rx a.txt

Linux三种文件类型

普通文件：包括文本文件、数据文件、可执行的二进制程序文件等。

目录文件： Linux系统把目录看成是一种特殊的文件，利用它构成文件系统的树型结构。

设备文件： Linux系统把每一个设备都看成是一个文件

文件类型标识

进入etc可以查看：普通文件（-）、目录（d）、符号链接（l）、字符设备文件（c）、块设备文件（s）、套接字（s）命名管道（p）

Linux网络操作

hostname 查看主机名

hostname xxx 修改主机名重启后无效（如果想要永久生效，可以修改/etc/sysconfig/network文件）

vim /etc/sysconfig/network-scripts/ifcfg-eth0 持久化修改ip地址

service iptables stop 关闭防火墙

service network status 查看指定服务的状态

service network stop 停止指定服务

service network start 启动指定服务

service network restart 重启指定服务

软件安装

安装方式：

二进制发布包：

软件已经针对具体平台编译打包发布，只要解压，修改配置即可。

RPM包：

软件已经按照redhat的包管理工具规范RPM进行打包发布，需要获取到相应的软件RPM发布包，然后用RPM命令进行安装。

Yum在线安装：

软件已经以RPM规范打包，但发布在了网络上的一些服务器上，可用yum在线安装服务器上的rpm软件，并且会自动解决软件安装过程中的库依赖问题。

源码编译安装：

软件以源码工程的形式发布，需要获取到源码工程后用相应开发工具进行编译打包部署。

上传与下载：

FileZilla：文件交互图形化软件，解压后可直接使用，通过拖动文件完成本地与虚拟机的文件交互

lrzsz：使用yum方式安装：yum install lrzsz，可以在crt中设置上传与下载目录：选项→会话选项→X/Y/Zmodem，设置上传和下载目录。在CRT界面输入rz获取上传目录，输入sz获取下载目录

sftp：使用alt + p 组合键打开sftp窗口，使用put 命令上传，使用get命令下载，默认下载位置在当前计算的的文档位置

在Linux上安装JDK

卸载系统自带jdk：

rpm -e --nodeps java-1.6.0-openjdk-1.6.0.35-1.13.7.1.el6_6.i686

rpm -e --nodeps java-1.7.0-openjdk-1.7.0.79-2.5.5.4.el6.i686

在Linux服务器上安装JDK：

直接解压就可以：tar –zxvf jdk.tar.gz -C 目标路径
配置JDK的环境变量：
vi /etc/profile
在末尾行添加下列文本后，保存退出
1
2
3
4
5
6
>       #set java environment
>       JAVA_HOME=/usr/local/jdk/jdk1.7.0_71
>       CLASSPATH=.:$JAVA_HOME/lib.tools.jar
>       PATH=$JAVA_HOME/bin:$PATH
>       export JAVA_HOME CLASSPATH PATH
>

source /etc/profile 使更改的配置立即生效

在Linux上安装Mysql

卸载系统自带mysql：

rpm -e --nodeps mysql-libs-5.1.73-5.el6_6.i686

安装MYSQL服务端：

rpm -ivh MySQL-server-5.6.22-1.el6.i686.rpm

查看系统随机生成的root初始密码：

cat /root/.mysql_secret

开启mysql服务：

service mysql start

登录mysql：

mysql -u root -p随机初始密码

第一次操作mysql前修改root用户密码：

set password=password('root')

设置mysql远程访问：

grant all privileges on *.* to 'root' @'%' identified by 'root';

flush privileges;

关闭防火墙：

service iptables stop;

在Linux上安装tomcat

在Linux服务器上安装tomcat：

直接解压就可以：tar –zxvf apache-tomcat-7.0.57 -C 目标路径

启动tomcat：

在tomcat/bin目录下执行 startup.sh（注意防火墙）

查看目标：

tomcat/logs/catalina.out

在Linux上安装redis

安装gcc-c++：yum install gcc-c++

下载redis：wget http://download.redis.io/releases/redis-3.0.4.tar.gz

解压：tar -xzvf redis-3.0.4.tar.gz

切换至程序目录，执行make命令进行编译：make

执行安装命令：make PREFIX=/usr/local/redis install

复制配置文件到redis/bin目录下：cd redis-3.0.4 cp redis.conf/usr/local/redis/bin

bin目录下启动redis服务端：./redis-server redis.conf

克隆新窗口，启动redis客户端：./redis-cli

28. Nginx

Nginx 是一款高性能的 http 服务器/反向代理服务器及电子邮件（IMAP/POP3）代理服务器，由俄罗斯的程序设计师伊戈尔·西索夫（Igor Sysoev）所开发，官方测试 nginx 能够支支撑5万并发链接，cpu、内存等资源消耗却非常低，运行非常稳定。

Nginx 应用场景

Nginx 可以做网页静态服务器，独立提供 http 服务。

可以实现在一台服务器虚拟出多个网站。

反向代理，负载均衡。高并发需要用多台服务器集群时可以使用 nginx 做反向代理，并且可以设定每台服务器分担负载的概率，不会出现某台服务器负载高宕机而某台服务器闲置的情况。

Nginx启动与访问

创建临时目录：mkdir /var/temp/nginx/client -p

进入到Nginx目录下的sbin目录：cd /usr/local/ngiux/sbin

输入命令启动Nginx：./nginx

启动后查看进程：ps aux|grep nginx

关闭 nginx：./nginx -s stop ./nginx -s quit

重启 nginx：./nginx -s reload

反向代理

以代理服务器来接受internet上的连接请求，然后将请求转发给内部网络上的服务器，并将从服务器上得到的结果返回给internet上请求连接的客户端，此时代理服务器对外就表现为一个反向代理服务器。

IP绑定域名：本地可以通过修改 hosts 文件（C:\Windows\System32\drivers\etc），配置域名和 ip 的映射关系，如果 hosts 文件中配置了域名和 ip 的对应关系，不需要走dns 服务器。

例如：192.168.177.129 www.hmtravel.com
1
2
3
4
5
6
7
8
9
10
11
12
13
> 配置反向代理：
> upstream tomcat-travel{
> 	server 192.168.177.129:8080;
> }
> server {
> 	listen 80; # 监听的端口
> 	server_name  www.hmtravel.com; # 域名或ip
> 	location / {	# 访问路径配置
> 	# root index;# 根目录
> 	proxy_pass http://tomcat-travel; # 通过此步设置代理的目录
> 	index  index.html index.htm; # 默认首页
> }}
>

负载均衡

英文名称为Load Balance，其意思就是分摊到多个操作单元上进行执行，提供了一种廉价有效透明的方法扩展网络设备和服务器的带宽、增加吞吐量、加强网络数据处理能力、提高网络的灵活性和可用性。

配置负载均衡:修改 Nginx配置文件
	upstream tomcat-travel {
	   server 192.168.177.129:8080;
	    server 192.168.177.129:8081 weight=2;
	   server 192.168.177.129:8082;
    }
    server {
        listen       80; # 监听的端口
        server_name  www.hmtravel.com; # 域名或ip
        location / {	# 访问路径配置
            # root   index;# 根目录
	    proxy_pass http://tomcat-travel;
            index  index.html index.htm; # 默认首页
        }
    }

Web核心知识点总结

1. XML概述

2. XML约束

3. XML解析

Jsoup解析器

Xpath路径语言

4. web服务器软件

Tomcat介绍

5. Servlet接口

访问原理

使用步骤

内部方法

体系结构

6. HTTP协议

7. 请求消息数据格式

8. Request对象

获取请求消息数据的方法

获取请求头数据的方法

获取请求体数据的方法

获取请求参数通用方式

请求转发的方法

共享数据的方法

9. BeanUtils工具类

10. 响应消息数据格式

11. Response对象

12. 重定向

13. ServletContext对象

14. 案例：文件下载

15. Cookie

16. Session

17. JSP

18. MVC开发模式

19. EL表达式

20. JSTL

21. 三层架构

22. Filter 过滤器

23. 代理模式

24. Listener 监听器

25. Maven

26. 综合案例

BaseServlet

Jquery的serialize方法

Redis与数据库交互

根据参数name获取对应的值

SQL语句的拼接

解决中文乱码的两种方式

三种前端往后端传参的方式

27. Linux

Linux常用命令

Vim编辑器

重定向输出

系统管理命令

管道 |

Linux权限命令

文件权限

Linux三种文件类型

文件类型标识

Linux网络操作

软件安装

在Linux上安装JDK

在Linux上安装Mysql

在Linux上安装tomcat

在Linux上安装redis

28. Nginx

反向代理

负载均衡