javaweb笔记

JavaWeb

Java Web

1、基本概念

1.1、前言

web开发:

  • web,网页的意思

  • 静态web

  1. html,css
  2. 提供给所有人看的数据始终不会发生变化!
  • 动态web
  1. 淘宝
  2. 提供给所有人看的数据始终会发生变化,每个人在不同的时间,不同的地点看到的信息各不相同!
  3. 技术栈: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

  • *.html,这些都是网页的后缀,如果服务器上一直存在这些东西,我们就可以直接进行读取、通信
  • 静态Web存在的缺点

Web页面无法动态更新,所有用户看到的都是同一个页面

  1. 轮播图,点击特效,伪动态
  2. Javascript(实际开发中,它用的最多)
  3. VBScript

它无法和数据库交互(数据无法持久化,用户无法交互)

1.4、动态Web

页面会动态展示:“Web的页面展示的效果会因人而异”。

缺点:

  • 假如服务器的动态Web资源出现了错误,我们需要重新编写我们的后台程序,重新发布;(停机维护)

优点:

  • Web页面可以动态更新,所有用户看到的都是同一个页面
  • 它可以和数据库交互(数据持久化,注册,商品信息,用户信息…)

2、web服务器

2.1、技术讲解

ASP

  • 微软:国内最早流行的就是ASP
  • 在html中嵌入了VB的脚本,ASP+COM;
  • 在ASP开发中,基本一个页面都有几千行的业务代码,页面极其换乱
  • 维护成本高!
  • C#
  • IIS

JSP/Servlet:

B/S:浏览和服务器

C/S:客户端和服务器

  • sun公司主推的B/S架构
  • 基于java语言的(所有的大公司,或者一些开源的组件,都是用Java写的)
  • 可以承载三高问题带来的影响(高并发、高可用、高性能)
  • 语法像ASP,ASP—>JSP,加强市场强度;

PHP

  • PHP开发速度很快,功能很强大,跨平台,代码很简单(70%,WP)

  • 无法承载大访问量的情况(局限性)

2.2、Web服务器

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

IIS

微软的:ASP…,Window中自带的

Tomcat:

面向百度编程

Tomcat是Apache 软件基金会(Apache Software Foundation)的Jakarta 项目中的一个核心项目,最新的Servlet 和JSP 规范总是能在Tomcat 中得到体现,Tomcat 5支持最新的Servlet 2.4 和JSP 2.0 规范。因为Tomcat 技术先进、性能稳定,而且免费,因而深受Java 爱好者的喜爱并得到了部分软件开发商的认可,成为目前比较流行的Web 应用服务器。

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

诀窍是,当配置正确时,Apache 为HTML页面服务,而Tomcat 实际上运行JSP 页面和Servlet。目前Tomcat最新版本为10.0.5**。**

1.安装or解压

2.了解配置文件及目录结构

3.这个东西的作用

3、Tomcat

3.1、安装Tomcat

3.2、Tomcat启动和使用

访问测试:http://localhost:8080/

可能遇到的问题:

1、Java环境没有配置

2、闪退问题:需要配置兼容性

3、乱码问题:配置文件中设置

3.3、配置

可以配置的端口号

tomcat的默认端口号为:8080

mysql:3306

http:80

https:443

<Connector port="8081" protocol = "HTTP/1.1"
           connectTimeout="20000"
           redirectPort="8443" />

可以配置主机的名称

默认的主机名为:localhost->127.0.0.1

默认网站应用存放的位置为:webapps

<Host name="www.qinjiang.com" appBase="webapps"
    unpackWARs="true" autoDeploy="true">

高难度面试题:

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

1、输入一个域名;回车

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

有:直接返回对应的ip地址,这个地址中,有我们可以访问的web程序,可以直接访问

127.0.0.1             www.qinjiang.com

没有:去DNS服务器找,找到的话就返回,找不到就返回找不到

3、 可以配置一下环境变量(可选性)

3.4、发布一个web网站

将自己写的网站,放到服务器(Tomcat)中指定的web应用的文件夹(webapps)下,就可以访问了网站应该有的结构

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

HTTP协议:面试

Maven:构建工具

  • Maven安装包

Servlet入门

  • HelloWorld!
  • Servlet配置
  • 原理

4、Http

4.1什么是http?

超文本传输协议(Hyper Text Transfer Protocol,HTTP)是一个简单的请求-响应协议,它通常运行在TCP之上。

  • 文本:html、字符串,…
  • 超文本:图片,音乐,视频,定位,地图…
  • 80

HTTPS:安全的

  • 443

4.2、两个时代

  • http1.0
  1. HTTP/1.0:客户端可以个web服务器连接,只能获得一个web资源,断开连接
  • http2.0
  1. HTTP/1.1:客户端可以个web服务器连接,可以获得多个web资源。

4.3、Http请求

  • 客户端…发请求(Request)…服务器

百度:

Request URL: https://www.baidu.com/    请求地址
Request Method:GET   get方法/post方法
Status Code:200 OK   状态码:200  
Remote(远程) Address:14.215.177.39.443

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

1.请求行

  • 请求行中的请求方式:GET
  • 请求方式:Get/Post,Head,Delete,PUT,TRACT…

get:请求能够携带的参数比较少,大小有限制,会在浏览器的URL地址栏显示数据内容,不安全,但高效

post:请求能够携带的参数没有限制,大小没有限制,不会在浏览器的URL地址栏显示数据内容,安全,但不高效

2.消息头

Accept:告诉浏览器,它所支持的数据类型
Accept-Encoding  支持哪种编码格式  GBK   UTF-8  GB2312   ISO8859-1
Accept--Language:告诉浏览器它的语言环境
Cache-Control:缓存控制
Connection:告诉浏览器,请求完成时,断开还是保持连接
HOST:主机

4.4、Http响应

  • 服务器…响应…客户端

百度:

Cache-Control:private    缓存控制
Connection:Keep-Alive    连续
Content-Encoding:gzip    编码
Content-Type:text/html   类型

