xiaoye-Blog

  博客园  :: 首页  :: 新随笔  :: 联系 :: 订阅 订阅  :: 管理
javaWeb知识点大集合！！！

目录

1.基本概念

  1. web开发：

    • web：网页

      • 静态web：
        • html，css
        • 提供给所有人看的数据始终不会发生变化
      • 动态web：：
        • 提供给所有人看的数据会发生变化，每个人在不同时间不同地点看到的信息各不相同
        • 技术栈：Servlet/JSP，ASP，PHP

      注：在java中，动态web资源开发的技术统称为javaweb

  2. web应用程序：

    1. 概念：即可以提供浏览器进行访问的程序

      • a.html，b.html...多个web资源，这些资源可以被外界访问，对外界提供服务

      • 访问到的任何一个页面或者资源都存在于某一台电脑上

      • 每个资源都存在一个URL标识其位置

      • 这个统一的web资源会被放在同一个文件下，web应用程序--tomcat：服务器

      • web应用组成：（静态web，动态web）：

        • html，css，js
        • jsp，servlet
        • java程序包
        • jar包
        • 配置文件

        注：如果一个web应用程序编写完毕后，若想被外界访问，需要一个服务器统一管理

  3. 静态web：

    • .htm，html都是网页后缀，如果服务器上存在这些资源，可以通过网络直接读取

    • 存在的缺点：

      1. 无法动态更新，所有用户看到的是同一个页面

        解决：

        1. 轮播图，点击特效：：伪动态
        2. javascript[设计开发中使用最多]
        3. VBScript

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

  4. 动态web：

    • 页面会动态展示，页面效果因人而异

    • 存在的缺点：

      • 如果加入服务器的动态资源出现错误，需要重新编写后台程序，重新发布

        解决：

        • 停机维护

    • 优点：

      • web页面可以动态变化，所有用户看到的画面不同
      • 可以与数据库交互，因此可以进行数据的持久化

2.web服务器

  1. 技术了解：

    1. ASP：微软的，这是国内最早流行的web服务器，在html中嵌入vb脚本，ASP+COM，在ASP开发中，基本上一个页面都有几千行业务代码，页面很乱，因此维护成本极高，ASP中主要使用c#语言。

    2. jsp/servlet：

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

      • sun公司主推的B/S架构
      • 基于java语言
      • 可以承载三高（高并发，高可用，高性能）问题带来的影响
      • 语法像ASP

    3. php：

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

  2. web服务器：

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

    1. IIS：

      • 了解：由微软公司提供的基于运行Microsoft Windows的互联网基本服务。最初是WindowsNT版本的可选包，随后自带在Windows2000、Windows XP XP/191927) Professional和Windows Server 2003一起发布，但在普遍使用的Windows XP Home版本上并没有IIS。

    2. Tomcat：

      了解：

      • Tomcat是Apache 软件基金会（Apache Software Foundation）的Jakarta 项目中的一个核心项目，由Apache、Sun 和其他一些公司及个人共同开发而成。Tomcat 5支持最新的Servlet 2.4 和JSP 2.0 规范。因为Tomcat 技术先进、性能稳定，而且免费，因而深受Java 爱好者的喜爱并得到了部分软件开发商的认可，成为比较流行的Web 应用服务器。
      • Tomcat 服务器是一个免费的开放源代码的Web 应用服务器，属于轻量级应用服务器，在中小型系统和并发访问用户不是很多的场合下被普遍使用，是开发和调试JSP 程序的首选。对于一个javaweb初学者来说，最佳选择
      • 当配置正确时，Apache 为HTML页面服务，而Tomcat 实际上运行JSP 页面和Servlet。另外，Tomcat和IIS]等Web服务器一样，具有处理HTML页面的功能，另外它还是一个Servlet和JSP容器，独立的Servlet容器是Tomcat的默认模式。
      • Tomcat处理静态HTML的能力不如Apache服务器。
      • Tomcat最新版本为10.0.14。

3. Tomcat部署

  1. 官网安装Tomcat

  2. Tomcat启动和配置

    1. tomcat的文件组成：

    2. tomcat启动，关闭：

      开启：startup.bat文件

      关闭：shutdown文件

  3. 配置：

    1. 配置文件：

      在这个配置文件里可以修改端口号，可以修改端口号，也可以修改主机

    2. 拓展：

      面试题：请问你是如何访问网站的！

      1. 输入域名：回车

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

        1. 有：直接返回对应的ip地址，如果这个地址中有我们需要访问的web程序，可以直接访问
        localhost name resolution is handled within DNS itself.
#	127.0.0.1       localhost
#	::1             localhost
127.0.0.1       activate.navicat.com
        1. 没有：去DNS服务器（管理所有域名）找到就返回，没有则返回没找到

  4. 一个web网站结构：

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

