关于JSP用户登录连接数据库详情_Java

关于jsp用户登录连接数据库详情

1、首先创建po类

与数据库一一对应

lombok生成get set方法

package com.ftzlover.demo.po;
import lombok.getter;
import lombok.setter;
@getter
@setter
public class user {

    private integer userid; // 用户id
    private string uname; // 用户名称
    private string upwd; // 用户密码
    private string nick; // 用户昵称
    private string head; // 用户头像
    private string mood; // 用户签名
}

2、创建底层userdao

这里就是所有创建好的层

3、创建userservice(一般都会调用userdao)

private userdao userdao = new userdao();

4、写web层usersrevlet

注意：

首先需要写@webservlet("/user")在顶端，
接下来让其调用service层private userservice userservice = new userservice();
然后让后让这个类继承 httpservlet

public class userservlet extends httpservlet {

4.1 重写方法

@override
    protected void service(httpservletrequest request, httpservletresponse response) throws servletexception, ioexception {

4.2创建vo层并在里面创建resultinfo类用于封装返回数据

创建状态码code 提示信息返回对象

@getter
@setter
public class resultinfo<t> {

    private integer code; // 状态码 成功=1，失败=0
    private string msg; // 提示信息
    private t result; // 返回的对象（字符串、javabean、集合、map等）

}

5、开始从dao开始写

dao层：（数据访问层：数据库中的增删改查操作）通过用户名查询用户对象，返回用户对象

获取数据库连接

定义sql语句
预编译
设置参数
执行查询，返回结果集
判断并分析结果集
关闭资源

package com.ftzlover.demo.dao;

import com.ftzlover.demo.po.user;
import com.ftzlover.demo.util.dbutil;

import java.sql.connection;
import java.sql.preparedstatement;
import java.sql.resultset;

/**
 *  dao层：（数据访问层：数据库中的增删改查操作）
 *         通过用户名查询用户对象， 返回用户对象
 *             1. 获取数据库连接
 *             2. 定义sql语句
 *             3. 预编译
 *             4. 设置参数
 *             5. 执行查询，返回结果集
 *             6. 判断并分析结果集
 *             7. 关闭资源
 */
public class userdao {

    public user queryuserbyname(string username){
        //首先创建对象
        user user = null;
        connection connection = null;
        preparedstatement preparedstatement = null;  //预编译对象
        resultset resultset = null;

        try {
            // 1. 获取数据库连接
            connection = dbutil.getconnetion();
            // 2. 定义sql语句
            string sql = "select * from tb_user where uname = ?";
            // 3. 预编译
            preparedstatement = connection.preparestatement(sql);
            // 4. 设置参数
            preparedstatement.setstring(1, username);
            // 5. 执行查询，返回结果集
            resultset = preparedstatement.executequery();
            // 6. 判断并分析结果集
            if (resultset.next()) {
                user = new user();
                user.setuserid(resultset.getint("userid"));
                user.setuname(username);
                user.sethead(resultset.getstring("head"));
                user.setmood(resultset.getstring("mood"));
                user.setnick(resultset.getstring("nick"));
                user.setupwd(resultset.getstring("upwd"));
            }
        } catch (exception e) {
            e.printstacktrace();
        } finally {
            // 7. 关闭资源
            dbutil.close(resultset,preparedstatement,connection);
        }


        return  user;
    }
}

6、开始写service层

package com.ftzlover.demo.service;

import cn.hutool.core.util.strutil;
import cn.hutool.crypto.digest.digestutil;
import com.ftzlover.demo.dao.userdao;
import com.ftzlover.demo.po.user;
import com.ftzlover.demo.vo.resultinfo;
/*service层：（业务逻辑层：参数判断、业务逻辑处理）
        1. 判断参数是否为空
        如果为空
        设置resultinfo对象的状态码和提示信息
        返回resultinfo对象
        2. 如果不为空，通过用户名查询用户对象
        3. 判断用户对象是否为空
        如果为空
        设置resultinfo对象的状态码和提示信息
        返回resultinfo对象
        4. 如果用户对象不为空，将数据库中查询到的用户对象的密码与前台传递的密码作比较 （将密码加密后再比较）
        如果密码不正确
        设置resultinfo对象的状态码和提示信息
        返回resultinfo对象
        5. 如果密码正确
        设置resultinfo对象的状态码和提示信息
        6. 返回resultinfo对象

 */
public class userservice {
    private userdao userdao = new userdao();

    public resultinfo<user> userlogin(string username,string userpwd){
        resultinfo<user> resultinfo = new resultinfo<>();

        // 数据回显：当登录实现时，将登录信息返回给页面显示
        user u = new user();
        u.setuname(username);
        u.setupwd(userpwd);
        // 设置到resultinfo对象中
        resultinfo.setresult(u);

        //  1. 判断参数是否为空
        if (strutil.isblank(username) || strutil.isblank(userpwd)) {
            // 如果为空 设置resultinfo对象的状态码和提示信息
            resultinfo.setcode(0);
            resultinfo.setmsg("用户姓名或密码不能为空！");
            // 返回resultinfo对象
            return resultinfo;

        }

        // 2. 如果不为空，通过用户名查询用户对象
        user user = userdao.queryuserbyname(username);


        // 3. 判断用户对象是否为空
        if (user == null) {
            // 如果为空,设置resultinfo对象的状态码和提示信息
            resultinfo.setcode(0);
            resultinfo.setmsg("该用户不存在！");
            // 返回resultinfo对象
            return resultinfo;
        }

        //  4. 如果用户对象不为空，将数据库中查询到的用户对象的密码与前台传递的密码作比较 （将密码加密后再比较）
        // 将前台传递的密码按照md5算法的方式加密
        userpwd = digestutil.md5hex(userpwd);

        // 判断加密后的密码是否与数据库中的一致
        if (!userpwd.equals(user.getupwd())) {
            // 如果密码不正确
            resultinfo.setcode(0);
            resultinfo.setmsg("用户密码不正确！");
            return resultinfo;
        }
        resultinfo.setcode(1);
        resultinfo.setresult(user);
        return resultinfo;
    }
}

7、编写最后的servelt层

7.1 用户登陆

package com.ftzlover.demo.web;

import com.ftzlover.demo.po.user;
import com.ftzlover.demo.service.userservice;
import com.ftzlover.demo.vo.resultinfo;

import javax.servlet.servletexception;
import javax.servlet.annotation.webservlet;
import javax.servlet.http.cookie;
import javax.servlet.http.httpservlet;
import javax.servlet.http.httpservletrequest;
import javax.servlet.http.httpservletresponse;
import java.io.ioexception;
@webservlet("/user")
public class userservlet extends httpservlet {

    private userservice userservice = new userservice();

    @override
    protected void service(httpservletrequest request, httpservletresponse response) throws servletexception, ioexception {


        // 接收用户行为
        string actionname = request.getparameter("actionname");
        if ("login".equals(actionname)) {

            // 用户登录
            userlogin(request, response);

        }


    }
    /**
     * 用户登录
     1. 获取参数 （姓名、密码）
     2. 调用service层的方法，返回resultinfo对象
     3. 判断是否登录成功
     如果失败
        将resultinfo对象设置到request作用域中
        请求转发跳转到登录页面
     如果成功
        将用户信息设置到session作用域中
           判断用户是否选择记住密码（rem的值是1）
              如果是，将用户姓名与密码存到cookie中，设置失效时间，并响应给客户端
              如果否，清空原有的cookie对象
     重定向跳转到index页面
     * @param request
     * @param response
     */

    private void userlogin(httpservletrequest request, httpservletresponse response) {
        // 1. 获取参数 （姓名、密码）
        string username = request.getparameter("username");
        string userpwd = request.getparameter("userpwd");

        // 2. 调用service层的方法，返回resultinfo对象
        resultinfo<user> resultinfo = userservice.userlogin(username, userpwd);

        // 3. 判断是否登录成功
        if (resultinfo.getcode() == 1) { // 如果成功
            //  将用户信息设置到session作用域中
            request.getsession().setattribute("user", resultinfo.getresult());
            //  判断用户是否选择记住密码（rem的值是1）
            string rem = request.getparameter("rem");
            // 如果是，将用户姓名与密码存到cookie中，设置失效时间，并响应给客户端
            if ("1".equals(rem)) {
                // 得到cookie对象
                cookie cookie = new cookie("user",username +"-"+userpwd);
                // 设置失效时间
                cookie.setmaxage(3*24*60*60);
                // 响应给客户端
                response.addcookie(cookie);
            } else {
                // 如果否，清空原有的cookie对象
                cookie cookie = new cookie("user", null);
                // 删除cookie，设置maxage为0
                cookie.setmaxage(0);
                // 响应给客户端
                response.addcookie(cookie);
            }
            // 重定向跳转到index页面
            try {
                response.sendredirect("index.html");
            } catch (ioexception e) {
                e.printstacktrace();
            }

        } else { // 失败
            // 将resultinfo对象设置到request作用域中
            request.setattribute("resultinfo", resultinfo);
            // 请求转发跳转到登录页面
            try {
                request.getrequestdispatcher("login.jsp").forward(request, response);
            } catch (servletexception e) {
                e.printstacktrace();
            } catch (ioexception e) {
                e.printstacktrace();
            }
        }

    }


}

附件：util层的dbutil

package com.ftzlover.demo.util;

import java.io.inputstream;
import java.sql.*;
import java.util.properties;


public class dbutil {

    // 得到配置文件对象
    private static properties properties = new properties();

    static {
        try {
            // 加载配置文件（输入流）
            inputstream in = dbutil.class.getclassloader().getresourceasstream("db.properties");
            system.out.println("是否获取到流对象：" + in);
            system.out.println("流对象：" + properties);
            // 通过load()方法将输入流的内容加载到配置文件对象中
            properties.load(in);
            // 通过配置文件对象的getproperty()方法获取驱动名，并加载驱动
            class.forname(properties.getproperty("jdbcname"));
        } catch (exception e) {
            e.printstacktrace();
        }
    }


    public static connection getconnetion() {
        connection connection = null;
        try {
            // 得到数据库连接的相关信息
            string dburl = properties.getproperty("dburl");
            system.out.println(dburl);
            string dbname = properties.getproperty("dbname");
            system.out.println(dbname);
            string dbpwd = properties.getproperty("dbpwd");
            system.out.println(dbname);
            // 得到数据库连接
            connection = drivermanager.getconnection(dburl, dbname, dbpwd);
            system.out.println(connection);
        } catch (sqlexception throwables) {
            throwables.printstacktrace();
        }

        return connection;
    }


    public static void close(resultset resultset,
                             preparedstatement preparedstatement,
                             connection connection) {

        try {
            // 判断资源对象如果不为空，则关闭
            if (resultset != null) {
                resultset.close();
            }
            if (preparedstatement != null) {
                preparedstatement.close();
            }
            if (connection != null) {
                connection.close();
            }
        } catch (exception e) {
            e.printstacktrace();
        }

    }

}

8、示例

十分炫酷的登陆界面加完善的后台登陆界面截图：

数据库代码：新建数据库名叫my 建表名叫tb_user

create table `tb_user` (
  `userid` int(11) not null auto_increment comment '主键，自动增长',
  `uname` varchar(50) not null comment '用户名',
  `upwd` varchar(50) default null comment '密码',
  `nick` varchar(50) default null comment '昵称',
  `head` varchar(100) default null comment '头像',
  `mood` varchar(500) default null comment '心情',
  primary key (`userid`)
) engine=innodb auto_increment=5 default charset=utf8;

到此这篇关于关于jsp用户登录连接数据库详情的文章就介绍到这了,更多相关jsp用户登录连接数据库内容请搜索代码网以前的文章或继续浏览下面的相关文章希望大家以后多多支持代码网！

关于JSP用户登录连接数据库详情

2024年05月15日 • Java •我要评论