1.响应体

Accept:告诉浏览器,它所支持的数据类型
Accept-Encoding  支持哪种编码格式  GBK   UTF-8  GB2312   ISO8859-1
Accept--Language:告诉浏览器它的语言环境
Cache-Control:缓存控制
Connection:告诉浏览器,请求完成时,断开还是保持连接
HOST:主机
Refrush:告诉客户端,多久刷新一次
Location:让网页重新定位;

2.响应状态码(重点)

200:请求响应成功

3**:请求重定向

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

4**:找不到资源 404

  • 资源不存在;

5**:服务器代码错误 500 502(网关错误)

常见面试题:

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

5、Maven

1、在javaweb开发中,需要使用大量的jar包,需要手动导入

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

由此,Maven诞生了!

5.1、Maven项目架构管理工具

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

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

  • 有约束,不要去违反

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

5.2、下载安装Maven

官网:Maven – Available Plugins (apache.org)

下载完成后,解压即可;

友情建议:电脑上面所有环境都放在同一个文件夹下

5.3、配置环境变量

在我们的系统环境变量中

配置如下配置:

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

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

5.4、阿里云镜像

  • 镜像:mirrors

作用:加速我们的下载

打开 Maven 的配置文件(windows机器一般在maven安装目录的conf/settings.xml),在标签中添加 mirror 子节点:

<mirror>
    <id>aliyunmavenid>
    <mirrorOf>*mirrorOf>
    <name>阿里云公共仓库name>
    <url>https://maven.aliyun.com/repository/publicurl>
mirror>

5.5、本地仓库

在本地的仓库,远程仓库;

建立一个仓库:

<localRepository>E:\apache-maven-3.8.2\maven-repolocalRepository>

5.6、在IDEA中使用Maven

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

5.8、标记文件夹功能

5.9、在IDEA中配置Tomcat

5.10、pom文件

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




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

  <groupId>com.kuanggroupId>
  <artifactId>javaweb-01-mavenartifactId>
  <version>1.0-SNAPSHOTversion>
  
  <packaging>warpackaging>

  
  <properties>
    
    <project.build.sourceEncoding>UTF-8project.build.sourceEncoding>
    
    <maven.compiler.source>1.7maven.compiler.source>
    <maven.compiler.target>1.7maven.compiler.target>
  properties>

  <dependencies>
    
    <dependency>
      <groupId>junitgroupId>
      <artifactId>junitartifactId>
      <version>4.11version>
      <scope>testscope>
    dependency>
  dependencies>

  
  <build>
    <finalName>javaweb-01-mavenfinalName>
    <pluginManagement>
      <plugins>
        <plugin>
          <artifactId>maven-clean-pluginartifactId>
          <version>3.1.0version>
        plugin>
        
        <plugin>
          <artifactId>maven-resources-pluginartifactId>
          <version>3.0.2version>
        plugin>
        <plugin>
          <artifactId>maven-compiler-pluginartifactId>
          <version>3.8.0version>
        plugin>
        <plugin>
          <artifactId>maven-surefire-pluginartifactId>
          <version>2.22.1version>
        plugin>
        <plugin>
          <artifactId>maven-war-pluginartifactId>
          <version>3.2.2version>
        plugin>
        <plugin>
          <artifactId>maven-install-pluginartifactId>
          <version>2.5.2version>
        plugin>
        <plugin>
          <artifactId>maven-deploy-pluginartifactId>
          <version>2.8.2version>
        plugin>
      plugins>
    pluginManagement>
  build>
project>

<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.0modelVersion>

    <groupId>com.kuanggroupId>
    <artifactId>javaweb-01-maven02artifactId>
    <version>1.0-SNAPSHOTversion>

    <dependencies>
        <dependency>
            <groupId>junitgroupId>
            <artifactId>junitartifactId>
            <version>4.11version>
            <scope>testscope>
        dependency>

        
        
        <dependency>
            <groupId>org.springframeworkgroupId>
            <artifactId>spring-webmvcartifactId>
            <version>5.3.9version>
        dependency>

    dependencies>

project>

maven由于他的约定大于配置,我们之后可以能遇到我们写的配置文件,无法被导出或者生效的问题,解决方案:


<build>
    <resources>
        <resource>
            <directory>src/main/resourcesdirectory>
            <excludes>
                <exclude>**/*.propertiesexclude>
                <exclude>**/*.xmlexclude>
            excludes>
            <filtering>falsefiltering>
        resource>
        <resource>
            <directory>src/main/javadirectory>
            <includes>
                <include>**/*.propertiesinclude>
                <include>**/*.xmlinclude>
            includes>
            <filtering>falsefiltering>
        resource>
    resources>
build>

5.11、idea操作

Maven中jar包的联系关联

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-C4l06815-1636270083112)(C:/Users/lei/AppData/Roaming/Typora/typora-user-images/image-20210912174218564.png)]

5.12、解决遇到的问题

  1. Maven 3.6.2

    解决方法:降级为3.6.1

  2. Tomcat闪退

  3. IDEA中每次都要重复配置Maven
    在IDEA中的全局默认配置中去配置

  4. Maven项目中Tomcat无法配置

  5. maven默认web项目中的web.xml版本问题

  6. 替换为webapp4.0版本和tomcat一致

    
    <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>
    
  7. Maven仓库的使用

    地址:https://mvnrepository.com/

6、Servlet

6.1、Servlet简介

  • Servlet就是sun公司开发动态web的一门技术
  • Sun在这些API中提供一个接口叫做:Servlet,如果你想开发一个Servlet程序,只需要完成两个小步骤:
    • 编写一个类,实现Servlet接口
    • 把开发好的Java类部署到web服务器中。

把实现了Servlet接口的Java程序叫做,Servlet

6.2、HelloServlet

