【Java学习总结】JavaWeb

一、概述

1. 静态web：提供给所有人看的数据始终不会发生变化。（html、css）
2. 动态web：提供给所有人看的数据始终会发生变化，每个人在不同的时间，不同的地点看到的信息各不相同！
3. 在Java中，动态web资源开发的技术统称为JavaWeb。

静态web存在的缺点：

• Web页面无法动态更新，所有用户看到都是同一个页面。
• 它无法和数据库交互。

动态web缺点：

• 加入服务器的动态web资源出现了错误，我们需要重新编写我们的后台程序,重新发布。

动态web优点：

• Web页面可以动态更新，所有用户看到都不是同一个页面。
• 它可以与数据库交互。

二、http

1.什么是http

HTTP即Hyper Text Transfer Protocol（超文本传输协议），是一个简单的请求-响应协议，它通常运行在TCP之上。

2.http请求

客户端向服务器发请求（Request）

1. 请求行

Request URL:https://www.baidu.com/ 请求地址
Request Method:GET get方法/post方法
Status Code:200 OK 状态码：200
Remote（远程） Address:14.215.177.39:443

请求方式：Get，Post，HEAD，DELETE，PUT，TRACT

get与post请求方式的区别：

• get：请求能够携带的参数比较少，大小有限制，会在浏览器的URL地址栏显示数据内容，不安全，但高效
• post：请求能够携带的参数没有限制，大小没有限制，不会在浏览器的URL地址栏显示数据内容，安全，但不高效

2. 消息头

Accept：告诉浏览器，它所支持的数据类型
Accept-Encoding：支持哪种编码格式 GBK UTF-8 GB2312 ISO8859-1
Accept-Language：告诉浏览器，它的语言环境
Cache-Control：缓存控制
Connection：告诉浏览器，请求完成是断开还是保持连接
HOST：主机…/.

3.http响应

服务器向客户端响应(Response)

1. 响应体

Accept：告诉浏览器，它所支持的数据类型
Accept-Encoding：支持哪种编码格式 GBK UTF-8 GB2312 ISO8859-1
Accept-Language：告诉浏览器，它的语言环境
Cache-Control：缓存控制
Connection：告诉浏览器，请求完成是断开还是保持连接
HOST：主机…/.
Refresh：告诉客户端，多久刷新一次；
Location：让网页重新定位；

2. 响应状态吗
   200：请求响应成功 200
   3xx：请求重定向：你重新到我给你新位置去；
   4xx：找不到资源 404:资源不存在；
   5xx：服务器代码错误 500 502:网关错误

三、Servlet（重点）

1.Servlet简介

Servlet就是Sun公司开发动态web的一门技术，Sun在这些API中提供一个接口叫做：Servlet，如果你想开发一个Servlet程序，只需要完成两个小步骤：
（1）编写一个类，实现Servlet接口
（2）把开发好的Java类部署到web服务器中

2.第一个Servlet程序

（1）编写HelloServlet程序

1. 部署好Tomcat、Maven等工具。
2. 创建一个web项目。
3. 编写一个普通类，并继承HttpServlet。

public class HelloServlet extends HttpServlet {
 
  //由于get或者post只是请求实现的不同的方式，可以相互调用，业务逻辑都一样；
  @Override
  protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    //ServletOutputStream outputStream = resp.getOutputStream();
    PrintWriter writer = resp.getWriter(); //响应流
    writer.print("HelloSerlvet");
 }
  @Override
  protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    doGet(req, resp);
 }
}

4. 在web.xml中编写Servlet的映射

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

5. 配置Tomcat并启动服务器。

（2）Mapping映射问题

1. 一个Servlet可以指定多个映射路径
2. 一个Servlet可以指定通用映射路径
3. 可以自定义后缀实现请求映射

3.ServletContext

web容器在启动的时候，它会为每个web程序都创建一个对应ServletContext对象。

（1）共享数据

通过ServletContext对象可以实现数据的共享，在一个Servlet中存的数据可以在另一个Servlet中拿到。

1. 在第一个Servlet中通过调用ServletContext对象的setAttribute方法将hello赋值给name。
2. 在第二个Servlet中通过调用ServletContext对象的getAttribute方法获取到第一个Servlet中存的数据，并输出。
3. 配置映射。

