JAVA WEB学习笔记

最新推荐文章于 2023-10-25 23:46:09 发布
最新推荐文章于 2023-10-25 23:46:09 发布
阅读量462 收藏 1
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43469023/article/details/108979836
版权

Tomcat

web应用服务器：Tomcat

web架构：客户端连接服务器，服务器当中部署web应用服务器，以及一系列Java程序

客户端通过Tomcat访问服务器中的Java程序

Tomcat文件夹

bin:存放各个平台下启动和停止Tomcat服务的脚本

conf：存放各种Tomcat服务器的配置文件

存放不同的端口，serve.xml

lib：存放Tomcat服务运行需要的jar

logs：存放Tomcat运行日志

temp：Tomcat运行的临时文件

webApps：存放用户客户端访问的资源(Java程序)

将程序放在文件夹中启动Tomcat客户端即可访问其中的文件

work：存放Tomcat将JSP转换之后的Servlet文件

URL

IP地址：指的是服务器所在的IP地址

PORT：服务器所提供访问的端口

PN：application当中部署的应用

在IDEA中通过设置Tomcat的deployment

Servlet

  • 什么是Servlet

Servlet是Java web开发的基石，与平台无关（操作系统）的服务器组件，运行在Servlet容器/Web应用服务器/Tomcat，负责和客户端进行通信

  1. 创建并返回基于客户请求的动态HTML页面

  2. 与数据库进行通信

    Servlet可以使用JDBC，成为连接后端和数据库的桥梁

  • 怎样使用Servlet

本质上：Servlet是一组接口，储存在javax.servlet包当中

javax是java包的扩展

package com.eric.servlet;

import javax.servlet.*;
import javax.servlet.annotation.WebServlet;
import java.io.IOException;
import java.io.Writer;
import java.util.Enumeration;

public class MyServlet implements Servlet {
    public MyServlet(){
        System.out.println("constructing");
    }
    @Override
    public void init(ServletConfig servletConfig) throws ServletException {       
        System.out.println(servletConfig.getServletName());                       
        System.out.println(servletConfig.getInitParameter("username"));           
        Enumeration<String> enumeration = servletConfig.getInitParameterNames();
        while (enumeration.hasMoreElements()){
            String element = enumeration.nextElement();
            System.out.println("name:" + element + " value:" + servletConfig.getInitParameter(element));
        }
        ServletContext servletContext = servletConfig.getServletContext();
        System.out.println(servletContext.getContextPath());                       
        System.out.println(servletContext.getServerInfo());                       
        System.out.println(servletContext.getServletContextName());
    }

    @Override
    public ServletConfig getServletConfig() {                                   
        return null;
    }

    @Override                                
    public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {          
        System.out.println("我是servlet，已接受");            
        servletResponse.setContentType("text/html;charset=UTF-8");           
        Writer writer = servletResponse.getWriter();                         
        writer.write("你好");
        String id = servletRequest.getParameter("id");                   
        System.out.println("id = " + id);
    }

    @Override
    public String getServletInfo() {
        return null;
    }

    @Override
    public void destroy() {                                

    }
}
  • 创建Servlet

先行创建包，在创建.java文件（在src文件夹中）

  • 创建映射

浏览器只能访问到web-inf文件夹中的文件，无法直接访问src中的servlet，需要进行映射

  1. 通过XML文件配置的方式
<servlet>
    <servlet-name>myServlet</servlet-name>                       
        <servlet-class>com.eric.servlet.MyServlet</servlet-class>
</servlet>

<servlet-mapping>                                              
    <servlet-name>myServlet</servlet-name>
    <url-pattern>/myservlet</url-pattern>                        
</servlet-mapping>

servlet-name:用于servlet和servlet-mapping映射

servlet-class：指servlet带包文件名

url-pattern:指位于浏览器url之后的内容

  1. 基于注解的方式
@WebServlet("/myservlet")

Servlet的生命周期

  1. 当浏览器访问Servlet的时候，Tomcat会查询当前Servlet的实例化对象是否已经存在，不存在则通过反射机制（不需要main方法）利用无参数构造函数创建对象，存在则执行第三步

  2. 调用init方法完成初始化操作

    参数servletConfig：用于描述Servlet的基本信息

    getServletName()返回Servlet的名称（全类名）

    getInitParameter(String key)获取init参数的值（位于web.xml)

     <servlet>
        <servlet-name>myServlet</servlet-name>    <!--给一个servlet标签对应起类当中的语句（指向服务器）-->
        <servlet-class>com.eric.servlet.MyServlet</servlet-class>
        <init-param>
            <param-name>username</param-name>
            <param-value>admin</param-value>
        </init-param>
        <init-param>
            <param-name>password</param-name>
            <param-value>123123</param-value>
        </init-param>
    </servlet>

    getINitParaNames()返回所有initParameter的name值

    getServletContext()返回servletContext对象，是servlet的上下文