Serlvet接口Sun公司有两个默认的实现类:HttpServlet,GenericServlet

  1. 构建一个普通的Maven项目,删掉里面的src目录,以后我们的学习就在这个项目里面建立Moudel;这个空的工程就是Maven主工程;

  2. 关于Maven父子工程的理解:

    父项目中会有

        <modules>
            <module>servlet-01module>
        modules>
    

    子项目会有

        <parent>
            <artifactId>javaweb-02-servletartifactId>
            <groupId>com.kuanggroupId>
            <version>1.0-SNAPSHOTversion>
        parent>
    

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

    son extends father
    
  3. Maven环境优化

    1. 修改web.xml为最新的
    2. 将maven的结构搭建完整
  4. 编写一个Servlet程序

    1. 编写一个普通类

    2. 实现Servlet接口,这里我们直接继承HttpServlet

      public class HelloServlet extends HttpServlet {
          
          //由于get或者post只是请求实现的不同的方式,可以相互调用,业务逻辑都一样;
          @Override
          protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
              //ServletOutputStream outputStream = resp.getOutputStream();
              PrintWriter writer = resp.getWriter(); //响应流
              writer.print("Hello,Serlvet");
          }
      
          @Override
          protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
              doGet(req, resp);
          }
      }
      
      
  5. 编写Servlet的映射

    为什么需要映射:我们写的是JAVA程序,但是要通过浏览器访问,而浏览器需要连接web服务器,所以我们需要再web服务中注册我们写的Servlet,还需给他一个浏览器能够访问的路径;

        
        <servlet>
            <servlet-name>helloservlet-name>
            <servlet-class>com.kuang.servlet.HelloServletservlet-class>
        servlet>
        
        <servlet-mapping>
            <servlet-name>helloservlet-name>
            <url-pattern>/hellourl-pattern>
        servlet-mapping>
    
    
  6. 配置Tomcat

    注意:配置项目发布的路径就可以了

  7. 启动测试,OK!

6.3、Servlet原理

Servlet是由Web服务器调用,web服务器在收到浏览器请求之后,会:

