JavaWeb

1、基本概念

1.1、前言

web开发

• web，网页的意思
• 静态web
  • HTML、CSS
  • 提供给所有人看的数据始终不变
• 动态WEB
  • 提供给所有人看的数据始终会发证变化，每个人在不同的时间，地点看到的信息各不相同
  • 技术栈：Servlet/JSP，ASP，PHP

在Java中，动态WEB资源开发的技术统称为JAVAWEB

1.2、web的应用程序

web应用程序，可以提供浏览器访问的程序包含的部分

• HTML、CSS、JS
• JSP、Servlet
• Java
• jar包
• 配置文件（properties）

1.3、静态web

• 静态页面的缺点
  • Web页面无法更新动态，所有的用户看到的都是一个页面
    • 轮播图、点击特效、伪动态
    • JavaScript（最常用）
    • VBScript
  • 无法与数据库进行交互（数据无法持久化用户无法交互）

1.4、动态Web

页面会动态展示，“web的页面展示的效果因人而异“。

缺点：

• 加入服务器的动态web的资源出现了错误，我们需要重新编写我们的后台程序
  • 停机维护

优点:

• web页面可以动态的更新，每个用户所看到的页面不是一个页面
• 它可以与数据库进行交互，保证数据的持久化。

2、web服务器的讲解

2.1、常见的web服务器

• ASP

  • 微软开创的变成语言，在HTML语句中添加java代码

  • <%  java代码%>
    

• PHP

  • 优点：运行速度快，性能好，跨平台、代码简洁。
  • 缺点：不适合大型的项目开发，无法承受大量的数据。

• JSP/Servlet JSP的本质是Servlet

  • 优点：可以承载三高，高并发、高可用、高性能。

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

2…2、web服务器

• IIS
• tomcat

Tomcat 5支持最新的Servlet 2.4 和JSP 2.0 规范。因为Tomcat 技术先进、性能稳定，而且免费，因而深受Java 爱好者的喜爱并得到了部分软件开发商的认可，成为目前比较流行的Web 应用服务器。

Tomcat 服务器是一个免费的开放源代码的Web 应用服务器，属于轻量级应用服务器，在中小型系统和并发访问用户不是很多的场合下被普遍使用，是开发和调试JSP 程序的首选。实际上Tomcat是Apache 服务器的扩展，但运行时它是独立运行的，所以当你运行tomcat 时，它实际上作为一个与Apache 独立的进程单独运行的。

诀窍是，当配置正确时，Apache 为HTML页面服务，而Tomcat 实际上运行JSP 页面和Servlet。另外，Tomcat和IIS等Web服务器一样，具有处理HTML页面的功能，另外它还是一个Servlet和JSP容器，独立的Servlet容器是Tomcat的默认模式。不过，Tomcat处理静态HTML的能力不如Apache服务器。目前Tomcat最新版本为10.0.5**。**

作用：是一种被动操作，处理一些客户端的请求并进行返回请求

3、Tomcat

3.1、Tomcat的安装和配置

注：在tomcat中常见的问题

• java环境变量配置存在问题，出现闪退现象
• 出现闪退还可能是自己点电脑的兼容性问题
• tomcat的中文乱码问题

3.2、tomcat的文件配置问题

注：在tomcat中其主要的核心配置文件在conf文件夹下的server.xml文件中

其可以配置端口号，可以配置主机的名称。

https的端口号默认是443

mysql的端口号默认是3306

http的端口号默认的是80

• 其默认的主机名为local hos t->127.0.01
• 默认的网站的存放位置是：webapp

高难度面试题

请你谈谈网站是如何让访问的

• 输入一个域名；点击回车

• 检查本机的hosts文件夹下是否有这个域名的映射

• 如果有，返回对应的IP地址

• 如果没有，去DNS服务器上去寻找（全世界的域名都在上边）

4.配置环境变量

3.3、发布一个外部网站

将自己写的网页放在tomcat中的webapp的文件下便可以进行访问

一个网站应该有的结构

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

4、HTTP

4.1、HTTP的定义

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

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

4.2、两个时代

• http1.0
  • HTTP/1.0:代表客户端与web服务器连接后，只能获得一个web资源，断开连接
• http2.0
  • HTTP/1.1：代表客户端与web服务器连接后，可以获得多个web资源，断开连接

4.3、Http请求

• 客户端发送请求（Request）到服务器

1. 请求行

   • 请求行中的请求方式：GET
   • 请求方式：GET 、POST
   • get：请求能够携带的参数比较的少，大小有限制，会在浏览器的URL地址栏显示数据的内容，不安全但是高效
   • post：请求能够携带的参数没有限制，大小没有限制，不会在浏览器的URL地址栏显示数据的内容，安全但是不高效

   2.消息头

   Accept:告诉浏览器所支持的数据类型
   Accept-Encoding：表示浏览器支持的编码格式 GBK UTF-8 GB2312 ISO8859-1
   Accept-Language:告诉浏览器的语言环境
   Cache-Control：缓存控制
   Connection：告诉浏览器请求断开还是保持连接
   Host：表示主机.....
   

4.4、Http相应

服务器–响应–客户端

1、 响应体

Accept:告诉浏览器所支持的数据类型
Accept-Encoding：表示浏览器支持的编码格式 GBK UTF-8 GB2312 ISO8859-1
Accept-Language:告诉浏览器的语言环境
Cache-Control：缓存控制
Connection：告诉浏览器请求断开还是保持连接
Host：表示主机.....
Refresh:告诉客户端，多久刷刷一次
Location：让网页重定向

