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">
<!--  配置servlet
    当通过url访问时http://localhost:8080/tomcatdemo_war_exploded/demo1
    服务器会到web.xml访问到/demo1
    然后往上找到demo1,接着找到com.example.tomcatdemo.servletdemo1
    这个是全类名，第一时间想到反射：
    tomcat将全类名对应的字节码文件加载进内存 Class.forName()
    创建对象cls.newInstance()
    调用方法 service 因为demo1指向的servlet文件实现了Servlet，所以tomcat知道有这个方法
    servlet的init方法，只执行一次，说明一个Servlet在内存中只存在一个对象，Servlet是单列的
    当多个用户访问这个Servlet时，可能存在线程安全问题
    解决：尽量不要在Servlet中定义成员变量，定义局部变量。万一即使定义了成员变量，也不要对其赋值、修改值
-->
    <servlet>
        <servlet-name>demo1</servlet-name>
        <servlet-class>com.example.tomcatdemo.servletdemo1</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>demo1</servlet-name>
        <url-pattern>/demo1</url-pattern>
    </servlet-mapping>
    <servlet>
        <servlet-name>demo2</servlet-name>
        <servlet-class>com.example.tomcatdemo.servletdemo2</servlet-class>
<!--        指定servlet的创建时机
            1、第一次被访问时，创建
                load-on-startup的值为负数
            2、在服务器启动时，创建
                load-on-startup的值为0或正整数
-->
        <load-on-startup>5</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>demo2</servlet-name>
        <url-pattern>/demo2</url-pattern>
    </servlet-mapping>
</web-app>

servlet

package com.example.tomcatdemo;
import javax.servlet.*;
import java.io.IOException;
public class servletdemo1 implements Servlet {
    /**
     * 初始化方法
     * Servlet被创建时执行，只会执行一次
     * @param servletConfig
     * @throws ServletException
     */
    @Override
    public void init(ServletConfig servletConfig) throws ServletException {
        System.out.println("init.......");
    }
    /**
     * 获取ServletConfig对象,即servlet的配置对象
     * @return
     */
    @Override
    public ServletConfig getServletConfig() {
        return null;
    }
    /**
     * 提供服务的方法
     * 每一次servlet被访问时执行，执行多次
     * @param servletRequest
     * @param servletResponse
     * @throws ServletException
     * @throws IOException
     */
    @Override
    public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
        System.out.println("service....");
    }
    /**
     * 获取servlet的一些信息，版本，作者等
     * @return
     */
    @Override
    public String getServletInfo() {
        return null;
    }
    /**
     * 销毁方法
     * 在服务器正常关闭时，执行，执行一次
     */
    @Override
    public void destroy() {
        System.out.println("destroy.......");
    }
}

注解-代替web.xml

package com.example.tomcatdemo;
import javax.servlet.*;
import javax.servlet.annotation.WebServlet;
import java.io.IOException;
@WebServlet(urlPatterns = "/demo3") //直接使用注解进行xml配置 也可以如下
//@WebServlet("/demo4") //直接使用注解进行xml配置
public class servletdemo3 implements Servlet {
    /**
     * 初始化方法
     * Servlet被创建时执行，只会执行一次
     * @param servletConfig
     * @throws ServletException
     */
    @Override
    public void init(ServletConfig servletConfig) throws ServletException {
        System.out.println("init.......");
    }
    /**
     * 获取ServletConfig对象,即servlet的配置对象
     * @return
     */
    @Override
    public ServletConfig getServletConfig() {
        return null;
    }
    /**
     * 提供服务的方法
     * 每一次servlet被访问时执行，执行多次
     * @param servletRequest
     * @param servletResponse
     * @throws ServletException
     * @throws IOException
     */
    @Override
    public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
        System.out.println("service....");
    }
    /**
     * 获取servlet的一些信息，版本，作者等
     * @return
     */
    @Override
    public String getServletInfo() {
        return null;
    }
    /**
     * 销毁方法
     * 在服务器正常关闭时，执行，执行一次
     */
    @Override
    public void destroy() {
        System.out.println("destroy.......");
    }
}

idea2021-代替web.xml

2021idea生成webapp 直接生成这个目录，在这个目录下面的servlet可以直接访问

HttpServlet-获取请求行方法

package com.example.tomcatdemo.servletdemo;
import javax.servlet.*;
import javax.servlet.http.*;
import javax.servlet.annotation.*;
import java.io.IOException;
/**
 * 演示请求行数据
 */