测试示例如下：

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    	//获取ServletContext对象
        ServletContext context = this.getServletContext();
        String username = "hello";//存入数据
        context.setAttribute("username",username);//将一个数据存在了ServletContent中，名字为：username，值username="hello"
        System.out.println("Hello");
    }

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        ServletContext context = this.getServletContext();
        //通过ServletContext对象的getAttribute方法获得数据
        String username = (String)context.getAttribute("username");
        resp.setContentType("text/html");
        resp.setCharacterEncoding("utf-8");
        resp.getWriter().print("名字"+username);
    }

    <servlet>
        <servlet-name>hello</servlet-name>
        <servlet-class>com.carry.servlet.HelloServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>hello</servlet-name>
        <url-pattern>/hello</url-pattern>
    </servlet-mapping>

    <servlet>
        <servlet-name>getContext</servlet-name>
        <servlet-class>com.carry.servlet.GetServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>getContext</servlet-name>
        <url-pattern>/getContext</url-pattern>
    </servlet-mapping>

（2）获取初始化参数

在web.xml中配置的一些参数，可以被ServletContext对象获取到。通过调用该对象的getInitParameter方法即可完成初始化参数的获取。

1. 在web.xml中配置一些web初始化参数

  <context-param>
    <param-name>url</param-name>
    <param-value>jdbc:mysql://localhost:3306/mybatis</param-value>
  </context-param>

2. 在Servlet中通过调用ServletContext对象的getInitParameter()方法获取初始化参数。

protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws
ServletException, IOException {
  ServletContext context = this.getServletContext();
  String url = context.getInitParameter("url");
  resp.getWriter().print(url);
}

（3）请求转发

ServletContext对象可以实现对网站的请求转发功能。
请求转发：Servlet（源组件）先对客户请求做一些预处理操作，然后把请求转发给其他Web组件（目标组件）来完成包括生成响应结果在内的后续作。
步骤如下：

1. 获取ServletContext对象。
2. 调用getRequestDispatcher()方法，并将要转发的路径作为参数。可以获取到RequestDispatcher类型的对象。
3. 通过RequestDispatcher对象调用foreard()方法实现请求转发。
   测试示例如下：

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        ServletContext context = this.getServletContext();
        System.out.println("进入了ServletDemo04的doGet方法");
        RequestDispatcher dispatcher = context.getRequestDispatcher("/getInitParameter");//转发的请求路径
        dispatcher.forward(req,resp);//调用forward() 实现请求转发
    }

（4）读取资源文件

ServletContext对象可以读取资源文件，但是这个过程需要流的帮助。
具体步骤如下：

1. 获取ServletContext对象。
2. 通过ServletContext对象将properties文件转化为流。
3. 获取一个Properteis对象。
4. 将流存入Properteis对象中。
5. 调用getProperty方法来获取properties资源文件中的数据。
   测试实例如下：

username=root
password=123456

    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        ServletContext context = this.getServletContext();

        InputStream inputStream = context.getResourceAsStream("/WEB-INF/classes/db.properties");

        Properties properties = new Properties();
        properties.load(inputStream);
        String user = properties.getProperty("username");
        String pwd = properties.getProperty("password");
        resp.getWriter().print(user+":"+pwd);
    }

4.HttpServletResponse

（1）下载文件

通过response下载文件的具体步骤如下：

1. 要获取下载文件的路径
2. 下载的文件名
3. 设置想办法让浏览器能够支持下载我们需要的东西
4. 获取下载文件的输入流
5. 创建缓冲区
6. 获取OutputStream对象
7. 将FileOutputStream流写入到buffer缓冲区
8. 使用OutputStream将缓冲区中的数据输出到客户端！

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

        //1. 要获取下载文件的路径
        //String realPath = this.getServletContext().getRealPath("/helloWorld.jpg");
        String realPath = "D:\\Project\\JetBrains\\IntelliJ IDEA\\JavaWeb\\javaweb-02-servlet\\response\\src\\main\\resources\\helloWorld.jpg";
        System.out.println("下载文件的路径："+realPath);
        //2. 下载的文件名
        String fileName = realPath.substring(realPath.indexOf("\\") + 10);
        System.out.println("下载的文件名"+fileName);
        //3. 设置想办法让浏览器能够支持下载我们需要的东西，中文文件名URLEncoder.encode编码，否则可能是乱码
        resp.setHeader("Content-Disposition","attachment; filename="+ URLEncoder.encode(fileName,"UTF-8"));
        //4. 获取下载文件的输入流
        FileInputStream inputStream = new FileInputStream(realPath);
        //5. 创建缓冲区
        int len = 0;
        byte[] buffer = new byte[1024];
        //6. 获取OutputStream对象
        ServletOutputStream outputStream = resp.getOutputStream();
        //7. 将FileOutputStream流写入到buffer缓冲区, 使用OutputStream将缓冲区中的数据输出到客户端
        while ((len=inputStream.read(buffer))>0){
            outputStream.write(buffer,0,len);
        }
        inputStream.close();
        outputStream.close();
    }

