AJAX+JAVA用户登陆注册验证的实现代码
发布于 2020-6-18|
复制链接
摘记: 需求
通过ajax异步刷新页面验证用户输入的账号密码是否在数据库中存在。技术栈
JS ..
需求通过ajax异步刷新页面验证用户输入的账号密码是否在数据库中存在。技术栈
JSP+Servlet+Oracle具体代码
JSP部分：
```java
Insert title here
function createXMLHttpRequest() {
try {
xmlHttp = new XMLHttpRequest();//除了ie之外的其他浏览器使用ajax
} catch (tryMS) {
try {
xmlHttp = new ActiveXObject("Msxml2.XMLHTTP");//ie浏览器适配
} catch (otherMS) {
try {
xmlHttp = new ActiveXObject("Microsoft.XMLHTTP");//ie浏览器适配
} catch (failed) {
xmlHttp = null;
}
}
}
return xmlHttp;
}
//提交请求
var xmlHttp;
function checkUserExists() {
var u = document.getElementById("uname");
var username = u.value;
if (username == "") {
alert("请输入用户名");
u.focus();
return false;
}
//访问字符串
var url = "loginServlet";
//创建核心xmlhttprequest组件
xmlHttp = createXMLHttpRequest();
//设置回调函数
xmlHttp.onreadystatechange = proessRequest;
//初始化核心组件
xmlHttp.open("post", url, true);
//设置请求头
xmlHttp.setRequestHeader("Content-Type","application/x-www-form-urlencoded;");
//发送请求
xmlHttp.send("uname="+username);
}
//回调函数
function proessRequest() {
if (xmlHttp.status==200 && xmlHttp.readyState == 4) {
var b = xmlHttp.responseText;//得到服务端的输出结果
if (b=="true") {
document.getElementById("alert").innerHTML = "用户名已经存在！";
}else {
document.getElementById("alert").innerHTML = "用户名可以使用！";
}
}
}
请输入用户名：
```
这里没有用Dao层，直接用servlet和service层进行验证。
下面是service下JDBC查询的代码：
```java
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import com.stx.service.User;
import com.stx.service.ConnectionManager;
public class ajaxService {
public boolean searchUser (String uname) {
//jdbc查询用户名是否存在
boolean isFalse = false;
Connection connection = null;
Statement stmt = null;
ResultSet rs = null;
connection = ConnectionManager.getConnection();
try {
stmt = connection.createStatement();
String sql = "select * from user_b where uname='"+uname+"'";//sql语句
rs = stmt.executeQuery(sql);
isFalse=rs.next();
} catch (SQLException e) {
e.printStackTrace();
} finally {
ConnectionManager.closeResultSet(rs);
ConnectionManager.closeStatement(stmt);
ConnectionManager.closeConnection(connection);
}
return isFalse;
}
}
```
JDBC连接代码：
```java
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class ConnectionManager {
private final static String DRIVER_CLASS = "oracle.jdbc.OracleDriver";
private final static String URL = "jdbc:oracle:thin:@localhost:1521:orcl";
private final static String DBNAME = "ibook";
private final static String PASSWORD = "qwer";
public static Connection getConnection() {
Connection connection = null;
try {
Class.forName(DRIVER_CLASS);
connection = DriverManager.getConnection(URL, DBNAME, PASSWORD);
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (SQLException e) {
e.printStackTrace();
}
return connection;
}
public static void closeResultSet(ResultSet rs) {
try {
if (rs != null)
rs.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
public static void closeConnection(Connection connection) {
try {
if (connection != null && !connection.isClosed())
connection.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
public static void closeStatement(Statement stmt) {
try {
if (stmt != null)
stmt.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
```
关于user类：
```java
public class User {
private String uname;
public User() {
super();
}
public User(String uname) {
super();
this.uname = uname;
}
public String getUname() {
return uname;
}
public void setUname(String uname) {
this.uname = uname;
}
```
关于控制层servlet：
```java
import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import com.stx.service.ajaxService;
/**
* Servlet implementation class loginServlet
*/
public class loginServlet extends HttpServlet {
private static final long serialVersionUID = 1L;
private ajaxService ajaxService = new ajaxService();
/**
* @see HttpServlet#HttpServlet()
*/
public loginServlet() {
super();
// TODO Auto-generated constructor stub
}
/**
* @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)
*/
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
request.setCharacterEncoding("UTF-8");
String uname = request.getParameter("uname");//获取到输入的用户名
boolean isUname = ajaxService.searchUser(uname);//调用service中的查询方法
response.setCharacterEncoding("UTF-8");//设置字符编码
PrintWriter out = response.getWriter();
out.print(isUname);
out.flush();
out.close();//关闭资源
}
/**
* @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)
*/
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
// TODO Auto-generated method stub
doGet(request, response);
}
}
```