@WebServlet(name = "ServletTest2", value = "/ServletTest2")
public class ServletTest2 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
//        System.out.println(111111);
//        //获取请求方式
//        String method = request.getMethod();
//        System.out.println(method);
////        获取虚拟目录 重要
//        String contextPath = request.getContextPath();
//        System.out.println(contextPath);
////        获取servlet路径 /ServletTest2
//        String servletPath = request.getServletPath();
//        System.out.println(servletPath);
////        获取get方式请求参数
//        String queryString = request.getQueryString();
//        System.out.println(queryString);
////        获取URI 和 URL
//        String requestURI = request.getRequestURI();
//        StringBuffer requestURL = request.getRequestURL();
//        System.out.println(requestURI);
//        System.out.println(requestURL);
////        获取协议及版本
//        String protocol = request.getProtocol();
//        System.out.println(protocol);
////        获取客户机IP地址
//        String remoteAddr = request.getRemoteAddr();
//        System.out.println(remoteAddr);
    }
    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        System.out.println(2222);
        //获取请求方式
        String method = request.getMethod();
        System.out.println(method);
//        获取虚拟目录 重要
        String contextPath = request.getContextPath();
        System.out.println(contextPath);
//        获取servlet路径 /ServletTest2
        String servletPath = request.getServletPath();
        System.out.println(servletPath);
//        获取post方式请求参数
        String queryString = request.getParameter("username");
        System.out.println(queryString);
//        获取URI 和 URL
        String requestURI = request.getRequestURI();
        StringBuffer requestURL = request.getRequestURL();
        System.out.println(requestURI);
        System.out.println(requestURL);
//        获取协议及版本
        String protocol = request.getProtocol();
        System.out.println(protocol);
//        获取客户机IP地址
        String remoteAddr = request.getRemoteAddr();
        System.out.println(remoteAddr);
    }
}

HttpServlet-获取请求头方法

package com.example.tomcatdemo.servletdemo;
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.Enumeration;
/**
 * 演示请求行数据
 */
@WebServlet(name = "ServletTest3", value = "/ServletTest3")
public class ServletTest3 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
//    获取请求头数据
        String userAgent = request.getHeader("user-agent");
        System.out.println(userAgent);
        if (userAgent.contains("Chrome")){
            System.out.println("Chrome");
        } else if (userAgent.contains("Firefox")){
            System.out.println("Firefox");
        }
        System.out.println("-------------");
        System.out.println("-------------");
//    获取所有的请求头名称,这个方法不常用，一般没有必要获取这么多
        Enumeration<String> headerNames = request.getHeaderNames();
//        遍历
        while (headerNames.hasMoreElements()){
            String name = headerNames.nextElement();
            //根据请求头名称获取请求头的值
            String value = request.getHeader(name);
            System.out.println(name+"------"+value);
        }
    }
    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    }
}

HttpServlet-获取请求体方法

package com.example.tomcatdemo.servletdemo;
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.BufferedReader;
import java.io.IOException;
import java.util.Enumeration;
/**
 * 演示请求行数据
 */
@WebServlet(name = "ServletTest4", value = "/ServletTest4")
public class ServletTest4 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    }
    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        /**
         * 请求体，只有post请求方式，才有请求体，在请求体中封装了post请求参数
         *
         * 1、获取流对象
         *      BufferedReader getReader() 获取字符输入流，只能操作字符数据
         *      ServletInputStream getInputStream() 获取字节输入流 可以操作所有类型数据 在文件上传再学
         *
         */
        BufferedReader br = request.getReader();
        String line = null;
        while ((line = br.readLine()) != null){
            System.out.println(line);
        }
    }
}

HttpServlet-重要方法

package com.example.tomcatdemo.servletdemo;
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.BufferedReader;
import java.io.IOException;
import java.util.Enumeration;
import java.util.Map;
import java.util.Set;
/**
 * 其它功能 都非常重要
 * getParameter(string name) 根据参数名称获取参数值
 * getParameterValues(string name) 根据参数名称获取参数值的数组  多用于复选框
 * getParameterNames() 获取所有请求的参数名称
 * getParameterMap() 获取所有参数的map集合
 */
@WebServlet(name = "ServletTest5", value = "/ServletTest5")
public class ServletTest5 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //这个方法无论是get和post方法都可以使用,这样get和post方法中写的差异就没有了，
        // 所以直接在post方法里面调用get方法即可
        //解决post请求体乱码问题
        request.setCharacterEncoding("utf-8");
        String username = request.getParameter("username");
//        System.out.println("get");
//        System.out.println(username);
        String[] hobbies = request.getParameterValues("hobby");
