day07 书城项目第二阶段
第一章 不带数据库的注册登录
1. 实现步骤
-
创建动态Web工程
-
将第一版书城的静态资源拷贝到web文件夹中
-
统一页面的基础访问路径
-
使用静态数据进行登录校验
-
使用完成注册时校验用户名是否存在
2. 内容讲解
2.1 创建动态Web工程
2.2 拷贝静态资源
2.3 在HTML中使用base标签统一页面基础访问路径
2.3.1 为什么要使用base标签统一页面基础访问路径
因为在页面中有很多的a标签、表单以及Ajax请求(以后会学)都需要写访问路径，而在访问路径中项目路径是一样的，所以如果不统一编写项目路径的话，就会发生当项目路径发生改变的时候该页面所有用到项目路径的地方都需要更改的情况
2.3.2 base标签的语法规则
- base标签要写在head标签内
- base标签必须写在所有其他有路径的标签的前面
- base标签使用href属性设置路径的基准
- base标签生效的机制是：最终的访问地址=base标签href属性设置的基准+具体标签内的路径
- 如果某个路径想要基于base中的路径进行路径编写，那么它不能以
/开头
2.3.3 base标签使用举例
<head>
<meta charset="UTF-8"/>
<meta name="viewport" content="width=device-width, initial-scale=1.0"/>
<title>书城首页</title>
<base href="/bookstore/"/>
<link rel="stylesheet" href="static/css/minireset.css"/>
<link rel="stylesheet" href="static/css/common.css"/>
<link rel="stylesheet" href="static/css/iconfont.css"/>
<link rel="stylesheet" href="static/css/index.css"/>
<link rel="stylesheet" href="static/css/swiper.min.css"/>
</head>
2.3.4 基于base标签调整整个页面的路径
在需要进行基础路径统一的页面做如下修改
2.3.4.1 base标签的代码
<base href="/bookstore/"/>
2.3.4.2 对需要统一调整的路径执行替换
Ctrl+r调出替换操作窗口，并做如下替换
2.4 使用静态数据实现登录校验
2.4.1 假定静态数据
为了实现『不带数据库』的登录注册，我们需要假设：系统中目前已有用户：
| 用户名 | 密码 |
|---|---|
| tom | 123456 |
2.4.2 目标
在服务器端检查用户通过表单提交的用户名、密码是否正确。
- 成功：跳转到login_success.html页面
- 失败：返回错误消息
2.4.3 思路
- 客户端发送请求，携带用户名和密码
- LoginServlet在doPost()方法中接收处理请求，判断客户端传入的账号密码和系统中现存的账号密码是否一致
- 如果一致，则重定向跳转到login_success.html页面
- 如果不一致，则通过response响应错误提示信息
2.4.4 代码实现
2.4.4.1 创建LoginServlet
创建Packages时的规范：
公司或组织域名倒序.项目名.模块名.具体包名
或
公司或组织域名倒序.项目名.具体包名
下面是完整的Servlet配置信息：
<servlet>
<servlet-name>LoginServlet</servlet-name>
<servlet-class>com.atguigu.servlet.LoginServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>LoginServlet</servlet-name>
<url-pattern>/loginServlet</url-pattern>
</servlet-mapping>
2.4.4.2 重写doGet方法
package com.atguigu.bookstore.servlet;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
/**
*/
public class LoginServlet extends HttpServlet {
@Override
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
doGet(request, response);
}
@Override
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
//解决请求参数的中文乱码问题
request.setCharacterEncoding("UTF-8");
//解决响应字符串的中文乱码问题
response.setContentType("text/html;charset=UTF-8");
//1. 获取请求参数:username、password
String username = request.getParameter("username");
String password = request.getParameter("password");
//2. 和系统中已有的用户的username、password进行比对
if ("tom".equals(username) && "123456".equals(password)) {
//说明登录成功:跳转到login_success.html页面
response.sendRedirect(request.getContextPath()+"/pages/user/login_success.html");
}else {
//登录失败:响应"登陆失败"字符串给客户端
response.getWriter().write("登陆失败!!!");
//优化登录失败的处理: 跳转回到login.html页面
//response.sendRedirect(request.getContextPath()+"/pages/user/login.html");
//优化登录失败的处理: 显示登录页面，并且在登录页面中要显示"登陆失败的提示信息"
//直接使用字符输出流向客户端输出整个login.html页面，并且在这个页面中设置错误信息
//response.getWriter().write("");
}
}
}
2.4.4.3 HTML页面设置表单提交地址
<form action="loginServlet">
<label>用户名称：</label>
<input
class="itxt"
type="text"
placeholder="请输入用户名"
autocomplete="off"
tabindex="1"
name="username"
id="username"
v-model.trim="username"
/>
<br />
<br />
<label>用户密码：</label>
<input
class="itxt"
type="password"
placeholder="请输入密码"
autocomplete="off"
tabindex="1"
name="password"
id="password"
v-model.trim="password"
/>
<br />
<br />
<input type="submit" value="登录" id="sub_btn" @click="login()"/>
</form>
2.4.4.4 提示消息改进探索(仅供参考，实际开发不会这样做)
// 5.登录失败
// 返回提示消息方案一：过于简陋
// response.setContentType("text/html;charset=UTF-8");
// response.getWriter().write("抱歉！用户名或密码不正确，请重新输入！");
// 返回提示消息方案二：没有提示消息，让用户非常困惑
// request.getRequestDispatcher("/pages/user/login.html").forward(request, response);
// 返回提示消息方案三：确实能在登录页面显示提示消息，但是实现的方式让我想骂人
response.setContentType("text/html;charset=UTF-8");
PrintWriter writer = response.getWriter();
writer.write("<!DOCTYPE html>");
writer.write("<html>");
writer.write(" <head>");
writer.write(" <base href='/bookstore/' />");
2.5 使用静态数据校验注册时候的用户名
2.5.1 目标
用户提交注册表单后，检查用户名是否被占用
- 没有被占用：注册成功
- 已经被占用：注册失败
2.5.2 思路
2.5.3 代码实现
2.5.3.1 创建RegisterServlet
完整配置信息：
<servlet>
<servlet-name>RegisterServlet</servlet-name>
<servlet-class>com.atguigu.servlet.RegisterServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>RegisterServlet</servlet-name>
<url-pattern>/registerServlet</url-pattern>
</servlet-mapping>
2.5.3.2 重写doPost()方法
package com.atguigu.bookstore.servlet;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.Map;
/**
*/
public class RegisterServlet extends HttpServlet {
@Override
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
doGet(request, response);
}
@Override
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
request.setCharacterEncoding("UTF-8");
response.setContentType("text/html;charset=UTF-8");
//1. 获取所有的请求参数
Map<String, String[]> parameterMap = request.getParameterMap();
//2. 从所有请求参数中拿到用户名
String username = parameterMap.get("username")[0];
//3. 将客户端传入的用户名和当前系统中已有的用户名做比对
if ("tom".equals(username)) {
//用户名已被占用，注册失败
response.getWriter().write("注册失败，用户名已被占用");
}else {
//用户名没有被占用，注册成功: 重定向跳转到regist_success.html
response.sendRedirect(request.getContextPath()+"/pages/user/regist_success.html");
}
}
}
2.5.3.3 HTML页面调整表单中的设置
<div class="register_form">
<h1>注册尚硅谷会员</h1>
<form action="registerServlet">
<div class="form-item">
<div>
<label>用户名称:</label>
<input type="text" name="username" placeholder="请输入用户名" v-model.trim="username" @blur="checkUserName()"/>
</div>
<span class="errMess" :style="usernameCss">{{usernameErrMsg}}</span>
</div>
<div class="form-item">
<div>
<label>用户密码:</label>
<input type="password" name="password" placeholder="请输入密码" v-model.trim="password" @blur="checkPassWord()" />
</div>
<span class="errMess" :style="passwordCss">{{passwordErrMsg}}</span>
</div>
<div class="form-item">
<div>
<label>确认密码:</label>
<input type="password" name="dbpassword" placeholder="请输入确认密码" v-model.trim="dbpassword" @blur="checkDbPassWord()"/>
</div>
<span class="errMess" :style="dbpasswordCss">{{dbpasswordErrMsg}}</span>
</div>
<div class="form-item">
<div>
<label>用户邮箱:</label>
<input type="text" name="email" placeholder="请输入邮箱" v-model.trim="email" @blur="checkEmail()"/>
</div>
<span class="errMess" :style="emailCss">{{emailErrMsg}}</span>
</div>
<div class="form-item">
<div>
<label>验证码:</label>
<div class="verify">
<input type="text" placeholder="" />
<img src="static/img/code.bmp" alt="" height="50px"/>
</div>
</div>
<span class="errMess">请输入正确的验证码</span>
</div>
<button class="btn" @click="register">注册</button>
</form>
</div>
第二章 完成带数据库的注册登录
1. 学习目标
- 了解三层架构
- 了解MD5加密
- 完成带数据库的登录校验
- 完成带数据库的注册功能
2. 内容讲解
2.1 三层架构
2.1.1 为什么要使用三层架构
如果不做三层架构形式的拆分：
所有和当前业务功能需求相关的代码全部耦合在一起，如果其中有任何一个部分出现了问题，牵一发而动全身，导致其他无关代码也要进行相应的修改。这样的话代码会非常难以维护。
所以为了提高开发效率，需要对代码进行模块化的拆分。整个项目模块化、组件化程度越高，越容易管理和维护，出现问题更容易排查。
2.1.2 三层架构的划分
- 表述层：又可以称之为控制层，负责处理浏览器请求、返回响应、页面调度(跳转)
- 业务逻辑层：负责处理业务逻辑，根据业务逻辑把持久化层从数据库查询出来的数据进行运算、组装，封装好后返回给表述层，也可以根据业务功能的需要调用持久化层把数据保存到数据库、修改数据库中的数据、删除数据库中的数据
- 持久化层：根据上一层的调用对数据库中的数据执行增删改查的操作
2.1.3 三层架构和数据模型的关系
模型对整个项目中三层架构的每一层都提供支持，具体体现是使用模型对象封装业务功能数据
其实数据模型就是我们之前学习的JavaBean，也是Java实体类，当然他还有很多其他的名称:
- POJO：Plain old Java Object，传统的普通的Java对象
- entity：实体类
- bean或Java bean
- domain：领域模型
2.2 持久层
2.2.1 数据建模
2.2.1.1 创建数据库和表
在sqlYog中执行资料中的数据库脚本bookstore.sql
2.2.1.2 创建JavaBean
package com.atguigu.pojo;
public class User {
private Integer userid;
private String username;
private String password;
private String email;
public User() {
}
public User(String username, String password) {
this.username = username;
this.password = password;
}
public User(Integer userid, String username, String password, String email) {
this.userid = userid;
this.username = username;
this.password = password;
this.email = email;
}
public Integer getUserid() {
return userid;
}
public void setUserid(Integer userid) {
this.userid = userid;
}
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;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
@Override
public String toString() {
return "Users{" +
"userid=" + userid +
", username='" + username + '\'' +
", password='" + password + '\'' +
", email='" + email + '\'' +
'}';
}
}
2.2.2 加入所需jar包
2.2.3 创建外部属性文件
在idea的工程结构中，我们通常将配置文件放在resources目录下
2.2.3.1 创建资源目录
- 在当前module中创建一个directory，并且命名为resources
- 然后将这个目录标记为Resources Root
- 编写jdbc.properties文件
driverClassName=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://localhost:3306/bookstore?rewriteBatchedStatements=true
username=root
password=123456
initialSize=5
maxActive=100
maxWait=5000
2.2.4 创建连接数据库的工具类
package com.atguigu.utils;
import com.alibaba.druid.pool.DruidDataSourceFactory;
import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.Properties;
public class JDBCutils {
public static void main(String[] args) throws SQLException {
for (int i = 0;i < 10;i++){
Connection connection = getConnection();
System.out.println(i + 1 + "===>" + connection);
// connection.close();
}
}
static DataSource dataSource;
static{
try {
Properties pro = new Properties();
// 将src下文件转为字节流
pro.load(JDBCutils.class.getClassLoader().getResourceAsStream("druid.properties"));
// 创建连接池对象 应用配置信息
dataSource = DruidDataSourceFactory.createDataSource(pro);
// 输出读取到的信息
pro.list(System.out);
} catch (Exception e) {
e.printStackTrace();
}
}
static ThreadLocal<Connection> local = new ThreadLocal<>();
/**
* 获取连接
* @return 返回连接
* @throws SQLException
*/
public static Connection getConnection() throws SQLException {
// main map ----> key:local value:conn
// 1.先从线程内的map中获取连接
Connection connection = local.get();
if (connection == null){
// 2.如果线程内的map没有连接 在去连接池中获取
connection = dataSource.getConnection();
// 3.再将连接池的连接放进map
local.set(connection);
}
return connection;
}
public static void closeConnection() throws Exception{
Connection connection = JDBCutils.getConnection();
if (connection != null){
// 将线程内的连接去掉
local.remove();
// 关闭事务
connection.setAutoCommit(true);
// 关闭连接
connection.close();
}
}
}
2.2.5 Dao的概念
Dao是data access Object的缩写，中文翻译为数据访问对象，我们会将操作持久层的代码编写到对应的Dao类中
2.2.6 编写BaseDao类作为所有Dao类的基类(父类)
package com.atguigu.dao;
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 java.sql.Connection;
import java.util.List;
/**
* 对重复的操作进行抽取
* */
public class BaseDao {
/**
* 通用的增删改方法
* @param sql
* @param params
*/
public void update(String sql, Object... params){
try {
// 1.创建操作对象
QueryRunner runner = new QueryRunner();
// 2.获取连接
Connection connection = JDBCutils.getConnection();
// System.out.println("test02: " + Thread.currentThread().getName() + "===>" + connection);
runner.update(connection, sql, params);
} catch (Exception e) {
e.printStackTrace();
throw new RuntimeException(e.getMessage());
}
}
/**
* 通用的查询数据返回集合的方法
* @param sql
* @param clazz
* @param <T>
* @return
*/
public <T>List<T> findAllBean(String sql, Class<T> clazz){
try {
// 1.创建操作对象
QueryRunner runner = new QueryRunner();
// 2.获取连接
Connection connection = JDBCutils.getConnection();
List<T> list = runner.query(connection, sql, new BeanListHandler<>(clazz));
return list;
} catch (Exception e) {
e.printStackTrace();
throw new RuntimeException(e.getMessage());
}
}
/**
* 通用的获取单个对象的方法
* @param sql
* @param tClass
* @param params
* @param <T>
* @return
*/
public <T> T findOneBean(String sql, Class<T> tClass, Object... params){
try {
// 1.创建操作对象
QueryRunner runner = new QueryRunner();
// 2.获取连接
Connection connection = JDBCutils.getConnection();
// System.out.println("test02: " + Thread.currentThread().getName() + "===>" + connection);
T t = runner.query(connection, sql, new BeanHandler<>(tClass), params);
return t;
} catch (Exception e) {
e.printStackTrace();
throw new RuntimeException(e.getMessage());
}
}
}
2.2.7 创建UserDao
2.2.7.1 用户登录注册功能中的组件关系图
2.2.7.2 创建UserDao接口
package com.atguigu.dao;
import com.atguigu.pojo.User;
public interface UserDao {
/**
* 根据用户名查找用户
* @param user
*/
void insertUser(User user);
/**
* 保存用户信息到数据库
* @param name
* @return
*/
User findUserByName(String name);
}
2.2.7.3 创建UserDaoImpl实现类
package com.atguigu.dao.impl;
import com.atguigu.dao.BaseDao;
import com.atguigu.dao.UserDao;
import com.atguigu.pojo.User;
public class UserDaoImpl extends BaseDao implements UserDao {
@Override
public void insertUser(User user) {
String sql = "insert into users values(null,?,?,?)";
update(sql, user.getUsername(), user.getPassword(), user.getEmail());
}
@Override
public User findUserByName(String name) {
String sql = "select * from users where username = ?";
User user = findOneBean(sql, User.class, name);
return user;
}
}
2.3 加密方式介绍
2.3.1 加密方式介绍
-
对称加密：加密和解密使用的相同的密钥，常见的对称加密算法有:DES、3DES
对称加密采用了对称密码编码技术，它的特点是文件加密和解密使用相同的密钥加密 也就是密钥也可以用作解密密钥，这种方法在密码学中叫做对称加密算法 -
非对称加密：加密和解密使用的密钥不同，常见的非对称加密算法有:RSA
-
加密：使用公钥加密
-
解密：使用私钥解密
与对称加密算法不同，非对称加密算法需要两个密钥：公开密钥（publickey）和私有密钥（privatekey）。 公开密钥与私有密钥是一对，如果用公开密钥对数据进行加密，只有用对应的私有密钥才能解密；如果用私有密钥对数据进行加密，那么只有用对应的公开密钥才能解密。因为加密和解密使用的是两个不同的密钥，所以这种算法叫作非对称加密算法。 非对称加密算法实现机密信息交换的基本过程是：甲方生成一对密钥并将其中的一把作为公用密钥向其它方公开；得到该公用密钥的乙方使用该密钥对机密信息进行加密后再发送给甲方；甲方再用自己保存的另一把专用密钥对加密后的信息进行解密。甲方只能用其专用密钥解密由其公用密钥加密后的任何信息。
-
-
消息摘要: 消息摘要算法的主要特征是加密过程不需要密钥，并且经过加密的数据无法被解密，只有相同的原文经过消息摘要算法之后，才能得到相同的密文，所以消息摘要通常用来校验原文的真伪。常用的消息摘要算法有:MD5、SHA、MAC
消息摘要是把任意长度的输入揉和而产生长度固定的伪随机输出的算法.
我们在书城项目中采用MD5算法对密码进行加密
2.3.2 封装执行加密的工具类
public class MD5Util {
/**
* 针对明文字符串执行MD5加密
* @param source
* @return
*/
public static String encode(String source) {
// 1.判断明文字符串是否有效
if (source == null || "".equals(source)) {
throw new RuntimeException("用于加密的明文不可为空");
}
// 2.声明算法名称
String algorithm = "md5";
// 3.获取MessageDigest对象
MessageDigest messageDigest = null;
try {
messageDigest = MessageDigest.getInstance(algorithm);
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
// 4.获取明文字符串对应的字节数组
byte[] input = source.getBytes();
// 5.执行加密
byte[] output = messageDigest.digest(input);
// 6.创建BigInteger对象
int signum = 1;
BigInteger bigInteger = new BigInteger(signum, output);
// 7.按照16进制将bigInteger的值转换为字符串
int radix = 16;
String encoded = bigInteger.toString(radix).toUpperCase();
return encoded;
}
}
2.4 注册功能
2.4.1 目标
检查用户名是否可用，如果用户名可用则保存User对象
2.4.2 思路
2.4.3 代码
2.4.3.1 创建UserService接口
package com.atguigu.service;
import com.atguigu.pojo.User;
public interface UserService {
/**
* 处理注册的业务
* @param user
*/
void doRegister(User user);
开发中，接口设计和接口中方式定义的理念：
- 方法的返回值应该对应这个方法本身的业务功能
- 写操作：没有返回值
- 读操作：有返回值，返回值就是查询的结果
- 方法执行是否成功
- 成功：不抛异常
- 失败：抛异常
2.4.3.2 创建UserServiceImpl实现类
package com.atguigu.service.impl;
import com.atguigu.dao.UserDao;
import com.atguigu.dao.impl.UserDaoImpl;
import com.atguigu.pojo.User;
import com.atguigu.service.UserService;
import com.atguigu.utils.MD5Util;
public class UserServiceImpl implements UserService {
@Override
public void doRegister(User user) {
// 1.创建持久层对象
UserDao userDao = new UserDaoImpl();
// 2.判断注册的用户名是否存在
User u = userDao.findUserByName(user.getUsername());
if (u != null){
// 不为空则用户名已存在 抛出异常
throw new RuntimeException("注册失败 用户名 【" + user.getUsername() + "】已存在");
}else{
// 为空则说明用户不存在 调用方法注册用户
// 对密码进行加密
String encode = MD5Util.encode(user.getPassword());
// 把加密后的密码覆盖原密码
user.setPassword(encode);
// 调用持久层的insertUser()方法 将用户信息存储到数据库中
userDao.insertUser(user);
}
}
}
2.4.3.3 修改RegisterServlet的代码
package com.atguigu.servlet;
import com.atguigu.pojo.User;
import com.atguigu.service.UserService;
import com.atguigu.service.impl.UserServiceImpl;
import org.apache.commons.beanutils.BeanUtils;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.util.Map;
public class RegisterServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doPost(req, resp);
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 解决请求的中文编码格式
req.setCharacterEncoding("utf-8");
// 解决响应的中文编码格式
resp.setContentType("text/html;charset=utf-8");
// 获取所有的请求参数
Map<String, String[]> parameterMap = req.getParameterMap();
// 将parameterMap中的数据封装到User对象中
User user = new User();
try {
BeanUtils.populate(user, parameterMap);
// 创建业务层的对象
UserService userService = new UserServiceImpl();
// 调用业务层的方法 如果注册失败了 业务层会抛出异常
userService.doRegister(user);
// 没有异常则 重定向跳转到注册成功页面
resp.sendRedirect(req.getContextPath() + "/pages/user/regist_success.html");
} catch (Exception e) {
e.printStackTrace();
// 如果出现异常 那就是注册失败
resp.getWriter().println(e.getMessage());
}
}
}
2.5 登录功能
2.5.1 目标
- 校验用户名是否正确
- 校验密码是否正确
2.5.2 思路
2.5.3 代码实现
2.5.3.1 UserService接口添加doLogin()方法
package com.atguigu.service;
import com.atguigu.pojo.User;
public interface UserService {
/**
* 处理注册的业务
* @param user
*/
void doRegister(User user);
/**
* 处理登录的业务
* @param user
* @return
*/
User doLogin(User user);
}
2.5.3.2 UserServiceImpl类的doLogin()
@Override
public User doLogin(User user) {
UserDao userDao = new UserDaoImpl();
// 调用dao层的方法根据用户名查询用户信息
User u = userDao.findUserByName(user.getUsername());
// 判断返回是否为空
if (u != null){
// 不为空则对传入的用户密码进行加密
String encode = MD5Util.encode(user.getPassword());
System.out.println(u.getPassword());
System.out.println(encode);
// 传入的用户密码和数据库中查询的密码进行比对
if (encode.equals(u.getPassword())){
// 比对成功 返回u对象
return u;
}else{
// 密码错误 抛出异常
throw new RuntimeException("登录失败 密码错误");
}
}else{
// 用户名错误 抛出异常
throw new RuntimeException("登录失败 用户名 【" + user.getUsername() + "】不存在");
}
}
2.5.3.2 修改LoginServlet
package com.atguigu.servlet;
import com.atguigu.pojo.User;
import com.atguigu.service.UserService;
import com.atguigu.service.impl.UserServiceImpl;
import org.apache.commons.beanutils.BeanUtils;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.util.Map;
public class LoginServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doPost(req, resp);
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 解决请求参数的中文乱码问题
req.setCharacterEncoding("utf-8");
// 解决响应字符串的中文乱码问题
resp.setContentType("text/html;charset=utf-8");
// 获取请求参数
Map<String, String[]> map = req.getParameterMap();
// 将请求参数封装到User对象中
User user = new User();
try {
BeanUtils.populate(user, map);
UserService userService = new UserServiceImpl();
// 调用业务层的方法处理登录
userService.doLogin(user);
// 没有出现异常 则表示登录成功 重定向跳转到登录成功页面
resp.sendRedirect(req.getContextPath() + "/pages/user/login_success.html");
} catch (Exception e) {
e.printStackTrace();
// 出现异常 返回异常信息
resp.getWriter().println(e.getMessage());
}
}
}
319
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
