JavaWeb


reading:   

JavaWeb笔记

1、JavaWeb

​ Java Web，是用Java技术来解决相关web互联网领域的技术栈。

2、Tomcat

2.1、Tomcat是什么

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

下载地址：https://tomcat.apache.org/

2.2、Tomcat文件夹

几个重要的文件夹

  • bin文件夹：主要存放开启Tomcat和关闭服务的文件（windows:.bat文件，linux:.sh文件）
  • conf文件夹：放置Tomcat配置文件
  • lib文件夹：依赖库文件夹
  • webapps文件夹：放置网站
  • work文件夹：Tomcat服务器工作的目录

2.3、启动

windows:执行bin目录下的startup.bat文件

linux:执行bin目录下的startup.sh文件

2.3.1、可能出现问题

  1. 闪退：查看8080端口是否被其他程序占用

  2. 乱码：解码问题，并无大影响

    解决方法：修改conf/logging.properties中的java.util.logging.ConsoleHandler.encoding = UTF-8改为GBK

2.4、关闭

windows:关闭窗口

linux:执行shutdown.sh

3、Maven

3.1、Maven是什么

百度百科：

Maven是基于项目对象模型(POM project object model)，可以通过一小段描述信息（配置）来管理项目的构建，报告和文档的软件项目管理工具。

简单点讲就是管理jar包的工具。

3.2、约定大于配置

3.3、Maven下载

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

3.4、配置

3.4.1、环境变量（windows）

​ 此电脑右键-》属性-》高级系统设置-》环境变量-》系统变量中

新建俩条系统变量：

1
2
3
4
5
变量名：M2_HOME
变量值：Maven压缩后存放的位置\bin(例：D:\Maven\apache-maven-3.6.3\bin)

变量名：MAVEN_HOME
变量值：Maven压缩后存放的位置(例：D:\Maven\apache-maven-3.6.3\bin)

在系统变量Path中添加

1
%MAVEN_HOME%\bin

3.5、Maven仓库

3.5.1、网址

网址：https://mvnrepository.com/

找下载量多的下载，若更新年份较为久远可选新一些的下载量较多的版本。

3.5.2、pom.xml

1
2
3
4
5
6
7
8
9
10
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.jiuzhao73</groupId>
    <artifactId>javaweb-01-servlet03ALL</artifactId>
    <packaging>pom</packaging>
    <version>1.0-SNAPSHOT</version>
</project>

有与Maven约定大于配置，资源文件有可能无法导出，可在pom.xml中加入

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
<build>
    <resources>
        <resource>
            <directory>src/main/resources</directory>
            <includes>
                <include>**/*.properties</include>
                <include>**/*.xml</include>
            </includes>
        </resource>
        <resource>
            <directory>src/main/java</directory>
            <includes>
                <include>**/*.properties</include>
                <include>**/*.xml</include>
            </includes>
            <filtering>true</filtering>
        </resource>
    </resources>
</build>

3.5.3、导入

例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<dependencies>
        <!-- https://mvnrepository.com/artifact/javax.servlet/javax.servlet-api -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.1.0</version>
            <scope>provided</scope>
        </dependency>
        <!-- https://mvnrepository.com/artifact/javax.servlet.jsp/javax.servlet.jsp-api -->
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>javax.servlet.jsp-api</artifactId>
            <version>2.3.1</version>
            <scope>provided</scope>
        </dependency>
</dependencies>

这也是servlet和jsp需要的jar包

4、Servlet

4.1、Servlet是什么

Servlet是一个java接口，用于处理网络的接口

俩个子类：

  • HttpServlet
  • GenericServlet

4.2、HttpServlet

UML关系图：

4.3、Servlet原理

Servlet由web服务器（Tomcat）调用，web服务器在收到浏览器请求：

4.4、servlet-mapping

将servlet的class路径映射到url中。

4.4.1、一个servlet-mapping映射一个路径

1
2
3
4
<servlet-mapping>
    <servlet-name>hello</servlet-name>
    <url-pattern>/hello</url-pattern>
</servlet-mapping>

4.4.2、一个servlet-mapping映射多个路径

1
2
3
4
5
6
7
8
<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>

4.4.3、一个servlet-mapping映射通用路径

