JavaWeb

Web分类
- 静态web
- 动态web

B/S：浏览器和服务器；C/S：客户端和服务器。

ASP
PHP
JSP
- sun公司主推的B/S架构
Web服务器：
- IIS
- Tomcat

Tomcat

启动/关闭

bin/startup.bat

bin/shutdown.bat

web工程

工程在webapps里，开启服务后，localhost:8080默认访问ROOT工程，localhost:8080/工程名，这样可访问其他工程，如我在webapps中创建了Tang工程，开启服务后可访问。

http://localhost:8080/Tang/

端口号等配置

conf/server.xml可自行修改配置文件

tomcat默认端口号：8080
mysql：3306
http：80
https；443

网站访问的过程!!

输入域名
查找本机C:\Windows\System32\drivers\etc\hosts配置文件中是否有该域名的映射
- 有，则返回ip地址
- 没有，去DNS服务器查找，找到则返回

HTTP（超文本传输协议）

文本：html，字符串。。。

超文本：图片，音乐，视频，定位。。。

https：更安全

1、http区别

http1.0
- HTTP/1.0：客户端与web服务器连接后，只能获得一个web资源
http2.0
- HTTP/1.1：客户端与web服务器连接后获得多个web资源

2、http请求

客户端–>请求–>服务器

百度：

Request URL: https://www.baidu.com/		请求地址
Request Method: GET		GET/POST方法
Status Code: 200 OK		状态码：200
Remote Address: 112.80.248.75:443	远程地址
Referrer Policy: unsafe-url   	发送信息的策略

请求方法（https://www.w3school.com.cn/tags/html_ref_httpmethods.asp）
- get：查询字符串（键/值）是在 GET 请求的 URL 中发送的，不安全，请求参数受限，但是高效
- post：通过 POST 发送到服务器的数据存储在 HTTP 请求的请求主体中，不会在url中显示，安全，参数不受限，但不高效。
Referrer Policy简单介绍：https://www.cnblogs.com/amyzhu/p/9716493.html

请求报文：

Accept: text/html
Accept-Encoding: gzip, deflate, br
Accept-Language: zh-CN,zh;q=0.9
Cache-Control: max-age=0
Connection: keep-alive

消息头：
- Accept：支持的数据类型
- Accept-Encoding：支持的编码格式
- Accept-Language：语言环境
- Cache-Control：缓存控制
- Connection：告诉浏览器，完成请求后是连接还是断开

3、http响应

服务器–>响应–>客户端

百度（响应报文）：

Cache-Control: private	缓存控制
Connection: keep-alive	连接
Content-Encoding: gzip	编码
Content-Type: text/html	类型

响应状态码：
- 2xx：请求响应成功 200
- 3xx：请求重定向
- 4xx：找不到资源 404
- 5xx：服务器代码错误（502网关错误）

4、当你在浏览器地址栏输入一个URL后回车，将会发生的事情？

大佬详细解析：

https://zhuanlan.zhihu.com/p/351247892

https://juejin.cn/post/6844903919395536910

DNS域名解析
- DNS迭代
- DNS递归
TCP三次握手
HTTP请求
服务器响应HTTP请求，浏览器获得html
TCP四次挥手，断开连接
浏览器解析html，并请求html中的资源
浏览器对页面进行渲染，展示给用户

Maven（约定大于配置）

方便jar包导入

约定大于配置指每个文件目录都是用来写约定好的默认项目，结果自己写了默认范围外的东西进去了，这些约定外的部分不会被处理。

1、配置环境变量

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

2、maven阿里云镜像加速

<mirror>
    <id>nexus-aliyun</id>
    <mirrorOf>*,!jeecg,!jeecg-snapshots</mirrorOf>
    <name>Nexus aliyun</name>
    <url>http://maven.aliyun.com/nexus/content/groups/public</url> 
</mirror>

3、本地仓库

在settings配置文件中设置localRepository

1	<localRepository>F:\Environment\apache-maven-3.8.1\maven-repo</localRepository>

4、IDEA新建Maven项目

我们选择使用骨架创建Maven的java web项目
- create from archetype 勾选，然后选择maven···webapp
- next后自定义项目名称及Artifact Coordinates（这个一般会收起来隐藏，一定要自己点击后配置id，不然项目会有问题）
- 自行补全剩余目录，java、resources，test自选
- File—Project Structure，管理项目结构
不用骨架创建web项目
- 细节看文章，就不截图了，注意war包，先按教程生成对应项目的war:explore
- 自己在重复explore生成过程，不过要选择Web Application:Archive，生成war

