SpringBoot案例3

1-登录校验的实现思路是怎样的？

在未登录的情况下，我们可以直接在浏览器地址栏访问部门管理、员工管理等功能。

 

因为在我们现在实现的代码逻辑中，我们根据用户名 和 密码查询用户，查询到了用户信息，就判定登录成功，我们并没有在服务端或客户端记录任何用户登录成功的标识。 而HTTP协议又是无状态协议，那下一次在请求时，我们也无法判断员工是否已经登录。

 

而要想解决上述的问题呢，我们就需要做两件事情：

• 在员工登录成功后，需要将用户登录成功的信息，存起来，记录用户已经登录成功的标记。

• 在浏览器发起请求时，需要在服务端进行统一拦截，然后读取登录标记中的信息，如果有登录成功的信息，就说明用户登录成功，放行请求，如果发现登录标记中没有登录成功的标记，则给前端返回错误信息，跳转至登录页面。

 

其中：

• 统一拦截：可以使用两种技术实现，Filter过滤器 以及 Interceptor 拦截器。

• 登录标记：就需要用户登录成功之后，每一次请求中，都可以获取到该标记。

此标记需要在用户登录成功之后，每一个请求资源中，都可以获取到，也就是说可以在多次请求间共享。但是我们之前介绍过，HTTP是无状态的，不能在多次请求间共享数据，所以，此处需要使用会话跟踪技术来解决。

那接下来呢，我们就先来讲解会话跟踪技术，然后再讲解统一拦截技术：Filter、Interceptor。

2.会话技术有哪些方式可以实现？

会话技术（Session Technology）可以实现多用户之间的交互和共享信息。以下是常见的几种会话技术方式： Cookie：Cookie是一种在用户计算机上存储小量数据的技术，通常用于存储用户的登录状态、购物车信息等。Cookie数据存储在用户的浏览器中，可以在用户下次访问同一网站时自动加载。

Session：Session是一种在服务器端存储用户会话数据的技术，通常用于存储用户的登录状态、购物车信息等。Session数据存储在服务器端，可以在多个用户访问同一网站时共享。

Token：Token是一种在用户计算机上存储的短期令牌，通常用于验证用户的身份。Token数据存储在用户的浏览器中，可以在用户进行操作时自动发送给服务器进行验证。

OAuth：OAuth是一种授权机制，允许用户授权第三方应用程序访问其受保护的资源。OAuth通常用于网站或应用程序之间的身份验证和授权。

JWT：JWT（JSON Web Token）是一种用于在用户计算机上存储和传输信息的开放标准。JWT通常用于身份验证和授权，可以在用户计算机和服务器之间传输信息。 这些会话技术方式可以根据具体的应用场景进行选择和使用。

3.JWT令牌组成部分有哪些，各自作用是什么？

JWT（JSON Web Token）是一个用于在用户计算机上存储和传输信息的开放标准，它由三个部分组成，分别是头部（Header）、有效载荷（Payload）和签名（Signature）。 头部（Header）：头部包含了JWT的类型（通常为JWT）和使用的加密算法（通常为HMAC SHA256或RSA）。

头部通常是Base64编码的。

有效载荷（Payload）：有效载荷包含了JWT的主要信息，例如用户的身份信息、角色信息、权限信息等。有效载荷通常是Base64编码的，并且可以包含自定义的属性和值。

签名（Signature）：签名用于验证JWT的完整性和真实性。签名通常是使用私钥对头部和有效载荷进行签名，然后使用公钥进行验证。签名通常是Base64编码的。

JWT的各个部分的作用如下： 头部：头部包含了JWT的类型和使用的加密算法，用于告诉服务器如何验证签名。

有效载荷：有效载荷包含了JWT的主要信息，例如用户的身份信息、角色信息、权限信息等。有效载荷还可以包含自定义的属性和值，用于传递额外的信息。

