从 01 开始
2023-04-17
目录

Servlet 实现登录功能

# 35.Servlet 实现登录功能

我们结合之前学习过的功能，做一个小功能来实践练习。 ‍

# 需求：用户登录

用户登录案例需求：

  1. 编写 login.html 登录页面，username & password 两个输入框
  2. 使用 Druid 数据库连接池技术
  3. 使用 JdbcTemplate 技术封装 JDBC
  4. 登录成功跳转到 SuccessServlet 展示：登录成功！用户名，欢迎您
  5. 登录失败跳转到 FailServlet 展示：登录失败，用户名或密码错误 ‍

# 分析

首先有个登录页面，上面有用户名和密码的输入框，还有个登录按钮

点击登录，将请求发到后台一个 Servlet，例如 LoginServlet。

LoginServlet 应该做如下事情：

  1. 设置编码

  2. 获取 username 和 password

  3. 查询动作不应该在 LoginServlet 中完成，因为他是一个单独的动作；我们新建一个 UserDao 类，用来操作数据库。

  4. UserDao 类定义一个登录方法，根据用户名和密码查询数据库，然后返回一个封装好的 User 对象；如果没有查询出来，则返回 null

  5. LoginServlet 根据用户名和密码封装为 User 对象，调用 UserDao 的方法查询，获取返回值（User 对象）

  6. 将用户信息存储到 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>
1
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')
1
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
1
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
1
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 + '\'' +
                '}';
    }
}
1
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();
    }
}
1
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;
        }
    }
}
1
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);
    }
}
1
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);
    }
}
1
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()+",欢迎您");
        }
    }
}
1
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);
    }
}
1
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);
1
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);
}
1
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 的规范：

  1. 类必须被 public 修饰
  2. 必须提供空参的构造器
  3. 成员变量必须使用 private 修饰
  4. 提供公共 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);
1
2
3
4
5
6

运行结果：

User{id=0, name='peterjxl', password='null'}
peterjxl
1
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 + '\'' +
                '}';
    }
}
1
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);
1
2
3
4
5

运行结果：

UserTest{name='null', gender='male'}
male
1
2

‍

上次更新: 2025/6/3 09:31:54
request 其他功能
HTTP 协议基础-响应

← HTTP 协议基础-响应→

最近更新
01
学点统计学：轻松识破一本正经的胡说八道
06-05
02
2025 年 5 月记
05-31
03
《贫穷的本质》很棒，但可能不适合你
05-27
更多文章>
Theme by Vdoing | Copyright © 2022-2025 | 粤 ICP 备 2022067627 号 -1 | 粤公网安备 44011302003646 号 | 点击查看十年之约