JavaWeb入门---参考狂神说

最新推荐文章于 2024-08-11 20:00:32 发布

m0_51348967

最新推荐文章于 2024-08-11 20:00:32 发布

阅读量209

点赞数

文章标签： java mysql intellij idea 后端 ubuntu

本文链接：https://blog.csdn.net/m0_51348967/article/details/118069853

版权

1.HTTP

1.1.HTTP介绍

HTTP是一种超文本传输协议，是一个基于请求与响应，无状态的，应用层的协议，常基于TCP/IP协议传输数据，互联网上应用最为广泛的一种网络协议,所有的WWW文件都必须遵守这个标准。设计HTTP的初衷是为了提供一种发布和接收HTML页面的方法。

客户向服务器发出请求，服务器向客户做出回应

客户端发出的是请求协议，服务端发出的是响应协议

1.2.HTTP之URL

HTTP URL(URL是一种特殊类型的URI，包含了用于查找某个资源的足够的信息)的格式如下：

http://host[:port]/[abc_path]
http://IP(主机名/域名):端口/访问的资源路径

http表示通过HTTP协议来定位网络资源；
host表示合法的Internet主机域名或IP地址；
port指定一个端口号，为空则使用缺省端口80；
abs_path指定请求资源的URI；如果URI没有给出abs_path,那么当它作为请求URI时，必须以“/”的形式给出，通常这个工作由浏览器自动帮我们完成。

1.3.HTTP请求

HTTP请求由三部分组成，分别是：请求行、请求头、请求正文。
通过chrom浏览器。F12–>Network查看
1.Get请求(没有请求体)
在这里插入图片描述
2.Post请求

1.4.HTTP响应

在接收和解释请求后，服务器返回一个HTTP响应消息。HTTP响应也是由是三个部分组成，分别是：状态行、消息报头、响应正文。
在这里插入图片描述
格式

状态行
响应头1
响应头2
……
响应空行
响应体

1.5.消息头

HTTP消息由客户端到服务器的请求和服务器到客户端的响应组成。请求消息和响应消息都是由开始行(对于请求消息，开始行就是请求行，对于响应消息开始行就是状态行)，消息报头(可选)，空行(只有CRLF的行)，消息正文(可选)组成。
每一个报头域都是由“名字+’:‘+空格+值”组成，消息报头域的名字是大小写无关。

请求头
请求报头允许客户端向服务器端传递请求的附加信息以及客户端自身的信息。

Referer:该请求头指明请求从哪里来。

如果是地址栏中输入地址访问的都没有该请求头。通过请求可以看到，此时多了一个Referer的请求头，并且后面的值为该请求从哪发出。比如：百度竞价，只能从百度来的才有效果，否则不算；通常用来做统计工作、防盗链。
响应头
响应报头允许服务器传递不能放在状态行中的附加响应信息，以及关于服务器的信息和对Request-URI所标识的资源进行下一步访问的信息。

Location:Location响应报头域用于重定向接受者到一个新的位置。
Location响应报头域，常用在更换域名的时候。

