JavaWeb基础一

JavaWeb

IDEA 快捷键：

导包：alt + enter
看方法的具体：ctrl + b /鼠标左键
重写父类方法：ctrl + o
补充左边代码：ctrl + alt + v 或 alt + enter
代码规范：ctrl + alt + l
：alt + insert
注释：Ctrl + / 或 Ctrl +Shift+ /

基本

新的web.xml

<?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>

基本路径

    <!--路径映射-->
    <servlet>
        <servlet-name>login</servlet-name>
        <servlet-class>com.requst.test.loginServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>login</servlet-name>
        <url-pattern>/login</url-pattern>
    </servlet-mapping>

maven依赖包 pom.xml

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
            <scope>test</scope>
        </dependency>
    
    <!--  jsp-api：项目依赖-->
    <dependency>
        <groupId>javax.servlet.jsp</groupId>
        <artifactId>jsp-api</artifactId>
        <version>2.2</version>
        <scope>provided</scope>
    </dependency>

编码和解码

// string 编码为 utf-8
URLEncoder.encode("string","utf-8");
// string 解码为 utf-8
URLDecoder.decode("string","utf-8");

1. 基本概念

1.1 前言

web开发

静态web
- html，css
- 页面不会发生改变
动态web
- 技术栈：Servlet/jsp。。。
- 数据会始终发生改变，不同的时间，不同的地点页面都会不同

1.2 web应用程序

2. web服务器

3. Tomcat

3.1下载tomcat

打开tomcat官网：https://tomcat.apache.org/download-70.cgi
点击 Download
选择包
下载完成后解压，即可

3.2 启动tomcat

现在暂时通过bin目录下的 startup.bat 启动 tomcat
访问http://localhost:8080若出现如下图，则表示启动成功

3.3 tomcat配置

tomcat默认端口号：8080

    <Connector port="8080" protocol="HTTP/1.1"
               connectionTimeout="20000"
               redirectPort="8443" />

服务器默认名：localhost
默认网站应用存放的位置为：webapps

      <Host name="localhost"  appBase="webapps"
            unpackWARs="true" autoDeploy="true">

3.4 发布网站

如何访问：
- 将自己写的网站，放到服务器（ Tomcat中指定的web应用的文件夹（ webapps）下，就可以访问了
- http://localhost:8080/myWeb/

网站结构：

--webapps:Tomcat服务器的web目录
	-ROOT 
	-webName：网站的目录名
		-WEB-工NF
			-c1asses:java程序
			-lib:web应用所依赖的jar包
			-web.xml：网站配置文件
		-index.htm默认的首页

4. HTTP

5. Maven

5.1 需求：

1.在javaweb开发中，需要使用大量的jar包，我们手动去导入；
2.如何能够让一个东西自动帮我导入和配置这个ar包。
由此， Maven诞生了！

5.2 Maven项目架构管理工具

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

5.3 maven 下载安装

打开 maven官网
选择 Download
找到Files，下载 Binary 和 Source
解压第一个即可

5.4 maven 配置

打开环境变量
在系统变量中新建
- 变量名：MAVEN_HOME
- 变量值：maven的目录
在path中添加：%MAVEN_HOME%in
在cmd中输入 mvn -version，若弹出如图，则成功

5.5阿里云镜像

先打开 setting.xml

找到 mirrors 标签，配置

<id>nexus-aliyun</id>
<mirrorOf>central</mirrorOf>
<name>Nexus aliyun</name>
<url>
http://maven.aliyun.com/nexus/content/groups/public class="hljs-tag">
</url>

5.6 本地仓库

先新建一个文件夹做为本地仓库
再打开 setting.xml
找到 localRepository

 <localRepository>你的本地仓库路径</localRepository>

如图我的配置

5.7 在 IDEA 中使用maven模板配置 Maven

打开 IDE 新建项目
创建Maven项目

等待项目初始化完成
观察本地仓库
IDEA 的 Maven 配置注意

