Vllos笔记-javaweb

JavaWeb

Java核心： tr.jar
bin:启动关闭的脚本文件
conf：配置
lib:依赖的jar包
logs：日志
webapps：存放网站的
work:工作区

常用默认端口号：
tomcat:8080
mysql:3306
http:80
https:443

面试题：
谈谈网站是如何进行访问的？
1：输入一个域名，回车 如：www.baidu.com
2：检查本机的C:\Windows\System32\drivers\etc\hosts配置文件下有没有这个域名映射
1：有：直接返回对应的ip地址，这个地址中有我们需要访问的web程序，可以直接访问
2：没有：去DNS服务器(存放全世界域名的云)找，找到的话就返回，找不到就返回找不到

改系统端口号在系统配置文件下：C:\Windows\System32\drivers\etc\hosts,增加就行

面试题：
tomcat端口号在配置文件下：server.xml的标签里改name属性为其他为什么访问不到？如：www.vllos. com

解决：原因解析不了ip地址
	改系统端口号在系统配置文件下：C:\\Windows\System32\drivers\etc\hosts,增加就行

面试题：
当你的浏览器中地址栏输入地址并回车的一瞬间到页面能够展示回来，经历了什么？

classpath: //类路径
java和resources都在里面

面试题：
重定向与转发的区别：

	相同：页面都会实现跳转
	不同点：
		请求转发的时候，url不会产生变化
	    重定向的时候，url地址栏会发生变化   

#JavaWeb基础

web开发：
	静态web：
	动态web：技术栈：Servlet/JSP、ASP\PHP
	
		在Java中，动态web资源开发d的技术统称为Javaweb
		
web应用程序
	可以提供浏览器访问的程序
	一个web应用程序由多部份组成
		html,css,js
		jsp,servlet
		java程序
		jar包
		配置文件properties

1. Tomcat:web服务器讲解

   工作三年后，可以尝试手写Tomcat
   
   	tomcat默认端口号:8080
   
   		改tomcat端口号在配置文件下：server.xml:
   		
   		<Connector>标签
   		
   		<Engine>标签是引擎，不改
   		
   		<Host>标签里改name属性为其他为什么访问不到？如：www.vllos.com
   	
   		改系统端口号在系统配置文件下：C:\\Windows\System32\drivers\etc\hosts,增加就行
   		
   	写一个web网站：
   		copy webapps下的root文件，留WEB-INF里的web.xml
   		新建：index.jsp  自己写
   		
   		http://8080/examples/servlets/里面有很多静态网页源码
   		将自己写的网站，放到服务器(Tomcat)中指定的web应用的文件夹下webapps，就可以访问了
   		
   		
   	webapps:Tomcat服务器的web目录：
   		-ROOT
   		-Vllos：网站的目录名		
   			-WEB-INF:
   				-classes: java程序
   				-lib: web应用所依赖的jar包
   				-web.xml: 网站的配置文件
   			-index.html： 默认的首页
   			-static
   				-css
   					-style.css
   				-js
   				-img
   

2. Http讲解：

   http(超文本传输协议)是一个简单的请求-响应协议，它通常运行在TCP之上。
   	
   	文本：html、字符串...
   	超文本：图片、音乐、视频、定位、地图...
   
   https:安全的
   
   两个时代：
   		http1.0:
   			http/1.0:客户端与web服务器连接后，只能获得一个web资源，就断开连接
   		http2.0:
   			http/1.1：客户端与web服务器连接后，可以获得多个web资源
   			
   http请求：
   	URL：  请求地址
   	Method: GET或者POST    //get方法/post方法   
   								get和post的区别：
   											get：请求能够携带的参数比较少，大小有限制，
   												会在浏览器的URL地址栏显示数据内容，不安全但高效
   											post：和get完全相反
   	Status Code:200  OK    //状态码：200
   	Remote Address:...     //远程地址
   
   
   http响应：
   	
   	响应状态码：
   				200  ：请求响应成功 
   				3xx  ：请求重定向
   							重定向:你重新到我给你新位置去
   				4xx  ：找不到资源 404
   							资源不存在
   				5xx  ：服务器代码错误
   							502：网关错误
   

