Servlet技术

<!--最后导入相关依赖即可：
(provided: 这里是因为项目最后会打包到Tomcat中运行，会使用Tomcat中的servlet ) -->
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <version>3.1.0</version>
    <scope>provided</scope>
</dependency>

<?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">

    <!-- 应用的显示名称 -->
    <display-name>My Web Application</display-name>

    <!-- Servlet的配置 -->
    <servlet>
        <servlet-name>HelloServlet</servlet-name>
        <servlet-class>com.example.HelloServlet</servlet-class>
        <load-on-startup>1</load-on-startup>
    </servlet>

    <!-- Servlet的映射 -->
    <servlet-mapping>
        <servlet-name>HelloServlet</servlet-name>
        <url-pattern>/hello</url-pattern>
    </servlet-mapping>

    <!-- 全局初始化参数 -->
    <context-param>
        <param-name>appVersion</param-name>
        <param-value>1.0</param-value>
    </context-param>

    <!-- 过滤器配置 -->
    <filter>
        <filter-name>LoggingFilter</filter-name>
        <filter-class>com.example.LoggingFilter</filter-class>
    </filter>

    <!-- 过滤器映射 -->
    <filter-mapping>
        <filter-name>LoggingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

    <!-- 监听器配置 -->
    <listener>
        <listener-class>com.example.MyServletContextListener</listener-class>
    </listener>

    <!-- 欢迎文件列表 -->
    <welcome-file-list>
        <welcome-file>index.jsp</welcome-file>
    </welcome-file-list>

    <!-- 错误页面 -->
    <error-page>
        <error-code>404</error-code>
        <location>/error/404.jsp</location>
    </error-page>

</web-app>

@WebServlet(name = "myUserServlet", urlPatterns = "/user/test",    // 必须有斜杠
 			loadOnStartup = 1, 
			initParams = {
                 @WebInitParam(name="name", value="zhangsan"),
                 @WebInitParam(name="pwd", value="123456")
             }
)
public class UserServlet extends HttpServlet {
    // ......
}


// 通常只需要设置访问路径即可
@WebServlet("/user/test")
public class UserServlet extends HttpServlet {
    // ......
}

@WebServlet("/hello")
public class HelloServlet extends HttpServlet {

    // init默认情况下会在当前servlet第一次被调用之前调用
    @Override
    public void init() throws ServletException {
        super.init();
    }

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) 
        throws ServletException, IOException {
        resp.getWriter().println("hello");
    }

    // 当前应用被卸载、服务器被关闭 时调用
    @Override
    public void destroy() {
        super.destroy();
    }
}

// 注解方式
@WebServlet(value = "/login",loadOnStartup = 1)

<!-- xml配置文件 -->
<servlet>
    <servlet-name>first</servlet-name>
    <servlet-class>com.xxxx.servlet.FirstServlet</servlet-class>
    <load-on-startup>1</load-on-startup>
</servlet>

@WebServlet(value = {"/hello","/helloServlet"},loadOnStartup = 1)

/* 会抛出异常
Caused by: java.lang.IllegalArgumentException: 
The servlets named [com.xxxxx.servlet.servlet.HelloServlet] and 			 
                   [com.xxxxx.servlet.servlet.HelloServlet2] 
are both mapped to the url-pattern [/hello] which is not permitted

/*
url-pattern的合法写法只有两种:

	/xxxxx    如 /user/login 、 /user/* 、 /* 、 /(DefaultServlet，下面会详细介绍) 等等
	
	*.xxxx    如 *.html	
	
常见错误写法：比如直接写 servletTest ( 没加 `/` )、  /hello*.do （ 中间加通配符 ）、 /user/*.do
    
Caused by: java.lang.IllegalArgumentException: Invalid <url-pattern> [servletTest] in servlet mapping

/*
如：请求参数从客户端发出时，使用的编码格式是啥：utf-8
   服务器接收到数据之后，从request里面获取到的数据时乱码的，只能说明服务器解码有问题
   
Request乱码问题的解决方法 **/
request.setCharacterEncoding("UTF-8");                             // 解决post提交方式的乱码
String name = request.getParameter("name");                        // 接收到get请求的中文字符串 

parameter = newString(name.getbytes("iso8859-1"),"utf-8");         // 将字符重新编码，默认编码为ISO-8859-1 