Servlet层次结构

Servlet(顶端接口) —》 GenericServlet —》 HttpServlet(是子类不是接口)

servlet开发往往是直接继承HTTPservlet，只需要覆写两个方法：doGet，doPost（分别是浏览器读取和保存）

httpservlet实现方法：先创建实现servlet，再创建一个类继承该类，只重写service（通过getmethod方法获取请求类型）

Http请求类型

GET：从数据库读取数据[a标签发出的请求都是get请求]

POST：让数据库保存数据（即添加信息）

PUT：修改数据

DELETE：删除数据

直接继承servlet，全部在service方法实现，继承httpservlet会自动分类

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("/test")
public class TestServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.getWriter().write("get");
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.getWriter().write("post");
    }
}

JSP（HTML+CSS+JS+JAVA)

JSP在本质上就是servlet（处理客户端的请求）：主要负责与用户进行交互，将最终的界面呈现给用户

JSP的作用是既能返回页面，也能处理数据

运作：当服务器接收到jsp请求时，将请求交给JSP引擎，每一个jsp页面第一次被访问，jsp引擎将会翻译成servlet文件，再有web服务器进行调用 – 相当于让一个httpservlet不停的write html代码

如何用servlet返回一个HTML页面（writer返回的只是文本，不是页面）

  1. 直接用writer一行一行返回html文本
  2. 直接返回jsp文件的位置

JSP文件嵌入Java代码

  1. JSP脚本嵌入
  <%
    String string = "helloworld";
    System.out.println(string);
  %>
  1. JSP声明：定义Java方法
<%!
public void say(){
      System.out.println("helloworld");
    }
%>
  1. JSP表达式：Java对象直接输出到HTML页面
<%
String str = "12";
%>
<%=str%>

JSP内置对象（9个在JSP文件当中可以直接进行调用）[常用的：request，response，session，application，pageContext]

  1. request：表示一次请求（HttpServletRequest)[请求完毕自动销毁]

    String getParameter(String key) : 获取客户端浏览器获取的参数

    void setAttribute(String key,Object value) : 通过键值对的形式保存数据（服务器内部页面传输）

    Object getAttribute(String key)：通过key取出value

    requestDispatcher getRequestDispatcher(String path)：转发数据到其他的jsp页面，同时浏览器跳转到下一页面

    requestDispatcher的forward方法发送请求

    String[] getParameterValues()：获取客户端传来的多个同名参数

    setCharacterEncoding(String key)：设置编码（防止中文乱码）

  2. response：表示一次相应（HttpServletResponse)

    sendRedirect(string path)：将请求从一个页面传递到另一个页面

    和setattribute的区别是它会创建一个新的请求（无法通过request的getattribute获取），需要有客户端发送一次新的请求，会跳转页面[如果页面需要传值，必须使用转发]

    例子：用户登录，用户名密码正确，跳转到首页，并展示用户名（转发），否则跳转回到登陆界面（重定向）[是一种单纯的跳转]

    jsp文件当中的input标签可以用于参数的传递，用getparameter获取，参数为input标签的name属性

    request 实现登录密码比较
    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 LoginServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String name = req.getParameter("email");
        String password = req.getParameter("password");

        if(name.equals("894962134@qq.com") && password.equals("123")){
            req.setAttribute("name", name);
            req.getRequestDispatcher("index.jsp").forward(req, resp);
        }
        else{
            String mistake = "mistake";
            req.setAttribute("mistake", mistake);
            req.getRequestDispatcher("login.jsp").forward(req, resp);
        }
    }
}

    问题：request的生命周期太短，刷新就会出现问题（用session存储）

    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("/login")