2、响应状态码（重点）

200：代表相应成功

3xx：请求重定向

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

404：找不到资源

• 资源不存在

5xx：服务器代码错误 500（最为常见）

502：网关错误

常见的面试题

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

5、Maven

5.1、Maven项目架构管理工具

作用：方便导入jar包

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

• 有约束不要去违反。必须按照规则进行

Maven会规定好如何进行编写Java，必须按照这个规范

5.2、下载安装Maven

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

5.3、Maven环境配置

配置如下配置

• M2_HOME:路径为maven目录下的bin目录
• MAVEN_HOME:maven的家目录
• PATH：配置maven下的bin目录

检测是否成功

5.4、阿里云镜像

• 镜像：mirrors
  • 加速相关包的下载
• 国内金阿姨使用阿里云的镜像

<mirror>
<id>alimaven</id>
<name>aliyun maven</name> <url>http://maven.aliyun.com/nexus/content/groups/public/</url> <mirrorOf>central</mirrorOf>
</mirror>

5.5、本地仓库

建立一个本仓库

 <localRepository>D:\Maven\apache-maven-3.8.1\maven-repo</localRepository>

5.6、在IDEA中使用maven

1、创建一个新的工程

2、选择Maven项目

3、项目的命名

4、选择自己的maven文件的位置

5、点击包的自动导入，最终显示导入成功

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

1、先创建一个新的项目

2、选择创建一个maven项目，但是不添加任何的选项

5.8、标记文件夹

第二种方法

5.9、maven中文件代表的含义

5.10、pom文件

pom.xml是maven的配置文件

maven可能存在问题

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

maven仓库

https://search.maven.org/

5.11、API

定义:API（Application Programming Interface，应用程序接口）是一些预先定义的接口（如函数、HTTP接口），或指软件系统不同组成部分衔接的约定。 [1] 用来提供应用程序与开发人员基于某软件或硬件得以访问的一组例程，而又无需访问源码，或理解内部工作机制的细节。

6、servlet

6.1、servlet简介

• servlet是用来开发动态web的一门技术
• servlet本质就是一个接口
• 开发servlet小程序的步骤
  • 编写一个类，实现servlet接口
  • 把开发好的java类部署到web服务器

把实现了servlet接口的java程序叫做Servlet

6.2、HelloServlet

注：在sun公司中的Servlet中存在两个Servlet的实现接口 HttpServlet，GenericServlet

1. 构建一个maven项目，删掉里面的东西，剩下的空的maven的框架便是主框架

2. 关于maven父子工程的理解（在主工程下在创建一个子工程）

   父项目中会用

    <modules>
           <module>Servlet</module>
    </modules>
   

   子项目中

   <parent>
           <artifactId>javaweb-03-maven</artifactId>
           <groupId>org.example</groupId>
           <version>1.0-SNAPSHOT</version>
   </parent>
   
   

   在maven父子工程子项目可以使用父项目中的jar包类似与java中的继承关系

3. Maven项目

4. 创建servlet项目

package com.xiang;



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

public class HelloServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("使用了doGet方法");
        PrintWriter writer = resp.getWriter();
        writer.println("你好世界");
    }

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

配置web.xml文件

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
                      http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0"
         metadata-complete="true">

  <display-name>Tomcat Documentation</display-name>
  <description>
    Tomcat Documentation.
  </description>
  <servlet>
    <servlet-name>hello</servlet-name>
    <servlet-class>com.xiang.HelloServlet</servlet-class>
  </servlet>
  <servlet-mapping>
    <servlet-name>hello</servlet-name>
    <url-pattern>/xiang</url-pattern>
  </servlet-mapping>
</web-app>

tomcat的配置

6.3、servlet原理

servlet是由web服务器调用

6.4、Mapping

1. 一个请求可任意指定一个映射路径

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

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

3. 一个Servlet可以指定通用的路径

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

4. 指定一些后缀

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

   注：加后缀的时候*前边不能天年任何的路径

5. 优先级问题

   制定了固有的映射级路径优先级最高，找不到则会走默认的路径

6.5、ServletContext

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

ServletContext类似于一个Servlet的数据存储库

6.5.1共享数据

进行数据的存放

package com.li;

import org.omg.IOP.ServiceContext;
import org.omg.IOP.ServiceContextListHolder;

import javax.servlet.ServletContext;
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 test extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp)  {
//        ServletContext servletContext = this.getServletContext();
        //this.getInitparameter 初始化参数
        //this.getServletConfig  Servlet配置
        //this.getServletContext  Servlet的上下文
        ServletContext servletContext = this.getServletContext();
        String username="李四";
        servletContext.setAttribute("username",username);
    }

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

进行数据的存放，注意先访问test页面进行数据的存入

进行数据的读取

package com.li;

import javax.servlet.ServletContext;
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 ServletContextTest extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        ServletContext servletContext = this.getServletContext();
        String username = (String) servletContext.getAttribute("username");
        resp.setContentType("text/html");
        resp.setCharacterEncoding("utf-8");
        resp.getWriter().print("name="+username);
    }

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

注：当数据的存入之后才能进行数据的读取

注:ServletContext是HttpServlet中的一个方法

6.5.2、获取初始化的参数

getInitparameter() 在xml文件中中设置相关的初始化的内容，在进行读取

 <context-param>
    <param-name>ts1</param-name>
    <param-value>djebfjiebfjbejfbjsebfjh</param-value>
  </context-param>

