[Java知识库]2021-12-23 SevletDay5-用户登录与注册

一、JavaEE三层架构&环境搭建

包结构（先建包）：
web层
com.atguigu.web/servlet/controller

service层
com.atguigu.service service接口包
com.atguigu.service.impl service接口实现类

dao持久层
com.atguigu.dao Dao接口包
com.atguigu.dao.impl Dao接口实现类

实体bean对象
com.atguigu.pojp/entity/domain/bean JavaBean类

测试包
com.atguigu.test/junit

工具类
com.atguigu.utils

二、流程

1. 先创建书城需要的数据库和表（注册功能）

用户名称、密码、邮箱

drop database if exists book;

create DATABASE book;

use book;
create TABLE t_user(

`id` int primary key auto_increment,
`username` varchar(20) not null unique,
`password` varchar(32) not null,
`email` varchar(200)
);

insert into t_user(`username`,`password`,`email`) values('admin','admin','admin@126.com');

select * from t_user;

2. 编写数据库表对应的JavaBean对象

pojo包下建一个User类，自动生成一些code…（ORM思想）

3. 编写工具类Utils

package com.atguigu.utils;

import com.alibaba.druid.pool.DruidDataSource;
import com.alibaba.druid.pool.DruidDataSourceFactory;

import java.io.InputStream;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.Properties;

/**
 * @program: JavaWeb
 * @description:
 * @author: zjx
 * @create: 2021-12-22 21:49
 **/
public class JdbcUtils {
    private static DruidDataSource dataSource;

    static {

        try
        {
            Properties properties=new Properties();
            //读取jdbc.properties属性配置文件
            InputStream is=JdbcUtils.class.getClassLoader().getResourceAsStream("jdbc.properties");
            //从流中加载数据
            properties.load(is);
            //创建数据库连接池
            dataSource= (DruidDataSource) DruidDataSourceFactory.createDataSource(properties);
        }catch (Exception e)
        {
            e.printStackTrace();
        }




    }
    /**
    * @Description: 获取数据库连接池中的连接
    * @Param: []
    * @return: 如果返回null，说明获取连接失败
    * @Author: zjx
    * @Date: 2021/12/23
    */

    public static Connection getConnection()
    {
        Connection conn= null;
        try {
            conn = dataSource.getConnection();
        } catch (SQLException e) {
            e.printStackTrace();
        }

        return conn;
    }

    //关闭连接，放回数据库连接池

    public static void close(Connection conn)
    {
        if(conn!=null)
        {
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

    }



}

编写测试

public class JdbcUtilsTest {