5.8 在 IDEA 中创建干净的Maven项目

新建项目
创建maven项目不用选，直接Next
输入项目名 ---》完成
如图，这是干净的maven项目

5.9 标记文件功能

方法一：

方法二：

先找到项目结构
1 --> 2--> 3--> 4

5.10 IDEA 配置 Tomcat

5.11 启动

点击启动
效果如图：

5.12 pom 文件

Maven 功能

pom.xml 是maven核心

 <?xml version="1.0" encoding="UTF-8"?>

<!--这里就是Maven版本和头文件-->
<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>

  <!--这里是项目 组id，名称 -->
  <groupId>org.example</groupId>
  <artifactId>javaweb-01-maven</artifactId>
  <version>1.0-SNAPSHOT</version>
<!--  packag：项目打包方式
  jar：java 应用
  war：javaWeb 应用
-->
  <packaging>war</packaging>

  <name>javaweb-01-maven Maven Webapp</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>

<!--  配置-->
  <properties>
<!--    默认编码格式-->
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<!--    编码版本-->
    <maven.compiler.source>1.7</maven.compiler.source>
    <maven.compiler.target>1.7</maven.compiler.target>
  </properties>

<!--  项目依赖-->
  <dependencies>
    <dependency>
<!--      具体依赖的 jar包 配置文件-->
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
  </dependencies>

<!--  项目构建的东西-->
  <build>
    <finalName>javaweb-01-maven</finalName>
    <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
      <plugins>
        <plugin>
          <artifactId>maven-clean-plugin</artifactId>
          <version>3.1.0</version>
        </plugin>
        <!-- see http://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_war_packaging -->
        <plugin>
          <artifactId>maven-resources-plugin</artifactId>
          <version>3.0.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-compiler-plugin</artifactId>
          <version>3.8.0</version>
        </plugin>
        <plugin>
          <artifactId>maven-surefire-plugin</artifactId>
          <version>2.22.1</version>
        </plugin>
        <plugin>
          <artifactId>maven-war-plugin</artifactId>
          <version>3.2.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-install-plugin</artifactId>
          <version>2.5.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-deploy-plugin</artifactId>
          <version>2.8.2</version>
        </plugin>
      </plugins>
    </pluginManagement>
  </build>
</project>

6. Servlet

6.1 Servlet简介

Sun在这些AP中提供一个接口叫做：Servlet，如果你想开发一个 Servlet程序，只需要完成两个小步骤：
- 编写一个类，实现 Servlet接口
- 把开发好的ava类部署到web服务器中。

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

6.2 HelloServlet

构建一个普通的 Maven项目，删掉里面的src目录，以后我们的学习就在这个项目里面建立 Moudle；这个空的工程就是 Maven主工程；
再创建一个模板maven，作为子工程

关于 Maven 父子工程的理解：

父项目中会有：

<modules>
<module>servlet_01</module>
</modules>

子项目中会有：

<parent>
<artifactId>javaWeb_study</artifactId>
<groupId>org.example</groupId>
<version>1.0-SNAPSHOT</version>
</parent>

父项目中的java，子项目可以直接使用

编写一个Java类，继承 HttpServlet （实现servlet接口）

public class HelloServlet extends HttpServlet {

    public HelloServlet() {
        super();
    }

//    由于get或都post只是请求实现的不同的方式，所以可以相互调用，业多逻都一样；
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//        ServletOutputStream outputStream = resp.getOutputStream();
        PrintWriter pw =    resp.getWriter();
        pw.println("hello servlet");
    }
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        super.doPost(req, resp);
    }
}

编写 servlet 映射

为什么需要映射：

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

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

配置Tomcat

5.1 先创建Facets

5.2 创建 Artifacts

5.3 添加Tomcat
启动测试

首页：

通过映射的：

6.3 Servlet原理

6.4 Mapping

一个 servlet 指定一个映射路径

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

一个 servlet 指定多个映射路径