public class LoginServlet extends HttpServlet {

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

    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String name = req.getParameter("email");
        String password = req.getParameter("password");
        HttpSession session = req.getSession();
        if(name.equals("894962134@qq.com") && password.equals("123")){
            session.setAttribute("name", name);                             //用session存储只要浏览器不关闭就不会清除信息
            req.getRequestDispatcher("index.jsp").forward(req, resp);
        }
        else{
            String mistake = "mistake";                
            session.setAttribute("mistake", mistake);
            req.getRequestDispatcher("login.jsp").forward(req, resp);
        }
    }
}

  3. pageContext：页面信息（pageContext）

  4. session：表示一次会话，从打开浏览器到关闭浏览器，一次会话有很多个请求和相应（HttpSession）

    用户会话：一个网站会有很多的终端同时访问，而服务器无法识别每一次HTTP请求的出处，出现的问题：将用户的相应发送给其他人

    会话：一台服务器和终端发生的一系列请求以及响应（打开浏览器到关闭浏览器）

    会话状态：借助会话状态，服务器把属于同一次会话的请求和响应进行连接[属于同一个会话的请求都有同一个sessionID] String sessionID = session.getId();

    实现会话的方法：session（Java程序）和cookie（浏览器提供）

    session 的方法

    1. string getID()：获取到当前的sessionID
    2. void setMaxInactiveInterval(int interval)：设置是session的时效时间，参数是时间（在一个时间内免登录）
    3. int getInactiveInterval() : 获取时效时间
    4. void invalidate()：设置session立即失效（退出登录）
    5. void setAttribute()：通过键值对存储数据
    6. Object getAttribute(String key)：通过键值对获取对应数据
    7. void removeAttribute(String key)：删除对应键值对

  5. application：表示当前的web应用，保存所有用户共享信息（servletContext）

  6. config：当前JSP对应的servlet的servletConfig，获取当前servlet的信息

  7. out：向客户端（浏览器）输出数据（JSPWriter）

  8. page：当前JSP对应的servlet

  9. exception：JSP页面发生的异常

网页异常

  1. 200：正常

  2. 404：资源找不到

  3. 400：请求类型不匹配

  4. 500：Java程序抛出异常

Cookie

cookie保存在客户端：cookie会跟着请求带到服务端进行操作，然后跟着相应被带回客户端

比如说一台电脑登陆一次之后就不需要重新输入（在同一种浏览器）

  1. 创建Cookie

    Cookie cookie = new Cookie("name", "zhangsan");
response.addCookie(cookie);      //通过响应进行返回客户端

  2. 读取Cookie

    Cookie[] cookies = request.getCookies();
for(Cookie cookie2: cookies){
    System.out.println(cookie2.toString());
}
Cookie的常用方法
  1. void setMaxAge(int age)：设置Cookie的有效时间
  2. int getMaxAge()：获取有效时间
  3. String getName()：获取Cookie的name值
  4. String getValue()：获取Cookie的value
Session和Cookie之间的区别

session保存在服务器，Cookie保存在客户端

session保存的是object类型，Cookie只能保存文本

session会随着会话的结束（浏览器关闭）而销毁，Cookie可以长期保存[需要设置生命周期]cookie.setMaxAge(1800);

cookie保存相对安全的信息（比如电影观看进度等）

loginServlet.java                                            //添加账户到cookie
			Cookie cookie = new Cookie("email", name);
            cookie.setMaxAge(1800);
			resp.addCookie(cookie);
            resp.sendRedirect("account.jsp");

index.jsp                                      <!--主页调取cookie,并自动跳转到用户首页-->
	<%
		Cookie[] cookies = request.getCookies();
		for(Cookie cookie:cookies){
			System.out.println(cookie.getName()+" "+cookie.getValue());
			if(cookie.getName().equals("email")) {
				request.setAttribute("email", cookie.getValue());
				request.getRequestDispatcher("account.jsp").forward(request, response);
				break;
			}
		}
	%>

account.jsp                                    <!--用户首页获取Cookie-->
<%String email = (String)request.getAttribute("email");%>

logout.java
		for(Cookie cookie:cookies){
            if(cookie.getName().equals("email")){
                cookie.setMaxAge(0);                //每一次对cookie做了操作之后都需addcookie
                resp.addCookie(cookie);
            }
        }

JSP数据传输内置对象的作用域（Cookie不属于内置对象,生命周期自定）

page,request,session,application(这四个内置对象都可以通过setAttribution和getAttribution来传输数据)

page < request < session < application

  1. page作用域(对应的内置对象是pageContext)：只在当前页面有效（jsp内部数据传输）

  2. request作用域：在一次请求内部有效（同一个request可以取出数据）

  3. session作用域：同一次会话内部有效（同一次打开浏览器）

  4. application作用域：整个Web应用内部（Tomcat不关闭就有效）

    可以用于访问量的记录

EL表达式（expression language表达式语言）

EL语句只能和jsp标签进行穿插使用，不能写在Java代码当中

替代JSP页面中数据访问的复杂编码：${变量名}

变量名称是存储在键值对中的名字，只简化了接受语法，没有简化发送语法

EL表达式可以取上述四个内置对象存储的键值对的值

同名的情况默认优先级：page > request > session > application(和作用域大小正好相反)

指定作用域进行查找(${作用域Scope.变量名})
  1. pageContext：${pageScope.name}
  2. request：${request.name}
  3. session：${session.name}
  4. qpplication：${application.name}

El可以展示（赋值）类对象以及其属性，直接级联就可以[实体类方法需要有共有的get，set方法]

${user.id} ${user.id = 3}

EL展示的信息不一定就是属性的值，是get方法返回的值