详细步骤：

https://blog.csdn.net/qq_42057154/article/details/106114515

https://blog.csdn.net/qq_41435602/article/details/104561206

5、配置Tomcat（war包的区别）

流程
- 点击绿色run按钮旁的方框进入运行相关配置界面。
- 然后点击左上角+，选择Tomcat Server。
- 进去后切记不可在before launch处添加war包。（耗了三小时才搞清楚）
- 注意要自定义部署页面的名称，不然直接用8080会把原本的ROOT文件覆盖
war 和 war explore区别
- war explore热部署
- https://blog.csdn.net/gghh2015/article/details/79509557

麻了。手贱在配置Tomcat时先点了一下before launch，导致lib目录出不来。。。详细情况看隔壁的文章，第一次跟着视频学还出问题，没谁了😥，这就是赶着看的后果吧。。

6、pom.xml（约定大于配置要自行配置）

<!-- 配置的GAV -->
<groupId>com.tang</groupId>
<artifactId>JavaWeb-maven1</artifactId>
<version>1.0-SNAPSHOT</version>
<!-- 打包方式
    jar：Java应用
    war：JavaWeb应用
-->
<packaging>war</packaging>

<!-- 配置 -->
<properties>
    <!-- 项目默认构建编码 -->
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <!-- 编码版本 -->
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
</properties>

Maven会自动导入你设置的jar包的需要的其他jar包
Scope标签细节：https://www.cnblogs.com/ergexy/p/10550980.htmlS

<!-- 项目依赖 -->
<dependencies>
    <!-- 依赖jar包的配置文件 -->
    <!-- Maven会自动导入你设置的jar包需要的其他jar包 -->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.11</version>
        <scope>complie</scope>
    </dependency>
</dependencies>

Maven由于它的约定大于配置，可能会有我们写的配置文件无法导出等问题

参考：https://www.cnblogs.com/pixy/p/4798089.html

<!-- 在build中配置resources，防止资源导出失败问题 -->
<build>
    <resources>
        <resource>
            <directory>src/main/resources</directory>
            <includes>
                <include>**/*.properties</include>
                <include>**/*.xml</include>
            </includes>
            <filtering>true</filtering>
        </resource>
        <resource>
            <directory>src/main/java</directory>
            <includes>
                <include>**/*.properties</include>
                <include>**/*.xml</include>
            </includes>
            <filtering>true</filtering>
        </resource>
    </resources>
</build>

7、Maven仓库查找

官方地址：https://mvnrepository.com/

对要使用的jar包alt+回车，选择maven选项自动搜索导入包，如果没找到则需自己下载方便以后的使用。

8、web.xml（4.0版本头信息）

配置web的核心应用，注册servlet

注意此处的metadata-complete，T表示不使用注解，不写/F则使用注解

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
          http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0"
         metadata-complete="true">

</web-app>

9、servlet简单调试

使用tomcat9，不可用tomcat10。其中javax换成了jakarta

看工程Maven1，tomcat还是要用稳定版本

Servlet

Servlet接口Sun公司有两个默认实现类：

HttpServlet、GenericServlet

1、简述

Sun公司为API提供的一个接口：Servlet
- 编写类，实现Servlet接口
- 将开发好的java类部署到web服务器

常将实现了Servlet接口的java类认为是Servlet

2、Hello Servlet（parent标签格式）

构建一个普通Maven项目，删除src目录，以后学习都在此处建立Moudel，，该空工程便是Maven主工程，

Maven父子工程：

父项目有modules标签

1
2
3

<modules>
    <module>servlet1</module>
</modules>

子项目有parent标签

加载的时候有，加载完毕就消失了，可能是软件版本问题，可自己手动加上parent标签

<parent>
    <groupId>com.tang</groupId>
    <artifactId>fanther-id</artifactId>
    <version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>

<artifactId>son-id</artifactId>
<packaging>war</packaging>

父项目java子项目可直接使用，类似继承。

maven优化

修改web.xml头信息
maven其他结构文件夹补全

Servlet程序

编写一个普通类来实现Servlet接口
实现Servlet接口，继承HttpServlet

HttpServlet–》继承GenericServlet–》实现Servlet

