SERVLET

​ 通过浏览器访问服务器的项目。

服务器

web开发中的服务器比较多，咱们暂时学习叫做tomcat。

使用：
	1：解压到自己盘符
	2：熟练掌握服务器各个文件夹的作用：
	bin：
		 startup.bat:启动服务器(注意jdk环境变量)，双击：如果黑dos框闪退，检查jdk和端口号是否被占用
		 shundown.bat:关闭服务器
	conf:
		server.xml:定义了tomcat默认端口号：8080：通过浏览器：http://172.16.8.78:8080，默认浏览器就访问到了tomcat/webapps目录。可以访问服务器
		
		web.xml:定义tomcat下所有项目默认session存活时间30分钟
		
		
		
	webapps:默认就是项目部署目录
		可以使用纯html项目测试，赋值粘贴到该目录，重启服务器http://172.16.8.78:8080/test/1.html
		tomcat中编译部署过的web项目目录：
				默认就是webcontent目录   /项目名/web-inf/classes（原src目录）
	lib：tomcat.jar：提供多个类，方法，学习的内容
	
	work:存储访问过的jsp页面，会先编译成servlet
		
	
	
=======================================================================================

eclipse配置tomcat：
	1：window->preferences->Server->点击Runtime Environments->右边点击add添加服务器:单击apache->tomcat8.5->next->选择服务器安装路径，并且单击下拉框选择自己安装的jdk->完成->完成
	2：新建web项目:Dynamic Web Project,
		target runtime:选择自己安装的服务器->next->next->打勾选中generate web.xml,完成
	3：window->show view->servers->点击超链接：查看服务器，完成
	4：双击服务器：修改配置：服务器窗口左下角选择overview：找到server locations：选择第二个单选框，在deploy path:选择tomcat\webapps目录：确定eclipse中web项目的发布路径，ctrl+s保存即可。
	5：服务器上右键add and remove:部署项目，右键启动服务器。

web项目目录结构

项目
	java  resource:
		src					java源文件
		libraries			tomcat.jar和jdk
	webcontent				所有web资源目录：html、jsp、css、js、img
		META-INF			忽略
		WEB-INF
			lib				项目添加依赖jar，注意mybatis逆向工程需要手动导入mysql.jar
			web.xml			项目核心配置文件

tomcat三大组件

三大功能类

HttpServlet

HttpServlet类：可以通过客户端浏览器访问服务器，tomcat会调用执行该类的某些方法，来处理客户端请求。
我们可以自定义类，继承该类，需要在项目核心配置文件中描述该servlet,当服务器启动时，扫描tomcat/webapps下所有的项目中的核心配置文件web.xml，根据该文件中对servlet的描述进行创建对象：
	public abstract class javax.servlet.http.HttpServlet extends javax.servlet.GenericServlet {}



	<!-- 给servlet起名字 -->
      <servlet>
        <servlet-name>test1</servlet-name>
        <servlet-class>com.woniu.servlet.TestServlet</servlet-class>
        <!-- 定义该servlet初始化参数，可以没有 -->
        <init-param>
        	<!-- 参数名a1 -->
            <param-name>a1</param-name>
            <!-- 参数值a2 -->
            <param-value>a2</param-value>
        </init-param>
  <!-- 定义该servlet什么时候被创建：1：启动服务器创建，-1：第一次请求该servlet时创建，默认单例 -->
        <load-on-startup>-1</load-on-startup>
      </servlet>
      <!--给哪个servlet定义映射路径 -->
      <servlet-mapping>
        <!-- 给test1对象定义映射路径 -->
        <servlet-name>test1</servlet-name>
        <!-- 给test1对象定义映射路径为 /xxx.dog-->
        <url-pattern>/xxx.dog</url-pattern>
      </servlet-mapping>

新建包：com.woniu.servlet,新建类TestServlet

public class TestServlet extends HttpServlet{
	private  String s1;
	
	//永远只执行1次：单例
	public TestServlet() {
		System.out.println("TestServlet...............");
	}
	
