JavaWeb

最新推荐文章于 2022-10-28 22:13:55 发布
最新推荐文章于 2022-10-28 22:13:55 发布
阅读量508 收藏 3
点赞数
分类专栏： JavaWeb 文章标签： javaweb
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mtcya/article/details/119362488
版权

💻 JavaWeb:

1. 基本概念：

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应用由多个部分组成（静态web,动态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
<h1>
<%
   System.out.println("hello");
   %>
</h1>

PHP

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

JSP/Servlet:

B/S：浏览器和服务器

C/S：客户端和服务器

  • SUN公司主推的B/S架构
  • 基于java语言（所有的大公司，或者一些开源的组件，都是用java写的）
  • 可以承载三高问题带来的影响；
  • 语法像ASP，ASP—>JSP，加强市场的强度；

2.2、web服务器：

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

IIS

微软的：ASP… window中自带的

Tomcat

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

下载tomcat:

  1. 安装 or 解压
  2. 了解配置文件及目录结构
  3. 这个东西的作用

3. Tomcat:

3.1、安装Tomcat:

官网：https://tomcat.apache.org/在这里插入图片描述

在这里插入图片描述

3.2、Tomcat启动和配置：

在这里插入图片描述

Tomcat启动

bin文件夹中的 startup.bat

Tomcat关闭

bin文件夹中的 shutdown.bat

访问测试

http://localhost:8080/

肯能会遇到的问题：

  1. java环境变量没有配置：闪退
  2. 需要配置兼容性
  3. 乱码问题：配置文件中设置

服务器核心配置文件

在这里插入图片描述

可以配置启动的端口号 port：

  • tomcat的默认端口号：8080
  • mysql：3306
  • http：80
  • https：443
<Connector port="8080" protocol="HTTP/1.1"
               connectionTimeout="20000"
               redirectPort="8443" />

可以配置主机的名称 localhost：

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

主机名称配置完后，需要到：C:\Windows\System32\drivers\etc\hosts 文件中设置映射关系

127.0.0.1 mtc.com

Tomcat在IDEA中乱码问题：

修改logging.properties文件

在这里插入图片描述

3.3、面试题：

请你谈谈网站是如何进行访问的：

  1. 输入一个域名：回车

  2. 检查本机的 C:\Windows\System32\drivers\etc\hosts 配置文件下有没有这个域名的映射

    • 有：直接返回对应的ip地址，这个地址中，有我们需要访问的web程序，可以直接访问
    127.0.0.1  mtc.com
    • 没有：去DNS服务器上找，找到就返回，找不到就返回找不到；

在这里插入图片描述

3.4、发布一个web网站：

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

网站应该有的结构：

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

4. Http:

4.1、什么是Http

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

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

https：安全的

  • 443

4.2、两个时代：

  • http 1.0
    • HTTP/1.0：客户端与web服务器连接后，只能获取一个web资源，断开连接
  • http 2.0
    • HTTP/1.1：客户端与web服务器连接后，可以获取多个web资源。

4.3、Http请求：

  • 客户端—>发请求—>服务器

百度：

Request URL: https://www.baidu.com/    请求地址
Request Method: GET                    get方法/post 方法
Status Code: 200 OK                    状态码
Referrer Policy: no-referrer-when-downgrade

Accept:text/html
Accept-Encoding: gzip, deflate, br
Accept-Language: zh-CN,zh;q=0.9
Connection: keep-alive
1. 请求行
  • 请求行中的请求方式：GET
  • 请求方式：GET/POST
    • GET：请求能够携带的参数比较少，大小有限制，会在浏览器的URL地址栏显示数据内容，不安全，但高效。
    • POST: 请求能够携带的参数没有限制，大小没有限制，不会在浏览器的URL地址栏显示数据内容，安全，但不高效。
2. 请求头
Accept:告诉浏览器，他所支持的数据类型
Accept-Encoding: 支持哪种编码格式  GBK UTF-8 GB2312
Accept-Language: 告诉浏览器，他的语言环境
Cache-Control: 缓存控制    
Connection: 告诉浏览器，请求完成是断开，还是保持连接
HOST: 主机

4.4、Http响应：

  • 服务器—>响应—>客户端

百度：

Cache-Control: private    // 缓存控制
Connection: keep-alive    // 连接
Content-Encoding: gzip    // 编码
Content-Type: text/html;charset=utf-8  // 类型
1.响应体：
Accept:告诉浏览器，他所支持的数据类型
Accept-Encoding: 支持哪种编码格式  GBK UTF-8 GB2312
Accept-Language: 告诉浏览器，他的语言环境
Cache-Control: 缓存控制    
Connection: 告诉浏览器，请求完成是断开，还是保持连接
HOST: 主机 
Refresh:  告诉客户端，多久刷新一次
Location: 让网页重新定位
2. 响应状态码:

200：请求响应成功

3xx：请求重定向

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

4xx：找不到资源 404

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

4.5、常见面试题

当你的浏览器中地址栏输入地址，并回车的一瞬间到页面能够展示回来，经历了什么？

5. Maven:

我为什么要学习这个技术？

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

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

    由此，Maven诞生了！

5.1、Maven项目架构管理工具：

我们目前用它就是方便导入jar包的。

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

  • 有约束，不要违反

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

5.2、下载安装Maven:

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

在这里插入图片描述

下载完成后，解压即可；

5.3、配置环境变量：

在我们的系统环境变量中：

配置如下：

  • MAVEN_HOME maven的目录
  • 在系统的path中配置 %MAVEN_HOME%\bin

在这里插入图片描述

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

5.4、修改一下配置文件：

阿里云镜像：mirrors

  • 作用：加速我们的下载
  • 国内建议使用阿里云的镜像
  • 在maven配置文件settings.xml文件中 标签内加上：
   <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>

5.5、本地仓库：

在本地的仓库，远程仓库；

建立一个本地仓库 localRepository

  • 新建一个maven-repo文件夹
  • 在settings.xml文件中加上
<localRepository>D:\java后端\javaweb\apache-maven-3.6.3\maven-repo</localRepository>

5.6、在IDEA中使用Maven:

  1. 启动IDEA
  2. 创建一个MavenWeb项目

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

这个目录只有在web应用下才有

到这边maven项目就创建完成了。

5.7、创建一个普通的Maven项目：

选择Maven ,直接点下一步
在这里插入图片描述

在这里插入图片描述

5.8、在IDEA中标记文件夹功能：

在这里插入图片描述

5.9、在IDEA中配置Tomcat:

在这里插入图片描述

在这里插入图片描述

解决警告问题：

为什么会有这个问题，我们访问一个网站，需要指定一个文件夹的名字；

在这里插入图片描述

在这里插入图片描述

启动Tomcat

在这里插入图片描述

在这里插入图片描述

5.10、pom文件：

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

在这里插入图片描述

maven由于约定大于配置，我们之后可能会遇到我们写的配置文件，无法被导出或者生效的问题

解决方案

<!--在build中配置resource，来防止我们资源导出失败问题-->

<build>
<resources>
    <resource>
        <directory>src/main/java</directory>
        <includes>
            <include>**/*.properties</include>
            <include>**/*.xml</include>
        </includes>
        <filtering>false</filtering>
    </resource>
    <resource>
        <directory>src/main/resources</directory>
        <includes>
            <include>**/*.properties</include>
            <include>**/*.xml</include>
        </includes>
        <filtering>false</filtering>
    </resource>
</resources>
</build>

5.11、IDEA操作：

在这里插入图片描述

5.12、解决遇到的问题：

  1. Maven 3.6.2报错Unable to import maven project See for details

    解决方法：降级为3.6.1

  2. Tomcat闪退：

  3. IDEA中每次都要重复配置Maven

    在IDEA中的全局默认配置中去配置

在这里插入图片描述

在这里插入图片描述

  1. IDEA中maven默认web项目中的web.xml版本问题：

在这里插入图片描述

解决：替换为webapp4.0版本和tomcat一致：

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

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. 导入servlet和jsp的jar包
  3. 在项目中新建一个maven-webapp的Moudel
  4. 关于Maven父子工程的理解：
    父项目中会有：
  <modules>
        <module>servlet-01</module>
    </modules>

  1. Maven环境优化：

    • 修改web.xml为最新的

    • 将Maven的结构搭建完整

  2. 编写一个Servlet程序:

    • 创建一个jave普通类
    • 实现Servlet接口，这里我们直接继承HttpServlet。
public class HelloServlet extends HttpServlet {
    
    // 由于get或者post只是请求实现的不同的方式，可以相互调用
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
       resp.setContentType("text/html");
       resp.setCharacterEncoding("utf8");
       