    @Test
    public void testJdbcUtils()
    {
        System.out.println(JdbcUtils.getConnection());
    }
}

4. 编写baseDAO

package com.atguigu.dao.impl;

import com.atguigu.utils.JdbcUtils;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;
import org.apache.commons.dbutils.handlers.ScalarHandler;

import java.sql.Connection;
import java.sql.SQLException;
import java.util.List;

/**
 * @program: JavaWeb
 * @description: 抽象类，代码复用
 * @author: zjx
 * @create: 2021-12-23 14:15
 **/
public abstract class BaseDao {
    //使用DBUtils操作数据库
    private QueryRunner queryRunner=new QueryRunner();
    
/**
* @Description: update()方法执行 insert、update、delete语句
* @Param: [sql, args]
* @return: 如果返回-1，说明执行失败<br/> 执行成功则返回影响的行数
* @Author: zjx
* @Date: 2021/12/23
*/
    public int update(String sql,Object... args)
    {
        Connection conn= JdbcUtils.getConnection();
        try {
            return queryRunner.update(conn,sql,args);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return -1;
    }

    //查询
    /**
    * @Description: 查询返回一个javaBean的sql语句
    * @Param: [type 返回对象类型, sql, args]
    * @return: T
    * @Author: zjx
    * @Date: 2021/12/23
    */
    public <T> T queryForOne(Class<T> type, String sql,Object... args)
    {
        Connection conn=JdbcUtils.getConnection();
        try {
            return queryRunner.query(conn,sql,new BeanHandler<T>(type),args);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return null;

    }

    public <T> List<T> queryForList(Class<T> type,String sql,Object... args)
    {
        Connection conn=JdbcUtils.getConnection();

        try {
            List<T> result=queryRunner.query(conn,sql,new BeanListHandler<T>(type),args);
            return result;
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return null;

    }
    /**
    * @Description: 执行返回一行一列的sql语句
    * @Param: [sql, args]
    * @return: java.lang.Object
    * @Author: zjx
    * @Date: 2021/12/23
    */

    public Object queryForSingleValue(String sql,Object... args)
    {
        Connection conn=JdbcUtils.getConnection();
        try {
            return queryRunner.query(conn,sql,new ScalarHandler(),args);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return null;
    }

}

5. 编写UserDao和测试

测试：ctrl+shift+T 在UserDao中。用的是JUnit4，勾上要测试的方法

package com.atguigu.dao.impl;

//思考对于注册会做哪些数据库操作

import com.atguigu.pojo.User;

public interface UserDao {
    

    //注册

    //查找这个用户是否已经存在
    /**
    * @Description: 根据用户名查询用户信息
    * @Param: [Username]
    * @return: 如果返回null，说明没有这个用户
    * @Author: zjx
    * @Date: 2021/12/23
    */
    public User queryUserByUsername(String Username);

    //添加用户 注册
    public int saveUser(User user);


    //登录
    //根据用户名和密码查询
    /**
    * @Description: 根据用户名和密码查询
    * @Param: [Username, password]
    * @return: com.atguigu.pojo.User如果查不到，说明没有这个用户
    * @Author: zjx
    * @Date: 2021/12/23
    */
    public User queryUserByUsernameAndPassword(String Username,String password);

}

package com.atguigu.dao.impl;

import com.atguigu.pojo.User;

/**
 * @program: JavaWeb
 * @description:
 * @author: zjx
 * @create: 2021-12-23 19:39
 **/
public class UserDaoImpl extends BaseDao implements UserDao{

    @Override
    public User queryUserByUsername(String username) {
        String sql="select `id`,`username`,`password`,`email` from t_user where username=?";
        User user = queryForOne(User.class, sql, username);
        return user;
    }

    @Override
    public int saveUser(User user) {
        String sql="insert into t_user(`username`,`password`,`email`) values(?,?,?)";

        return update(sql,user.getUsername(),user.getPassword(),user.getEmail());
    }

    @Override
    public User queryUserByUsernameAndPassword(String username, String password) {
        String sql="select `id`,`username`,`password`,`email` from t_user where username=? and password=?";
        User user = queryForOne(User.class, sql, username,password);
        return user;
    }
}

测试：

package com.atguigu.test;

import com.atguigu.dao.impl.UserDao;
import com.atguigu.dao.impl.UserDaoImpl;
import com.atguigu.pojo.User;
import org.junit.Test;

import static org.junit.Assert.*;

public class UserDaoTest {
    UserDao userDao=new UserDaoImpl();
    @Test
    public void queryUserByUsername() {

        if(userDao.queryUserByUsername("admin")==null)
        {
            System.out.println("用户名可用");
        }
        else System.out.println("用户名已存在！");
    }

    @Test
    public void saveUser() {

       User newUser=new User(null,"zjx1","123","zjx@163.com");
        System.out.println(userDao.saveUser(newUser));

    }

    @Test
    public void queryUserByUsernameAndPassword() {
        if(userDao.queryUserByUsernameAndPassword("admin","admin")==null)
            System.out.println("用户名或密码错误，登录失败");
        else System.out.println("查询成功");

    }
}

6. 编写UserService和测试

package com.atguigu.service;

import com.atguigu.pojo.User;

/**
 * @program: JavaWeb
 * @description:业务，一个业务对应一个方法： 登录、注册
 * @author: zjx
 * @create: 2021-12-23 20:12
 **/
public interface UserService {

    /**
    * @Description: 注册用户
    * @Param: [user]
    * @return:
    * @Author: zjx
    * @Date: 2021/12/23
    */
    public void registerUser(User user);

    /**
    * @Description: 登录
    * @Param: [user]
    * @return: com.atguigu.pojo.User
    * @Author: zjx
    * @Date: 2021/12/23
    */
    public User login(User user);

    /**
    * @Description: 检查用户名是否可用
    * @Param: [username]
    * @return: 返回true表示用户名存在，false表示用户名可用
    * @Author: zjx
    * @Date: 2021/12/23
    */
    public boolean existsUsername(String username);





}

package com.atguigu.test;

import com.atguigu.pojo.User;
import com.atguigu.service.UserService;
import com.atguigu.service.impl.UserServiceImpl;
import org.junit.Test;

import static org.junit.Assert.*;

public class UserServiceTest {
    UserService userService=new UserServiceImpl();


    @Test
    public void registerUser() {
        userService.registerUser(new User(null,"1","1","1"));
    }

    @Test
    public void login() {
        System.out.println(userService.login(new User(null,"1","1","1")));
    }

    @Test
    public void existsUsername() {
        System.out.println(userService.existsUsername("1"));
        if(userService.existsUsername("1")) System.out.println("用户名已经存在");
        else System.out.println("用户名不存在");
    }
}

7. 注册功能业务逻辑

package com.atguigu.web;

import com.atguigu.pojo.User;
import com.atguigu.service.UserService;
import com.atguigu.service.impl.UserServiceImpl;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

/**
 * @program: JavaWeb
 * @description: 注册功能
 * @author: zjx
 * @create: 2021-12-23 20:44
 **/
public class RegisterServlet extends HttpServlet {
    //web层只能调用service，不能dao
    private UserService userService=new UserServiceImpl();


    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //1.获取请求的参数
        String username = req.getParameter("username");
        String password = req.getParameter("password");
       // String repwd = req.getParameter("repwd");
        String email = req.getParameter("email");
        String code = req.getParameter("code");

        //2.检查验证码是否正确（先写死
        if("abcde".equalsIgnoreCase(code))
        {
            //3. 用户名是否可用
            if(userService.existsUsername(username)==false)
            {
                //4. 可用，保存到数据库
                userService.registerUser(new User(null,username,password,email));
                req.getRequestDispatcher("pages/user/regist_success.html").forward(req,resp);
            }
            else
            {
                System.out.println("用户名"+username+"已存在");
                req.getRequestDispatcher("pages/user/regist.html").forward(req,resp);
            }

        }else //跳回注册页面
        {
            System.out.println("验证码错误");
            req.getRequestDispatcher("pages/user/regist.html").forward(req,resp);//斜杠大头，web目录
        }

    }
}