EL语句发送object
  1. 发送的语法并没有发生改变
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.ArrayList;
@WebServlet("/list")
public class List extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        ArrayList<Employee> list = new ArrayList<>();
        list.add(new Employee(12, "asd","dehu"));
        list.add(new Employee(12, "asd","dehu"));
        list.add(new Employee(12, "asd","dehu"));
        req.setAttribute("list", list);
        req.getRequestDispatcher("index.jsp").forward(req, resp);
    }
}
  1. 展示时如果是集合类不能调用方法（利用的是反射机制）
<table>
  <thead>
  <td>name</td>
  <td>id</td>
  <td>address</td>
  </thead>
  <tr>
    <td>${requestScope.list[0].name}</td>
    <td>${requestScope.list[0].id}</td>
    <td>${requestScope.list[0].address}</td>
  </tr>
</table>

JSTL详解

JSP Standard Tag Library：JSP标准标签库，JSP为开发者提供的标签，用来完成逻辑处理（循环等），取代JSP脚本穿插,用于展示传输的数据

JSTL侧重于逻辑处理，EL用于展示数据

JSTL 使用

  1. 导入JSTL.jar和standard.jar（必须存放在WEB-INF）

  2. 在JSP页面开始端，配置引用

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

  3. 在需要的页面区域进行使用

<c:forEach items="${requestScope.list}" var="employee">
  <tr>
    <td>${employee.name}</td>
    <td>${employee.id}</td>
    <td>${employee.address}</td>
  </tr>
</c:forEach>
常用标签

  1. set

    向域对象当中添加数据和以下脚本相等

    <%
request.setAttribute(key,value);
%>

    <c:set var="name" value="tom" scope="request"></c:set>

  2. out

    输出域对象中的数据

    <c:out value="${name}" default="未定义"></c:out>

  3. catch(用于捕获异常)

        <c:catch var="error">
      <%int a  = 10/0;%>
    </c:catch>
${error}

  4. 条件标签：if choose

    <c:if test="${num1>num2}">ok</c:if>
<c:if test="${num1<num2}">fail</c:if>

    <c:choose>
    <c:when test="${num1>num2}">ok</c:when>
    <c:otherwise>fail</c:otherwise>
</c:choose>

  5. 迭代标签 foreach

    <c:forEach items="${requestScope.list}" var="employee">   
  <tr>
    <td>${employee.name}</td>
    <td>${employee.id}</td>
    <td>${employee.address}</td>
  </tr>
</c:forEach>

    item: 需要迭代的集合类

    begin: 开始的元素 <c:forEach items="${requestScope.list}" var="employee" begin="2">

    end: 结束的元素<c:forEach items="${requestScope.list}" var="employee" end="2">

    step: 每一次迭代的步数 <c:forEach items="${requestScope.list}" var="employee" step="2">

    varStatus: 用来取集合中元素的信息

    <c:forEach items="${requestScope.list}" var="employee" varStatus="sta">
${sta.count} <br/>
</c:forEach>

格式化标签库（对日期，时间等的处理）

<%@ page import="java.util.Date" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <%request.setAttribute("date",new Date());%>
    <fmt:formatDate value="${date}" pattern="yyyy-MM-dd HH:mm:ss"></fmt:formatDate>
    <fmt:formatNumber value="234567.1233" maxIntegerDigits="2" maxFractionDigits="3"></fmt:formatNumber>
</body>
</html>

函数标签库

<%@ page import="java.util.Date" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib prefix="fn" uri="http://java.sun.com/jsp/jstl/functions" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <%request.setAttribute("str","java");%>
    ${fn:contains(str,"python")}
    ${fn:startsWith(str,"java")}
    ${fn:endsWith(str, "a")}      
    ${fn:indexOf(str, "va")}      <!-- 判断字符串存在的位置-->
    ${fn:replace(str, "a", "c")}
    ${fn:split(str, "a")}
    ${fn:substring(str, 2, 3)}    <!-- 截取字符串-->
</body>
</html>

Filter 过滤器（位于服务端和客户端之间）

对不满足规范的请求进行过滤，将某些重复的请求进行处理，或者直接截断请求

修改或者以某种方式处理客户端和服务端之间的数据流：比如设置编码方式

Filter 是 java web 提供的接口，只需要创建一个类再实现该接口即可

实现filter接口可以只实现doFilter方法，其他的方法是default

package com.Eric.filter;

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

public class CharacterFilter implements Filter {
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        servletRequest.setCharacterEncoding("UTF-8");       //所有的请求均设置编码方式为UTF-8
        filterChain.doFilter(servletRequest, servletResponse);  //和键值对的转发类似,必须添加
    }
}

配置filter映射