<servlet-mapping>
    <servlet-name>hello</servlet-name>
    <url-pattern>/ppx</url-pattern>
    <url-pattern>/gkd</url-pattern>
    <url-pattern>/hello/*</url-pattern>
    <url-pattern>/ok</url-pattern>
</servlet-mapping>

<servlet-mapping>
    <servlet-name>hello</servlet-name>
    <url-pattern>/ppx</url-pattern>
</servlet-mapping>
<servlet-mapping>
    <servlet-name>hello</servlet-name>
	<url-pattern>/gkd</url-pattern>
</servlet-mapping>
<servlet-mapping>
    <servlet-name>hello</servlet-name>
    <url-pattern>/hello/*</url-pattern>
</servlet-mapping>
<servlet-mapping>
    <servlet-name>hello</servlet-name>
    <url-pattern>/ok</url-pattern>
</servlet-mapping>

一个 servlet 指定通用映射路径

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

一个 servlet 指定映射路径后缀

<!--  注意： * 前面不能加 / 和 映射路径
	例：<url-pattern>/whh/*.ppx</url-pattern>  tomcat会报错
-->
<servlet-mapping>
    <servlet-name>hello</servlet-name>
    <url-pattern>*.ppx</url-pattern>
</servlet-mapping>

优先级问题：

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

6.5 ServletContext

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

1、共享数据

//  HelloServlet 中
	@Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        super.doGet(req, resp);
//        this.getInitParameter();
//        this.getServletConfig();
//        this.getServletContext();
        ServletContext context = this.getServletContext();
        String uname = " ppx ";
        context.setAttribute("username",uname); //将一个数据保存在了 ServletContext中，名字为：username。值:uname
        System.out.println("come to HelloServlet");
    }

//	GetServlet 中
	@Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        ServletContext context = this.getServletContext();
        String username = (String) context.getAttribute("username");
        resp.setContentType("text/html;charset=utf-8");
        resp.getWriter().print("名字是：" + username);
        System.out.println("come to GetServlet，name --->"+username);
    }

<!--  HelloServlet-->
  <servlet>
    <servlet-name>hello</servlet-name>
    <servlet-class>com.study.servlet_03.HelloServlet_03</servlet-class>
  </servlet>
  <servlet-mapping>
    <servlet-name>hello</servlet-name>
    <url-pattern>/hello</url-pattern>
  </servlet-mapping>

  <!--  GetServlet-->
  <servlet>
    <servlet-name>getC</servlet-name>
    <servlet-class>com.study.servlet_03.GetServlet</servlet-class>
  </servlet>
  <servlet-mapping>
    <servlet-name>getC</servlet-name>
    <url-pattern>/getC</url-pattern>
  </servlet-mapping>

2、测试：

首先进入 GetServlet.java ，这时 ServletContext 的 username值为null

进入 HelloServlet ，将 username 的值 ppx 存入 ServletContext 中

再次进入 GetServlet.java ，这时 ServletContext 的 username值为 ppx

3、请求转发

public class ServletDome_02 extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.setContentType("text/html;charset=utf-8");
//        resp.getWriter().println("这里是ServletDome_02");

        ServletContext context = this.getServletContext();
//		请求转发
      context.getRequestDispatcher("/getC").forward(req,resp);
        System.out.println("come to ServletDome_02");
    }

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

4、读取资源文件

Properties

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

发现都被打包到了classes目录下，一般称这个路径为classpath

思路：同过文件流来读取

public class PropertiesServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.setContentType("text/html;charset=utf-8");
        System.out.println("come to PropertiesServlet ");
        InputStream is = this.getServletContext().getResourceAsStream("/WEB-INF/classes/db.properties");
        Properties prop = new Properties();
        prop.load(is); //本地路径
        String user = prop.getProperty("username");
        String pwd = prop.getProperty("password");
        resp.getWriter().print(user+"："+pwd);
    }
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        super.doPost(req, resp);
    }
}

  <!--  PropertiesServlet-->
  <servlet>
    <servlet-name>ps</servlet-name>
    <servlet-class>com.study.servlet_03.PropertiesServlet</servlet-class>
  </servlet>
  <servlet-mapping>
    <servlet-name>ps</servlet-name>
    <url-pattern>/ps</url-pattern>
  </servlet-mapping>

测试结果：

6.6 HttpServletResponse

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

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

1、文件下载

获取文件的下在路径
下载的文件名称
设置支持浏览器下载需要的东西
获取下载文件的输入流
创建缓冲区
获取OutputStream对象
将FileOutputStream流写入到buffer缓冲区

使用OutputStream将缓冲区中的数据输出到客户端

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//        1. 获取文件的下在路径
        String realPath = "E:\java  学习代码\IDEAJavaProject\javaWeb_study_01\response_01\target\classes\007.png";
                // this.getServletContext().getRealPath("src/main/resources/007.png");
        System.out.println("现在的文件下载路径为："+realPath);
//        2. 下载的文件名称
        String fileName = realPath.substring(realPath.lastIndexOf("\")+1);
//        3. 设置支持浏览器下载需要的东西
        resp.setHeader("Content-Disposition","attachment; filename"+ URLEncoder.encode(fileName,"utf-8"));
//        4. 获取下载文件的输入流
        FileInputStream in = new FileInputStream(realPath);
//        5. 创建缓冲区
        int len = 0;
        byte[] buffer = new byte[1024];
//        6. 获取OutputStream对象
        ServletOutputStream out = resp.getOutputStream();
//        7. 将FileOutputStream流写入到buffer缓冲区,使用OutputStream将缓冲区中的数据输出到客户端
        while((len = in.read(buffer)) != -1){
            out.write(buffer,0,len);
        }
//        8. 关闭流
        out.close();
        in.close();
    }

2、简单验证码

验证实现

前段实现

后端实现

@Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 如何让浏览器 3s 刷新一次
        resp.setHeader("refresh","3");

        // 在内存中创建一张图片
        BufferedImage image = new BufferedImage(80, 20, BufferedImage.TYPE_3BYTE_BGR);
        // 得到图片
            //得到笔
        Graphics2D g = (Graphics2D) image.getGraphics();
            //画出背景
        g.setColor(Color.WHITE);
        g.fillRect(20,20,80,20);
            // 画出随机数字
        g.setColor(Color.BLUE);
        g.setFont(new Font(null,Font.BOLD,20));
        g.drawString(makeNum(),0,20);

        // 告诉浏览器 用图片方式打开
        resp.setC ontentType("image/jpeg");
        // 网站存在缓存 ， 不让图片进行缓存
        resp.setDateHeader("expirse",-1);
        resp.setHeader("cache-control","no-cache");
        resp.setHeader("pragma","no-cache");
        // 把图片写给浏览器
        ImageIO.write(image,"jpg",resp.getOutputStream());
    }

    private String makeNum (){
        Random random = new Random();
        String num = random.nextInt(999999) + 100000 + "";
        return num;
    }

3. 重定向

一个web资源收到客户端请求后，他会通知客户端去访问另外一个web资源，这个过程叫重定向。一般是跳转页面。

测试：

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        /*
         resp.setHeader("Location","/r/img");
         resp.setStatus(HttpServletResponse.SC_MOVED_TEMPORARILY);
         */
        resp.sendRedirect("/r/img");    //重定向
    }