利用 Spring IOC 技术实现用户登录的验证机制，对用户进行登录验证。
首先利用 Spring 的自动装配模式将 User 对象注入到控制器中，然后将用户输入的用户名和密码与系统中限定的合法用户的用户名和密码进行匹配。
当用户名与密码匹配成功时，跳转到登录成功页面；当用户名与密码不匹配时，跳转到登录失败的页面。
1.创建 User 对象，定义用户名和密码属性，代码如下：
package com.importnew;
public class User {
private String username;
private String password;
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;
}
}
2.创建控制器 TestUtil ，注入 User 对象并进行登录验证。代码如下：
package com.importnew;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.AbstractController;
public class TestUtil extends AbstractController{
private User user;
public User getUser() {
return user;
}
public void setUser(User user) {
this.user = user;
}
@Override
protected ModelAndView handleRequestInternal(HttpServletRequest arg0,
HttpServletResponse arg1) throws Exception {
String username = arg0.getParameter("username");
String password = arg0.getParameter("password");
if(username.equals(user.getUsername()) && password.equals(user.getPassword())){
return new ModelAndView("yes");
}else{
return new ModelAndView("Error");
}
}
}
3.在 Spring 的配置文件 applicationContext.xml 中为 User 对象的属性赋值，并使用自动装配的方式在控制器 TestUtil 中注入 User 对象。代码如下：
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd">
/
.jsp
admin
123
4.在 web.xml 文件中配置 applicationContext.xml 的自动加载，当项目启动后程序将自动加载配置文件中的信息。代码如下：
/p>
"-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"http://java.sun.com/dtd/web-app_2_3.dtd" >
Archetype Created Web Application
dispatcherServlet
org.springframework.web.servlet.DispatcherServlet
contextConfigLocation
/applicationContext.xml
1
dispatcherServlet
*.do
备注：
TestUtil 中继承的类 AbstractController 需要引关于 spring-web-mvc 的 JAR 包支持。
end

java相关：利用Spring IOC技术实现用户登录验证机制
发布于 2020-4-3|
复制链接
摘记: 利用 Spring IOC 技术实现用户登录的验证机制，对用户进行登录验证。首先利用 Spring 的自动装配模式将 User 对象注入到控制器中，然后将用户输入的用户名和密码与系统中限定的合法用户的用户名和密码进行匹配。当用户名与密码匹配成功时，跳转到登录成功页面；当用户名与密码不匹配时，跳转到登录失败的页面。 ..
利用 Spring IOC 技术实现用户登录的验证机制，对用户进行登录验证。首先利用 Spring 的自动装配模式将 User 对象注入到控制器中，然后将用户输入的用户名和密码与系统中限定的合法用户的用户名和密码进行匹配。当用户名与密码匹配成功时，跳转到登录成功页面；当用户名与密码不匹配时，跳转到登录失败的页面。1.创建 User 对象，定义用户名和密码属性，代码如下：
```java
package com.importnew;
public class User {
private String username;
private String password;
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;
}
}
```
2.创建控制器 TestUtil ，注入 User 对象并进行登录验证。代码如下：
```java
package com.importnew;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.AbstractController;
public class TestUtil extends AbstractController{
private User user;
public User getUser() {
return user;
}
public void setUser(User user) {
this.user = user;
}
@Override
protected ModelAndView handleRequestInternal(HttpServletRequest arg0,
HttpServletResponse arg1) throws Exception {
String username = arg0.getParameter("username");
String password = arg0.getParameter("password");
if(username.equals(user.getUsername()) && password.equals(user.getPassword())){
return new ModelAndView("yes");
}else{
return new ModelAndView("Error");
}
}
}
```
3.在 Spring 的配置文件 applicationContext.xml 中为 User 对象的属性赋值，并使用自动装配的方式在控制器 TestUtil 中注入 User 对象。代码如下：
```xml
/
.jsp
admin
123
```
4.在 web.xml 文件中配置 applicationContext.xml 的自动加载，当项目启动后程序将自动加载配置文件中的信息。代码如下：
```xml
Archetype Created Web Application
dispatcherServlet
org.springframework.web.servlet.DispatcherServlet
contextConfigLocation
/applicationContext.xml
1
dispatcherServlet
*.do
```
备注：TestUtil 中继承的类 AbstractController 需要引关于 spring-web-mvc 的 JAR 包支持。end