<?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">
    <filter>
        <filter-name>character</filter-name>
        <filter-class>com.Eric.filter.CharacterFilter</filter-class>
    </filter>

    <filter-mapping>
        <filter-name>character</filter-name>
        <url-pattern>/login</url-pattern>
        <url-pattern>/register</url-pattern>     <!--一个filter可以截留多个servlet-->
    </filter-mapping>
</web-app>
filter的生命周期

filter和servlet基本相同（除了实例化对象的时间点不同）:以目的地为分类

  1. 当Tomcat启动时，通过反射机制调用无参数构造创建实例化对象，同时调用init方法实现初始化
  2. 访问一次filter会调用一次dofilter方法
  3. 当Tomcat关闭的时候会调用destroy方法来销毁filter对象

filter之间的顺序由web xml的配置顺序决定

注解的形式配置（多个映射）
@WebFilter({"/register", "/login"})
主要作用

  1. 统一处理中文乱码

  2. 屏蔽（替换）敏感词

    package com.Eric.filter;

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

@WebFilter({"/register", "/login"})
public class CharacterFilter implements Filter {
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        String source = servletRequest.getParameter("source");
        source = source.replace("敏感词", "***");
        servletRequest.setAttribute("source",source); //在servlet当中需要getAttribute()，相当于在重置键值对
        filterChain.doFilter(servletRequest, servletResponse);
    }
}

  3. 控制资源的访问权限（只有登录之后才能访问）

    package com.Eric.filter;
import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.io.IOException;
@WebFilter("/services.jsp")                         //jsp不需要进行映射
public class LoginPowerFilter implements Filter {
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        HttpServletRequest request = (HttpServletRequest) servletRequest;
        HttpServletResponse response = (HttpServletResponse) servletResponse;
        HttpSession session = request.getSession();
        String email = (String)session.getAttribute("login_email_to_account");
        if(email == null)
            response.sendRedirect("login.jsp");
        else
            filterChain.doFilter(servletRequest, servletResponse);
    }
}

文件上传下载

文件的上传

JSP：

  1. 设置input标签type为file
  2. form 的method设置为post（设置为get的话会把文件名传输）
  3. form表单的enctype属性设置为mutipart/form-data：以二进制的形式传输数据

servlet：

  1. fileupload组件：导入commons-fileupload.jar和commons-io.jar

    将所有的请求信息解析成FileItem对象，对这个对象操作可以完成上传

    fileupload会把一个form表单当中的所有input框全部转换成fileitem对象

    package com.Eric.servlet;

import com.Eric.Vulnerability;
import org.apache.commons.fileupload.FileItem;
import org.apache.commons.fileupload.FileUploadException;
import org.apache.commons.fileupload.disk.DiskFileItem;
import org.apache.commons.fileupload.disk.DiskFileItemFactory;
import org.apache.commons.fileupload.servlet.ServletFileUpload;

import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.ServletSecurityElement;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.List;

@WebServlet("/upload")
public class UploadServlet extends HttpServlet {
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        DiskFileItemFactory fileItemFactory = new DiskFileItemFactory();      
        //文件对象的工厂
        ServletFileUpload servletFileUpload = new ServletFileUpload(fileItemFactory);         //创建fileupload对象
        Vulnerability vul = new Vulnerability();
        try {
            List<FileItem> list = servletFileUpload.parseRequest(req);        
            //直接获取上传文件的fileitem对象的集合
            for(FileItem fileItem:list){         //判断表单当中提交的是文件还是文本
                if(fileItem.isFormField()){
                    if (fileItem.getFieldName().equals("name"))
                        vul.setName(fileItem.getString("UTF-8"));
                    else if (fileItem.getFieldName().equals("message"))
                        vul.setMessage(fileItem.getString("UTF-8"));
                    else
                        vul.setCatagory(fileItem.getString("UTF-8"));
                }else{
                    String filename = fileItem.getName();
                    vul.setFilename(filename);
                    InputStream inputStream = fileItem.getInputStream();
                    String path = req.getServletContext().getRealPath("FILE/" + filename);
                    OutputStream outputStream = new FileOutputStream(path);
                    int temp = 0;
                    while((temp=inputStream.read()) != -1){
                        outputStream.write(temp);
                    }
                    outputStream.close();
                    inputStream.close();
                    //连接数据库之后导入vul
                    
                }
            }
        } catch (FileUploadException e) {
            e.printStackTrace();
        }
    }
}
文件下载

下载属于响应，调用response

