JavaWeb笔记

1、JavaWeb基本概念

---

1.1、前言

web开发：

• web，网页的意思 www.baidu.com

• 静态web

  • html，css
  • 提供给所有人看的数据始终不会发生变化

• 动态web

  • 淘宝，几乎是所有的网站；
  • 提供给所有人看的数据始终会发生变化，每个人在不同的时间，不同的地点看到的信息各不相同！
  • 技术栈：Servlet/jsp，ASP，PHP

在Java中，动态web资源开发的技术统称为JavaWeb；

1.2、Web应用程序

web应用程序：可以提供浏览器访问的程序；

• a.html、b.html…多个web资源，这些web资源可以被外界访问，对外界提供服务；
• 你们能访问到的任何一个页面或者资源，都存在于这个世界的某一个角落的计算机上
• URL：通过这个访问
• 这些统一的web资源会被放在同一个文件夹下，web应用程序–>Tomcat：服务器
• 一个web应用由多部分组成
  • html，css，js
  • jsp，servlet
  • Java程序
  • jar包
  • 配置文件（Properties）

web应用程序编写完毕后，若想提供给外界访问：需要一个服务器来统一管理；

1.3、静态Web

• *.htm， *.html，这些都是网页的后缀，如果服务器上一直存在这些东西，我们就可以直接进行读取，通过网络

• 静态web存在的缺点

  • Web页面无法动态更新，所有用户看到的都是同一个页面
  • 轮播图，点击特效：伪动态
  • JavaScript
  • VBScript

• 它无法和数据库交互（数据无法持久化，用户无法交互）

1.4、动态web

页面会动态展示：Web的页面展示的效果因人而异；

缺点：

• 假如服务器的动态Web资源出现了错误，我们需要重新编写我们的后台程序，重新发布
  • 停机维护

优点：

• Web页面可以动态更新，所有用户看到的都不是同一个页面

• 它可以和数据库交互（数据持久化：注册，商品，用户信息…）

2、Web服务器

---

2.1、技术讲解

ASP：

• 微软：国内最早流行的就是ASP；
• 在HTML中嵌入了VB的脚本代码，ASP+COM；
• 在ASP开发中，基本一个页面都有几千行的业务代码，页面及其混乱
• 维护成本高
• C#
• iis

PHP：

• PHP开发速度很快，功能及其强大，跨平台，代码很简单
• 无法承载大访问量的情况（局限性）

JSP/Servlet：

B/S：浏览器和服务器

C/S：客户端和服务器

• sun公司主推的B/S架构
• 基于Java语言的（所有的大公司，或者一些开源的组件，都是用Java写的）
• 可以承载三高问题带来的影响
• 语法像ASP

2.2、Web服务器

服务器是一直被动的操作，用来处理用户的一些请求和给用户一些响应信息

IIS：

微软的 ：ASP…，windows中自带的

Tomcat：

Tomcat是Apache 软件基金会（Apache Software Foundation）的Jakarta 项目中的一个核心项目，最新的Servlet 和JSP 规范总是能在Tomcat 中得到体现。因为Tomcat 技术先进、性能稳定，而且免费，因而深受Java 爱好者的喜爱并得到了部分软件开发商的认可，成为比较流行的Web 应用服务器。

Tomcat 服务器是一个免费的开放源代码的Web 应用服务器，属于轻量级应用服务器，在中小型系统和并发访问用户不是很多的场合下被普遍使用，是开发和调试JSP 程序的首选。对于一个Java初学者来说，它是最佳的选择。

Tomcat 实际上运行JSP 页面和Servlet。Tomcat最新版本为10.0.23

下载Tomcat：

1、安装or解压

2、了解配置文件及结构目录

3、这个东西的作用

3、Tomcat

---

3.1、安装Tomcat

3.2、Tomcat启动和配置

文件夹作用：

启动关闭Tomcat

访问测试：http://localhost:8080/

3.3、配置

可以配置启动的端口号

默认为：8080

可以配置主机的名称

默认主机名：localhost–>127.0.0.1

默认网站应用存放的位置：webapps

3.4、发布一个web网站

• 将自己写的网站，放到服务器（Tomcat）中指定的web应用的文件夹（webapps）下，就可以访问了

网站应该有的结构