签名：签名用于验证JWT的完整性和真实性。签名通常是使用私钥对头部和有效载荷进行签名，然后使用公钥进行验证。如果签名验证成功，则表示JWT的真实性和完整性得到了保护。

JWT的优点是可以跨域传递，可以在不同的应用程序之间共享用户的身份信息和权限信息。JWT的缺点是需要在每个应用程序中存储和验证JWT，增加了服务器的负担和安全风险。因此，需要根据具体的应用场景来选择和使用JWT。

4

怎么使用JWT令牌？（依赖，创建，校验）

JWT（JSON Web Token）是一种用于在用户计算机上存储和传输信息的开放标准。JWT通常用于身份验证和授权，可以在用户计算机和服务器之间传输信息。

JWT的组成部分包括三个部分：头部（Header）、有效载荷（Payload）和签名（Signature）。其中，头部用于指定JWT的类型和算法，有效载荷用于存储实际的数据，签名用于验证JWT的完整性和真实性。

使用JWT的步骤如下：

1. 引入JWT库：可以使用Java中的jjwt库或其他支持JWT的库。

2. 创建JWT令牌：可以使用jjwt库提供的JwtBuilder类来创建JWT令牌。例如：

import io.jsonwebtoken.JwtBuilder;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
​
public class JwtUtils {
    private static final String SECRET_KEY = "mysecretkey";
​
    public static String createToken(String username) {
        JwtBuilder builder = Jwts.builder()
               .setSubject(username)
               .setExpiration(new Date(System.currentTimeMillis() + 60 * 60 * 1000))
               .signWith(SignatureAlgorithm.HS256, SECRET_KEY);
        return builder.compact();
    }
}

在上面的代码中，我们使用JwtBuilder类创建了一个JWT令牌，其中包含了用户名、过期时间和签名。签名使用了HMAC算法，使用了指定的密钥（这里是mysecretkey）。

1. 校验JWT令牌：可以使用jjwt库提供的JwtParser类来校验JWT令牌。例如：

import io.jsonwebtoken.Claims;
import io.jsonwebtoken.JwtException;
import io.jsonwebtoken.JwtParser;
import io.jsonwebtoken.Jwts;
​
public class JwtUtils {
    private static final String SECRET_KEY = "mysecretkey";
​
    public static String getUsername(String token) {
        try {
            JwtParser parser = Jwts.parser().setSigningKey(SECRET_KEY);
            Claims claims = parser.parseClaimsJws(token).getBody();
            return claims.getSubject();
        } catch (JwtException e) {
            return null;
        }
    }
}

在上面的代码中，我们使用JwtParser类解析了JWT令牌，并从有效载荷中获取了用户名。如果JWT令牌无效，则返回null。

需要注意的是，JWT令牌应该在安全的环境下存储和传输，例如使用HTTPS协议进行加密传输。同时，为了保证JWT令牌的安全性，应该使用强密码学算法和密钥进行签名和验证。

5

项目中在什么时候去生成令牌？

JWT令牌通常在用户登录成功后生成，并存储在用户的计算机上或服务器上。以下是生成JWT令牌的步骤：

1. 定义JWT令牌的结构：JWT令牌通常包含三个部分：头部（Header）、有效载荷（Payload）和签名（Signature）。头部通常包含令牌的类型、算法等信息，有效载荷包含用户的身份信息、过期时间等信息，签名用于验证JWT令牌的完整性和有效性。

2. 生成JWT令牌：可以使用Java中的JWT库（如jjwt）或其他JWT生成工具来生成JWT令牌。在生成JWT令牌时，需要指定令牌的有效期、密钥、算法等参数。

3. 存储JWT令牌：生成的JWT令牌可以存储在用户的计算机上或服务器上。通常使用HTTP Cookie或localStorage等方式将JWT令牌存储在用户的浏览器中，或使用服务器端存储方式将JWT令牌存储在服务器端。