其中service方法最重要，直到HttpServlet类才实现了其方法体，然后我们要在自己的继承类中重写该方法，其中有多种方式的判断，我们现在多用get和post

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 {
        doGet(req,resp);
    }
}

编写Servlet映射Mapping

写的是Java程序，要通过web服务到浏览器访问，而浏览器需要我们的路径（配置映射）

<!-- 注册Servlet -->
    <servlet>
        <servlet-name>Helloservlet</servlet-name>
        <servlet-class>com.tang.servlet.HelloServlet</servlet-class>
    </servlet>
    <!-- 映射:请求路径 -->
    <servlet-mapping>
        <servlet-name>Helloservlet</servlet-name>
        <url-pattern>/Hello</url-pattern>
    </servlet-mapping>

配置Tomcat

和之前一样，配置好后测试，注意要跑其他项目时，应先清理之前项目导入Tomcat中的war包

3、Servlet原理

Servlet由web服务器调用

4、Mapping映射

一个Servlet对应一个映射路径

<!-- 映射:请求路径 localhost:8080/Maven/Hello-->
<servlet-mapping>
    <servlet-name>Helloservlet</servlet-name>
    <url-pattern>/Hello</url-pattern>
</servlet-mapping>

一个Servlet对应多个路径

<servlet-mapping>
    <servlet-name>Helloservlet</servlet-name>
    <url-pattern>/Hello</url-pattern>
</servlet-mapping>
<servlet-mapping>
    <servlet-name>Helloservlet</servlet-name>
    <url-pattern>/Hello1</url-pattern>
</servlet-mapping>
<servlet-mapping>
    <servlet-name>Helloservlet</servlet-name>
    <url-pattern>/Hello2</url-pattern>
</servlet-mapping>

一个Servlet可指定通用映射路径，或自定义后缀等

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