package com.li;

import javax.servlet.ServletContext;
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 ServletDemo extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        ServletContext context = this.getServletContext();
        String ts1 = context.getInitParameter("ts1");  //获取初始化的参数    Parameter：参数
        resp.getWriter().print("value="+ts1);

    }

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

6.5.3、请求转发

getRequestDispatcher

package com.li;

import javax.servlet.RequestDispatcher;
import javax.servlet.ServletContext;
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 ServletDemo01  extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        ServletContext context = this.getServletContext();
        RequestDispatcher requestDispatcher = context.getRequestDispatcher("/ts1");  //存写跳转的路径
        requestDispatcher.forward(req, resp);  //接收客户端对web服务器的请求
        resp.setContentType("text/html");
        resp.setCharacterEncoding("utf-8");
        resp.getWriter().print("你好世界");
    }
        @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req, resp);
    }
}

<servlet>
    <servlet-name>ts1</servlet-name>
    <servlet-class>com.li.ServletDemo</servlet-class>
  </servlet>
  <servlet-mapping>
    <servlet-name>ts1</servlet-name>
    <url-pattern>/ts1</url-pattern>
  </servlet-mapping>

  <servlet>
    <servlet-name>ServletDemo01</servlet-name>
    <servlet-class>com.li.ServletDemo01</servlet-class>
  </servlet>
  <servlet-mapping>
    <servlet-name>ServletDemo01</servlet-name>
    <url-pattern>/ts2</url-pattern>
  </servlet-mapping>
  

6.5.4、读取文件

properties

package com.li;

import org.omg.Dynamic.Parameter;

import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.Properties;

public class ServletDemo02 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        ServletContext context = this.getServletContext();
        BufferedReader reader = new BufferedReader(new InputStreamReader(context.getResourceAsStream("/WEB-INF/classes/db.properties"), "GBK"));  //进行文件的编码，消除乱码问题

//        InputStream in = context.getResourceAsStream("/WEB-INF/classes/db.properties");
        Properties properties=new Properties();
        properties.load(reader);
        String username = properties.getProperty("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);
    }
}

在web项目获取资源文件的时候建议采用在web中的资源文件的相对位置

解决读取资源文件中的乱码问题

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

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

6.6、HttpServletResponse

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

• 如果要获取客户端请求的参数，找HttpServletRequest
• 如果给客户端响应一些参数，找HTTP Servlet Response

1、简单分类

1. 负责想浏览器发送数据的方法
2. 负责项浏览器发送响应头的方法
3. 响应的状态码

2、文件下载

1. 向浏览器输出消息

2. 可以进行下载文件

   1. 要获取下载文件的路径
   2. 下载的文件名
   3. 设置想办法让浏览器支持我们下载的东西
   4. 获取下载文件的输入流
   5. 创建缓冲区
   6. 获取OutPutStream对象
   7. 将FileOutPutStream流入到buffer缓冲区
   8. 将OutPutStream缓冲区的数据输出到客户端

   package com.li.response;
   
   import javax.servlet.ServletContext;
   import javax.servlet.ServletException;
   import javax.servlet.ServletOutputStream;
   import javax.servlet.http.HttpServlet;
   import javax.servlet.http.HttpServletRequest;
   import javax.servlet.http.HttpServletResponse;
   import java.io.FileInputStream;
   import java.io.FileOutputStream;
   import java.io.IOException;
   import java.net.URLEncoder;
   
   public class responseDemo  extends HttpServlet {
   
       @Override
       protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
           //. 要获取下载文件的路径
           ServletContext context = this.getServletContext();
           String contextPath ="D:\\IDEA\\javaweb-01-maven\\javaweb-04-maven\\response\\target\\response\\WEB-INF\\classes\\1.png" ;
           System.out.println(contextPath);
           //2. 下载的文件名
           String fileName = contextPath.substring(contextPath.lastIndexOf("//") + 1);
   
           //3. 设置想办法让浏览器支持我们下载的东西
           resp.setHeader("Content-disposition","attachment;filename=" + URLEncoder.encode(fileName,"utf-8"));
           //4. 获取下载文件的输入流
           FileInputStream in = new FileInputStream(contextPath);
           //5. 创建缓冲区
           int len=0;
           byte[] bytes = new byte[1024];
           //6. 获取OutPutStream对象
           ServletOutputStream outputStream = resp.getOutputStream();
           //7. 将FileOutPutStream流入到buffer缓冲区  将OutPutStream缓冲区的数据输出到客户端
           while ((len=in.read(bytes))>0){
              outputStream.write(bytes,0,len);
           }
       }
   
       @Override
       protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
           doGet(req, resp);
       }
   
   }
   
   

   

3、验证码功能

• 前端实现