package com.Eric.servlet;
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.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
@WebServlet("/kitdownload")
public class KitDownload extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //启动下载器，响应方式的设置
        resp.setContentType("application/x-msdownload");
        //设置下载之后的文件名
        String filename = "kit.pdf";
        resp.setHeader("Content-Disposition", "attachment;filename=" + filename);
        OutputStream outputStream = resp.getOutputStream();
        String path = req.getServletContext().getRealPath("FILE/kti.pdf");
        InputStream inputStream = new FileInputStream(path);
        int temp = 0;
        while((temp = inputStream.read())!=-1){
            outputStream.write(temp);
        }
        outputStream.close();
        inputStream.close();
    }
}

Ajax

Asynchronous JavaScript And Xml （异步的js和XML）

指的是交互方式：异步加载：客户端与服务器的数据交互是更新在局部页面，不需要刷新整个页面

优点：效率更高，用户体验更好：页面的需求分成两个步骤，同步加载会导致后面的步骤白费

传统响应方式：响应一个完整的页面，AJax：只返回需要的数据

基于JQuery的Ajax

<script type="text/javascript" src="js/jquery-3.4.1.min.js"></script>

<!--jsp代码-->
<script>
  $(function () {
    var btn = $("#frontPage");           //获取一个按钮对象，使用id选择器
    btn.click(function () {              //监听点击事件
      $.ajax({
        url:'/frontPage',
        type:'post',
        dataType:'text',
        data:'id=1',                     //传递的参数
        success:function (data) {        //服务器返回的数据：data
            var table = $("#table");
            table.before("<span>" + data + "</span>");
        }
      });
    });
  })
</script>

package com.Eric.servlet;

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("/frontPage")
public class FrontPageServlet extends HttpServlet {
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String id = req.getParameter("id");
        String string = "hello";
        resp.getWriter().write(string);            //只给页面返回一个数据，返回给ajax
        //不能跳转到jsp，只能返回数据，否则会页面重新加载
    }
}

Ajax基本语法

$.ajax({属性})

  1. url：请求的后端服务地址
  2. type：请求的类型（默认是get方式）
  3. data：请求的参数
  4. datatype：服务器返回的数据类型：text/json
  5. success：请求成功的回调函数：执行到页面的动作
  6. error：请求失败的回调函数
  7. complete：请求完成的回调函数，先进入complete再进入success

JSON

JavaScript object notation：在js当中描述对象，完成js与Java的对象数据转换，将Java对象封装成JSON

服务器和客户端交互数据出现对象类型数据

<script>
  $(function () {
    var btn = $("#frontPage");          
    btn.click(function () {              
      $.ajax({
        url:'/frontPage',
        type:'post',
        dataType:'json',
        data:'${requestScope.round}',                 
        success:function (data) {      
          var tbody = $("#body");
          $("#vul_id").val(data.name);

        }
      });
    });
  })
</script>

package com.Eric.servlet;

import com.Eric.Vul_text;
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;

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("/frontPage")
class User{
    int id;
    String name;

    public User(int id, String name) {
        this.id = id;
        this.name = name;
    }
}
public class FrontPageServlet extends HttpServlet {
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        User list = new User(1, "hh");
        String id = req.getParameter("id");
        String string = "hello";
        //将Java对象转换成json，再进行返回
        JSONObject object = JSONObject.fromObject(list);          //将Java对象转换为json对象
        resp.getWriter().write(object.toString());                 //将json对象返回给ajax
    }
}

JDBC：Java database connectivity

是一个独立于特定数据库的管理系统：能够连接各种数据库，通用的SQL数据库存取和操作的公共接口

为访问不同数据库提供了同一途径

JDBC体系结构
  1. 面向应用的API，供开发者调用
  2. 面向数据库的API，供数据库产商开发所用
JDBC API：供开发者调用的接口

在java.sql和javax.sql包当中

  1. DriverManager类

    由Java官方提供，管理不同的JDBC驱动（由数据库厂商进行提供，负责连接不同的数据库）

  2. Connection接口

  3. Statement接口

  4. ResultSet接口

JDBC的使用
  1. 加载数据库驱动：Java程序和数据库之间的桥梁（是一种基站）[由数据库产商提供]
  2. 获取connection：Java程序与数据库的一次链接
  3. 创建Statement对象，由connection产生，执行SQL语句
  4. 如果需要接受返回值（执行查询语句等），创建ResultSet对象：用于保存Statement执行之后所查询到的结果[如果只是增加，删除等操作，则不需要该对象]

连接数据库