       //响应流
        PrintWriter writer = resp.getWriter();
        writer.print("hello Servlet");
    }

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

  1. 在web.xml中，编写Servlet的映射：

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

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

  1. 配置Tomcat：

    注意：配置项目发布的路径。

  2. 启动测试：成功！

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>
  1. 一个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>
  1. 一个Servlet可以指定通用映射路径
    <servlet-mapping>
        <servlet-name>hello</servlet-name>
        <url-pattern>/hello/*</url-pattern>
    </servlet-mapping>
  1. 默认请求路径：
    <servlet-mapping>
        <servlet-name>hello</servlet-name>
        <url-pattern>/*</url-pattern>
    </servlet-mapping>
  1. 指定一些后缀或前缀：
<!--
可以自定义后缀实现请求映射
注意点：*前面不能加映射的路径
-->   
<servlet-mapping>
        <servlet-name>hello</servlet-name>
        <url-pattern>*.ma</url-pattern>
    </servlet-mapping>

  1. 优先级问题：

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

6.5、ServletContext：

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

1. 共享数据

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

this.getServletContext().setAttribute(key,value);   // 设置属性

this.getServletContext().getAttribute(key);   // 获取属性

在这里插入图片描述

public class HelloServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //this.getInitParameter();    初始化参数
        //this.getServletConfig();     Servlet配置
        //this.getServletContext();    Servlet上下文
        resp.setContentType("text/html");
        resp.setCharacterEncoding("utf-8");

        ServletContext servletContext = this.getServletContext();
        String username="小马";  //数据
        // 将一个数据保存到ServletContext中  名字为：username，值：username
        servletContext.setAttribute("username",username);

        System.out.println("hello ma");
    }
}

public class GetServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.setContentType("text/html");
        resp.setCharacterEncoding("utf-8");
        ServletContext servletContext = this.getServletContext();
        String  username = (String) servletContext.getAttribute("username");
        resp.getWriter().print("名字："+username);
    }

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


<?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">
    <servlet>
        <servlet-name>hello</servlet-name>
        <servlet-class>com.ma.servlet.HelloServlet</servlet-class>
    </servlet>

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

    <servlet>
        <servlet-name>getc</servlet-name>
        <servlet-class>com.ma.servlet.GetServlet</servlet-class>
    </servlet>

    <servlet-mapping>
        <servlet-name>getc</servlet-name>
        <url-pattern>/getc</url-pattern>
    </servlet-mapping>
</web-app>
2. 获取初始化参数：

this.getServletContext().getInitParameter(str);

    <!--配置一些web应用初始化参数-->
    <context-param>
        <param-name>url</param-name>
        <param-value>jdbc:mysql://localhost:3306/mybatis</param-value>
    </context-param>

public class ServletDemo03 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        ServletContext servletContext = this.getServletContext();
        String url = servletContext.getInitParameter("url");
        resp.getWriter().print(url);
    }

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


  <servlet>
        <servlet-name>getc</servlet-name>
        <servlet-class>com.ma.servlet.GetServlet</servlet-class>
    </servlet>

    <servlet-mapping>
        <servlet-name>getc</servlet-name>
        <url-pattern>/getc</url-pattern>
    </servlet-mapping>
3. 请求转发（307）：

访问http://localhost:8080/s2/sd4，获得http://localhost:8080/s2/getc中信息

注意：/代表当前的web应用

在这里插入图片描述

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

        System.out.println("进入servletdemo04");

       // RequestDispatcher requestDispatcher = servletContext.getRequestDispatcher("/getc"); //转发的请求路径
        //requestDispatcher.forward(req,resp);  // 调用forword实现请求转发

        servletContext.getRequestDispatcher("/getc").forward(req,resp);
    }

 <servlet>
        <servlet-name>sd4</servlet-name>
        <servlet-class>com.ma.servlet.ServletDemo04</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>sd4</servlet-name>
        <url-pattern>/sd4</url-pattern>
    </servlet-mapping>
4. 读取资源文件：

Properties类

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

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

思路：需要一个文件流：

public class ServletDemo05 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.setContentType("text/html");
        resp.setCharacterEncoding("utf-8");
        InputStream resourceAsStream = this.getServletContext().getResourceAsStream("/WEB-INF/classes/db.properties");
        Properties properties = new Properties();
        properties.load(resourceAsStream);
        String user=properties.getProperty("username");
        String pwd= properties.getProperty("password");

        resp.getWriter().print(user+":"+pwd);

        if(resourceAsStream!=null){
            resourceAsStream.close();
        }
    }

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


    <servlet>
        <servlet-name>sd5</servlet-name>
        <servlet-class>com.ma.servlet.ServletDemo05</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>sd5</servlet-name>
        <url-pattern>/sd5</url-pattern>
    </servlet-mapping>

访问测试ok

6.6. HttpServletRespone:

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

  • 如果要获取客户端请求过来的参数：找HttpServletRequest
  • 如果要给客户端响应一些信息，找HttpServletRespone
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 setBufferSize(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);
2. 下载文件：
  • 向浏览器输出消息
  • 下载文件
    • 要获取下载文件的路径
    • 下载的文件是什么
    • 设置想办法让浏览器能够支持下载我们需要的东西
    • 获取下载文件的输入流
    • 创建缓冲区
    • 获取OutputStream对象
    • 将FileOutputStream流写入到buffer缓冲区
    • 使用OutputStream将缓冲区中的数据输出到客户端
public class FileServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//                1 要获取下载文件的路径
        String realPath ="D:\\IDEA项目\\javaweb--02-servlet\\response\\src\\main\\resources\\小汐.jpg";
        System.out.println("下载文件的路径："+realPath);
//                2 下载的文件是什么（文件名）
        String fileName=realPath.substring(realPath.lastIndexOf("\\")+1);
//                3 设置想办法让浏览器能够支持下载我们需要的东西  中文文件名URLEncoder.encode(fileName,"UTF-8")编码，否则有可能乱码
        resp.setHeader("Content-disposition","attachment;filename="+ URLEncoder.encode(fileName,"UTF-8"));
//                4 获取下载文件的输入流
        FileInputStream fileInputStream = new FileInputStream(realPath);
//                5 创建缓冲区
        int i=0;
        byte[]buffer=new byte[1024];
//                6 获取OutputStream对象
        ServletOutputStream outputStream = resp.getOutputStream();
//                7 将FileOutputStream流写入到buffer缓冲区
        while ((i=fileInputStream.read(buffer))!=-1){
            outputStream.write(buffer,0,i);
        }
        outputStream.flush();
        outputStream.close();
        fileInputStream.close();
//                8 使用OutputStream将缓冲区中的数据输出到客户端



    }

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

    <servlet>
        <servlet-name>filedown</servlet-name>
        <servlet-class>com.ma.servlet.FileServlet</servlet-class>
    </servlet>

    <servlet-mapping>
        <servlet-name>filedown</servlet-name>
        <url-pattern>/filedown</url-pattern>
    </servlet-mapping>
3. 验证码实现：

验证码怎么来的：

  • 前端实现：
  • 后端实现，需要用到java的图片类，生成一个图片
ublic class imageServlet extends HttpServlet {

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

        // 在内存中创建一个图片
        BufferedImage bufferedImage = new BufferedImage(80,20,BufferedImage.TYPE_INT_RGB);

        // 得到图片
        Graphics2D graphics = (Graphics2D) bufferedImage.getGraphics(); //笔

        //设置图片的背景颜色
        graphics.setColor(Color.white);
        graphics.fillRect(0,0,80,20);

        //给图片写数据
        graphics.setColor(Color.BLUE);
        graphics.setFont(new Font(null,Font.BOLD,20));
        graphics.drawString(makeNum(),0,20);


        // 告诉浏览器，这个请求用图片的方式打开
        resp.setContentType("image/jpg");

        // 网站存在缓存，不让浏览器缓存
        resp.setDateHeader("expires",-1);
        resp.setHeader("Cache-Control","no-cache");
        resp.setHeader("Pragma","no-cache");

        // 把图片写给浏览器
        ImageIO.write(bufferedImage, "jpg",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");
        }
        // 若不是7位 ，用0 填充
         num=sb.toString()+num;
        return num;
    }
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req, resp);
    }
}


    <servlet>
        <servlet-name>imageServlet</servlet-name>
        <servlet-class>com.ma.servlet.imageServlet</servlet-class>
    </servlet>

    <servlet-mapping>
        <servlet-name>imageServlet</servlet-name>
        <url-pattern>/image</url-pattern>
    </servlet-mapping>
4. Response重定向 (302)：

在这里插入图片描述

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

常见场景：

  • 用户登录
void sendRedirect(String varl) throws IOException

测试：

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

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

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

相同点：

  • 页面都会实现跳转

不同点：

  • 请求转发的时候，url不会发生变化 307
  • 重定向时候，url地址栏会发生变化 302
5. jsp和servlet使用:
  1. index页面：
<%@page language="java" contentType="text/html;charset=UTF-8" pageEncoding="UTF-8"  %>
<html>
<body>
<h2>Hello World!</h2>

<%--这里提交的路径，需要寻找到项目的类路径--%>
<%--${pageContext.request.contextPath} 代表当前的项目--%>
<form action="${pageContext.request.contextPath}/login" method="get">
    用户名：<input type="text" name="username"><br>
    密码： <input type="password" name="password"> <br>
    <input type="submit">
</form>
</body>
</html>
  1. 登录后，重定向的页面：
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<h1>success</h1>
</body>
</html>
  1. java代码：
public class RequestTest extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 处理请求
        String username=req.getParameter("username");
        String password=req.getParameter("password");
        System.out.println(username+":"+password);

        // 重定向一定要注意路径问题，不然就会404
        resp.sendRedirect("/response_war/success.jsp");
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    doGet(req, resp);
    }
}
  1. 映射：
    <servlet>
        <servlet-name>request</servlet-name>
        <servlet-class>com.ma.servlet.RequestTest</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>request</servlet-name>
        <url-pattern>/login</url-pattern>
    </servlet-mapping>

6.7. HttpServletRequest:

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

1. 获取前端传递的参数，请求转发：

重点方法：

     req.getParameter(String s);
     req.getParameterValues(String s);

演示：

  1. index.jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>登录</title>
</head>
<body>
<h1>登录</h1>
<div style="text-align: center">
    <%--这里表单表示的信息: 以post方式提交表单，提交到我们的login请求--%>
    <form action="${pageContext.request.contextPath}/login" method="get">
        用户名：<input type="text" name="username"> <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">
    </form>
</div>
</body>
</html>
  1. success.jsp:
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>登录成功</title>
</head>
<body>
<h1>登录成功</h1>
</body>
</html>
  1. LoginServlet.java:
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[] hobbies = req.getParameterValues("hobbies");
        System.out.println("=========");
        System.out.println(username+":"+password);
        System.out.println(Arrays.toString(hobbies));
        System.out.println("==========");
        // 通过请求转发
        // 这里的 / 代表当前的web应用。
        req.getRequestDispatcher("/success.jsp").forward(req,resp);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
       doGet(req, resp);
    }
}
  1. web.xml：

    <servlet>
        <servlet-name>LoginServlet</servlet-name>
        <servlet-class>com.ma.servlet.LoginServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>LoginServlet</servlet-name>
        <url-pattern>/login</url-pattern>
    </servlet-mapping>

7. Cookie和Seeion：

7.1、会话：

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

有状态会话：如：一个人来过南京，下次再来，我知道他曾经来过，称之为有状态的会话；

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

客户端 ，服务端

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

7.2、保存会话的两种技术：

cookie

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

session

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

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

7.3、Cookie:

在这里插入图片描述

  1. 从请求中拿到cookie信息
  2. 服务器响应给客户端cookie
 Cookie[] cookies = req.getCookies();   //获得Cookie
 cookie.getName();  // 获得cookie中的key
 cookie.getValue();  // 获取cookie中的值
 new Cookie(key,value); // 新建一个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，如：
 protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 创建一个cookie  名字必须要和要删除的名字一致
        Cookie cookie = new Cookie("lastLoginTime",System.currentTimeMillis()+"");
        // 将cookie 有效期设置为0   立马过期
        cookie.setMaxAge(0);
        resp.addCookie(cookie);
    }

具体代码实现：

// 保存用户上一次访问的时间
public class CookieDemo01 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
       // 服务器告诉你来的时间，把这个时间封装成一个信件，你下次再来我就知道你来了

        // 解决中文乱码

        req.setCharacterEncoding("UTF-16");
        resp.setCharacterEncoding("UTF-16");

        PrintWriter out = resp.getWriter();

        //Cookie ,服务器端从客户端获取
        Cookie[] cookies = req.getCookies(); // 这里返回数组，说明Cookie可能存在多个

        // 判断Cookie是否存在
        if(cookies!=null){
            //  如果存在，取出数据
            out.write("你上一次访问的时间是：");
            for (int i = 0; i < cookies.length; i++) {
                Cookie cookie=cookies[i];
                // 获取cookie的名字
                if(cookie.getName().equals("lastLoginTime")){
                    // 获取Cookie中的值
                    long lastLoginTime=Long.parseLong(cookie.getValue());
                    Date date = new Date(lastLoginTime);
                    out.write(date.toLocaleString());
                }
            }
        }else{
            out.write("这是你第一次访问");
        }

        // 服务器给客户端响应一个cookie

        Cookie cookie = new Cookie("lastLoginTime",System.currentTimeMillis()+"");
        //cookie 有效期为一天
        cookie.setMaxAge(24*60*60);
        resp.addCookie(cookie);


    }

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


   <servlet>
        <servlet-name>CookieDemo01</servlet-name>
        <servlet-class>com.ma.servlet.CookieDemo01</servlet-class>
    </servlet>
    
    <servlet-mapping>
        <servlet-name>CookieDemo01</servlet-name>
        <url-pattern>/login</url-pattern>
    </servlet-mapping>
1. 关于Cookie中的中文乱码问题：
// 编码
Cookie cookie = new Cookie("name", URLEncoder.encode("小马同学","utf-8"));


// 解码
out.write( URLDecoder.decode(cookie.getValue(),"utf-8"));

7.4、Session（重点）:

在这里插入图片描述

在这里插入图片描述

1. 什么是Session：
  • 服务器会给每一个用户（浏览器）创建一个Session对象
  • 一个Session独占一个浏览器，只要浏览器没有关闭，这个Session就存在；
  • 用户登录之后，整个网站他都可以访问！—>保存用户的信息，保存购物车的信息
2. Session和Cookie的区别：
  • Cookie是把用户的数据写给用户的浏览器，浏览器保存 （可以保存多个）。
  • Session把用户的数据写到用户独占的Session中，服务器端保存（保存重要的信息，减少服务器资源的浪费）
  • Session 对象由服务器创建
3. 使用场景：
  • 保存一个登陆用户的信息
  • 购物车信息
  • 在整个网站中，经常会使用的数据，我们将他保存在Session中
4. 使用Session:
  1. 设置Session:
public class SessionDemo01 extends HttpServlet {
    @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",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);


    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
       doGet(req, resp);
    }
}
  1. 获取Session：
public class SessionDemo02 extends HttpServlet {
    @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();

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


    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req, resp);
    }
}
  1. 删除Session:
    • 方法一：手动注销，主要使用在用户的注销功能：
public class SessionDemo03 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        HttpSession session = req.getSession();

        // 删除Session
        session.removeAttribute("name");

        // 手动注销Session
        session.invalidate();


    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req, resp);
    }
}
  • 方法二：会话自动过期，在web.xml中设置一个注销时间，当用户这段时间没来访问，就会删除：

    <!--设置Session默认的失效时间-->
    <session-config>
        <!--15 分钟后，Session自动失效，以分钟为单位-->
        <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怎么执行的：

  • 代码层面没有任何问题

  • 服务器内部工作

    tomcat中有一个work目录

    IDEA中使用Tomcat的话，会在IDEA的Tomcat中生成一个work目录

在这里插入图片描述

电脑地址：

C:\Users\user\.IntelliJIdea2019.2\system\tomcat\Unnamed_javaweb-session-cookie\work\Catalina\localhost\ROOT\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)
      throws java.io.IOException, javax.servlet.ServletException{}
  1. 判断请求
  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;                       // 响应
  1. 输出页面前增加的代码：
      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;
  1. 以上的这些对象我们可以在JSP页面中直接使用！

在这里插入图片描述

在JSP页面中：

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

如果是HTML代码，就会被转化为：

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

这样的格式输出到前端

8.3、JSP的基础语法：

需要的依赖：

  <!--Servlet依赖-->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>servlet-api</artifactId>
            <version>2.5</version>
        </dependency>

        <!--JSP依赖-->
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>javax.servlet.jsp-api</artifactId>
            <version>2.3.3</version>
        </dependency>

        <!--JSTL依赖-->
        <dependency>
            <groupId>javax.servlet.jsp.jstl</groupId>
            <artifactId>jstl-api</artifactId>
            <version>1.2</version>
        </dependency>

        <!--standard标签库-->
        <dependency>
            <groupId>taglibs</groupId>
            <artifactId>standard</artifactId>
            <version>1.1.2</version>
        </dependency>

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

1. JSP表达式：
  <%--JSP表达式
  作用：用来将程序输出到客户端
  <%= 变量或表达式%>
  --%>
  <%= new java.util.Date()%>
2. JSP脚本片段：
  <%--jsp 脚本片段--%>
  <%
  int sum=0;
    for (int i = 0; i <=100 ; i++) {
      sum+=i;
    }
    out.println("<h1>Sum="+sum+"</h1>");
  %>
3. 脚本片段的再实现：
 <%
  int x=0;
  out.println(x);
  %>

  <p>这是一个jsp文档</p>


  <%
  int y=20;
  out.println(y);
  %>

  <%--在代码嵌入HTML元素--%>

  <%
    for (int i = 0; i <5 ; i++) {


  %>
  <h1>hello 小马 <%=i%></h1>
  <%
    }
  %>
4. JSP声明：
<%!
  static {
    System.out.println("Loading Servlet");
  }
  private int  globalVar=0;
  public void ma(){
    System.out.println("进入了方法ma");
  }
  %>

区别：

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

在JSP中，嵌入代码。

<%%>   <%--片段--%>
<%=%>  <%--表达式输出值--%>
<%!%>  <%--全局--%>

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

8.4、 JSP指令：

  1. 500错误页面显示：
    • 方法一：
    • 编写一个500错误页面显示的内容：500.jsp。
    • 再向需要访问的页面，申明发送500错误时转到的页面
<%--500错误页面--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<img src="../img/500.png" alt="">
</body>
</html>


<%--导入错误页面--%>
<%--<%@page errorPage="error/500.jsp" %>--%>

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<%
int x=1/0;
%>
</body>
</html>
  • 方法二，在web.xml里申明：
<error-page>
        <error-code>500</error-code>
        <location>/error/500.jsp</location>
    </error-page>
  1. 提取公共页面：
    • 新建一个公共的头部 header.jsp
    • 在页面中导入公共的header.jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<h1>我是header</h1>
</body>
</html>

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<%--@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"/>
</body>
</html>

8.5、9大内置对象：

  • PageContext 存东西
  • Request 存东西
  • Response
  • Session 存东西
  • Application 【ServletContext】存东西
  • config 【ServletConfig】
  • out
  • page 不用了解
  • exception
1. 作用域范围：

在这里插入图片描述

从底层到高层（作用域） page–>request–>session–>application

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<%--内置对象--%>
<%
pageContext.setAttribute("name1","小马1号"); // 保存的数据只在一个页面中有效
request.setAttribute("name2","小马2号"); // 保存的数据在一次请求中有效，请求转发会携带这个参数
session.setAttribute("name3","小马3号");// 保存的数据在一次会话中有效，从打开浏览器到关闭浏览器
application.setAttribute("name4","小马4号");// 保存的数据在服务器中有效，从打开服务器到关闭服务器
%>

<%--通过pageContext取出我们保存的值--%>
<%
    // 从pageContext取出，我们通过寻找的方式来
    // 从底层到高层（作用域） page-->request-->session-->application
    String name1 = (String)pageContext.findAttribute("name1");
    String name2= (String) pageContext.findAttribute("name2");
    String name3= (String) pageContext.findAttribute("name3");
    String name4= (String) pageContext.findAttribute("name4");
    String name5= (String) pageContext.findAttribute("name5");  // 不存在
%>

<%--使用EL表达式输出--%>
<h1>取出的值为：</h1>
<h3>${name1}</h3>
<h3>${name2}</h3>
<h3>${name3}</h3>
<h3>${name4}</h3>
<h3>${name5}</h3>   <%--不显示--%>

<h3><%=name5%></h3>  <%--null--%>
</body>
</html>

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

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

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

2. 两种请求转发方式：
<%
    // 两种转发方式
    pageContext.forward("/index.jsp");
    request.getRequestDispatcher("/index.jsp").forward(request,response);
%>

8.6、JSP标签、JSTL标签、EL标签：

EL表达式：${}

需要的jar包：

 <!--JSTL依赖-->
        <dependency>
            <groupId>javax.servlet.jsp.jstl</groupId>
            <artifactId>jstl-api</artifactId>
            <version>1.2</version>
        </dependency>

        <!--standard标签库-->
        <dependency>
            <groupId>taglibs</groupId>
            <artifactId>standard</artifactId>
            <version>1.1.2</version>
        </dependency>
  • 获取数据
  • 执行运算
  • 获取web开发的常用对象
  • 调用java方法
  1. JSP标签：
<%--<jsp:include page=""/>--%>

<%--
http://localhost:8080/jsptag.jsp?name=xiaoma&age=23
--%>
<jsp:forward page="/jsptag2.jsp">
    <jsp:param name="name" value="xiaoma"/>
    <jsp:param name="age" value="23"/>
</jsp:forward>

  1. JSTL表达式：

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

    • 核心标签（掌握部分）
      • 引入核心标签库：
    <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>

在这里插入图片描述

主要在Tomcat也需要引入jstl的包（jstl，standard），否则会报：JSTL解析错误

  1. c:if标签：
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%--引入JSTL核心标签库，我们才能使用JSTL标签 core--%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<h1>if测试</h1>
<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}"></c:out>
</body>
</html>
  1. c:choose标签
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%--引入JSTL核心标签库，我们才能使用JSTL标签 core--%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<html>
<head>
    <title>Title</title>
</head>
<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:choose>
</body>
</html>
  1. c:foreach标签：
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ page import="java.util.ArrayList" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%--引入JSTL核心标签库，我们才能使用JSTL标签 core--%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<html>
<head>
    <title>Title</title>
</head>
<body>

<%
ArrayList<String> people=new ArrayList<String>();
people.add(0,"张三");
people.add(1,"李四");
people.add(2,"王五");
people.add(3,"赵六");
people.add(4,"田七");
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 begin="1" end="3" step="2" var="people" items="${list}">
    <c:out value="${people}"/> <br>
</c:forEach>
</body>
</html>
  • 格式化标签
  • SQL标签
  • XML标签

9. JavaBean:

实体类

JavaBean有特殊的写法：

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

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

ORM：对象关系映射

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

如：people表

idnameageaddress
1小马1号3江苏
2小马2号18南京
3小马3号100浦口
class People{
  private int id;
  private String name;
  private int age;
  private String address;  
}


class A{
    new People(1,"小马1号",3,"江苏");
    new People(2,"小马2号",18,"南京");
    new People(3,"小马3号",100,"浦口");
}

jsp设置获取信息：

jsp:useBean id="people" class="com.ma.pojo.People" scope="page"/>
<jsp:setProperty name="people" property="id" value="1"/>
<jsp:setProperty name="people" property="name" value="小马1号"/>
<jsp:setProperty name="people" property="age" value="1"/>
<jsp:setProperty name="people" property="address" value="江苏"/>

id：<jsp:getProperty name="people" property="id"/>
姓名：<jsp:getProperty name="people" property="name"/>
年龄：<jsp:getProperty name="people" property="age"/>
地址：<jsp:getProperty name="people" property="address"/>

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:

  • 接收用户请求：（req：请求参数，Session信息…）
  • 交给业务层处理对应的代码
  • 控制视图的跳转
登录--->接收用户的请求--->处理用户的请求(获取用户登录的参数，username,password)--->交给业务层处理登录业务（判断用户名密码是否正确：事务）--->Dao层查询用户名和密码是否正确--->数据库

11、Filter（重点）:

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

  • 处理中文乱码
  • 登录验证

在这里插入图片描述

Filter开发步骤：

  1. 导包

  2. 编写过滤器:

    • 导包不要错：

在这里插入图片描述

  • 编写java代码：实现Filter接口，重写对应的方法
public class CharacterEncodingFilter implements Filter {

    // 初始化
    public void init(FilterConfig filterConfig) throws ServletException {
       // 初始化:web服务器启动，就已经初始化了，随时等待过滤对象出现
        System.out.println("CharacterEncodingFilter 初始化");
    }


    // chain :链
    /*
    1. 过滤中的所有代码，在过滤特定请求的时候都会执行
    2. 必须要让过滤器继续同行
    * */
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
          request.setCharacterEncoding("utf-16");
          response.setCharacterEncoding("utf-16");
          response.setContentType("text/html;charset=UTF-16");
        System.out.println("CharacterEncodingFilter执行前");
        chain.doFilter(request,response); // 让我们的请求继续走，如果不写，程序到这里就被拦截停止了
        System.out.println("CharacterEncodingFilter执行后");
    }

     // 销毁
    public void destroy() {
        // 销毁：web服务器关闭的时候，过滤器会销毁
        System.out.println("CharacterEncodingFilter 销毁");
        
    }
}
  • 设置web.xml:
 <filter>
        <filter-name>CharacterEncodingFilter</filter-name>
        <filter-class>com.ma.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就会触发一次这个时间
    public void sessionCreated(HttpSessionEvent se) {
        ServletContext servletContext = se.getSession().getServletContext();
        System.out.println(se.getSession().getId());
        Integer onlineCount = (Integer) servletContext.getAttribute("onlineCount");
        if(onlineCount==null){
            onlineCount=new Integer(1);
        }else {
            int count=onlineCount.intValue();
            onlineCount=new Integer(count+1);
        }

        servletContext.setAttribute("onlineCount",onlineCount);
    }
    // 销毁session监听
    public void sessionDestroyed(HttpSessionEvent se) {
        ServletContext servletContext = se.getSession().getServletContext();
        Integer onlineCount = (Integer) servletContext.getAttribute("onlineCount");
        if(onlineCount==null){
            onlineCount=new Integer(0);
        }else {
            int count=onlineCount.intValue();
            onlineCount=new Integer(count-1);
        }

        servletContext.setAttribute("onlineCount",onlineCount);
    }

    /*
    Session 销毁：
    1. 手动销毁：    se.getSession().invalidate();
    2. 自动销毁，在web.xml中配置过期时间
    * */
}
  1. web.xml中注册监听器：