• 后端实现（用到java的图片类）生成一个图片

  package com.li.response;
  
  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 responseDemo01 extends HttpServlet {
      @Override
      protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
          //设置页面刷新  通过refresh进行设置，设置时间间隔为3秒
          resp.setHeader("refresh","3");
         //在内存中创建一个图片
          BufferedImage image = new BufferedImage(80,20,BufferedImage.TYPE_INT_RGB);
          //获取图片
          Graphics2D  graphics= (Graphics2D) image.getGraphics();
          //设置图片的背景颜色
          graphics.setColor(Color.white);//设置图片的背景颜色
          graphics.fillRect(0,0,80,20);  //进行图片的填充
          //给图片编写数据
          graphics.setColor(Color.black);
          graphics.setFont(new Font("null",Font.BOLD,20));
          graphics.drawString(makeNum(),0,20);
          //告诉浏览器这个请求用图片的方式打开
          resp.setContentType("image/jpeg");
          //网站存在缓存，不让网站进行缓存
          resp.setDateHeader("expires",-1);
          resp.setHeader("Cache-Control","no-cache");
          resp.setHeader("Pragma","no-cache");
          //把图写给浏览器
          boolean write = ImageIO.write(image,"jpg", resp.getOutputStream());
      }
  
  
      //设置随机数
      private String makeNum() {
          Random random=new Random();
          String s = random.nextInt(9999999) + "";//将int类型转换为String
          StringBuffer sb=new StringBuffer();
          for (int i = 0; i <7-s.length() ; i++) {
              sb.append("0");
  
          }
          return s;
      }
  
      @Override
      protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
          doGet(req, resp);
      }
  }
  
  

  

4、实现重定向

本质：

面试题：重定向与转向的区别

相同点

• 页面偶会进行跳转

不同点

• 请求转发的时候，url不会产生变化

• 重定向的时候，url地址栏会发生变化；

  package com.li.response;
  
  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 responseDemo02 extends HttpServlet {
      @Override
      protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
          resp.sendRedirect("ts2");
          resp.getWriter().print("欢迎来到这个页面");
      }
  
      @Override
      protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
          doGet(req, resp);
      }
  }
  
  

  

页面重定向

package com.li.response;

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 requestDemo extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("进入该方法");
        String username = req.getParameter("username");
        String password = req.getParameter("password");
        System.out.println("username是"+username+"password是"+password);
        resp.sendRedirect("/response_war/success.jsp");  //在填写跳转的路径的时候注意要写全

    }

    @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>
<body>
<form action="${pageContext.request.getContextPath()}/t4 " method="get">
    <p>
      <span>用户名：</span>  <input type="text" name="username"/>
    </p>
    <p>
        <span>密码</span>
        <input type="password" name="password"/>
    </p>
    <input type="submit" value="提交"/>
</form>
</body>
</html>

登录成功的页面

<%--
  Created by IntelliJ IDEA.
  User: dell
  Date: 2021/9/20
  Time: 23:19
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<h1>登录成功</h1>

</body>
</html>

6.7、HttpServletRequest

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

6.7.1、获取前端的参数、请求转发

package com.li.response;

import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.lang.reflect.Array;

public class requestDemo01 extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        req.setCharacterEncoding("utf-8");
        String username = req.getParameter("username");
        String password = req.getParameter("password");
        System.out.println(username);
        System.out.println(password);
        String[] ch1s = req.getParameterValues("ch1");
        for (int i = 0; i < ch1s.length; i++) {
            System.out.println(ch1s[i]);
        }
        ServletContext context = this.getServletContext();
        context.getRequestDispatcher("/success.jsp").forward(req,resp);  //注意进行页面的转发
        resp.setCharacterEncoding("utf-8");
    }

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

注：一次性获取多个值的时候采用 getParameterValues()这个方法并返回一个数组

7、Cookie、session

7.1、会话

会话：用户打开一个浏览器，打开很多的链接或者是访问多个web资源，关闭浏览器，这个过程被称为会话。

**有状态会话：**一个网站怎样证明你访问过。

7.1.2、保存会话的两种技术

cookie

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

session

• 服务器技术（服务器行为）利用这个技术，可以保存用户的会话信息，可以把信息或者数据放在session中

常见的例子：网站登录之后，你下次在登陆，直接登陆进去

7.2、cookie

1. 在请求中拿到Cookie信息
2. 服务器想用给客户端cookie

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

一个网站的cookie是否存在上限

• 一个Cookie只能保存一个信息
• 一个Web站点可以给浏览器发送多个Cookie，一个浏览器的上限大约是300个，每个站点最多是20个
• Cookie的大小限制在4KB左右

删除Cookie

• 不设置有效期，关闭浏览器自动失效
• 设置有效期的时间为0s，时间是以秒为单位

package com.li.Cookies;

import javax.servlet.ServletException;
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;

public class CookieDemo extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String value ;
        resp.setContentType("text/html");
        resp.setCharacterEncoding("utf-8");
        Cookie[] cookies = req.getCookies();  //可以有多个Cookie
        PrintWriter out = resp.getWriter();
        Cookie cookie = new Cookie("name", "lisi");
        value = cookie.getValue();

        if (cookies.equals(value)) {
            out.write("，该用户曾经登陆过"+value);
        } else {
            out.write("该用户没有相关登录信息");
        }
        resp.addCookie(cookie);

    }


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

编码解码

URLEncoder.encode("value","UTF-8")  //进行编码
URLDecoder.decode("value","utf-8");   //进行解码

7.3、session（重点）

什么是Session

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

Session与Cookie的区别

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

Sesison一般的使用场景

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

使用Session

package com.li.Session;

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

public class SessionDemo 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","张三");
        PrintWriter out = resp.getWriter();
        //获取Session的ID
        String id = session.getId();
        //判断Seeion是否为新设置的  session.isNew()
            out.write("Session为新设置的，Session的id为"+id);
    }

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

package com.li.Session;

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

public class SessionDemo01 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        HttpSession session = req.getSession();
        //获取Session
        String name = (String) session.getAttribute("name");
        
        System.out.println(name);
    }

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

package com.li.Session;
import com.li.pojo.Parent;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.io.IOException;
import java.io.PrintWriter;