3. Maven：

   核心思想：约定大于配置
   解压bin
   

4. Servlet:

   入门：
   	开发动态web的一门技术
   	sun公司在这些API中提供一个接口叫：Servlet，如果你想开发一个servlet程序，
   	只需要两步：
   			1：编写一个类，实现Servlet接口			//有实现类可以直接被继承：HttpServlet
   			2：把开发好的Java类部署到web服务器中
   			
   	把实现了Servlet接口的Java程序叫做，Servlet
   	
   	具体步骤如下：
   		1:	建maven工程
   		2：编写一个类实现Servlet接口，
   		`public class HelloServlet extends HttpServlet{
   			
   			@Override
   			protected void doGet(HttpServletRequest req,HttpServletResponse resp) throws ServletException,IOException {
   				PrintWriter writer = resp.getWriter();
   				writer.print("Hello,Servlet");
   			}
   			
   			@Override
   			protected void doPost(HttpServletRequest req,HttpServletResponse resp) throws ServletException,IOException {
   			
   			}
   		}`
   		
   		
   		3:编写Servlet的映射
   			为什么需要映射？我们写的是Java程序，但是要通过浏览器访问，而浏览器需要连接web服务器，
   			所以我们需要在web服务中注册我们写的Servlet，还需给他一个浏览器能够访问的路径
   	
   			在web.xml中：
   