//connect to database
        try {
            Class.forName("com.mysql.cj.jdbc.Driver");         //获取运行时类
            String url = "jdbc:mysql://localhost:3306/webProject?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai";      
            //设置访问数据库的位置
            String user= "root";
            String databasePassword = "123456";
            Connection connection =                                   DriverManager.getConnection(url,user,databasePassword);               
            //利用Drivermanager管理驱动
            String sql = "insert into user(email,password,username) values('123456@qq.com','123','eric')";
            String selectSQL = "select * from user";
            Statement statement = connection.createStatement();
            statement.executeUpdate(sql);
            ResultSet resultSet = statement.executeQuery(selectSQL);                 
            //查询sql语句使用query，其他更新类型语句使用update,需要resultSet进行接受
            while (resultSet.next()){                                                                 //next方法会返回一个布尔值，并跳转到下一个获取的对象
                String email = resultSet.getString("email");
                String password = resultSet.getString("password");
                accountArrayList.add(new Account(email, password, null));
            }
        } catch (ClassNotFoundException | SQLException e) {
            e.printStackTrace();
        }

​

Eric Zerk
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
php cookie max age,使用spring-session时，动态修改cookie的max-age
weixin_42351363的博客
03-19 1155
使用spring-session时，动态修改cookie的max-age不论是使用spring提供的spring-session，还是使用servle容器实现的http session。原理都是把session-id以cookie的形式存储在客户端。每次请求都带上cookie。服务器通过session-id，找到session。spring-session的使用由“记住我”引发的一个问题用户登录的...
Spring Boot 2.0.3 修改 Servlet 容器（服务器）配置
蚩尤后裔-汪茂雄
08-09 1705
目录 需求分析 全局配置文件修改 可修改配置项 修改配置 自定义 Servlet 容器定制器 springboot 1.x springboot 2.x SpringBoot 默认使用 Tomcat 作为嵌入式的Servlet容器； 如下所示，找到应用的 pom.xml文件，文件中右击选择 “Diagrams（图解）”，可以看到 Spring Boot 2.0.3 版本默认使...
SpringBoot集成SpringSecurity5和OAuth2 — 2、OAuth2客户端【SSO单点登录时作为客户端】
Mr_XiMu的博客
05-31 3262
SpringBoot集成SpringSecurity5和OAuth2 — 2、OAuth2客户端【SSO单点登录时作为客户端】
servlet之session&cookie
chen2016的博客
12-06 912
会话技术 可以简单理解为：浏览器打开到关闭就是一次会话 session和cookie可以实现会话跟踪技术，功能有重叠一般结合使用 session和cookie结合使用的例子：用户访问浏览器，服务器生成JESSIONID，JESSIONID是一个cookie，每次http请求会携带此cookie，用来让服务器知道选择哪个session，即JESSIONID相当于session的id。（因为服务器中存这好多用户的会话session），这个过程由服务器自动完成。 会话技术可以：记住浏览的商品，可以识别用户，可以
springboot
m0_46589813的博客
06-15 144
SpringBoodSpring BootSpring Boot 的优势：springboot的使用1. 创建handler2. 创建启动类springboot配置文件Spring Boot 整合 JSP Spring Boot 通过 Spring Boot 可以快速构建⼀个基于 Spring 框架的 Java Application，简化配置，⾃动装配。 JavaConfiguration ⽤ Java 类替代 XML 的配置⽅式。 Spring Boot 对常⽤的第三⽅库提供了配置⽅案，可以很好地和 S
Spring Session框架
最新发布
小电玩
10-25 155
Spring Session是一个用于在分布式环境中管理会话的框架。它提供了一种无状态的方式来管理用户会话，使得应用程序可以在不同的服务器之间共享会话数据。SpringSession的设计目标是为了解决传统基于Servlet容器的会话管理的局限性，特别是在集群和云环境中。SpringSession的核心思想是将会话数据从Servlet容器中抽离出来，并存储在外部存储介质中，例如数据库、Redis等。这样做的好处是，会话数据可以被多个服务器共享，从而实现会话的跨服务器访问。Spring。
SpringBoot配置属性之Server
weixin_34148340的博客
01-14 715
SpringBoot配置属性系列 SpringBoot配置属性之MVC SpringBoot配置属性之Server SpringBoot配置属性之DataSource SpringBoot配置属性之NOSQL SpringBoot配置属性之MQ SpringBoot配置属性之Security SpringBoot配置属性之Migrati...
session.setAttribution getAttribution空指针异常
06-09 147
今天在系统里面做一个新模块，在写一个获取登录时储存的session.setattribute值的时候，爆出了空指针异常。 但是在其他模块这个方法是没有问题的 搞了一下午 最后不知道怎么搞的 改了什么地方 就自己变好了。真是无语死了。谁知道为什么吗？ 转载于:https://www.cnblogs.com/Ychao/p/6972795.html...
Springboot应用中设置Cookie的SameSite属性，跨域支持
热门推荐
seapeak007的博客
02-07 1万+
转自：Springboot应用中设置Cookie的SameSite属性 - SpringBoot中文社区 - 博客园 Cookie除了key和value以外有几个属性。 httpOnly是否允许js读取cookie secure是否仅仅在https的链接下，才提交cookie domaincookie提交的域 pathcookie提交的path maxAgecookie存活时间 sameSite同站策略，枚举值：StrictLaxNone 其他的都很熟悉了，最后一个是 Chro...
Cookie
qq_50794782的博客
03-29 2061
Cookie：客户端对象 1）什么是Cookie Cookie是Web服务器保存在用户硬盘上的一段文本。Cookie允许一个Web站点在用户电脑上保存信息并且随后再取回它。 举例来说，一个Web站点可能会为每一个访问者产生一个唯一的ID，然后以Cookie文件的形式保存在每个用户的机器上。 如果用户使用IE浏览器访问Web，那么用户就会看到所有保存在自己硬盘上的Cookie。它们最常存放的地方是C:\Windows\Cookies。Cookie是以"关键字key=值value"的格式来保存记录的。.
Spring Boot启动过程（六）：内嵌Tomcat中StandardHost、StandardContext和StandardWrapper的启动...
weixin_30847939的博客
03-17 357
　　看代码有助于线上出现预料之外的事的时候，不至于心慌。。。 　　StandardEngine[Tomcat].StandardHost[localhost]的启动与StandardEngine不在同一个线程中，它的start: // Start our child containers, if any Container children[]...
jsp嵌入java代码
a568005784的专栏
06-12 1546
JSP中嵌入java代码的三种方式：       （1）声明变量或方法 :  声明; %> :慎重使用,因为此方法定义的是全局变量       （2）java片段(scriptlet):  java代码; %>       （3）表达式：用于输出表达式的值到浏览器，表达式  %>  在表达式中不能加分号(;) JSP页面的指令     page %> //这个一般是写在
设置Session超时的三种方法
weixin_43808717的博客
04-12 2534
在Java代码中设置一些Session的属性配置 session.setMaxInactiveInterval(500); //设置超时时间，单位是s session.getId(); //获取sessionid session.invalidate(); //清除Session session.setMaxInactiveInterval(500)这里的超时时间单位是秒..
JSP网页中内嵌JAVA 语句的配置。
yanjiang212的专栏
08-28 2014
 补充：tomcat是中间件服务器，用来解释.jsp和java代码的，因此只需要服务器上安装就可以了，客户端通过http://ip:port/appname/jspfilename来访问.其中 ip为服务器地址，本机为localhost.port为所开端口，默认为8080.appname是你的web应用的名称。jspfilename为jsp所在目录和jsp文件名的相对路径。一.调试JSP
