Servlet 实现登录功能
# 35.Servlet 实现登录功能
我们结合之前学习过的功能,做一个小功能来实践练习。
# 需求:用户登录
用户登录案例需求:
- 编写 login.html 登录页面,username & password 两个输入框
- 使用 Druid 数据库连接池技术
- 使用 JdbcTemplate 技术封装 JDBC
- 登录成功跳转到
SuccessServlet
展示:登录成功!用户名,欢迎您 - 登录失败跳转到
FailServlet
展示:登录失败,用户名或密码错误
# 分析
首先有个登录页面,上面有用户名和密码的输入框,还有个登录按钮
点击登录,将请求发到后台一个 Servlet,例如 LoginServlet。
LoginServlet 应该做如下事情:
设置编码
获取 username 和 password
查询动作不应该在 LoginServlet 中完成,因为他是一个单独的动作;我们新建一个 UserDao 类,用来操作数据库。
UserDao 类定义一个登录方法,根据用户名和密码查询数据库,然后返回一个封装好的 User 对象;如果没有查询出来,则返回 null
LoginServlet 根据用户名和密码封装为 User 对象,调用 UserDao 的方法查询,获取返回值(User 对象)
将用户信息存储到 request 中,然后判断 User 对象是否为 null,
是则登录成功,跳转到
SuccessServlet
否则登录失败,跳转到
FailServlet
# 新建 login.html
该 HTML 页面比较简单:
<!doctype html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport"
content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0">
<meta http-equiv="X-UA-Compatible" content="ie=edge">
<title>登录页面</title>
</head>
<body>
<form action="/hello/loginServlet" method="post">
用户名: <input type="text" name="name"> <br>
密码: <input type="text" name="password"> <br>
<input type="submit" value="登录">
</form>
</body>
</html>
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# 数据库准备
这里我们使用在学习 JDBC 时创建的数据库 什么是 JDBC (opens new window) 和 user 表:
CREATE TABLE user (
id BIGINT AUTO_INCREMENT NOT NULL,
name VARCHAR(50) NOT NULL,
password VARCHAR(50) NOT NULL,
PRIMARY KEY(id)
) Engine=INNODB DEFAULT CHARSET=UTF8;
INSERT INTO user (id, name, password) VALUES (1, 'peterjxl', '123456')
INSERT INTO user (id, name, password) VALUES (2, 'peter', '123456')
2
3
4
5
6
7
8
9
在 src 目录下添加 druid.properties:
driverClassName=com.mysql.cj.jdbc.Driver
url=jdbc:mysql:///learnjdbc
username=learn
password=learnpassword
initialSize=5
maxActive=10
maxWait=3000
2
3
4
5
6
7
添加依赖:我们将相关依赖导入到 WEB-INF/lib 目录下(之前学习 JDBC 里用到过的)
commons-logging-1.2.jar
druid-1.0.9.jar
mchange-commons-java-0.2.12.jar
mysql-connector-java-58.0.27.jar
spring-beans-5.0.0.RELEASE.jar
spring-core-5.0.0.RELEASE.jar
spring-jdbc-5.0.0.RELEASE.jar
spring-tx-5.0.0.RELEASE.jar
2
3
4
5
6
7
8
可以从我的 GitHub 仓库里下载 jar 包:
Gitee:lib · /LearnJavaEE - Gitee (opens new window)
GitHub:LearnJavaEE/lib at master · Peter-JXL/LearnJavaEE (opens new window)
# 创建实体类 User
代码如下:
package com.peterjxl.domain;
public class User {
private int id;
private String name;
private String password;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "User{" +
"id=" + id +
", name='" + name + '\'' +
", password='" + password + '\'' +
'}';
}
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
# 编写工具类 JDBCUtils
package com.peterjxl.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 {
//1.加载配置文件
Properties pro = new Properties();
//使用ClassLoader加载配置文件,获取字节输入流
InputStream is = JDBCUtils.class.getClassLoader().getResourceAsStream("druid.properties");
pro.load(is);
//2.初始化连接池对象
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();
}
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
# 创建 UserDao 类
package com.peterjxl.dao;
import com.peterjxl.domain.User;
import com.peterjxl.util.JDBCUtils;
import org.springframework.dao.DataAccessException;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
//操作数据库中User表的类
public class UserDao {
//声明JDBCTemplate对象共用
private JdbcTemplate template = new JdbcTemplate(JDBCUtils.getDataSource());
/**
* 登录方法
* @param loginUser 只有用户名和密码
* @return user包含用户全部数据,没有查询到,则返回null
*/
public User login(User loginUser){
try {
//1.编写sql
String sql = "select * from user where name = ? and password = ?";
//2.调用query方法
User user = template.queryForObject(sql,
new BeanPropertyRowMapper<User>(User.class),
loginUser.getName(),
loginUser.getPassword());
return user;
} catch (DataAccessException e) {
e.printStackTrace();//记录日志
return null;
}
}
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
# 创建测试类 UserDaoTest
我们先测试下 UserDao 类是否能正常使用,然后再继续往下写代码
package com.peterjxl.test;
import com.peterjxl.dao.UserDao;
import com.peterjxl.domain.User;
import org.junit.Test;
public class UserDaoTest {
@Test
public void testLogin(){
User loginUser = new User();
loginUser.setName("peterjxl");
loginUser.setPassword("123456");
UserDao dao = new UserDao();
User user = dao.login(loginUser);
System.out.println(user);
}
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# 编写 LoginServlet 类
package cn.itcast.web.servlet;
import cn.itcast.dao.UserDao;
import cn.itcast.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("/loginServlet")
public class LoginServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//1.设置编码
req.setCharacterEncoding("utf-8");
//2.获取请求参数
String name = req.getParameter("name");
String password = req.getParameter("password");
//3.封装user对象
User loginUser = new User();
loginUser.setUsername(name);
loginUser.setPassword(password);
//4.调用UserDao的login方法
UserDao dao = new UserDao();
User user = dao.login(loginUser);
//5.判断user
if(user == null){
//登录失败
req.getRequestDispatcher("/failServlet").forward(req,resp);
}else{
//登录成功
//存储数据
req.setAttribute("user",user);
//转发
req.getRequestDispatcher("/successServlet").forward(req,resp);
}
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
this.doGet(req,resp);
}
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
# 编写 FailServlet 和 SuccessServlet 类
package com.peterjxl.login;
import com.peterjxl.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 {
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
//获取request域中共享的user对象
User user = (User) request.getAttribute("user");
if(user != null){
//给页面写一句话
//设置编码
response.setContentType("text/html;charset=utf-8");
//输出
response.getWriter().write("登录成功!"+user.getName()+",欢迎您");
}
}
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
package com.peterjxl.login;
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("/failServlet")
public class FailServlet extends HttpServlet {
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
//给页面写一句话
//设置编码
response.setContentType("text/html;charset=utf-8");
//输出
response.getWriter().write("登录失败,用户名或密码错误");
}
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
this.doPost(request,response);
}
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
# 测试
重启 Tomcat,访问 http://localhost: 8080/hello/login.html,测试登录
# BeanUtils 简介
考虑到我们 LoginServlet 中,我们获取参数是一个个获取的,然后封装对象也是一个个设置值,这样非常麻烦:
String username = req.getParameter("username");
String password = req.getParameter("password");
User loginUser = new User();
loginUser.setName(username);
loginUser.setPassword(password);
2
3
4
5
6
我们希望能通过一个方法一次获取到所有参数,然后通过一个方法将数据封装成对象,为此我们可以写个工具类 BeanUtils,简化数据封装 用于封装 JavaBean 的。
为此,我们需要用到 Apache 提供的一个开源的 jar 包:commons-beanutils-1.8.0.jar,将其放到 lib 目录下
修改 loginServlet,使用 BeanUtils 工具类(注意不是 Spring 框架的 BeanUtils,而是 org.apache.commons.beanutils.BeanUtils;)
//1.设置编码
req.setCharacterEncoding("utf-8");
// 2.通过BeanUtils来获取所有参数并封装
Map<String, String[]> parameterMap =req.getParameterMap();
//3.创建user对象
User loginUser = new User();
//3.1使用BeanUtils封装
try {
BeanUtils.populate(loginUser, parameterMap);
} catch (IllegalAccessException | InvocationTargetException e) {
throw new RuntimeException(e);
}
2
3
4
5
6
7
8
9
10
11
12
13
重启 Tomcat 进行测试。
需要注意的是,参数名要和类的成员变量名字一样,例如前堆传的参数是 name,User 类里也定义了 name;如果前端传参是 username,那么会对应不上,使得封装后 User 里的 name 是 null。
# BeanUtils 深入
在继续介绍 BeanUtils 类之前,我们先说下什么是 Bean,也叫 JavaBean。
JavaBean 是一个标准的 Java 类,常用于表示一个实体。在 Java 中,万物皆对象,因此我们常定义一个类表示现实中的事务,例如用户、商品、学生等实体。JavaBean 的规范:
- 类必须被 public 修饰
- 必须提供空参的构造器
- 成员变量必须使用 private 修饰
- 提供公共 setter 和 getter 方法
定义了 JavaBean 后,我们就可以用 JavaBean 来封装数据了,例如数据库里存储了一个个学生信息,我们就可以用一个个 Student 类来存储一个学生的信息。
在 JavaBean 中,有很多的成员变量;而 setter 和 getter 方法截取后的产物,我们称之为属性。
BeanUtils 有如下方法:
setProperty(Object bean, String name, Object value)
:这个方法的作用是,name 是属性名,value 是属性值,然后调用 set 方法来赋值。getProperty(Object bean, String name, Object value)
:根据 value 属性值获取对象里的属性populate(Object obj , Map map)
:将 map 集合的键值对信息,封装到对应的 JavaBean 对象中(其实就是逐个调用setProperty
)
比如,我们可以用 setProperty
和 getProperty
读写 User 对象的 name 属性:
User user = new User();
BeanUtils.setProperty(user, "name", "peterjxl");
System.out.println(user);
String name = BeanUtils.getProperty(user, "name");
System.out.println(name);
2
3
4
5
6
运行结果:
User{id=0, name='peterjxl', password='null'}
peterjxl
2
而 populate(Object obj , Map map)
方法,原理就是逐个获取 map 集合的键,当做属性名,然后通过 setProperty
设置属性的值。
我们可以验证下 BeanUtils 使用的是属性,而不是成员变量。例如我们新建一个 UserTest 类:
package com.peterjxl.domain;
public class UserTest {
private String name;
private String gender;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getHehe() {
return gender;
}
public void setHehe(String gender) {
this.gender = gender;
}
@Override
public String toString() {
return "UserTest{" +
"name='" + name + '\'' +
", gender='" + gender + '\'' +
'}';
}
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
成员变量 gender 的 setter 和 getter,命名方式并不是 set+成员变量的形式。然后我们使用 BeanUtils 方法设置和获取属性:
UserTest userTest= new UserTest();
BeanUtils.setProperty(userTest, "hehe", "male");
System.out.println(userTest);
String gender = BeanUtils.getProperty(userTest, "hehe");
System.out.println(gender);
2
3
4
5
运行结果:
UserTest{name='null', gender='male'}
male
2