<!--注册监听器-->
    <listener>
        <listener-class>com.ma.listener.OnlineCountListener</listener-class>
    </listener>


    <!--销毁Session-->
    <session-config>
        <session-timeout>1</session-timeout>
    </session-config>
  1. 页面展示：index.jsp:
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
  <head>
    <title>$Title$</title>
  </head>
  <body>
<h1>当前有 <span><%=this.getServletConfig().getServletContext().getAttribute("onlineCount")%></span></h1>
  </body>
</html>

13. 过滤器、监听器的常见应用：

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

public class TestListener {
    public static void main(String[] args) {
        Frame frame = new Frame("小马加油"); // 新建一个窗体
        Panel panel=new Panel(null); // 面板
        frame.setLayout(null); // 设置窗体的布局

        frame.setBounds(300,300,500,500);
        frame.setBackground(new Color(0,0,255)); // 设置背景颜色
        panel.setBounds(50,50,300,300);
        panel.setBackground(new Color(0,255,0)); // 设置背景颜色

        frame.add(panel);

        frame.setVisible(true);

        // 监听事件，监听关闭事件
        frame.addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosing(WindowEvent e) {
                System.exit(0);
            }
        });

    }
}

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

  1. 用户登录后，向Session中放入用户的数据
  2. 进入主页的时候要判断用户是否已经登录
  • 用户登录