// Response的乱码问题(解决方式一)
response.setCharacterEncoding("utf-8");                         // 设置HttpServletResponse使用utf-8编码
response.setHeader("Content-Type", "text/html;charset=utf-8");  // 通知浏览器使用 utf-8 解码

// Response的乱码问题(解决方式二)
response.setContentType("text/html;charset=utf-8");

// 1. 利用ServletRequest接口中的getRequestDispatcher()方法
request.getRequestDispatcher("success.html").forward(request, response);

// 2. 利用ServletContext接口
getServletContext().getRequestDispatcher("/index.jsp").forward(request, response);	

protected void doPost(HttpServletRequest request, HttpServletResponse response) 
    throws ServletException, IOException {
    response.setContentType("text/html;charset=utf-8");
    
    // 转发
    request.getRequestDispatcher("success.html").forward(request, response);
   
    // 重定向
    response.sendRedirect("test.html");
    
    // 重定向还可以这样写: 301、302、307状态码 + Location响应头
    response.setStatus(302);  
    //访问当前页面时，将请求重定向到1.jpeg （ http://localhost/app/1.jpeg ）
    response.setHeader("Location", request.getContextPath() + "/1.jpeg");  
}

// 通过HttpServletResponse.addCookie的⽅式设置Cookie
Cookie cookie = new Cookie("jieguo","true");
response.addCookie(cookie);

// 服务端获取客户端携带的cookie：同样通过HttpServletRequest获取
Cookie[] cookies = request.getCookies();
if(cookies != null){
    for(Cookie c : cookies){
        String name = c.getName(); // 获取Cookie名称
        if("zhangsan".equals(name)){
            String value = c.getValue(); // 获取Cookie的值
            bool = Boolean.valueOf(value); // 将值转为Boolean类型
        }
    }
}

cookie.setMaxAge(180); // 持久化保存 180 秒

// 设置负数表示的是cookie存在于浏览内存中

// 如果设置0，表示的是删除cookie

// 删除Cookie是指使浏览器不再保存Cookie，使Cookie⽴即失效
Cookie cookie = new Cookie("username", "aaa"); // 创建⼀个name为username的Cookie
cookie.setMaxAge(0); // 删除cookie的关键（设置Cookie的有效时间为0）
response.addCookie(cookie); // 将有效时间为0的cookie发送给浏览器（达到删除cookie的目的）

@WebServlet("/path1")
public class PathServlet extends HttpServlet {
    protected void doGet(HttpServletRequest request, HttpServletResponse response)
    throws ServletException, IOException {
        Cookie cookie = new Cookie("name", "zhangsan");
        cookie.setPath(request.getContextPath() + "/path1"); // 只有访问当前路径时才会携带cookie
        response.addCookie(cookie);
    }
}

@WebServlet("/domain")
public class DomainServlet extends HttpServlet {
    protected void doGet(HttpServletRequest request, HttpServletResponse response)
    throws ServletException, IOException {
        Cookie cookie = new Cookie("key", "domain");
        cookie.setDomain("aaa.com");
        response.addCookie(cookie);
    }
}

// 获取Session对象（有则返回session，没有则创建一个session对象）
HttpSession session = request.getSession();

// 有则返回，没有并且create是true则创建一个session对象；
// 如果没有，并且create是false，则返回null
HttpSession getSession(boolean create);


// 生成session对象：
// 通过抓包可以发现，只有第一次访问ss1时，会有set-Cookie:JSESSIONID=xxx

// 服务器是如何知道当前请求有没有关联的session对象的？
// 根据请求头中是否携带了一个有效的Cookie:JSESSIOINID=xxx

<!--Session的超时时间也可以在web.xml中修改(单位是分钟)-->
<session-config>
    <session-timeout>30</session-timeout>
</session-config>

<role rolename="manager-gui"/>
<user username="tomcat" password="tomcat" roles="manager-gui"/>

// 若要求关闭浏览器之后，依然可以访问到原先session中的数据
// （即将保存sessionID的cookie保存到硬盘, 或者说设置maxAge属性）

HttpSession session = request.getSession();
session.setAttribute("user", user);

Cookie jsessionid = new Cookie("JSESSIONID", session.getId());
jsessionid.setMaxAge(60*60*24*7);
response.addCookie(jsessionid);

// URL重写就是在URL中附加标识客户的Session ID
// Servlet容器解析URL，取出Session ID，根据Session ID将请求与特定的Session关联