4.http

  1. 基础概念：

    1. http：超文本传输协议（Hyper Text Transfer Protocol，HTTP）是一个简单的请求-响应协议，它通常运行在TCP之上。
      • 文本：html等等
      • 超文本：图片，音乐，视频，定位，地图等等
      • 默认端口：80
    2. https：（全称：Hyper Text Transfer Protocol over SecureSocket Layer），是以安全为目标的 HTTP 通道，在HTTP的基础上通过传输加密和身份认证保证了传输过程的安全性 [1] 。HTTPS 在HTTP 的基础下加入SSL，HTTPS 的安全基础是 SSL，因此加密的详细内容就需要 SSL。
      • 默认端口：443

  2. 版本：

    1. HTTP/0.9：0.9协议就是一个交换信息的无序协议，仅仅限于文字，图片是无法显示和处理的。
    2. HTTP/1.0:该协议对每一次请求/响应建立并拆除一次连接
    3. HTTP/1.1:客户与服务器连接后，可以获得多个web资源，不用断开连接
    4. HTTP/2.0：HTTP2.0的前身是HTTP1.0和HTTP1.1

  3. HTTP请求：

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

    请求 URL: wss://cstm.baidu.com/log/index  //请求地址
请求方法: GET //请求方法 post/get
状态代码: 101 Switching Protocols  //状态码

    • 请求行：

      请求方式：POST、GET

      请求的资源：

      协议版本：HTTP/1.1（一般都是）

    • 请求头：

      是客户端发送给服务器端的一些信息，使用键值对表示key：value请求头：

    • 请求体：

      当请求方式是post的时，请求体有请求的参数，格式如下：

      username=zhangsan&password=123

      如果请求方式为get，那么请求参数不会出现在请求体中，会拼接在url地址后面

      http://localhost:8080...?username=zhangsan&password=123

  4. HTTP响应：

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

    Connection: Upgrade //连接
Content-Type: text/plain; charset=utf-8 //类型以及编码

    • 响应行：

      • Http协议：

      • 状态码：

        • 常用的状态码如下：

          200 ：请求成功。

          302 ：请求重定向。

          304 ：请求资源没有改变，访问本地缓存。

          404 ：请求资源不存在。通常是用户路径编写错误，也可能是服务器资源已删除。

          500 ：服务器内部代码错误。通常程序抛异常。

          状态信息：状态信息是根据状态码变化而变化的

    • 响应头：也都是键值对形式，服务器端将信息以键值对的形式返回给客户端

    • 响应体：是服务器回写给客户端的页面正文，浏览器将正文加载到内存，然后解析渲染，显示页面内容

5.Maven

  1. 作用：方便jar包的导入

  2. 核心思想：约定大于配置

  3. 下载安装：

  4. 配置环境变量：

    配置如下：

    • M2_HOME:maven目录下的bin目录

    • MAVEN_HOME:maven的目录

    • 在PATH中配置 %MAVEN_HOME%\bin

  5. 测试配置是否成功

  6. 修改配置文件：

    镜像：mirrors

    • 作用：加速下载
    • 建议使用阿里云镜像国内
    <mirror> 
    <id>alimaven</id> 
    <name>aliyun maven</name> 
    <url>http://maven.aliyun.com/nexus/content/groups/public/</url> 
    <mirrorOf>central</mirrorOf> 
  </mirror>

  7. 配置本地仓库：

    • 注：Maven 仓库有三种类型：
      • 本地（local）：maven 的本地仓库，在安装 Maven 后并不会创建，它是在第一次执行 maven 命令的时候才被创建
      • 中央（central）：Maven 中央仓库是由 Maven 社区提供的仓库，其中包含了大量常用的库。
      • 远程（remote）：如果 Maven 在中央仓库中也找不到依赖的文件，它会停止构建过程并输出错误信息到控制台。为避免这种情况，Maven 提供了远程仓库的概念，它是开发人员自己定制仓库，包含了所需要的代码库或者其他工程中用到的 jar 文件。

    1. 在配置文件配置自己仓库的位置：

  8. 在idea中使用maven：

    !

    注：如果idea和maven版本发生冲突需要重新下载maven进行配置

  9. 在idea中配置maven：

    解决重复配置问题：在idea全局默认配置中改一下

  10. 到这里在idea中配置和使用maven就ok了

  12. pom文件：

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

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

<!--  这里是一开始配置的GAV-->
  <groupId>org.example</groupId>
  <artifactId>javaweb_maven</artifactId>
  <version>1.0-SNAPSHOT</version>
<!--  这是项目打包方式
java打包：jar
javaweb打包：war
-->
  <packaging>war</packaging>

  <!--配置-->
  <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>
      <groupId>com.github.pagehelper</groupId>
      <artifactId>pagehelper-spring-boot-starter</artifactId>
      <version>1.4.2</version>
    </dependency>
  </dependencies>

  <dependencyManagement>
    <dependencies>
      <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-dependencies</artifactId>
        <version>${spring-boot.version}</version>
        <type>pom</type>
        <scope>import</scope>
      </dependency>
    </dependencies>
  </dependencyManagement>

  <!--项目构建使用的东西-->
  <build>
  </build>