session简介
做过Web开发的程序员应该对Session都比较熟悉，Session是一块保存在服务器端的内存空间，一般用于保存用户的会话信息。
用户通过用户名和密码登陆成功之后，服务器端程序会在服务器端开辟一块Session内存空间并将用户的信息存入这块空间，同时服务器会
在cookie中写入一个Session_id的值，这个值用于标识这个内存空间。
下次用户再来访问的话会带着这个cookie中的session_id，服务器拿着这个id去寻找对应的session，如果session中已经有了这个用户的
登陆信息，则说明用户已经登陆过了。
使用Session保持会话信息使用起来非常简单，技术也非常成熟。但是也存在下面的几个问题：
服务器压力大：通常Session是存储在内存中的，每个用户通过认证之后都会将session数据保存在服务器的内存中，而当用户量增大时，服务器的压力增大。
Session共享：现在很多应用都是分布式集群，需要我们做额外的操作进行Session共享；
CSRF跨站伪造请求攻击：Session机制是基于浏览器端的cookie的，cookie如果被截获，用户就会很容易受到跨站请求伪造的攻击。
基于token的认证
基于token的认证机制将认证信息返回给客户端并存储。下次访问其他页面，需要从客户端传递认证信息回服务端。简单的流程如下：
客户端使用用户名跟密码请求登录；
服务端收到请求，去验证用户名与密码；
验证成功后，服务端会签发一个 Token，再把这个 Token 发送给客户端；
客户端收到 Token 以后可以把它存储起来，比如放在 Cookie 里或者 Local Storage 里；
客户端每次向服务端请求资源的时候需要带着服务端签发的 Token；
服务端收到请求，然后去验证客户端请求里面带着的 Token，如果验证成功，就向客户端返回请求的数据；
基于token的验证机制，有以下的优点：
支持跨域访问，将token置于请求头中，而cookie是不支持跨域访问的；
无状态化，服务端无需存储token，只需要验证token信息是否正确即可，而session需要在服务端存储，一般是通过cookie中的sessionID在服务端查找对应的session；
无需绑定到一个特殊的身份验证方案(传统的用户名密码登陆)，只需要生成的token是符合我们预期设定的即可；
更适用于移动端(Android，iOS，小程序等等)，像这种原生平台不支持cookie，比如说微信小程序，每一次请求都是一次会话，当然我们可以每次去手动为他添加cookie，详情请查看博主另一篇博客；
避免CSRF跨站伪造攻击，还是因为不依赖cookie；
缺点的话一个就是相比较于传统的session登陆机制实现起来略微复杂一点，另外一个比较大的缺点是由于服务器不保存 token，因此无法在使用过程中废止某个 token，或者更改 token 的权限。也就是说，一旦 token 签发了，在到期之前就会始终有效，除非服务器部署额外的逻辑。
退出登陆的话，只要前端清除token信息即可。
基于JWT的token认证实现
JWT(JSON Web Token)就是基于token认证的代表，这边就用JWT为列来介绍基于token的认证机制。
需要引入JWT的依赖
com.auth0
java-jwt
3.8.2
生成token和验证token的工具类如下：
public class JWTTokenUtil {
//设置过期时间
private static final long EXPIRE_DATE=30*60*100000;
//token秘钥
private static final String TOKEN_SECRET = "ZCfasfhuaUUHufguGuwu2020BQWE";
public static String token (String username,String password){
String token = "";
try {
//过期时间
Date date = new Date(System.currentTimeMillis()+EXPIRE_DATE);
//秘钥及加密算法
Algorithm algorithm = Algorithm.HMAC256(TOKEN_SECRET);
//设置头部信息
Map header = new HashMap<>();
header.put("typ","JWT");
header.put("alg","HS256");
//携带username，password信息，生成签名
token = JWT.create()
.withHeader(header)
.withClaim("username",username)
.withClaim("password",password).withExpiresAt(date)
.sign(algorithm);
}catch (Exception e){
e.printStackTrace();
return  null;
}
return token;
}
public static boolean verify(String token){
/**
* @desc   验证token，通过返回true
* @params [token]需要校验的串
**/
try {
Algorithm algorithm = Algorithm.HMAC256(TOKEN_SECRET);
JWTVerifier verifier = JWT.require(algorithm).build();
DecodedJWT jwt = verifier.verify(token);
return true;
}catch (Exception e){
e.printStackTrace();
return  false;
}
}
public static void main(String[] args) {
String username ="name1";
String password = "pw1";
//注意，一般不会把密码等私密信息放在payload中，这边只是举个列子
String token = token(username,password);
System.out.println(token);
boolean b = verify(token);
System.out.println(b);
}
}
执行结果如下：
Connected to the target VM, address: '127.0.0.1:11838', transport: 'socket'
eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJwYXNzd29yZCI6IjEyMyIsImV4cCI6MTU5NzM5Nzc0OCwidXNlcm5hbWUiOiJ6aGFuZ3NhbiJ9.LI5S_nX-YcqtExI9UtKiP8FPqpQW_ccaws2coLzyOS0
true
关于DecodedJWT这个类，大家可以重点看下，里面包含了解码后的用户信息。
JWT的使用说明
客户端收到服务器返回的 JWT，可以储存在 Cookie 里面，也可以储存在 localStorage。
此后，客户端每次与服务器通信，都要带上这个 JWT。你可以把它放在 Cookie 里面自动发送，但是这样不能跨域，所以更好的做法是放在 HTTP 请求的头信息Authorization字段里面。
Authorization: Bearer 
另一种做法是，跨域的时候，JWT 就放在 POST 请求的数据体里面。
JWT 本身包含了认证信息，一旦泄露，任何人都可以获得该令牌的所有权限。为了减少盗用，JWT 的有效期应该设置得比较短。对于一些比较重要的权限，使用时应该再次对用户进行认证。
为了减少盗用，JWT 不应该使用 HTTP 协议明码传输，要使用 HTTPS 协议传输。(或者是对JWT在前后端之间进行加密之后在传输)
关于JWT的一个问题
上面生成JWT token的过程关键点就是密钥，假如这个密钥泄露了，那是不是就可以伪造token了。
还有就是生产环境的密钥值，开发的程序员大概率是知道的，怎么防止程序要监守自盗，伪造token值呢？希望有经验的大佬指教下。
//token秘钥
private static final String TOKEN_SECRET = "ZCfasfhuaUUHufguGuwu2020BQWE";
关于上面的问题，@仙湖码农 给出了一个简单易懂的方案~
jwt 来生成token，还有一个玩法，用户登录时，生成token的 SecretKey 是一个随机数，也就是说每个用户，每次登录时jwt SecretKey 是随机数，并保存到缓存，key是登录账户，(当然了，分布式缓存的话，就用Redis，sqlserver缓存等等)，总之，客户端访问接口是，header 要带登录账户，和token，服务端拿到登录账号，到缓存去捞相应的SecretKey ，然后再进行token校验。可以防伪造token了(这个方案在一定程度上能防止伪造，但是不能防止token泄露被劫持)。
获取refresh token的方法
参考