JavaWeb_request&response！

1、Request对象

用户通过浏览器访问服务器的时候，Tomcat将HTTP请求中所有的信息都封装在Request对象中
开发人员可以通过request对象方法，来获取浏览器发送的所有信息

获取请求行：

请求行：请求方式+请求url+请求协议

String    getMethod()           获取请求方式
String  getMethod()            获取请求方式
String getContextPath()        获取项目虚拟路径（项目名）
String getRequestURI()        获取URI 项目名/类名 
StringBuffer getRequestURL()        获取URL http://localhost:8080/项目名/类名 
String getProtocol()        获取协议和版本号    HTTP/1.1
String getRemoteAddr()        获取客户端IP地址

获取请求头：

请求头：请求头名称+请求头值

String getHeader(String name)    获取请求头名称对应的值
Enumeration<String> getHeaderNames()    获取所有请求头的名称

获取请求体：

请求体：参数名1+值1&参数名2+值2…

String getParameter(String name)        根据参数名称获取参数值
String[] getParameterValues(String name)    根据参数名称获取参数值的数组
Enumeration<String> getParameterNames()        获取所有请求的参数名称
Map<String,String[]> getParameterMap()    获取所有参数的map集合

乱码问题：

若服务器端（Tomcat：ISO-8859）和客户端（浏览器：GBK）的编码不一致

request.setCharacterEncoding("utf-8");    //必须在行首

2、Request对象的使用

请求转发：

一种在服务器内部的资源跳转方式

1、通过request对象获取转发器对象：
        RequestDispatcher    getRequestDispatcher（String path）
2、使用RequesDispatcher对象来进行转发：
        forward（ServletRequest    request，ServletResponse    response）
二合一：
    request.getRequestDispatcher("转发资源地址").forward(request,response);

请求转发特点：

1. 浏览器地址栏路径不发生变化
2. 只能转发到当前服务器内部资源中。
3. 转发是一次请求
4. 共享同一个请求中的数据
5. 请求转发可以访问WEB-INF目录中的内容

域对象：

一个有作用范围的对象，可以在范围内共享数据
Request，Session，ServletContext（application）
域对象共有方法：

void setAttribute(String name,Object obj)    设置数据
Object getAttribute(String name)    获取数据
void removeAttribute(String name)    删除数据

3、ServletContext对象

servlet上下文，全局唯一，工程内部所有servlet共享这个对象
1、是一个域对象
2、可以读取全局配置参数
3、可以搜索当前工程目录下面的资源文件
4、可以获取当前工程名字

通过request对象获取：

ServletContext sc = request.getServletContext();

通过this获取：

ServletContext sc = this.getServletContext();

ServletContext生命周期：

1、创建
项目加载时，创建
2、销毁
项目卸载时，销毁
3、作用范围
与项目共存亡（多个servlet都可以操作它）

获取资源真实路径：

动态获取文件的真实路径
String getRealPath（String path）

获取全局配置参数：

读取web配置文件中的标签信息

    <!--全局配置参数：所有的servlet都可以读取...-->
    <context-param>
        <param-name>encode</param-name>
        <param-value>UTF-8</param-value>
    </context-param>
// 获取全局参数
        String value = request.getServletContext().getInitParameter("encode");
        System.out.println("全局配置参数："+value);

获取MIME类型：

在互联网通信中定义的一种文件数据类型
大类型/小类型

String filename = req.getParameter("filename");
String mimeType = req.getServletContext().getMimeType(filename);
System.out.println("文件类型:" + mimeType);

4、Response对象

response对象标识web服务器给浏览器返回的响应信息

设置响应行：
    格式：协议/版本号：状态码
    void    setStatus(int sc)    设置状态码
设置响应头：
    格式：响应头值
       void    setHeader(String name,String value)    设置指定头名称和对应的值
设置响应体：
    PrintWriter    getWriter()    字节输出流，不支持中文，默认编码为ISO-8859-1
    ServletOutputStream getOutputStream()    字节输出流
        在同一个servlet中，两种类型的输出流不能同时存在，互斥

5、Response对象的使用