6.4、Mapping问题

  1. 一个Servlet可以指定一个映射路径

        <servlet-mapping>
            <servlet-name>helloservlet-name>
            <url-pattern>/hellourl-pattern>
        servlet-mapping>
    
  2. 一个Servlet可以指定多个映射路径

        <servlet-mapping>
            <servlet-name>helloservlet-name>
            <url-pattern>/hellourl-pattern>
        servlet-mapping>
        <servlet-mapping>
            <servlet-name>helloservlet-name>
            <url-pattern>/hello2url-pattern>
        servlet-mapping>
        <servlet-mapping>
            <servlet-name>helloservlet-name>
            <url-pattern>/hello3url-pattern>
        servlet-mapping>
        <servlet-mapping>
            <servlet-name>helloservlet-name>
            <url-pattern>/hello4url-pattern>
        servlet-mapping>
        <servlet-mapping>
            <servlet-name>helloservlet-name>
            <url-pattern>/hello5url-pattern>
        servlet-mapping>
    
    
  3. 一个Servlet可以指定通用映射路径

        <servlet-mapping>
            <servlet-name>helloservlet-name>
            <url-pattern>/hello/*url-pattern>
        servlet-mapping>
    
  4. 默认请求路径

        
        <servlet-mapping>
            <servlet-name>helloservlet-name>
            <url-pattern>/*url-pattern>
        servlet-mapping>
    
  5. 指定一些后缀或者前缀等等….

    
    <servlet-mapping>
        <servlet-name>helloservlet-name>
        <url-pattern>*.qinjiangurl-pattern>
    servlet-mapping>
    
  6. 优先级问题
    指定了固有的映射路径优先级最高,如果找不到就会走默认的处理请求;

    
    <servlet>
        <servlet-name>errorservlet-name>
        <servlet-class>com.kuang.servlet.ErrorServletservlet-class>
    servlet>
    <servlet-mapping>
        <servlet-name>errorservlet-name>
        <url-pattern>/*url-pattern>
    servlet-mapping>
    
    

6.5、ServletContext

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

1、共享数据

我在这个Servlet中保存的数据,可以在另外一个servlet中拿到;

public class HelloServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        
        //this.getInitParameter()   初始化参数
        //this.getServletConfig()   Servlet配置
        //this.getServletContext()  Servlet上下文
        ServletContext context = this.getServletContext();

        String username = "秦疆"; //数据
        context.setAttribute("username",username); //将一个数据保存在了ServletContext中,名字为:username 。值 username

    }

}

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

        resp.setContentType("text/html");
        resp.setCharacterEncoding("utf-8");
        resp.getWriter().print("名字"+username);

    }

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

    
        hello
        com.kuang.servlet.HelloServlet
    
    
        hello
        /hello
    


    
        getc
        com.kuang.servlet.GetServlet
    
    
        getc
        /getc
    

测试访问结果;

2、获取初始化参数

    
    <context-param>
        <param-name>urlparam-name>
        <param-value>jdbc:mysql://localhost:3306/mybatisparam-value>
    context-param>
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    ServletContext context = this.getServletContext();
    String url = context.getInitParameter("url");
    resp.getWriter().print(url);
}

3、请求转发

@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    ServletContext context = this.getServletContext();
    System.out.println("进入了ServletDemo04");
    //RequestDispatcher requestDispatcher = context.getRequestDispatcher("/gp"); //转发的请求路径
    //requestDispatcher.forward(req,resp); //调用forward实现请求转发;
    context.getRequestDispatcher("/gp").forward(req,resp);
}

4、读取资源文件

Properties

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

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

思路:需要一个文件流;

username=root12312
password=zxczxczxc
public class ServletDemo05 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

        InputStream is = this.getServletContext().getResourceAsStream("/WEB-INF/classes/com/kuang/servlet/aa.properties");

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

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

    }

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

访问测试即可ok;

6.6、HttpServletResponse

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

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

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 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);

响应的状态码

    int SC_CONTINUE = 100;
    int SC_SWITCHING_PROTOCOLS = 101;
    int SC_OK = 200;
    int SC_CREATED = 201;
    int SC_ACCEPTED = 202;
    int SC_NON_AUTHORITATIVE_INFORMATION = 203;
    int SC_NO_CONTENT = 204;
    int SC_RESET_CONTENT = 205;
    int SC_PARTIAL_CONTENT = 206;
    int SC_MULTIPLE_CHOICES = 300;
    int SC_MOVED_PERMANENTLY = 301;
    int SC_MOVED_TEMPORARILY = 302;
    int SC_FOUND = 302;
    int SC_SEE_OTHER = 303;
    int SC_NOT_MODIFIED = 304;
    int SC_USE_PROXY = 305;
    int SC_TEMPORARY_REDIRECT = 307;
    int SC_BAD_REQUEST = 400;
    int SC_UNAUTHORIZED = 401;
    int SC_PAYMENT_REQUIRED = 402;
    int SC_FORBIDDEN = 403;
    int SC_NOT_FOUND = 404;
    int SC_METHOD_NOT_ALLOWED = 405;
    int SC_NOT_ACCEPTABLE = 406;
    int SC_PROXY_AUTHENTICATION_REQUIRED = 407;
    int SC_REQUEST_TIMEOUT = 408;
    int SC_CONFLICT = 409;
    int SC_GONE = 410;
    int SC_LENGTH_REQUIRED = 411;
    int SC_PRECONDITION_FAILED = 412;
    int SC_REQUEST_ENTITY_TOO_LARGE = 413;
    int SC_REQUEST_URI_TOO_LONG = 414;
    int SC_UNSUPPORTED_MEDIA_TYPE = 415;
    int SC_REQUESTED_RANGE_NOT_SATISFIABLE = 416;
    int SC_EXPECTATION_FAILED = 417;
    int SC_INTERNAL_SERVER_ERROR = 500;
    int SC_NOT_IMPLEMENTED = 501;
    int SC_BAD_GATEWAY = 502;
    int SC_SERVICE_UNAVAILABLE = 503;
    int SC_GATEWAY_TIMEOUT = 504;
    int SC_HTTP_VERSION_NOT_SUPPORTED = 505;

2、下载文件

  1. 向浏览器输出消息 (一直在讲,就不说了)
  2. 下载文件
    1. 要获取下载文件的路径
    2. 下载的文件名是啥?
    3. 设置想办法让浏览器能够支持下载我们需要的东西
    4. 获取下载文件的输入流
    5. 创建缓冲区
    6. 获取OutputStream对象
    7. 将FileOutputStream流写入到buffer缓冲区
    8. 使用OutputStream将缓冲区中的数据输出到客户端!
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    // 1. 要获取下载文件的路径
    String realPath = "F:\\班级管理\\西开【19525】\\2、代码\\JavaWeb\\javaweb-02-servlet\\response\\target\\classes\\秦疆.png";
    System.out.println("下载文件的路径:"+realPath);
    // 2. 下载的文件名是啥?
    String fileName = realPath.substring(realPath.lastIndexOf("\\") + 1);
    // 3. 设置想办法让浏览器能够支持(Content-Disposition)下载我们需要的东西,中文文件名URLEncoder.encode编码,否则有可能乱码
    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、验证码功能

验证怎么来的?

  • 前端实现
  • 后端实现,需要用到 Java 的图片类,生产一个图片
package com.kuang.servlet;

import javax.imageio.ImageIO;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.awt.*;
import java.awt.image.BufferedImage;
import java.io.IOException;
import java.util.Random;

public class ImageServlet extends HttpServlet {

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

        //如何让浏览器3秒自动刷新一次;
        resp.setHeader("refresh","3");
        
        //在内存中创建一个图片
        BufferedImage image = new BufferedImage(80,20,BufferedImage.TYPE_INT_RGB);
        //得到图片
        Graphics2D g = (Graphics2D) image.getGraphics(); //笔
        //设置图片的背景颜色
        g.setColor(Color.white);
        g.fillRect(0,0,80,20);
        //给图片写数据
        g.setColor(Color.BLUE);
        g.setFont(new Font(null,Font.BOLD,20));
        g.drawString(makeNum(),0,20);

        //告诉浏览器,这个请求用图片的方式打开
        resp.setContentType("image/jpeg");
        //网站存在缓存,不让浏览器缓存
        resp.setDateHeader("expires",-1);
        resp.setHeader("Cache-Control","no-cache");
        resp.setHeader("Pragma","no-cache");

        //把图片写给浏览器
        ImageIO.write(image,"jpg", resp.getOutputStream());

    }

    //生成随机数
    private String 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");
        }
        num = sb.toString() + num;
        return num;
    }


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

4、实现重定向

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

常见场景:

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

测试:

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

    /*
        resp.setHeader("Location","/r/img");
        resp.setStatus(302);
         */
    resp.sendRedirect("/r/img");//重定向
}

面试题:请你聊聊重定向和转发的区别?

相同点:

  1. 页面都会实现跳转

不同点:

  1. 请求转发的时候,url不会产生变化ss
  2. 重定向的时候,url地址栏会发生变化

6.7、HttpServletRequest

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

获取参数,请求转发

@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[] hobbys = req.getParameterValues("hobbys");
    System.out.println("=============================");
    //后台接收中文乱码问题
    System.out.println(username);
    System.out.println(password);
    System.out.println(Arrays.toString(hobbys));
    System.out.println("=============================");


    System.out.println(req.getContextPath());
    //通过请求转发
    //这里的 / 代表当前的web应用
    req.getRequestDispatcher("/success.jsp").forward(req,resp);

}

面试题:请你聊聊重定向和转发的区别?

相同点

  • 页面都会实现跳转

不同点

  • 请求转发的时候,url不会产生变化 307
  • 重定向时候,url地址栏会发生变化; 302

7、Cookie、Session(重点)

7.1、会话

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

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

你能怎么证明你是西开的学生?