public class LoginServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 获取前端请求的参数
        String username=req.getParameter("username");
        System.out.println(username);
        if (username.equals("admin")){
            //登录成功
            req.getSession().setAttribute(Constant.USER_SESSION,req.getSession().getId());
            resp.sendRedirect("/sys/success.jsp");
        }
        else{
            // 登录失败
                resp.sendRedirect("/error.jsp");
        }
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
      doGet(req,resp);
    }
}
  • 用户注销
public class LoginOutServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        Object user_session = req.getSession().getAttribute(Constant.USER_SESSION);
        if(user_session!=null){
            req.getSession().removeAttribute(Constant.USER_SESSION);
            resp.sendRedirect("/login.jsp");
        }else {
            resp.sendRedirect("/login.jsp");
        }
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req, resp);
    }
}
  • 过滤器：
public class SysFilter implements Filter {
    public void init(FilterConfig filterConfig) throws ServletException {

    }

    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        HttpServletRequest request1 = (HttpServletRequest) request;
        HttpServletResponse response1 = (HttpServletResponse) response;
        Object userSession = request1.getSession().getAttribute(Constant.USER_SESSION);
        if(userSession==null){
            response1.sendRedirect("/error.jsp");
        }
        chain.doFilter(request,response);
    }

    public void destroy() {

    }
}