4. 发送JWT令牌：在用户进行操作时，可以将JWT令牌发送给服务器进行验证和授权。通常使用HTTP请求头中的Authorization字段来发送JWT令牌，例如：Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c

5. 验证JWT令牌：服务器端可以使用JWT库或其他验证工具来验证JWT令牌的有效性和完整性。在验证JWT令牌时，需要指定密钥、算法等参数，并检查令牌的过期时间、用户的身份信息等信息。

在项目中，通常在用户登录成功后生成JWT令牌，并将其存储在用户的计算机上或服务器上。在用户进行操作时，可以使用HTTP请求头中的Authorization字段来发送JWT令牌，服务器端可以使用JWT库或其他验证工具来验证JWT令牌的有效性和完整性。

6

当前端携带令牌访问资源时怎么去拦截校验令牌的合法性

在客户端携带JWT令牌访问资源时，通常需要在请求头中添加Authorization字段，将令牌值放在Bearer字段中。例如：

Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c

在服务器端，需要对JWT令牌进行验证和解析，以确保令牌的合法性和有效性。通常可以使用JWT库来实现JWT令牌的生成、验证和解析。

在客户端携带JWT令牌访问资源时，通常需要在请求头中添加Authorization字段，将令牌值放在Bearer字段中。在服务器端，需要对JWT令牌进行验证和解析，以确保令牌的合法性和有效性。如果令牌验证失败，需要返回错误信息，告诉客户端该令牌无效或已过期。

以下是一个简单的Java代码示例，演示了如何使用JWT库生成、验证和解析JWT令牌：

import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
​
import java.util.Date;
​
public class JwtTokenUtil {
    // 密钥
    private static final String SECRET_KEY = "mysecretkey";
    // 有效期
    private static final long EXPIRATION = 604800000L;
​
    public static String generateToken(String username) {
        Date now = new Date();
        Date expirationDate = new Date(now.getTime() + EXPIRATION);
​
        return Jwts.builder()
               .setSubject(username)
               .setIssuedAt(now)
               .setExpiration(expirationDate)
               .signWith(SignatureAlgorithm.HS512, SECRET_KEY)
               .compact();
    }
​
    public static String getUsernameFromToken(String token) {
        Claims claims = Jwts.parser()
               .setSigningKey(SECRET_KEY)
               .parseClaimsJws(token)
               .getBody();
​
        return claims.getSubject();
    }
​
    public static boolean validateToken(String token) {
        try {
            Jwts.parser().setSigningKey(SECRET_KEY).parseClaimsJws(token);
            return true;
        } catch (Exception e) {
            return false;
        }
    }
}

在上面的代码中，我们使用了io.jsonwebtoken库来生成、验证和解析JWT令牌。generateToken方法用于生成JWT令牌，getUsernameFromToken方法用于从JWT令牌中解析出用户名，validateToken方法用于验证JWT令牌的合法性。在生成和解析JWT令牌时，我们需要指定密钥和有效期等参数。

7

过滤器具体使用的步骤是怎样的？

过滤器（Filter）是Java EE中的一种技术，用于在请求处理前或处理后对请求和响应进行拦截和修改。过滤器通常用于实现身份验证、日志记录、缓存、压缩等功能。

使用过滤器的一般步骤如下：

1. 实现Filter接口，重写doFilter方法，实现过滤器的逻辑。

2. 在web.xml文件中配置过滤器，指定过滤器的名称、URL模式、顺序等参数。

3. 在请求处理过程中，过滤器会在请求到达URL模式时被调用，doFilter方法会接收请求和响应作为参数，可以在其中对请求和响应进行拦截和修改。

4. 在doFilter方法中，可以调用链中的下一个过滤器或目标资源，也可以直接返回响应结果。

5. 在过滤器的doFilter方法中，可以使用HttpServletRequest和HttpServletResponse对象来获取请求和响应的信息，也可以对请求和响应进行修改。