responses.sendRedirect(“http://www.baidu.com”);

Refresh:自动跳转(单位是秒)，可以在页面通过meta标签实现，也可在后台实现。

<meta http-equiv="refresh" content="3;url=http://www.baidu.com">

2.Tomcat

2.1.什么是Tomcat

Tomcat 服务器是一个免费的开放源代码的Web 应用服务器，属于轻量级应用服务器，在中小型系统和并发访问用户不是很多的场合下被普遍使用，是开发和调试JSP 程序的首选。对于一个初学者来说，可以这样认为，当在一台机器上配置好Apache 服务器，可利用它响应HTML（标准通用标记语言下的一个应用）页面的访问请求。实际上Tomcat是Apache 服务器的扩展，但运行时它是独立运行的，所以当你运行tomcat 时，它实际上作为一个与Apache 独立的进程单独运行的。

2.2.ubantu系统安装Tomcat

Tomcat运行需要基于Java已经安装配置好的环境下,安装前需要确认已经安装好JAVA环境。
第一步：下载
tomcat官网地址：https://tomcat.apache.org/download-10.cgi

在这里插入图片描述
第二步：安装
找到下载的安装包，使用终端命令安装。

sudo tar -zxvf 安装包路径

第三步：配置文件

sudo vi /etc/profile

在这里插入图片描述

#set java env
export JAVA_HOME=/usr/lib/jdk/jdk1.8.0_11
export JRE_HOME=${JAVA_HOME}/jre    
export CLASSPATH=.:${JAVA_HOME}/lib:${JRE_HOME}/lib    
export PATH=${JAVA_HOME}/bin:$PATH
 
export CATALINA_HOME=/usr/env/apache-tomcat-8.5.42
export PATH=$CATALINA_HOME/bin:$PATH
export CLASSPATH=.:$CATALINA_HOME/lib

执行命令

(base) ocean@ocean-Lenovo-ideapad-300-15ISK:~$ ./startup.sh

打开浏览器输入：localhost:8080
出现下图页面则配置成功
在这里插入图片描述

3.Servlet

3.1.Servlet介绍

Java Servlet 是运行在 Web 服务器或应用服务器上的程序，它是作为来自 Web 浏览器或其他 HTTP 客户端的请求和 HTTP 服务器上的数据库或应用程序之间的中间层。
使用 Servlet，您可以收集来自网页表单的用户输入，呈现来自数据库或者其他源的记录，还可以动态创建网页。
Java Servlet 通常情况下与使用 CGI（Common Gateway Interface，公共网关接口）实现的程序可以达到异曲同工的效果。但是相比于 CGI，Servlet 有以下几点优势：

性能明显更好。
Servlet 在 Web 服务器的地址空间内执行。这样它就没有必要再创建一个单独的进程来处理每个客户端请求。
Servlet 是独立于平台的，因为它们是用 Java 编写的。
服务器上的 Java 安全管理器执行了一系列限制，以保护服务器计算机上的资源。因此，Servlet 是可信的。
Java 类库的全部功能对 Servlet 来说都是可用的。它可以通过 sockets 和 RMI 机制与 applets、数据库或其他软件进行交互。

3.2.创建Web项目

1.选择“File”—>“New”—>“Project”
在这里插入图片描述
2.设置项目的相关信息，选择“Next”

在这里插入图片描述
3.设置项目的名称及工作空间

在这里插入图片描述
4.web项目目录结构如下

3.3.Servlet的实现

3.3.1.新建类

1.点击“src”—>“New”—>“package”,创建一个文件包

在这里插入图片描述
2.在包下面创建Java类文件，点击包名—>“New”—>“java class”

3.创建一个普通的Java类

在这里插入图片描述

3.3.2.实现Servlet规范

实现Servlet规范，即继承HttpServlet类，并到响应的包。该类中已经完成了通信的规则，我们只需要进行业务的实现即可。
在这里插入图片描述

3.3.3.重写service方法

满足Servlet规范只是让我们得类能够满足接收请求的要求，接受到请求后需要对请求进行处理，以及进行业务逻辑处理。计算出结果，则需要添加代码，在规范中有一个叫做service的方法，专门用来做请求的操作，业务代码则可以在该方法中。

package com.example.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 Servlet01 extends HttpServlet {

    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("Hello Servlet");
        resp.getWriter().write("Hello world");
    }
}

3.3.4.设置注解

       在完成好了一切代码的编写后，还需要向服务器说明，特定请求对应特定资源。
       开发Servlet项目，使用@WebServlet将一个继承于javax.servlet.http.HttpServlet的类定义为Servlet组件。在Servlet3.0中，可以使用@WebServlet注解将一个继承于javax.servlet.http.HttpServlet的类标注为可以处理用户请求的Servlet。
      在使用tomcat10时，JSP跳转的时候可能会出现404或者500的错误，降低Tomcat的版本可解决。

package com.example.demo1;

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

@WebServlet("/ser")
public class Servlet extends HttpServlet {
    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("zhanghaiyang");
        resp.getWriter().write("haiyang");
    }
}

3.4.Servlet运行原理

Servlet是由Web服务器调用，web服务器在收到浏览器请求之后，会：
在这里插入图片描述