--webapps:Tomcat服务器的web目录
    --ROOT
    --lihongtao：网站的目录名
    	--WEB-INF
    		--classes   Java程序
    		--lib：web应用所依赖的jar包
    		--web.xml  网站的配置文件
    	--index.html   默认的网页
    	--static
    		--css
    		--js
    		--img
    	.......

4、HTTP

---

4.1、什么是HTTP

超文本传输协议（Hypertext [Transfer Protocol](https://baike.baidu.com/item/Transfer Protocol/612755?fromModule=lemma_inlink)，HTTP）是一个简单的请求-响应协议，它通常运行在TCP之上。

• 文本：html，字符串，~，…
• 超文本：图片，音乐，视频，定位，地图…
• 80

HTTPS：

• 443

4.2、两个时代

• HTTP1.0
  • HTTP/1.0:客户端可以与web服务器连接后，只能获得一个web资源，断开连接
• HTTP2.0
  • HTTP/2.0:客户端可以与web服务器连接后，可以获得多个web资源

4.3、HTTP请求

• 客户端----发请求----服务器

百度：

1、请求行

• 请求行中的请求方式：GET
• 请求方式：GET，POST，HEAD，DELETE，PUT，TRACT…
  • get:一次请求能够携带的参数比较少，大小有限制，会在浏览器的URL地址栏显示数据内容，不安全，但高效
  • post:一次请求能够携带的参数没有限制，大小没有限制，不会在浏览器的URL地址栏显示数据内容，安全，但不高效

2、消息头

4.4、HTTP响应

• 服务器----响应----客户端

百度：

1、响应体

2、响应状态码

200：请求响应成功 200

3xx：请求重定向

• 重定向：你重新到我给你新位置去；

404：找不到资源

• 资源不存在；

5xx：服务器代码错误 500 502：网关错误

5、Maven

---

1、在JavaWeb开发中，需要使用大量的jar包，我们手动去导入；

2、如何能够让一个东西自动帮我导入和配置这个jar包。

5.1、Maven项目架构管理工具

我们目前用来就是方便导入jar包的！

Maven的核心思想：约定大于配置

• 有约束，不要去违反

Maven会规定好你该如何去编写我们的Java代码，必须要按照这个规范来；

5.2、下载安装Maven

官网：https://maven.apache.org/

下载完成后，解压即可；

5.3、配置环境变量

在我们的系统环境变量中

配置如下配置：

• M2_HOME maven目录下的bin目录
• MAVEN_HOME maven的目录
• 在Path中配置%MAVEN_HOME%\bin

测试Maven是否安装成功，保证必须配置完毕！

5.4、阿里云镜像

• 镜像：mirrors

  • 作用：加速我们的下载

• 国内建议使用阿里云的镜像

<mirror>
    <id>nexus-aliyun</id>
    <mirrorOf>central</mirrorOf>
    <name>Nexus aliyun</name>
    <url>http://maven.aliyun.com/nexus/content/groups/public</url>
</mirror>

5.5、本地仓库

建立一个本地仓库：localRepository

<localRepository>D:\Maven\apache-maven-3.9.5\maven-repo</localRepository>

5.6、在IDEA中使用MAven

1、启动IDEA

2、创建一个Maven项目

5.7、在IDEA中配置Tomcat

5.8、pom文件

pom.xml是Maven的核心配置文件

6、Servlet

---

6.1、Servlet简介

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

把实现了Servlet接口的Java程序叫做Servlet

6.2、HelloServlet

Servlet接口Sun公司有两个默认的实现类：HttpServlet，GenericServlet

1、构建一个普通的Maven项目，删掉里面的src目录，以后我们的学习就在这个项目里面建立Moudel；这个空的工程就是Maven的主工程；

2、关于Maven父子工程的理解：

父项目中会多一个

  <modules>
    <module>servlet01</module>
  </modules>

子项目中会有一个

    <parent>
        <groupId>org.example</groupId>
        <artifactId>javaweb-02-servlet</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>

父项目的jar包子项目可以直接使用

son extends father

3、Maven环境优化

• 修改web.xml为最新的
• 将maven的结构搭建完整

4、编写一个Servlet程序

• 编写一个普通类
• 实现一个Servlet接口，这里我们直接继承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("HelloServlet");
    }

5、编写Servlet的映射