重定向：资源跳转的方式

设置状态码：
    response.setStatus(302);
设置响应头：
    response.setHeader("Location","重新定向网络地址");
    sendRedirect(String urlPath)    重定向到指定资源路径

forword与redirect的区别：

重定向：redirect
1. 地址栏发生变化
2. 重定向可以访问其他站点(服务器)的资源(跨域访问)
3. 重定向是两次请求。不能使用request对象来共享数据
4. 最终响应给浏览器的由最后一个Servlet来决定响应的内容
   这个操作相当于把目标的资源路径拷贝到浏览器地址栏中，回车
5. URL重写向不能访问WEB-INF目录中的资源
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
转发：forward
1. 转发地址栏路径不变
2. 转发只能访问当前服务器下的资源
3. 转发是一次请求，可以使用request对象来共享数据

forword与redirect的使用场景：

1.分析各自的特点
2.必须使用forward
    * 如果需要共享同一次请求中的数据
    * 要访问WEB-INF目录下的资源
3.如果要跨域访问必须使用redirect
4.其他情况根据自己的使用情况来定
5.能使用请求转发的就用请求转发

定时刷新：Refresh

        // 1. 通过response设置响应头 Refresh
        response.setHeader("Refresh", "3;https://www.baidu.com");
        response.setContentType("text/html;charset=utf-8");
        response.getWriter().write("操作成功，3秒后跳转到百度首页...");

用户登录

JDBC工具类：

package com.yunhe.utils;
/*
    @ClassName JDBCUtil
    @Date 2021/6/11
    @Time 11:50
*/
import com.alibaba.druid.pool.DruidDataSourceFactory;
import javax.sql.DataSource;
import java.io.InputStream;
import java.util.Properties;
public class JDBCUtil {
    private static DataSource dataSource;
    static{
        try {
            //读取配置文件
            InputStream is = JDBCUtil.class.getClassLoader().getResourceAsStream("druid.properties");
            Properties pro = new Properties();
            pro.load(is);
            // 创建Druid的数据库连接池对象
            dataSource = DruidDataSourceFactory.createDataSource(pro);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    //提供一个方法用于获取连接池
    public static DataSource getDataSource(){
        return dataSource;
    }
}

前端html：

<!DOCTYPE html>
<!--Date: 2021/6/11 Time: 9:29-->
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>login</title>
    <style type="text/css">
        #login{
            height: 150px;
            width: 200px;
            border: 1px solid green;
            margin: auto;
            margin-top: 100px;
            padding-left:30px;
            padding-top:10px;
        }
        #login input{
            margin-top: 10px
        }
    </style>
</head>
<body>
<div id="login">
    <form action="/loginServlet" method="get">
        用户名：<input type="text" name="username"><br />
        密码：<input type="password" name="password"> <br />
        <input type="submit" value="登录">
    </form>
</div>
</body>
</html>

后端domain：

package com.yunhe.domain;
/*
    @ClassName User
    @Date 2021/6/11
    @Time 9:34
*/
public class User {
    private int uid;
    private String username;
    private String password;
    //省略get/set
    //省略无参和有参
}

后端servlet&登录结果：

package com.yunhe.web;
import com.yunhe.domain.User;
import com.yunhe.service.Userservice;
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("/loginServlet")
public class LoginServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        Userservice userservice = new Userservice();
        String username = request.getParameter("username");
        String password = request.getParameter("password");
        User user = new User(username,password);
        if (userservice.login(user)!=null){
            request.setAttribute("msg","登录成功！欢迎你，"+username);
            request.getRequestDispatcher("/okServlet").forward(request,response);
        }else{
            request.setAttribute("msg","登录失败！请从重新登录，"+username);
            request.getRequestDispatcher("/okServlet").forward(request,response);
        }
    }
    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        // 处理post请求乱码问题
        request.setCharacterEncoding("utf-8");
        // 响应参数乱码解决方法
        response.setContentType("text/html;charset=UTF-8");
        this.doGet(request, response);
    }
}
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
package com.yunhe.web;
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("/okServlet")
public class okServlet extends HttpServlet {
    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        request.setCharacterEncoding("utf-8");// 处理post请求乱码问题
        response.setContentType("text/html;charset=UTF-8"); // 响应参数乱码解决方法
        response.getWriter().write("<h1>"+request.getAttribute("msg")+"</h1>");
    }
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        this.doPost(request, response);
    }
}