你 西开

  1. 发票 西开给你发票
  2. 学校登记 西开标记你来过了

一个网站,怎么证明你来过?

客户端 服务端

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

7.2、保存会话的两种技术

cookie

  • 客户端技术 (响应,请求)

session

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

常见常见:网站登录之后,你下次不用再登录了,第二次访问直接就上去了!

7.3、Cookie

  1. 从请求中拿到cookie信息
  2. 服务器响应给客户端cookie
Cookie[] cookies = req.getCookies(); //获得Cookie
cookie.getName(); //获得cookie中的key
cookie.getValue(); //获得cookie中的vlaue
new Cookie("lastLoginTime", System.currentTimeMillis()+""); //新建一个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 ;

编码解码:

URLEncoder.encode("秦疆","utf-8")
URLDecoder.decode(cookie.getValue(),"UTF-8")

7.4、Session(重点)

什么是Session:

  • 服务器会给每一个用户(浏览器)创建一个Session对象;
  • 一个Seesion独占一个浏览器,只要浏览器没有关闭,这个Session就存在;
  • 用户登录之后,整个网站它都可以访问!–> 保存用户的信息;保存购物车的信息……

Session和cookie的区别:

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

使用场景:

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

使用Session:

package com.kuang.servlet;

import com.kuang.pojo.Person;

import javax.servlet.ServletException;
import javax.servlet.http.*;
import java.io.IOException;

public class SessionDemo01 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        
        //解决乱码问题
        req.setCharacterEncoding("UTF-8");
        resp.setCharacterEncoding("UTF-8");
        resp.setContentType("text/html;charset=utf-8");
        
        //得到Session
        HttpSession session = req.getSession();
        //给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);
    }
}

//得到Session
HttpSession session = req.getSession();

Person person = (Person) session.getAttribute("name");

System.out.println(person.toString());

HttpSession session = req.getSession();
session.removeAttribute("name");
//手动注销Session
session.invalidate();

会话自动过期:web.xml配置


<session-config>
    
    <session-timeout>15session-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\Administrator\.IntelliJIdea2018.1\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(.HttpServletRequest request,HttpServletResponse response)
      
  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                      //响应
    
  3. 输出页面前增加的代码

    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;
    
  4. 以上的这些个对象我们可以在JSP页面中直接使用!

在JSP页面中;

只要是 JAVA代码就会原封不动的输出;

如果是HTML代码,就会被转换为:

out.write("\r\n");

这样的格式,输出到前端!

8.3、JSP基础语法

任何语言都有自己的语法,JAVA中有,。 JSP 作为java技术的一种应用,它拥有一些自己扩充的语法(了解,知道即可!),Java所有语法都支持!

JSP表达式

  <%--JSP表达式
  作用:用来将程序的输出,输出到客户端
  <%= 变量或者表达式%>
  --%>
  <%= new java.util.Date()%>

jsp脚本片段

  <%--jsp脚本片段--%>
  <%
    int sum = 0;
    for (int i = 1; i <=100 ; i++) {
      sum+=i;
    }
    out.println("

Sum="+sum+"

"); %>

脚本片段的再实现

  <%
    int x = 10;
    out.println(x);
  %>
  

这是一个JSP文档

<% int y = 2; out.println(y); %>
<%--在代码嵌入HTML元素--%> <% for (int i = 0; i < 5; i++) { %>

Hello,World <%=i%>

<% } %>

JSP声明

  <%!
    static {
      System.out.println("Loading Servlet!");
    }

    private int globalVar = 0;

    public void kuang(){
      System.out.println("进入了方法Kuang!");
    }
  %>

JSP声明:会被编译到JSP生成Java的类中!其他的,就会被生成到_jspService方法中!

在JSP,嵌入Java代码即可!

<%%>
<%=%>
<%!%>

<%--注释--%>

JSP的注释,不会在客户端显示,HTML就会!

8.4、JSP指令

<%--定制错误页面--%>

<%--<%@ page errorPage="error/500.jsp" %>--%>
<%--显示的声明这是一个错误页面--%>
<%@ page isErrorPage="true" %>
<%@ page pageEncoding="UTF-8" %>
<%@include file=""%>
<%@include file="common/header.jsp"%>

<%--@include会将两个页面合二为一--%>
<%@include file="common/header.jsp"%>

网页主体

<%@include file="common/footer.jsp"%>
<%--JSP标签 jsp:include相对于拼接页面,本质还是三个 --%>

网页主体

静态文件包

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4kfbJufJ-1636270083118)(C:/Users/lei/AppData/Roaming/Typora/typora-user-images/image-20211025203100466.png)]

8.5、9大内置对象

  • PageContext 存东西
  • Request 存东西
  • Response
  • Session 存东西
  • Application 【ServletContext】存东西
  • config 【ServletConfig】
  • out
  • page :不用了解
  • exception

<%--内置对象--%>
<%
    pageContext.setAttribute("name1","乔木1号");//保存的数据只在一个页面中有效
    request.setAttribute("name2","乔木2号");//保存的数据只在一次请求中有效,请求转发会携带这数据
    session.setAttribute("name3","乔木3号");//保存的数据只在一次会话中有效,从打开浏览器到关闭浏览器
    application.setAttribute("name4","乔木4号");//保存的数据只在服务器中有效,从打开服务器到关闭服务器

%>

<%--脚本片段中的代买会被原封不动生成到.JSP.java
要求:这里面的代码必须保证java语法的正确性
--%>
<%
    /*通过pageContext取出我们保存的值*/
    //从pageContext取出,我们通过寻找的方式来
    //寻找机制:从底层到高层(作用域)page-->request-->session-->application
    //JVM:双亲委派机制
    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表达式输出 ${}--%>

取出的值为:

${name1}

${name2}

${name3}

${name4}

${name5}

<%--不使用EL表达式会显示取出的值为null 例如:

<%=name%>>

--%>

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

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

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

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

EL表达式:${}

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