public class SessionDemo02 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.setContentType("text/html;charset=utf-8");
        req.setCharacterEncoding("utf-8");
        resp.setCharacterEncoding("utf-8");
        HttpSession session = req.getSession();
        //对Session设置值
        session.setAttribute("name",new Parent("张三","男"));
        PrintWriter out = resp.getWriter();
        out.write("进入第三个页面");

    }

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

package com.li.Session;

import com.li.pojo.Parent;

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

public class SessionDemo03 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.setContentType("text/html;charset=utf-8");
        req.setCharacterEncoding("utf-8");
        resp.setCharacterEncoding("utf-8");
        HttpSession session = req.getSession();
        Parent parent = (Parent) session.getAttribute("name");
        resp.getWriter().write("进入第四个页面");
        System.out.println(parent);
    }

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

package com.li.Session;

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

public class SessionDemo04 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.setContentType("text/html;charset=utf-8");
        req.setCharacterEncoding("utf-8");
        resp.setCharacterEncoding("utf-8");
        HttpSession session = req.getSession();
        //删除Session
        session.removeAttribute("name");
        resp.getWriter().write("删除Session");
    }

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

 <session-config>
<!--    设置Session最大的生命周期， 以分钟为单位，表示10分钟之后Session自动删除-->
    <session-timeout>10</session-timeout>
  </session-config>

8、JSP

8.1、什么是JSP

Java Server Pages:java服务端页面

特点

• jsp与Html的语法比较类似
• 区别
  • html只给用户提供静态数据
  • JSP页面中可以嵌入java代码，为用户提供动态数据

8.2、JSP的原理

在jsp的页面中

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

只要是Html代码，就会被转换为out.write(“name”)

8.3、JSP的基础语法

热河语言都有自己的语法，jsp作为java技术中的一种应用，它拥有一些自己扩充的语法，java中的所有语法他都支持

JSP表达式：

<%= new java.util.Date()%>//获取当前时间
//作用将程序的结果输出到客户端
<%= 表达式或变量%>

jsp中maven导入的包

 <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>4.0.1</version>
    </dependency>

    <dependency>
      <groupId>javax.servlet.jsp</groupId>
      <artifactId>javax.servlet.jsp-api</artifactId>
      <version>2.3.3</version>
    </dependency>

    <dependency>
      <groupId>jstl</groupId>
      <artifactId>jstl</artifactId>
      <version>1.2</version>
    </dependency>
  

jsp的脚本片段

<%
    int num=0;
	for(int i=1;i<=100,i++){
        num=num+1;
    }
out.println("<h1>sunm="+sum+"</h1>")
    %>

JSP声明

<!%
static {
    System.out.println("Loading Servlet");
}
private int globalvar=0;
public void test(){
    System.out.println("进入了方法test");
}
%>

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

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

8.4、JSP指令

8.5、JSP的内置对象及作用域

在static文件下放置，img、js、plugin、css（插件）

• Pagecontext 存东西
• Request 存东西
• Response
• Session 存东西
• Application【ServletContext】存东西
• config【Servlet Config】
• out
• page（几乎不用）
• excepetion （大多是采用Java的异常）

<%@ page import="javafx.application.Application" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>

<html>
<head>
    <title>Title</title>
</head>
<body>
<%
    pageContext.setAttribute("name1","李四");//保存的数据只在一个页面中有效，
    session.setAttribute("name2","王五");//保存的数据只在一个请求中有效，请求转发会携带则这个数据
    request.setAttribute("name3","赵六");//保存的数据只在一个会话中有效，从打开浏览器到关闭浏览器
    application.setAttribute("name4","陆七");//保存的数据在服务器中有效，从打开服务器到关闭服务器
%>

<%
    String  name1 = (String) pageContext.findAttribute("name1");
    String  name2 = (String) pageContext.findAttribute("name2");
    String  name3 = (String) request.getAttribute("name3");
    String name4 = (String) application.getAttribute("name4");
%>
<h1>
    查询的结果：
    <h2><%= name1%></h2>
    <h2><%= name2%></h2>
    <h2><%= name3%></h2>
    <h2><%= name4%></h2>
</h1>
</body>
</html>

常见的应用的场景

• 客户端向服务器发送请求，产生的数据，用户看完之后就没用了，比如：新闻。用户看完据没用了
• session：客户端向服务器发送请求，产生数据，用户一会还有用，比如购物车
• application：客户端向服务器发送请求，产生数据，一个用户用完了，其他的用户还可以使用，比如：聊天数据

8.6、jsp标签、jstl标签、el表达式

EL表达式你 ${}

maven文件

 <dependency>
      <groupId>javax.servlet.jsp.jstl</groupId>
      <artifactId>jstl-api</artifactId>
      <version>1.2-rev-1</version>
    </dependency>

<!--     https://mvnrepository.com/artifact/taglibs/standard -->
        <dependency>
          <groupId>taglibs</groupId>
          <artifactId>standard</artifactId>
          <version>1.1.2</version>
        </dependency>

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

jsp标签

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<%--表示页面进行转向--%>
<jsp:forward page="indexDemo02.jsp">
    <jsp:param name="username" value="zhanghsan "/>
    <jsp:param name="password" value="123456"/>
</jsp:forward>
</body>
</html>



<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<h1>Hello world</h1>
<%--获取其中的值--%>
<%= request.getParameter("username")%>
<%= request.getParameter("password")%>
</body>
</html>

JSTL表达式