</project>

    注1：maven的高级之处在于当你导入一个jar包时，会自动帮助导入相关的jar包

    注2：maven约定大于配置，可能会遇到我们写的配置文件无法被导出或者生效的问题，解决方案：在build标签之中添加一个resource（百度）

  13. maven默认web项目的web.xml的版本问题;

    解决：可以参考tomcat中的web.xml文件

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

  14. maven解决配置文件无法导出或者生效的问题：在pom文件下添加这段代码

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

6.在idea中配置Tomcat

  1. 添加配置：

  2. 找到Tomcat，添加;

  3. 配置Tomcat：

  4. 部署工件(必须：因为项目启动的文件是必须的)

6.Servlet

  1. 简介：servlet由sun公司开发的一门动态web技术，如果想要编写一个servlet程序，那么只需要做两件事：

    • 编写一个类，实现servlet接口
    • 把实现好的类部署到web服务器上

  2. 编写一个简单的servlet：

    1. 首先创建一个javaweb项目：

      1. 方式一：创建一个项目，然后手动创建需要的文件夹比如src

      2. 方式二：创建一个项目，然后右键项目选择添加框架支持选择web application

      3. 拓展：创建一个maven父子工程：

        1. 首先删掉父工程的src目录

        2. 然后创建新的模块

        3. 注：关于父子pom文件中多出来的东西：

          父：

          <modules>
        <module>model_1</module>
        <module>model_2</module>
    </modules>

          子：

          <parent>
        <artifactId>javaweb_study</artifactId>
        <groupId>com.LPJ</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>

    2. 编写一个普通类并实现HttpServlet接口：

      1. 实现HttpServlet接口：

        public class HelloServlet extends HttpServlet

      2. 重写方法：一般而言就是重写doGet（）和doPost两个方法，并且一般我们会在其中一个方法里面直接调用另一个方法，然后将代码写在另一个方法里。

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

    }

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

      3. 配置servlet映射：在web.xml里面注册servlet然同时给该servlet一个访问的地址

        <servlet>
        <servlet-name>helloservlet</servlet-name>
        <servlet-class>HelloServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>helloservlet</servlet-name>
        <url-pattern>/hello</url-pattern>
    </servlet-mapping>

      4. 配置Tomcat

      5. 启动测试

      注：当启动项目时如果不自动跳转网页，那么查看tomcat的部署路径是否正确

  3. servlet原理：

    1. servlet在容器中的执行过程：

      img

    2. servlet的底层：

      本质上，HelloServlet--》HttpServlet--》GenericServlet--》Servlet，ServletConfig

      img

  4. servlet映射：

    1. 一个servlet指定一个路径

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

    2. 一个servlet指定多个路径

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

    3. 一个servlet指定通用路径

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

    4. 默认请求路径:优先级大于index页面

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

    5. 指定后缀：

       <servlet-mapping>
        <servlet-name>helloservlet</servlet-name>
        <url-pattern>*.do</url-pattern><!--注：*前面不能加项目路径，也就是不要加 /-->
    </servlet-mapping>

    注：优先级：确定的路径>含有通配符如*的路径

7.ServletContext

  1. ServletContext

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

    • 共享数据：

      在一个servlet中保存数据可以在另一个servlet中拿到

      ServletContext servletContext = this.getServletContext();//首先获得Context对象
servletContext.setAttribute("username",usernamne);//保存数据
String username = (String)servletContext.getAttribute("username")//获得数据
//注：getAttribute方法返回的是一个Object对象，所以需要强转

    • 获取参数：

      servletContext.getInitParameter("");//根据名字获取参数的值
servletContext.getInitParameterNames();//获取全部参数，返回类型是一个枚举类

    • 请求转发：

      //通过指定路径跳转
servletContext.getRequestDispatcher("/index.jsp").forward(req,resp);
//通过指定名字跳转servlet，注：名字为通过name属性赋值的名字
servletContext.getNamedDispatcher("helloservlet").forward(req,resp);

    • 读取资源文件：

      1. Propertise建立的地点：:

        • java目录下

        • resources目录下

        • 结果：都被保存·到classes文件下，而这个路径我们一般叫做classpath

        • 关于out目录和target目录：

          1. out存放的是该项目下所有Module(模块)的编译结果。
          2. target存放的是单个Module的编译结果。

      2. 读取：

        @WebServlet(value = "/read")
public class Read extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        ServletContext servletContext = this.getServletContext();
        InputStream in=servletContext.getResourceAsStream("/WEB-INF/classes/db.properties");//注：这里路径一定要写对，这里是根据out目录下写的，从根目录开始
        Properties prop=new Properties();
        prop.load(in);
    }
}