JSP标签

<%--
http://localhost:8080/jsptag.jsp?name=kuangshen&age=12
--%>

    
    


JSTL表达式

JSTL标签库的使用就是伪类弥补HTML标签的不足;它自身定义许多标签,可以供我们使用,标签的功能和java代码一样!

JSP标准标签库(JSTL)是一个JSP标签集合,它封装了JSP应用的通用核心功能。

JSTL支持通用的、结构化的任务,比如迭代,条件判断,XML文档操作,国际化标签,SQL标签。 除了这些,它还提供了一个框架来使用集成JSTL的自定义标签。

根据JSTL标签所提供的功能,可以将其分为5个类别。

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

核心标签(掌握部分)

核心标签是最常用的 JSTL标签。引用核心标签库的语法如下:

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nP5hcqrs-1636270083120)(C:/Users/lei/AppData/Roaming/Typora/typora-user-images/image-20211025223221250.png)]

JSTL标签库使用步骤:

  • 引入对于的taglib
  • 使用其中的方法
  • 在Tomcat中也需要引入JSTL的包,否则会报错,JSTL解析错误

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" %>
<%@ page isELIgnored="false" %>


    Title




if测试


<%-- EL表达式获取表单中的数据 ${param.参数名} --%>
<%--判断如果提交的用户名是管理员,则登录成功--%> <%--自闭合标签--%>

c:when c:choose

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>


    Title



<%--定义一个变量叫score,它的值为85--%>



    
        你的成绩为优秀!
    
    
        你的成绩为一般!
    
    
        你的成绩为良好!
    
    
        你的成绩为不合格!
    



c:forEach

<%@ page import="java.util.ArrayList" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>


    Title



<%
    ArrayList people = new ArrayList<>();
    people.add(0,"张三");
    people.add(1,"李四");
    people.add(2,"王五");
    people.add(3,"赵六");
    people.add(4,"田六");
    request.setAttribute("list",people);

%>

<%--
var ,每一次遍历出来的变量
items, 要遍历的对象
begin,哪里开始
end,到哪里
step,步长
--%>

    


格式化标签

JSTL格式化标签用来格式化并输出文本、日期、时间、数字。引用格式化标签库的语法如下:

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

SQL标签

JSTL SQL标签库提供了与关系型数据库(Oracle,MySQL,SQL Server等等)进行交互的标签。引用SQL标签库的语法如下:

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

XML 标签

JSTL XML标签库提供了创建和操作XML文档的标签。引用XML标签库的语法如下:

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

JSTL函数

JSTL包含一系列标准函数,大部分是通用的字符串处理函数。引用JSTL函数库的语法如下:

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

9、JavaBean

实体类

JavaBean有特定的写法:

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

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

ORM:对象关系映射

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

people表

id name age address
1 乔木一号 3 湖南
2 乔木二号 18 湖南
3 乔木三号 100 湖南
class Peopele{
    private int id;
    private String name;
    private int age;
    private String address;
}

class A{
    new People(1,"乔木一号",3,"湖南")}
  • 过滤器
  • 文件上传
  • 邮件发送
  • JDBC复习:如何使用JDBC、JDBC crud、jdbc事务

10、MVC三层架构

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

10.1、早些年

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

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

架构:没有什么是加一层架构解决不了的!

程序员调用

JDBC

Mysql Oracle SqlServlet....

10.2、MVC三层架构

控制层:Controller Servlet:1、接受用户的请求,2、交给业务员去做(返回数据)3、视图跳转

Model:控制业务操作、保存数据、修改数据、删除数据、查询数据

View:视图层JSP:1、展示数据模型 2、提供用户操作

service(login)(logout)(查询所有用户)----》Dao层----》JDBC----》数据库

Model:

  • 业务处理:业务逻辑(Service)
  • 数据持久层:CRUD(增删改查)(Dao)

View:

  • 展示数据
  • 提供链接发起Servlet请求(a,form,img…)

Controller

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

11、Filter过滤器(重点)

shiro

Filter:过滤器,用来过滤网站的数据;

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

Web浏览器----》Web服务器----》过滤器(web服务有一些垃圾请求,后台应该处理,或者应该报错)处理乱码问题—》Servlet、JSP、HTML、静态资源…

Filter开发步骤:

  1. 导包

<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.0modelVersion>

    <groupId>com.kuanggroupId>
    <artifactId>javaweb-filterartifactId>
    <version>1.0-SNAPSHOTversion>

    <dependencies>
        
        <dependency>
            <groupId>javax.servletgroupId>
            <artifactId>servlet-apiartifactId>
            <version>2.5version>
        dependency>
        
        <dependency>
            <groupId>javax.servlet.jspgroupId>
            <artifactId>jsp-apiartifactId>
            <version>2.2version>
        dependency>
        
        <dependency>
            <groupId>javax.servlet.jsp.jstlgroupId>
            <artifactId>jstl-apiartifactId>
            <version>1.2version>
        dependency>
        
        <dependency>
            <groupId>taglibsgroupId>
            <artifactId>standardartifactId>
            <version>1.1.2version>
        dependency>
        
        <dependency>
            <groupId>mysqlgroupId>
            <artifactId>mysql-connector-javaartifactId>
            <version>8.0.23version>
        dependency>
    dependencies>

project>

2.编写过滤器

注意:导包不要错误:导入Servlet下的filter

实现Filter接口,重写对应的方法即可

package com.kuang.servlet;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class ShowServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //req.setCharacterEncoding("UTF-8");
        //resp.setCharacterEncoding("UTF-8");
        //resp.setContentType("text/html;charset=utf-8");
        resp.getWriter().write("您好呀,世界!");
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
       doGet(req, resp);
    }
}
package com.kuang.filter;

import javax.servlet.*;
import java.io.IOException;

public class CharacterEncodingFilter implements Filter {

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