定义:JSP标准标签库（JSTL）是一个JSP标签集合，它封装了JSP应用的通用核心功能。

优点:在一定程度上弥补了HTML的不足,他自定义了很多的标签,标签的功能和java

代码一样

JSTL的核心标签

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

• 标签的分类
  • 核心标签(掌握部分)
  • 格式化标签
  • Sql标签
  • XML标签

菜鸟教程:https://www.runoob.com/jsp/jsp-jstl.html

JSTL的使用方法

1. 当如相应的标签库
2. 使用其中的方法
3. 在tomcat中也需要导入包,不然会报错解析错误

例子：

<c:if test="<boolean>" var="<string>" scope="<string>">
   ...
</c:if>

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
}<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<form action="indexDemo04.jsp" method="post">
    <input type="text" name="username" value=""/>
    <input type="password" name="password" value=""/>
    <input type="submit" value="登录"/>
</form>
<c:if test="${param.username.equals('admin')}" var="valueDemo" >
    <c:out value="valueDemo" />
</c:if>
</body>
</html>



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

例子

<c:choose>
    <c:when test="<boolean>">
        ...
    </c:when>
    <c:when test="<boolean>">
        ...
    </c:when>
    ...
    ...
    <c:otherwise>
        ...
    </c:otherwise>
</c:choose>



<c:set
   var="<string>"
   value="<string>"
   target="<string>"
   property="<string>"
   scope="<string>"/>

<%@ page language="java" contentType="text/html; charset=UTF-8"
         pageEncoding="UTF-8"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<html>
<head>
    <title>c:choose 标签实例</title>
</head>
<body>
<c:set var="salary" scope="session" value="${2000*2}"/>
<c:choose>
    <c:when test="${salary <= 0}">
        太惨了。
    </c:when>
    <c:when test="${salary > 1000}">
        不错的薪水，还能生活。
    </c:when>
    <c:otherwise>
        什么都没有。
    </c:otherwise>
</c:choose>
</body>
</html>

注：设置值的时候注意添加其作用域

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

forEach 语法格式

<c:forEach
    items="<object>"
    begin="<int>"
    end="<int>"
    step="<int>"
    var="<string>"
    varStatus="<string>">

    ...

<%@ page language="java" contentType="text/html; charset=UTF-8"
         pageEncoding="UTF-8"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<html>
<head>
    <title>c:forEach 标签实例</title>
</head>
<body>
<c:forEach var="i" begin="1" end="5">
Item <c:out value="${i}"/><p>
    </c:forEach>
</body>
</html>

9、javaBean

实体类

javaBean有特定的写法：

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

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

ORM:对象的映射关系

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

10、MVC三层架构

10.1、MVC的三层架构

MVC的定义： Model 、View 、Controller；模型、视图、控制器

注

• Servlet和jsp都可以写Java代码：为了更好的维护和使用；Servlet专注于处理请求，以及控制视图跳转Jsp专注于显示数据
• model：控制业务的操作、保存数据、修改数据、删除数据、查询数据

Model

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

View

• 展示数据
• 提供链接发起Servlet请求

controller（Servlet)

• 接受用户的请求：（req：请求参数、Session等信息）
• 交给业务层处理对应的代码
• 控制视图的跳转

一个项目一般额流程

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

11、过滤器（Filter）

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

例

• 处理中文乱码

• 登陆验证…

  

Filter的开发步骤

1. 导包
2. 编写过滤器
   • 导包的时候注意不要弄错

注

• 过滤中的所有的代码，在过滤器请求的时候都会执行

• 必须要让过滤器继续通行

  ControllerDemo
      
    package com.li.Controller;
  
  import com.li.Filter.FilterDemo;
  
  import javax.servlet.*;
  import javax.servlet.http.HttpServlet;
  import javax.servlet.http.HttpServletRequest;
  import javax.servlet.http.HttpServletResponse;
  import java.io.IOException;
  
  public class ControllerDemo extends HttpServlet {
  
      FilterChain filterChain;
      @Override
      protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
  
          FilterChain filterChain = new FilterChain() {
              @Override
              public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse) throws IOException, ServletException {
  
              }
          };
          FilterDemo filterDemo = new FilterDemo();
          filterDemo.doFilter(req,resp,filterChain);
          resp.getWriter().write("你好，世界");
  
      }
  
      @Override
      protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
          doGet(req, resp);
      }
  
  
  }
  
  
  
  
  package com.li.Filter;
  
  
  import javax.servlet.*;
  import javax.servlet.http.HttpServlet;
  import java.io.IOException;
  
  public class FilterDemo extends HttpServlet implements Filter {
      //事务的初始值
      @Override
      public void init(FilterConfig filterConfig) throws ServletException {
  
      }
      //进行过滤器的创建事务的处理
      @Override
      public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
          System.out.println("进入了这个发方法");
          servletRequest.setCharacterEncoding("GBK");
          servletResponse.setCharacterEncoding("GBK");
          //保证在得到了过滤之后还能继续的进行传输
          filterChain.doFilter(servletRequest,servletResponse);
      }
  
      //进行过滤器的销毁
      @Overr
      ide
      public void destroy() {
          super.destroy();
      }
  }
  
  

 <servlet>
    <servlet-name>ControllerDemo</servlet-name>
    <servlet-class>com.li.Controller.ControllerDemo</servlet-class>
  </servlet>
  <servlet-mapping>
    <servlet-name>ControllerDemo</servlet-name>
    <url-pattern>/ControllerDemo</url-pattern>
  </servlet-mapping>

