个人Tomcat复习篇

Tomcat

web相关基础回顾

1.软件架构1，c/s：客户端/服务器端       2，b/s：浏览器/服务器端2，资源分类1，静态资源：所有用户访问后，得到的结果都是一样的，称为静态资源。静态资源可以直接被浏览器解析*html   css     JavaScript2，动态资源：每个用户访问相同资源后，得到的结果可能不一样，动态资源被访问之后，需要先转换为静态资源，再返回给浏览器3，网络通信的三要素1，IP：电子设备在网络中的唯一标识2，端口：应用程序在网络中的唯一标识   0-655363，传输协议1，基础协议1，tcp：安全协议     三次握手   速度较慢2,udp   不安全协议    速度较快

web服务器

服务器:安装了服务器软件的计算机

服务器软件：接受用户的请求，处理请求，做出相应

web服务器软件：接受用户的请求，处理请求，做出相应

*在web服务器软件开发中，可以部署web项目，让用户用过浏览器来访问这些项目*web容器

常见的java相关的web服务器软件

webLogic,webSphere,Jboss（支持所有规范）,Tomcat

JavaEE:Java语言在企业级开发中使用的技术规范的总和，一共规范13种大的规范

tomcat

web服务器软件

1,下载;官网2，安装3，卸载4，启动bin/startup.bat  双击该文件就好访问：在浏览器输入：http://localhost:8080   回车访问自己http://别人的id:8080    访问别人(id在cmd中用 idconfig来查看)*可能出现的问题1，黑窗口一闪而过*原因：，未正确配置JAVA_HOME环境变量2，启动报错1，暴力：找到占用的端口号，并且找到对应的进程，杀死该进程在cmd中使用    netstat -ano2，温柔：修改自己的端口号在conf/server.xml文件下<Connector port="8080" protocol="HTTP/1.1"connectionTimeout="20000"redirectPort="8445"/>*一般会将tomcat的默认端口号修改为80，80端口号是HTTP协议的默认端口号浏览器中访问的时候，就不需要再加端口号了5，关闭1,正常关闭*bin/shutdown.bat*CTRL+C（启动窗体时）2，强制关闭点击启动窗口的 右上角X6，配置    部署项目的方式：1，直接将该项目放到Webapps目录下即可*/hello：项目的访问路径-->虚拟路径*简化部署：将项目打包成war包，再将war包放置到webapps目录下，war包会自动进行解压2，配置conf/server.xml在<Host>标签体中配置<Context doBase="D:\hello" path="/hehe" />doBase：项目存放的路径path:虚拟目录3，在conf\Catalina\localhost创建任意名称的xml文件，在文件中编写<Context doBase="D:\hello" />虚拟目录：xml文件的名称*静态项目和动态项目*目录结构*Java动态项目的目录结构--项目的根目录--WEB-INF目录--web.xml:web项目的核心配置文件--classes目录：放置字节码文件的目录--lib目录：放置依赖的jar包

servlet

server   applet概念：运行在服务器端的小程序*Servlet就是一个接口，定义了Java类被浏览器访问到(tomcat识别)的规则*将来我们定义一个类，实现servlet接口，复写方法*快速入门1，创建Java EE项目2，创建一个类，实现servlet接口‘3，实现接口中的抽象方法4，配置servlet<!--配置Servlet,在web.xml中--><servlet><servlet-name>demo1</servlet-name><servlet-class>com.mjn.JAVA_study.servletDemo1</servlet-class></servlet><servlet-mapping><servlet-name>demo1</servlet-name><url-pattern>/demo1</url-pattern></servlet-mapping>

servlet执行原理

1，当服务器接收到客户请求后，会解析请求的URL路径，获取访问Servlet的资源路径2，查找web.xml文件，是否有对应的<url-pattern>标签体内容3，如果有，则查找相应的<servlet-class>全类名4，tomcat会将字节码文件加载进内存，并创建其对象5，调用其方法

*Servlet的生命周期

1，被创建，执行init方法，只执行一次*servlet什么时候被创建*默认情况下，每一次被访问时，Servlet被创建*可以配置执行Servlet的创建时机<servlet><servlet-name>demo2</servlet-name><servlet-class>com.mjn.JAVA_study.servletDemo2</servlet-class><!--指定Servlet的创建时机1，第一次访问被创建<load-on-startup>的值为负数时2，在服务器启动时，被创建<load-on-startup>的值为0或正整数时<load-on-startup>默认值为-1--><load-on-startup></load-on-startup></servlet><servlet-mapping><servlet-name>demo2</servlet-name><url-pattern>/demo2</url-pattern></servlet-mapping>*servlet的init方法，只执行一次，说明一个Servlet在内存中只存在一个对象，servlet是单例的*多个用户同时访问时，可能存在线程安全问题*解决，尽量不要在Servlet中定义成员变量，即使定义了成员变量，也不要对其修改值2，提供服务：执行service方法，执行多次*每次访问Servlet时都会执行service方法3，被销毁：执行destroy方法，执行一次*Servlet被销毁时执行，服务器关闭，Servlet被销毁*只有在服务器正常关闭时，才会执行destroy方法(destroy方法实在Servlet被销毁之前执行的)*Servlet 3.0*好处：支持注解配置，可以不需要web.xml*步骤1，创建Java EE项目，选择Servlet的版本3.0以上，可以不创建web.xml2,定义一个类，实现Servlet接口3，复写方法4，在类上使用@webServlet注解，进行配置@webServlet("资源路径")

webServlet方法

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface WebServlet {String name() default "";String[] value() default {};String[] urlPatterns() default {};int loadOnStartup() default -1;WebInitParam[] initParams() default {};boolean asyncSupported() default false;String smallIcon() default "";String largeIcon() default "";String description() default "";String displayName() default "";
}注意：注解可以用ctrl+shift+i进行打开源码import javax.servlet.*;
import java.io.IOException;public class demo1 implements Servlet {@Overridepublic void init(ServletConfig servletConfig) throws ServletException {}@Overridepublic ServletConfig getServletConfig() {return null;}@Overridepublic void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {}@Overridepublic String getServletInfo() {return null;}@Overridepublic void destroy() {}
}

IDEA与tomcat的相关配置

1，IDEA会为每一个tomcat部署的项目单独建立一份配置文件*查看控制台的log2,工作空间项目  和    tomcat部署的web项目*tomcat真正访问的时“tomcat部署的web项目”，“tomcat部署的web项目”对应着“工作空间项目”的web目录下的所有文件*WEB-INF目录下的资源不能被浏览器直接访问3，断点调试：使用“小虫子”(就是启动项目的右边的按钮)启动dubug启动

Servlet

1，概念

2，步骤

3，执行原理

4，生命周期

5，Servlet3.0注解配置

6，Servlet的体系结构

Servlet----接口      (爷)GenericServlet----抽象类      (子)HttpServlet----抽象类      (孙)*GenericServlet:将Servlet接口中其他的方法做了默认空实现，只将service()方法作为抽象*将来定义Servlet类时，可以继承GenericServlet，实现service()方法即可*HttpServlet:对http协议的一种封装。简化操作1，定义类继承HttpServlet        2，复写doGet()或者doPost()方法

7，Servlet相关配置

1，urlpartten:Servlet访问路径1，一个Servlet可以定义多个访问路径@webServlet({"/d4","dd4","ddd4"});2，路径定义规则1，/XXX2，/XXX/XXX:多层路径3，*.do@webServlet("/demno");
@webServlet("/demo1/demo");
@webServlet("/*.do");@webServlet("/*");什么都可以访问！

HTTP

*概念：Hyper Text   transfer  protocol  超文本传输协议*传输协议：定义了客户端和服务器端通信时，发送数据的格式*特点1，基于TCP/IP的传输协议2，默认端口号：803，基于请求/响应模型的：一次请求一次响应4，无状态的，每次请求之间相互独立，不能交互数据*历史版本：*1.0：每一次请求响应都会建立新的连接*1.1：复用连接*请求消息数据格式1，请求行请求方式   请求URl  请求协议/版本GET          /login.html     http/1.1*请求方式*HTTP协议中有7中请求方式，常见的有2种*GET1,请求参数在请求行种，在url后2，请求的url长度有限制3，不太安全*POST        1，请求参数在请求体种2，请求的url长度没有限制3，相对安全2，请求头请求头名称：请求头值3，请求空行空行4，请求体(正文)*响应消息数据格式