    //Chain : 链
    /*
    1. 过滤中的所有代码,在过滤特定请求的时候都会执行
    2. 必须要让过滤器继续同行
        chain.doFilter(request,response);
     */
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        request.setCharacterEncoding("utf-8");
        response.setCharacterEncoding("utf-8");
        response.setContentType("text/html;charset=UTF-8");

        System.out.println("CharacterEncodingFilter执行前....");
        chain.doFilter(request,response); //让我们的请求继续走,如果不写,程序到这里就被拦截停止!
        System.out.println("CharacterEncodingFilter执行后....");
    }

    //销毁:web服务器关闭的时候,过滤会销毁
    public void destroy() {
        System.out.println("CharacterEncodingFilter销毁");
    }
}

3.在web.xml中配置Filter


<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">
    <servlet>
        <servlet-name>ShowServletservlet-name>
        <servlet-class>com.kuang.servlet.ShowServletservlet-class>
    servlet>
    <servlet-mapping>
        <servlet-name>ShowServletservlet-name>
        <url-pattern>/servlet/showurl-pattern>
    servlet-mapping>
    <servlet-mapping>
        <servlet-name>ShowServletservlet-name>
        <url-pattern>/servleturl-pattern>
    servlet-mapping>

    <filter>
        <filter-name>CharacterEncodingFilterfilter-name>
        <filter-class>com.kuang.filter.CharacterEncodingFilterfilter-class>
    filter>
    <filter-mapping>
        <filter-name>CharacterEncodingFilterfilter-name>
        
        <url-pattern>/servlet/*url-pattern>
        
    filter-mapping>
web-app>

12、监听器

实现一个监听器接口:(有N种)

1、编写一个监听器

实现监听器的接口,重写里面的方法

package com.kuang.listener;


import javax.servlet.ServletContext;
import javax.servlet.http.HttpSessionEvent;
import javax.servlet.http.HttpSessionListener;

//统计网站在线人数:统计session(一个用户对应一个session)
public class OnlineCountListener implements HttpSessionListener {

    //创建session监听:看你的一举一动
    //一旦创建Session就会触发一次这个事件!
    @Override
    public void sessionCreated(HttpSessionEvent  se) {

        ServletContext ctx = se.getSession().getServletContext();
        Integer onlineCount = (Integer) ctx.getAttribute("OnlineCount");

        if(onlineCount==null){
            onlineCount = new Integer(1);
        }else{
            int count = onlineCount.intValue();
            onlineCount = new Integer(count+1);
        }

        ctx.setAttribute("OnlineCount",onlineCount);
    }

    //销毁session监听
    //一旦销毁session就会触发一次这个事件!
    @Override
    public void sessionDestroyed(HttpSessionEvent  se) {
        ServletContext ctx = se.getSession().getServletContext();
        Integer onlineCount = (Integer) ctx.getAttribute("OnlineCount");

        if(onlineCount==null){
            onlineCount = new Integer(1);
        }else{
            int count = onlineCount.intValue();
            onlineCount = new Integer(count-1);
        }

        ctx.setAttribute("OnlineCount",onlineCount);
    }


    /*
    Session销毁:
    1、手动销毁  getSession().invalidate();
    2、自动销毁  在xml中配置
    
    
        1
    

     */
}

2.web.xml中注册监听器


    <listener>
        <listener-class>com.kuang.listener.OnlineCountListenerlistener-class>
    listener>

3.看情况是否使用!

13、过滤器、监听器常见应用

监听器:GUI编程中的使用

package com.kuang.listener;

import java.awt.*;
import java.awt.event.WindowEvent;
import java.awt.event.WindowListener;

public class TextPanel {
    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);
        frame.setBackground(new Color(0,255,0));//设置背景颜色

        frame.add(panel);

        //可见性
        frame.setVisible(true);

        //监听事件:监听关闭事件
        frame.addWindowListener(new WindowListener() {
            @Override
            public void windowOpened(WindowEvent e) {
                System.out.println("打开");
            }

            @Override
            public void windowClosing(WindowEvent e) {
                System.out.println("关闭ing");
            }

            @Override
            public void windowClosed(WindowEvent e) {
                System.out.println("关闭ed");
                System.exit(0);
            }

            @Override
            public void windowIconified(WindowEvent e) {

            }

            @Override
            public void windowDeiconified(WindowEvent e) {

            }

            @Override
            public void windowActivated(WindowEvent e) {
                System.out.println("激活");
            }

            @Override
            public void windowDeactivated(WindowEvent e) {
                System.out.println("未激活");
            }
        });


    }
}

用户登录之后才能进入主页,用户注销后就不能进入主页!

1.用户登录之后,向Session中放入用户的数据

2.进入主页的时候要判断用户是否已经登录;要求在过滤器中实现!

HttpServletRequest request = (HttpServletRequest) req;
HttpServletResponse response = (HttpServletResponse) resp;

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

chain.doFilter(request,response);

14、JDBC

什么是JDBC?

java连接数据库!

连接数据库需要jar包的支持:

  1. java.sql
  2. javax.sql
  3. mysql.conneter.java连接驱动(必须要导入)

实验环境搭建:

数据库创建

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','[email protected]','2000-01-01');
INSERT INTO users(id,`name`,`password`,email,birthday)
VALUES(2,'李四','123456','[email protected]','2000-01-01');
INSERT INTO users(id,`name`,`password`,email,birthday)
VALUES(3,'王五','123456','[email protected]','2000-01-01');


SELECT	* FROM users;

导入数据库依赖

     <dependencies>
    
            <dependency>
                <groupId>mysqlgroupId>
                <artifactId>mysql-connector-javaartifactId>
                <version>8.0.23version>
            dependency>

        dependencies>

IDEA中连接数据库

JDBC固定步骤:

1.固定驱动

2.连接数据库,代表数据库

3.向数据库发送SQL的对象Statement:CRUD

4.编写SQL(根据业务,不同的SQL)

5.执行SQL

6.关闭连接

package com.kuang.test;

import java.sql.*;