14. JDBC:

什么是JDBC：java 连接数据库！

需要jar包：

  • java.sql
  • javax.sql
  • mysql-connector-java 连接驱动（必须导入）

1、模拟JDBC：

  1. 创建数据库
CREATE TABLE users(
 id INT PRIMARY KEY,
 `name` VARCHAR(40),
 `password` VARCHAR(40),
 `email` VARCHAR(60),
 `birthday` DATE
);

INSERT INTO users(`id`,`name`,`password`,`email`,`birthday`) 
VALUES(1,'张三','123456','zs@qq.com','2000-01-01'),(2,'李四','123456','ls@qq.com','2000-01-01'),
(3,'王五','123456','ww@qq.com','2000-01-01');
  1. 在pom.xml中导入依赖：
<!--     mysql 的驱动-->
     <dependency>
         <groupId>mysql</groupId>
         <artifactId>mysql-connector-java</artifactId>
         <version>5.1.47</version>
     </dependency>

  1. IDEA中连接数据库

  2. 编写程序：

public class TestJdbc {
    public static void main(String[] args) throws ClassNotFoundException, SQLException {
        String url="jdbc:mysql://localhost:3306/jdbc?useUnicode=true&characterEncoding=utf-8&useSSL=true";
        String username="root";
        String password="087415157";
        // 1. 加载驱动
        Class.forName("com.mysql.jdbc.Driver");
        // 2. 连接数据库 代表数据库
        Connection connection = DriverManager.getConnection(url, username, password);
        // 3. 向数据库发送SQL的对象Statement :CRUD
        Statement statement = connection.createStatement();
        // 4. 编写SQL
        String sql="select * from users";
        // 5. 执行查询的SQL。返回一个resultSet ：结果集
        ResultSet resultSet = statement.executeQuery(sql);
        while (resultSet.next()){
            System.out.println("id:"+resultSet.getInt("id"));
            System.out.println("name:"+resultSet.getString("name"));
            System.out.println("password:"+resultSet.getString("password"));
            System.out.println("email:"+resultSet.getString("email"));
            System.out.println("birthday:"+resultSet.getInt("birthday"));

        }

        // 6. 关闭连接，释放资源  先开后关
        resultSet.close();
        statement.close();
        connection.close();

    }
}

预编译程序（preparedStatement）：

public class TestJdbc02 {
    public static void main(String[] args) throws ClassNotFoundException, SQLException {
        String url="jdbc:mysql://localhost:3306/jdbc?useUnicode=true&characterEncoding=utf-8&useSSL=true";
        String username="root";
        String password="087415157";
        // 1. 加载驱动
        Class.forName("com.mysql.jdbc.Driver");
        // 2. 连接数据库 代表数据库
        Connection connection = DriverManager.getConnection(url, username, password);
        String sql="insert into users (id, name, password, email, birthday) VALUES (?,?,?,?,?)";
        // 3. 向数据库发送SQL的对象Statement :CRUD
        PreparedStatement preparedStatement = connection.prepareStatement(sql);
        preparedStatement.setInt(1,4);
        preparedStatement.setString(2,"小马");
        preparedStatement.setString(3,"123456");
        preparedStatement.setString(4,"xm@qq.com");
        preparedStatement.setDate(5,new Date(new java.util.Date().getTime()));

        int i = preparedStatement.executeUpdate();
        if(i>0){
            System.out.println("插入成功");
        }

        // 6. 关闭连接，释放资源  先开后关

        preparedStatement.close();
        connection.close();

    }
}

3、Junit单元测试：

依赖

     <dependency>
         <groupId>junit</groupId>
         <artifactId>junit</artifactId>
         <version>4.12</version>
         <scope>test</scope>
     </dependency>

简单使用

@Test注解只有在方法上有效，只要加这个注解的方法，就可以直接运行。

成功的时候是绿色，失败的时候是红色

public class TestJdbc03 {

    @Test
    public void test(){
        System.out.println("hello");
    }
}

2、事务：

要么都成功，要么都失败

ACID原则：保证数据的安全

开启事务
    
事务提交
    
事务回滚
    
关闭事务

15. SMBMS项目：

1、项目搭建准备工作：

  1. 搭建一个maven web项目

  2. 配置Tomcat

  3. 测试项目是否能启动

  4. 导入需要的jar包

    jsp，Servlet，mysql驱动，jstl，standard

  5. 创建项目包结构

在这里插入图片描述

  1. 编写实体类:

    ORM映射：表-类映射

  2. 编写基础公共类

    • 数据库配置文件：db.properties

      driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/smbms?useUnicode=true&characterEncoding=utf-8&useSSL=true
username=root
password=087415157

    • 编写数据库的公共类BaseDao：

      // 操作数据库的公共类
public class BaseDao {
    private static String dirver;
    private static String url;
    private static String username;
    private static String password;
    
    // 启动后就加载
    static {
        // 通过类加载器读取对应的资源
        InputStream resourceAsStream = BaseDao.class.getClassLoader().getResourceAsStream("db.properties");
        Properties properties = new Properties();
        try {
            properties.load(resourceAsStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
        dirver=properties.getProperty("driver");
        url =properties.getProperty("url");
        username=properties.getProperty("username");
        password=properties.getProperty("password");


    }

    // 获取数据库的连接
    public static Connection getConnection(){
        Connection connection=null;
        try {
            Class.forName(dirver);
            connection = DriverManager.getConnection(url, username, password);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return connection;
    }


    // 编写查询公共类
    public static ResultSet execute(Connection connection,String sql,Object[]params,ResultSet resultSet){
        try {
            PreparedStatement preparedStatement = connection.prepareStatement(sql);
            for (int i =0;i<params.length;i++) {

                // setObject,占位符从1开始，但是我们的数组是从0开始的
                preparedStatement.setObject(i+1,params[i]);
            }

           resultSet= preparedStatement.executeQuery();

        } catch (SQLException e) {
            e.printStackTrace();
        }
        return resultSet;
    }


    // 编写增删改的公共方法

    public static int execute(Connection connection,String sql,Object[]params){
        int updateRows=0;
        try {
            PreparedStatement preparedStatement = connection.prepareStatement(sql);
            for (int i =0;i<params.length;i++) {

                // setObject,占位符从1开始，但是我们的数组是从0开始的
                preparedStatement.setObject(i+1,params[i]);
            }

           updateRows= preparedStatement.executeUpdate();

        } catch (SQLException e) {
            e.printStackTrace();
        }
        return updateRows;
    }

    // 释放资源
    public static  boolean closeResource(Connection connection,  PreparedStatement preparedStatement,ResultSet resultSet){
        boolean flag=true;
        if (resultSet!=null) {
            try {
                resultSet.close();
                //GC回收
                resultSet = null;
            } catch (SQLException e) {
                e.printStackTrace();
                flag = false;
            }
        }

            if (preparedStatement!=null) {
                try {
                    preparedStatement.close();
                    //GC回收
                    preparedStatement = null;
                } catch (SQLException e) {
                    e.printStackTrace();
                    flag = false;
                }
            }


                if (connection!=null){
                    try {
                        connection.close();
                        //GC回收
                      connection=null;
                    } catch (SQLException e) {
                        e.printStackTrace();
                        flag=false;
                    }
        }
                return flag;
    }
}

    • 编写字符编码过滤器CharacterEncodingFilter：

      public class CharacterEncodingFilter implements Filter {
    public void init(FilterConfig filterConfig) throws ServletException {

    }

    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
           servletRequest.setCharacterEncoding("utf-16");
           servletResponse.setCharacterEncoding("utf-16");
           filterChain.doFilter(servletRequest,servletResponse);
    }

    public void destroy() {

    }
}

  3. 导入静态资源：

2、登录功能实现：

在这里插入图片描述

  1. 编写前端页面：

  2. 设置首页web.xml：

        <!--设置欢迎页面-->
    <welcome-file-list>
        <welcome-file>login.jsp</welcome-file>
    </welcome-file-list>

  3. 编写dao层登录用户登录的接口UserDao:

    public interface UserDao {
    // 得到要登录的用户
    public User getLoginUser(Connection connection,String userCode);
}

  4. 编写dao层实现类UserDaoImpl：

    blic class UserDaoImpl implements UserDao {
    public User getLoginUser(Connection connection, String userCode) {
        PreparedStatement pstm=null;
        ResultSet rs=null;
        User user=null;

        if (connection!=null){
            String sql="select * from smbms_user where userCode=?";
            Object[]params={userCode};
            try {
                rs= BaseDao.execute(connection,pstm,rs,sql,params);
                if (rs.next()){
                    user=new User();
                    user.setId(rs.getInt("id"));
                    user.setUserCode(rs.getString("userCode"));
                    user.setUserName(rs.getString("userName"));
                    user.setUserPassword(rs.getString("userPassword"));
                    user.setGender(rs.getInt("gender"));
                    user.setBirthday(rs.getDate("birthday"));
                    user.setPhone(rs.getString("phone"));
                    user.setAddress(rs.getString("address"));
                    user.setUserRole(rs.getInt("userRole"));
                    user.setCreatedBy(rs.getInt("createBy"));
                    user.setCreationDate(rs.getTimestamp("creationDate"));
                    user.setModifyBy(rs.getInt("modifyBy"));
                    user.setModifyDate(rs.getTimestamp("modifyDate"));
                }
                BaseDao.closeResource(null,pstm,rs);
            } catch (SQLException e) {
                e.printStackTrace();
            }

        }

        return user;
    }
}

  5. 业务层接口UserService：

    public interface UserService {
    // 用户登录
    public User login(String userCode,String password);
}

  6. 业务实现类UserServiceImpl：

    public class UserServiceImpl implements UserService {

    // 业务层都会调用dao层，所以我们要引入Dao层
    private UserDao userDao;
    public UserServiceImpl(){
        userDao=new UserDaoImpl();
    }

    public User login(String userCode, String password) {
        Connection connection=null;
        User user=null;
         connection = BaseDao.getConnection();
         // 通过业务层调用对应的具体的数据库操作
        user= userDao.getLoginUser(connection,userCode);
        BaseDao.closeResource(connection,null,null);


     return user;
     }




}

  7. 编写Servlet类LoginServlet:

    public class LoginServlet extends HttpServlet {

    // Servlet:控制层调用业务层



    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("LoginServlet-->start...");

        // 获取用户名和密码
       String userCode= req.getParameter("userCode");
       String userPassword=req.getParameter("userPassword");

       // 和数据库中的用户名和密码对比，调用业务层
        UserServiceImpl userService = new UserServiceImpl();
        // 这里已经把登录的人给查出来了
        User user = userService.login(userCode, userPassword);

        if(user!=null){ //查有此人，可以登录
            // 将用户的信息放到Session 中
            req.getSession().setAttribute(Constants.USER_SESSION,user);

            // 跳转到内部主页
            resp.sendRedirect("jsp/frame.jsp");
        }
        else {
            //查无此人，无法登录
            // 转发回登录页面，顺带提示他，用户名，密码错误：
            req.setAttribute("error","用户或密码不正确");
            req.getRequestDispatcher("login.jsp").forward(req,resp);
        }


    }

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

3、退出及权限过滤：

  1. 退出功能：
public class LoginoutServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 移除用户的session
        req.getSession().removeAttribute(Constants.USER_SESSION);
        resp.sendRedirect(req.getContextPath()+"/login.jsp"); // 返回登录页面
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
       doGet(req, resp);
    }
}
  1. 注册xml:
   <servlet>
        <servlet-name>LogoutServlet</servlet-name>
        <servlet-class>com.ma.servlet.user.LoginoutServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>LogoutServlet</servlet-name>
        <url-pattern>/jsp/logout.html</url-pattern>
    </servlet-mapping>
  1. 登录拦截优化
