Request 和 Response详解（中）：https://developer.aliyun.com/article/1491732
- 重定向的特点
- 浏览器地址栏路径发送变化
当进行重定向访问的时候，由于是由浏览器发送的两次请求，所以地址会发生变化
- 可以重定向到任何位置的资源(服务内容、外部均可)
因为第一次响应结果中包含了浏览器下次要跳转的路径，所以这个路径是可以任意位置资源。
- 两次请求，不能在多个资源使用request共享数据
因为浏览器发送了两次请求，是两个不同的request对象，就无法通过request对象进行共享数据
介绍完请求重定向和请求转发以后，接下来需要把这两个放在一块对比下:
以后到底用哪个，还是需要根据具体的业务来决定。
# 如果需要在资源之间传递数据,使用请求转发, 否则就用重定向
4 路径问题
- 问题1：转发的时候路径上没有加
/request-demo而重定向加了，那么到底什么时候需要加，什么时候不需要加呢?
其实判断的依据很简单，只需要记住下面的规则即可:
- 浏览器使用:需要加虚拟目录(项目访问路径)
- 服务端使用:不需要加虚拟目录
对于转发来说，因为是在服务端进行的，所以不需要加虚拟目录
对于重定向来说，路径最终是由浏览器来发送请求，就需要添加虚拟目录。
掌握了这个规则，接下来就通过一些练习来强化下知识的学习:
1.超链接，从浏览器发送，需要加 2.表单，从浏览器发送，需要加 3.转发，是从服务器内部跳转，不需要加 4.重定向，是由浏览器进行跳转，需要加。
5 Response响应字符数据
/** * 响应字符数据：设置字符数据的响应体 */ @WebServlet("/resp3") public class ResponseDemo3 extends HttpServlet { @Override protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { response.setContentType("text/html;charset=utf-8"); //1. 获取字符输出流 PrintWriter writer = response.getWriter(); writer.write("aaa"); } @Override protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { this.doGet(request, response); } }
PrintWriter writer = response.getWriter(); //content-type，告诉浏览器返回的数据类型是HTML类型数据，这样浏览器才会解析HTML标签 response.setHeader("content-type","text/html"); writer.write("<h1>aaa</h1>");
==注意:==一次请求响应结束后，response对象就会被销毁掉，所以不要手动关闭流。
//设置响应的数据格式及数据的编码 response.setContentType("text/html;charset=utf-8"); writer.write("你好");
6 Response响应字节数据
/** * 响应字节数据：设置字节数据的响应体 */ @WebServlet("/resp4") public class ResponseDemo4 extends HttpServlet { @Override protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { //1. 读取文件 FileInputStream fis = new FileInputStream("d://a.jpg"); //2. 获取response字节输出流 ServletOutputStream os = response.getOutputStream(); //3. 完成流的copy byte[] buff = new byte[1024]; int len = 0; while ((len = fis.read(buff))!= -1){ os.write(buff,0,len); } fis.close(); } @Override protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { this.doGet(request, response); } }
上述代码中，对于流的copy的代码还是比较复杂的，所以我们可以使用别人提供好的方法来简化代码的开发，具体的步骤是:
<dependency> <groupId>commons-io</groupId> <artifactId>commons-io</artifactId> <version>2.6</version> </dependency>
//fis:输入流 //os:输出流 IOUtils.copy(fis,os);
/** * 响应字节数据：设置字节数据的响应体 */ @WebServlet("/resp4") public class ResponseDemo4 extends HttpServlet { @Override protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { //1. 读取文件 FileInputStream fis = new FileInputStream("d://a.jpg"); //2. 获取response字节输出流 ServletOutputStream os = response.getOutputStream(); //3. 完成流的copy IOUtils.copy(fis,os); fis.close(); } @Override protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { this.doGet(request, response); } }
5.用户注册登录案例
接下来我们通过两个比较常见的案例，一个是注册，一个是登录来对今天学习的内容进行一个实战演练，首先来实现用户登录。
5.1 用户登录
1.登录案例分析
学习目标
- 能够分析登录案例的步骤
- 能够理解登录案例整体流程
内容讲解
1.开发步骤
1.画流程开发图
2.搭建项目环境
3.根据流程图编写代码
4.浏览器访问服务器，测试功能
2.画流程开发图
#web层： 1.获取浏览器的请求数据 2.创建实体类对象user 3.将用户名和密码封装到对象user 4.创建业务层对象 5.使用业务层对象调用业务层登录方法 6.判断业务层返回的对象是否是null 7.是null，说明没有查到用户，登录失败，跳转到登录失败页面 8.如果不是null,登录成功，跳转到成功页面 #service层： 1.定义登录方法接收web层传递的用户对象 2.使用mybatis工具类获取session对象 3.使用session对象调用方法获取接口Mapper对象 4.使用Mapper对象调用接口的登录方法 User u = mapper.login(user); 5.返回给web层对象u #dao层： 1.定义接口UserMapper 2.在接口UserMapper中定义登录方法
2.环境搭建
学习目标
- 能够独立完成前后台环境的搭建
内容讲解
1后台环境
【1】数据库环境
create database day11_db; use day11_db; DROP TABLE IF EXISTS `user`; CREATE TABLE `user` ( `id` int(11) NOT NULL AUTO_INCREMENT, `username` varchar(20) NOT NULL, `password` varchar(32) NOT NULL, PRIMARY KEY (`id`) ) ENGINE=InnoDB AUTO_INCREMENT=5 DEFAULT CHARSET=utf8; -- ---------------------------- -- Records of user -- ---------------------------- INSERT INTO `user` VALUES ('1', 'zhangsan', '1234'); INSERT INTO `user` VALUES ('2', 'lisi', '1234'); INSERT INTO `user` VALUES ('3', 'wangwu', '1234'); INSERT INTO `user` VALUES ('4', 'zhaoliu', '1234');
【2】创建工程并创建分层包
【3】导入第三方jar包
<dependencies> <!--junit--> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <!--<version>4.13</version>--> <version>4.13</version> <!--范围：测试存在--> <!--<scope>test</scope>--> </dependency> <!--mybatis核心包--> <dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis</artifactId> <version>3.5.0</version> </dependency> <!--logback日志包--> <dependency> <groupId>org.slf4j</groupId> <artifactId>slf4j-api</artifactId> <version>1.7.26</version> </dependency> <dependency> <groupId>ch.qos.logback</groupId> <artifactId>logback-core</artifactId> <version>1.2.3</version> </dependency> <dependency> <groupId>ch.qos.logback</groupId> <artifactId>logback-classic</artifactId> <version>1.2.3</version> </dependency> <!--mysql驱动--> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>5.1.18</version> </dependency> <dependency> <groupId>javax.servlet</groupId> <artifactId>javax.servlet-api</artifactId> <version>3.0.1</version> <!--编译 测试需要，运行时不需要--> <scope>provided</scope> </dependency> </dependencies> <!--插件管理--> <build> <plugins> <!--JDK编译插件--> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-compiler-plugin</artifactId> <version>3.8.1</version> <configuration> <!-- put your configurations here --> <source>1.8</source> <target>1.8</target> <encoding>UTF-8</encoding> </configuration> </plugin> <plugin> <groupId>org.apache.tomcat.maven</groupId> <artifactId>tomcat7-maven-plugin</artifactId> <version>2.2</version> <configuration> <port>80</port> <path>/</path> </configuration> </plugin> </plugins> </build>
【4】配置文件
db.properties:
jdbc.driver=com.mysql.jdbc.Driver jdbc.url=jdbc:mysql://localhost:3306/day33_usermanager jdbc.username=root jdbc.password=1234
mybatis核心配置文件：
<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd"> <configuration> <!--加载外部的配置文件--> <properties resource="db.properties"></properties> <!--settings--> <settings> <!--开启驼峰自动映射--> <setting name="mapUnderscoreToCamelCase" value="true"/> </settings> <!--别名--> <typeAliases> <package name="com.itheima.sh.pojo"></package> </typeAliases> <!--mybatis环境的配置 一个核心配置文件，可以配置多个运行环境，default默认使用哪个运行环境 --> <environments default="development"> <!--通常我们只需要配置一个就可以了， id是环境的名字 --> <environment id="development"> <!--事务管理器：由JDBC来管理--> <!-- 事务管理器type的取值： 1. JDBC：由JDBC进行事务的管理 2. MANAGED：事务由容器来管理，后期学习Spring框架的时候，所有的事务由容器管理 --> <transactionManager type="JDBC"/> <!--数据源的配置：mybatis自带的连接池--> <!-- 数据源： 1. POOLED：使用mybatis创建的连接池 2. UNPOOLED：不使用连接池，每次自己创建连接 3. JNDI：由服务器提供连接池的资源，我们通过JNDI指定的名字去访问服务器中资源。 --> <dataSource type="POOLED"> <property name="driver" value="${jdbc.driver}"/> <property name="url" value="${jdbc.url}"/> <property name="username" value="${jdbc.username}"/> <property name="password" value="${jdbc.password}"/> </dataSource> </environment> </environments> <!--映射器--> <mappers> <!--加载其它的映射文件 注：注解开发是点号--> <!-- <package name="com.itheima.sh.dao"></package>--> <!--加载其它的映射文件 注：不是点号--> <!--<mapper resource="org/mybatis/example/BlogMapper.xml"/>--> <!-- 加载其它的映射文件 xml形式 包扫描方式加载mapper映射文件,说明： 1. 要求mapper映射文件，与mapper接口要放在同一个目录 2. 要求mapper映射文件的名称，与mapper接口的名称要一致 --> <package name="com.itheima.sh.dao"></package> </mappers> </configuration>
【5】实体类
package com.itheima.sh.pojo; public class User { //成员变量 private Integer id; private String username; private String password; public User() { } public Integer getId() { return id; } public void setId(Integer 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 + '\'' + '}'; } }
【6】工具类
package com.itheima.sh.util; import org.apache.ibatis.io.Resources; import org.apache.ibatis.session.SqlSession; import org.apache.ibatis.session.SqlSessionFactory; import org.apache.ibatis.session.SqlSessionFactoryBuilder; import java.io.IOException; /* 工具类特点： 1.位于util包 2.私有化构造方法 3.提供静态方法 */ public class SqlSessionUtil { private static SqlSessionFactory factory = null; //2.私有化构造方法 目的：不能创建对象，使用类名调用本类静态方法 private SqlSessionUtil() { } //定义静态代码块：当前类加载就执行，之后执行一次 static { try { //1.创建工厂创造类对象 SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder(); //2.获取工厂对象 factory = builder.build(Resources.getResourceAsStream("mybatis-config.xml")); } catch (IOException e) { e.printStackTrace(); } } //编写静态方法获取会话对象，设置自动提交事务 public static SqlSession getSqlSession() { //1.根据会话工厂对象获取会话对象 SqlSession sqlSession = factory.openSession(true); //2.返回会话对象 return sqlSession; } //编写静态方法获取会话对象，方法接收调用者传递的参数是布尔类型，决定是否设置自动提交事务 public static SqlSession getSqlSession(boolean isAutoCommit) { //1.根据会话工厂对象获取会话对象 SqlSession sqlSession = factory.openSession(isAutoCommit); //2.返回会话对象 return sqlSession; } //编写静态方法接收会话对象，手动提交事务并且关闭会话 public static void commitAndClose(SqlSession sqlSession) { //防止空指针异常 if (sqlSession != null) { //1.手动提交事务 sqlSession.commit(); //2.释放资源 sqlSession.close(); } } //编写静态方法接收会话对象，回滚事务并且关闭会话 public static void rollbackAndClose(SqlSession sqlSession) { //防止空指针异常 if (sqlSession != null) { //1.回滚事务 sqlSession.rollback(); //2.释放资源 sqlSession.close(); } } }
【7】UserMapper接口
package com.itheima.sh.dao; import com.itheima.sh.pojo.User; import org.apache.ibatis.annotations.Select; public interface UserMapper { //登录 /* 1.username=#{username} 等号左边的username数据表的字段名 等号右边大括号中的username看此时login登录方法的形参类型 这里login登录方法形参类型是User类型，如果形参是一个pojo属于复杂类型，看实体类User中的getXxxx()去掉get，X变为x 例如getUsername----username,#{username}在mybatis底层调用的是User实体类中的getUsername */ @Select("select * from user where username=#{username} and password=#{password}") User login(User user); }
【8】测试类
package com.itheima.sh.test; import com.itheima.sh.dao.UserMapper; import com.itheima.sh.pojo.User; import com.itheima.sh.utils.SessionFactoryUtils; import org.apache.ibatis.session.SqlSession; import org.junit.Test; public class LoginTest { //查询 @Test public void login(){ //1.使用工具类获取会话对象 SqlSession session = SessionFactoryUtils.getSession(); //2.使用会话对象获取接口代理对象 UserMapper mapper = session.getMapper(UserMapper.class); //3.使用接口代理对象调用接口中的登录方法 User user = new User(); user.setUsername("zhangsan"); user.setPassword("1234"); User u = mapper.login(user); //4.输出结果 System.out.println("u = " + u); //5.关闭会话 session.close(); } }
2前台环境
直接将资料中的内容复制到工程下面的web文件夹即可。
直接将资料中的内容复制到工程下面的web文件夹即可。
3.根据流程图编写代码
1.dao层代码的编写
学习目标
- 能够编写出dao层的代码向数据库查询数据
内容讲解
【1】步骤
1.创建UserMapper接口 2.在UserMapper接口中定义登录方法 3.在登录方法上使用注解向数据库根据用户名和密码查询数据
【2】实现
package com.itheima.sh.dao; import com.itheima.sh.pojo.User; import org.apache.ibatis.annotations.Select; // 1.定义接口UserMapper public interface UserMapper { // 2.在接口UserMapper中定义登录方法 //登录 /* 1.username=#{username} 等号左边的username数据表的字段名 等号右边大括号中的username看此时login登录方法的形参类型 这里login登录方法形参类型是User类型，如果形参是一个pojo属于复杂类型，看实体类User中的getXxxx()去掉get，X变为x 例如getUsername----username,#{username}在mybatis底层调用的是User实体类中的getUsername */ @Select("select * from user where username=#{username} and password=#{password}") User login(User user); }
内容小结
1.定义根据用户名和密码查询的方法
username=#{username}: 1.等号左边的username看数据表的字段名 2.#{username}:大括号中的username，由于login方法参数是User实体类类型，所以这里的username书写看User实体类中的成员变量名username 实际上这里调用的是User实体类中的getUsername
2.service层代码的编写
学习目标
- 能够编写业务层代码
内容讲解
【1】步骤：
1.定义登录方法接收web层传递的用户对象 2.使用mybatis工具类获取session对象 3.使用session对象调用方法获取接口Mapper对象 4.使用Mapper对象调用接口的登录方法 User u = mapper.login(user); 5.返回给web层对象u
【2】实现：
import org.apache.ibatis.session.SqlSession; /* 业务层 */ public class UserServcie { //1.定义登录方法接收web层传递的用户对象 public User login(User user) { //2.使用mybatis工具类获取session对象 SqlSession session = SessionFactoryUtils.getSession(); //3.使用session对象调用方法获取接口Mapper对象 UserMapper mapper = session.getMapper(UserMapper.class); //4.使用Mapper对象调用接口的登录方法 User u = mapper.login(user); //User u = mapper.login(user); //关闭会话对象 session.close(); //5.返回给web层对象u return u; } }
内容小结
使用mybatis工具类获取接口代理对象，调用方法查询用户并返回查询的实体类对象给web层。
3.web层代码的编写
学习目标
- 能够编写web层代码
内容讲解
【1】步骤
1.获取浏览器的请求数据 2.创建实体类对象user 3.将用户名和密码封装到对象user 4.创建业务层对象 5.使用业务层对象调用业务层登录方法 6.判断业务层返回的对象是否是null 7.是null，说明没有查到用户，登录失败，跳转到登录失败页面 8.如果不是null,登录成功，跳转到成功页面
【2】实现
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 { protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { doGet(request, response); } protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { //1.获取浏览器的请求数据 String username = request.getParameter("username"); String password = request.getParameter("password"); //2.创建实体类对象user User user = new User(); //3.将用户名和密码封装到对象user user.setUsername(username); user.setPassword(password); //4.创建业务层对象 UserServcie userServcie = new UserServcie(); //5.使用业务层对象调用业务层登录方法 User u = userServcie.login(user); //6.判断业务层返回的对象是否是null if (u == null) { //7.是null，说明没有查到用户，登录失败，跳转到登录失败页面 request.getRequestDispatcher("/error.html").forward(request,response); } else { //8.如果不是null,登录成功，跳转到成功页面 request.getRequestDispatcher("/success.html").forward(request,response); } } }
5.2 用户注册
学习目标
- 完成注册案例
内容讲解
1.开发步骤
1.画注册流程图
2.根据流程图编写代码
3.浏览器访问服务器，测试功能
2.画注册流程图
dao层： //1.在接口中定义根据用户名查询的方法 //2.在接口中定义注册方法 service层： //1.定义注册的方法接收web层传递的user对象 //2.获取会话对象 //3.获取接口代理对象 //4.使用接口代理对象调用接口中的根据用户名查询的方法 //5.判断返回的User对象是否等于null //6.如果等于null,说明没有查到，可以注册，使用接口代理对象调用注册方法 //7.提交事务 //8.返回给web层true //9.如果查询的用户对象不等于null,说明用户存在，不能注册，返回给web层false //10.释放资源 web层： //1.处理请求乱码 //2.获取页面的数据 //3.创建User对象 //4.将获取的数据封装到User对象中 //5.创建业务层对象 //6.使用业务层对象调用注册方法，将User对象作为参数传递到业务层 //7.判断返回值 //8.如果返回值是true，注册成功，跳转到登录页面 //9.如果返回值是false，注册失败，跳转到失败页面
注意：注册案例需要先根据注册的用户名查询数据，如果用户名存在注册失败，用户名不存在，注册成功。
3.根据流程图编写代码
3.1dao层
import org.apache.ibatis.annotations.Insert; import org.apache.ibatis.annotations.Param; import org.apache.ibatis.annotations.Select; import java.util.List; //1.创建接口UserMapper public interface UserMapper { //1.定义根据用户名查询用户的方法 @Select("select * from user where username=#{username}") User queryUserByUsername(@Param("username") String username); //2.添加用户的方法 @Insert("insert into user values(null,#{username},#{password})") void addUser(User user); }
3.2service层
import org.apache.ibatis.session.SqlSession; /* 业务层 */ public class UserService { //1.定义一个登录方法接收web层传递的数据 public User login(User user) { //2.使用mybatis工具类调用方法获取会话对象 SqlSession session = SessionFactoryUtils.getSession(); //3.使用session对象调用UserMapper接口代理对象 UserMapper mapper = session.getMapper(UserMapper.class); //4.使用接口代理对象mapper调用接口中的方法根据用户名和密码查询数据 User u = mapper.login(user); //5.关闭session session.close(); //6.返回u return u; } //1.定义注册方法接收web层传递的数据user public boolean register(User user) { //2.使用mybatis工具类获取session会话对象 SqlSession session = SessionFactoryUtils.getSession(); //3.使用会话对象调用方法获取接口UserMapper代理对象 UserMapper mapper = session.getMapper(UserMapper.class); //4.根据UserMapper代理对象 调用根据用户名查询的方法 String username = user.getUsername(); User u = mapper.queryUserByUsername(username); //5.判断u是否等于null if (u == null) { //6.没有查到用户，可以注册，直接调用添加方法 mapper.addUser(user); //提交事务 session.commit(); //7.关闭session session.close(); //8.返回true return true; } else { //9.注册失败,关闭session session.close(); //10.返回false return false; } } }
小结：
1.在业务层我们主要是先根据用户名查询用户是否存在，如果不存在在执行添加用户方法，存在则不添加。
2.别忘记提交事务，增删改需要提交事务
3.3web层
import org.apache.commons.beanutils.BeanUtils; 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.lang.reflect.InvocationTargetException; @WebServlet("/registerServlet") public class RegisterServlet extends HttpServlet { protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { doGet(request, response); } protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { //1.处理post请求乱码 request.setCharacterEncoding("utf-8"); //2.接收请求数据封装到User实体类对象中 User user = new User(); try { BeanUtils.populate(user, request.getParameterMap()); //3. 创建业务层对象 UserService service = new UserService(); //4. 使用业务层对象调用注册方法将用户数据传递到service层 boolean result = service.register(user); //5. 判断result结果 if (result) { //6. 表示注册成功, 跳转到登录页面 response.sendRedirect("/login.html"); } else { //7. 注册失败，跳转到失败页面 response.sendRedirect("/registerError.html"); } } catch (Exception e) { e.printStackTrace(); } } }
3.4页面实现
register.html页面：
<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>欢迎注册</title> <link href="css/register.css" rel="stylesheet"> </head> <body> <div class="form-div"> <div class="reg-content"> <h1>欢迎注册</h1> <span>已有帐号？</span> <a href="login.html">登录</a> </div> <form id="reg-form" action="#" method="get"> <table> <tr> <td>用户名</td> <td class="inputs"> <input name="username" type="text" id="username"> <br> <span id="username_err" class="err_msg" style="display: none">用户名不太受欢迎</span> </td> </tr> <tr> <td>密码</td> <td class="inputs"> <input name="password" type="password" id="password"> <br> <span id="password_err" class="err_msg" style="display: none">密码格式有误</span> </td> </tr> </table> <div class="buttons"> <input value="注 册" type="submit" id="reg_btn"> </div> <br class="clear"> </form> </div> </body> </html>
registerError.html
<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Title</title> </head> <body> <h2>注册失败，<a href="register.html">重新注册</a></h2> </body> </html>