//当浏览器禁用Cookie时，每次访问都要手动添加jesessionid ，servlet中指定：
HttpSession session=request.getSession();
String path = "sess;jsessionid=" + session.getId();
String path = response.encodeURL("sess");
response.sendRedirect(path);

// 页面中的使用方式
<a href="sess;jsessionid=${requestScope.id}">点击</a>

@WebListener 
public class MyListener implements ServletContextListener, HttpSessionAttributeListener {
    public MyListener() {
    }

    @Override
    public void contextInitialized(ServletContextEvent sce) {
        /* This method is called when the servlet context is initialized
        (when the Web application is deployed). */
    }

    @Override
    public void contextDestroyed(ServletContextEvent sce) {
        /* This method is called when the servlet Context is undeployed or Application Server shuts down. */
    }

    @Override
    public void attributeAdded(HttpSessionBindingEvent sbe) {
        /* This method is called when an attribute is added to a session. */
    }

    @Override
    public void attributeRemoved(HttpSessionBindingEvent sbe) {
        /* This method is called when an attribute is removed from a session. */
    }

    @Override
    public void attributeReplaced(HttpSessionBindingEvent sbe) {
        /* This method is called when an attribute is replaced in a session. */
    }
}

// 登录拦截器示例
@WebFilter(filterName = "LoginFilter", urlPatterns = "/*")
public class LoginFilter implements Filter {
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) 
        throws ServletException, IOException {
        HttpServletRequest req= (HttpServletRequest)request;
        HttpServletResponse resp= (HttpServletResponse) response;
        boolean isLogin = (boolean)req.getSession().getAttribute("isLogin");
        if(isLogin){
            chain.doFilter(request, response);
        }else {
           resp.sendRedirect("/login.html");
        }
    }
}

<filter>
    <filter-name>LoginFilter</filter-name>
    <filter-class>com.example.filter.LoginFilter</filter-class>
</filter>
<filter-mapping>
    <filter-name>LoginFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

<!-- 注意: (1) form标签中要添加enctype属性 
          (2) 提交方式必须是post   -->
<form action="appName/fileUpload" method="POST" enctype="multipart/form-data" >
    
 	<!-- input表单项 -->
    <input type="file" name="avatar"  />
    
</form>

fileupload核心API:

1. DiskFileItemFactory  
    1) DiskFileItemFactory()        // 构造器  使用默认配置
    2) DiskFileItemFactory(int sizeThreshold, File repository)
      // sizeThreshold 内存缓冲区, 不能设置太大, 否则会导致JVM崩溃
      // repository    临时文件目录

2. ServletFileUpload
  1) isMutipartContent(request) // 判断上传表单是否为multipart/form-data类型 true/false
  2) parseRequest(request)      // 解析request, 返回值为List<FileItem>类型
  3) setFileSizeMax(long)       // 上传文件单个最大值 fileupload内部通过抛出异常的形式处理, 
    						    // 处理文件大小超出限制, 可以通过捕获这个异常, 提示给用户
  4) setSizeMax(long)           // 上传文件总量最大值
  5) setHeaderEncoding(String)  // 设置编码格式
    
  6) setProgressListener(ProgressListener)  // 设置监听器, 可以用于制作进度条

/*

一 中文乱码问题

 1). 表单数据中文乱码
	fileItem.getString("utf-8");
	
 2).上传的文件名有中文乱码问题
 	upload.setHeaderEncoding("utf-8");
 	
 	
 	
二 目录内文件数过多的问题 -- 目录内文件数过多，会影响当前文件的加载查询效率(磁盘IO)

    目录创建多个。 按照年、月、日。不稳定。文件分散不均匀。同时目录也不会特别多。

    使用hash算法产生图片上传的随机目录 -- 为了防止一个目录中出现太多文件, 使用算法打散存储  */


    public String generatePath(String savePath, String originFileName) {
        String fileName = getFileName(originFileName);
        
        //文件名取 32 位的 hashcode
        int hashCode = fileName.hashCode();
        // 4位 对应一位 十六进制，--> 转换为一个八位的十六进制字符串
        String hexString = Integer.toHexString(hashCode);
        
        // 生成目录结构
        char[] chars = hexString.toCharArray();
        String basePath = "file";              // 文件都放在应用根路径下的 file 目录下
        for (char aChar : chars) {
            basePath = basePath + "/" + aChar;
        }
		
        String relativePath = basePath + "/" + fileName;
    }
    
	/***
     * 生成唯一的文件名
     * @author itdrizzle
     * @date 2022/4/12 20:08
     * @return {@link File}
     */
    private static String getFileName(String originFileName) {
        // 获取文件后缀名   新的文件名：当前日期(也可以使用用户id) + UUID + 文件后缀名
        int index = originFileName.lastIndexOf(".");
        String suffix = originFileName.substring(index);

        String uuid = UUID.randomUUID().toString();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd-HH-mm-ss");
        String formatDate = sdf.format(new Date());

        return formatDate + "-" + uuid + suffix;
    }