为什么需要映射：我们写的是Java程序，但是要通过浏览器访问，而浏览器需要连接web服务器，所以我们需要在web服务中注册我们写的Servlet，还需要给他一个浏览器能够访问的路径；

    <!--注册Servlet-->
    <servlet>
        <servlet-name>hello</servlet-name>
        <servlet-class>com.li.servlet.HelloServlet</servlet-class>
    </servlet>

    <!--Servlet的请求路径-->
    <servlet-mapping>
        <servlet-name>hello</servlet-name>
        <url-pattern>/hello</url-pattern>
    </servlet-mapping>

6、配置Tomcat

7、启动测试

6.3、Servlet原理

Servlet是由Web服务器调用，web服务器在收到浏览器请求之后，会：

6.4、Mapping问题

1、一个Servlet可以指定一个映射路径

    <servlet-mapping>
        <servlet-name>hello</servlet-name>
        <url-pattern>/hello</url-pattern>
    </servlet-mapping>

2、一个Servlet可以指定多个映射路径

    <servlet-mapping>
        <servlet-name>hello</servlet-name>
        <url-pattern>/hello</url-pattern>
    </servlet-mapping>
    <servlet-mapping>
        <servlet-name>hello</servlet-name>
        <url-pattern>/hello1</url-pattern>
    </servlet-mapping>
    <servlet-mapping>
        <servlet-name>hello</servlet-name>
        <url-pattern>/hello2</url-pattern>
    </servlet-mapping>
    <servlet-mapping>
        <servlet-name>hello</servlet-name>
        <url-pattern>/hello3</url-pattern>
    </servlet-mapping>

