Java Web学习

Java Web学习记录

上一篇：https://blog.csdn.net/rulerrr_r/article/details/123098524

这部分学到了Tomcat配置，web相关内容：

开始：
关于获取某个文件的路径，以后不需要使用相对绝对路径了，直接把它放到和这个源码同一个文件夹下，在这个类中使用：
类名.class.getClassLoader.getResource(“要找到的文件的全名”).getPath();
返回值是个字符串，绝对路径。
URL url=new URL(“网址”);//代表了网络中的一个统一资源定位符，直接new
Document document=Jsoup.parse(url,10000(超时时间));
System.out.println(document);
这个可以返回网站的html或者xml，也就是源码

使用Jsoup进行获取document之后可以使用选择器或者Xpath进行筛选，
选择器是使用：标签元素名[属性名=‘属性值’] 子标签元素名[属性名=‘属性值’]…这样选择出来得到的是Elements列表，使用get取出的就是原级标签
Xpath是使用：//标签元素名[@属性名=‘属性值’]/子标签元素名[@属性名=‘属性值’]…这样取出来是JxNodes列表，直接打印和打印Elements列表是一样的
打印Elements是不带[]的，但是打印JxNodes带有[]

打印element元素和打印element.html()是不一样的，element元素也会带着他本身的标签，但是打印html是没有他本身的标签的，只有内部的信息；
打印text()也是只有内部信息，但是是内部的文本，没有内部的标签。

JavaWeb基础回顾：
1.静态资源和动态资源：
静态资源：所有用户访问时，得到的结果是一样的，成为静态资源，静态资源可以直接被浏览器解析
：html，css，JavaScript
动态资源：每个用户访问后得到的结果不同，称为动态资源；被访问后，需要先转换为静态资源，然后交还给浏览器。
：sevelet/jsp，php，asp
（资源放在服务器端，浏览器端需要向服务器请求数据，服务器响应）
网络通信三要素：
1.IP：电子设备（计算机）在网络中唯一标识
2.端口：应用程序在计算机中的唯一标识。0-65536
3.传输协议：确定了传输规则
1.tcp：安全协议 ，稍慢
2.udp：不安全协议 ，快

Tomcat：Web服务器软件
4.启动项：
bin/startup.bat,双击运行启动
访问：浏览器输入：http://localhost:8080 (ip地址+端口号)，可以访问本地的tomcat
http://ip地址:8080，可以访问其他计算机上的tomcat