以下是一个简单的Java代码示例，演示了如何使用过滤器实现身份验证：

import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
​
public class AuthenticationFilter implements Filter {
    private static final String AUTH_HEADER = "Authorization";
    private static final String BEARER_PREFIX = "Bearer ";
​
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        HttpServletRequest httpRequest = (HttpServletRequest) request;
        HttpServletResponse httpResponse = (HttpServletResponse) response;
​
        String authHeader = httpRequest.getHeader(AUTH_HEADER);
        if (authHeader!= null && authHeader.startsWith(BEARER_PREFIX)) {
            String token = authHeader.substring(BEARER_PREFIX.length());
            if (isValidToken(token)) {
                // 身份验证通过，继续处理请求
                chain.doFilter(request, response);
            } else {
                // 身份验证失败，返回错误响应
                httpResponse.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
                httpResponse.getWriter().write("Invalid token");
            }
        } else {
            // 没有提供身份验证信息，返回错误响应
            httpResponse.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
            httpResponse.getWriter().write("Missing token");
        }
    }
​
    private boolean isValidToken(String token) {
        // 验证令牌的合法性，返回true或false
    }
}

在上面的代码中，我们实现了一个简单的身份验证过滤器，用于验证请求头中是否包含JWT令牌。在doFilter方法中，我们首先获取请求头中的Authorization字段，然后检查令牌是否以Bearer开头。如果令牌合法，我们调用链中的下一个过滤器或目标资源，否则返回错误响应。在isValidToken方法中，我们可以实现具体的令牌验证逻辑，例如从数据库中查询令牌是否有效等。

8

拦截器具体使用的步骤是怎样的？

拦截器是一种在请求或响应被发送到服务器之前或之后对其进行修改的机制。它可以用于添加、删除或修改请求或响应中的头部、参数、数据等。以下是使用拦截器的步骤：

1. 创建一个拦截器类，实现`Interceptor`接口。

```java
public class MyInterceptor implements Interceptor {
    @Override
    public Response intercept(Chain chain) throws IOException {
        // 在请求被发送之前进行操作
        Request request = chain.request();
        // 在请求被发送之后进行操作
        Response response = chain.proceed(request);
        // 在响应被返回之前进行操作
        return response;
    }
}
```

2. 在OkHttp客户端中添加拦截器。

```java
OkHttpClient client = new OkHttpClient.Builder()
   .addInterceptor(new MyInterceptor())
   .build();
```

3. 在发送请求时，OkHttp会自动调用拦截器的`intercept()`方法，并将请求传递给拦截器进行处理。

```java
Request request = new Request.Builder()
   .url("https://www.example.com")
   .build();
Response response = client.newCall(request).execute();
```

在拦截器的`intercept()`方法中，可以对请求和响应进行修改，然后返回修改后的请求或响应。如果需要继续传递请求或响应，可以调用`chain.proceed()`方法，并将修改后的请求或响应作为参数传递给它。如果需要终止请求或响应，可以返回一个新的响应对象，例如：

```java
@Override
public Response intercept(Chain chain) throws IOException {
    Request request = chain.request();
    Response response = chain.proceed(request);
    if (response.code() == 401) {
        // 如果响应状态码为401，则重新登录
        //...
        // 重新发送请求
        return chain.proceed(request);
    }
    return response;
}
```

在这个例子中，如果响应状态码为401，则重新登录并重新发送请求。如果响应状态码不是401，则返回原始响应。

9

项目中异常是怎么处理的？具体怎么实现？

在项目中，异常处理是非常重要的一部分，它可以帮助我们更好地处理程序中的错误和异常情况。以下是一些常见的异常处理方法：
使用try-catch语句：try-catch语句是Java中最常用的异常处理方式，它可以让我们在try语句块中执行代码，如果出现异常，就跳转到catch语句块中进行处理。
使用throws语句：throws语句可以让方法抛出异常，让调用者去处理异常。
使用自定义异常类：自定义异常类可以让我们更加细粒度地控制异常的类型和信息。
使用日志记录：日志记录可以帮助我们记录程序的运行状态和异常信息，方便我们后续的调试和排查问题。
具体实现方法可以根据具体的项目需求和技术水平来决定，可以使用Java中的异常处理机制或者第三方库来实现。