8.HttpServletResponse，HttpServletRequest

  1. HttpServletResponse（响应对象）：

    1. 解决浏览器中文乱码：

    req.setCharacterEncoding("utf-8"); //设置编码
    ```

    1. 源码：

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

        getOutputStream();
getWriter();

      2. 一些关于响应信息的方法：

            void sendError(int var1) throws IOException;
    void sendRedirect(String var1) throws IOException;
    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);
    int getStatus();
    String getHeader(String var1);
    Collection<String> getHeaders(String var1);
    Collection<String> getHeaderNames();

      3. 一些常见状态码常量：

            int SC_OK = 200;
    int SC_NOT_MODIFIED = 304;
    int SC_BAD_REQUEST = 400;
    int SC_NOT_FOUND = 404;
    int SC_INTERNAL_SERVER_ERROR = 500;

    2. 常见应用：

      1. 向浏览器输出一些消息

      2. 下载文件

        		//1.获取需要下载的文件的路径
        String realPath = "E:\\word\\javaweb-02-serlvet\\response\\src\\main\\resources\\1.jpg";
        System.out.println("下载文件的路径"+realPath);
        //2.下载的文件名
        String fileName = realPath.substring(realPath.lastIndexOf("\\") + 1);
        //3.想办法让浏览器能够支持（Content-disposition）下载我们需要的东西
        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))>0){
            out.write(buffer,0,len);
        }
        in.close();
        out.close();

      3. 验证码功能：

        1. 前端实现

        2. 后端实现

          public class CodeServlet extends HttpServlet {

    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

        //验证码图片宽和高
        int length = 120;
        int width = 50;

        //画布
        BufferedImage image = new BufferedImage(length,width,BufferedImage.TYPE_INT_RGB);
        //画笔
        Graphics graphics = image.getGraphics();
        //设置画笔为灰色
        graphics.setColor(Color.gray);
        //使用画笔填充矩形边框
        graphics.fillRect(0,0,length,width);
        //验证码的内容，字母和数字
        String[] codes = {"a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r",
                "s","t","u","v","w","x","y","z","A","B","C","D","E","F","G","H","I","J","K","L","M","N",
                "O","P","Q","R","S","T","U","V","W","X","Y","Z","0","1","2","3","4","5","6","7","8","9"};

        //颜色数组
        Color[] colors = {Color.red,Color.yellow,Color.green,Color.cyan,Color.pink,Color.orange,Color.blue};

        //随机数，随机的中字母和数字中获取4个
        Random ran = new Random();
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < 4; i++) {
            //随机的画笔颜色
            graphics.setColor(colors[ran.nextInt(colors.length)]);
            //设置字体
            graphics.setFont(new Font("宋体",Font.BOLD,20+ran.nextInt(20)));
            String str = codes[ran.nextInt(codes.length)];
            //在画布上写上验证码
            graphics.drawString(str,20+i*20,25+ran.nextInt(20));
            sb.append(str);
        }

        HttpSession session = req.getSession();
        session.setAttribute("systemCode",sb.toString());
        System.out.println("系统生成的验证码是:"+sb.toString());

        //生成随机的哦干扰线
        for (int i = 0; i < 6; i++) {
            graphics.setColor(colors[ran.nextInt(colors.length)]);
            graphics.drawLine(ran.nextInt(length),ran.nextInt(width),ran.nextInt(length),ran.nextInt(width));
        }
        //将图片写入到响应对象的输出流
        ImageIO.write(image,"jpg",resp.getOutputStream());
    }
}

      4. 实现重定向（掌握）;

        response.sendRedirect("/m1/first");

      //注：重定向时：
      //如果路径加斜杠，则是相对于http://localhost:8080/的路径
      //如果不加斜杠那么是相对于当前路径

      
5. 重定向和请求转发的区别：

1. 请求转发：
   1. 客户端只发送一次请求到服务器，服务器也只做一次响应给客户端。
   2. 浏览器地址栏只会显示客户端第一次访问的URL，相当于服务器将此次响应交给另一个Servlet处理，但还是当前Servlet。
   3. 请求转发的路径必须是同一个服务器下的地址。
   4. 转发可以携带参数和request作用域的值。
2. 重定向：
   1. 客户端先发送一次请求到服务器，服务器给出响应给客户端告诉其访问另一个url，从而客户端再一次发出请求到服务器。
   2. 客户端地址栏显示第二次请求的url。
   3. 重定向的地址不局限于当前服务器，还可以访问其它url地址。
   4. 重定向不携带上一次请求的参数数据。

  2. HttpServletRequest（请求对象）：用户访问服务器的时候，会产生一个请求信息，这些信息在请求时会被封装到HttpServletRequest类型的对象中，我们可以通过这个对象的方法获得用户的一些请求信息。

    1. 获取请求参数：

      request.getParameter();//获取指定name的参数的值
request.getParameterValues();//获取指定name的参数的值，返回一个字符串数组，比如用于多选框

    2. 请求转发：

      request.getRequestDispatcher("/index.jsp").forward(request,response);

//ServletContext.getRequestDispatcher和ServletRequest.getRequestDispatcher区别：
//前者参数必须以斜杠（/）开始，被解释为相对于当前上下文根（context root）的路径
//后者参数不但可以使相对于上下文根的路径，而且可以是相对于当前Servlet的路径。

    3. 解决前端数据到后端中文乱码：

   ```java
   req.setCharacterEncoding("utf-8");//设置编码