3、一个Servlet可以指定通用映射路径

    <servlet-mapping>
        <servlet-name>hello</servlet-name>
        <url-pattern>/hello/*</url-pattern>
    </servlet-mapping>

4、指定一些后缀或者前缀等等…

    <!--可以自定义后缀实现请求映射
	注意点：*前面不能加项目映射的路径
	hello/asfsdafdsf.lihongtao
	-->
	<servlet-mapping>
        <servlet-name>hello</servlet-name>
        <url-pattern>*.lihongtao</url-pattern>
    </servlet-mapping>

5、优先级问题

指定了固有的映射路径优先级最高，如果找不到就会走默认的处理请求；

    <servlet>
        <servlet-name>error</servlet-name>
        <servlet-class>com.li.servlet.ErrorServlet</servlet-class>
    </servlet>
    
    <servlet-mapping>
        <servlet-name>error</servlet-name>
        <url-pattern>/*</url-pattern>
    </servlet-mapping>

6.5、ServletContext

web容器在启动的时候，它会为每个web程序都创建一个对应的ServletContext对象，它代表了当前的web应用；

1、共享数据

我在这个Servlet中保存的数据，可以在另一个servlet中拿到；

    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //System.out.println("hello");
        //this.getServletContext()    Servlet上下文
        ServletContext servletContext = this.getServletContext();

        String username = "李洪涛";
        servletContext.setAttribute("username",username);  //将一个数据保存在了ServletContext中，名字为：username，值为username
    }

 <servlet>
    <servlet-name>getcon</servlet-name>
    <servlet-class>com.li.servlet.GetServlet</servlet-class>
  </servlet>
  
  <servlet-mapping>
    <servlet-name>getcon</servlet-name>
    <url-pattern>/getcon</url-pattern>
  </servlet-mapping>

测试访问结果；

2、获取初始化参数

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

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

        String url = servletContext.getInitParameter("url");
        resp.getWriter().print(url);
    }

3、请求转发

    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("进入了ServletDemo04");
        ServletContext servletContext = this.getServletContext();
        RequestDispatcher requestDispatcher = servletContext.getRequestDispatcher("/gp");
        requestDispatcher.forward(req,resp);
    }

4、读取资源文件

Properties

• 在Java目录下新建properties
• 在resources目录下新建properties

发现：都被打包到了同一个路径下：classes，我们俗称这个路径为classpath；

思路：需要一个文件流；

username=root
password=123456

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

        InputStream resourceAsStream = this.getServletContext().getResourceAsStream("/WEB-INF/classes/db.properties");

        Properties properties = new Properties();
        properties.load(resourceAsStream);
        String username = properties.getProperty("username");
        String password = properties.getProperty("password");

        resp.getWriter().print(username+":"+password);
    }

访问测试即可；

6.6、HttpServletResponse

web服务器接收到客户端的http请求，针对这个请求，分别创建一个代表请求的HttpServletRequest对象，代表响应的一个HttpServletResponse对象；

• 如果要获取客户端请求过来的参数：找HttpServletRequest
• 如果要给客户端响应一些信息：找HttpServletResponse

1、简单分类

负责向浏览器发送数据的方法

ServletOutputStream getOutputStream() throws IOException;
PrintWriter getWriter() throws IOException;

负责向浏览器发送响应头的方法

void setCharacterEncoding(String var1);

void setContentLength(int var1);

void setContentLengthLong(long var1);

void setContentType(String var1);

void setDateHeader(String var1, long var2);

void addDateHeader(String var1, long var2);

void setHeader(String var1, String var2);

void addHeader(String var1, String var2);

void setIntHeader(String var1, int var2);

void addIntHeader(String var1, int var2);

2、下载文件

1、向浏览器输出消息

2、下载文件

    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //1、要获取下载文件的路径
        String realPath = "D:\\javase\\JavaWeb\\javaweb-01-servlet\\response\\src\\main\\resources\\1.png";
        System.out.println("下载文件的路径："+realPath);
        //2、下载的文件名是啥
        String substring = realPath.substring(realPath.lastIndexOf("\\") + 1);
        //3、设置想办法让浏览器能够支持(Content-Disposition)下载我们需要的东西，中文文件名URLEncoder.encode编码，否则有可能乱码
        resp.setHeader("Content-Disposition","attachment;filename="+ URLEncoder.encode(substring,"UTF-8"));
        //4、获取下载文件的输入流
        FileInputStream fileInputStream = new FileInputStream(realPath);
        //5、创建缓冲区
        int len = 0;
        byte[] buffer = new byte[1024];
        //6、获取OutputStream对象
        ServletOutputStream outputStream = resp.getOutputStream();
        //7、将FileInputStream流写入到buffer缓冲区，使用OutputStream将缓冲区的数据输出到客户端！
        while ((len=fileInputStream.read(buffer))>0){
                outputStream.write(buffer,0,len);
        }
        fileInputStream.close();
        outputStream.close();
    }

3、验证码功能

    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/png");
        //网站存在缓存，不让浏览器缓存
        resp.setDateHeader("expires",-1);
        resp.setHeader("Cache-Control","no-cache");
        resp.setHeader("Pragma","no-cache");
        //把图片写给浏览器
        boolean write = ImageIO.write(image, "png",resp.getOutputStream());
    }

    //生成随机数
    private String makeNum(){
        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");
        }
        String s = sb.toString() + num;
        return num;
    }

4、实现重定向

一个web资源（B）收到客户端（A）请求后，它（B）会通知客户端（A）去访问另一个web资源（C），这个过程叫重定向

常见场景：

• 用户登陆

    void sendRedirect(String var1) throws IOException;

测试：

resp.sendRedirect("/re/image");  //重定向

面试：请你聊聊重定向和转发的区别？

相同点：

• 页面都会实现跳转

不同点：

• 请求转发的时候，url不会产生变化 307
• 重定向的时候，url的地址栏会发生变化 302

6.7、HttpServletRequest

HttpServletRequest代表客户端的请求，用户通过Http协议访问服务器，HTTP请求中的所有信息会被封装到HttpServletRequest，通过这个HttpServletRequest的方法，获得客户端的所有信息

获取参数，请求转发

public class LoginServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

        req.setCharacterEncoding("utf-8");
        resp.setCharacterEncoding("utf-8");

        String username = req.getParameter("username");
        String password = req.getParameter("password");
        String[] hobbys = req.getParameterValues("hobbys");

        System.out.println("==========================");
        System.out.println(username);
        System.out.println(password);
        System.out.println(Arrays.toString(hobbys));
        System.out.println("==========================");

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

7、Cookie和Session

---

7.1、会话

会话：用户打开一个浏览器，点击了很多超链接，访问多个web资源，关闭浏览器，这个过程可以称之为会话；

有状态会话：一个同学来过教室，下次再来教室，我们会知道这个同学曾经来过，称之为有状态会话：

一个网站，怎么证明你来过？

• 服务端给客户端一个信件，客户端下次再访问服务端带上信件就可以了； cookie
• 服务器登记你来过了，下次你再来的时候我来匹配你； session

7.2、保存会话的两种技术

cookie

• 客户端技术（响应，请求）

session

• 服务器技术，利用这个技术，可以保存用户的会话信息，我们可以把信息或者数据放在Session中！

常见场景：网站登陆之后，你下次不用再登陆了，第二次访问直接就上去了！

7.3、Cookie

1、从请求中拿到cookie信息

2、服务器响应给客户端cookie

Cookie[] cookies = req.getCookies();  //获得Cookie
cookie.getName();  //获得Cookie中的key
cookie.getValue();  //获得Cookie中的vlaue
new Cookie("lastLoginTime", System.currentTimeMillis()+"");  //新建一个Cookie
cookie.setMaxAge(24*60*60);  //设置Cookie的有效期
resp.addCookie(cookie);  //响应给客户端一个Cookie

cookie：一般会保存在本地的用户目录下appdata：

一个网站Cookie是否存在上限？

• 一个Cookie只能保存一个信息；
• 一个web站点可以给浏览器发送多个Cookie，最多存放20个Cookie；
• Cookie大小有限制4kb；
• 300个Cookie浏览器上限；

删除Cookie：

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

编码解码：

URLEncoder.encode("李洪涛","UTF-8")
URLDecoder.decode(cookie.getValue(),"UTF-8")

7.4、Session（重点）

什么是Session：

• 服务器会给每一个用户（浏览器）创建一个Session对象；
• 一个Session独占一个浏览器，只要浏览器没有关闭，这个Session就存在；
• 用户登陆之后，整个网站它都可以访问啊；–>保存用户的信息；保存购物车的信息…

Session和Cookie的区别：

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

使用场景：

• 保存一个登陆用户的信息；
• 购物车信息；
• 在整个网站中经常会使用的数据，我们将他保存在Session中；

使用Session：

public class SessionDemo01 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

        //解决乱码问题
        resp.setCharacterEncoding("utf-8");
        req.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);
        }
        //Session创建的时候做了什么事情
        //        Cookie cookie = new Cookie("JSESSIONID","sessionId");
        //        resp.addCookie(cookie);

    }

    //得到Session
    HttpSession session = req.getSession();

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


    HttpSession session = req.getSession();
    session.removeAttribute("name");
    //手动注销Session
    session.invalidate();

会话自动过期：web.xml

<!--设置Session默认的失效时间-->
<session-config>
    <!--15分钟后Session自动失效，以分钟为单位-->
    <session-timeout>15</session-timeout>
</session-config>

8、JSP

---

8.1、什么是JSP

Java Server Pages：Java服务器端页面，也和Servlet一样，用于动态Web技术！

最大的特点：

• 写JSP就像在写HTML
• 区别：
  • HTML只给用户提供静态数据；
  • JSP页面中可以嵌入Java代码，为用户提供动态数据；

8.2、JSP原理

思路：JSP到底怎么执行的？

• 代码层面没有任何问题
• 服务器内部工作
  • Tomcat中有一个work目录；
  • IDEA中使用Tomcat的时候会在IDEA的Tomcat中生成一个work目录

自己电脑的地址：

D:\ruanjian\idea\.IntelliJIdea\system\tomcat\b35f246c-4db8-47cf-a97e-918a0807a129\work\Catalina\localhost\cookie\org\apache\jsp

发现页面转变成了Java程序

浏览器向服务器发送请求，不管访问什么资源，其实都是在访问Servlet

JSP最终也会被转换成为一个Java类！

JSP本质上就是一个Servlet

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

1. 判断请求

2. 内置了一些对象

   //页面上下文
   final javax.servlet.jsp.PageContext pageContext;
   //session
   javax.servlet.http.HttpSession session = null;
   //applicationContext
   final javax.servlet.ServletContext application;
   //config
   final javax.servlet.ServletConfig config;
   //out
   javax.servlet.jsp.JspWriter out = null;
   //page:当前页
   final java.lang.Object page = this;
   //请求
   final javax.servlet.http.HttpServletRequest request 
   //响应
   final javax.servlet.http.HttpServletResponse response
   

3. 输出页面前增加的代码

   //设置响应的页面类型
   response.setContentType("text/html");
   pageContext = _jspxFactory.getPageContext(this, request, response,
                                             null, true, 8192, true);
   _jspx_page_context = pageContext;
   application = pageContext.getServletContext();
   config = pageContext.getServletConfig();
   session = pageContext.getSession();
   out = pageContext.getOut();
   _jspx_out = out;
   

   以上的这些对象我们可以在JSP页面直接使用！

在JSP页面中：

只要是Java代码，就会原封不动的输出；

如果是HTML代码，就会被转换为:

out.write("<html>\r\n");

这样的格式，输出到前端！

8.3、JSP基础语法

任何语言都有自己的语法，Java中有，JSP作为Java技术的一种应用，它拥有一些自己扩充的语法（了解、知道即可）Java的所有语法都支持！

JSP表达式

<%--JSP表达式
作用：用来将程序的输出，输出到客户端
<%= 变量或者表达式%>
--%>
<%= new java.util.Date()%>

JSP脚本片段

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

脚本片段的再实现

<%
  int x = 10;
  out.println(x);
%>
  <p>这是一个JSP文档</p>
<%
  int y = 2;
  out.println(y);
%>
<hr>
<%--在代码嵌入HTML元素--%>
<%
  for (int i = 0; i < 5; i++) {

%>
  <h1>Hello,World <%= i%></h1>
<%
  }
%>

JSP声明

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

JSP声明：会被编译到JSP生成的Java的类中！其他的，就会被生成到_jspService方法中！

在JSP中，嵌入Java代码即可

<%%>
<%=%>
<%!%>
<%--注释--%>

JSP的注释，不会在客户端显示，HTML的就会！

8.4、JSP指令

<%@ page args.... %>
<%@include file=""%>

<%--@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"/>

8.5、9大内置对象

• PageContext 存东西
• Request 存东西
• Response
• Session 存东西
• Application(ServletContext) 存东西
• config(ServletConfig)
• out
• page
• exception

pageContext.setAttribute("name1","绝情1号");  //保存的数据只在一个页面中有效
request.setAttribute("name2","绝情2号");  //保存的数据只在一次请求中有效，请求转发会携带这个数据
session.setAttribute("name3","绝情3号");  //保存的数据只在一次会话中有效，从打开浏览器到关闭浏览器
application.setAttribute("name4","绝情4号");  //保存的数据只在服务器中有效，从打开服务器到关闭服务器

request:客户端向服务器发送请求，产生的数据，用户看完就没用了，比如：新闻；用户看完没用的！

session:客户端向服务器发送请求，产生的数据，用户用完一会儿还有用，比如：购物车；

application:客户端向服务器发送请求，产生的数据，一个用户用完了，其他用户还可能使用，比如：聊天数据；

8.6、JSP标签、JSTL标签、EL表达式

<dependency>
    <groupId>javax.servlet.jsp.jstl</groupId>
    <artifactId>jstl-api</artifactId>
    <version>1.2</version>
</dependency>
<dependency>
    <groupId>taglibs</groupId>
    <artifactId>standard</artifactId>
    <version>1.1.2</version>
</dependency>

EL表达式：${}

• 获取数据
• 执行运算
• 获取web开发的常用对象

JSP标签：

<%--jsp:include--%>
<jsp:forward page="/jsptag2.jsp">
    <jsp:param name="name" value="LiHongTao"/>
    <jsp:param name="age" value="18"/>
</jsp:forward>

JSTL表达式

JSTL标签库的使用就是为了弥补HTML标签的不足；它自定义许多标签，可以供我们使用，标签的功能和Java代码一样！

格式化标签

SQL标签

XML标签

核心标签（掌握部分）

JSTL标签库使用步骤：

• 引入对应的taglib
• 使用其中的方法
• 在Tomcat也需要引入JSTL的包，否则会报错：JSTL解析错误

c:if

<body>
    <h4>if测试</h4>
    <hr>
    <form action="coreif.jsp" method="get">
        <%--
    EL表达式获取表单中的数据
    ${param.参数名}
        --%>
        <input type="text" name="username" value="${param.username}">
        <input type="submit" value="登陆">
    </form>

    <%--判断如果提交的用户名是管理员，则登陆成功--%>
    <c:if test="${param.username=='admin'}" var="isAdmin">
        <c:out value="管理员欢迎你"/>
    </c:if>
    <c:out value="${isAdmin}"/>
</body>

c:choose c:when

<body>
    <%--定义一个变量score，值为85--%>
    <c:set var="score" value="85"/>

    <c:choose>
        <c:when test="${score>=90}">
            你的成绩为优秀
        </c:when>
        <c:when test="${score>=80}">
            你的成绩为一般
        </c:when>
        <c:when test="${score>=70}">
            你的成绩为良好
        </c:when>
        <c:when test="${score<=60}">
            你的成绩为不及格
        </c:when>
    </c:choose>
</body>

c:forEach

<body>
    <%
    ArrayList<String> people = new ArrayList<>();
    people.add(0,"张三");
    people.add(1,"李四");
    people.add(2,"王五");
    people.add(3,"赵六");
    request.setAttribute("list",people);
    %>
    <%--
    var:每一次遍历出来的变量
        items:要遍历的对象
            begin:哪里开始
                end:到哪里
                    step:步长
                        --%>
    <c:forEach var="people" items="${list}">
        <c:out value="${people}"/> <br>
    </c:forEach>

    <hr>
    <c:forEach var="people" items="${list}" begin="1" end="3" step="2">
        <c:out value="${people}"/> <br>
    </c:forEach>
</body>

9、JavaBean

---

实体类

JavaBean有特定的写法：

• 必须要有一个无参构造
• 属性必须私有化
• 必须有对应的get/setfangfa

一般用来和数据库的字段做映射

ORM：对象关系映射

• 表----->类
• 字段------>属性
• 行记录------>对象

people表

id	name	age	address
1	绝情1号	18	西安
2	绝情2号	19	北京
3	绝情3号	20	上海

class People{
    private int id;
    private String name;
    private int id;
    private String address;
}

class A{
    new People(1,"绝情1号",18,"西安");
    new People(2,"绝情2号",19,"北京");
    new People(3,"绝情3号",20,"上海");
}

10、MVC三层架构

---

什么是MVC：Model（模型） view（视图） Controller（控制器）

10.1、最早架构

用户直接访问控制层，控制层就可以直接操作数据库；

servlet--CRUD-->数据库
弊端：程序臃肿，不利于维护
servlet的代码中：处理请求、响应、视图跳转、处理JDBC、处理业务代码、处理逻辑代码

架构：没有什么是加一层解决不了的！

10.2、MVC三层架构

Model

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

View

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

Controller（Servlet）

• 接收用户的请求：（req：请求参数、Session信息…）

• 交给业务层处理对应的代码

• 控制视图的跳转

  登陆--->接收用户的登陆请求--->处理用户的请求（获取用户登陆的参数，username，password）--->交给业务层处理登陆业务（判断用户名密码是否正确：事务）--->Dao层查询用户名和密码是否正确--->数据库
  

11、Filter（重点）

---

Filter：过滤器，用来过滤网站的数据；

• 处理中文乱码
• 登陆验证…

Filter开发步骤：

1. 导包
2. 编写过滤器（导包不能错javax.servlet）

实现Filter接口，重写对应的方法

public class CharacterEncodingFilter implements Filter {
    //初始化：web服务器启动，就开始初始化了，随时等待过滤对象出现！
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        System.out.println("CharacterEncodingFilter初始化");
    }

    //Chain:链
    /*
    1、过滤器中的所有代码，在过滤特定请求的时候都会执行
    2、必须要让过滤器继续通行
    filterChain.doFilter(servletRequest,servletResponse);
    */
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        servletRequest.setCharacterEncoding("utf-8");
        servletResponse.setCharacterEncoding("utf-8");
        servletResponse.setContentType("text/html;charset=UTF-8");

        System.out.println("CharacterEncodingFilter执行前...");
        filterChain.doFilter(servletRequest,servletResponse);   //让我们的请求继续走，如果不写，程序到这里就被拦截停止！
        System.out.println("CharacterEncodingFilter执行后...");
    }

    //销毁：web服务器关闭的时候，过滤会销毁
    @Override
    public void destroy() {
        System.out.println("CharacterEncodingFilter销毁");
    }
}