//进行Filter的注册
  <filter>
    <filter-name>FilterDemo</filter-name>
    <filter-class>com.li.Filter.FilterDemo</filter-class>
  </filter>
  <filter-mapping>
    <filter-name>FilterDemo</filter-name>
    <url-pattern>/servlet/*</url-pattern>
  </filter-mapping>

通过过滤来处理中文的乱码问题

12、监听器

实现一个监听器的接口

注：监听器需要在web.xml中进行注册

13、过滤器、监听器的应用

监听器，在GUI中常用

package com.li.Listener;

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

public class Demo extends Frame {
    public static void main(String[] args) {
        Frame frame = new Frame("中秋快乐");//设置页面的标题
        Panel panel=new Panel();//设置面板
        frame.setLayout(null);//设置窗体的布局
        frame.setBounds(10,20,400,400);
        frame.setBackground(Color.CYAN);

        panel.setBounds(60,60,200,200);
        panel.setBackground(Color.WHITE);

        frame.add(panel);
        frame.setVisible(true);
        //设置监听时间
        frame.addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosing(WindowEvent e) {
               System.exit(0);//进行关闭事件
            }
        });


    }
}

用户登陆后就进入主页，注销后无法登录（过滤器）

14、JDBC

JDBC：java连接数据库

固定步骤

1. 加载驱动
2. 连接数据库
3. 向数据库发送SQL的对象Statement：CRUD
4. 编写SQL（根据业务编写不同的SQL语句）
5. 执行SQL
6. 关闭连接

注：在数据库的编写之中尽量的采用prepareStatement

package com.li.Dao;


import java.sql.*;

public class Daodemo0 {
    public static void main(String[] args) throws ClassNotFoundException, SQLException {
        String url = "jdbc:mysql://localhost:3306/school?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT%2B8&useSSL=false";
        String root="root";
        String password="lyj18366635303";
        String driver = "com.mysql.cj.jdbc.Driver";
        Class.forName(driver);
        Connection connection = DriverManager.getConnection(url,root,password);
//        String sql="select * from  class";
        String sql="insert into class (categoryId,pId,categoryName) values(?,?,?)";
        PreparedStatement preparedStatement = connection.prepareStatement(sql);
        preparedStatement.setInt(1,12);
        preparedStatement.setInt(2,12);
        preparedStatement.setString(3,"web");
        int i = preparedStatement.executeUpdate();

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

    }
}

注：在使用statement与PrepareSatatement的区别

Statement
      int i = preparedStatement.executeUpdate(sql);
prepareStatement
     int i = preparedStatement.executeUpdate();

15、事务

要么都成功，要么都失败

ACID原则，保证数据的安全

事务的步骤

1. 开启事务
2. 事务的提交
3. 事务回滚
4. 关闭事务

例子：银行转账

junit 单元测试

   <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
    </dependency>

简单使用

@Test只有在当方法上有用，对相应的方法进行测试

代码

package com.li.test;

import java.io.IOException;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.Properties;

public class affairDemo {
    public static void main(String[] args) throws ClassNotFoundException, SQLException, IOException {

        Connection connection;
       Properties properties =new Properties();
       String path="db.properties";
       InputStream in = affairDemo.class.getClassLoader().getResourceAsStream(path);
       properties.load(in);
        String driver = properties.getProperty("driver");
        String url = properties.getProperty("url");
        String user = properties.getProperty("user");
        String password = properties.getProperty("password");
        Class.forName(driver);
        connection=DriverManager.getConnection(url,user,password);
        connection.setAutoCommit(false);
        String sql="update bill set money=money+2000 where name=?";
        PreparedStatement preparedStatement = connection.prepareStatement(sql);
        preparedStatement.setString(1,"A");
        preparedStatement.executeUpdate();
        String sql1="update bill set money=money-2000 where  name =?" ;
        PreparedStatement preparedStatement1 = connection.prepareStatement(sql1);
        preparedStatement1.setString(1,"B");
        connection.prepareStatement(sql1);
        connection.commit();
        System.out.println("提交成功");
        preparedStatement1.close();
        preparedStatement.close();
        connection.close();
    }
}

16、项目搭建

1. 考虑是否使用maven，之后搭建maven项目

2. 配置tomcat

3. 测试项目是否部署成功

4. 导入项目中需要的jar包

5. 创建项目的包结构

   

6. 编写实体类

   • ORM映射，数据库和类的映射

17、文件的上传和下载

17.1文件上传和下载所使用的包

17.2、文件上传注意的事项

1. 为了保证服务器的安全，上传文件应该放在外界无法直接访问的目录下，比如放于WEB-INF目录下

2. 为防止文件覆盖的现象发生，要为上传文件产生一个唯一的文件名

3. 要限制上传文件的最大值

4. 可以限制上传文件的类型，在上传文件名时，判断后缀名是否合法。

   注：常用的防止文件名重复的方法有：时间戳、-uuid -md5、-位运算法

   需要用到的类的详解

   1. ServletFileUpload类：负责处理上传的文件的数据，并将表单中每个输入向封装成一个Fileltem对象，在使用ServletFileUpload对象解析请求时需要DiskFileltemFactory对象，所以，我们需要在进行解析工作前构造好DiskFileltemFactory对象，通过ServletFileltemUpload对象构造方法或setFileltemFactory()方法进行设置ServletFileUpload对象的fileltemFactory属性

   2. Fileltem类：在HTML页面input必须有name

      表单必须包含一个文件上传输入项的话，这个表单的enctype属性就必须设置为multipart/from-data

   在进行文件上传的时候我们要采用post的方式,因为个体方式存在文件的大小的限制

   进行文件上传所需要的maven依赖

   <!--进行上传文件所需要的maven依赖-->
       <dependency>
         <groupId>commons-fileupload</groupId>
         <artifactId>commons-fileupload</artifactId>
         <version>1.3.1</version>
       </dependency>
       <dependency>
         <groupId>commons-io</groupId>
         <artifactId>commons-io</artifactId>
         <version>2.4</version>
       </dependency>
   

   18、IDEA常用的快捷键

   ctrl+shift+alt：多行操作
   psvm：生成main()方法；
   fori：生成for循环；
   Ctrl+Alt+v：自动补齐返回值类型
   ctrl+o：覆写方法
   ctrl+i：实现接口中的方法
   ctrl+shift+u：大小写转换
   CTRL+SHIFT+Z：取消撤销
   Alt＋Insert：生成构造方法、getter、setter
   ctrl+y：删除当前行
   Ctrl+Shift+J：将选中的行合并成一行
   ctrl+g：定位到某一行
   Ctrl+Shitft+向下箭头：将光标所在的代码块向下整体移动
   Ctrl+Shift+向上箭头：将光标所在的代码块向上整体移动
   Alt+Shift+向下箭头：将行向下移动
   Alt+Shift+向上箭头：将行向上移动
   Ctrl+F：在当前文件中查找
   Ctrl+R：替换字符串
   Ctrl+Shift+F:在全局文件中查找字符串
   Ctrl+Shift+R：在全局中替换字符串
   Ctrl+Shift+Enter：自动补齐{}或者分号;
   Shift+Enter：在当前行的下方开始新行
   Ctrl+Alt+Enter：在当前行的上方插入新行
   Ctrl+Delete：删除光标所在至单词结尾处的所有字符

   19、邮件的传输及其原理

   邮件传输的流程

   

java编写邮件发送所需要的jar包

• java Mail API
• java Activation framework

目的包结构

[外链图片转存中…(img-HU40288k-1635249200351)]

6. 编写实体类

   • ORM映射，数据库和类的映射

17、文件的上传和下载

17.1文件上传和下载所使用的包

[外链图片转存中…(img-Lusv7A7A-1635249200352)]

17.2、文件上传注意的事项

1. 为了保证服务器的安全，上传文件应该放在外界无法直接访问的目录下，比如放于WEB-INF目录下

2. 为防止文件覆盖的现象发生，要为上传文件产生一个唯一的文件名

3. 要限制上传文件的最大值

4. 可以限制上传文件的类型，在上传文件名时，判断后缀名是否合法。

   注：常用的防止文件名重复的方法有：时间戳、-uuid -md5、-位运算法

   需要用到的类的详解

   1. ServletFileUpload类：负责处理上传的文件的数据，并将表单中每个输入向封装成一个Fileltem对象，在使用ServletFileUpload对象解析请求时需要DiskFileltemFactory对象，所以，我们需要在进行解析工作前构造好DiskFileltemFactory对象，通过ServletFileltemUpload对象构造方法或setFileltemFactory()方法进行设置ServletFileUpload对象的fileltemFactory属性

   2. Fileltem类：在HTML页面input必须有name

      表单必须包含一个文件上传输入项的话，这个表单的enctype属性就必须设置为multipart/from-data

   在进行文件上传的时候我们要采用post的方式,因为个体方式存在文件的大小的限制

   进行文件上传所需要的maven依赖

   <!--进行上传文件所需要的maven依赖-->
       <dependency>
         <groupId>commons-fileupload</groupId>
         <artifactId>commons-fileupload</artifactId>
         <version>1.3.1</version>
       </dependency>
       <dependency>
         <groupId>commons-io</groupId>
         <artifactId>commons-io</artifactId>
         <version>2.4</version>
       </dependency>
   

   18、IDEA常用的快捷键

   ctrl+shift+alt：多行操作
   psvm：生成main()方法；
   fori：生成for循环；
   Ctrl+Alt+v：自动补齐返回值类型
   ctrl+o：覆写方法
   ctrl+i：实现接口中的方法
   ctrl+shift+u：大小写转换
   CTRL+SHIFT+Z：取消撤销
   Alt＋Insert：生成构造方法、getter、setter
   ctrl+y：删除当前行
   Ctrl+Shift+J：将选中的行合并成一行
   ctrl+g：定位到某一行
   Ctrl+Shitft+向下箭头：将光标所在的代码块向下整体移动
   Ctrl+Shift+向上箭头：将光标所在的代码块向上整体移动
   Alt+Shift+向下箭头：将行向下移动
   Alt+Shift+向上箭头：将行向上移动
   Ctrl+F：在当前文件中查找
   Ctrl+R：替换字符串
   Ctrl+Shift+F:在全局文件中查找字符串
   Ctrl+Shift+R：在全局中替换字符串
   Ctrl+Shift+Enter：自动补齐{}或者分号;
   Shift+Enter：在当前行的下方开始新行
   Ctrl+Alt+Enter：在当前行的上方插入新行
   Ctrl+Delete：删除光标所在至单词结尾处的所有字符

   19、邮件的传输及其原理

   邮件传输的流程

   [外链图片转存中…(img-0sv6pvxi-1635249200353)]

java编写邮件发送所需要的jar包

• java Mail API
• java Activation framework

[外链图片转存中…(img-uEZTov8Z-1635249200353)]