//        for (String hobby : hobbies) {
//            System.out.println(hobby);
//
//        }
        //这里发现复选框没有被全部获取，使用
        Enumeration<String> parameterNames = request.getParameterNames();
        while (parameterNames.hasMoreElements()){
            String name = parameterNames.nextElement();
            System.out.println(name);
            String value = request.getParameter(name);
            System.out.println(value);
            System.out.println("------------");
        }
        System.out.println("----------修复复选框没有全选的问题------------");
        Map<String, String[]> parameterMap = request.getParameterMap();
        Set<String> keyset = parameterMap.keySet();
        for (String name : keyset) {
            String[] values = parameterMap.get(name);
            for (String value : values) {
                System.out.println(value);
            }
            System.out.println("---------------");
        }
    }
    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
//        String username = request.getParameter("username");
//        System.out.println("post");
//        System.out.println(username);
//        简略
        this.doGet(request,response);
    }
}

HttpServlet-请求转发

package com.example.servletdemoone;
import javax.servlet.*;
import javax.servlet.http.*;
import javax.servlet.annotation.*;
import java.io.IOException;
@WebServlet(name = "Servlettest1", value = "/s1")
public class Servlettest1 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        System.out.println(1111);
        //创建转发对象，使用转发对象调用转发方法
//        RequestDispatcher rqd =request.getRequestDispatcher("/s2");
//        rqd.forward(request,response);
        //简化
        request.getRequestDispatcher("/s2").forward(request,response);
    }
    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    }
}

package com.example.servletdemoone;
import javax.servlet.*;
import javax.servlet.http.*;
import javax.servlet.annotation.*;
import java.io.IOException;
@WebServlet(name = "Servletdemo1", value = "/s2")
public class Servletdemo1 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        System.out.println(222222);
    }
    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    }
}

Servlet-登录demo阶段一

1、写一个user类 接受参数，实例化一个user类对象，传输给userdao类的对象，进度登录验证
2、写一个userdao类 接受user类对象，传入login方法进行登录验证，这里面使用JdbcTemplate进行数据库连接操作
3、写一个jdbcutils类 数据库工具类，获取连接池对象，获取Connection对象

package com.example.javawebs.util;
import com.alibaba.druid.pool.DruidDataSourceFactory;
/**
 * 数据库连接池
 */
import javax.sql.DataSource;
import java.io.IOException;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.Properties;
public class jdbcutils {
    private static DataSource ds;
    static {
        try {
            //加载配置文件
            Properties pro = new Properties();
            InputStream is = jdbcutils.class.getClassLoader().getResourceAsStream("druid.properties");
            pro.load(is);
            //初始化连接池对象
            ds = DruidDataSourceFactory.createDataSource(pro);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    /**
     * 获取连接池对象
     */
    public static DataSource getDataSource(){
        return ds;
    }
    /**
     * 获取Connection对象
     */
    public static Connection getConnection() throws SQLException {
        return ds.getConnection();
    }
}

package com.example.javawebs.dao;
import com.example.javawebs.domain.user;
import com.example.javawebs.util.jdbcutils;
import org.springframework.dao.DataAccessException;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
public class userdao {
    //创建JdbcTemplate对象，直接链接数据库并进行操作
    private JdbcTemplate template = new JdbcTemplate(jdbcutils.getDataSource());
    /**
     * 登录方法 接受一个user对象
     * @param loginuser 只有用户名和密码
     * @return 包含用户全部数据
     */
    public user login(user loginuser){
        try {
            String sql = "select * from user where username = ? and password =?";
            //使用JdbcTemplate对象的queryForObject()方法查询结果，方法中传入BeanPropertyRowMapper的实现类 
            // 这里是传入通过获取的参数实例化出来的user对象，去数据库查询是否存在这个用户，如果存在，就返回这个用户的信息
            user user1 = template.queryForObject(sql,
                    new BeanPropertyRowMapper<user>(user.class),
                    loginuser.getUsername(), loginuser.getPassword());//这里的loginuser.getPassword()是user类里面的getPassword()方法，loginuser是user类的实例化对象
            return user1;
        } catch (DataAccessException e) {
            return null;
        }
    }
}

package com.example.javawebs.domain;
/*
用户实体类
 */
public class user {
    private int id;
    private String username;
    private String password;
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
    @Override
    public String toString() {
        return "user{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

import com.example.javawebs.dao.userdao;
import com.example.javawebs.domain.user;
import org.junit.jupiter.api.Test;
//测试上面的三个类是否能正常运行
public class usertest {
    @Test
    public void testlogin(){
        user loginuser = new user();
        loginuser.setUsername("lww");
        loginuser.setPassword("lwwpasswd");
        /**
         * 使用userdao创建一个对象，这个对象可以调用userdao类里面的login方法
         * login方法接受的是user类的对象，因此上面先使用user类实例化一个对象，并且对该对象赋值进行测试
         */
        userdao dao = new userdao();
        user user1 = dao.login(loginuser);
        System.out.println(user1);
    }
}

Servlet-登录demo阶段二

接上面，写了一个登录界面 三个servlet

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>demo1</title>
</head>
<body>
<form action="/demo/LoginServlet" method="post">
    username<input type="text" name="username1"><br>
    password<input type="text" name="password1"><br>
    <input type="submit" value="登录">
</form>
</body>
</html>

package com.example.javawebs.servletloginP;
import com.example.javawebs.dao.userdao;
import com.example.javawebs.domain.user;
import javax.servlet.*;
import javax.servlet.http.*;
import javax.servlet.annotation.*;
import java.io.IOException;
@WebServlet("/LoginServlet")
public class LoginServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        request.setCharacterEncoding("utf-8");
        //这里需要注意，直接最好request.getParameter的参数和配置文件里面的不一样，不然容易默认去获取配置文件里面的数据库账号密码
        String username = request.getParameter("username1");
        //测试获取的是什么值
//        System.out.println(username);
        String password = request.getParameter("password1");
//        System.out.println(password);
        user loginuser = new user();
        loginuser.setUsername(username);
        loginuser.setPassword(password);
        userdao dao = new userdao();
        user reluser = dao.login(loginuser);
        if (reluser == null){
            //登录失败
            request.getRequestDispatcher("/failServlet").forward(request,response);
            //测试
//            System.out.println(22222);
        }else {
            //登录成功
            //存储数据，值就是查回来的user对象 进行request域共享user对象
            request.setAttribute("user",reluser);
            request.getRequestDispatcher("/successServlet").forward(request,response);
        }
            //测试
//        System.out.println(111111111);
    }
    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        this.doGet(request,response);
    }
}

package com.example.javawebs.servletloginP;
import com.example.javawebs.domain.user;
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("/successServlet")
public class SuccessServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        this.doPost(request,response);
    }
    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