9. Cookie，Session

  1. 会话：客户打开浏览器，然后在浏览器中进行各种操作，再关闭浏览器，中间过程就叫做一个会话

  2. 保存会话的技术：

    1. cookie：

      • 客户端技术

      1. 相关操作：

        1. cookie常用属性及方法

             //属性
    private String name;//名字
    private String value;//值
    private int maxAge = -1;//保存的时间

   //方法
    public Cookie(String name, String value)//构造方法
    String getName()   //用于返回Cookie的名称
    void setValue(String name)    //用于设置Cookie的值
    String getValue()    //用于返回Cookie的值
    void setMaxAge(int expiry)    //用于设置Cookie在浏览器客户端上保存的秒数
    int getMaxAge()     //用于获取Cookie在浏览器客户端上保存的秒数
//注：cookie没有setName方法，通过创建新cookie来变相达到改名

        2. 取到cookie

          request.getCookies();//只能一下获取全部cookie，然后进行遍历

        3. 添加cookie

          Cookie cookie=new Cookie("name","小明"); 
        response.addCookie(cookie);

        4. cookie有效期

          cookie.setMaxAge(0)//不记录cookie
cookie.setMaxAge(-1)//会话级cookie，关闭浏览器失效，不设置时默认为-1
    
//删除cookie
//1.首先创建一个与要删除cookie名字相同的cookie
//2.设置该cookie的有效期为0

        5. cookie存中文乱码问题

          Cookie[] cookies = request.getCookies();
        if(cookies!=null) {
            for (Cookie cookie : cookies) {
                System.out.println(cookie.getName()+":"+ URLDecoder.decode(cookie.getValue(),"UTF-8"));//取的时候解码
            }
        }
        Cookie cookie=new Cookie("name", URLEncoder.encode("小明","UTF-8"));//存储的时候编码
        response.addCookie(cookie);

          注1：请求信息获得cookie，通过响应给服务器添加cookie

          注2：一个cookie只能存一个信息

          注3：一个web站点可以给浏览器发送多个cookie，最大存放20个

          注4：cookie大小限制为4kb

          注5：浏览器cookie上限w为300个

    2. session（重点）：

      • 服务器技术

      • 一个session独占一个浏览器。浏览器没关，那么这个session则一直存在

      1. 常用属性及方法：

            long getCreationTime();//获取创建时间
    String getId();//得到session的id
    long getLastAccessedTime();//返回session最后的访问时间
    ServletContext getServletContext();//得到servlet上下文对象
    void setMaxInactiveInterval(int var1);//设置最大时间
    int getMaxInactiveInterval();//得到最大时间
    void invalidate();//注销session
    boolean isNew();//判断该session是否已经存在
    Object getAttribute(String var1);//获取存储在session中的指定的属性的值
    Enumeration<String> getAttributeNames();//获取session中的全部存储的属性的名字
    void setAttribute(String var1, Object var2);//设置指定属性新的值
    void removeAttribute(String var1);//移除指定的属性

      2. 获取session：

            request.getSession();//通过请求对象获得

      3. 常用存储获取信息：

            Object getAttribute(String var1);//获取存储在session中的指定的属性的值
    void setAttribute(String var1, Object var2);//设置指定属性新的值

      4. 会话自动过期：web.xml配置

        <session-config>
    <!--注：是以分钟为单位-->
    <session-timeout>15</session-timeout>
</session-config>

        注：在用户第一次访问服务器的时候，服务器会给用户发送一个session的id，然后将这个id以cookie的形式保存在客户端，以后用户访问的时候都会携带这个cookie

    3. cookie和session区别：

      1. 从存储角度来说：

        • Cookie的数据保存在客户端且保存数据有限；

        • Session的数据保存在服务器；

      2. 从安全性角度来说：

        • Cookie的数据保存在客户端容易被篡改、删除、禁用；
        • Session的数据保存在服务器，返还给客户端的是一个id，安全性比较高；

10.JSP

  1. 什么是jsp：全称JavaServer Pages是一种动态网页技术标准。JSP部署于网络服务器上，可以响应客户端发送的请求，并根据请求内容动态地生成HTML、XML或其他格式文档的Web网页，然后返回给请求者。

  2. jsp原理：

    • jsp其实就是一种特殊的Servlet，当jsp页面第一次被访问时，服务器会把jsp编译成java文件（这个java其实是一个Servlet类），然后再把Java编译成.class，然后再创建该类对象，最后调用它的service()方法

      • jsp在编译为servlet类过程中的一些操作：

        //首先会继承一个HttpJspBase