10

登录校验功能实现完善，并集成全局异常处理！
实现登录校验功能需要以下步骤：

1. 在登录页面中添加一个表单，用于输入用户名和密码。

2. 在登录按钮的点击事件中，获取表单中的用户名和密码，并调用一个登录接口进行登录验证。

3. 如果登录成功，跳转到主页面；如果登录失败，弹出一个提示框，提示用户登录失败。

4. 为了实现登录校验功能，需要在后端添加一个登录接口，该接口接收用户名和密码作为参数，并验证其是否正确。如果验证成功，返回一个登录令牌；如果验证失败，返回一个错误信息。

5. 在前端代码中，需要对登录接口的返回结果进行处理。如果返回的是登录令牌，则将其存储在本地存储中，并跳转到主页面；如果返回的是错误信息，则弹出一个提示框，提示用户登录失败。

6. 为了实现全局异常处理，可以在前端代码中添加一个全局异常处理函数，该函数会在任何地方出现异常时被调用。在该函数中，可以根据异常类型和错误信息，弹出一个提示框，提示用户出现了错误。

7. 在后端代码中，需要对登录接口的异常情况进行处理。如果出现异常，可以返回一个错误信息，并在前端代码中进行处理。

具体实现步骤如下：

1. 在登录页面中添加一个表单，用于输入用户名和密码。

```html
<form>
  <label for="username">用户名：</label>
  <input type="text" id="username" name="username"><br>
  <label for="password">密码：</label>
  <input type="password" id="password" name="password"><br>
  <button type="button" οnclick="login()">登录</button>
</form>
```

2. 在登录按钮的点击事件中，获取表单中的用户名和密码，并调用一个登录接口进行登录验证。

```javascript
function login() {
  const username = document.getElementById('username').value;
  const password = document.getElementById('password').value;
  // 调用登录接口进行登录验证
  fetch('/api/login', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({ username, password })
  })
 .then(response => {
    if (response.ok) {
      return response.text();
    } else {
      throw new Error('登录失败');
    }
  })
 .then(token => {
    // 如果登录成功，将登录令牌存储在本地存储中，并跳转到主页面
    localStorage.setItem('token', token);
    window.location.href = '/';
  })
 .catch(error => {
    // 如果登录失败，弹出一个提示框，提示用户登录失败
    alert(error.message);
  });
}
```

3. 为了实现登录校验功能，需要在后端添加一个登录接口，该接口接收用户名和密码作为参数，并验证其是否正确。如果验证成功，返回一个登录令牌；如果验证失败，返回一个错误信息。

```javascript
app.post('/api/login', (req, res) => {
  const { username, password } = req.body;
  // 调用数据库进行登录验证
  const user = users.find(u => u.username === username && u.password === password);
  if (user) {
    // 如果登录成功，返回一个登录令牌
    const token = generateToken();
    res.send(token);
  } else {
    // 如果登录失败，返回一个错误信息
    res.status(401).send('用户名或密码错误');
  }
});
```

4. 在前端代码中，需要对登录接口的返回结果进行处理。如果返回的是登录令牌，则将其存储在本地存储中，并跳转到主页面；如果返回的是错误信息，则弹出一个提示框，提示用户登录失败。

```javascript
fetch('/api/login', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({ username, password })
})
.then(response => {
  if (response.ok) {
    return response.text();
  } else {
    throw new Error('登录失败');
  }
})
.then(token => {
  // 如果登录成功，将登录令牌存储在本地存储中，并跳转到主页面
  localStorage.setItem('token', token);
  window.location.href = '/