Request

1，request对象和response对象的原理1，request和response对象由服务器创建，我们来使用它们2，request对象是来获取请求消息，response对象是来设置响应消息2，request对象继承体系结构ServletRequest       ----------------接口| 继承HttpServletRequest    --------------接口|   实现org.apache.catalina.connector.RequestFacade  类(tomcat)3，Request功能：1，获取请求消息1，获取请求行数据*GET  /day14/demo1?name=zhangsan  Http/1.1*方法：1，获取请求方式      GET *String getMethod()；（***）2，获取虚拟目录       /day14*String getContextPath();3,获取Servlet路径        /demo1*String getServletPath();4,获取get请求方式参数   name=zhangsan*String getQueryString();（***）5,获取请求URI:    /day14/demo1*String getRequestURI();*StringBuffer getRequestURL();    http://localhost/day14/demo1*URI:统一资源标识符   /day14/demo1*URL:统一资源标识符    http://localhost/day14/demo16,获取协议及版本       Http/1.1*String getProtocol();7,获取客户机的IP地址  *String getRemoteAddr();package request;import javax.servlet.*;
import javax.servlet.http.*;
import javax.servlet.annotation.*;
import java.io.IOException;@WebServlet("/requestDemo1")
public class RequestDemo1 extends HttpServlet {@Overrideprotected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {/*1，获取请求消息1，获取请求行数据*GET  /day14/demo1?name=zhangsan  Http/1.1*方法：1，获取请求方式      GET*String getMethod()；（***）2，获取虚拟目录     /day14*String getContextPath();3,获取Servlet路径     /demo1*String getServletPath();4,获取get请求方式参数   name=zhangsan*String getQueryString();（***）5,获取请求URI:    /day14/demo1*String getRequestURI();*StringBuffer getRequestURL();    http://localhost/day14/demo1*URI:统一资源标识符   /day14/demo1*URL:统一资源标识符   http://localhost/day14/demo16,获取协议及版本     Http/1.1*String getProtocol();7,获取客户机的IP地址*String getRemoteAddr();*///1，获取请求方式String method=request.getMethod();System.out.println(method);//2，获取虚拟目录String contextPath=request.getContextPath();System.out.println(contextPath);3,获取Servlet路径String servletPath=request.getServletPath();System.out.println(servletPath);//4,获取get请求方式参数String queryString=request.getQueryString();System.out.println(queryString);//5,获取请求URI,URLString requestURI=request.getRequestURI();System.out.println(requestURI);StringBuffer requestURL=request.getRequestURL();System.out.println(requestURL);//6,获取协议及版本String protocol=request.getProtocol();System.out.println(protocol);//7,获取客户机的IP地址String remoteAddr=request.getRemoteAddr();System.out.println(remoteAddr);/*GET/requestDemo1null/requestDemo1http://localhost:8080/requestDemo1HTTP/1.10:0:0:0:0:0:0:1**/}@Overrideprotected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {}
}                       2，获取请求头数据*方法：*String  getHeader(String name):通过请求头的名称获取请求头的值*Enumeration<String>  getHeaderName():获取所有的请求头名称package request;import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.Enumeration;@WebServlet("/requestDemo2")
public class RequestDemo2 extends HttpServlet {@Overrideprotected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {/**String  getHeader(String name):通过请求头的名称获取请求头的值*Enumeration<String>  getHeaderName():获取所有的请求头名称* */Enumeration<String> headerNames=request.getHeaderNames();//遍历headerNameswhile(headerNames.hasMoreElements()){String name=headerNames.nextElement();//根据名称获取请求头的值String value=request.getHeader(name);System.out.println(name+"----"+value);/*host----localhost:8080connection----keep-alivesec-ch-ua----"Chromium";v="92", " Not A;Brand";v="99", "Google Chrome";v="92"sec-ch-ua-mobile----?0upgrade-insecure-requests----1user-agent----Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4503.5 Safari/537.36accept----text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/}}@Overrideprotected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {}
}3，获取请求体数据*请求体：只有post请求方式才有请求体，在请求体中封装了post请求的请求参数*步骤：1，获取流对象*BufferedReader  getReader():获取字符输入流，只能操作字符数据*ServletInputStream  getInputStream();获取字节输入流，可以操作所有类型数据*在文件上传知识点后讲解2，再从流对象中取数据package request;import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.BufferedReader;
import java.io.IOException;@WebServlet("/requestDemo4")
public class RequestDemo4 extends HttpServlet {@Overrideprotected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {}@Overrideprotected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {//获取请求消息体--请求参数//获取字符流BufferedReader br=request.getReader();//读取数据String line=null;while((line=br.readLine())!=null){System.out.println(line);}/*username=2018042063wef&password=wqfrw* */}
}2，其他功能1，获取请求参数的通用方式1,String getParameter(String name):根据参数名称获取参数值2，String[]   getParameterValues(String name):根据参数名称获取参数值的数组3，Enumeration<String>   getParameterNames():获取所有请求的参数名称4，Map<String,String[]>  getParameterMap():获取所有参数的map集合package request;import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.BufferedReader;
import java.io.IOException;
import java.util.Enumeration;
import java.util.Map;
import java.util.Set;@WebServlet("/requestDemo5")
public class RequestDemo5 extends HttpServlet {@Overrideprotected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {/*//获取请求参数String username=request.getParameter("username");System.out.println(username);*///根据参数名称获取参数值的数组
/*        String[] hobbies=request.getParameterValues("hobby");for (String name : hobbies) {System.out.println(name);}*///获取所有请求的参数名称
/*        Enumeration<String> parameterNames=request.getParameterNames();while(parameterNames.hasMoreElements()){String name=parameterNames.nextElement();System.out.println(name);//获取的不是数组，只能输出一个String value=request.getParameter(name);System.out.println(value);}*///获取所有参数的map集合Map<String, String[]> parameterMap=request.getParameterMap();//遍历parameterMap集合Set<String> keyset=parameterMap.keySet();for (String name : keyset) {//获取键值对String[] values=parameterMap.get(name);System.out.println(name);for (String value : values) {System.out.println(value);}System.out.println("------");}/**usernamezhangsan------password123------hobbybasketballfootball------* */}@Overrideprotected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {this.doGet(request,response);}
}中文乱码问题：*get方式：tomcat  8以上已经将get乱码问题解决*post方式：会乱码解决：在获取参数之前设置request.setCharacterEncoding("UTF-8");       输入的utf-8必须是html页面中的编码方式 package request;import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.Map;
import java.util.Set;@WebServlet("/requestDemo6")
public class RequestDemo6 extends HttpServlet {@Overrideprotected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {request.setCharacterEncoding("UTF-8");String name=request.getParameter("username");System.out.println(name);}@Overrideprotected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {this.doGet(request,response);}
}2，请求转发1，步骤1，通过request对象获取请求转发器对象，RequestDispatcher    getRequestDispatcher(String  path);2,使用RequestDispatcher对象来进行转发：forward(ServletRequest   request,ServletResponse  response);2，特点1，浏览器地址栏路径不发生变化2，只能转发到当前服务器内部资源当中3，转发是一次请求3，共享数据1，域对象：一个有作用范围的对象，可以在范围内共享数据2，request域：代表一次请求的范围，一般用于请求转发的多个资源中获取数据3，方法：1，void   setAttribute(String  name,Object  obj):存储数据2，object  getAttribute(String   name):通过键获取值3，void  removeAttribute(String  name):通过键移除键值对4，获取ServletContext*ServletContext  getServletContext();

HTTP

1,请求消息：客户端发送服务器端的数据*数据格式1，请求行2，请求头3，请求空行4，请求体2，响应消息：服务器发送给客户端的数据*数据格式1，响应行1，组成：协议/版本  响应状态码   状态码描述2，响应状态码：服务器告诉客户端浏览器本次请求和响应的一个状态1，状态码都是三数字2，分类1，1XX:服务器接受客户信息，但没有完全接收，等待一段时间后，发送1XX状态码2，2XX:成功代表  2003，3XX:重定向，代表：302   304(访问缓冲)4，4XX:客户端错误*代表*404（请求路径没有对应的资源）*405：请求方式没有对应的doXxx方法5，5XX：服务器错误，代表：500（服务器出现异常）   2，响应头1，格式：头名称：值2，常见的响应头1，content-type:服务器告诉客户端本次响应体数据格式以及编码格式、                2，content-disposition:服务器告诉客户端以什么格式打开响应体数据       *值*in-line:默认值，在当前页打开*attachment:以附件形式打开响应体3，响应空行4，响应体：传输的数据

Response

*功能：设置响应消息1，设置响应行1，格式：HTTP/1.1  200  ok2,设置状态码：setStatus(int sr)2,设置响应头1，setHeader(String name,String value);3,设置响应体*步骤1，获取输出流：*字符输出流:PrintWriter getWriter()*字节输出流：ServletOutputStream   getOutputStream()2,使用输出流，将数据输出到客户端浏览器

案例

1,完成重定向

*重定向的特点  redirect1，地址栏会发生变化2，重定向可以访问其他站点(服务器)的资源3，重定向是两次请求，不能使用request对象来共享数据*转发的特点  forword1，转发地址栏不变2，转发只能访问当前服务器下的资源3，转发是一次请求，可以使用request对象来共享数据*路径写法1，相对路径：通过相对路径不可能确定唯一资源*如：./index.html*不以/开头，以.开头*规则：找到当前资源和目标资源之间的相对位置关系、*：./当前目录*：../后退一级目录2，绝对路径:通过绝对路径可以确定唯一资源*如：https://www.daidu.com以/开头：/www.daidu.com    *规则：判断定义的路径是给谁用的？判断请求从哪发出*给客户端浏览器使用，需要加虚拟目录(项目的访问路径)*建议虚拟目录动态获取：request.getContextPath();*<a>   <form>*给服务器用，不需要加虚拟目录*转发路径2，绝对路径package ResponseDemo;import javax.servlet.*;
import javax.servlet.http.*;
import javax.servlet.annotation.*;
import java.io.IOException;@WebServlet("/ResponseDemo1")
public class ResponseDemo1 extends HttpServlet {@Overrideprotected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {System.out.println("dqwd");//设置重定向，设置状态码response.setStatus(200);//设置响应头response.setHeader("location","/ResponseDemo2");/*response.sendRedirect("/ResponseDemo2");*/}@Overrideprotected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {this.doGet(request, response);}
}package ResponseDemo;import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;@WebServlet("/ResponseDemo2")
public class ResponseDemo2 extends HttpServlet {@Overrideprotected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {System.out.println("这是Demo2");}@Overrideprotected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {this.doGet(request, response);}
}

2，服务器输出字符数据到浏览器

*步骤1，获取字符输出流2，输出数据*注意*乱码问题1，PrintWriter  pw=new response.getWriter();默认编码是ISO-8859-12,设置该流的默认编码3，告诉浏览器响应体使用的编码简单的格式设置编码 response.setContentType("text/html;charset=utf-8");package ResponseDemo;import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;@WebServlet("/ResponseDemo3")
public class ResponseDemo3 extends HttpServlet {@Overrideprotected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {//获取流之前，设置流的默认编码    ISO-8859-1//response.setCharacterEncoding("Utf-8");//response.setHeader("content-type","text/html;charset=utf-8");//简单的格式设置编码response.setContentType("text/html;charset=utf-8");//获取字符输出流PrintWriter ps=response.getWriter();//输出数据ps.write("你好！！！");}@Overrideprotected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {this.doGet(request, response);}
}

3，服务器输出字节数据到浏览器

*步骤1，获取字节输出流2，输出数据package ResponseDemo;import javax.servlet.ServletException;
import javax.servlet.ServletOutputStream;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;@WebServlet("/ResponseDemo4")
public class ResponseDemo4 extends HttpServlet {@Overrideprotected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {//设置浏览器接收的编码response.setContentType("text/html;charset=utf-8");//获取字符输出流ServletOutputStream sos=response.getOutputStream();//输出流数据sos.write("你好".getBytes("utf-8"));}@Overrideprotected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {this.doGet(request, response);}
}

验证码案例

package ResponseDemo;import javax.imageio.ImageIO;
import javax.servlet.ServletException;
import javax.servlet.ServletOutputStream;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.awt.*;
import java.awt.image.BufferedImage;
import java.io.IOException;
import java.util.Random;@WebServlet("/CheckCodeServlet")
public class CheckCodeServlet extends HttpServlet {@Overrideprotected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {int width=100;int height=50;//创建一个对象，在内存中的图片(验证码图片对象)BufferedImage image=new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);//2美化图片//2.1填充背景色Graphics g=image.getGraphics();//画笔对象g.setColor(Color.PINK);//设置画笔颜色g.fillRect(0,0,width,height);//设置填充坐标//2.2画边框g.setColor(Color.BLUE);//设置边框颜色g.drawRect(0,0,width-1,height-1);//设置边框位置//2.3写验证码String str="ABCDEFGHIGKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";//生成随机角标Random ran=new Random();for (int i=1; i <= 4; i++) {int index=ran.nextInt(str.length());//获取字符char ch=str.charAt(index);//写验证码g.drawString(ch+"",width/5*i,height/2);}//2.4画干扰线g.setColor(Color.BLACK);//随机生成坐标点for (int i=0; i < 5; i++) {int x1=ran.nextInt(width);int x2=ran.nextInt(width);int y1=ran.nextInt(height);int y2=ran.nextInt(height);g.drawLine(x1,y1,x2,y2);}//将图片输出到页面展示ImageIO.write(image,"jpg",response.getOutputStream());}@Overrideprotected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {this.doGet(request, response);}
}

点击图片刷新验证码

<!DOCTYPE html>
<html lang="en">
<head><meta charset="UTF-8"><title>Title</title>
</head>
<body><img id="image" src="/CheckCodeServlet"/><script>/** 分析*   点击图片。更新一张*   1，给图片设置单击事件*   2，修改图片的src属性* */window.onload=function (){//获取图像对象let image = document.getElementById("image");image.onclick=function (){let date = new Date().getTime();image.src="/CheckCodeServlet?"+date}}</script>
</body>
</html>

ServletContext对象

1，概念：代表整个web应用，可以和程序的容器通信

2，获取：

1，通过request对象获取request。getServletContext();2,通过HttpServletContext();this.getServletContext();//获取ServletContext对象
ServletContext sc1=request.getServletContext();
//HttpServlet中获取ServletContext对象
ServletContext sc2=this.getServletContext();
System.out.println(sc1);
System.out.println(sc2);

3,功能

1，获取MIME对象*MIME类型：在互联网通信过程中定义的一种数据类型例如：大类型/小类型     text/html    image/jpg获取方法：String getMimeType(String file);//获取ServletContext对象
ServletContext sc1=request.getServletContext();
//HttpServlet中获取ServletContext对象
ServletContext sc2=this.getServletContext();
//获取文件的MIME类型
String filename="a.png";
String mimeType=sc1.getMimeType(filename);
System.out.println(mimeType);2，域对象：共享数据1，setAttaibute(String name,Onject value);2,setAttribute(name);3,removeAttribute(name);*ServletContext对象范围，所有用户所请求的数据3，获取文件的真实(服务器)路径方法：String   getRealPath();//获取ServletContext对象
ServletContext sc=request.getServletContext();
//获取文件的真实路径
String cpath=sc.getRealPath("/c.txt");//web下的文件
System.out.println(cpath);String dpath=sc.getRealPath("/WEB-INF/d.txt");//WEB-INF的文件
System.out.println(dpath);String bpath=sc.getRealPath("/WEB-INF/classes/b.txt");//src下的文件
System.out.println(bpath);/*
结果
D:\JAVA-study\test\out\artifacts\demoResponse_war_exploded\c.txt
D:\JAVA-study\test\out\artifacts\demoResponse_war_exploded\WEB-INF\d.txt
D:\JAVA-study\test\out\artifacts\demoResponse_war_exploded\WEB-INF\classes\b.txt
* */

会话技术

1，会话：一次会话中包含多次请求和响应*一次会话：浏览器第一次给服务器资源发送请求，会话建立，直到有一方断开为止2，功能：在一次会话的范围内的多次请求间，共享数据3，方式：1，客户端会话技术：Cookie2，服务器端会话技术：Session

1,概念：客户端会话技术，将数据保存到客户端

2，快速入门

*使用步骤1，创建Cookie对象，绑定数据*new  Cookie(String name,String value);2,发送Cookie对象*response.addCookie(Cookie cookie);3,获取Cookie，拿到数据Cookie[]  request.getCookie();//创建Cookie对象
Cookie c=new Cookie("zhangsan", "123");
//将数据发送给客户端
response.addCookie(c);//服务器接收数据Cookie[] cookies=request.getCookies();//输出数据if (cookies !=null){for (Cookie c : cookies) {//输出数据String name=c.getName();String value=c.getValue();System.out.println(name+"---"+value);}}
}

3,实现原理

*基于响应头set-cookie和请求头Cookie实现

4，cookie细节

1，一次可以发送多个Cookie吗？*可以*可以创建多个Cookie对象，使用response调用多次addCookie方法发送cookie即可//创建Cookie对象
Cookie c1=new Cookie("zhangsan", "123");
Cookie c2=new Cookie("lisi", "456");//将数据发送给客户端
response.addCookie(c1);
response.addCookie(c2);2，Cookie在浏览器中保存多长时间1，默认情况下，当浏览器关闭之后，cookie数据在内存中被销毁2，持久化存储*setMaxage(int seconds);1,整数：将cookie数据写到硬盘的文件当中，持久化存储，cookie存活时间2，负数：默认值   -13，零：删除cookie信息//创建Cookie对象Cookie c1=new Cookie("mjn", "666");//设置cookie存活时间
//        c1.setMaxAge(200);c1.setMaxAge(-1);//将数据发送给客户端response.addCookie(c1);3，cookie能不能存中文*在tomcat 8之前，cookie中不能直接存储中文数据需要中文数据转码---一般采用URL编码*在tomcat8之后，cookie支持中文数据,特殊字符还是不支持，建议使用URL编码存储，URL解码解析4，Cookie共享数据范围1，假设在一个tomcat服务器中，部署多个web项目，那么这些web项目中cookie能不能共享*默认情况下不能共享*setPath(String  path):设置cookie的获取范围，默认情况下，设置当前的虚拟目录如果要共享，则将setPath设置为“/”2，不同的tomcat服务器键cookie共享数据*setDomain(String path);如果设置一级域名相同，那么多个服务器之间cookie就可以共享数据*setDomain(".baidu.com")那么tieba.baidu.com和news.baidu.com中cookie可以共享数据5，cookie的特点和作用1，cookie存储数据在客户端浏览器2，浏览器对于单个cookie有限制，对同一个域名下的cookie数量也会进行限制*作用1，cookie一般用于存储少量并且不太重要的数据2，在不登录的情况下，完成服务器对客户端的身份识别

案例练习：记住上一次访问时间

1，需求1，访问一个Servlet,如果是第一次访问，则提示你好2，如果不是第一次访问，提示，欢迎回来：显示时间字符串2，分析：1，可以采用cookie技术2，在服务器中的Servlet判断是否有一个名为lastTime的1，没有：是第一次访问1，响应数据：你好，欢迎你首次访问2，写回cookie：lastTime=yyyy年MM月dd日  hh时ss分2,有，不是第一次访问1，响应数据：欢迎回来，你上次访问的时间为XXXXXXXX2,写回cookie：XXXXXXXXXXpackage CookieDemo;import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.net.URLDecoder;
import java.net.URLEncoder;
import java.text.SimpleDateFormat;
import java.util.Date;@WebServlet("/CookieDemo5")
public class CookieDemo5 extends HttpServlet {@Overrideprotected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {/**     2，在服务器中的Servlet判断是否有一个名为lastTime的1，没有：是第一次访问1，响应数据：你好，欢迎你首次访问2，写回cookie：lastTime=yyyy年MM月dd日  hh时mm分ss秒2,有，不是第一次访问1，响应数据：欢迎回来，你上次访问的时间为XXXXXXXX2,写回cookie：XXXXXXXXXX* *///设置响应的消息体的数据格式以及编码response.setContentType("text/html;charset=utf-8");//获取所有Cookie对象Cookie[] cookies=request.getCookies();boolean flag = false;//没有cookie为lastTimeif (cookies != null && cookies.length > 0){//遍历cookie数组for (Cookie cookie : cookies) {获取cookie的名称String name=cookie.getName();//判断名字是否是lastTimeif ("lastTime".equals(name)){//获取到cookies不是第一次访问flag = true;//有cookie为lastTime//设置Cookie的value//获取当前时间的字符串，重新设置Cookie的值，重新发送cookieDate date=new Date();SimpleDateFormat sdf=new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");String format=sdf.format(date);//URL编码System.out.println("编码前"+format);format = URLEncoder.encode(format,"utf-8");System.out.println("编码后"+format);cookie.setValue(format);//设置存活时间
//                    cookie.setMaxAge(60 * 60 * 24 * 30);cookie.setMaxAge(-1);response.addCookie(cookie);//响应数据//获取value,时间String value=cookie.getValue();System.out.println("解码前"+value);//URL解码value=URLDecoder.decode(value,"utf-8");System.out.println("解码后"+value);response.getWriter().write("欢迎回来"+value);break;}}}if (cookies == null || cookies.length == 0 || flag == false ){//设置Cookie的value//获取当前时间的字符串，重新设置Cookie的值，重新发送cookieDate date=new Date();SimpleDateFormat sdf=new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");String format=sdf.format(date);//URL编码System.out.println("编码前"+format);format = URLEncoder.encode(format,"utf-8");System.out.println("编码后"+format);Cookie cookie=new Cookie("lastTime", format);cookie.setValue(format);//设置存活时间cookie.setMaxAge(60 * 60 * 24 * 30);response.addCookie(cookie);response.getWriter().write("欢迎首次访问");}}@Overrideprotected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {this.doGet(request, response);}
}

Session

1，概念：服务器端会话技术，在一次会话的多次请求间共享数据，将数据保存在服务器端的对象中 HttpSession对象

2，快速入门

1，获取HttpSession对象HttpSession   session=request.getSession();2,使用HttpSession对象Object getAttribute(String name);void setAttribute(String name,Object value);void removeAttribute(String name);package SessionDemo;import javax.servlet.*;
import javax.servlet.http.*;
import javax.servlet.annotation.*;
import java.io.IOException;@WebServlet("/SessionDemo1")
public class SessionDemo1 extends HttpServlet {@Overrideprotected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {//获取HttpSession对象HttpSession session=request.getSession();//使用HttpSession对象session.setAttribute("mjn","hello ");}@Overrideprotected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {this.doGet(request, response);}
}

3,工作原理

Session的实现依赖于Cookie

4，Session细节

1，当客户端关闭后，服务器不关闭，两次获取的Session是否为同一个？默认情况下，不是要想获取的Session一样，修改如下//获取HttpSession对象
HttpSession session=request.getSession();
System.out.println(session);Cookie cookie=new Cookie("JSESSIONID", session.getId());
cookie.setMaxAge(60*60);
response.addCookie(cookie); 2，当客户端不关闭，服务器关闭后，两次获取的Session是同一个吗？*不是同一个，但是要确保数据不会丢失*session的钝化：在服务器正常关闭之前，将session对象系列化到硬盘上*session的活化：在服务器启动后，将session文件转化为内存中的session对象即可3，Session的失效时间或者说是session什么时候被销毁1，服务器关闭时2，session对象调用方法   invalidate();3，session默认失效时间   30分钟选择性配置修改<Session-config><Session-timeout>30</Session-timeout><Session-config>

5，Session特点

1,session用于存储一次会话的多次请求的数据，存在服务器端2，session可以存储任意类型，任意大小的数据*Session与Cookie的区别：1，session存储数据在服务器端，cookie在客户端2，session没有数据大小限制，cookie有3，session存储在服务器端比较安全，cookie相对于Session不安全

JSP:入门

1，概念:java servlet pages:java服务器端页面

*也是一个比较特殊的页面，其中可以指定定义一些HTML和Java代码*用于简化书写(比如在一个页面中动态资源和静态资源的展示)

2，原理

jsp本身也是servlet

3,jsp脚本

1，<%   代码   %>:定义的Java代码，在service中，service方法中可以定义什么，该脚本中就可以定义什么2，<%!   代码  %>：声明的Java代码，在jsp转换后的Java类的成员位置   也就是Java类的成员变量位置3，<%=   代码    %>：声明的Java代码，在会输出到页面上，输出语句中可以定义什么，该脚本中就可以定义什么

4，jsp九大内置对象

*在jsp页面中不需要获取和创建，可以直接使用的对象

request内置对象

response内置对象

page内置对象

session内置对象

application内置对象

out内置对象

exception内置对象

config内置对象

pageContext内置对象

学习链接：https://www.cnblogs.com/zhaotiancheng/p/6374863.html

response,request,outout：字符输出流对象，可以将数据输出到页面上，和response.getWriter();类似区别：在tomcat服务器真正给客户端做出响应之前，会先找到response缓冲区数据，再找out缓冲区数据response.getWriter()永远输出在out对象之前

jsp

1，指令

*作用：用于配置jsp页面，导入资源文件*格式：<%@  指令名称   属性名1=属性值1 属性名2=属性值2 ....%>*分类：1，page：配置jsp页面*contentType:等同于response.setContentType()1,设置响应体的mime类型以及字符集2，设置当前jsp页面的编码(只能是高级的ide才能生效，如果使用低级工具，需要设置pageEncoding来设置页面字符集)*import:导包*errorPage:当前页面发生异常之后，会自动跳转到1指定的错误页面*isErrorPage:标识当前是否是错误页面*true:可以使用内置对象exception*false：默认值，不可以使用内置对象exception2，include：页面包含的，导入1页面的资源文件<%@include file="top.jsp"%>3,taglib:导入资源<%@ taglib prefix="c" uri="http://java.sun.com/jip/jst1/core"%>prefix:前缀，自定义

2，注释

1，html注释：<!-- -->*只能注释HTML代码片段2，jsp注释：<%-- --%>推荐使用*可以注释所有

3，内置对象

*在jsp页面中不需要创建，直接使用的对象*一共有九个变量名                        真实类型                    作用pageContext               PageContext             当前页面共享数据，还可以获取其他八个内对象request                 HttpServletRequest              一次请求访问的多个资源(转发)session                  HttpSession             一次会话的多个请求间application               ServletContext          所用用户间共享数据response               HttpServletResponse     响应对象page                    Object                  当前页面(Servlet)的对象   thisout                      JspWriter               输出对象，数据输出到页面上config                  ServletConfig           Servlet的配置对象exception               Throwable               异常对象

MVC开发模式

1，用途：借鉴MVC，可以让程序的设计更加合理性

2，MVC:

1,M:model  模型，javabean*完成具体的业务操作，如操作数据库。封装对象2，V:view  视图  jsp*展示数据3，C:controller  控制器  Servlet*获取用户的输入*调用模型*将数据交给视图进行展示*优缺点*优点1，耦合性低，便于维护，利于分工写作2，重用性高*缺点*使得项目架构变得复杂，对开发人员要求较高

EL表达式

1，概念：Expression Language:表达式语言

2，作用：替换和简化jsp页面中的Java代码

3，语法：${表达式}

4，注意：

*jsp默认支持El表达式的，如果忽略el表达式1，设置jsp中的page指令：isElIgnored="true"忽略当前jsp页面中的所有El表达式2，\${表达式}：忽略当前el表达式

5，使用：

1，运算*运算符1，算术运算符：+  -    *   %(mod)    /(div)2，比较运算符: <   >   <=   >=  ==3，逻辑运算符:&&      ||      !4，空运算符   empty*功能：用于判断字符串，数组，集合对象是否为null或者长度为0*${empty  list}：判断字符串，集合，数组对象是否为null或者长度为0*${not empty list}:判断字符串，集合，数组对象是否不为null或者长度大于02，获取值1,el表达式只能从域对象中获取值2，语法：1，${域名称.键名}：从指定域中获取指定间的值*域名称1，pageScope      ------------pageContext2,requestScope  -------------request3,sessionScope    ------------------session4,applicationScope  ----------------application(ServletContext)*举例在request域中存储了  name=张三*获取值：${requestScope.name}2,${键名}：表示一次从最小的域中查找是否有该键对应的值，直到找到为止以上域名称范围依次变大3，获取：对象，list集合，map集合的值1，对象：${域名称.键名.属性名}*本质上会去调用对象的getter方法2，list集合：${域名称.键名[索引]3，map集合：${域名称.键名.key名称}${域名称.键名["key名称"]}3，隐式对象*el表达式中有11个隐式对象*pageContext*获取jsp其他八个内置对象*${pageContext.request.contextPath}:动态获取虚拟目录

JSTL

1，概念：Java Server pages Tag Librery jsp标准标签库

 *是由Apache组织提供的开源的免费的jsp标签     <标签>

2，作用：用于简化和替换jsp页面上的Java代码

3，使用步骤

1，导入jstl相关的jar包2，引入标签库：taglib指令：<%@  taglib  %>3,使用标签

4，常用的JSTL标签

1，if：相当于Java代码中的if语句1，属性*test必须属性，接受Boolean表达式*如果表达式为true，则显示if标签体内容，如果为false则不显示*一般情况下，test属性域el表达一起使用2，注意1，c:if标签没有else情况，想要else效果就再写一个if标签2，choose：相当于Java代码中的switch1，使用choose标签声明     相当于switch声明2，使用when标签做判断     相当于case3，使用otherwise标签做其他情况的声明           相当于default3，foreach：相当于Java代码中的for语句foreach:相当于Java代码的for语句1，完成重复的操作for(int i=0;i<10;i++){}属性begin:开始值end:结束值var:零时变量step:步长varStatus:循环状态对象index:容器中元素的索引，从0开始count：循环次数，从一开始2，遍历容器List<User> listfor(User user : list){}属性：item:容器对象var:容器中元素的零时变量varStatus:循环状态对象index:容器中元素的索引，从0开始count：循环次数，从1开始

Filter

1，概念：

web当中的过滤器：当访问服务器的资源时，过滤器可以将请求拦截下来，完成一些特殊的功能过滤器的作用：*一般用于完成通用的操作，比如登录验证，统一编码处理，以及敏感字符的过滤

2，快速入门

1，步骤1，定义一个类，实现接口Filter(javax.Servlet.Filter)2,复写方法  3，配置拦截路径1，web.xml2，配置注解package Filter;import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import java.io.IOException;//访问所有资源之前都会访问过滤器
//当只有一个配置信息时，value可以省略
@WebFilter(value="/*")
public class FilterDemo1 implements Filter {@Overridepublic void init(FilterConfig filterConfig) throws ServletException {}@Overridepublic void destroy() {}@Overridepublic void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {System.out.println("过滤器");filterChain.doFilter(servletRequest,servletResponse);}
}

3，过滤细节

1，web.xml配置<filter><filter-name>demo2</filter-name><filter-class>Filter.FilterDemo2</filter-class></filter><filter-mapping><filter-name>demo2</filter-name><!--   拦截路径--><url-pattern>/*</url-pattern></filter-mapping>2，过滤器执行流程1，执行过滤器2，执行放行后的资源3，回来执行过滤器放行代码下边的代码3，过滤器的生命周期1，init:在服务器启动的时候，会被执行2，doFilter:每一次请求被拦截资源时候，会执行，执行多次3，destroy：在服务器正常关闭后，filter对象被销毁，执行destroy方法4，过滤器配置详解*拦截路径配置1，具体资源拦截路径：  /index.jsp   只有访问index.jsp资源时，过滤器才会执行2，拦截目录： /user/*   访问/user下的所有资源时候，过滤器才会被访问3，后缀名拦截   *.jsp     只有访问后缀名为.jsp的文件时，过滤器才会执行4，拦截所有的资源   /*     访问所有资源时候都会执行过滤器*拦截方式配置：资源被访问的方式*注解配置*设置dispatcherTypes属性1，REQUEST：默认值，浏览器直接请求资源2，FORWARD:转发访问资源3，INCLUDE:包含访问资源4，ERROR:错误跳转资源5，ASYNC:异步访问资源*web.xml配置*设置<dispatcher></dispatcher>标签即可(标签中包含五个类型)5，过滤器链(配置多个过滤器)*执行顺序：如果有两个过滤器：过滤器1和过滤器21，过滤器12，过滤器23，执行资源4，过滤器25，过滤器1*过滤器先后执行顺序1，注解配置：按照类名的字符串进行规则比较，值小的先执行*例如：Afilter和Bfilter,A比B小就先执行Afilter          2，web.xml:谁定义的<filter-mapping>在上面，谁先执行

Listener

1,概念：web三大组件之一

*事件监听机制*事件    一件事情*事件源   事件发生的地方*监听器   一个对象*注册监听：将事件，事件源，监听器绑定在一起，当事件源上发生事件后，执行监听器代码。*ServletContextListener:监听ServletContext对象的创建和销毁*方法*void contextDestoryed(ServletContextEvent sce):ServletContext对象被销毁之前会调用方法*void contextInitialized(ServletContextEvent sce):ServletContext对象创建后会调用该方法*步骤1，定义一个类，实现ServletContextListener接口2，复写方法3，配置1，web.xml<listener><listener-class>实现接口类的位置</listener-class></listener>*指定初始化参数<context-param>2，注解配置@webListener

JQuery

1,概念：

jQuery是一个快速、简洁的JavaScript框架，是继Prototype之后又一个优秀的JavaScript代码库（框架）于2006年1月由John Resig发布。jQuery设计的宗旨是“write Less，Do More”，即倡导写更少的代码，做更多的事情。它封装JavaScript常用的功能代码，提供一种简便的JavaScript设计模式，优化HTML文档操作、事件处理、动画设计和Ajax交互。

2，快速入门

1，步骤1，下载Jquery2,导入JQuery的js文件：导入min.js文件 3，使用var div1=$("#div1");alert(div1.html());

3,IQuery对象和js对象区别与转换

1，JQuery对象在操作时，更加方便2，JQuery对象和js对象方法不相通3，两者相互转换*jq------->js     jq对象[索引]  或者   jq对象.get(索引)*js---------->jq   $(js对象)

4，选择器：筛选出具有相似特征的元素(标签)

1，基本操作学习1，事件绑定//获取b1按钮$("#b1").click(function()){alert("abc"); });2,入口函数

$(function(){

});

window.onload和$(function)区别

*window.onload只能定义一次，如果定义多次，后面会将前面的覆盖*$(function)可以定义多次3，样式控制：css方法//$("#div").css("background-color","red");$("#div").css("backgroundColor","red");

2,分类

1，基本选择器1，标签选择器(元素选择器)语法：$("html标签名")  获取所有匹配标签名称的元素2，id选择器语法：$("#id的属性值") 获取与指定id属性匹配的元素3，类选择器语法：$(".class的属性值")     获取与指定的class属性值匹配的元素4，并集选择器语法：$("选择器1,选择器2,........") 获取多个选择器选中的所有元素2，层级选择器1，后代选择器语法：$("A  B") 选择A元素中的所有B元素2，子选择器语法：$("A >  B") 选择A元素内部所有的B子元素3，属性选择器1，属性名称选择器语法：$("A[属性名]") 包含指定属性的选择器2，属性选择器语法：$("A[属性名=‘值’]")    包含指定属性等于指定值的选择器3，复合属性选择器语法：$("A[属性名='值'][].....")    包含多个属性条件的选择器4，过滤选择器1，首元素选择器语法：:first    获取选择的元素中的第一个元素2，尾元素选择器语法： :last    获取选择的元素的最后一个元素3，非元素选择器语法： :not(selecter)不包括指定内容的元素4，偶数选择器语法：  :even   偶数   从0开始计数5，奇数选择器语法：  :odd   奇数   从0开始计数6，等于索引选择器语法：:eq(index)指定索引元素7，大于索引选择器语法：:gt(index)指定索引元素8，小于索引选择器语法：:lt(index)指定索引元素9,标题选择器语法：:header  获取标题(h1-h6)元素，固定写法5，表单过滤选择器1，可用元素选择器语法： :enabled   获取可用元素2，不可用元素选择器语法：  :disabled    获取不可用元素3，选中选择器语法：  :checked   获取单选/复选框选中的元素4，选中选择器语法： :selected   获取下拉框选中的元素5，DOM操作1，内容操作1，html():获取/设置元素的标签体内容   <a><font>内容</font></a>----><font>内容</font>2,text():获取/设置元素的标签体纯文本内容 <a><font>内容</font></a>--->内容3，val();获取/设置元素的value属性2，属性操作1，通用属性操作1，attr():获取/设置元素的属性2，removeAttr():删除属性3，prop():获取/设置元素的属性4,removeProp():删除属性*attr和prop区别1，如果操作的是元素的固有属性(比如form表单的action属性)，则建议使用prop2,如果操作的是元素自定义的属性，则建议attr 2，对class属性操作1，addClass()：添加class属性值2，removeClass():删除class属性值3，toggleClass:切换class属性值*toggleClass("one"):如果判断元素对象上存在class=”one“则将属性删除，如果元素对象上不存在，就加上3，CRUD操作1，append():父元素将子元素追加到末尾*对象1.append(对象2)：将对象2添加到对象1元素的内部，并且在末尾   2，prepend():父元素将子元素追到开头*对象1.prepend(对象2)：将对象2添加到对象1元素内部，并且在开头3，appendTo():*对象1.appendTo(对象)：将对象1添加到对象2内部，并且在末尾4，prependTo():*对象1.prependTo(对象2)：将对象1添加到对象2内部，并且在开头5，after():添加元素到元素后边*对象1.after(对象2)：将对象2添加到对象1后边，对象1和对象2是兄弟关系6，before():添加元素到元素前边*对象1.before(对象2)：将对象2添加到对象1前边，对象1和对象2是兄弟关系7，insertAfter()*对象1.insertAfter(对象2)：将对象2添加到对象1后边，对象1和对象2是兄弟关系8，insertBefore()*对象1.insertBefore(对象2)：将对象2添加到对象1前边，对象1和对象2是兄弟关系9，remove():移除元素*对象。remove():将对象删除掉10，empty():清空元素地所有后代元素*对象.empty():将对象的后代元素全部清空，但是保留当前对象以及其属性节点

JQuery高级

1，动画

1，三种方式显示和隐藏元素1，默认显示和隐藏方式1，show([speend],[easing],[fn])1,参数：1，speed:动画的速度，三个预定义的值(“slow”，“normal”，“fast”)或表示动画时长的毫秒值2，easing：用来指定切换效果，默认为“swing”，可用参数“linear”*swing：动画执行时候效果是嫌慢，中间快，最后慢*linear：动画执行速度是匀速的3，fn:在动画完成时执行的函数，每个元素执行一次2，hide([speend],[easing],[fn])3,toggle([speend],[easing],[fn])2，滑动显示和隐藏1,slideDown([speend],[easing],[fn])2,slideUp([speend],[easing],[fn])3,slideToggle([speend],[easing],[fn])3，淡入淡出显示和隐藏方式1,fadeIn([speend],[easing],[fn])2,fadeOut([speend],[easing],[fn])3,fadeToggle([speend],[easing],[fn])

2,遍历

/*1，js的遍历方式for(初始值；循环结束条件;步长)<script>$(function () {let city = $("#city li");for (let i = 0; i < city.length; i++) {alert(i+":"+city[i].innerText);}});</script><ul id="city"><li>北京</li><li>陕西</li><li>上海</li><li>成都</li></ul>2，jq的遍历方式1，jq对象：each(callback)<script>$(function () {let city = $("#city");//jq对象citys.each(function (index,element) {//获取li对象//alert(this.innerText);// alert($(this).html());//获取li对象，第二种方式，在回调函数中定义参数  index(索引)和element(元素对象)// alert(index+":"+element.innerText);// alert(index+":"+$(element).html());//判断如果是陕西，则结束循环if ("陕西" == $(element).html()){//如果当前返回false，则结束循环(break)//如果当前返回的是true，则跳过本次循环(continue)return false;}alert(index+":"+$(element).html());});});</script>2,$.each(object,[callback])//:$.each(object,[callback])$.each(city,function () {alert($(this).html());})*/3,for..of//for...of:jQuery3.0版本之后提供的方式for (li of city){alert($(li).html());}
*/

3,事件的绑定

1，jQuery标准的绑定方式   *jq对象.事件方法(回调函数);*注意：如过调用事件方法，不传递回调函数，则会触发浏览器默认行为*表单对象.submit();//让表单提交2，on绑定事件/off解除绑定*jq对象.on(“事件名称”,回调函数)；*jq对象.off("事件名称");*如果off方法不传递任何参数，则将组件上的所有事件全部解绑3，事件切换：toggle*jq对象.toggle(fn1,fn2.....)*当点击jq对象应用的组件后，会执行fn1,第二次点击会执行fn2........*注意：1.9版本.toggle()方法删除，jQuery   Migrate(迁移)插件可以恢复此功能

5，插件：增强JQuery的功能

1，实现方式1，$.fn.extend(object)*增强通过Jquery获取的对象的功能    $("#id");//定义jQuery的对象插件
$.fn.extend({//定义一个check方法，所有的jq 对象都可以调用该方法check:function () {this.prop("checked",true);}
});2,$.extend(object)*增强Jquery对象自身的功能$.extend({//定义一个max方法max:function (a,b) {//返回两者之间的最大值return a >= b ? a : b;},min:function (a, b) {return a <= b ? a :b;}
});

AJAX

1，概念：Asynchronous JavaScript and xml

1,异步和同步：客户端和服务器端相互通信的基础上*客户端必须等待服务器的响应，在等待的期间客户端不能做其他操作    *客户端不需要等待服务器的响应，在服务器处理数据的过程中，客户端可以进行其他的操作Ajax是一种无需重新加载整个网页的情况下，能够更行部分网页的技术

2，实现方式

1，原生的Js实现方式<!DOCTYPE html>
<html lang="en">
<head><meta charset="UTF-8"><title>Title</title><script src="js/jquery-3.3.1.js"></script><script>//定义方法function fun(){//发送异步请求//1，创建核心对象let xmlhttp;if (window.XMLHttpRequest){//code for IE7+  Firefox   Chrome   Opera  Safarixmlhttp=new XMLHttpRequest();}else {//code for IE6 IE5xmlhttp=new ActiveXObject("Microsoft.XMLHTTP");}//2,建立连接/** 参数*       1，请求方式   GET    Post*       2,请求的URL*       3,同步或异步请求，true(异步)，false(同步)** */xmlhttp.open("GET","ajaxServlet?username=tom",true);//3，发送请求xmlhttp.send();//接收结果//获取方式xmlhttp.responseText//当服务器响应成功的时候获取//当xmlhttp对象的就绪状态改变时，触发事件onreadystatechangexmlhttp.onreadystatechange=function () {//判断readState就绪状态是否为4，判断status响应状态码是否为200if (xmlhttp.status==200 && xmlhttp.readyState==4){//获取服务器的响应结果let responseText = xmlhttp.responseText;alert(responseText);}}}</script>
</head>
<body><input type="button" value="异步请求" onclick="fun()">
</body>
</html>package Servlet;import javax.servlet.*;
import javax.servlet.http.*;
import javax.servlet.annotation.*;
import java.io.IOException;@WebServlet("/ajaxServlet")
public class AjaxServlet extends HttpServlet {@Overrideprotected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {//获取请求参数String username=request.getParameter("username");//打印usernameSystem.out.println(username);//响应response.getWriter().write("hello"+username);}@Overrideprotected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {this.doGet(request, response);}
}

2，Jquery实现方式

 1，$.ajax()<script>//定义方法function fun(){//使用Jquery发送异步请求$.ajax({//写参数url:"ajaxServlet",//请求路径type:"POST",//默认是GET// data:"username=jack&age=23"data:{"username":"jack","age":"23"},success:function (data){alert(data);},//响应成功后的回调函数});}
</script>$.ajax({//写参数url:"ajaxServlet",//请求路径type:"POST",//默认是GET//data对象为jsondata:{"username":"jack","age":"23"},success:function (data){alert(data);},//响应成功后的回调函数});2，$.get()<script>//定义方法function fun(){//使用Jquery-get发送异步请求$.get("ajaxServlet",{username:"cat"},function (data) {alert(data);},"text");}
</script>3，$.post()<script>//定义方法function fun(){//使用Jquery-get发送异步请求$.post("ajaxServlet",{username:"cat"},function (data) {alert(data);},"text");}
</script>

JSON

1,概念：JAvaScript Object notation javaScript对象表示法

var   p={"name":"jack","age":"23","gender":"男"};

作用

json现在多用于存储和交换文本信息的语法进行数据的传输Json比xml更小，更快，更易解析

2，语法

1，语法规则*数据在名称/值中：json数据是由键值对组成的*键用引号(单双都可)引起来，也可以不引*值的取值类型1，数字(整数或者浮点数)2，字符串(在双引号当中)3，逻辑值(true或false)4，数组(存放在[]方括号中)     {"p":[{},{},{}]5，对象(存放在{}花括号中)     {"a":{"province":"陕西",......}}6，null*数据由逗号隔开:多个键值对由逗号隔开*花括号保存对象：使用{}定义json格式*方括号保存数组：[]2，获取数据1,json对象.键名2，json对象["键名"]3，数组对象[索引]<script>//定义基本格式let p={"name":"jack","age":23,"gender":"男"};// let name = p.name;// alert(name);//嵌套格式   {}---->[]let person={"p":[{"name":"张三","age":12,"gender":true},{"name":"李四","age":16,"gender":true},{"name":"王五","age":15,"gender":false}]};let name = person.p[1].name;alert(name);//嵌套格式    []---->{}let a=[{"name":"张三","age":12,"gender":true},{"name":"张三","age":12,"gender":true},{"name":"张三","age":12,"gender":true}];let age = a[0].age;alert(age);
</script>数组遍历json<script>//定义基本格式let p={"name":"jack","age":23,"gender":"男"};//for..in..循环/*for (let key in p){alert(key+":"+p[key]);}*///嵌套格式   {}---->[]let person={"p":[{"name":"张三","age":12,"gender":true},{"name":"李四","age":16,"gender":true},{"name":"王五","age":15,"gender":false}]};//获取jason对象中p的数组let p1 = person.p;for (let i=0;i < p1.length; i++){alert(p1[i].name);}</script>

3,Json数据和Java对象的相关转换

*json的解析器常见的解析器：Jasonlib   Gson   fastjson    jackson1，Json转换为Java对象1,使用步骤1，导入jackson相应的jar包2，创建jackson的核心对象    ObjectMapper3，调用ObjectMapper的相关方法进行转换1，readValue(json字符串数据,转换的对象类型.Class)2，Java对象转换为Json1,使用步骤1，导入jackson相应的jar包2，创建jackson的核心对象    ObjectMapper3，调用ObjectMapper的相关方法进行转换package test;import domain.Person;
import org.codehaus.jackson.map.ObjectMapper;
import org.junit.Test;import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;public class JacksonTest {/*1，导入jackson相应的jar包2，创建jackson的核心对象    ObjectMapper3,调用ObjectMapper的相关方法进行转换* *///java对象转换为json字符串@Testpublic void test() throws Exception {//创建person对象Person p=new Person();p.setName("张三");p.setAge(23);p.setGender("男");//创建jackson核心对象ObjectMapper mapper=new ObjectMapper();//转换/** 转换方法：*   writeValue(参数1，obj)*       参数1：*          File:将obj对象转换为json字符串，并保存到指定的文件中*          Writer:将obj对象转换为json字符串，并将json数据填充到字符输出流中*          OutputStream:将obj对象转换为json字符串，并将json数据填充到字节输出流中*       writeValueAsString(obj):将对象转换为json对象* *///String json=mapper.writeValueAsString(p);//System.out.println(json);//{"name":"张三","gender":"男","age":23}//将数据写到d://a.txt中//mapper.writeValue(new File("d://a.txt"),p);//将数据写到d://b.txt中，采用字符输出流mapper.writeValue(new FileOutputStream("d://b.txt"),p);}
}

2，注解

1，@JsonIgnore:排除属性2，@JsonFormat:属性值的格式化加在实体类的定义变量上或者getXxx上面都行

3，复杂Java对象转换

1，List:数组2，Map:对象格式一样public void test3() throws Exception {//创建person对象Person p=new Person();p.setName("张三");p.setAge(23);p.setGender("男");Person p1=new Person();p1.setName("李四");p1.setAge(22);p1.setGender("男");Person p2=new Person();p2.setName("王五");p2.setAge(21);p2.setGender("女");List<Person> list=new ArrayList<Person>();list.add(p);list.add(p1);list.add(p2);//创建jackson核心对象ObjectMapper mapper=new ObjectMapper();String json=mapper.writeValueAsString(list);System.out.println(json);
}

Redis

1,NoSQL

NoSQL：即Not-Nnly SQL（泛指菲关系型数据库），作为关系型数据库的补充。

作用：应对基于海量用户和海量数据前提下的数据处理问题。

特征：

可扩容，可伸缩大数据量下高性能灵活的数据模型高可用

常见的NoSQL数据库有：

RedismemcacheHBaseMongoDB

Redis

概念：Redis（REmote DIctionary Service）是用c语言开发的一个开源的高性能键值对（key-value）数据库。

特征：

数据间没有必然的关联关系
内部采用单线程机制进行工作
高性能。官方提供测试数据，50个并发执行100000个请求，读的速度是110000次/s，写的速度是81000次/s。
多数据类型支持：

字符串类型 String

列表类型 List（LinkedList）

散列类型 hash（HashMap）

集合类型 set（HashSet）

有序集合类型 sorted_set（TreeSet）

持久化支持。可以进行数据灾难恢复
Redis的应用
为热点数据加速查询（主要场景），如热点商品，热点新闻，热点资讯，推广类等高访问量信息等
任务队列，如秒杀，抢购、购票排队等
即时信息查询，如各种排行榜，各类网站访问统计，公交到站信息、在线人数信息等
时效性信息控制，如验证码控制，投票控制等
分布式数据共享，如分布式集群架构中的session分离
消息队列
分布式锁

2，下载安装

1，Windows建议3.0版本Linux建议4.0以上版本2，解压使用*redis.windows.conf:配置文件*redis-cli.exe：redis的客户端*redis-server.exe：redis服务器端

3，命令操作

1，redis存储的时:key,value格式的数据，其中key都是字符串，value有5中不同的数据结构*value的数据结构1，字符串类型：string2，哈希类型:hash：map格式3，列表类型：list:linkedlist格式：支持重复元素4，集合类型：set:不允许重复元素5，有序集合类型 sortedset：不允许重复元素，且元素是有序的2，字符串类型1，存储：set    key   value2，获取：get    key3,删除：del    key3，哈希类型   hash1，hset key  filed  value2，获取:*hget  key   filed:获取指定的filed的值*hgetall  key：获取所有的filed和value3,删除 ：hdel   key   filed4,列表类型：list:可以添加一个元素到元素的左边或者右边1，添加：lpush    key   value  :将元素加入到列表的左侧rpush   key   value :将元素加入到元素的右侧2，获取lrange  key  start  end:范围获取0   -1范围表示获取所有3，删除lpop  key:删除列表左边的元素，并将元素返回rpop  key:删除列表右边的元素，并将元素返回5，集合   set1,存储：sadd  key   value:2，获取：smembers  key:获取set集合中的所有元素3，删除：srem  key  value:删除set集合中的某个元素6，有序集合   sortedset:不允许重复元素，且元素有顺序1，存储：zadd  key  score  value2，获取：zrange  key  start  end3，删除：zrem    key   value:7.通用命令1，keys  *:查询所有的键2，type  key:获取键对应的value的类型3，del   key:删除指定的key  value

4,持久化

1,redis是一个内存数据库，当redis服务器重启，或者电脑重启，数据会丢失，我们可以将redis内存中的数据持久化存储到硬盘当中2，redis持久化机制1,ROB：默认方式，不需要进行配置，默认就使用这种机制*在一定事件间隔内，检测到key的变化情况，然后持久化数据1，编译redis.windows.conf文件save 900 1当key在900秒事件内改变，就持久化数据一次save 300 10save 60 100002，重启redis服务器，并指定配置文件名称在控制台操作 redis-server.exe redis.windows.conf2.AOF:日志记录的方式，可以记录每一条命令的操作，进行每一次的命令操作之后，持久化数据(和关系型数据库比较相似)1，编辑redis.windows.conf文件appendonly  no(关闭AOF)------->appendonly   yes（开启AOF）#appendfsync always：表示每一次操作都进行持久化appendfsync everysec：每隔一秒进行一次持久化#appendfsync no：不进行持久化

5，Java客户端 Jedis

*Jedis：一款Java操作redis数据库的工具使用步骤：1，下载jedis的jar包2，使用//获取连接Jedis jedis=new Jedis("127.0.0.1", 6379);//操作jedis.set("username","zhangsan");//关闭连接jedis.close();*Jedis操作1，string操作//获取连接
//如果在构造函数中不传入值，则默认端口号为localhost，端口号为6379
Jedis jedis=new Jedis("127.0.0.1", 6379);
//操作
String username=jedis.set("username", "zhang");
System.out.println(username);
String checkcode=jedis.setex("checkcode", 30, "success");
System.out.println(checkcode);
//关闭连接
jedis.close();2，hash操作//获取连接//如果在构造函数中不传入值，则默认端口号为localhost，端口号为6379Jedis jedis=new Jedis("127.0.0.1", 6379);jedis.hset("user","name","zhangsan");jedis.hset("user","age","12");jedis.hset("user","gender","male");String user=jedis.hget("user", "name");System.out.println(user);Map<String, String> map=jedis.hgetAll("user");//遍历map集合Set<String> set=map.keySet();for (String key : set) {String value=map.get(key);System.out.println("key="+key+" : value="+value);}//通过迭代器来获取值
//        Iterator<Map.Entry<String, String>> iterator=map.entrySet().iterator();
//        while(iterator.hasNext()){
//            Map.Entry<String, String> next=iterator.next();
//            System.out.println("key="+next.getKey()+": value="+next.getValue());
//        }//关闭连接jedis.close();}3，list的操作//获取连接
//如果在构造函数中不传入值，则默认端口号为localhost，端口号为6379
Jedis jedis=new Jedis("127.0.0.1", 6379);
//操作
//从左边插入
jedis.lpush("alist","c","b","a");
//从右边插入
jedis.rpush("alist","e","f","g");List<String> list=jedis.lrange("alist", 0, -1);
System.out.println(list);
//关闭连接
jedis.close();4，set的操作//如果在构造函数中不传入值，则默认端口号为localhost，端口号为6379Jedis jedis=new Jedis("127.0.0.1", 6379);//操作jedis.sadd("set","java","c",".net");Set<String> set=jedis.smembers("set");System.out.println(set);//关闭连接jedis.close();5，sortSet//获取连接
//如果在构造函数中不传入值，则默认端口号为localhost，端口号为6379
Jedis jedis=new Jedis("127.0.0.1", 6379);
//操作
jedis.zadd("myset",2,"熊的力量");
jedis.zadd("myset",30,"贾科斯");
jedis.zadd("myset",60,"豹女");Set<String> set=jedis.zrange("myset", 0, -1);System.out.println(set);
//关闭连接
jedis.close();

个人Tomcat复习篇相关推荐

Tomcat 原理篇
TOMCAT 原理篇一.Tomcat 组成(Tomcat 由以下组件组成) 1.server a) Server是一个Catalina Servlet容器: b) Server 可以包含一个或多个s ...
C语言复习篇之数组与指针
C语言复习篇之数组与指针学习了一段时间的嵌入式linux了,学习中有很多的东西需要总结,有经验有教训,我觉得把他写下来会更好,就当做是一种笔记的形式,记录学习中的点点滴滴,不仅仅自己可以经常复习,也 ...
用不同的姿势求逆序对（复习篇）
用不同的姿势求逆序对(复习篇) 文章目录用不同的姿势求逆序对(复习篇) 前言讲解归并排序树状数组线段树题目思路代码归并排序求逆序对树状数组求逆序对线段树求逆序对历届试题小朋友 ...
最小生成树，回忆复习篇。
最小生成树,回忆复习篇. 以前听过一遍最小生成树,可惜,当时没弄会.过了几天就全忘了.而如今在做LCA的时候,woc我居然不会最小生成树了. 所以来回忆一下最小生成树. kruskal算法.这个算法的 ...
NOIP复习篇———动态规划
NOIP复习篇---动态规划 ------------------------------------------------------------------------------------- ...
NOIP复习篇———贪心
NOIP复习篇---贪心 --------------------------------------------------------------------------------------- ...
NOIP复习篇———枚举
NOIP复习篇---枚举 --------------------------------------------------------------------------------------- ...
Android期末复习篇_传智课后习题以及答案（选择、填空、判断、简答、编码题）
写在前面此为移动应用开发传智课后习题及答案,供期末复习使用,注意答案仅供参考加粗题目为强调题型涉及:选择.判断.填空.简答.编程题另8章习题及答案汇总:Android期末复习篇_8章节练习题 ...
扩展欧几里得复习篇。
扩展欧几里得复习篇. 由于多校考了欧几里得,所以这里复习一波扩欧. 这里主要讲解利用扩欧求解二元一次方程的整数解问题. 0.求解: a x + b y = g c d ( a , b ) ax+by= ...

个人Tomcat复习篇

个人Tomcat复习篇相关推荐

最新文章

热门文章