public final class test_jsp extends org.apache.jasper.runtime.HttpJspBase implements org.apache.jasper.runtime.JspSourceDependent{
    
    //jsp的内置对象
    final javax.servlet.jsp.PageContext pageContext;//页面上下文
    javax.servlet.http.HttpSession session= null;//session
    final javax.servlet.ServletContext application;//相当于servletContext，即servlet上下文
    final javax.servlet.ServletConfig config;//配置
    javax.servlet.jsp.JspWriter out= null; //输出对象，PrintWriter
    final java.lang.Object page = this;//当前页
    HttpServletRequest request;//请求
    HttpServletResponse response;//响应
    
    //页面输出之前对象进行初始化
    response.setContentType("text/html;charset=UTF-8");//设置页面为html文本，编码为utf-8
    pageContext= _jspxFactory.getPageContext(this, request, response,null, true, 8192, true);
    application=pageContext.getServletContext();
    config=pageContext.getServletConfig();
    session=pageContext.getSession();    
    out=pageContext.getOut();
}

    • 当第二次请求同一个jsp时，就会直接调用service()方法，在tomcat的work目录下可以找到jsp对应的.java源代码。

  3. jsp与html和servlet的比较：

    • Servet：
      缺点：不适合设置html响应体，需要大量的response.getWriter().print("<html>");
      优点：动态资源，可以编程
    • html：
      缺点：html是静态页面，不能包含动态信息
      优点：不用为输出html标签而发愁
    • jsp：
      优点：在原有的html基础上添加java脚本，构成jsp页面

  4. jsp基础语法：

    1. <%…%>:java代码片段（常用），用于定义0~N条Java语句。方法里面能放什么他就能放什么。

        <%
    int i=10;
    System.out.println(i);
  %>
<%--控制台输出i的值--%>

    2. <%=…%>:java表达式，用于输出（常用），用于输出一条表达式（或变量）的结果。
      输出语句里面能放什么他就能放什么。

         <%
    request.setCharacterEncoding("utf-8");
    response.setCharacterEncoding("utf-8");
    int i=10;
    System.out.println(i);
    request.setAttribute("name","小明");
  %>
  <%="name:"+request.getAttribute("name")%>

<%--页面显示：name：小明--%>

    3. <%!..%>:声明，用来创建类的成员变量和成员方法（基本不用）。类里面能放什么他就可以放什么。注：在jsp声明中的代码会在编译时放到java类中，而其他部分的代码会被放到_jspService方法中

        <%!
    private String name1="123";
  %>

    4. <%----%>：注释，注：jsp的注释不会在客户端显示，而html的会

        <%--jsp注释--%>
  <!--html注释-->

  5. JSP指令

    1. page：

      1. 自定义异常页面：

        1. 方式一：局部，在jsp里面设置，优先级大于全局

          <%@ page errorPage="error500.jsp" %>
<!--只要该页面发生错误就会跳转到error500.jsp页面-->

        2. 方式二：全局，在web.xml里面配置

              <error-page>
        <error-code>404</error-code>
        <location>/error404.jsp</location><!--必须一斜杠开头，即相对于web目录的路径-->
    </error-page>

    <error-page>
        <error-code>500</error-code>
        <location>/error500.jsp</location>
    </error-page>

      2. 导包：

        <%@ page import="javafx.util.Builder" %>

    2. include:静态包含页面

      <%@ include file="error404.jsp"%>

      注：将其他页面包含在调用页面，本质上是将其他页面的代码拼接到调用页面，在编译阶段就把被包含的文件内嵌到包含文件中，形成一个文件然后进行编译运行，所以包含文件和被包含文件不能同名的变量和方法

  6. JSP内置对象及作用域:

    1. 九大内置对象：

      1. page页面对象：

        • page对象代表当前JSP页面，是当前JSP编译后的Servlet类的对象。相当于this，几乎不用

      2. config配置对象：

      3. request请求对象：

        • request对象的作用域为一次请求(一次请求可能包含一个页面，也可能包含多个页面)。

      4. response响应对象

        • response对象其作用域只在JSP页面内有效。

    2. session会话对象

      1. application全局对象
      • application对象生命周期更长，类似系统的 "全局变量"ServletContext。
      1. out输出对象

    3. pageContext页面上下文对象

      • pageContext 对象的作⽤是取得任何范围的参数，通过它可以获取 JSP⻚⾯的out、request、reponse、session、application 等对象。pageContext对象的创建和初始化都是由容器来完成的，在JSP⻚⾯中可以直接使⽤pageContext对象。

        • 通过该对象可以取得任何作用域范围类的参数，寻找范围可以指定，如果不指定那么从page到application小到大的范围找，同时也可以在任何范围内存参数，如果不知道则范围默认是页面

          public void setAttribute(String name, Object attribute)
public void setAttribute(String name, Object o, int scope)
    
public Object getAttribute(String name)
public Object getAttribute(String name, int scope)