public class SysFilter implements Filter {
    public void init(FilterConfig filterConfig) throws ServletException {

    }

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

        // 过滤器，从Session中获取用户
        User user  = (User) request.getSession().getAttribute(Constants.USER_SESSION);
        if(user==null){ // 已经被移除或注销，或者未登录
            response.sendRedirect("/smbms/error.jsp");
        }else {
            filterChain.doFilter(servletRequest, servletResponse);
        }
    }

    public void destroy() {

    }
}
  1. 拦截器注册：
 <!--用户登录过滤器-->
    <filter>
        <filter-name>SysFilter</filter-name>
        <filter-class>com.ma.filter.SysFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>SysFilter</filter-name>
        <url-pattern>/jsp/*</url-pattern>
    </filter-mapping>

4、密码修改：

  1. 导入前端素材：

                  <li><a href="${pageContext.request.contextPath }/jsp/pwdmodify.html">密码修改</a></li>

  2. 写项目，建议从底层向上写

  3. UserDao接口：

      
    // 修改当前用户密码
    public int updatePwd(Connection connection,int id,int password) throws SQLException;

  4. UserDaoimpl:

        public int updatePwd(Connection connection, int id, int password) throws SQLException {
         PreparedStatement pstm=null;
         int execute=0;
         if(connection!=null) {
             String sql = "update smbms_user set userPassword=? where id=?";
             Object[] params = {password, id};
              execute = BaseDao.execute(connection, pstm, sql, params);
             BaseDao.closeResource(null, pstm, null);
         }
         return execute;
    }

  5. UserService接口:

        // 根据用户ID修改当前用户密码
    public boolean updatePwd( int id, int password) ;

  6. UserService实现类：

        public boolean updatePwd(int id, int password) {
        Connection connection=null;
        boolean flag=false;
      connection = BaseDao.getConnection();

      // 修改密码
        try {
            if (userDao.updatePwd(connection,id,password)>0){
                flag=true;

            }
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            BaseDao.closeResource(connection,null,null);
        }
        return flag;

    }

  7. 记得实现复用，需要提取方法

       protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String method = req.getParameter("method");
        if (method.equals("savepwd")&& method!=null){
            this.updatePwd(req,resp);
        }
    }

5、优化密码修改使用Ajax:

  1. 阿里巴巴的fastjson:

    <dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.61</version>
</dependency>

  2. 后台代码UserServlet中：

    // 验证旧密码，session中有用户密码
    public void pwdModify(HttpServletRequest req, HttpServletResponse resp){
        User o = (User) req.getSession().getAttribute(Constants.USER_SESSION);
        String oldpassword=req.getParameter("oldpassword");


        // 万能的Map: 结果集
        HashMap<String, String> resultMap = new HashMap<String, String>();

        if(o==null){  // Session失效，session过期
            resultMap.put("result","sessionerror");

        }else if(StringUtils.isNullOrEmpty(oldpassword)){ // 输入密码为空
            resultMap.put("result","error");
        }else{
            String userPassword=o.getUserPassword();  //Session中用户的密码
            if(oldpassword.equals(userPassword)){
                resultMap.put("result","true");
            }else{
                resultMap.put("result","false");
            }
        }

        try {
            resp.setContentType("application/json");
            PrintWriter writer = resp.getWriter();
            // JSONArray 阿里巴巴JSON工具类 转换格式的
            writer.write(JSONArray.toJSONString(resultMap));
            writer.flush();
            writer.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

6、用户管理实现：

在这里插入图片描述

  1. 导入分页的工具类

  2. 用户列表页面导入

    userlist.jsp

1.获取用户数量：

  1. UserDao

        // 查询用户总数
    public int getUserCount(Connection connection,String username,int userRole)throws SQLException;

  2. UserDaoImpl

        // 根据用户名或者角色查询用户总数
    public int getUserCount(Connection connection, String username, int userRole) throws SQLException {
        PreparedStatement pstm=null;
        ResultSet rs=null;
        int count=0;
        if (connection!=null){
            StringBuffer sql=new StringBuffer();
            sql.append("select count(1) as count from smbms_user u,smbms_role r where u.userRole=r.id");
            ArrayList<Object> list = new ArrayList<Object>();// 存放我们的参数
            if(!StringUtils.isNullOrEmpty(username)){
                sql.append("and u.userName like ?");
                list.add("%"+username+"%");  // 9
            }
            if(userRole>0){
                sql.append(" and u.userRole=?");
                list.add(userRole);
            }

            // 把list转换成数组
            Object[] objects = list.toArray();
            System.out.println("UserDaoImpl-->getUserCount"+" "+sql.toString());// 输出最后的sql

             rs= BaseDao.execute(connection, pstm, rs, sql.toString(), objects);
             if(rs.next()){
                  count = rs.getInt("count");//从结果集中获取最终的数量
             }
             BaseDao.closeResource(null,pstm,rs);
        }
        return count;
    }

  3. UserService

        // 查询记录数
    public int getUserCount(String username,int userRole);

  4. UserServiceImpl

        // 查询记录
    public int getUserCount(String username, int userRole) {
        Connection connection = null;
        int count=0;
        try {
            connection = BaseDao.getConnection();
            count = userDao.getUserCount(connection, username, userRole);
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            BaseDao.closeResource(connection,null,null);
        }
        return count;
    }
2.获取用户列表：

  1. UserDao:

     // 获取用户列表
    public List<User> getUserList(Connection connection,String userName,int userRole,int currentPageNo,int pageSize)throws  SQLException;

  2. UserDaoImpl:

        public List<User> getUserList(Connection connection, String userName, int userRole, int currentPageNo, int pageSize) throws SQLException {
     PreparedStatement pstm=null;
     ResultSet rs=null;
     List<User>userList=new ArrayList<User>();
     if(connection!=null){
         StringBuffer sql=new StringBuffer();
         sql.append("select u.*,r.roleName as userRoleName from smbms_user u,smbms_role r where u.userRole=r.id");
         List<Object>list=new ArrayList<Object>();
         if(!StringUtils.isNullOrEmpty(userName)){
             sql.append(" and u.userName like ?");
             list.add("%"+userName+"%");
         }
         if(userRole>0){
             sql.append(" and u.userRole= ?");
             list.add(userRole);
         }
         sql.append(" order by creationDate DESC limit ?,?");
         currentPageNo=(currentPageNo-1)*pageSize;
         list.add(currentPageNo);
         list.add(pageSize);
         Object[] params = list.toArray();
         System.out.println("getUserList-->sql"+" "+sql);
         rs=BaseDao.execute(connection,pstm,rs,sql.toString(),params);
         while (rs.next()){
             User _user=new User();
             _user.setId(rs.getInt("id"));
             _user.setUserCode(rs.getString("userCode"));
             _user.setUserName(rs.getString("userName"));
             _user.setGender(rs.getInt("gender"));
             _user.setBirthday(rs.getDate("birthday"));
             _user.setPhone(rs.getString("phone"));
             _user.setUserRole(rs.getInt("userRole"));
             _user.setUserRole(rs.getInt("userRoleName"));
             userList.add(_user);


         }
         BaseDao.closeResource(null,pstm,rs);
     }
     return userList;
    }

  3. UserService:

        // 根据条件查询用户列表
    public List<User>getUserList(String queryUserName,int queryUserRole,int currentPageNo,int pageSize);

  4. UserServiceImpl:

        public List<User> getUserList(String queryUserName, int queryUserRole, int currentPageNo, int pageSize) {
        Connection connection=null;
        List<User>userList=null;
        System.out.println("queryUserName---->"+queryUserName);
        System.out.println("queryUserRole---->"+queryUserRole);
        System.out.println("currentPageNo---->"+currentPageNo);
        System.out.println("pageSize---->"+pageSize);


        try {
            connection=BaseDao.getConnection();
            userList=userDao.getUserList(connection,queryUserName,queryUserRole,currentPageNo,pageSize);
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            BaseDao.closeResource(connection,null,null);
        }
        return userList;
    }
3.获取角色操作：

为了我们职责统一，可以把角色得到操作单独放在一个包中，和entity类对应

  1. RoleDao:

    public interface RoleDao {
    // 获取角色列表
    public List<Role> getRoleList(Connection connection) throws SQLException;
}

  2. RoleDaoImpl;

    public class RoleDaoImpl implements RoleDao{
    // 获取角色列表
    public List<Role> getRoleList(Connection connection) throws SQLException {
        PreparedStatement pstm=null;
        ResultSet rs=null;
        ArrayList<Role> roleList = new ArrayList<Role>();
        if(connection!=null){
            String sql="select * from smbms_role";
            Object[]params={};
            rs = BaseDao.execute(connection, pstm, rs, sql, params);
            while (rs.next()){
                Role _role=new Role();
                _role.setId( rs.getInt("id"));
                _role.setRoleCode( rs.getString("roleCode"));
                _role.setRoleName(  rs.getString("roleName"));
                roleList.add(_role);


            }
            BaseDao.closeResource(null,pstm,rs);
        }
        return roleList;
    }
}

  3. RoleService:

    public interface RoleService {
    // 获取角色列表
    public List<Role> getRoleList();
}

  4. RoleServiceImpl:

    public class RoleServiceImpl implements RoleService {
    // 业务层都会调用dao层，所以我们要引入Dao层
    private RoleDao roleDao;
    public RoleServiceImpl(){
        roleDao=new RoleDaoImpl();
    }


    public List<Role> getRoleList() {
        Connection connection=null;
        List<Role> roleList=null;

        try {
            BaseDao.getConnection();
            roleList=roleDao.getRoleList(connection);

        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            BaseDao.closeResource(connection,null,null);
        }
        return roleList;
    }

  5. UserServlet:

    // 重点，难点
    public void query(HttpServletRequest req, HttpServletResponse resp){

        // 查询用户列表

        // 从前端获取数据
        String queryUserName = req.getParameter("queryUserName");
        String temp = req.getParameter("queryUserRole");
        String pageIndex = req.getParameter("pageIndex");
        int queryUserRole=0;

        // 获取用户列表
        UserServiceImpl userService = new UserServiceImpl();
        List<User> userList=null;

        // 第一次走这个请求，一定是第一页，页面大小是固定的

        int pageSize=5; // 可以写到配置文件中，方便以后修改

        int currentPageNo=1;

        if (queryUserName==null){
            queryUserName="";
        }
        if (temp!=null&& !temp.equals("")){
            queryUserRole=Integer.parseInt(temp); // 给查询的赋值
        }

        if(pageIndex!=null){

            try {
                currentPageNo=Integer.parseInt(pageIndex);
            } catch (NumberFormatException e) {
                try {
                    resp.sendRedirect("error.jsp");
                } catch (IOException ex) {
                    ex.printStackTrace();
                }
            }
        }

        // 获取用户总数(分页：上一页 下一页)
        int totalCount = userService.getUserCount(queryUserName, queryUserRole);


        // 总页数支持
        PageSupport pageSupport=new PageSupport();
        // 当前页码
        pageSupport.setCurrentPageNo(currentPageNo);
        // 设置页面容量
        pageSupport.setPageSize(pageSize);
        // 设置总数
        pageSupport.setTotalCount(totalCount);

        // 总页数
        int totalPageCount=pageSupport.getTotalPageCount(); // 总共有几页
        // 控制首页和尾页
        // 如果页面要小于1就显示第一页
        if(currentPageNo<1){
            currentPageNo=1;
        }else if(currentPageNo>totalPageCount){ // 当前页面大于最后一页
            currentPageNo=totalPageCount;

        }

        // 获取用户的展示
        userList = userService.getUserList(queryUserName, queryUserRole, currentPageNo, pageSize);
        req.setAttribute("userList",userList);

        // 获取角色列表
        RoleServiceImpl roleService = new RoleServiceImpl();
        List<Role> roleList = roleService.getRoleList();
        req.setAttribute("roleList",roleList);
        req.setAttribute("totalCount",totalCount);
        req.setAttribute("currentPageNo",currentPageNo);
        req.setAttribute("totalPageCount",totalPageCount);
        req.setAttribute("queryUserName",queryUserName);
        req.setAttribute("queryUserRole",queryUserRole);


        // 返回前端
        try {
            req.getRequestDispatcher("userlist.jsp").forward(req,resp);
        } catch (ServletException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

16. 文件传输：

  1. 需要的jar包：

    • https://mvnrepository.com/artifact/commons-io/commons-io/2.6
    • https://mvnrepository.com/artifact/commons-fileupload/commons-fileupload/1.4

  2. 文件上传注意事项：

    • 为保证服务器的安全，上传文件应该放在外界无法直接访问的目录下，比如WEB-INF目录下
    • 为防止文件覆盖的现象发生，要为上传文件产生一个唯一的文件名（时间戳，UUID，MD5等，防止文件名重复）
    • 要限制上传文件的最大值
    • 可以限制上传文件的类型，在收到上传文件名时，判断后缀名是否合法

  3. 需要用到的类详解：

    • ServletFileUpload负责处理上传的文件数据，并将表单中每个输入项封装成一个File对象，在使用ServletFileUpload对象解析请求时需要DiskFileItemFactory对象，所以，我们需要在进行解析工作前构造好DiskFileItemFactory对象，通过ServletFileUpload对象的构造方法或setFileItemFactory()方法设置ServletFileUpload对象的fileItmFactory属性。

  4. 表单如果包含一个文件上传输入项的话，这个表单的enctpe属性就必须设置为multipart/form-data

  5. 常用方法介绍：

    // 判断FileItem类对象封装的数据是一个普通文本表单
// 还是一个文件表单，如果是普通表单字段则返回true，否则返回false
boolean isFormField(); 

// getFieldName()方法用于返回表单标签name属性的值
String  getFieldName();

// getString()方法用于将FileItem对象中保存的数据流内容以一个字符串返回
String getString();

// getName()方法用于获得文件上传字段中的文件名
String getName();

// 以流的形式返回上传文件的数据内容
InputStream getInputStream();

// delete()方法用来清空FileItem类对象中存放的主题内容
// 如果主体内容被保存在临时文件中，delete方法将删除该临时文件
void delete();

1. ServletFileUpload类：

ServletFileUpload负责处理上传的文件数据，并将表单中每个输入项封装成一个FileItem对象中，使用其parseRequest(HttpServletRequest)方法可以通过表单中每一个HTML标签提交的数据封装成一个FileItem对象，然后以List列表的形式返回。使用该方法处理上传文件简单易用。

17、邮件发送：

  1. 传输协议

    • SMTP协议：发送邮箱：我们通常把处理用户smtp请求（邮件发送请求）的服务器称之为SMTP服务器（邮件发送服务器）。
    • POP3协议：接收邮箱：我们通常把处理用户pop3请求（邮件接收请求）的服务器称之为POP3服务器（邮件接收服务器）。

  2. 需要准备两个包

    • mail.jar：https://mvnrepository.com/artifact/javax.mail/mail/1.4.7
    • activation.jar：https://mvnrepository.com/artifact/javax.activation/activation/1.1.1

  3. 主要的四个核心类：

在这里插入图片描述

  1. 一封简单的邮件:

在这里插入图片描述

// 一封简单的邮件
public class MailDemo01 {
    public static void main(String[] args) throws GeneralSecurityException, MessagingException {
        Properties prop=new Properties();
        prop.setProperty("mail.host","smtp.qq.com"); // 设置QQ邮箱服务器
        prop.setProperty("mail.transport.protocol", "smtp");// 邮箱发送协议
        prop.setProperty("mail.smtp.auth", "true");// 需要验证用户名密码


        // 如果是QQ邮箱，还要设置SSL加密，加上以下代码即可 其他邮箱不需要
        MailSSLSocketFactory sf=new MailSSLSocketFactory();
        sf.setTrustAllHosts(true);
        prop.put("mail.smtp.ssl","true");
        prop.put("mail.smtp.ssl.socketFactory",sf);


        // 使用JavaMail发送邮箱的5个步骤

        // 1.创建定义整个应用程序所需要的环境信息的Session对象

        // QQ才有，其他邮箱不需要
        Session session= Session.getDefaultInstance(prop, new Authenticator() {
            @Override
            protected PasswordAuthentication getPasswordAuthentication() {
                // 发件人邮箱用户名  授权码
                return new PasswordAuthentication("发送人邮箱","授权码");
            }
        });

        // 开启Session的debug模式，这样就可以查看到程序发送Email的运行状态
        session.setDebug(true);

        // 2.通过session得到transport对象
        Transport ts = session.getTransport();

        // 3. 使用邮箱的用户名和授权码连上邮件服务器
        ts.connect("smtp.qq.com","发送人邮箱","授权码");


        // 4. 创建邮件
        // 注意，需要传递Session

        MimeMessage message = new MimeMessage(session);

        // 指明邮件的发件人
        message.setFrom(new InternetAddress("发送人邮箱"));

        // 指明邮件的收件人
        message.setRecipient(MimeMessage.RecipientType.TO,new InternetAddress("接收人邮箱"));

        // 邮件主题
        message.setSubject("吼吼");

        // 邮箱的文本内容
        message.setContent("<h1 style='color:pink'>小马同学</h1>","text/html;charset=UTF-8");



        // 5. 发送邮件
        ts.sendMessage(message,message.getAllRecipients());

        // 6. 关闭连接
        ts.close();

    }
}
我只爱吃肉呀
关注
专栏目录
1.请求和响应
weixin_55897821的博客
11-02 174
1.HttpServletResponse对象 他继承自servletResponse接口,用来封装HTTP响应消息,由于HTTP响应消息分为状态行、响应消息头、消息体三部分,因此,在HttpServletResponse中定义了状态行、响应消息头、消息体三部分; 2.setStatus(int status)方法 该方法用于设置HTTP响应消息的状态码,并生成相应代码行;默认会生成一个状态码为200的状态行; ...
JavaWeb重修（一）【JavaWeb入门】
智慧地球（AI·Earth）
03-14 2万+
废话不多说，这个系列是在我自己对JavaWeb的理解的基础上，结合之前JavaWeb开发的经验的总结。 在学习的过程中我会把我的源代码分享出来，喜欢的话记得给星星哦~： #手里目前确实有几个好一点的项目，不过实在是太忙了，等有时间了整理几篇博客出来供大家参考 JavaWeb重修（一）【JavaWeb入门】 一、首先是怎么学【学习的系统路线】： 这个我个人推荐的有： 【1】知...
JAVA WEB 初识EL
qq_63093843的博客
11-15 315
1.初识EL EL可以简化JSP页面的书写; 格式: ${表达式} 在项目的src目录创建包cn.itcase.chapter08.servlet,在包里创建一个用于存储用户名和密码的类MyServlet.java MyServlet.java 然后,在WebContent目录下编写一个名为myjsp.jsp的JSP文件,用于存储输出MyServlet所有信息; myjsp.jsp 运行结果 2.EL隐式对象 pageContext对象:用来获取对象中的属性; 在We..
Javaweb
qq_63093843的博客
10-30 338
请求和响应 1.HttpServletResponse对象:他继承自servletResponse接口,用来封装HTTP响应消息,由于HTTP响应消息分为状态行、响应消息头、消息体三部分,因此,在HttpServletResponse中定义了状态行、响应消息头、消息体三部分; 2. ...
javaweb项目实（含笔记与详细实现步骤）
07-20
JavaWeb项目实（含笔记与详细实现步骤） JavaWeb是一种基于Java技术的Web应用程序开发框架，它涵盖了服务器端编程、数据库交互、用户界面设计等多个方面。对于初学者来说，掌握JavaWeb开发是步入Web开发领域的关键...
JavaWEB商城项目(包括数据库)
09-20
功能描述:包括用户的登录注册,以及个人资料的修改.商品的分类展示,详情,加入购物车,生成订单,到银行支付等!另外还有收货地址的和我的收藏等常用操作.环境(JDK 1.7 ,mysql 5.5,Eclipse mars2 ).
尚硅谷全新JavaWeb教程，企业主流javaweb技术栈 中代码
最新发布
04-07
【JavaWeb教程详解】 JavaWeb开发是Java编程领域的一个重要分支，主要涉及构建基于Web的交互式应用程序。尚硅谷推出的全新JavaWeb教程聚焦于企业主流技术栈，旨在帮助开发者掌握实际工作中所需的关键技能。本教程...
教务管理系统javaweb项目
03-24
教务管理系统javaweb项目 运行环境：window系统，Apache Tomcat v7.0.84、JDK1.8 开发环境：J2EE eclipse、navicat for mysql 运用的技术：MVC设计模式、DAO模式、Servlet、JSP、Filter、MySQL数据库 该项目主要分为...
JavaWeb仿小米在线商城ShoppingMall
06-30
JavaWeb在线商城开发知识总结(java+jsp+servlet+MySQL+jdbc+css+js+jQuery) 可以实现浏览商品，查看商品详情，添加购物车，计算价格等功能 项目文章：...
JavaWeb：WEB服务器
离开屏幕的光，哪盏灯照亮你的孤独？
03-07 8133
WEB WEB，在英语中web即表示网页的意思，它用于表示Internet主机上供外界访问的资源。 Internet上供外界访问的Web资源分为： 静态web资源（如html 页面）：指web页面中供人们浏览的数据始终是不变。 动态web资源：指web页面中供人们浏览的数据是由程序产生的，不同时间点访问web页面看到的内容各不相同。 静态web资源开发技术：HTML、CSS、JavaScr...
面试——Java Web
CC_zard的博客
05-24 397
jsp 和 servlet 的区别是什么？ jsp 是 servlet 技术的扩展，属于简易方式。 它们不同在于，前者侧重于视图，后者侧重于控制逻辑。 servlet 应用逻辑在 Java 的文件中，且完全从表示层中的 html 里分离出来； jsp 是 Java 和 html 可组成一个扩展名为 .jsp 的文件。 jsp 中有哪些内置对象？有什么作用？ request： 封装客户端请求。（包含 get、post 的请求参数） response： 封装服务器对客户端的响应。 pageContext：
Java Web基础概述
巧克力布丁的博客
09-20 4736
一. Web结构 以下三块组成一个完整的项目 1. 什么是后端开发 后端开发即“服务器端”开发，主要涉及软件系统“后端”的东西。比如，用于托管网站和 App 数据的服务器、放置在后端服务器与浏览器及 App 之间的中间件，它们都属于后端。简单地说，那些你在屏幕上看不到但又被用来为前端提供支持的东西就是后端。 网站和移动 App 的后端 网站的后端涉及搭建服务器、保存和获取数据，以及用于连接前端的接口。如果说前端开发者关心的是网站外观，那么后端开发者关心的是如何通过代码、API 和数据库集成来提升网站的速度
java web mvc 模式_JavaWeb-MVC模式概述
weixin_29871753的博客
02-16 368
MVC设计模式MVC模式(Model-View-Controller)是软件工程中的一种软件架构模式，把软件系统分为三个基本部分：模型(Model)、视图(View)和控制器(Controller)。MVC模式最早为TrygveReenskaug提出，为施乐帕罗奥多研究中心(XeroxPARC)的Smalltalk语言发明的一种软件设计模式。MVC可对程序的后期维护和扩展提供了方便，并且使程序...
Javaweb安全——反序列化漏洞-CC&CB链思路整理
weixin_43610673的博客
10-28 2394
如上图所示基本上起点终点就是那几个点然后相互拼接：《Shiro RememberMe 漏洞检测的探索之路》中Koalr师傅已经对CommonsCollections 系列 gadget进行了提纯变成以下四条对命令执行部分的调用分别为InvokerTransformer调用TemplatesImpl对 commons-Collections4 的适配则直接用替换。
安全检测点的一些梳理——待长期整理
djph26741的博客
04-30 319
渗透攻击检测：邮件检测、扫描、爆破内网安全：基线检测、内部扩散、蠕虫、数据外泄恶意通道检测：DGA、恶意C&C流、隐蔽通道高级威胁分析：攻击工具、扫描工具、高级威胁加密流量检测：恶意加密流，https ddosweb安全：webshell、waf/ips降噪、webcc、sql、xss等 UEBA：主机流量异常，用户行为异常等 第4章　Web安全基础 414...
JavaWeb分页技术实现
08-01
实现了JavaWeb分页技术：内存分页与数据库分页，并对分页进行了封装，学习该课程可以掌握分页的整个技术实现过程。技术参数：Java+Servlet/Jsp实现分页数据库：MySQL课程中包含内存分页、数据库分页、按添加查询分页、以及分页封装及源代码，通过该课程，可以掌握分页的实现过程，建议由兴趣的同学可以学习一下！ 
JavaWeb介绍
热门推荐
希望有点用
06-13 2万+
Web开发是为Internet（World Wide Web）或Intranet（私有网络）开发网站所涉及的工作。Web开发的范围可以从开发简单的纯文本单个静态页面到复杂的基于Web的Internet应用程序（Web应用程序）。 静态web：动态web：可以读取一些服务器存在的数据，例如： 缺点页面会动态展示：web的页面展示效果因人而异。 缺点优点微软：国内最早流行的就是ASP 在HTML中嵌入VB的脚本，ASP+COM优点缺点优点缺点B/S：浏览器和服务器 C/S：客户端和服务器 sun公司主推的B
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值