	//初始化无参方法：永远只执行1次：单例
	public void init() {
		System.out.println("init11111.....");
	}
	//初始化有参方法：初始化：tomcat在创建当前对象时，从web.xml读取参数给当前类属性赋值
	public void init(ServletConfig config) {
		System.out.println("init222222....."+config.getInitParameter("b1"));
		this.s1 = config.getInitParameter("b1");
	}
	
	
	//客户端每次请求服务器时，都会执行一次该方法:根据客户端的请求方式分别执行当前类的doGet或者doPost方法
	public void service(HttpServletRequest request,HttpServletResponse response) {
		String m1 = request.getMethod();
		if("GET".equals(m1)) {
			this.doGet(request, response);
		}else {
			this.doPost(request, response);
		}
	}
	
	//客户端每次请求服务器时，如果客户端请求方式是GET方式，都会执行一次该方法
	public void doGet(HttpServletRequest request,HttpServletResponse response) {
		System.out.println("doGet.....");
		System.out.println(request.getParameter("x1"));
		//doGet：设置编码格式模式：UTF-8,支持中文，但是支持上传，客户端请求效率高
		System.out.println("可以调用业务层方法了");
	}
	
	
	//客户端每次请求服务器时，如果客户端请求方式是POST方式，都会执行一次该方法
	public void doPost(HttpServletRequest request,HttpServletResponse response) {
		System.out.println("doPost.....");
		System.out.println(request.getParameter("x1"));
		//doPost方法接受参数：没有设置编码格式模式：iso-8859-1,不支持中文
		System.out.println("可以调用业务层方法了");
	}
	
	public void destroy(){
		System.out.println("销毁当前对象");
	}
	
}





浏览器返回状态码：
	404：请求资源文件不存在:各种路径错误
	405：请求权限不存在：客户端请求时，分为get方式和post方式请求，服务器没有定义对应的方法。
			post请求方式：<form action="/test1/xxx.dog" method="post"></form>
			其他全是get请求方式：地址栏输入，超链接、method="get",location.href,window.open()
	500:服务器程序异常

servlet生命周期

HttpServlet的执行原理：重中之重

启动服务器，tomcat读取项目的web.xml文件，定义了servlet，创建servlet对象，并初始化
构造器、init方法：启动服务器或者第一次访问时执行，永远只执行1次(单例)
service方法：每次请求servlet时，都会执行该方法，根据客户端的请求方式，分别调用了doGet或者doPost方法
doGet或者doPost方法：就是留给咱们专门调用业务层方法的地方，专门来处理客户端的具体请求，
当关闭服务器时，执行destroy，销毁当前servlet对象

常用类

HttpServletRequest：请求对象：专门来处理客户端的请求，该对象封装了客户端的所有参数.......
		String s1 = request.getRealPath("/");
		String s2 = request.getContextPath();
		String s3 = request.getRequestURI();
		StringBuffer s4 = request.getRequestURL();
		String s5 = request.getRemoteAddr();
		String s6 = request.getParameter("x1");		根据参数名获得客户端的请求参数
		String s7 = request.getMethod();
		System.out.println("客户端请求项目的绝对路径="+s1);
		System.out.println("客户端请求项目名="+s2);
		System.out.println("客户端请求项目名下的servlet="+s3);
		System.out.println("客户端请求项目的网络路径="+s4);
		System.out.println("客户端的ip地址="+s5);
		System.out.println("客户端的请求参数名为x1的参数值是："+s6);
		System.out.println("客户端的请求方式是："+s7);
	
		//将obj对象传递给下1个页面，在该request对象中存储的对象，保证在一次请求范围内，随时可以获取，但是注意：该传参方式不能使用重定向跳转
		request.setAttribute(String name,Object obj);
		
		//获得转发跳转对象
		RequestDispatcher dispatcher = request.getRequestDispatcher("goods/goods.jsp");
		//跳转并将当前请求响应对象传递给转发页面
		dispatcher.forward(request, response);