<!--注册Servlet-->
					<servlet>
						<servlet-name>hello</servlet-name>
						<servlet-class>com.vllos.servlet.HelloServlet</servlet-class>
					</servlet>
					<!--Servlet的请求路径-->
					<servlet-mapping>
						<servlet-name>hello</servlet-name>
						<url-pattern>hello</url-pattern>
					</servlet-mapping>

			4:配置Tomcat:
				注意：要配置项目发布的路径  Deployment -->Application context:随便写
				
			5:启动测试
		
	Servlet原理：
		Servlet是由web服务器调用，web服务器在收到浏览器请求之后，会：
	![Servlet原理](https://img-blog.csdnimg.cn/20200821082246362.PNG?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2OTMxODc2,size_16,color_FFFFFF,t_70#pic_center)

	
		Mapping问题：请求映射的路径：		
			1：一个servlet可以指定一个映射路径：
				<url-pattern>hello</url-pattern>  //一般使用
			2：一个servlet可以指定多个映射路径：
				<url-pattern>hello</url-pattern>
				<url-pattern>hello1</url-pattern>
				...
			3：一个servlet可以指定通用映射路径：
				<url-pattern>hello/*</url-pattern>
			4：默认请求路径：
				<url-pattern>/*</url-pattern>     //一般不这样用
			5:指定一些后缀或者前缀等...//注意点：*前面不能加映射的路径
				<url-pattern>*.do</url-pattern>
				
		
		
			6：自定义404：

自定义404：
					public class HelloServlet extends HttpServlet{
						
						@Override
						protected void doGet(HttpServletRequest req,HttpServletResponse resp) throws ServletException,IOException {
							resp.setContentType("text/html");
							resp.setCharacterEncoding("utf-8");
							
							PringWriter writer = resp.getWriter();
							writer.print("<h1>404</h1>");
						}
						
						@Override
						protected void doPost(HttpServletRequest req,HttpServletResponse resp) throws ServletException,IOException {
						
						}
					}
				
				
					<!--404-->
					<servlet>
						<servlet-name>error</servlet-name>
						<servlet-class>com.vllos.servlet.ErrorServlet</servlet-class>
					</servlet>
					<!--Servlet的请求路径-->
					<servlet-mapping>
						<servlet-name>error</servlet-name>
						<url-pattern>/*</url-pattern>
					</servlet-mapping>

			7:优先级：
				指定了固有的映射路径优先级最高，如果找不到就会走默认的处理请求
				
			
	
		ServletContext:
			web容器在启动时，会为每个web程序都创建一个对应的ServletContext对象，代表当前的web应用
			
			1:共享数据
				在这个servlet中保存的数据，可以在另外一个servlet中拿到
				
				1:放置的类:HelloServlet

                        //HelloServlet
						public class HelloServlet extends HttpServlet{
							
							@Override
							protected void doGet(HttpServletRequest req,HttpServletResponse resp) throws ServletException,IOException {
								ServletContext context = this.getServletContext();
								
								String username = "硬币"
								context.setAttribute("username",username);//将一个数据保存在了ServletContext中，名字为：username 值：username
							}
						}

				2:读取的类：GetServlet

//GetServlet
						public class GetServlet extends HttpServlet{
						
							@Override
							protected void doGet(HttpServletRequest req,HttpServletResponse resp) throws ServletException,IOException {
								ServletContext context = this.getServletContext();
								String username = (String) context.getAttribute("username");
								
								resp.setContentType("text/html");
								resp.setCharacterEncoding("utf-8");
								resp.getWriter().print("名字："+username);
							}
							@Override
							protected void doPost(HttpServletRequest req,HttpServletResponse resp) throws ServletException,IOException{...}
						}
			

				3:配置xml

<servlet>
							<servlet-name>hello</servlet-name>
							<servlet-class>com.vllos.servlet.HelloServlet</servlet-class>
						</servlet>
						<!--Servlet的请求路径-->
						<servlet-mapping>
							<servlet-name>hello</servlet-name>
							<url-pattern>/hello</url-pattern>
						</servlet-mapping>
						
						<servlet>
							<servlet-name>getc</servlet-name>
							<servlet-class>com.vllos.servlet.GetServlet</servlet-class>
						</servlet>
						<!--Servlet的请求路径-->
						<servlet-mapping>
							<servlet-name>getc</servlet-name>
							<url-pattern>/getc</url-pattern>
						</servlet-mapping>

				4:测试访问结果
				
			2:获取初始化参数
			
			3：请求转发

public class ServletDemo01 extends HttpServlet{
						
							@Override
							protected void doGet(HttpServletRequest req,HttpServletResponse resp) throws ServletException,IOException {
								ServletContext context = this.getServletContext();
								//RequestDispatcher requestDispatcher = context.getRequestDispatcher("/hello"); //转发的请求类路径
								//requestDispatcher.forword(req,resp);//调用forward实现请求转发
								context.getRequestDispatcher("/hello").forword(req,resp);
							}
							@Override
							protected void doPost(HttpServletRequest req,HttpServletResponse resp) throws ServletException,IOException{
								doGet(req,resp);
							}
						}
						
						
						<servlet>
							<servlet-name>sd4</servlet-name>
							<servlet-class>com.vllos.servlet.ServletDemo01</servlet-class>
						</servlet>
						<!--Servlet的请求路径-->
						<servlet-mapping>
							<servlet-name>sd4</servlet-name>
							<url-pattern>/sd4</url-pattern>
						</servlet-mapping>
				

5. HttpServletResponse、HttpServletRequest

   	HttpServletResponse
   		web服务器接收到客户端的http请求，针对这个请求，分别创建一个代表请求的HttpServletRequest对象，代表响应的一个HttpServletResponse
   		
   			如果要获取客户端请求过来的参数：找HttpServletRequest
   			如果要给客户端响应一些信息：找HttpServletResponse
   			
   			简单分类：
   				1：负责向浏览器发送数据的方法
   					1:ServletOutputStream getOutputStream()throws IOException;
   					2:PrintWriter getWriter() throws IOException;
   					
   				2：负责向浏览器发送响应头的方法
   	
   				3:响应的状态码
   				
   			常见应用：
   				1：向浏览器输出消息
   					
   				2：下载文件
   					1：要获取下载文件的路径
   					2：下载的文件名
   					3：设置让浏览器能够支持下载我们需要的东西
   					4：获取下载文件的输入流
   					5：创建缓冲区
   					6：获取OutputStream对象
   					7：将FileOutputStream流写入到buffer缓冲区,使用OutputStream将缓冲区中的数据输出到客户端
   

                        public class FileServlet extends HttpServlet{
						
							@Override
							protected void doGet(HttpServletRequest req,HttpServletResponse resp) throws ServletException,IOException {
								1：要获取下载文件的路径
								String realPath = ".................\\1.png" //绝对路径
								2：下载的文件名
								String fileName = realPath.substring(realPath.lastIndexOf("\\")+1);
								3：设置让浏览器能够支持(Content-Disposition)下载我们需要的东西,中文文件名URLEncoder.encode编码，否则有可能乱码
								resp.setHeader("Content-Disposition","attachment;filename="+URLEncoder.encode(fileName,"UTF-8"));
								4：获取下载文件的输入流
								FileInputStream in = new FileInputStream(realPath);
								5：创建缓冲区
								int len = 0;
								byte[] buffer = new byte[1024];
								6：获取OutputStream对象
								ServletOutputStream out = resp.getOutputStream();
								7：将FileOutputStream流写入到buffer缓冲区,
								   使用OutputStream将缓冲区中的数据输出到客户端
								while((len=in.read(buffer))>0){
									out.write(buffer,0,len);
								}
								in.close();
								out.close();
							}
							@Override
							protected void doPost(HttpServletRequest req,HttpServletResponse resp) throws ServletException,IOException{
								doGet(req,resp);
							}
						}

					3:验证码功能
						前端实现
						后端实现，需要用到Java的图片类，生产一个图片

                          public class ImageServlet extends HttpServlet{
						
							@Override
							protected void doGet(HttpServletRequest req,HttpServletResponse resp) throws ServletException,IOException {
								//如何让浏览器3秒自动刷新一次
								resp.setHeader("refresh","3")
								//在内存中创建一个图片
								BufferedImage image = new BufferedImage(80,20,BufferedImage.TYPE_INT_RGB);
								//得到图片
								Graphics2D g = (Graphics2D) image.getGraphics();//笔
								//设置图片的背景颜色
								g.setColor(Color.white);
								g.fillRect(0,0,80,20);
								//给图片写数据
								g.setColor(Color.BLUE);
								g.setFont(new Font(null,Font.BOLD,20));
								g.drawString(makeNum(),0,20);
								
								//告诉浏览器这个请求用图片的方式打开
								resp.setContentType("image/jpeg");
								//网站存在缓存，不让浏览器缓存
								resp.setDateHeader("expires",-1);
								resp.setHeader("Cacche-Control","no-cache");
								resp.setHeader("Pragma","no-cache");
								
								//把图片写给浏览器
								ImageIO.write(image,"jpg",resp.getOutputStream());
							}
							
							//生成随机数
							private String makeMun(){
								Random random = new Random();
								String num = random.nextInt(9999999)+"";
								StringBuffer sb = new StringBuffer();
								for(int i = 0;i < 7-num.length();i++){
									sb.append("0");
								}
								num = sb.toString()+num;
								return num;
							}
							
							
							@Override
							protected void doPost(HttpServletRequest req,HttpServletResponse resp) throws ServletException,IOException{
								doGet(req,resp);
							}
						}	
						
						
						<servlet>
							<servlet-name>ImageServlet</servlet-name>
							<servlet-class>com.vllos.servlet.ImageServlet</servlet-class>
						</servlet>
						<!--Servlet的请求路径-->
						<servlet-mapping>
							<servlet-name>ImageServlet</servlet-name>
							<url-pattern>/img</url-pattern>
						</servlet-mapping>
			

					4:实现重定向(重要！！！)
						一个web资源收到客户端请求后，会通知客户端去访问另一个web资源，这个过程叫重定向
						区别![转发和重定向](https://img-blog.csdnimg.cn/20200821082800350.PNG?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2OTMxODc2,size_16,color_FFFFFF,t_70#pic_center)

						resp.sendRedirect("/r/img");  //重定向到img
						
						常用场景：
							用户登录：

                                    1：maven导依赖：jsp
									2：index.jsp
										<html>
										<body>
										<h2>Hello World!</h2>
										<%--这里提交的路径，需要寻找到项目的路径--%>
										<form action="${pageContext.request.contextPath}/login" method="get">
											用户名：<input type="text" name="username"><br>
											密码：<input type="password" name="password"><br>
											<input type="submit">
										</form>
										</body>
										</html>
									3:写一个重定向页面：success.jsp
										<html>
										<head>
											<title>Title</title>
										</head>
										<body>
										
										<h1>Success</h1>
										
										</body>
										</html>
										
									4:
									public class TestcServlet extends HttpServlet{
						
										@Override
										protected void doGet(HttpServletRequest req,HttpServletResponse resp) throws ServletException,IOException {
											//处理请求
											String username = req.getParameter("username");
											String password = req.getParameter("password");
											//重定向一定要注意路径问题
											resp.sendRedirect("/r/success.jsp");
										}
										@Override
										protected void doPost(HttpServletRequest req,HttpServletResponse resp) throws ServletException,IOException{
											doGet(req,resp);
										}
									}
									
									5:
									<servlet>
										<servlet-name>TestcServlet</servlet-name>
										<servlet-class>com.vllos.servlet.TestcServlet</servlet-class>
									</servlet>
									<!--Servlet的请求路径-->
									<servlet-mapping>
										<servlet-name>TestcServlet</servlet-name>
										<url-pattern>/TestcServlet</url-pattern>
									</servlet-mapping>

		HttpServletRequest
			代表客户端请求，用户通过http协议访问服务器，http请求中的所有信息会被封装到HttpServletRequest，
			通过这个HttpServletRequest的方法，获得客户端的所有
			
			1：获取前端传递的参数
				
			2：请求转发

6. 会话：

   	用户打开一个浏览器，点击了很多超链接，访问多个web资源，关闭浏览器，这个过程可以称为会话
   	
   	有状态会话：一个同学来过教室，下次再来教室，我们会知道这个同学，曾经来过，称之为有状态会话
   		
   		
   		一个网站怎么证明你来过？
   			客户端  服务端
   			1：服务端给客户端一个信件，客户端下次访问服务端带上信件就可以了  ：cookie
   			2：服务器登记你来过了，下次来的时候我来匹配你：session
   	
   	保存会话的两种技术：
   		
   		1：Cookie讲解：
   			客户端技术(响应、请求)
   			![Cookie讲解](https://img-blog.csdnimg.cn/20200821082425695.PNG?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2OTMxODc2,size_16,color_FFFFFF,t_70#pic_center)
   
   			常见应用：网站登录之后，下次不用再登录，直接访问就上去了
   			
   			
   				1：从请求中拿到cookie信息
   				2：服务器响应给客户端cookie
   

                                Cookie[] cookie = req.getCookies();//获得cookie
								cookie.getName();//获得cookie中的key
								cookie.getValue(); //获得cookie中的value
								new Cookie("lastLoginTime",System.currentTimeMillis()+"");//新建一个cookie
								cookie.setMaxAge(24*60*60);//设置cookie的有效期
								resp.addCookie(cookie);//响应给客户端一个cookie
							cookie一般会保存在本地的用户目录下appdata
							

                        //保存用户上一次访问的时间
						public class CookieDemo01 extends HttpServlet{
						
							@Override
							protected void doGet(HttpServletRequest req,HttpServletResponse resp) throws ServletException,IOException {
								//服务器 告诉你 你来的时间，把这个时间封装成一个信件，你下次带来，我就知道你来了
								
								//解决中文乱码
								req.setCharacterEncoding("utf-8");
								resp.setCharacterEncoding("utf-8");
								
								PrintWriter out = resp.getWriter();
								
								//Cookie服务器端从客户端获取：
								Cookie[] cookie = req.getCookies();//这里返回数组，说明cookie可能存在多个
								
								//判断cookie是否存在
								if(cookies!=null){
									//如果存在
									out.write("你上一次访问的时间是：");
									
									for(int i = 0; i < cookies.length; i++){
										Cookie cookie = cookie[i];
										//获取cookie的名字
										if(cookie.getName().equals("lastLoginTime")){
											//获取cookie中的值
											long lastLoginTime = Long.parseLong(cookie.getValue());
											Date date = new Date(lastLoginTime);
											out.write(date.toLocaleString());
										}
									}									
								}else{
									out.write("这是您第一次访问本站");
								}
								//服务端给客户端响应一个cookie
								Cookie cookie = new Cookie("lastLoginTime",System.currentTimeMillis()+"");
								//给cookie设置有效期为1天
								cookie.setMaxAge(24*60*60);
								
								resp.addCookie(cookie);
							}
							@Override
							protected void doPost(HttpServletRequest req,HttpServletResponse resp) throws ServletException,IOException{
								doGet(req,resp);
							}
						}
						
						
						<servlet>
							<servlet-name>CookieDemo01</servlet-name>
							<servlet-class>com.vllos.servlet.CookieDemo01</servlet-class>
						</servlet>
						<!--Servlet的请求路径-->
						<servlet-mapping>
							<servlet-name>CookieDemo01</servlet-name>
							<url-pattern>/CookieDemo01</url-pattern>
						</servlet-mapping>

				细节问题：
					一个网站的cookie是否存在上限？
							一个cookie只能保存一个信息
							一个web站点可以给浏览器发送多个cookie，最多存放20个cookie
							cookie大小有限制4kb
							300个cookie浏览器上限
							
					删除cookie：
						不设置有效期，关闭浏览器，自动失效
						设置有效期时间为0
						
					编码解码：

                            URLEncoder.encode("硬币","utf-8")
							URLDecoder.decode(cookie.getValue(),"utf-8")

			2：Session讲解：(重点掌握！！！)
				服务器技术，利用这个技术，可以保存用户的会话信息，我们可以把信息或者数据放在Session中
				![Session原理](https://img-blog.csdnimg.cn/20200821082501226.PNG?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ2OTMxODc2,size_16,color_FFFFFF,t_70#pic_center)

				服务器会给每一个用户(浏览器)创建一个Session对象;
				一个Session独占一个浏览器，只要浏览器没有关闭，这个Session就存在
				用户登录之后，整个网站它都可以访问
				
				使用场景：
					保存一个登录用户的信息
					购物车信息
					在整个网站中经常会使用的数据，我们将它保存在Session中

                          public class SessionDemo01 extends HttpServlet{
						
							@Override
							protected void doGet(HttpServletRequest req,HttpServletResponse resp) throws ServletException,IOException {
								
								//解决乱码问题
								req.setCharacterEncoding("utf-8");
								resp.setCharacterEncoding("utf-8");
								resp.setContentType("text/html;charset=utf-8");
								
								//得到Session
								HtttpSession session = req.getSession();
								
								//给Session中存东西
								session.setAttribute("name","Vllos");
								
								//获取Session的ID
								String id = session.getId();
								
								//判断Session是不是新创建
								if(session.isNew()){
									resp.getWriter().write("session创建成功，ID:"+sessionId);
								}else{
									resp.getWriter().write("session已经在服务器中存在了，ID:"+sessionId);
								}	
							}
							
							
							@Override
							protected void doPost(HttpServletRequest req,HttpServletResponse resp) throws ServletException,IOException{
								doGet(req,resp);
							}
						}
									
									
						

						<servlet>
							<servlet-name>SessionDemo01</servlet-name>
							<servlet-class>com.vllos.servlet.SessionDemo01</servlet-class>
						</servlet>
						<!--Servlet的请求路径-->
						<servlet-mapping>
							<servlet-name>SessionDemo01</servlet-name>
							<url-pattern>/SessionDemo01</url-pattern>
						</servlet-mapping>
									

				Session存取对象：共享数据   //用这个

                        //共享数据
						1：存
						public class SessionDemo02 extends HttpServlet{
						
							@Override
							protected void doGet(HttpServletRequest req,HttpServletResponse resp) throws ServletException,IOException {
								
								//解决乱码问题
								req.setCharacterEncoding("utf-8");
								resp.setCharacterEncoding("utf-8");
								resp.setContentType("text/html;charset=utf-8");
								
								//得到Session
								HtttpSession session = req.getSession();
								
								//给Session中存东西
								session.setAttribute("name",new Person("Vllos",1));
								
								//获取Session的ID
								String id = session.getId();
								
								
							}
							
							
							@Override
							protected void doPost(HttpServletRequest req,HttpServletResponse resp) throws ServletException,IOException{
								doGet(req,resp);
							}
						}
									
						
						2：
						<servlet>
							<servlet-name>SessionDemo02</servlet-name>
							<servlet-class>com.vllos.servlet.SessionDemo02</servlet-class>
						</servlet>
						<!--Servlet的请求路径-->
						<servlet-mapping>
							<servlet-name>SessionDemo02</servlet-name>
							<url-pattern>/SessionDemo02</url-pattern>
						</servlet-mapping>
						
						
						3：写一个实体类：person
						
						public class Person{
							private String name;
							private int age;
							
							//有参无参
							//get/set/toString
							
						}
						
						
						
						4：取
						public class SessionDemo03 extends HttpServlet{
						
							@Override
							protected void doGet(HttpServletRequest req,HttpServletResponse resp) throws ServletException,IOException {
								
								//解决乱码问题
								req.setCharacterEncoding("utf-8");
								resp.setCharacterEncoding("utf-8");
								resp.setContentType("text/html;charset=utf-8");
								
								//得到Session
								HtttpSession session = req.getSession();
								
								Person person = (Person) session.getAttribute("name");
								System.out.println(person.toString());
									
							}
							
							
							@Override
							protected void doPost(HttpServletRequest req,HttpServletResponse resp) throws ServletException,IOException{
								doGet(req,resp);
							}
						}
						
						<servlet>
							<servlet-name>SessionDemo03</servlet-name>
							<servlet-class>com.vllos.servlet.SessionDemo03</servlet-class>
						</servlet>
						<!--Servlet的请求路径-->
						<servlet-mapping>
							<servlet-name>SessionDemo03</servlet-name>
							<url-pattern>/SessionDemo03</url-pattern>
						</servlet-mapping>

			3：Session和Cookie的区别：
					cookie是把用户的数据写给用户的浏览器，浏览器保存(可以保存多个)
					Session把用户的数据写到用户独占Session中，服务器端保存(保存重要的信息，减少服务器资源浪费)
					Session对象由服务创建

7. JSP

    		Java Server Pages :java服务器端页面，和servlet一样，用于动态web技术
    		
    			最大特点：写JSP像在写HTML
    			区别：
    				HTML只给用户提供静态的数据
    				JSP页面中可以嵌入Java代码，为用户提供动态数据
    				
    			JSP原理：JSP怎么执行的
    				tomcat中有一个work目录
    				IDEA中使用tomcat会在IDEA的tomcat中生成一个work目录
    					发现页面变成了Java程序
    					
    					浏览器向服务器发送请求，不管访问什么资源，其实都是在访问Servlet
    					JSP最终也会被转换成一个Java类
    					JSP本质上就是一个servlet,只是帮程序员简化了使用
    					
    					index_jsp.java源码:
    					方法：
   

                                public void _jspInit(){} //初始化
								public void _jspDestroy(){} //销毁
								public void _jspService(HttpServletRequest request,HttpServletResponse response)//JSPService
								

							1:判断请求
							2:内置一些对象
						
						在JSP页面中：
							只要是Java代码就会原封不动的输出
							如果是HTML代码，就会被转换为这样的格式输出到前端：out.write("<html> \r\n");
					
					
				JSP语法和指令
				
				
				JSP的9大内置对象：

                        PageContext	 //存东西,保存的数据只在一个页面中有效
						Request		 //存东西,客户端向服务器发送请求，产生的数据，用户看完就没用了 如：新闻
						Response
						Session      //存东西,客户端向服务器发送请求，产生的数据，用户用完一会还有用  如：购物车
						Application  //存东西,客户端向服务器发送请求，产生的数据，一个用户用完了，其他用户还可能使用 如：聊天数据据
						config
						out
						page
						exception

				JSP标签、JSTL标签、EL标签
					
					EL表达式：${}
							获取数据
							执行运算
							获取web开发的常用对象

8. JavaBean:
   实体类

         Java有特定写法：
					必须要有一个无参构造
					属性必须私有化
					必须有对应的get/set方法
					

			一般用来和数据库的字段做映射ORM
				ORM：对象关系映射

9. Filter过滤器：
   用来过滤网站的数据
   处理中文乱码
   登录验证
   

    			步骤：
    				1:导包
    				2:实现Filter接口，重写对应的方法即可
   

10. 监听器：

11. JDBC：
    连接数据库
    步骤：
    1：加载驱动
    2：连接数据库
    3：向数据库发送SQL的对象Statement
    4：编写SQL
    5：执行查询SQL，返回一个ResultSet 结果集
    6：关闭连接，释放资源 先开后关

    		事务：
    			开启事务
    			事务提交 commit()
    			事务回滚 rollback()
    			关闭事务