（2）重定向（重点）

重定向(Redirect)就是通过各种方法将各种网络请求重新定个方向转到其它位置。

B一个web资源收到客户端A请求后，B他会通知A客户端去访问另外一个web资源C，这个过程叫重定向。
简单的实现一个重定向：

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

        /*
            实际上相当于做了一下两个步骤：
            resp.setHeader("Location","/response/image");
            resp.setStatus(302);
         */
        resp.sendRedirect("/response/image");//重定向
    }

5.HttpServletRequest

HttpServletRequest代表客户端的请求，用户通过Http协议访问服务器，HTTP请求中的所有信息会被封装到HttpServletRequest，通过这个HttpServletRequest的方法，获得客户端的所有信息；
HttpServletRequest对象实现获取参数、请求转发：

	@Override
	protected void doGet(HttpServletRequest req, HttpServletResponse resp) throwsServletException, IOException {
		req.setCharacterEncoding("utf-8");
		resp.setCharacterEncoding("utf-8");
		String username = req.getParameter("username");
		String password = req.getParameter("password");

		System.out.println(username);
		System.out.println(password);
		System.out.println(req.getContextPath());
		//通过请求转发
		//这里的 / 代表当前的web应用
		req.getRequestDispatcher("/success.jsp").forward(req,resp);
 }

6.Cookie与Session

（1）概述

1. 会话：用户打开一个浏览器，点击了很多超链接，访问多个web资源，关闭浏览器，这个过程可以称之为会话；
2. 有状态会话：一个同学来过教室，下次再来教室，我们会知道这个同学曾经来过，称之为有状态会话。
3. 怎么证明你来过一个网站
   （1）服务端给客户端一个信件，客户端下次访问服务端带上信件就可以了（Cookie）
   （2）服务器登记你来过了，下次你来的时候我来匹配你（Session）
4. 保存会话的两种技术
   （1）cookie：客户端技术 （响应，请求）
   （2）session：服务器技术，利用这个技术，可以保存用户的会话信息。我们可以把信息或者数据放在Session中！
5. 常见应用：网站登录之后，你下次不用再登录了，第二次访问直接就上去了。

（2）Cookie

1. 从请求中拿到cookie信息
2. 服务器响应给客户端cookie
   以下测试代码中包含了Cookie的常用方法。

    @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[] cookies = req.getCookies();//获取cookie，返回数组，说明Cookie可能存在多个
        //判断Cookie是否存在
        if (cookies!=null){
            //如果存在怎么办
            out.write("你上一次访问的时间是：");
            for (int i = 0;i < cookies.length;i++){
                Cookie cookie = cookies[i];
                //获取Cookie的名字
                if(cookie.getName().equals("name")){
                    //获取Cookie的值
                    System.out.println(cookie.getValue());
                    //解码
                    out.write(URLDecoder.decode(cookie.getValue(),"utf-8"));
                }
            }
        }else {
            out.write("这是你第一次访问本站");
        }
        //服务器给客户端响应一个cookie
        Cookie cookie = new Cookie("lastLoginTime", System.currentTimeMillis() + "");
        //设置cookie的有效期为1天
        cookie.setMaxAge(24*60*60);
        resp.addCookie(cookie);//响应给客户端一个cookie
    }

删除Cookie:

1. 不设置有效期，关闭浏览器，自动失效；
2. 设置有效期时间为 0 ；

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //创建一个cookie，名字必须要和删除的名字一致,目的是覆盖掉之前的cookie
        Cookie cookie = new Cookie("lastLoginTime", System.currentTimeMillis() + "");
        //将cookie有效期设置为0，立马过期
        cookie.setMaxAge(0);
        resp.addCookie(cookie);
    }

（3）Session（重点）

什么是Session：
服务器会给每一个用户（浏览器）创建一个Seesion对象，一个Seesion独占一个浏览器，只要浏览器没有关闭，这个Session就存在。