重定向和转发的区别：

相同点：
- 页面都会跳转
不同点
- 请求转发的时候，url 不会发生变化，编码307
- 重定向时，url 会发生改变，编码302

6.7 HttpServletRequest

HttpServletRequest代表客户端的所有请求

获取前端传递的参数，再转发

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.setCharacterEncoding("utf-8");
        req.setCharacterEncoding("utf-8");
        // 获取参数
        String name = req.getParameter("username");
        String pwd = req.getParameter("password");
        String[] hobbies = req.getParameterValues("hobbies");
        // 打印参数
        System.out.println("----------------------------");
        System.out.println(name);
        System.out.println(pwd);
        System.out.println(Arrays.toString(hobbies));
        System.out.println("----------------------------");
        // 通过请求转发
        req.getRequestDispatcher("/succse.jsp").forward(req,resp);
    }

7、Cookie、Session

7.1 会话

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

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

7.2 保存会话的两种技术

cookie

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

session

服务器技术、利用这个技术、可以保存用户的会话信息。我们把信息放在Session 中

常见应用：网站会

1、从请求得到 Cookie

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

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

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

删除cookie：

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

7.4 Session（重点）

什么是 Session ：

服务器会给每个浏览器创建一个 Session 对象；
一个Session 独占一个浏览器，只要浏览器没有关闭，这个Session 就会一直存在
用户登录后，整个网站都可以访问。保存用户信息

 @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 解决乱码问题
        req.setCharacterEncoding("utf-16");
        resp.setCharacterEncoding("utf-16");
        resp.setContentType("text/html;charset=utf-8");
        //得到Session
        HttpSession session = req.getSession();
        //给Session中存入信息
        session.setAttribute("name","皮皮虾");
        session.setAttribute("object",new preson("七仔",15));
        //获取Session 的 ID
        String id = session.getId();
        //判断Session 是不是新创建的
        if (session.isNew()){
             resp.getWriter().write("
Session 创建成功,ID为"+id);
        }else{
            resp.getWriter().write("
Session 已经存在,ID为"+id);
        }
    }

		//得到Session中的信息
        String name = (String) 		session.getAttribute("name");
        resp.getWriter().println("name--->"+name);
		// 移除 session 的值
        session.removeAttribute("name");
        //注销 Session
        session.invalidate();

自动失效：

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

8、 JSP

8.1 什么是 JSP

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

最大的特点：

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

8.2 JSP原理

思路：JSP是怎么执行的

将html内容变为Java语法执行
服务器内部工作

tomcat中有一个work目录

本机地址：C:UsersASUS.IntelliJIdea2019.3system omcatUnnamed_javaWeb_study_02workCatalinalocalhost qorgapachejsp

页面转变为了Java程序

JSP的本质是Servlet

//初始化
public void _jspInit() {
  }
//销毁
  public void _jspDestroy() {
  }
//JSPServer
  public void _jspService(HttpServletRequest request,HttpServletResponse response)

1、判断方法的代码

if ("OPTIONS".equals(_jspx_method)) {
        response.setHeader("Allow","GET, HEAD, POST, OPTIONS");
        return;
      }
      if (!"GET".equals(_jspx_method) && !"POST".equals(_jspx_method) && !"HEAD".equals(_jspx_method)) {
        response.setHeader("Allow","GET, HEAD, POST, OPTIONS");
        response.sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED, "JSP 只允许 GET、POST 或 HEAD。Jasper 还允许 OPTIONS");
        return;
      }