//        获取request域中共享的user对象
        user user1 = (user)request.getAttribute("user");
        if (user1 != null){
            response.setContentType("text/html;charset=utf-8");
            response.getWriter().write("欢迎"+" "+user1.getUsername());
        }
    }
}

package com.example.javawebs.servletloginP;
import javax.servlet.*;
import javax.servlet.http.*;
import javax.servlet.annotation.*;
import java.io.IOException;
@WebServlet("/failServlet")
public class FailServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        this.doPost(request,response);
    }
    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        response.setContentType("text/html;charset=utf-8");
        response.getWriter().write("用户名或密码错误");
    }
}

Servlet-登录demo-BeanUtils改造LoginServlet

package com.example.javawebs.servletloginP;
import com.example.javawebs.dao.userdao;
import com.example.javawebs.domain.user;
import org.apache.commons.beanutils.BeanUtils;
import javax.servlet.*;
import javax.servlet.http.*;
import javax.servlet.annotation.*;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.util.Map;
import java.util.Set;
@WebServlet("/LoginServlet")
public class LoginServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        request.setCharacterEncoding("utf-8");
        /**
        //这里需要注意，直接最好request.getParameter的参数和配置文件里面的不一样，不然容易默认去获取配置文件里面的数据库账号密码
        String username = request.getParameter("username1");
        //测试获取的是什么值
//        System.out.println(username);
        String password = request.getParameter("password1");
//        System.out.println(password);
        user loginuser = new user();
        loginuser.setUsername(username);
        loginuser.setPassword(password);
         **/
        //获取所有的请求参数  这里很奇怪，与上面备注不同的是，这里html中要写成username和password,不然这个方法获取不到
        Map<String, String[]> map = request.getParameterMap();
        Set<String> keyset = map.keySet();
        for (String name : keyset) {
            String[] values = map.get(name);
            for (String value : values) {
                System.out.println(value);
            }
            System.out.println("---------------");
        }
        //创建user对象
        user loginuser = new user();
        //使用beanutils封装,将map里面的键值对封装到loginuser对象中  这里如果登录页面的键名和user类里面的username成员变量不一样，就有可能封装一个null过去，password类似
        try {
            BeanUtils.populate(loginuser,map);
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
        System.out.println(loginuser);
        userdao dao = new userdao();
        user reluser = dao.login(loginuser);
        if (reluser == null){
            //登录失败
            request.getRequestDispatcher("/failServlet").forward(request,response);
            //测试
            System.out.println(22222);
        }else {
            //登录成功
            //存储数据，值就是查回来的user对象 进行request域共享user对象
            request.setAttribute("user",reluser);
            request.getRequestDispatcher("/successServlet").forward(request,response);
        }
            //测试
//        System.out.println(111111111);
    }
    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        this.doGet(request,response);
    }
}