// 三 监听文件上传进度  （ 监听器要在request解析之前设置）

ServletFileUpload upload = new ServletFileUpload(factory);
upload.setProgressListener(new ProgressListener(){
    
    // pBytesRead      当前已上传大小
    // pContentLength  文件总大小
    // arg2            当前解析的item
    public void update(long pBytesRead, long pContentLength, int arg2) {
        System.out.println("文件大小为：" + pContentLength + ", 当前已处理：" + pBytesRead);
    }
    
});

/*

JavaEE项目中通过fileupload新上传的图片文件要等至少5秒以后才能访问? （使用Tomcat）

	有人说Tomcat7没有这个问题，但经过实际测试，结果是一样的（至少我亲自尝试了Tomcat7 - Tomcat10 ）

有这样一种说法：
	这是因为Tomcat8起、其IO不再是传统的BIO，其底层复制文件的过程中使用了Channel
	
	但仅凭直觉都知道不对，为什么无论上传什么文件都是上传后5秒内无法访问，怎么可能呢？
	严谨一点，通过追踪fileupload源码（追踪 FileItem 的 write方法 发现）可以发现只有在上传文件大小超过内存缓冲区的情形下，
	才会涉及文件的复制（这时才会使用通道），
	而一般的小文件，直接从内存写入硬盘。 参考下面部分源码：

/**

事实上，在此基本上可以确定这个问题与上传没有太大关系，可以通过自己实现 DefaultServlet （即 `/`）
直接用文件名获取文件来验证（使用IO流直接读硬盘文件）

或者不在IDEA中操作，直接启动本地的Tomcat，复制一个文件到webapp目录下的任何一个应用，5秒内快速访问该资源你就会明白了

不知出于何种原因，Tomcat在启动后部署资源后要5秒后才能访问到，个人有一些猜测：

	Tomcat具备热部署的特性，在用户访问资源时，如果每次都去硬盘查询资源，效率肯定极低，
	
	想想自己实现一个Tomcat，你会让每次请求都去查询硬盘吗？
	
	通常的做法，应该会在内存中维护一些 servlet、文件资源 和 请求路径的对应关系，Tomcat接收到请求后，
	先在内存中查询是否有对应资源，有的话再去获取该资源文件
	
	问题也许就在这儿，我们上传文件时、或者对Tomcat内应用的资源做了变动，不太可能做到实时修改Tomcat内存中的对应关系信息
	常用的策略或许是有一个（或一些）扫描应用资源的线程，周期性的将资源变动信息同步到内存中，而5秒延迟，或许也是因此而来
	以上纯属个人猜想，无任何依据，但这个答案应该比较接近事实了，有空只能通过调试Tomcat源码来验证了

<!--maven导入FileUpload依赖-->
<dependency>
    <groupId>commons-fileupload</groupId>
    <artifactId>commons-fileupload</artifactId>
    <version>1.4</version>
</dependency>
<dependency>
    <groupId>commons-io</groupId>
    <artifactId>commons-io</artifactId>
    <version>2.6</version>
</dependency>

/**
 * @Classname FileUploadUtil
 * @Description TODO
 * @Date 2022/4/12 19:41
 * @Author idrizzle
 */
public class FileUploadUtil {