3. 在web.xml中配置Filter

   <filter>
       <filter-name>CharacterEncodingFilter</filter-name>
       <filter-class>com.li.filter.CharacterEncodingFilter</filter-class>
   </filter>
   
   <filter-mapping>
       <filter-name>CharacterEncodingFilter</filter-name>
       <!--只要是/servlet的任何请求，会经过这个过滤器-->
       <url-pattern>/servlet/*</url-pattern>
   </filter-mapping>
   

12、监听器

---

实现一个监听器的接口：（有N种）

1. 编写一个监听器

   实现监听器的接口

   //统计网站在线人数：统计Session
   public class OnlineCountListener implements HttpSessionListener {
   
       //创建Session监听
       //一但创建Session就会触发一次这个事件
       @Override
       public void sessionCreated(HttpSessionEvent se) {
           ServletContext ctx = se.getSession().getServletContext();
   
           System.out.println(se.getSession().getId());
   
           Integer onlineCount = (Integer) ctx.getAttribute("OnlineCountListener");
   
           if (onlineCount == null) {
               onlineCount = new Integer(1);
           } else {
               int count = onlineCount.intValue();
   
               onlineCount = new Integer(count + 1);
           }
           ctx.setAttribute("OnlineCountListener", onlineCount);
       }
   
       //销毁Session监听
       //一但销毁Session就会触发一次这个事件
       @Override
       public void sessionDestroyed(HttpSessionEvent se) {
           ServletContext ctx = se.getSession().getServletContext();
           Integer onlineCount = (Integer) ctx.getAttribute("OnlineCountListener");
   
           if (onlineCount == null) {
               onlineCount = new Integer(0);
           } else {
               int count = onlineCount.intValue();
   
               onlineCount = new Integer(count - 1);
           }
           ctx.setAttribute("OnlineCountListener", onlineCount);
       }
   }
   

2. web.xml中注册监听器

   <!--注册监听器-->
   <listener>
       <listener-class>com.li.listener.OnlineCountListener</listener-class>
   </listener>
   

3. 看情况是否使用

13、过滤器、监听器常见应用

---

监听器：GUI编程中经常使用；

用户登陆之后才能进入主页，用户注销之后就不能进入主页了

1. 用户登陆之后，向Session中放入用户的数据

2. 进入主页的时候要判断用户是否已经登陆；要求：在过滤器中实现！

   HttpServletRequest request = (HttpServletRequest) req;
   HttpServletResponse response = (HttpServletResponse) resp;
   
   if (request.getSession().getAttribute("USER_SESSION")==null){
       response.sendRedirect("/error.jsp");
   }
   
   chain.doFilter(request,response);
   

       onlineCount = new Integer(1);
       } else {
           int count = onlineCount.intValue();
   
           onlineCount = new Integer(count + 1);
       }
       ctx.setAttribute("OnlineCountListener", onlineCount);
   }
   
   //销毁Session监听
   //一但销毁Session就会触发一次这个事件
   @Override
   public void sessionDestroyed(HttpSessionEvent se) {
       ServletContext ctx = se.getSession().getServletContext();
       Integer onlineCount = (Integer) ctx.getAttribute("OnlineCountListener");
   
       if (onlineCount == null) {
           onlineCount = new Integer(0);
       } else {
           int count = onlineCount.intValue();
   
           onlineCount = new Integer(count - 1);
       }
       ctx.setAttribute("OnlineCountListener", onlineCount);
   }
   

   }

3. web.xml中注册监听器

   <!--注册监听器-->
   <listener>
       <listener-class>com.li.listener.OnlineCountListener</listener-class>
   </listener>
   

4. 看情况是否使用

13、过滤器、监听器常见应用

---

监听器：GUI编程中经常使用；

用户登陆之后才能进入主页，用户注销之后就不能进入主页了

1. 用户登陆之后，向Session中放入用户的数据

2. 进入主页的时候要判断用户是否已经登陆；要求：在过滤器中实现！

   HttpServletRequest request = (HttpServletRequest) req;
   HttpServletResponse response = (HttpServletResponse) resp;
   
   if (request.getSession().getAttribute("USER_SESSION")==null){
       response.sendRedirect("/error.jsp");
   }
   
   chain.doFilter(request,response);