Servlet-response-字符流输出

package com.example.javawebs.respdemo;
/**
 * 输出字符数据到浏览器
 */
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.PrintWriter;
@WebServlet("/rs3")
public class respServletdemo3 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
//        获取流对象之前，设置流的默认编码
        response.setCharacterEncoding("utf-8");
//        告诉浏览器建议使用的编码
        response.setHeader("content-type","text/html;charset=utf=8");
        //        获取字符输出流
        PrintWriter pw = response.getWriter();
//        输出数据
        pw.write("hello,resp,长河落日圆");
    }
    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        this.doGet(request,response);
    }
}

Servlet-response-字节流输出

package com.example.javawebs.respdemo;
/**
 * 输出字节数据到浏览器
 */
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.IOException;
import java.io.PrintWriter;
import java.nio.charset.StandardCharsets;
@WebServlet("/rs4")
public class respServletdemo4 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
//        获取流对象之前，设置流的默认编码
        response.setCharacterEncoding("utf-8");
//        告诉浏览器建议使用的编码
        response.setHeader("content-type","text/html;charset=utf=8");
        //        获取字节输出流
        ServletOutputStream os = response.getOutputStream();
//        输出数据
        os.write("hello,resp,长河落日圆，落日孤烟直".getBytes(StandardCharsets.UTF_8));
    }
    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        this.doGet(request,response);
    }
}

Servlet-文件下载

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<a href="images/01.jpg">图片</a>
<hr>
<a href="/demo/downLoadServlet?filename=一.jpg">图片</a>
<a href="/demo/downLoadServlet?filename=01.mp4">视频</a>
</body>
</html>

package com.example.javawebs.downLoadServlet;
/**
 * 下载文件demo
 * 自定义资源文件夹，将文件放在资源文件夹中，如果中途加入新的文件，需要将资源文件夹取消资源文件夹设施，重新设置当前文件夹为资源文件，不然会报错
 */
import com.example.javawebs.util.DownLoadUtils;
import javax.servlet.*;
import javax.servlet.http.*;
import javax.servlet.annotation.*;
import java.io.FileInputStream;
import java.io.IOException;
@WebServlet("/downLoadServlet")
public class downLoadServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //获取请求参数，文件名称
        String filename = request.getParameter("filename");
//        使用字节流加载文件进内存
//        找到文件服务器路径
        ServletContext servletContext = this.getServletContext();
        String realPath = servletContext.getRealPath("/images/" + filename);
//        使用字节流关联
        FileInputStream fis = new FileInputStream(realPath);
        //设置response的响应头
        //设置响应头类型 content-type
        String mimeType = servletContext.getMimeType(filename);
        response.setHeader("content-type",mimeType);
        //解决中文文件名问题  网上找的这个工具类，他的火狐浏览部分的代码有点问题，别的没有问题，先不找别的了
        String agent = request.getHeader("user-agent");
        filename = DownLoadUtils.getFileName(agent, filename);
        //设置响应头打开方式 content-disposition  就是用来设置先弹框再下载的
        response.setHeader("content-disposition","attachment;filename="+filename);
//        将输入流数据，写出到输出流中
        //实例化输出流对象
        ServletOutputStream sos = response.getOutputStream();
        //写一个字节数组作为缓冲区,并输出
        byte[] buff = new byte[1024 * 8];
        int len = 0;
        while ((len = fis.read(buff)) != -1){
            sos.write(buff,0,len);
        }
        fis.close();
    }
    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        this.doGet(request, response);
    }
}

package com.example.javawebs.util;
import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import java.util.Base64;
    public class DownLoadUtils {
        public static String getFileName(String agent, String filename) throws UnsupportedEncodingException {
            if (agent.contains("MSIE")) {
                // IE浏览器
                filename = URLEncoder.encode(filename, "utf-8");
                filename = filename.replace("+", " ");
            } else if (agent.contains("Firefox")) {
                // 火狐浏览器
                Base64.Encoder encoder = Base64.getEncoder();
                filename = "=?utf-8?B?" + encoder.encode(filename.getBytes("utf-8")) + "?=";
            } else {
                // 其它浏览器
                filename = URLEncoder.encode(filename, "utf-8");
            }
            return filename;
        }
    }