    /**
     * 利用 fileupload 处理文件上传相关业务
     * 将各个表单项和文件上传后的网络路径 put 到 map 中
     * @author itdrizzle
     * @date 2022/4/12 19:42
     */
    public static void upload(HttpServletRequest request, Map<String, Object> map) throws Exception {
        DiskFileItemFactory factory = new DiskFileItemFactory();
        factory.setSizeThreshold(1024 * 1024 * 1024);              // 内存缓冲区大小
        factory.setRepository(factory.getRepository());            // 设置存放临时文件的目录
        ServletFileUpload upload = new ServletFileUpload(factory);
        upload.setHeaderEncoding("utf-8");                         // 可以解决上传文件名中文乱码问题

        // 通过parseRequest()方法获取的全部表单项将保存到List集合中，
        // 并且保存到List集合中的表单项，不管是文件域还是普通表单域，都将当成FileItem对象处理
        List<FileItem> fileItems = upload.parseRequest(request);

        for (FileItem item : fileItems) {
            // 判断是文件还是普通表单
            if (item.isFormField()) {
                // 普通表单域
                map.put(item.getFieldName(), item.getString("utf-8"));
            } else {
                // 文件
                String originFileName = item.getName();         // 文件名
                // long fileSize = item.getSize();              // 文件大小
                // String contentType = item.getContentType();  // 文件类型

                String fileName = getFileName(originFileName);
                String relativePath = "file/" + fileName;

                String realPath = request.getServletContext().getRealPath(relativePath);
                File file = new File(realPath);
                if(!file.getParentFile().exists()){
                    file.getParentFile().mkdirs();
                }

                // 上传文件
                item.write(file);
                map.put(item.getFieldName(), request.getContextPath() + "/" + relativePath);
            }
        }

    }

    /***
     * 生成存放文件的目录、及唯一的文件名
     * @author itdrizzle
     * @date 2022/4/12 20:08
     * @return {@link File}
     */
    private static String getFileName(String originFileName) {
        // 获取文件后缀名   新的文件名：当前日期 + UUID + 文件后缀名
        int index = originFileName.lastIndexOf(".");
        String suffix = originFileName.substring(index);

        String uuid = UUID.randomUUID().toString();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd-HH-mm-ss");
        String formatDate = sdf.format(new Date());

        return formatDate + "-" + uuid + suffix;
    }
}

@WebServlet("/user/*")
public class UserServlet extends HttpServlet {

    @SneakyThrows
    protected void doPost(HttpServletRequest request, HttpServletResponse response) {
        String contextPath = request.getContextPath();  // contextPath = /app
        String servletPath = request.getServletPath();  // servletPath = /user
        String requestURI = request.getRequestURI();    // requestURI = /app/user/login

        String path = requestURI.replace(contextPath + servletPath + "/", "");  // login

        if ("login".equals(path)) {
            // 登录
            login(request, response);
        } else if ("info".equals(path)) {
            // 显示用户信息
            info(request, response);
        } else if ("update".equals(path)) {
            // 修改用户信息
            updateProfile(request, response);
        }
    }


    protected void doGet(HttpServletRequest request, HttpServletResponse response)  {
        //
        this.doPost(request, response);
    }


    /**
     * 展示用户信息
     * @author itdrizzle
     * @date 2022/4/12 19:18
     */
    private void info(HttpServletRequest request, HttpServletResponse response) 
        throws InvocationTargetException, IllegalAccessException, IOException {
        Cookie[] cookies = request.getCookies();
        User user = new User();
        Map<String, Object> map = new HashMap<>();
        for (Cookie cookie : cookies) {
            map.put(cookie.getName(), cookie.getValue());
        }
        BeanUtils.populate(user, map);

        StringBuilder sb = new StringBuilder();
        sb.append("用户名：").append(user.getUsername()).append("<br>");
        sb.append("密码：").append(user.getPassword()).append("<br>");
        sb.append("性别：").append(user.getGender()).append("<br>");
        sb.append("头像：").append("<br>").append("<img src= '" + user.getAvatar()  + "'/>");

        response.setContentType("text/html;charset=utf-8");

        response.getWriter().println(sb.toString());

    }

    /**
     * 修改用户信息
     * @author itdrizzle
     * @date 2022/4/12 19:33
     */
    private void updateProfile(HttpServletRequest request, HttpServletResponse response) throws Exception {

        Map<String, Object> params = new HashMap<>();
        FileUploadUtil.upload(request, params);

        User user = new User();
        BeanUtils.populate(user, params);

        for (String key : params.keySet()) {
            Cookie cookie = new Cookie(key, params.get(key).toString());
            response.addCookie(cookie);
        }
        response.setHeader("refresh", "5;url=/app/user/info");
        response.setContentType("text/html;charset=utf-8");
        response.getWriter().println("上传成功，5秒后将跳转至info页面");
    }
}