后端service：

package com.yunhe.service;
/*
    @ClassName Userservice
    @Date 2021/6/11
    @Time 9:37
*/
import com.yunhe.dao.UserDao;
import com.yunhe.domain.User;
public class Userservice {
    UserDao userDao = new UserDao();
    //登录
    public User login(User user) {
            return userDao.login(user);
    }
}

后端dao：

package com.yunhe.dao;
/*
    @ClassName UserDao
    @Date 2021/6/11
    @Time 9:38
*/
import com.yunhe.domain.User;
import com.yunhe.utils.JDBCUtil;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
public class UserDao {
    JdbcTemplate jdbcTemplate = new JdbcTemplate(JDBCUtil.getDataSource());
    public User login(User user) {
        String sql="select * from zw_user where username=? and password = ?";
        try {
            //执行sql语句
            User userLogin = jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<>(User.class),
                    user.getUsername(), user.getPassword());
            return userLogin;
        }catch (Exception e){
            e.printStackTrace();
            return null;
        }
    }
}

文件下载

前端html：

<!DOCTYPE html>
<!--Date: 2021/6/11 Time: 14:06-->
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>未命名</title>
    <style type="text/css">
    </style>
</head>
<body>
<p><a href="/downLoadServlet?filename=java.docx">doc文档</a></p>
<p><a href="/downLoadServlet?filename=java.jpg">jpg图片</a></p>
<script type="text/javascript">
</script>
</body>
</html>

后端download：

package com.download;
import com.util.DownLoadUtils;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.ServletInputStream;
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.File;
import java.io.FileInputStream;
import java.io.IOException;
@WebServlet("/downLoadServlet")
public class DownLoadServlet extends HttpServlet {
    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        request.setCharacterEncoding("utf-8");// 处理post请求乱码问题
        response.setContentType("text/html;charset=UTF-8"); // 响应参数乱码解决方法
        String filename = request.getParameter("filename");//获取前端传过来的文件名
        //获取服务器文件的真实路径
        ServletContext servletContext  = this.getServletContext();  //获取项目路径
        filename = servletContext.getRealPath("/down/" + filename); //拼接项目路径和文件名
        //读取文件
        //创建本地流
        FileInputStream fis = new FileInputStream(new File(filename));
        // 获取文件的真实类型
        String mimeType = servletContext.getMimeType(filename);
        //设置响应头
        response.setHeader("Content-Type",mimeType);    //响应头名称+,+获取的文件的真实类型
        //获取获取访问的浏览器类型
        String useragent = request.getHeader("user-agent");
        filename = DownLoadUtils.getName(useragent, filename); //解决浏览器中文兼容问题
        // 设置以附件的形式打开文件
        response.setHeader("content-disposition","attachment;filename="+filename);
        // 获取字节输出流
        ServletOutputStream os = response.getOutputStream();
        //读取文件
        int len ;
        byte[] bys = new byte[1024];
        while ((len = fis.read(bys))!=-1){
            os.write(bys,0,len);
        }
        //释放资源
        os.close();
        fis.close();
    }
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        this.doPost(request, response);
    }
}

后端判断访问浏览器类型工具类：

package com.util;
import sun.misc.BASE64Encoder;
import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
/*
  解决浏览器中文兼容性的问题的
 */
public class DownLoadUtils {
    public static String getName(String agent, String filename) throws UnsupportedEncodingException {
        if (agent.contains("Firefox")) {
            // 火狐浏览器
            BASE64Encoder base64Encoder = new BASE64Encoder();
            filename = "=?utf-8?B?" + base64Encoder.encode(filename.getBytes("utf-8")) + "?=";
        } else {
            // 其它浏览器
            filename = URLEncoder.encode(filename, "utf-8");
        }
        return filename;
    }
}