//参数scope的取值：
//public static final int PAGE_SCOPE = 1;
//public static final int REQUEST_SCOPE = 2;
//public static final int SESSION_SCOPE = 3;
//public static final int APPLICATION_SCOPE = 4;

        • 使用pageContext请求转发

          pageContext.forward("index.jsp");//无论是使用pageContext还是request进行转发，路径不加斜杠都是相对于当前所在位置

      1. exception异常对象

        • 表示发生异常对象，类型 Throwable。作用域：page。

    4. 四大作用域：

      1. page: 页面作用域，变量只能在当前页面上生效。
      2. request：变量能在一次请求中生效，一次请求可能包含一个页面，也可能包含多个页面，不同页面的跳转中都可以使用该变量
      3. session：代表变量能在一次会话中生效，所谓当前会话，就是指从用户打开浏览器开始，到用户关闭浏览器这中间的过程。
      4. application：不同的会话也能够访问同一个application作用域里的东西

  7. JSP标签，JSTL标签，EL表达式

    1. EL表达式：$

      • 获取数据：从四大作用域里获取，${pageScope.xxx}、${reqeustScope.xxx}、${sessionScope.xxx}、$

      • 执行运算

      • 获取web的常用对象：

        pageContext:（pageContext.request.xxxxx方法）
pageScope：获取指定域下的名称的数据
requestScope：获取指定域下的名称的数据
sessionScope:获取指定域下的名称的数据
applicationScope:获取指定域下的名称的数据
param:在页面中接收请求参数（接收一个名称对应一个值参数）
paramValues：在页面中接收请求参数（接收一个名称对应多个值参数）
cookie：访问cookie的名称和值（${cookie.key.name} ${cookie.key.value}）

    2. JSP标签：

      1. jsp:include（动态包含）：将另一个文件的内容包含到当前的JSP页面内

         <jsp:include page="url" flush="false|true"/>
<!-- page：用于指定被包含文件的相对路径-->
<!-- flush：可选参数，用于设置是否刷新缓冲区。默认值为false;-->

<!-- 
注：
JSP静态include和动态include的区别：
1.静态include在编译阶段就把被包含的文件内嵌到包含文件中，形成一个文件然后进行编译运行，所以包含文件和被包含文件不能同名的变量和方法；而动态包含在编译时包含文件和被包含文件是单独编译的
2.，静态include编译完成后只会生成一个单独的.class文件，因为在编译阶段会融合成一个文件再进行编译，而动态include则会对每个.jsp文件生成一个.class文件，每个.jsp文件单独进行编译。
-->

      2. jsp:forward：请求转发

        <jsp:forward page="">
     <jsp:param name="" value=""/>
</jsp:forward>
<!--可以在里面使用jsp:param标签传递参数-->

      3. jsp:param：可以作为其他标签的子标签，为其他标签传递参数

         <jsp:param name="paramName"value="paramValue" />
<!-- name：指定参数的名称
     value：设置对应的参数值-->

      4. jsp:useBean： 用于在JSP页面中创建一个JavaBean实例，并通过属性的设置将此实例存放在JSP指定范围内

        <jsp:useBean id="" scope="" class="" type="" beanName=""></jsp:useBean>
<!-- id属性:定义一个变量名，javaBean的唯一标识
     scope属性:设置JavaBean的作用域，有四种范围 page、request、session、application。默认为 page
     class属性:指定JavaBean的完整类名。和beanName属性不能同时存在
     type属性:指定id属性所定义的变量类型
     beanName属性:指定JavaBean的完整类名。和class属性不能同时存在 -->

      5. jsp:setProperty： 用于对JavaBean中的属性赋值，但JavaBean的属性要提供相应的setXXX()方法。通常与jsp:useBean标签一起使用

        <jsp:setProperty name="" property="" value=""></jsp:setProperty>
<!--   name属性：指定JavaBean的引用名称 
       property属性：指定JavaBean中的属性名，此属性是必须的，其取值有两种，分别为“*”、“JavaBean的属性名称” 
       value属性：指定一个属性的值-->

      6. jsp:getProperty：用于获取JavaBean中的属性值，但要求JavaBean的属性必须具有相应getXXX()方法。

        <jsp:getProperty name="" property=""/>
<!--  name：指定存在某一范围的JavaBean实例引用。 
      property：指定JavaBean的属性名称-->

    3. JSTL:

      1. 根据JSTL标签所提供的功能，可以将其分类：

        • 核心标签（掌握部分）
        • 格式化标签
        • SQL 标签
        • XML 标签
        • JSTL 函数
        • 自定义标签

      2. maven导入依赖：

                <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>
        <dependency>
            <groupId>jstl</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>
        <dependency>
            <groupId>taglibs</groupId>
            <artifactId>standard</artifactId>
            <version>1.1.2</version>
        </dependency>