以下部分代码较多：

					  dom命令：1.ipconfig：获取本地ip
							   2.netstat -ano：获取端口号
					  在Tomcat的配置文件中有个sever.xml，更改里面的port的端口号就可以变更Tomcat的端口号。（不只有port，别的也需要，但不建议做更改）
					  http协议的默认端口号是80
					  
					  配置服务器：
						1.将html文件打成.war包，放到webapps下即可自动解压（压缩成zip，改名）
						2.在conf的server.xml文件下的<Host>标签体中配置：
							<Context docBase="(html的绝对路径)" path="/.../...(虚拟路径)"/>
							这样的话只需要在地址栏里输入虚拟路径即可
						3.在conf、Catalina、localhost创建任意名称的xml文件，在文件中编写
							<Context docBase="(html的绝对路径)" />
							这样的话在地址栏里输入该文件名称作为虚拟路径
							
							
					  1.创建JavaEE项目
					  2.定义一个类，实现Servlet接口
					  3.实现接口中的抽象方法
					  4.配置Servlet（在web.xml中的<web-app>中配置）
						<servlet>
							<servlet-name>domo1</servlet-name>(这里随便起一个名称)
							<servlet-class>cn.itcast.Tomcat_L.Demo01.demo01</servlet-class>（找到了类全名便定位服务器的servlet，调用其中的service方法）
						</servlet>
						<servlet-mapping>
							<servlet-name>domo1</servlet-name>
							<url-pattern>/demo1</url-pattern>（浏览器发布请求后，通过这个url去找servlet-class）
						</servlet-mapping>
						
						在Edit Configurations里面可以改变服务器的虚拟路径
						改变后：localhost:8080/虚拟路径/servlet名称
						
						*在上边的servlet标签内加入<load-on-startup></load-on-startup>标签，可以选择init函数执行的时间：
						负数：在访问时执行
						非负数：在服务器加载成功时执行
						
						▲：不使用配置文件Web.xml来配置URL和资源路径：
						使用注解：
						在类前边加上：@WebServlet("/资源路径名称")（合起来就是资源路径，就是地址栏里边要写的路径）
						原本：@WebServlet(urlPatterns = "/资源路径名称")
						或者：@WebServlet(value = "/资源路径名称")
						但是value作为可以省略的部分 不写（只有一个属性的时候可以不写value，几乎所有的注解都可以省略value）
						
						
						
						总结：创建在web下边的html文件可以在浏览器中直接在虚拟路径后边加上这个文件名即可访问；
							  创建在src中的class文件需要注解部署配置文件，然后在虚拟路径后边输入资源路径即可
							  （一个项目下或者一个模块下使用一个虚拟路径）
							  WEB-INF下边的html文件无法被浏览器访问，所以不要放到它下边
							  
						配置资源路径时的urlpattern，这个里边可以加入多个资源路径（urlpattern要求的是个数组）
						也可以传入这种定义规则的路径：
							/xxx
							/xxx/xxx
							*.do    (后边这个do写成什么都可以)
							/*		(这个后边写几层路径都可以)
							
							
							关于表单提交到服务器并且做出一定动作：首先这个服务器资源（Servlet）路径要给定好，然后表单的action属性值要设置为这个资源路径，
							资源类要继承HttpServlet类，覆写其中的doGet和doPost函数，设置好相应的动作；注意不要清空覆写service方法，否则无效。
							到表单页面去，提交，会跳转到资源类页面去。
							
							
							
	# 今日内容：
		1. Servlet
		2. HTTP协议
		3. Request

	## 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. /xxx：路径匹配
					2. /xxx/xxx:多层路径，目录结构
					3. *.do：扩展名匹配

	## HTTP：
		* 概念：Hyper Text Transfer Protocol 超文本传输协议
			* 传输协议：定义了，客户端和服务器端通信时，发送数据的格式
			* 特点：
				1. 基于TCP/IP的高级协议
				2. 默认端口号:80
				3. 基于请求/响应模型的:一次请求对应一次响应
				4. 无状态的：每次请求之间相互独立，不能交互数据

			* 历史版本：
				* 1.0：每一次请求响应都会建立新的连接
				* 1.1：复用连接

		* 请求消息数据格式
			1. 请求行
				请求方式 请求url 请求协议/版本
				GET /login.html	HTTP/1.1

				* 请求方式：
					* HTTP协议有7中请求方式，常用的有2种
						* GET：
							1. 请求参数在请求行中，在url后。
							2. 请求的url长度有限制的
							3. 不太安全
						* POST：
							1. 请求参数在请求体中
							2. 请求的url长度没有限制的
							3. 相对安全
			2. 请求头：客户端浏览器告诉服务器一些信息
				请求头名称: 请求头值
				* 常见的请求头：
					1. User-Agent：浏览器告诉服务器，我访问你使用的浏览器版本信息
						* 可以在服务器端获取该头的信息，解决浏览器的兼容性问题

					2. Referer：http://localhost/login.html
						* 告诉服务器，我(当前请求)从哪里来？（显示主页的URL）
							* 作用：
								1. 防盗链：
								2. 统计工作：
			3. 请求空行
				空行，就是用于分割POST请求的请求头，和请求体的。
			4. 请求体(正文)：
				* 封装POST请求消息的请求参数的 （GET请求就没有请求体了，都在请求方式的URL中）

			* 字符串格式：
				POST /login.html	HTTP/1.1
				Host: localhost
				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
				
				username=zhangsan	


			HttpServletRequest重要方法：
			获取虚拟目录：getContextPath():只获取虚拟目录，而不获取资源路径
			获取请求URI：getRequestURI();
					URL: getRequestURL();
			获取请求头：getHeader(String headerName):
						getHeaderNames();得到Enumeration<String> 这样的和迭代器一样的东西，使用它进行遍历时有类似于迭代器的方法
						
			获取请求体：getReader() :获取字符输入流
						getInputStream() ：获取字节输入流
		
			同时，getParameterNames() ,也返回的是一个Enumeration<String> 使用遍历方式和上边说的一样
			
			
			*******（直接输入URL访问网址是Get请求）*******
	


	## 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():		/day14/demo1
							* StringBuffer getRequestURL()  :http://localhost/day14/demo1

							* URL:统一资源定位符 ： http://localhost/day14/demo1	中华人民共和国
							* URI：统一资源标识符 : /day14/demo1					共和国
						
						6. 获取协议及版本：HTTP/1.1
							* String getProtocol()

						7. 获取客户机的IP地址：
							* String getRemoteAddr()
						
				2. 获取请求头数据
					* 方法：
						* (*)String getHeader(String name):通过请求头的名称获取请求头的值
						* Enumeration<String> getHeaderNames():获取所有的请求头名称
					
				3. 获取请求体数据:
					* 请求体：只有POST请求方式，才有请求体，在请求体中封装了POST请求的请求参数
					* 步骤：
						1. 获取流对象
							*  BufferedReader getReader()：获取字符输入流，只能操作字符数据
							*  ServletInputStream getInputStream()：获取字节输入流，可以操作所有类型数据
								* 在文件上传知识点后讲解

						2. 再从流对象中拿数据
					
					
			2. 其他功能：
				1. 获取请求参数通用方式：不论get还是post请求方式都可以使用下列方法来获取请求参数
					1. String getParameter(String name):根据参数名称获取参数值    username=zs&password=123
					2. String[] getParameterValues(String name):根据参数名称获取参数值的数组  hobby=xx&hobby=game
					3. Enumeration<String> getParameterNames():获取所有请求的参数名称
					4. Map<String,String[]> getParameterMap():获取所有参数的map集合

					* 中文乱码问题：
						* get方式：tomcat 8 已经将get方式乱码问题解决了
						* post方式：会乱码
							* 解决：在获取参数前，设置request的编码request.setCharacterEncoding("utf-8");
				
						
				2. 请求转发：一种在服务器内部的资源跳转方式
					1. 步骤：
						1. 通过request对象获取请求转发器对象：RequestDispatcher getRequestDispatcher(String path)
						2. 使用RequestDispatcher对象来进行转发：forward(ServletRequest request, ServletResponse response) 

					2. 特点：
						1. 浏览器地址栏路径不发生变化
						2. 只能转发到当前服务器内部资源中。
						3. 转发是一次请求
						4. 套娃转发会直接找不到页面

				3. 共享数据：
					* 域对象：一个有作用范围的对象，可以在范围内共享数据
					* request域：代表一次请求的范围，一般用于请求转发的多个资源中共享数据
					* 方法：
						1. void setAttribute(String name,Object obj):存储数据
						2. Object getAttitude(String name):通过键获取值
						3. void removeAttribute(String name):通过键移除键值对

				4. 获取ServletContext：
					* ServletContext getServletContext()
				



	## 案例：用户登录
		* 用户登录案例需求：
			1.编写login.html登录页面
				username & password 两个输入框
			2.使用Druid数据库连接池技术,操作mysql，day14数据库中user表
			3.使用JdbcTemplate技术封装JDBC
			4.登录成功跳转到SuccessServlet展示：登录成功！用户名,欢迎您
			5.登录失败跳转到FailServlet展示：登录失败，用户名或密码错误


		* 分析

		* 开发步骤
			1. 创建项目，导入html页面，配置文件，jar包
			2. 创建数据库环境
				CREATE DATABASE day14;
				USE day14;
				CREATE TABLE USER(
				
					id INT PRIMARY KEY AUTO_INCREMENT,
					username VARCHAR(32) UNIQUE NOT NULL,
					PASSWORD VARCHAR(32) NOT NULL
				);

			3. 创建包cn.itcast.domain,创建类User
				package cn.itcast.domain;
				/**
				 * 用户的实体类
				 */
				public class User {
				
					private int id;
					private String username;
					private String password;
				
				
					public int getId() {
						return id;
					}
				
					public void setId(int id) {
						this.id = id;
					}
				
					public String getUsername() {
						return username;
					}
				
					public void setUsername(String username) {
						this.username = username;
					}
				
					public String getPassword() {
						return password;
					}
				
					public void setPassword(String password) {
						this.password = password;
					}
				
					@Override
					public String toString() {
						return "User{" +
								"id=" + id +
								", username='" + username + '\'' +
								", password='" + password + '\'' +
								'}';
					}
				}
			4. 创建包cn.itcast.util,编写工具类JDBCUtils
				package cn.itcast.util;

				import com.alibaba.druid.pool.DruidDataSourceFactory;
				
				import javax.sql.DataSource;
				import javax.xml.crypto.Data;
				import java.io.IOException;
				import java.io.InputStream;
				import java.sql.Connection;
				import java.sql.SQLException;
				import java.util.Properties;
				
				/**
				 * JDBC工具类 使用Durid连接池
				 */
				public class JDBCUtils {
				
					private static DataSource ds ;
				
					static {
				
						try {
							//1.加载配置文件
							Properties pro = new Properties();
							//使用ClassLoader加载配置文件，获取字节输入流
							InputStream is = JDBCUtils.class.getClassLoader().getResourceAsStream("druid.properties");
							pro.load(is);
				
							//2.初始化连接池对象
							ds = DruidDataSourceFactory.createDataSource(pro);
				
						} catch (IOException e) {
							e.printStackTrace();
						} catch (Exception e) {
							e.printStackTrace();
						}
					}
				
					/**
					 * 获取连接池对象
					 */
					public static DataSource getDataSource(){
						return ds;
					}
				
				
					/**
					 * 获取连接Connection对象
					 */
					public static Connection getConnection() throws SQLException {
						return  ds.getConnection();
					}
				}
			5. 创建包cn.itcast.dao,创建类UserDao,提供login方法
				
				package cn.itcast.dao;

				import cn.itcast.domain.User;
				import cn.itcast.util.JDBCUtils;
				import org.springframework.dao.DataAccessException;
				import org.springframework.jdbc.core.BeanPropertyRowMapper;
				import org.springframework.jdbc.core.JdbcTemplate;
				
				/**
				 * 操作数据库中User表的类
				 */
				public class UserDao {
				
					//声明JDBCTemplate对象共用
					private JdbcTemplate template = new JdbcTemplate(JDBCUtils.getDataSource());
				
					/**
					 * 登录方法
					 * @param loginUser 只有用户名和密码
					 * @return user包含用户全部数据,没有查询到，返回null
					 */
					public User login(User loginUser){
						try {
							//1.编写sql
							String sql = "select * from user where username = ? and password = ?";
							//2.调用query方法
							User user = template.queryForObject(sql,
									new BeanPropertyRowMapper<User>(User.class),
									loginUser.getUsername(), loginUser.getPassword());
				
				
							return user;
						} catch (DataAccessException e) {
							e.printStackTrace();//记录日志
							return null;
						}
					}
				}
			
			6. 编写cn.itcast.web.servlet.LoginServlet类
				package cn.itcast.web.servlet;

				import cn.itcast.dao.UserDao;
				import cn.itcast.domain.User;
				
				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("/loginServlet")
				public class LoginServlet extends HttpServlet {
				
				
					@Override
					protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
						//1.设置编码
						req.setCharacterEncoding("utf-8");
						//2.获取请求参数
						String username = req.getParameter("username");
						String password = req.getParameter("password");
						//3.封装user对象
						User loginUser = new User();
						loginUser.setUsername(username);
						loginUser.setPassword(password);
				
						//4.调用UserDao的login方法
						UserDao dao = new UserDao();
						User user = dao.login(loginUser);
				
						//5.判断user
						if(user == null){
							//登录失败
							req.getRequestDispatcher("/failServlet").forward(req,resp);
						}else{
							//登录成功
							//存储数据
							req.setAttribute("user",user);
							//转发
							req.getRequestDispatcher("/successServlet").forward(req,resp);
						}
				
					}
				
					@Override
					protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
						this.doGet(req,resp);
					}
				}

			7. 编写FailServlet和SuccessServlet类
				@WebServlet("/successServlet")
				public class SuccessServlet extends HttpServlet {
					protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
						//获取request域中共享的user对象
						User user = (User) request.getAttribute("user");
				
						if(user != null){
							//给页面写一句话
				
							//设置编码
							response.setContentType("text/html;charset=utf-8");
							//输出
							response.getWriter().write("登录成功！"+user.getUsername()+",欢迎您");
						}
				
				
					}		


				@WebServlet("/failServlet")
				public class FailServlet extends HttpServlet {
					protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
						//给页面写一句话
				
						//设置编码
						response.setContentType("text/html;charset=utf-8");
						//输出
						response.getWriter().write("登录失败，用户名或密码错误");
				
					}
				
					protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
						this.doPost(request,response);
					}
				}



			8. login.html中form表单的action路径的写法
				* 虚拟目录+Servlet的资源路径

			9. BeanUtils工具类，简化数据封装
				* 用于封装JavaBean的
				1. JavaBean：标准的Java类
					1. 要求：
						1. 类必须被public修饰
						2. 必须提供空参的构造器
						3. 成员变量必须使用private修饰
						4. 提供公共setter和getter方法
					2. 功能：封装数据


				2. 概念：
					成员变量：
					属性：setter和getter方法截取后的产物
						例如：getUsername() --> Username--> username


				3. 方法：
					1. setProperty()
					2. getProperty()
					3. populate(Object obj , Map map):将map集合的键值对信息，封装到对应的JavaBean对象中						
									
	
	
	Response类：
		这个类是控制服务器返回给浏览器客户端内容的类
		返回的信息叫作响应信息，也就是响应：
			1.响应行
				包括 协议名称/服务器版本 响应状态 状态描述
					状态就是404 ,504这样的
			2.响应头
				包括键值对：
				1. Content-Type：服务器告诉客户端本次响应体数据格式以及编码格式：Content-Type: text/html;charset=UTF-8
				2. Content-disposition：服务器告诉客户端以什么格式打开响应体数据
					* 值：
						* in-line:默认值,在当前页面内打开
						* attachment;filename=xxx：以附件形式打开响应体。文件下载
				
				3.Content-Length: 101 响应体字节数
				4.Date: Wed, 06 Jun 2018 07:08:42 GMT
			3.响应空行
			4.响应体
				就是页面的源码
	
	1.相对路径：
		要注意当前资源和目标资源的相对位置，"./"和" "都表示在同一个目录下，"../"表示在外层目录下
	
	2.绝对路径：
		绝对路径可以简化，只剩下虚拟路径和资源路径
		而当客户端浏览器使用路径时才需要加上虚拟路径，比如重定向时输入的路径
		但是服务器使用路径时不需要写虚拟路径，只需要用资源路径即可，比如请求转发；
		也正是因此，请求转发的request有数据域，可以进行setAttribute/getAttitude操作，但是重定向的response没有
	请求转发的request.getRequestDispatcher("/FailinLog").forward(request,response);
	使用的是/FailingLog
	只有资源路径
	而重定向redirect()
	里面传递的是绝对路径或者相对路径，也可以使用绝对路径的简写：虚拟路径加资源路径"/Res_test/demo01_response"
	
	🔺使用request.getContextPath()方法可以获取这个服务器类的虚拟路径，建议使用虚拟路径时用：request.getContextPath()+"/资源路径"代替
		   System.out.println(request.getContextPath());
		   System.out.println(request.getServletContext().getContextPath());
		   这两种方式都可以得到这个资源的虚拟路径
		   或者如果说你这个服务器继承了HttpServlet类，则可以直接使用getServletContext().getContextPath();获取
	
	向浏览器输入字符数据：
		PrintWriter getWriter()
		成员方法Write();Print();  （两个好像是通用的）
		这个里边可以加上任意字符，也可以写入html语句，正常显示；
		中文乱码问题：如果编程环境使用的是utf-8则要在获取字符输出流之前加上：response.setContextType("text/html;charset=utf-8");
		这样可以改变浏览器的适宜编码，使编码同步，正常显示中文
		（由于这个方法不需要知道浏览器的偏好编码，所以称为自动适应方法）
	像浏览器输入字节数据：
		ServletOutputStream getOutputStream();
		输入时使用write();方法，里边的字符串需要.getByte()处理，getByte()里边可以传递参数，可以根据setContextType()设置的编码来进行getByte的编码设置（String的getBytes()方法是得到一个系统默认的编码格式的字节数组）
		
		话说为啥字节和字符输出流只有一个能输出过去啊...）
		
	【Graphic】
    int width=100;
    int height=50;
	//创建一个图片对象（流可控制），构造方法传递参数，宽 高 图片类型
    BufferedImage bi=new BufferedImage(width,height,BufferedImage.TYPE_INT_RGB);

    //创建画笔对象
    Graphics graphics=bi.getGraphics();
	//设置画笔颜色
    graphics.setColor(Color.pink);
	//使用填充的方式操作画笔（填充矩形）
    graphics.fillRect(0,0,width,height);

    
    graphics.setColor(Color.BLUE);
	//使用画线的方式操作画笔（画矩形），绘制边框
    graphics.drawRect(0,0,width-1,height-1);
    //绘制字符串
	graphics.drawString(string,x,y);
	//画直线
    graphics.drawLine(x1,x2,y1,y2);

    //使用ImageIO.write方法将这个图片输出到控制台上
    ImageIO.write(bi,"jpg",response.getOutputStream());
	
	ServletContext类：
	1.获取MIME
	2.共享数据
	3.获取（文件）真实路径
	
	
	Cookie：
		cookie设置了setMaxAge(0)之后还是会在response头里看到它，只不过写的是Max-Age=0
		cookie的共享问题：
			在同一个Tomcat的同一个项目下cookie是可以共享的，但是如果不是同一个项目（虚拟路径不一样），则默认情况下是不可共享的；
			设置：setPath("/")这样默认该Tomcat所有路径下的项目都可访问该cookie；
			如果不是一个Tomcat，则需要设置一级域名一致才可以访问cookie。
			使用setDomain("一级域名")，这样的话所有一级域名相同的都可以共享cookie（安装在不同的服务器上是为了减轻服务器负担）
			比如account.bilibili.com
			account是二级域名，.bilibili.com是一级域名
		
	cookie使用的是request的.getCookies()获取所有的传递过来的cookies
	getName()和getValue()是Cookie的成员方法
	response.addCookie()是添加cookie的方法
	
	Session是基于cookie的，使用的是request的.getSession
	这个方法是向客户端请求一次session，返回来的是id，如果在本地找到了相应的id的session，则获得这个session；
	否则将这个session的id发送过去（没有的话会创建一个）那么就出现了新的session配上新的id，cookie里面也是新的id的情况，
	发送id的addCookie在getSession里面。
	关闭客户端，不关服务器；则两次的session是不一样的，因为两次没有获取到session，所以都是新创建了一个；
	这样会session越来越多（不超过销毁时间）
	设置cookie-JSESSIONID的maxage可以保持一个session的使用