2、内置的对象：

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

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

response.setContentType("text/html;charset=UTF-8");
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;

4、内置的对象能在JSP中直接使用

访问JSP页面的流程：

在JSP页面中；
只要是JAVA代码就会原封不动的输出；
如果是HTML代码，就会被转换为：

out.write("<h1>登录</h1>
");

8.3 JSP基本语法

EL表达式：${ }

JSP表达式

  <% = new java.util.Date() %>

JSP脚本片段

<% for (int i = 0; i < 5; i++) { %>
<h2> Start ${i} </h2>
<% }%>

JSP声明

<%! static {
    System.out.println("这是 PIG");
}
    private  int  value = 20;
    public void domeFuncation(){
        System.out.println("PIG AGE IS"+value);
    }
%>

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

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

8.4 JSP 指令

1、定制错误页面

<%--JSP里：定制错误页面--%>
	<%--<%@ page errorPage="error/500.jsp"  %>--%>
<%--web.xml里：定制错误页面--%>
 <error-page>
        <error-code>404</error-code>
        <location>/error/404.jsp</location>
    </error-page>
    <error-page>
        <error-code>500</error-code>
        <location>/error/500.jsp</location>
</error-page>

2、404页面

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>404 ERROR</title>
</head>
<body>
    <h1>糟糕，访问丢失了...</h1>
    <img src="../images/404.jfif" title="访问丢失">
</body>
</html>

2、添加网页头和网页尾

<%--第一种：两个页面和当前页面 合在一起 --%>
    <%@ include file="/common/Header.jsp"%>
    <h2>Start</h2>
    <%@ include file="/common/footer.jsp"%>
<%--第二种：3个页面拼接在一起，本质还是3个--%>
	<jsp:include page="common/Header.jsp"/>
    <h2>Start</h2>
    <jsp:include page="common/footer.jsp"/>

8.5 9大内置对象

PageContext 存东西
Request 存东西
Response
Session 存东西
Application【ServletContext】存东西
config 【ServletConfig】
out
page
exception

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

 <!-- https://mvnrepository.com/artifact/javax.servlet.jsp.jstl/jstl-api -->
        <!-- JSTL表达式 依赖-->
        <dependency>
            <groupId>javax.servlet.jsp.jstl</groupId>
            <artifactId>jstl-api</artifactId>
            <version>1.2</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/taglibs/standard -->
        <!-- standard 标签库-->
        <dependency>
            <groupId>taglibs</groupId>
            <artifactId>standard</artifactId>
            <version>1.1.2</version>
        </dependency>

EL表达式：$ { }

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

JSTL标签

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

<jsp:forward page="dome03.jsp">
    <jsp:param name="name" value="ppx"/>
    <jsp:param name="age" value="18"/>
</jsp:forward>

格式化标签
SQL 标签
XML 标签
JSTL 函数

核心标签

JSTL标签库使用步骤：

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

JSTL：if测试

  <%@ page contentType="text/html;charset=UTF-8" language="java" %>
  
  <%--引入JSTL核心标签库，才能使用JSTL标签--%>
  <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
  <html>
  <head>
      <title>JSTL if测试</title>
  </head>
  <body>
      <h2>  测试 DOME </h2>
  <%--    <div>--%>
          <form action="jstlDome01.jsp" method="get">
              <input type="text" name="username" value="${param.username}" >
  
              <input type="submit" value="Login...">
          </form>
      <%--
      test：条件
      var：存储 变量名
      value：赋值
      --%>
      <hr/>
  <c:if test="${param.username == '123'}"  var="isAdmin" >
      <c:out value="jin ru le"></c:out>
  </c:if>
      <c:out value="${isAdmin}"></c:out>
  </body>
  </html>

JSTL：choose when 测试

<body>
    <h1>choose when 判断</h1>
    <hr/>
    <form action="jstlDome02.jsp" methon="get">
        <input type="number" name="score" />
        <input type="submit" value="start">
    </form>
    <hr/> 

<c:choose>
    <%-- param . name ：可以取得 name 的值  --%>
    <c:when test="${param.score >= 90}">优秀</c:when>
    <c:when test="${param.score >= 80}">良好</c:when>
    <c:when test="${param.score >= 60}">及格</c:when>
    <c:when test="${param.score <= 59}">失败</c:when>
</c:choose>
    <hr/>
</body>

9、JavaBean

IDEA连接MySQL出现错误，解决地址：连接地址

10、 MVC三层架构

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

10.1 以前的架构

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

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

十万签名内容......

相关阅读:
第十周进度条
 冲刺阶段第十天
 冲刺阶段第九天
 冲刺阶段第八天
 冲刺阶段第七天
 冲刺阶段第六天
 第一次冲刺阶段（十一）
第一次冲刺阶段（十）
第一次冲刺阶段（九）
第一次冲刺阶段（八）
原文地址：https://www.cnblogs.com/myswift/p/13406257.html