JavaWeb(重点)学习笔记（精华版）
清峰的博客
09-17 1918
JavaWeb学习笔记 一、Servlet介绍 概念： Servlet是运行在Java服务器端的程序，用于接收和响应来自客户端基于HTTP协议的请求。 实现： 如果想要实现Servlet的功能，可以通过实现Servlet接口或者继承他的实现类。 核心方法： service()，任何客户端的请求都会经过该方法。 二、.请求对象 1.请求对象常用的方法 返回值 方法名 说明 String getContexPath() 获取虚拟目录名称 String getServletPath()
11. OutputFormat数据输出
weixin_45267102的博客
07-12 617
OutputFormat是MapReduce输出的基类，所有实现MapReduce输出都实现了 OutputFormat接口。下面我们介绍几种常见的OutputFormat实现类。
JAVAweb学习日记第一天
TianZ123的博客
10-11 721
前言： 我是一个没有太多激情的人，之前学了前端，学完html，css，JavaScript，ajax，一点点的php。报名学的，每学完一部分都有一个作业，现在在ajax卡住了。。。卡了好久，就开始想看看别的。又学了一点java，看到java可以代替php，就想java能不能也做网页，会不会简单点，就开始找Javaweb了。。 学习动态网页要弄服务器，因为公司主要业务是.net，所以我的电脑配置
Servlet三大作用域：Request、Session、Application
Java开发，人工智能，边缘计算，致力于掌握前沿技术
06-16 1265
Request作用域 当请求从一个action转发到一个jsp的时候，如果jsp中要使用action类中的变量，那么我们需要将action中的变量放入到request作用域中传给jsp。那么jsp中就可以通过request作用域获取到该变量。 例如：登陆成功后需要在成功页面显示人员信息。 Request对象类似于一个map集合。放数据的时候，放入键值对，取数据时通过键取值。 request.set...
javaweb学习日记
小欢
04-03 348
网页定时刷新：在http中定义了一个Refresh头字段用于通知浏览器定时刷新并且跳转页面在doGet方法中添加代码response.setHeader("Refresh","2");可以通过打印时间知道是否刷新，添加代码response.getWriter().println(new java.util.Date());网页定时刷新并跳转:在doGet方法中添加代码response.setHea...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值