<!--默认请求路径-->
<servlet-mapping>
    <servlet-name>Helloservlet</servlet-name>
    <url-pattern>/*</url-pattern>
</servlet-mapping>

<!--自定义后缀-->
<servlet-mapping>
    <servlet-name>Helloservlet</servlet-name>
    <url-pattern>*.xxxxx</url-pattern>
</servlet-mapping>

5、ServletContext（上下文连接）

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

共享数据

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

设置发送类

public class HelloServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        ServletContext sc = this.getServletContext();

        String username="Tang";
        sc.setAttribute("username",username);//键值对
    }
}

接收类，注意要先跑一下发送类，不然数据都没传怎么可能收到呢？

public class GetServlet extends HelloServlet{
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        ServletContext sc = this.getServletContext();
        String username = (String) sc.getAttribute("username");

        resp.setContentType("text/html");
        resp.setCharacterEncoding("utf-8");
        resp.getWriter().print("你的名字是："+username);//要先跑一下Hello，不然拿不到数据，因为还没输入呢
    }
}

配置web.xml的Servlet

获得初始化参数

web.xml写上以下语句对应键值对，然后用ServletContext的getInitParameter()方法拿一下

<context-param>
    <param-name>name</param-name>
    <param-value>Tang</param-value>
</context-param>

请求转发

写一个转发类，使用getRequestDispatcher,自己的Servlet照常设置

public class Demo1 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        ServletContext sc = this.getServletContext();
        //转发去别的路径，还是走自己的路径，结果是别人的
        sc.getRequestDispatcher("/get").forward(req,resp);
    }
}

读取资源文件

输入流获得文件路径，然后输出。使用properties

public class PropertiesServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        InputStream is = this.getServletContext().getResourceAsStream("/WEB-INF/classes/db.properties");

        Properties prop = new Properties();
        prop.load(is);
        String username = prop.getProperty("username");
        String password = prop.getProperty("password");

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

6、HttpServletResponse

web服务器收到客户端请求，会创建HttpServletResponse和HttpServletRequest，对应响应和请求。其中通过HttpServletRequest获得客户端的参数，通过HttpServletResponse给客户端响应信息。

代码看底层分析，这两个方法最常用。而且底层可以发现定义了很多状态码。

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

向浏览器输出信息（就是前面在干的事情）

下载文件

获取下载文件路径、文件名
让浏览器支持下载的东西
获取文件输入流
创建缓冲区
获得OutputStream对象
FileOutputStream流写入buffer缓冲区，用OutputStream将缓冲区数据输出到客户端

public class FileServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //1、获取下载文件路径、文件名
        //F:\IDEA\work\MavenWeb\Maven2\response\target\response\WEB-INF\classes\1.png
        String realPath = "F:\\IDEA\\work\\MavenWeb\\Maven2\\response\\target\\response\\WEB-INF\\classes\\1.png";
        System.out.println("下载的路径："+realPath);
        String filename = realPath.substring(realPath.lastIndexOf("\\") + 1);
        //2、让浏览器支持下载的东西("Content-disposition")
        resp.setHeader("Content-disposition","attachment;filename="+filename);
        //3、获取文件输入流
        FileInputStream in = new FileInputStream(realPath);
        //4、创建缓冲区
        int len = 0;
        byte[] buffer = new byte[1024];
        //5、获得OutputStream对象
        ServletOutputStream out = resp.getOutputStream();
        //6、FileOutputStream流写入buffer缓冲区，用OutputStream将缓冲区数据输出到客户端
        while ((len=in.read(buffer)) > 0){
            out.write(buffer,0,len);
        }
        in.close();
        out.close();
    }
}

图片变换码

public class ImageServlet extends HttpServlet{
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //浏览器3s刷新
        resp.setHeader("refresh","1");
        //内存中创建图片
        BufferedImage image = new BufferedImage(100,30,BufferedImage.TYPE_INT_RGB);
        //得到图片
        Graphics2D g = (Graphics2D) image.getGraphics();//画笔
        //图片背景颜色
        g.setColor(Color.cyan);
        g.fillRect(0,0,100,50);
        //图片写数据
        g.setColor(Color.white);
        g.setFont(new Font(null,Font.BOLD,25));
        g.drawString(random(),0,20);
        //告诉浏览器，请求以图片的形式打开
        resp.setContentType("image/jpeg");
        //网站有缓存，不让浏览器缓存
        resp.setDateHeader("expires",-1);
        resp.setHeader("Cache-Control","no-cache");
        resp.setHeader("Pragma","no-cache");
        //图片写给浏览器
        ImageIO.write(image,"jpg",resp.getOutputStream());
    }
    //随机数
    private String random(){
        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;
    }
}

重定向

web资源（A）收到客户端（B）请求后，它会通知客户端（B）去访问web资源（C），这就是重定向的过程。一般就是各种页面跳转体现最明显。

public class RedirectServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.sendRedirect("/response_war/img");
    }
}

重定向和转发的区别

相同：页面都会跳转

不同：转发地址栏url不变（307），重定向url会变化（302），转发是引用其他页面，重定向则是跳转。

7、HttpServletRequest

HttpServletRequest代表客户端请求，用户通过Http协议访问服务器，Http请求的信息被封装到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[] parameterValues = req.getParameterValues("hobbys");
        req.getRequestDispatcher("/yes.jsp").forward(req,resp);
    }

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

注意重定向写地址要写全，要包括tomcat里war包的地址，转发则只需要写当前页面的地址，主要刚刚做完重定向，再写转发就下意识把war包地址也写了，还调试了半天。。。

重定向和转发的区别

相同：页面都会跳转

不同：转发地址栏url不变（307），重定向url会变化（302），转发是引用其他页面，重定向则是跳转。

1、会话

会话： 用户打开浏览器，点击很多超链接，访问多个web资源，随后关闭浏览器，这个过程称为会话。

有状态的会话：登录网站时，信息状态被记录，相当于你来过一个地方，下次来的时候这里的人还记得你曾来过，也就是被记录住了，这差不多就是有状态会话。

Cookie：服务器给客户端一个凭证，客户端下次访问时带上凭证就行。

Session：服务器登记过客户端来过，下次访问时由服务器来匹配客户端。

2、保存会话的两种技术

Cookie

客户端技术（请求、响应）
Session

服务器技术，可把信息数据存放到Session中，保存用户信息

一般会发现网站多次登录会记住登录的信息

请求中拿到Cookie

服务器响应给客户端Cookie

Cookie会缓存到本地文件中

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

一个Cookie只保存一个信息
一个web站点可以发送给浏览器多个Cookie，上限20~
Cookie大小限制为4kb~
浏览器有300~cookie上限

删除Cookie

不设置有效期，关闭浏览器，会自动失效
有效期设置0

4、Session（重点！！！）

服务器给浏览器创建一个Session对象，每个用户的SessionID唯一
浏览器独占一个Session，每个浏览器相当于一个新的Session
Session用来保存各种用户的信息，用户登录后可访问网站全部功能

Session与Cookie的区别：

Cookie是把用户数据提交给用户浏览器，有浏览器保存
Session是把用户数据写到用户独占的Session中，服务器保存（保存重要信息，避免资源浪费）
Session对象由服务器创建

应用：购物车、网站登录数据、用户登录数据

Session小实现：

public class SessionServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse response) throws ServletException, IOException {
        response.setContentType("text/html");
        response.setCharacterEncoding("utf-8");
        response.setContentType("text/html; charset=UTF-8");
        //得到session
        HttpSession session = req.getSession();
        //在session中存储信息
        session.setAttribute("name","汤承");
        //获取id
        String id = session.getId();
        if(session.isNew()) {
            response.getWriter().write("session创建成功,id是" + id);
        }else {
            response.getWriter().write("session已存在,id是" + id);
        }
    }
}

public class SessionServlet2 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse response) throws ServletException, IOException {
        response.setContentType("text/html");
        response.setCharacterEncoding("utf-8");
        response.setContentType("text/html; charset=UTF-8");
        //得到session
        HttpSession session = req.getSession();
        //在session中存储信息
        String name = (String) session.getAttribute("name");
        System.out.println(name);
    }
}

//手动注销，也可在web.xml中设置有效时间
public class SessionServlet3 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse response) throws ServletException, IOException {
        response.setContentType("text/html");
        response.setCharacterEncoding("utf-8");
        response.setContentType("text/html; charset=UTF-8");
        //得到session
        HttpSession session = req.getSession();
        //session注销
        session.removeAttribute("name");
        session.invalidate();
    }
}

<!-- 设置session的失效时间，自动注销，以分钟为单位 -->
<session-config>
  <session-timeout>1</session-timeout>
</session-config>

JSP

Java Server Pages：Java服务器端页面，和Servlet一样，应用于动态web。

特点：

写JSP约等于写HTML
区别：
- HTML给用户提供静态数据
- JSP可嵌入Java代码，为用户提供动态数据

1、JSP原理

服务器工作

Tomcat：

1	F:\Environment\apache-tomcat-9.0.46\work\Catalina\localhost\ROOT\org\apache\jsp

IDEA中运行Tomcat：

1	C:\Users\Lenovo\AppData\Local\JetBrains\IntelliJIdea2020.3\tomcat\a9bc89a7-4fe3-4f37-bf25-36590eb23696\work\Catalina\localhost\Maven1\org\apache\jsp

最后发现页面最终转化成了Java页面，浏览器向服务器发送请求，访问资源实际是访问Servlet。JSP最终转化为Java类。

JSP溯源

首先我们发现jsp.java继承于HttpJspBase

<!--相关依赖-->
<dependency>
    <groupId>tomcat</groupId>
    <artifactId>jasper-runtime</artifactId>
    <version>5.5.23</version>
</dependency>

我们可以发现jsp最终还是继承于Servlet的

1	class HttpJspBase extends HttpServlet implements HttpJspPage

所以JSP本质上就是一个Servlet

public void _jspInit() 

public void _jspDestroy() 

public abstract void _jspService(HttpServletRequest var1, HttpServletResponse var2) throws ServletException, IOException

内置对象：

final javax.servlet.jsp.PageContext pageContext;	//页面上下文
javax.servlet.http.HttpSession session = null;		//Session
final javax.servlet.ServletContext application;		//ServletContext
final javax.servlet.ServletConfig config;			//设置
javax.servlet.jsp.JspWriter out = null;				//输出
final java.lang.Object page = this;					//当前页
HttpServletRequest var1, HttpServletResponse var2	//请求、响应

输出页面前的相关配置：

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中可直接使用

2、JSP基础语法

了解语法

JSP表达式，使用变量，程序的输出（不以分号结尾）
1
<%= 变量或表达式%>

JSP脚本（类比Java ，其实就是跑java）

<%
    for(int i = 0; i<5; i++){
%>
    <h1>ttttCCC</h1>
<%
    }
%>

JSP声明，定义变量、方法（初始化）
1
2
3
<%!
int num = 0;
%>

<%%>
<%=%>
<%!%>
<%--JSP注释不会在客户端显示--%>

3、九大内置对象及四大作用域

JSP九大内置对象和四大作用域：

https://blog.csdn.net/qq_40587575/article/details/79810019

九大对象

pageContext ！！
request ！！
response
session ！！
application(ServletContext) ！！
config(ServletConfig)
out
page
exception

四大作用域

pageContext.setAttribute(···);//保存的数据在一个页面中有效（page）
request.setAttribute(···);//保存的数据在一次请求中有效，请求转发会携带该数据（request）
session.setAttribute(···);//保存数据在一次会话中有效，从打开浏览器到关闭（session）
application.setAttribute(···);//保存数据在服务器中有效，从打开服务器到关闭服务器（application）

request：使用后不会再用第二次

session：会有多次重复使用

application：自己查看的数据，其他人也能看（群聊）

4、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标签

1
2
3

<jsp:forward page="/hello.jsp">
    <jsp:param name="name" value="Ta"/>
</jsp:forward>

JSTL表达式

https://www.runoob.com/jsp/jsp-jstl.html

JSTL标签库是为了弥补HTML的不足，它自定义许多标签供我们使用。标签功能 = java。

核心标签！

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

格式化标签
SQL标签
XML标签

先导入对应的标签库，然后选择对应的方法使用即可。Tomcat也要导入JSTL相关包，否则会JSTL解析错误。以下是核心标签的展示。

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%--引入标签库--%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    
<h1>jstl</h1>
<form action="jstl.jsp" method="get">
    <input type="text" name="username" value="${param.username}">
    <input type="submit" value="on">
</form>

<c:if test="${param.username=='admin'}" var="isAdmin" >
    <c:out value="管理员"></c:out>
</c:if>
<c:out value="${isAdmin}"></c:out>

</body>
</html>

JavaBean

实体类，JavaBean特定写法：

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

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

ORM：对象关系映射

表——》类
字段——》属性
行记录——》对象

//实体类结构和数据库表结构相对应
public class Person {
    private int id;
    private String name;
    private int age;

    public Person() {
    }

    public Person(int id, String name, int age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

MVC三层架构

MVC：Model、View、Controller；模型、视图、控制器。

Model（JavaBean）
- 连接数据库，数据持久化，CURD（Dao）
- 业务处理（Service）
View视图层（JSP，前端等）
- 展示数据模型
- 提供用户操作
Controller控制层（Servlet）
- 接受用户请求
- 响应客户端（交给业务层，Model）
- 控制视图跳转

Filter（重点）

Filter：过滤器。处理中文乱码、登录验证等。

开发步骤

导入包，不要导错了有同名的，导javax.servlet下的

编写过滤器

过滤的所有代码，在过滤特点请求时执行

要使用chain.doFilter方法，使得过滤器按流程运行（chain.doFilter(request,response);）

实现接口，重写对应方法。

public class CharacterFilter implements Filter {

    //web服务器启动就已经初始化
    public void init(FilterConfig filterConfig) throws ServletException {
        System.out.println("初始化成功");
    }

    //chain:链
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        request.setCharacterEncoding("utf-8");
        response.setCharacterEncoding("utf-8");
        response.setContentType("text/html; charset=UTF-8");

        System.out.println("过滤前");
        //转发过滤信息，为了数据交接，否则被拦截
        chain.doFilter(request,response);
        System.out.println("过滤后");
    }

    //web服务器关闭时，过滤器销毁
    public void destroy() {
        System.out.println("销毁成功");
    }
}

web.xml中配置filter

<filter>
    <filter-name>f</filter-name>
    <filter-class>com.tang.filter.CharacterFilter</filter-class>
</filter>
<filter-mapping>
    <filter-name>f</filter-name>
    <!-- f路径下的全部内容均通过过滤器 -->
    <url-pattern>/f/*</url-pattern>
</filter-mapping>

登录拦截应用

用户登录后，向session放入用户数据

要跳转时判断是否登录，通过过滤器实现

public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
    HttpServletRequest request = (HttpServletRequest) servletRequest;
    HttpServletResponse response = (HttpServletResponse) servletResponse;

    if(request.getSession().getAttribute("USER_SESSION") == null){
        response.sendRedirect("/Filter/error.jsp");
    }

    filterChain.doFilter(servletRequest,servletResponse);
}

小结

SSM冲！！！，剑指Offer也开始刷，就不做力扣每日了。