<!--
注:
如果报错：无法在web.xml或使用此应用程序部署的jar文件中解析绝对uri：[http://java.sun.com/jsp/jstl/core]
解决方案：在Tomcat的lib包中手动加入standard-1.1.2.jar和jstl-1.2.jar两个包即可。
-->

      3. 核心标签库的使用：

        1. 引入核心标签库：

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

        2. 常用标签的使用：

          1. c:set

            <!--标签用于设置变量值和对象属性。-->
<c:set var="salary" scope="session" value="${2000*2}"/>

<!--var:变量名
    scope：作用域
    value：值-->

          2. c:out

            <!--标签用来显示一个表达式的结果-->
<c:out value="<string>" default="<string>"/>

<!--value：输出的值
    default：默认值，或者使用主体中的内容为默认值-->

          3. c:if

            <!--标签判断表达式的值，如果表达式的值为 true 则执行其主体内容。-->
<c:set var="salary" scope="session" value="${2000*2}"/>
<c:if test="${salary > 2000}">
   <p>我的工资为: <c:out value="${salary}"/><p>
</c:if>
<!--test:条件
    var:存储条件结果的变量
    scope:var作用域-->

          4. c:chooes

            <c:set var="salary" scope="session" value="${2000*2}"/>
<c:choose>
    <c:when test="${salary <= 0}">
       太惨了。
    </c:when>
    <c:when test="${salary > 1000}">
       不错的薪水，还能生活。
    </c:when>
    <c:otherwise>
        什么都没有。
    </c:otherwise>
</c:choose>

<!--
<c:choose>标签没有属性。
<c:when>标签只有一个属性
test:条件
<c:otherwise>标签没有属性。
-->

          5. c:forEach

            <c:forEach
    items="<object>"
    begin="<int>"
    end="<int>"
    step="<int>"
    var="<string>"
    varStatus="<string>">
</c:forEach>
<!--
items:要被循环的信息
begin:开始的元素（0=第一个元素，1=第二个元素）
end:最后一个元素
step:每一次迭代的步长
var:代表当前条目的变量名称,可以通过${}使用该变量
varStatus:代表循环状态的变量名称
-->

11.JavaBean

  1. 本质：一个类
  2. 特定写法：
    1. 必须有一个无参构造函数
    2. 属性必须私有化
    3. 属性必须有对应的get/set方法
  3. 作用：一般用来与数据库中的表进行映射，一个JavaBean也就是实体类映射一张表

12.MVC三层架构

  1. MVC：

    1. Model：模型，相当于实体类，其分为两类： 一类称为数据承载 Bean：实体类，专门用户承载业务数据的，如 Student、User 等 一类称为业务处理 Bean：指 Service 或 Dao 对象，专门用于处理用户提交请求的。
    2. View（Jsp）：视图，与用户进行交互
    3. Controller（servlet）：控制器，用于接收并且处理用户的请求，然后响应给用户

  2. 三层架构：

    1. 视图层（View）：由于接收用户的请求并将信息展示给客户
    2. 服务层（Service）：由于处理系统的业务逻辑
    3. 持久层（Dao）：与数据库进行对接，对数据进行读取和一个持久化的操作

13.过滤器Filter

在请求服务之前可以使用过滤器进行过滤

  1. Filter底层：与servlet类似，创建一个Filter就是继承HttpFilter类，HttpFilter继承GenericFilter类，然后GenericFilter实现Filter接口，并且Filter的方法没有servlet那么多，重要的是doFilter(ServletRequest req, ServletResponse res, FilterChain chain)方法，该方法有三个参数，chain对象只有一个方法，即doFilter（ServletRequest req, ServletResponse res），作用相当于放行，放行到下一个过滤器或者servlet。

  2. 过滤器的执行顺序：

    1. 注解的方式：按照过滤器的name比较字符串的值大小执行，值小的先执行
    2. web.xml配置：按照配置的顺序执行，写在上边的先执行
    3. 注：过滤器的执行是一个循环链的过程。

  3. 常用场景：

    • 登录验证

      1. 编写监听器
      2. 配置监听器

    • 处理乱码

      1. 编写过滤器

        public class filter extends HttpFilter {
    @Override
    protected void doFilter(HttpServletRequest req, HttpServletResponse res, FilterChain chain) throws IOException, ServletException {
        req.setCharacterEncoding("utf-8");
        res.setCharacterEncoding("utf-8");
        res.setContentType("text/html;character=utf-8");
        chain.doFilter(req,res);
    }
}

      2. 配置过滤器

            <servlet>
        <servlet-name>test</servlet-name>
        <servlet-class>testServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>test</servlet-name>
        <url-pattern>/test2</url-pattern>
    </servlet-mapping>

    <filter>
        <filter-name>character</filter-name>
        <filter-class>filter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>character</filter-name>
        <url-pattern>/test2</url-pattern>
    </filter-mapping>

14.监听器（了解）

posted on 2022-07-24 14:10  小也取不到名字  阅读(143)  评论(0)    收藏  举报