使用场景：
保存一个登录用户的信息；
购物车信息；
在整个网站中经常会使用的数据，我们将它保存在Session中

使用Session：

    @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
        HttpSession session = req.getSession();
        //给session中存东西
        session.setAttribute("name",new Person("小明",1));
        //获取session的id
        String sessionId = session.getId();
        //判断session是不是新创建的
        if(session.isNew()){
            resp.getWriter().write("session是新创建的，id："+sessionId);
        }else {
            resp.getWriter().write("session已经存在了，id："+sessionId);
        }

        Person person = (Person)session.getAttribute("name");
        System.out.println(person.toString());

        //手动注销session
        session.removeAttribute("name");
        session.invalidate();
    }
    
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req, resp);
    }

四、JSP

1.简述

Java Server Pages ： Java服务器端页面，也和Servlet一样，用于动态Web技术！
最大的特点：写JSP就像在写HTML
区别：

1. HTML只给用户提供静态的数据
2. JSP页面中可以嵌入JAVA代码，为用户提供动态数据；

2.基础语法

（1）jsp脚本片段

<%--jsp脚本片段--%>
<%
  int sum = 0;
  for (int i = 1; i <=100 ; i++) {
   sum+=i;
 }
  out.println("<h1>Sum="+sum+"</h1>");
%>

（2）在代码嵌入HTML元素：

  <%--在代码中嵌入HTML--%>
  <%
    for (int i = 0; i < 5; i++){
  %>
      <h1>helloWorld <%= i%></h1>
  <%
    }
  %>

（3）jsp声明

<%!
  static {
   System.out.println("Loading Servlet!");
 }
  private int globalVar = 0;
  public void hello(){
   System.out.println("进入了方法hello！");
 }
%>

3.JSP指令

@include与jsp:include区别

• @include会将多个页面合而为一
• jsp:include会将页面拼接，本质还是多个页面

    <%--@include会将两个页面合二为一--%>
    <%@include file="common/header.jsp"%>
    <h1>网页主体</h1>
    <%@include file="common/footer.jsp"%>
    <hr>

    <%--jsp标签
    jsp:include：拼接页面，本质还是三个
    --%>
    <jsp:include page="common/header.jsp"/>
    <h1>网页主体</h1>
    <jsp:include page="common/footer.jsp"/>

4.九大内置对象

• PageContext （存东西）
• Request （存东西）
• Response
• Session （存东西）
• Application 【SerlvetContext】（存东西）
• config 【SerlvetConfig】
• out
• page（不用了解）
• exception

对象	作用域
PageContext	保存的数据只在一个页面中有效
Request	保存的数据只在一次请求中有效，请求转发会携带这个数据
Session	保存的数据只在一次会话中有效，从打开浏览器到关闭浏览器
Application	保存的数据只在服务器中有效，从打开服务器到关闭服务器
从底层到高层(作用域）：page->request–>session–>application
说明：
request：客户端向服务器发送请求，产生的数据，用户看完就没用了，比如：新闻，用户看完没用的！
session：客户端向服务器发送请求，产生的数据，用户用完一会还有用，比如：购物车；
application：客户端向服务器发送请求，产生的数据，一个用户用完了，其他用户还可能使用，比如：聊天数据。

五、MVC架构

MVC，即Model（ 模型）、 view（视图） 、Controller（控制器）。

1.Model

• 业务处理 ：业务逻辑（Service）
• 数据持久层：CRUD （Dao）

2.View

• 展示数据
• 提供链接发起Servlet请求 （a，form，img…）

3.Controller （Servlet）

• 接收用户的请求 ：（req：请求参数、Session信息….）
• 交给业务层处理对应的代码
• 控制视图的跳转

4.MVC结构图

六、小结

1.get与post的区别

• get：请求能够携带的参数比较少，大小有限制，会在浏览器的URL地址栏显示数据内容，不安全，但高效
• post：请求能够携带的参数没有限制，大小没有限制，不会在浏览器的URL地址栏显示数据内容，安全，但不高效

2.重定向和转发的区别

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

3.Session和Cookie的区别：

• Cookie是把用户的数据写给用户的浏览器，浏览器保存 （可以保存多个）
• Session把用户的数据写到用户独占Session中，服务器端保存 （保存重要的信息，减少服务器资源的浪费）
• Session对象由服务创建