public class TestJdbc {
    public static void main(String[] args) throws ClassNotFoundException, SQLException {
        //配置信息
        //useUnicode=true&characterEncoding=utf-8 解决中文乱码
        String url = "jdbc:mysql://localhost:3306/jdbc?useUnicode=true&characterEncoding=utf-8";
        String username = "root";
        String password = "root";

        //1.加载驱动
        Class.forName("com.mysql.jdbc.Driver");
        
        //2.连接数据库
        Connection connection = DriverManager.getConnection(url, username, password);
        
        //3.向数据库发送SQL的对象Statement,PreparedStatement:CRUD
        Statement statement = connection.createStatement();
        
        //4.编写SQL
        String sql="select * from users";

        //5.执行查询SQL,返回一个ResultSet:结果集
        ResultSet rs = statement.executeQuery(sql);

        while (rs.next()){
            System.out.println("id="+rs.getObject("id"));
            System.out.println("name="+rs.getObject("name"));
            System.out.println("password="+rs.getObject("password"));
            System.out.println("email="+rs.getObject("email"));
            System.out.println("birthday="+rs.getObject("birthday"));
        }


        //6.关闭连接,释放资源(一定要做)先开后关
        rs.close();
        statement.close();
        connection.close();
    }
}

受影响的行数,增删改都是用executeUpdate即可

预编译SQL

public class TestJDBC2 {
    public static void main(String[] args) throws Exception {
        //配置信息
        //useUnicode=true&characterEncoding=utf-8 解决中文乱码
        String url="jdbc:mysql://localhost:3306/jdbc?useUnicode=true&characterEncoding=utf-8";
        String username = "root";
        String password = "123456";

        //1.加载驱动
        Class.forName("com.mysql.jdbc.Driver");
        //2.连接数据库,代表数据库
        Connection connection = DriverManager.getConnection(url, username, password);

        //3.编写SQL
        String sql = "insert into  users(id, name, password, email, birthday) values (?,?,?,?,?);";

        //4.预编译
        PreparedStatement preparedStatement = connection.prepareStatement(sql);

        preparedStatement.setInt(1,2);//给第一个占位符? 的值赋值为1;
        preparedStatement.setString(2,"狂神说Java");//给第二个占位符? 的值赋值为狂神说Java;
        preparedStatement.setString(3,"123456");//给第三个占位符? 的值赋值为123456;
        preparedStatement.setString(4,"[email protected]");//给第四个占位符? 的值赋值为1;
        preparedStatement.setDate(5,new Date(new java.util.Date().getTime()));//给第五个占位符? 的值赋值为new Date(new java.util.Date().getTime());

        //5.执行SQL
        int i = preparedStatement.executeUpdate();

        if (i>0){
            System.out.println("插入成功@");
        }

        //6.关闭连接,释放资源(一定要做) 先开后关
        preparedStatement.close();
        connection.close();
    }
}

事务

要么都成功,要么都失败

ACID原则:保证数据的安全

开启事务
事务提交 commit()
事务回滚 rollback()
关闭事务
    
转账:
    A:1000
    B:1000
 A(900)   ---100--->   B(1100)
    

Junit单元测试

依赖

 
        <dependency>
            <groupId>junitgroupId>
            <artifactId>junitartifactId>
            <version>4.13.2version>
        dependency>

简单使用

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


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

搭建一个环境测试一个事务

t rs = statement.executeQuery(sql);

    while (rs.next()){
        System.out.println("id="+rs.getObject("id"));
        System.out.println("name="+rs.getObject("name"));
        System.out.println("password="+rs.getObject("password"));
        System.out.println("email="+rs.getObject("email"));
        System.out.println("birthday="+rs.getObject("birthday"));
    }


    //6.关闭连接,释放资源(一定要做)先开后关
    rs.close();
    statement.close();
    connection.close();
}

}




受影响的行数,增删改都是用executeUpdate即可

**预编译SQL**

```java
public class TestJDBC2 {
    public static void main(String[] args) throws Exception {
        //配置信息
        //useUnicode=true&characterEncoding=utf-8 解决中文乱码
        String url="jdbc:mysql://localhost:3306/jdbc?useUnicode=true&characterEncoding=utf-8";
        String username = "root";
        String password = "123456";

        //1.加载驱动
        Class.forName("com.mysql.jdbc.Driver");
        //2.连接数据库,代表数据库
        Connection connection = DriverManager.getConnection(url, username, password);

        //3.编写SQL
        String sql = "insert into  users(id, name, password, email, birthday) values (?,?,?,?,?);";

        //4.预编译
        PreparedStatement preparedStatement = connection.prepareStatement(sql);

        preparedStatement.setInt(1,2);//给第一个占位符? 的值赋值为1;
        preparedStatement.setString(2,"狂神说Java");//给第二个占位符? 的值赋值为狂神说Java;
        preparedStatement.setString(3,"123456");//给第三个占位符? 的值赋值为123456;
        preparedStatement.setString(4,"[email protected]");//给第四个占位符? 的值赋值为1;
        preparedStatement.setDate(5,new Date(new java.util.Date().getTime()));//给第五个占位符? 的值赋值为new Date(new java.util.Date().getTime());

        //5.执行SQL
        int i = preparedStatement.executeUpdate();

        if (i>0){
            System.out.println("插入成功@");
        }

        //6.关闭连接,释放资源(一定要做) 先开后关
        preparedStatement.close();
        connection.close();
    }
}

事务

要么都成功,要么都失败

ACID原则:保证数据的安全

开启事务
事务提交 commit()
事务回滚 rollback()
关闭事务
    
转账:
    A:1000
    B:1000
 A(900)   ---100--->   B(1100)
    

Junit单元测试

依赖

 
        <dependency>
            <groupId>junitgroupId>
            <artifactId>junitartifactId>
            <version>4.13.2version>
        dependency>

简单使用

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


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

搭建一个环境测试一个事务

你可能感兴趣的:(学习,服务器,javascript,html)