HttpServletResponse：响应对象，专门给客户端发送各种数据..........
		PrintWriter writer = response.getWriter();		获得流对象，给客户端浏览器发送字符串
		writer.write("<div style='border:1px solid 			
									red;width:200px;height:50px;color:green'>abc</div>");

		//客户端浏览器地址栏重定向：跳转
		response.sendRedirect("login.jsp");
		
		
HttpSession:会话对象：从你访问服务器，到你离开服务器称之为一次会话。重点在于session对象是一次会话，
意味者，只要在一次会话范围内，可以随时随地获取该session对象中保存的对象
		session.setAttribute(String obj1,Object obj2);  将obj2起的名字叫做obj1,存储在该session对象中(盒子，容器)，
		Object obj2 = sesssion.getAttribute(String obj1) 在session对象中根据名字obj1获得对象
		注意：session中存储对象时，比较占用内存，安全退出项目时，一定要删除session中的对象
		
		sesssion.removeAttribute(String name) :将session对象中根据名字删除对象

转发与重定向的区别

转发跳转
    RequestDispatcher dispatcher = request.getRequestDispatcher("goods/goods.jsp");
    //跳转并将当前请求响应对象传递给转发页面
    dispatcher.forward(request, response);

重定向跳转：
	response.sendRedirect("login.jsp");
	
区别：
	转发跳转：会将当前请求与响应对象传递给目标网页，可以传递request对象中的参数,地址栏不变
	重定向：不会将当前请求与响应对象传递给目标网页，不能传递request对象中的参数，地址栏变化：属于第二次请求。
	

文件上传

1：引入上传的jar包：commons-fileupload.jar和commons-io.jar
2：表单提交方式是post，需要设置请求头信息：添加entype属性<form action="/test1/userinfo.do?method=updateUserinfo" method="post" enctype="multipart/form-data">
	enctype="application/x-www-form-urlencode"	默认属性：表单提交时，默认将表单参数以字符流传递给服务器，服务器通过request.getParameter()：以字符流方式接受参数。
	enctype="multipart/form-data"：表单中如果有上传文件，以字节流将表单所有参数传递给服务器，那么服务器就不能通过request.getParameter()接受参数。
3：上传域定义名字：<input type="file" name="uphoto">
4：servlet实现接收表单参数与上传功能：
	//上传与接收数据修改
	public void updateUserinfo(HttpServletRequest request,HttpServletResponse response) throws IOException,ServletException {
		Userinfo userinfo = new Userinfo();
		try {
			SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd");
			//上传工厂对象
			DiskFileItemFactory factory = new DiskFileItemFactory();
			//创建上传工具对象
			ServletFileUpload servletFileUpload = new ServletFileUpload(factory);
			//解析request对象，进行封装了List：存储了表单中的每个元素<input>
			//FileItem:表单元素<input>
			List<FileItem> list = servletFileUpload.parseRequest(request);
			for (FileItem it : list) {
				//System.out.println("是否为表单元素："+it.isFormField()+"======表单元素的name："+it.getFieldName()+"====上传文件名字："+it.getName()+"======表单元素所填内容："+it.getString("UTF-8"));
				if(it.isFormField()) {  //文本框
					switch(it.getFieldName()) {
						case "uid":userinfo.setUid(Integer.parseInt(it.getString("UTF-8")));break;
						case "uacc":userinfo.setUacc(it.getString("UTF-8"));break;
						case "upwd":userinfo.setUpwd(it.getString("UTF-8"));break;
						case "uflag1":userinfo.setUflag1(Integer.parseInt(it.getString("UTF-8")));break;
						case "uflag2":userinfo.setUflag2(Integer.parseInt(it.getString("UTF-8")));break;
						case "uphoto":userinfo.setUphoto(it.getString("UTF-8"));break;
						case "uname1":userinfo.setUname1(it.getString("UTF-8"));break;
						case "uname2":userinfo.setUname2(it.getString("UTF-8"));break;
						case "uname3":userinfo.setUname3(it.getString("UTF-8"));break;
						case "usex":userinfo.setUsex(it.getString("UTF-8"));break;
						case "ubir":userinfo.setUbir(sdf1.parse(it.getString("UTF-8")));break;
						case "uadd1":userinfo.setUadd1(it.getString("UTF-8"));break;
						case "uadd2":userinfo.setUadd2(it.getString("UTF-8"));break;
						case "uadd3":userinfo.setUadd3(it.getString("UTF-8"));break;
						case "utel":userinfo.setUtel(it.getString("UTF-8"));break;
					}
				}else {	//上传域
					if(!it.getName().equals("") && it.getFieldName().equals("uphoto2")) {  //有上传文件			aaa.bbb.jpg
						String path1 = request.getRealPath("/");
						String path2 = "upload/"+new Date().getTime()+new Random().nextInt(100000000)+it.getName().substring(it.getName().lastIndexOf("."));
//						String str1 = UUID.randomUUID().toString();
//						System.out.println(str1);
//						String path2 = "upload/"+str1+it.getName().substring(it.getName().lastIndexOf("."));
						File f1 = new File(path1+path2);
						it.write(f1);  //文件另存为
						userinfo.setUphoto(path2);
					}
				}
			
			}
			
			UserinfoService proxy = (UserinfoService)ServiceProxy.createProxy(UserinfoService.class);
			proxy.updateUserinfo(userinfo);
			HttpSession session = request.getSession();
			session.setAttribute("U", userinfo);
			
			response.sendRedirect("userinfo/userinfo.jsp");
			
			
		} catch (Exception e) {
			e.printStackTrace();
		}
		
		
		
		
	}

Filter

过滤器：每当客户访问服务器servlet时，filter过滤器先拦截请求(看门大爷)，默认拦截请求，通常会对请求或者响应进行设置，可以放行或者跳转。

	<!-- 定义过滤器 -->
  	<filter>
  		<!-- 定义过滤器的名字 -->
  		<filter-name>f1</filter-name>
  		<!-- 定义过滤器的路径 -->
  		<filter-class>com.woniu.filter.Filter1</filter-class>
  	</filter>
  	<filter-mapping>
  		<filter-name>f1</filter-name>
  		<!-- 定义过滤器拦截的路径 -->
  		<url-pattern>*.do</url-pattern>
  	</filter-mapping>


public class Filter1 implements Filter{
	
	private String encoding;
	
	public Filter1() {
		System.out.println("f1111111111111");
	}
	
	public void destroy() {
		System.out.println("关闭服务器执行销毁当前对象的方法。。。。。");
	}

	public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
			throws IOException, ServletException {
		
		System.out.println("每次请求servlet，都会执行该过滤器的doFilter方法");
		HttpServletRequest request2 = (HttpServletRequest)request;
		HttpServletResponse response2 = (HttpServletResponse)response;
		//设置请求的编码格式
		request2.setCharacterEncoding(encoding);
		
		//FilterChain:责任链对象
		chain.doFilter(request2, response2);//放行
		
	}

	public void init(FilterConfig filterConfig) throws ServletException {
		encoding = filterConfig.getInitParameter("encoding");//根据参数名获取参数值
		System.out.println("init............."+encoding);
	}

}

声明周期

启动服务器，创建过滤器对象，执行init方法，
每次请求servlet之前，都执行doFilter方法，就是拦截的方法：通常会对请求或者响应对象进行设置，设置完成后，可以放行或者跳转。关闭服务器销毁当前对象。

Listener

监听器：一直监管HttpSession对象，当HttpSession创建、销毁、添加属性、覆盖属性、移除属性都会执行对应的方法。

当客户端第一次访问服务器时，当获得session对象时或者访问jsp时，会创建一个新的HttpSession对象，执行监听器中的sessionCreated方法，服务器创建session对象时，每个session对象都有一个编号，叫做jsessionid,
当服务器创建session对象后，该session对象保存在服务器中，同时会将jsessionid发送给客户端保存在cookie中，客户端每次请求服务器，都会携带该jsessionid，让服务器来辨别每一个客户。当浏览器关闭，session对象没有被销毁，只是cookie当中的jsessionid被销毁了，再次打开浏览器访问服务器，客户端与服务器的jsessionid匹配不上，所以获取不到Session中的登录U对象。

session对象销毁的方式:
	1：session.invalidate()
	2：客户端与服务器失去联系，默认超过30分
	3：客户端与服务器失去联系，手动代码设置session存活时间：				
					session.setMaxInactiveInterval(60*10);
	4：在自己项目的web.xml中定义session存活时间：
            <session-config>
                <session-timeout>10</session-timeout>
            </session-config>
	5：在tomcat核心配置文件中设置：
			 <session-config>
                <session-timeout>10</session-timeout>
            </session-config>
            
            
HttpSessionListener：监听session对象的创建与销毁
HttpSessionAttributeListener：监听session添加属性、覆盖属性、移除属性


	@WebListener
	public class MyListener implements HttpSessionListener,HttpSessionAttributeListener{
	
	private Integer count = 0;
	private Integer count2 = 0;
	@Override
	public void sessionCreated(HttpSessionEvent se) {
		System.out.println("项目中HttpSession创建了");
		count++;
		ServletContext servlet = se.getSession().getServletContext();
		servlet.setAttribute("count",count);
	}
	@Override
	public void sessionDestroyed(HttpSessionEvent se) {
		System.out.println("项目中HttpSession销毁了");
		count--;
		ServletContext servlet = se.getSession().getServletContext();
		servlet.setAttribute("count",count);
	}
	
	@Override
	public void attributeAdded(HttpSessionBindingEvent event) {
		System.out.println("session对象添加属性了");
		count2++;
		ServletContext servlet = event.getSession().getServletContext();
		servlet.setAttribute("count2",count2);
	}
	@Override
	public void attributeRemoved(HttpSessionBindingEvent event) {
		System.out.println("session对象移除属性了");
		count2--;
		ServletContext servlet = event.getSession().getServletContext();
		servlet.setAttribute("count2",count2);
		
	}
	@Override
	public void attributeReplaced(HttpSessionBindingEvent event) {
		System.out.println("session对象覆盖属性了");
	}
}
<listener>
  		<listener-class>com.woniu.listener.MyListener</listener-class>
</listener>

Http协议

网络传输数据的协议(规则)：三次握手协议：该协议的安全性较高，效率较低，A人，B人打招呼	
	A：你在不在?
	B：在呢！
	
	A：好的，我现在要给你发送数据了啊？
	B：好的，发吧。
	
	A：发送数据
	B：接收数据
	
Udp协议：安全性低，但是效率高	

自定义注解

注解：针对类、属性、方法的显示描述，可以给注解定义属性
	元注解：jdk提供
		overide
		overload
		@Retention:定义当前自定义注解的的运行时间：当前注解为运行时注解
		@Target：定义当前自定义注解的应用对象：ElementType.METHOD:当前注解的应用对象是方法，当前注解就是方法注解
		
	第三方注解：引入的jar中定义的注解
	@WebServlet(loadOnStartup = 1,urlPatterns = {"/delGoods.do","/updateGoods.do","/selGoodsByGid.do","/selAllTypes.do","/addGoods.do","/selGoodsByUid.do"})


	@WebFilter(urlPatterns = {"*.do"},initParams = {@WebInitParam(name = "aaa",value="bbb"),@WebInitParam(name = "encoding",value="UTF-8")})


1：自定义注解：
	@Target(ElementType.METHOD)
    @Retention(RetentionPolicy.RUNTIME)
    public @interface MyAnnotation {
        //注解的属性：在使用注解时，可以给属性赋值，在反射执行时，可以获得属性的属性值
        public String name();
    }
2：自定义注解的应用：
	@MyAnnotation(name1 = "退出")
	public void out(HttpServletRequest request,HttpServletResponse response) throws IOException,ServletException {
		request.getSession().removeAttribute("U");
		response.sendRedirect("userinfo.do?method=selCookie");
	}
	注意：自定义注解定义了N个属性，在使用时，必须全部赋值；如果有且只有一个属性叫做value，在使用时，可以不写该属性名

3：在反射执行方法时，可以获得注解的属性值
	Method method = this.getClass().getDeclaredMethod(m,HttpServletRequest.class,HttpServletResponse.class);
	//Annotation[] ans = method.getAnnotations();	获得该方法的所有注解对象数组
	//根据类型获得注解对象
	MyAnnotation myAnnotation = method.getAnnotation(MyAnnotation.class);
	if(myAnnotation != null) {
		String n1 = myAnnotation.name1();
		System.out.println(n1);
	}

jsp

Java Server Pages；JAVA服务器页面：将java代码块和html页面代码封装成了jsp页面

三大指令

编译指令

<%@ page %>：定义如何编译当前jsp：
	language="java"以java语言来编译
	contentType="text/html; charset=UTF-8"：字符串内容并定义编码格式
	pageEncoding="UTF-8"：当前java代码块中编码格式

导入标签指令

<%@ taglib %>：当前页面导入标签

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

页面包含指令

<%@ include file="xxx.jsp"  %>：当前页面包含该页面,路径只能是相对路径

EL表达式

${applicationScope.对象名字}  ==  application.getAttribute("对象名字");
${sessionScope.对象名字}  ==  session.getAttribute("对象名字");
${requestScope.对象名字}  ==  request.getAttribute("对象名字");
${pageScope.g.gname }	==	page.getAttribute("对象名字");
${对象名字}			==	从4大作用域从大到小范围依次获取对象，获得到之后不再向小范围获得



${pageScope.g.gflag eq 1 }:  eq :相等
${pageScope.g.gflag gt 1 }:  gt :大于
${pageScope.g.gflag lt 1 }:  lt :小于

jsp四大作用域

作用域：使用范围
page			当前页面
request			一次请求
session			一会会话
application		服务器范围:服务器不关闭，保存的对象一直存在
	//服务器对象
	ServletContext application = request.getServletContext();
	//将aaa对象起名字叫做a1，保存在服务器上，该a1的作用域是application
	application.setAttribute("a1", "aaa");

作用域越大，消耗服务器内存越大

JSTL

核心标准标签库：将循环判断、数字、时间格式化的java代码块封装了标签

	1：引入jar包：standard.jar和jstl.jar
	2：在需要使用jstl标签的jsp页面上引入标签名和路径
		<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>


	<c:if test="${判断表达式}"></c:if>
	<c:if test="${判断表达式}"></c:if>
	<c:if test="${判断表达式}"></c:if>
	
	<c:choose>
			<c:when test="${sessionScope.U.uflag1 eq 1 }">卖家</c:when>
			<c:when test="${sessionScope.U.uflag1 eq 2 }">买家</c:when>
			<c:otherwise>管理员</c:otherwise>
	</c:choose>
	
	循环：循环的对象是a,循环a对象过程中，每一个对象起个名字叫做b
	<c:forEach items="a" var="b">
								
	</c:forEach>
	
	for(int i=0;i<a.size();i++){
		Emp b = list.get(i);
	}
	

Cookie

tomcat包下一个对象，该对象可以存储键值对，键值对都必须是字符串类型，该键值对数据存储在客户端浏览器上。
常见：
	保存账号密码、各大网站推送个人感兴趣的信息。

//创建一个cookie对象，默认保存时间：一次会话
Cookie c1 = new Cookie("x1", uacc);
//设置cookie存活时间：单位秒
c1.setMaxAge(60*60*24*7);
//给客户端浏览器发送cookie数据并保存
response.addCookie(c1);



Cookie[] cs = request.getCookies();
		String a1 = "";
		String a2 = "";
		if(cs != null) {
			for(int i=0;i<cs.length;i++) {
				//System.out.println(cs[i].getName()+"===="+cs[i].getValue());
				if(cs[i].getName().equals("x1")) {
					a1 = cs[i].getValue();
				}
				if(cs[i].getName().equals("x2")) {
					a2 = cs[i].getValue();
				}
			}
		}




在浏览器上查看cookie数据：
	方式1：浏览器上F12：点击NetWork,单击doc：刷新当前页面，单击Name框中的页面名字：查看数据
	方式2：浏览器上工具栏中设置->隐私设置->网站设置->cookie->查看所有cookie数据


cookie与session的区别：
	cookie和session默认的存活时间都是一次会话
	cookie数据是以字符串的键值对存储在客户端上
	session是将一个Object对象存在服务器上

jsp的执行原理

tomcat将jsp会先编译成servlet，

MVC

web项目的基本结构:mvc:开发思想
	M:model：	   模型层：业务层+持久层+实体类，针对service层包
	V:view:			视图层：针对代码的视图层：页面部分，html、jsp
	C:controller	控制层：servlet：接受参数，调用业务层方法，给页面传递参数，跳转
V->C->M

路径

在jsp中：因为每个jsp自己的路径不同，导致使用相对路径则../个数不同，写法不同，所以统一使用/项目开始找

在servlet中，所有的servlet路径相同，都在com.woniu.servlet包，跳转页面时，默认所有的页面都在webContent包下，所以servlet跳转页面时，不用写项目名/webContent,直接写包/页面名