1
2
3
4
<servlet-mapping>
    <servlet-name>hello</servlet-name>
    <url-pattern>/hello/*</url-pattern>
</servlet-mapping>

4.4.4、默认映射设置

1
2
3
4
<servlet-mapping>
    <servlet-name>hello</servlet-name>
    <url-pattern>/*</url-pattern>
</servlet-mapping>

4.4.5、后缀实现

1
2
3
4
<servlet-mapping>
    <servlet-name>hello</servlet-name>
    <url-pattern>.jiuzhao</url-pattern>
</servlet-mapping>

4.4.6、优先级问题

​ 指定固有路径的映射优先级最高，如果找不到会前往默认的请求。

4.5、HttpServlet几个方法

4.5.1、方法

1
2
3
//getServletConfig()        获取Servlet配置
//getServletContext()       获取Servlet上下文
//getInitParameter()        获取初始化参数

4.5.2、web.xml参数

全局参数：

1
2
3
4
5
<!--全局上下文参数-->
<context-param>
    <param-name>url</param-name>
    <param-value>jdbc:mysql://localhost:3306</param-value>
</context-param>

servlet参数：

1
2
3
4
5
<!--servlet的参数-->
<init-param>
    <param-name></param-name>
    <param-value></param-value>
</init-param>

4.6、ServletContext

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

多个servlet可以访问共同的ServletContext以达到以下几个目的：

4.6.1、共享数据

web.xml映射配置块

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<servlet>
    <servlet-name>hello</servlet-name>
    <servlet-class>com.jiuzhao73.HelloServlet</servlet-class>
</servlet>
<servlet-mapping>
    <servlet-name>hello</servlet-name>
    <url-pattern>/hello</url-pattern>
</servlet-mapping>
<servlet>
    <servlet-name>getName</servlet-name>
    <servlet-class>com.jiuzhao73.GetUserNameContextServlet</servlet-class>
</servlet>
<servlet-mapping>
    <servlet-name>getName</servlet-name>
    <url-pattern>/getName</url-pattern>
</servlet-mapping>

可以看成servlet1（作为写入上下文节点的Servlet类）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class HelloServlet extends HttpServlet {
    //getServletConfig()        获取Servlet配置
    //getServletContext()       获取Servlet上下文
    //getInitParameter()        获取初始化参数
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.setContentType("text/html;charset=UTF-8");
        PrintWriter w = resp.getWriter();
        w.print("<h1>WELCOME!</h1>");
        getServletContext().setAttribute("UserName", "久曌");
        w.close();
    }

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

可以看成Servlet（作为读取上下文节点的servlet类）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class GetUserNameContextServlet extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //设置编码
        resp.setContentType("text/html;charset=UTF-8");
        PrintWriter w = resp.getWriter();
        ServletContext context = getServletContext();
        Object val = context.getAttribute("UserName");
        if (val instanceof String) {
            w.print("姓名：" + val);
        }
        w.close();
    }

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

结果：在/getName中看到（姓名：久曌），说明多个Servlet共享同一个ServletContext，并且ServletContext可以进行数据共享。

4.6.2、获取初始化参数

创建getContextParam类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class getContextParam extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String val = getServletContext().getInitParameter("url");
        PrintWriter w = resp.getWriter();
        w.print(val);
        w.close();
    }

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

web.xml配置，让getContextParam可以读取

1
2
3
4
5
6
7
8
9
10
11
12
13
<!--配置参数-->
<context-param>
    <param-name>url</param-name>
    <param-value>jdbc:mysql://localhost:3306</param-value>
</context-param>
<servlet>
    <servlet-name>getParam</servlet-name>
    <servlet-class>com.jiuzhao73.getContextParam</servlet-class>
</servlet>
<servlet-mapping>
    <servlet-name>getParam</servlet-name>
    <url-pattern>/getParam</url-pattern>
</servlet-mapping>

4.6.3、请求转发

4.6.3.1、重定向与请求转发

请求转发：

重定向：

请求转发不需要知道C，重定向需要知道。请求转发的url不变，重定向的url变为C的url。

4.6.3.2、例子
1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class requestDispatcherServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        PrintWriter w = resp.getWriter();
        //将请求转发到/getName
        getServletContext().getRequestDispatcher("/getParam").forward(req, resp);
        w.close();
    }

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

4.6.4、读取资源文件

Properties

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

发现：文件都打包到同一路径下：classes，这个路径称之为classpath。

/代表当前web应用

1
2
username=root
pwd=123456
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class servletDemo05 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        InputStream is = getServletContext().getResourceAsStream("/WEB-INF/classes/note.properties");
        Properties prop = new Properties();
        prop.load(is);
        String name = prop.getProperty("username");
        String pwd = prop.getProperty("pwd");
        PrintWriter w = resp.getWriter();
        w.print(name + ":" + pwd);
        w.close();
    }

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

4.7、HttpServletResponse

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

4.7.1、简单分类

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

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
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);
void setStatus(int 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);
void setStatus(int var1);

响应的状态码常量：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
int SC_CONTINUE = 100;
int SC_SWITCHING_PROTOCOLS = 101;
int SC_OK = 200;
int SC_CREATED = 201;
int SC_ACCEPTED = 202;
int SC_NON_AUTHORITATIVE_INFORMATION = 203;
int SC_NO_CONTENT = 204;
int SC_RESET_CONTENT = 205;
int SC_PARTIAL_CONTENT = 206;
int SC_MULTIPLE_CHOICES = 300;
int SC_MOVED_PERMANENTLY = 301;
int SC_MOVED_TEMPORARILY = 302;
int SC_FOUND = 302;
int SC_SEE_OTHER = 303;
int SC_NOT_MODIFIED = 304;
int SC_USE_PROXY = 305;
int SC_TEMPORARY_REDIRECT = 307;
int SC_BAD_REQUEST = 400;
int SC_UNAUTHORIZED = 401;
int SC_PAYMENT_REQUIRED = 402;
int SC_FORBIDDEN = 403;
int SC_NOT_FOUND = 404;
int SC_METHOD_NOT_ALLOWED = 405;
int SC_NOT_ACCEPTABLE = 406;
int SC_PROXY_AUTHENTICATION_REQUIRED = 407;
int SC_REQUEST_TIMEOUT = 408;
int SC_CONFLICT = 409;
int SC_GONE = 410;
int SC_LENGTH_REQUIRED = 411;
int SC_PRECONDITION_FAILED = 412;
int SC_REQUEST_ENTITY_TOO_LARGE = 413;
int SC_REQUEST_URI_TOO_LONG = 414;
int SC_UNSUPPORTED_MEDIA_TYPE = 415;
int SC_REQUESTED_RANGE_NOT_SATISFIABLE = 416;
int SC_EXPECTATION_FAILED = 417;
int SC_INTERNAL_SERVER_ERROR = 500;
int SC_NOT_IMPLEMENTED = 501;
int SC_BAD_GATEWAY = 502;
int SC_SERVICE_UNAVAILABLE = 503;
int SC_GATEWAY_TIMEOUT = 504;
int SC_HTTP_VERSION_NOT_SUPPORTED = 505;

4.7.2、下载文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    //1. 要获取下载文件的路径
    String filePath = "D:/01.png";
    //2. 下载的文件名是啥
    String fileName = filePath.substring(filePath.lastIndexOf("/") + 1);
    System.out.println(filePath);
    System.out.println(fileName);
    //3. 设置让浏览器能够支持我们需要的东西
    resp.setHeader("Content-disposition", "attachment;filename=" + URLEncoder.encode(fileName, "utf-8"));
    //4. 获取下载文件的输入流
    FileInputStream fis = new FileInputStream(filePath);
    //5. 创建缓冲区
    int len = 0;
    byte[] buffer = new byte[1024];
    //6. 获取OutputStream对象
    OutputStream os = resp.getOutputStream();
    //7. 将FileOutputStream写入buffer缓冲区，使用OutputStream将缓冲区中的数据输出到客户端。
    while ((len = fis.read(buffer)) > 0) {
        os.write(buffer, 0, len);
    }
    fis.close();
    os.close();
}

4.7.3、验证码的简单实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
public class ImageServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //设置浏览器刷新时间
        resp.setHeader("refresh", "3");
        //内存中创建一个图片
        BufferedImage bi = new BufferedImage(80, 40, BufferedImage.TYPE_INT_RGB);
        Graphics2D gs = bi.createGraphics();
        gs.setBackground(Color.BLUE);
        gs.setFont(new Font("red", Font.BOLD, 20));
        gs.drawString(getRandomNumByString(), 0, 20);
        //告诉浏览器，这个请求用图片方式打开
        resp.setContentType("image/jpeg");
        //网站存在缓存，不让浏览器缓存
        resp.setDateHeader("expires", -1);
        resp.setHeader("Cache-Control", "no-cache");
        resp.setHeader("Pragma", "no-cache");
        //把图片写给浏览器
        ImageIO.write(bi, "jpg", resp.getOutputStream());
    }

    private String getRandomNumByString() {
        String num = String.valueOf((int) (Math.random() * 100000));
        int len = 5 - num.length();
        StringBuilder sbu = new StringBuilder(5);
        for (int i = 0; i < len; i++) sbu.append(0);
        return sbu.append(num).toString();
    }

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

4.7.4、实现重定向

A向B发送请求，B通知A去访问另外一个web资源C

1
2
3
4
5
6
7
8
9
10
11
12
13
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>登入页面</title>
</head>
<body>
    <form action="${pageContext.request.contextPath}/login">
        账号：<input type="text" name="username"><br>
        密码：<input type="password" name="password"><br>
        <input type="submit">
    </form>
</body>
</html>
1
2
3
4
5
6
7
8
9
10
11
12
13
@WebServlet(name = "redirectServlet")
public class redirectServlet extends HttpServlet {
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        String userName = request.getParameter("username");
        String password = request.getParameter("password");
        System.out.println(userName+":"+password);
        response.sendRedirect("/r/imageNum");
    }

    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        doGet(request, response);
    }
}

4.8、HttpServletRequest

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>登入</title>
</head>
<body>
<form action="${pageContext.request.contextPath}/request">
    <h1>登入</h1>
    id:<input type="text" name="id"><br>
    密码：<input type="password" name="password"><br>
    爱好：
    <input type="checkbox" name="hobbies" value="游泳">游泳
    <input type="checkbox" name="hobbies" value="跳绳">跳绳
    <input type="checkbox" name="hobbies" value="长跑">长跑
    <input type="checkbox" name="hobbies" value="跳高">跳高
    <br>
    <input type="submit" name="提交">
</form>
</body>
</html>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class requestServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        req.setCharacterEncoding("UTF-8");
        resp.setCharacterEncoding("UTF-8");

        String id = req.getParameter("id");
        String password = req.getParameter("password");
        String[] hobbies = req.getParameterValues("hobbies");

        System.out.println("id=" + id + "\n" + "password=" + password);
        System.out.println(Arrays.toString(hobbies));
        req.getRequestDispatcher("/success.jsp").forward(req, resp);
    }

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

getParameter()、getParameterValues()方法来获取参数和参数数组。

getRequestDispatcher()方法请求转发。

${pageContext.request.contextPath}获取路径。

重定向与转发的区别：

相同点：

  • 页面都会实现跳转

不同点：

  • 请求转发时，url不会发生改变；307
  • 重定向时，url会发生变化；302

5、Cookie、Session

5.1、会话

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

有状态会话：类似一个专有服务员一直服务与你，直至你离开餐馆。

5.2、保存会话的两种技术

1、Cookie

cookie

  • 客户端技术

session

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

常见场景：网站登入之后，你下次不用在登陆，第二次访问直接就登入了。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public class CookieDemo01 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        req.setCharacterEncoding("utf-8");
        resp.setHeader("charset", "utf-8");
        Cookie[] cookies = req.getCookies();
        OutputStream out = resp.getOutputStream();
        for (Cookie c : cookies) {
            if (c.getName().equals("last_time")) {
                out.write(("您上次访问时间为：" +
                        new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(
                                Long.parseLong(c.getValue()))).getBytes());
            }
        }
        //写入cookie
        Cookie last_time = new Cookie("last_time", String.valueOf(System.currentTimeMillis()));
        last_time.setMaxAge(24 * 60 * 60);
        resp.addCookie(last_time);
    }

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

注：PrintWriter在使用时，setCharacterEncoding是无用的，响应时会自动使用ISO-8859-1，这时我们应该使用OutputStream out = resp.getOutputStream();

2、Session

Session方法:

s Function

Session与Cookie的区别：

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

session存活时间

1
2
3
4
<session-config>
    <!--以分钟为单位存活-->
    <session-timeout>1</session-timeout>
</session-config>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
@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();
    //req.getSession().invalidate();
    session.setAttribute("name", "久曌");
    if(session.isNew()){
        resp.getOutputStream().print("这是一个新的session");
    }else {
        System.out.println((String)session.getAttribute("name"));
    }
}

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

使用场景：

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

6、JSP

6.1、什么是JSP

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

6.2、JSP原理

方法：

1
2
3
4
5
6
//初始化
public void _jspInit() {}
//销毁
public void _jspDestroy() {}
//jsp服务
public void _jspService(HttpServletRequest request, HttpServletResponse response){}

JSP内置对象：

1
2
3
4
5
6
7
8
PageContext pageContext;		//页面上下文
HttpSession session = null;		//会话
ServletContext application;		//applicationContext
ServletConfig config;			//config
JspWriter out = null;			//输出
Object page = this;				//页面
HttpServletRequest request		//请求
HttpServletResponse response	//响应

6.3、JSP基础语法

1
2
3
4
5
6
7
8
9
10
11
<%--导包--%>
<%@ page import="java.util.*"%>
<%--局部变量--%>
<%int x = 10;%>
<%System.out.println(x);%>
<%
    for (int i = 0; i < 5; i++) {
%>
<h1><%=i%>
</h1>
<%}%>

局部变量生成在try块中

1
2
3
4
5
6
7
8
9
10
<%--全局变量--%>
<%!
    //静态内部类

    static class test {
    }

    //类属性
    int num = 10;
%>

全局变量生成在类中

EL表达式

1
2
${x}
<%=x%>

${xx} 意思是取出某一范围中名称为xx的变量，取值范围Page,Request,Session,Application。

${param.xx} 意思是获取请求的元素，相当于 request.getParameter(“xx”)。

6.4、注释

1
2
3
<!--html注释-->
<%--JSP注释--%>
//Java注释

html注释会出现在页面上，另外俩个不会

6.5、指令用法

6.5.1、错误页面跳转

（JSP、web.xml）：

1
<%@ page errorPage="Error/404.jsp" %>
1
2
3
4
<error-page>
    <error-code>404</error-code>
    <location>/Error/404.jsp</location>
</error-page>

6.5.2、导入其他页面

1
2
3
<%@ include file="header.jsp" %>
<h1>身体</h1>
<%@ include file="fotter.jsp" %>

标签：

1
2
3
<jsp:include page="/header.jsp"></jsp:include>
<h1>身体</h1>
<jsp:include page="/fotter.jsp"></jsp:include>

@include：会将俩个页面合二为一。

缺点：如果合并的文件繁多，会因此占了过多的本地存储空间。

优点：因为已经生成了jsp文件，不需要在去拼接，提高运行效率。

jsp:include：仍是三个页面。

缺点：每次用户请求都需要进行拼接，消耗事件，用户体验差上些许。

优点：占用空间小。

6.6、九大内置对象

  • PageContext 存东西
  • Request 存东西
  • Response
  • Application ServletContext 存东西
  • Session 存东西
  • Config SerlvetConfig
  • out
  • Page
  • Exception

源码：

1
2
3
4
5
6
7
8
9
10
final javax.servlet.jsp.PageContext pageContext;
javax.servlet.http.HttpSession session = null;
final javax.servlet.ServletContext application;
final javax.servlet.ServletConfig config;
javax.servlet.jsp.JspWriter out = null;
final java.lang.Object page = this;
javax.servlet.jsp.JspWriter _jspx_out = null;
javax.servlet.jsp.PageContext _jspx_page_context = null;
final javax.servlet.http.HttpServletRequest request
final javax.servlet.http.HttpServletResponse response

从pageContext取出，我们通过的寻找方式：

从底层到高层（作用域）：page->request->session->application->null

1
<% pageContext.findAttribute("name"); %>
1
2
3
4
5
6
<%
    pageContext.setAttribute("mate1", "abc");   //保存在一个页面中有效
    request.setAttribute("mate1","def");        //保存的数据在一次请求中有效
    application.setAttribute("mate1","ghi");    //保存的数据在服务器有效
    session.setAttribute("mate1","jkl");		//保存的数据在一次会话中有效
%>

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

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

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

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

导包

1
2
3
4
5
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>jstl</artifactId>
    <version>1.2</version>
</dependency>

EL表达式：${}

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

JSP标签：

1
2
3
4
5
6
<jsp:include page="Error/404.jsp"></jsp:include>
<%--http://localhost:8080/index.jsp?name=jiuzhao--%>
<!--请求转发-->
<jsp:forward page="/index.jsp">
    <jsp:param name="name" value="jiuzhao"/>
</jsp:forward>

JSTL表达式：

JSTL（Java server pages standarded tag library，即JSP标准标签库）是由JCP（Java community Proces）所制定的标准规范，它主要提供给Java Web开发人员一个标准通用的标签库，并由Apache的Jakarta小组来维护。开发人员可以利用这些标签取代JSP页面上的Java代码，从而提高程序的可读性，降低程序的维护难度。

简单来说，JSTL就是弥补Html的不足，也是一种标签。

  • 核心标签
  • 格式化标签
  • SQL标签
  • XML标签
  • JSTL函数

核心标签：

导入：

1
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
核心标签 描述
<c:out> 用于在JSP中显示数据，就像<%= … >
<c:set> 用于保存数据
<c:remove> 用于删除数据
<c:catch> 用来处理产生错误的异常状况，并且将错误信息储存起来
<c:if> 与我们在一般程序中用的if一样
<c:choose>, <c:when>, <c:otherwise> 循环
<c:import> 检索一个绝对或相对 URL，然后将其内容暴露给页面
<c:forEach>, <c:forTokens> 迭代
<c:redirect> 跳转
<c:url> 使用可选的查询参数来创造一个URL 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
<%@ page contentType="text/html;charset=UTF-8" language="java" pageEncoding="UTF-8" %>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<form action="JSTLDemo01.jsp" method="get">
    姓名：<input type="text" name="name" value="${param.name}">
    <input type="submit">
</form>
<c:if test="${param.name == 'root'}" var="isResult">
    <c:out value="welcome,root!"/>
</c:if>
<c:out value="${isResult}"/>
</body>
</html>

7、JavaBean

maven依赖:

1
2
3
4
5
6
<!--导入mysql驱动-->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.21</version>
</dependency>

实体类例子：

1
2
3
4
5
6
7
8
9
10
public class Address {
    private long id;
    private String tel;
    public Address() {}
    public long getId() {return id;}
    public void setId(long id) {this.id = id;}
    public String getTel() {return tel;}
    public void setTel(String tel) {this.tel = tel;}
}

JavaBean有特定的写法：

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

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

ORM：对象关系映射

  • 表–>类
  • 字段–>属性
  • 行记录–>对象
1
2
3
4
5
6
<jsp:useBean id="address" class="com.jiuzhao73.entity.Address" scope="page"/>
<%--赋值--%>
<jsp:setProperty name="address" property="id" value="123"/>
<jsp:setProperty name="address" property="tel" value="12345678912"/>
id:${address.id}<br>
tel:${address.tel}

8、三层架构与MVC

MVC:

三层架构：

三层架构和MVC的目标都是一致的：为了解耦合、提高代码的复用。

不同：三层架构是软件架构，MVC是设计模式

对应关系

Filter（过滤器）:对用户的读取进行拦截

功能：

  • 在request到达servlet之前，检查或修改resquest。
  • 在reponse到达web服务器之前，检查或修改reponse。

可能有多个过滤器一起过滤

1
2
3
4
5
6
7
8
9
10
11
//在服务器关闭时，销毁过滤器
public void destroy() {}
//在调用过滤资源时，先调用doFilter
public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws ServletException, IOException {
    resp.setContentType("text/html;charset=utf-8");
    resp.setCharacterEncoding("utf-8");
    //过滤器放行chain.doFilter(req, resp)
    chain.doFilter(req, resp);
}
//在服务器刚开启时，创过滤听器
public void init(FilterConfig config) throws ServletException {}

web.xml：

1
2
3
4
5
6
7
8
<filter>
    <filter-name>CharsetFilter</filter-name>
    <filter-class>com.jiuzhao73.filter.CharsetFilter</filter-class>
</filter>
<filter-mapping>
    <filter-name>CharsetFilter</filter-name>
    <url-pattern>/hello</url-pattern>
</filter-mapping>

10、Listener

（监听器）：

注册监听器（web.xml）:

1
2
3
<listener>
    <listener-class>com.jiuzhao73.MyListener</listener-class>
</listener>

11、Junit单元测试

依赖导入：

1
2
3
4
5
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.11</version>
</dependency>

@Test只有在方法上有效

扫一扫，分享到微信

微信分享二维码

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

很惭愧<br><br>只做了一点微小的工作<br>谢谢大家