3.5.Mapping问题

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

	  <!--servlet-name元素给出的Servlet名字必须是在servlet元素中声明过的Servlet的名字。-->
      <servlet-mapping>
          <servlet-name>hello</servlet-name>
          <url-pattern>/hello</url-pattern>
      </servlet-mapping>

2.一个servlet可以指定多个映射路径

      <servlet-mapping>
          <servlet-name>hello</servlet-name>
          <url-pattern>/hello</url-pattern>
      </servlet-mapping>
      <servlet-mapping>
          <servlet-name>hello</servlet-name>
          <url-pattern>/hello2</url-pattern>
      </servlet-mapping>
      <servlet-mapping>
          <servlet-name>hello</servlet-name>
          <url-pattern>/hello3</url-pattern>
      </servlet-mapping>
      <servlet-mapping>
          <servlet-name>hello</servlet-name>
          <url-pattern>/hello4</url-pattern>
      </servlet-mapping>
      <servlet-mapping>
          <servlet-name>hello</servlet-name>
          <url-pattern>/hello5</url-pattern>
      </servlet-mapping>

3.一个servlet可以指定通用映射路径

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

4.默认请求路径

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

5.指定一些后缀或者前缀等等…

  
  <!--可以自定义后缀实现请求映射
      注意点，*前面不能加项目映射的路径
      hello/sajdlkajda.qinjiang
      -->
  <servlet-mapping>
      <servlet-name>hello</servlet-name>
      <url-pattern>*.qinjiang</url-pattern>
  </servlet-mapping>

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

  <!--404-->
  <servlet>
      <servlet-name>error</servlet-name>
      <servlet-class>com.kuang.servlet.ErrorServlet</servlet-class>
  </servlet>
  <servlet-mapping>
      <servlet-name>error</servlet-name>
      <url-pattern>/*</url-pattern>
  </servlet-mapping>

3.6.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);
    }
}

    <servlet>
        <servlet-name>hello</servlet-name>
        <servlet-class>com.kuang.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.kuang.servlet.GetServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>getc</servlet-name>
        <url-pattern>/getc</url-pattern>
    </servlet-mapping>

测试访问结果；
2.获取初始化参数

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

package com.example.demo1;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

@WebServlet("/ser")
public class Servlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

        InputStream is = this.getServletContext().getResourceAsStream("WEB-INF/classes/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;

3.7.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 varl,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 varl,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.下载文件

要获取下载文件的路径
下载的文件名是啥？
设置想办法让浏览器能够支持下载我们需要的东西
获取下载文件的输入流
创建缓冲区
获取OutputStream对象
将FileOutputStream流写入到bufer缓冲区
使用OutputStream将缓冲区中的数据输出到客户端

package com.example.demo1;

import javax.servlet.ServletException;
import javax.servlet.ServletOutputStream;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.FileInputStream;
import java.io.IOException;
import java.net.URLEncoder;

@WebServlet("/down")
public class FileServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //1.要获取下载文件的路径
        String realPath = "/media/ocean/大白菜U盘/Github代码上传/JAVA/demo1/src/main/resources/dream.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();
    }

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

3.验证码功能
验证码怎么来的

前端实现
后端实现，需要用到Java的图片类，生产一个图片

package com.example.demo1;

import javax.imageio.ImageIO;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
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;


@WebServlet("/img")
public class ImageServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

        //如何让浏览器5秒刷新一次
        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/jepg");
        //网站存在缓存，不让浏览器缓存
        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;

package com.example.demo1;

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

@WebServlet("/red")
public class RedirectServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.sendRedirect("/demo1_war_exploded/img");//设置重定向的地址
    }

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

在这里插入图片描述

index.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<h1>success</h1>
</body>
</html>

RequestTest.java

package com.example.demo1;

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


@WebServlet("/login")
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);

        resp.sendRedirect("/demo1_war_exploded/success.jsp");
    }

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

重定向页面success.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<h1>success</h1>
</body>
</html>

3.8.HttpServletRequest

HttpServletRequest代表客户端的请求,用户通过Http协议访问服务器, HTTP请求中的所有信息会被封装到HttpServletRequest,通过这个HttpServletRequest的方法,获得客户端的所有信息;
在这里插入图片描述
获取参数，请求转发

package com.example.demo1;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.Arrays;


@WebServlet("/logins")
public class LoginServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        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("=================");

        //通过请求转发,req.getContextPath()获取项目路径
        req.getRequestDispatcher(req.getContextPath()+ "/success.jsp").forward(req, resp);
    }

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

index.jsp

<%@ page contentType="text/html; charset=UTF-8" pageEncoding="UTF-8" %>
<!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8">
    <title>登录</title>
</head>
<body>
<div style="text-align: center;">
    <form action="${pageContext.request.contextPath}/login" method="post">
        用户名:<input type="text" name="username"><br>
        密码:<input type="password" name="password"><br>
        爱好:
        <input type="checkbox" name="hobbys" value="女孩">女孩
        <input type="checkbox" name="hobbys" value="代码">代码
        <input type="checkbox" name="hobbys" value="唱歌">唱歌
        <input type="checkbox" name="hobbys" value="电影">电影<br>

        <input type="submit" value="登录">
    </form>
</div>
</body>
</html>

success.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<h1>success</h1>
</body>
</html>

运行成功后会出现下图界面
在这里插入图片描述
点击登录出现success,则运行成功，如下图

4.Cookie、Session

4.1.会话

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

有状态会话：一个同学来过教室，下次再来教室，我们会知道这个同学，曾经来过，称之为有状态会话；
在这里插入图片描述

4.2.保存会话的两种技术

cookie

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

session

服务器技术，利用这个技术，可以保存用户的会话信息？可将信息或数据放在 session 中。

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

4.3.Cookie

package com.example.demo1;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Date;


@WebServlet("/cookie")
public class CookieDemo01 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");

        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 doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req, resp);
    }
}

在这里插入图片描述

从请求中拿到 cookie 信息
服务器响应给客户端 cookie

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 ；

一个 Web 站点可以给浏览器发送多个 Cookie，最多存放 20 个 cookie；
cookie 大小有限制 4kb；
300 个 cookie 浏览器上限

删除 Cookie

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

网络编程的编码解码

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

4.4.Session(重点)

在这里插入图片描述
什么是 Session ？

服务器会给每一个用户（浏览器）创建一个 Session 对象；
一个 Session 独占一个浏览器，只要浏览器没有关闭，这个 Session 就存在；
用户登录之后，整个网站它都可以访问！-> 保存用户的信息；保存购物车的信息…

Session和cookie的区别：

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

使用场景：

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

使用session

package com.example.demo1;

import com.example.demo1.pojo.Person;

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


@WebServlet("/sess01")
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);
        }
    }

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


@WebServlet("/sess02")
public class SessionDemo02 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();

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

        System.out.println(person);
    }


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

package com.example.demo1;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.io.IOException;


@WebServlet("/sess03")
public class SessionDemo03 extends HelloServlet {
    @Override
    public void doGet(HttpServletRequest req, HttpServletResponse resp) throws IOException {
        //手动注销session
        HttpSession session = req.getSession();
        session.removeAttribute("name");
        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>15</session-timeout>
</session-config>

5.MVC三层架构

什么是MVC： Model view Controller 模型、视图、控制器
1.以前的流程 在这里插入图片描述
用户直接访问控制层，控制层就可以直接操作数据库；

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

架构：没有什么是加一层解决不了的！
程序猿调用
|
JDBC
|
Mysql Oracle SqlServer ....

2.MVC三层架构 在这里插入图片描述
Model

业务处理：业务逻辑（Service）
数据持久层：CRUD
view
展示数据
提供链接发起 Servlet 请求（a,form,img…）
Controller （Servlet）
接收用户的请求：（req：请求参数、Session 信息…）
交给业务层处理对应的代码
控制试图的跳转

  登录--->接收用户的登录请求--->处理用户的请求（获取用户登录的参数，username，password）---->交给业务层处理登录业务（判断用户名密码是否正确：事务）--->Dao层查询用户名和密码是否正确-->数据库

6.Filter

Filter：过滤器，用来过滤网站的数据；（具体实现跟servlet一模一样）

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

在这里插入图片描述

Filter 开发步骤：

导包
编写过滤器

package com.example.demo1.filter;

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

@WebFilter("/servlet/*") //只要是/servlet下的请求，都要经过过滤器
public class CharacterEncodingFilter implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        System.out.println("CharacterEncodeingFilter初始化");
    }

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        servletRequest.setCharacterEncoding("UTF-8");
        servletResponse.setCharacterEncoding("UTF-8");
        servletResponse.setContentType("text/html;charset=UTF-8");

        System.out.println("CharacterEncodingFilter执行前");

        filterChain.doFilter(servletRequest, servletResponse); //过滤器放行，让请求继续走；如果不写，程序到这里就被拦截停止

        System.out.println("CharacterEncodingFilter执行后");
    }

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

7.监听器

编写一个监听器，实现监听器的接口…

import javax.servlet.annotation.WebListener;
import javax.servlet.http.HttpSessionEvent;
import javax.servlet.http.HttpSessionListener;

@WebListener
//统计网站在线人数，统计session
public class OnlineCountListener implements HttpSessionListener {
    //创建session的监听
    //一旦创建Session就会触发一次这个事件
    @Override
    public void sessionCreated(HttpSessionEvent se) {
        ServletContext ctx = se.getSession().getServletContext();
        System.out.println(se.getSession().getId());
        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的监听
    @Override
    public void sessionDestroyed(HttpSessionEvent se) {
        ServletContext ctx = se.getSession().getServletContext();
        Integer onlineCount = (Integer) ctx.getAttribute("OnlineCount");
        if (onlineCount==null){
            onlineCount = new Integer(0);
        }else {
            int count = onlineCount.intValue();
            onlineCount = new Integer(count-1);
        }

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

index.jsp

<%@ page contentType="text/html; charset=UTF-8" pageEncoding="UTF-8" %>
<!DOCTYPE html>
<html>
<head>
    <title>监听</title>
</head>
<body>
    <h1><span>在线<%=session.getServletContext().getAttribute("OnlineCount")%>人</span></h1>
</body>
</html>

8.过滤器、监听器常见应用

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

package com.example.demo1.listener;

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

public class TestPanel {
    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.out.println("关闭ing");
                System.exit(0);
            }
        });
    }
}

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

用户登录之后，向Sesison中放入用户的数据
进入主页的时候要判断用户是否已经登录；要求：在过滤器中实现！

LoginServlet

package com.example.demo1;

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


@WebServlet("/logs")
public class LoginServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //获取前端请求的参数
        String username = req.getParameter("username");
        if (username.equals("admin")){
            //登录成功
            req.getSession().setAttribute("USER_SESSION",req.getSession().getId());
            resp.sendRedirect(req.getContextPath() + "/sys/success.jsp");
        }else {
            resp.sendRedirect(req.getContextPath() + "/error.jsp");
        }
    }

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

LogoutServlet

package com.example.demo1;

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

@WebServlet("/logout")
public class LogoutServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        Object user_session = req.getSession().getAttribute("USER_SESSION");

        if (user_session!=null){
            req.getSession().removeAttribute("USER_SESSION");
            resp.sendRedirect(req.getContextPath() + "/log.jsp");
        }
    }

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

SysFilter

package com.example.demo1.filter;

import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;


@WebFilter("/sys/*")
public class SysFilter implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        Filter.super.init(filterConfig);
    }

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

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

        filterChain.doFilter(request, response);
    }

    @Override
    public void destroy() {
        Filter.super.destroy();
    }
}

log.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
	<form action="${pageContext.request.contextPath}/logs" method="post">
		<input type="text" name="username">
		<input type="submit">
	</form>
</body>
</html>

success.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
	<h1>主页</h1>
	<p><a href="${pageContext.request.contextPath}/logout">注销</a></p>
</body>
</html>

error.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
	<h1>错误</h1>
	<p><a href="${pageContext.request.contextPath}/log.jsp">返回登录页面</a></p>
</body>
</html>

9.JDBC

9.1.什么是JDBC ：

Java连接数据库！SUN公司为了简化开发人员的(对数据库的统一)操作，提供了一个(JAVA操作数据库的)规范，俗称JDBC；这些规范的实现由具体的厂商去做。
对于开发人员来说，我们只需要掌握JDBC接口的操作即可。
在这里插入图片描述
我们的程序会通过数据库驱动，和数据库打交道。
需要jar包的支持：

java.sql
javax.sql
mysql-conneter-java… 连接驱动（必须要导入）

9.2.第一个JDBC程序

1.创建一个数据库和表

CREATE DATABASE jdbcstudy;

USE jdbcstudy;

CREATE TABLE  users
(
`id` INT (4) PRIMARY KEY,
`name` VARCHAR(40),
`password` VARCHAR(40),
`birthday` DATE
);

INSERT INTO `users` (`id`,`name`,`password`,`birthday`) 
VALUES ('1','张三','123456','1999-02-02'),('2','李四','1234556','1999-08-02'),('3','王五','1288556','1998-02-15')
,('4','赵六','752156','1999-12-12');

2.导入数据库驱动,写出第一个JDBC程序

package com.zhang.test;

import java.sql.*;

//第一个JDBC程序
public class JdbcFirstDemo {
    public static void main(String[] args) throws ClassNotFoundException, SQLException {
        //1.加载驱动
        Class.forName("com.mysql.jdbc.Driver");

        //2.用户信息和url
        String url = "jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&characterEncoding=UTF-8&useSSL=true";
        String username = "root";
        String password = "Zhy119128@";

        //3.连接成功，数据库对象
        Connection connection = DriverManager.getConnection(url, username, password);

        //4.执行SQL的对象;Statement执行SQL的对象
        Statement statement = connection.createStatement();

        //5.执行SQL，可能存在结果，查看返回结果
        String sql = "SELECT * FROM users";

        //返回的结果集封装了我们查询到的全部结果
        ResultSet resultSet = statement.executeQuery(sql);

        while(resultSet.next()){
            System.out.println("id=" + resultSet.getObject("id"));
            System.out.println("name=" + resultSet.getObject("name"));
            System.out.println("pwd=" + resultSet.getObject("password"));
            System.out.println("birthday=" + resultSet.getObject("birthday"));
        }
        //6.释放连接
        resultSet.close();
        statement.close();
        connection.close();
    }
}

9.3步骤总结

加载驱动
连接数据库DriverManager
获取执行sql的对象Statement
获的返回的结果集
释放连接

DriverManager

Class.forName("com.mysql.jdbc.Driver"); //固定写法，加载驱动
Connection connection = DriverManager.getConnection(url, username, password);

//connection 代表数据库
//数据库设置自动提交
//事务提交
//事务回滚
connection.rollback();
connection.commit();
connection.setAutoCommit();

URL

String  url ="jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&characterEncoding=utf8&useSSL=true"
    //mysql默认3306
    //协议://主机地址:端口号/数据库名？参数1&参数2&参数3

Statement、PrepareStatement执行SQL的类

String sql="sekect * from users";
statement.executeQuery();//查询
statement.execute();//执行任何SQL
statement.executeUpdate();//更新，插入，删除

ResultSet 查询的结果集：封装了所有的查询结果

//获取指定的结果类型
resultset.getObject();//在不知道列类型的情况下使用
//如果知道列的类型就是用指定的类型
resultset.getint();
resultset.getobject();
resultset.getDate();


//遍历，指针
resultset.beforFirst();//移动到第一个
resultset.afterLast();//移动到自动一个
resultset.next();    //移动到下一行
resultset.previous();//移动到前一行
resultset.absolute(row)//移动到指定行
...

释放资源

//6.释放连接
resultSet.close();
statement.close();
connection.close(); //耗资源，用完关闭

9.4.statement对象

Jdbc中的statement对象用于向数据库发送SQL语句，想完成对数据库的增删改查，只需要通过这个对象向数据库发送增删改查语句即可。

Statement对象的executeUpdate方法，用于向数据库发送增、删、改的sql语句，executeUpdate执行完后，将会返回一个整数（即增删改语句导致了数据库几行数据发生了变化)。

Statement.executeQuery方法用于向数据库发送查询语句，executeQuery方法返回代表查询结果的ResultSet对象。

使用executeUpdate(String sql)方法完成数据添加操作，示例操作：

  Statement statement = connection.createStatement();
        String sql = "insert into user(...) values(...)";
        int num = statement.executeUpdate(sql);
        if(num>0){
            System.out.println("插入成功");
        }

使用executeUpdate(String sql)方法完成数据删除操作，示例操作：

Statement statement = connection.createStatement();
        String sql = "delete from user where id =1";
        int num = statement.executeUpdate(sql);
        if(num>0){
            System.out.println("删除成功");
        }

使用executeUpdate(String sql)方法完成数据修改操作，示例操作：

Statement statement = connection.createStatement();
        String sql = "update user set name ='' where name = ''";
        int num = statement.executeUpdate(sql);
        if(num>0){
            System.out.println("修改成功");
        }

使用executeUpdate(String sql)方法完成数据查询操作，示例操作：

Statement statement = connection.createStatement();
        String sql = "select * from  user where id =1";
        ResultSet rs= statement.executeQuery(sql);
        if(rs.next()){
            System.out.println("");
        }

代码实现：
1.提取工具类–JdbcUtils.java

package com.zhang.test;

import java.io.IOException;
import java.io.InputStream;
import java.sql.*;
import java.util.Properties;

public class JdbcUtils {
    private static String driver = null;
    private static String url = null;
    private static String username = null;
    private static String password = null;

    static {
        try {
            InputStream inputStream = JdbcUtils.class.getClassLoader().getResourceAsStream("db.properties");
            Properties properties = new Properties();
            properties.load(inputStream);

            driver = properties.getProperty("driver");
            url = properties.getProperty("url");
            username = properties.getProperty("username");
            password = properties.getProperty("password");

            //1.驱动只用加载一次
            Class.forName(driver);


        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

    //获取连接
    public static Connection getConnection() throws SQLException {
        return DriverManager.getConnection(url, username, password);
    }

    //释放连接资源
    public static void release(Connection conn, Statement st, ResultSet rs){
        if (rs!=null){
            try {
                rs.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
        if (st!=null){
            try {
                st.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
        if (conn!=null){
            try {
                conn.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
    }
}

2.编写增删改的方法–TestInsert.java

package com.zhang.test.Lesson;

import com.zhang.test.JdbcUtils;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class TestInsert {
    public static void main(String[] args) {
        Connection connection = null;
        Statement statement = null;
        ResultSet resultSet = null;

        try {
            connection = JdbcUtils.getConnection();
            statement = connection.createStatement();
            String sql = "INSERT INTO users(id, name, password, birthday)" +
                    "VALUES(5, '海洋', '124345', '2020-02-03')";
            int i = (int) statement.executeLargeUpdate(sql);
            if (i>0){
                System.out.println("插入成功");
            }
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }finally {
            JdbcUtils.release(connection, statement, resultSet);
        }
    }
}

3.编写查询的方法–TestSelect.java

package com.zhang.test.Lesson;

import com.zhang.test.JdbcUtils;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class TestSelect {
    public static void main(String[] args) {
        Connection connection = null;
        Statement statement = null;
        ResultSet resultSet = null;

        try {
            connection = JdbcUtils.getConnection();
            statement = connection.createStatement();
            String sql = "SELECT * FROM users";
            resultSet = statement.executeQuery(sql);  //查询完毕回返回一个结果集
            while (resultSet.next()){
                System.out.println("id：" + resultSet.getObject("id"));
                System.out.println("name：" + resultSet.getObject("name"));
                System.out.println("password：" + resultSet.getObject("password"));
                System.out.println("birthday：" + resultSet.getObject("birthday"));
            }
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }finally {
            JdbcUtils.release(connection, statement, resultSet);
        }
    }
}

4.配置文件–db.properties

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

5.SQL注入
sql存在漏洞，会被攻击导致数据泄露 SQL会被拼接 or

package com.zhang.test.Lesson;

import com.zhang.test.JdbcUtils;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

import static com.zhang.test.JdbcUtils.getConnection;

public class SQL_in {
    public static void main(String[] args) {

        //SQL注入
        login("' or '1=1","123456");
    }
    public static void login(String name,String password){
        
        Connection conn =null;
        Statement st = null;
        ResultSet rs =null;
        
        try {
            conn = getConnection();//获取连接
            st = conn.createStatement();//获取SQL执行对象
            String sql = "select * from users where `NAME`='"+ name +"'  AND `PASSWORD`='"+ password +"'" ;
            rs=st.executeQuery(sql);//查询完毕返回结果集

            while (rs.next()){
                System.out.println(rs.getString("NAME"));
            }
            JdbcUtils.release(conn,st,rs);
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            JdbcUtils.release(conn,st,rs);
        }
    }
}

9.5.PreparedStatement对象

PreparedStatement 可以防止SQL注入，效率更高。

package com.zhang.test.Lesson;

import com.zhang.test.JdbcUtils;
import java.sql.*;

public class TestInsertPara {
    public static void main(String[] args) {
        Connection connection = null;
        PreparedStatement statement = null;
        ResultSet resultSet = null;

        try {
            connection = JdbcUtils.getConnection();

            //区别
            //使用？占位符代替参数
            //PreparedStatement防止SQL注入的本质，把传递进来的参数当做字符，假设其中存在转义字符，比如说‘，会被直接转义。
            String sql = "INSERT INTO users(id,name,password,birthday) VALUES(?,?,?,?)";

            statement = connection.prepareStatement(sql); //预编译SQL，先写sql，然后不执行

            //手动给参数赋值
            statement.setInt(1,6);
            statement.setString(2,"ocean");
            statement.setString(3,"123789");
            //注意点： sql.Date     数据库     java.sql.Date()
            //        util.Date   java      new Date.getTime() 获得时间戳
            statement.setDate(4,new java.sql.Date(new java.util.Date().getTime()));

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

        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }finally {
            JdbcUtils.release(connection, statement, resultSet);
        }
    }
}

9.6.JDBC事务

要么都成功，要么都失败
ACID原则

原子性：要么全部完成，要么都不完成。
一致性：结果总数不变。
隔离性：多个进程互不干扰。
持久性：一旦提交不可逆，持久化到数据库了。

隔离性的问题：

脏读：一个事务读取了另一个没有提交的事务。
不可重复读：在同一个事务内，重复读取表中的数据，表发生了改变。
虚读（幻读）：在一个事务内，读取到了别人插入的数据，导致前后读出来的结果不一致。

代码实现

开启事务conn.setAutoCommit(false)。
一组业务执行完毕，提交事务。
可以在catch语句中显示的定义回滚，但是默认失败会回滚。

package com.kuang.lesson04;

import com.kuang.lesson02.utils.JdbcUtils;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

public class Action {
    public static void main(String[] args) {

        Connection conn =null;
        PreparedStatement ps = null;
        ResultSet rs = null;
    
        try {
            conn = JdbcUtils.getConnection();
            //关闭数据库的自动提交功能， 开启事务
            conn.setAutoCommit(false);
            //自动开启事务
            String sql = "update account set money = money-500 where id = 1";
            ps =conn.prepareStatement(sql);
            ps.executeUpdate();
            String sql2 = "update account set money = money-500 where id = 2";
            ps=conn.prepareStatement(sql2);
            ps.executeUpdate();
    
            //业务完毕，提交事务
            conn.commit();
            System.out.println("操作成功");
        } catch (Exception e) {
            try {
                //如果失败，则默认回滚
                conn.rollback();//如果失败，回滚
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
            e.printStackTrace();
        }finally {
            try {
                JdbcUtils.release(conn,ps,rs);
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
    }
}

m0_51348967

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JavaWeb入门---参考狂神说

1.HTTP1.1.HTTP介绍        HTTP是一种超文本传输协议，是一个基于请求与响应，无状态的，应用层的协议，常基于TCP/IP协议传输数据，互联网上应用最为广泛的一种网络协议,所有的WWW文件都必须遵守这个标准。设计HTTP的初衷是为了提供一种发布和接收HTML页面的方法。客户端发出的是请求协议，服务端发出的是响应协议1.2.HTTP之URL    &nb
复制链接

扫一扫