• 登录怎么实现的，密码加密了嘛？使用明文还是暗文，知道怎么加密嘛？

    在Java中登录功能的实现通常包括以下步骤，其中密码应该以加密形式存储在数据库中，而不以明文形式存储，以增强安全性：

    登录功能的实现步骤：

    1. 用户输入： 用户在登录页面上输入用户名和密码。

    2. 传输到服务器： 用户的输入数据通过网络传输到服务器。

    3. 验证用户名： 服务器首先验证用户提供的用户名是否存在于数据库中。如果用户名不存在，登录失败。

    4. 密码验证： 如果用户名存在，服务器从数据库中检索与该用户名关联的加密密码散列值。

    5. 密码比较： 服务器将用户提供的密码通过相同的加密算法进行散列处理，然后将其与数据库中存储的散列值进行比较。如果匹配成功，登录成功；否则，登录失败。

    6. 生成会话： 一旦用户成功登录，服务器通常会生成一个会话（Session）来跟踪用户的登录状态。会话可以包括一些令牌或标识信息，以便在用户进行后续请求时进行验证。

    7. 返回响应： 服务器向客户端发送登录成功或失败的响应，并在成功登录时提供访问权限。

    整理总结起来就是：

    1. 用户输入：用户在前端界面输入用户名和密码。

    2. 前端验证：前端可以进行基本的输入验证，例如检查用户名和密码是否为空。

    3. 后端验证：后端接收前端发送的用户名和密码，然后验证用户名是否存在于数据库中，并检查密码是否匹配。这通常涉及到从数据库中检索用户信息，然后使用适当的加密算法验证密码。

    4. Session管理：如果验证成功，服务器会创建一个会话（session）来表示用户已登录。这可以是基于HTTP会话的，也可以使用JWT（JSON Web Token）等其他机制。

    5. 登录状态管理：服务器通常会返回一个登录成功的响应，并在响应中包含有关用户的信息（例如用户ID或用户名）。前端可以存储这些信息，以便在用户进行后续请求时验证其身份。

    密码加密：

    密码通常不应该以明文形式存储在数据库中，因为这会增加安全风险。相反，应使用适当的加密算法对密码进行哈希（散列）处理，然后将哈希值存储在数据库中。这有助于保护用户密码的机密性。

    以下是密码加密的一般步骤：

    1. 密码哈希：在用户注册或修改密码时，后端应使用密码哈希算法（例如BCrypt、SHA-256等）对用户提供的明文密码进行哈希处理。

    2. 哈希存储：将哈希后的密码存储在数据库中。不要存储明文密码。

    3. 验证：在用户登录时，后端会将用户提供的密码再次进行哈希处理，然后与数据库中存储的哈希密码进行比较。如果哈希值匹配，说明密码正确。

    密码应该以加密形式存储在数据库中，而不以明文形式存储。这是为了防止数据库泄露或被未授权的人访问时，用户的密码不被轻易获取。常见的密码加密方法包括使用密码散列函数，如SHA-256、BCrypt  

    示例代码（Spring Security中的BCrypt密码加密）：

    1. import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
    2.  
    3. // 注册时加密密码
    4. String rawPassword = "user_password";
    5. BCryptPasswordEncoder encoder = new BCryptPasswordEncoder();
    6. String encodedPassword = encoder.encode(rawPassword);
    7. // 将encodedPassword存储到数据库中
    8.  
    9. // 验证登录时比较密码
    10. String loginPassword = "user_login_password";
    11. if (encoder.matches(loginPassword, encodedPassword)) {
    12.     // 密码匹配，允许登录
    13. } else {
    14.     // 密码不匹配，拒绝登录
    15. }

    简单举例：      

    以下是一个简单的示例，包括前端和后端的代码，用于实现用户登录和密码加密的功能。前端使用HTML、CSS、JavaScript，后端使用Spring Boot和Spring Security。

    前端部分（HTML + CSS + JavaScript）：

    1. html>
    2. <html lang="en">
    3. <head>
    4.     <meta charset="UTF-8">
    5.     <title>Logintitle>
    6.     <link rel="stylesheet" type="text/css" href="styles.css">
    7. head>
    8. <body>
    9.     <div class="login-container">
    10.         <h2>Loginh2>
    11.         <form id="login-form">
    12.             <div class="form-group">
    13.                 <label for="username">Username:label>
    14.                 <input type="text" id="username" name="username" required>
    15.             div>
    16.             <div class="form-group">
    17.                 <label for="password">Password:label>
    18.                 <input type="password" id="password" name="password" required>
    19.             div>
    20.             <button type="submit">Loginbutton>
    21.         form>
    22.         <div id="message">div>
    23.     div>
    24.     
    25.     <script src="https://code.jquery.com/jquery-3.6.0.min.js">script>
    26.     <script src="main.js">script>
    27. body>
    28. html>
    CSS文件（styles.css）：
    1. body {
    2.     font-family: Arial, sans-serif;
    3.     background-color: #f4f4f4;
    4.     margin: 0;
    5.     padding: 0;
    6.     display: flex;
    7.     justify-content: center;
    8.     align-items: center;
    9.     height: 100vh;
    10. }
    11.  
    12. .login-container {
    13.     background-color: #fff;
    14.     border-radius: 5px;
    15.     box-shadow: 0 0 10px rgba(0, 0, 0, 0.1);
    16.     padding: 20px;
    17.     text-align: center;
    18. }
    19.  
    20. h2 {
    21.     margin-bottom: 20px;
    22. }
    23.  
    24. .form-group {
    25.     margin-bottom: 15px;
    26.     text-align: left;
    27. }
    28.  
    29. label {
    30.     font-weight: bold;
    31. }
    32.  
    33. input[type="text"],
    34. input[type="password"] {
    35.     width: 100%;
    36.     padding: 10px;
    37.     border: 1px solid #ccc;
    38.     border-radius: 5px;
    39. }
    40.  
    41. button {
    42.     background-color: #007bff;
    43.     color: #fff;
    44.     border: none;
    45.     padding: 10px 20px;
    46.     border-radius: 5px;
    47.     cursor: pointer;
    48. }
    49.  
    50. button:hover {
    51.     background-color: #0056b3;
    52. }

    JavaScript文件（main.js）：
    1. $(document).ready(function() {
    2.     $('#login-form').submit(function(event) {
    3.         event.preventDefault();
    4.         var username = $('#username').val();
    5.         var password = $('#password').val();
    6.         var formData = { username: username, password: password };
    7.  
    8.         $.ajax({
    9.             type: 'POST',
    10.             url: '/login',
    11.             data: JSON.stringify(formData),
    12.             contentType: 'application/json',
    13.             success: function(response) {
    14.                 $('#message').text('Login successful. Redirecting...');
    15.                 setTimeout(function() {
    16.                     window.location.href = '/dashboard';
    17.                 }, 1000); // Redirect to dashboard after 1 second
    18.             },
    19.             error: function(xhr, textStatus, errorThrown) {
    20.                 $('#message').text('Login failed. Please check your credentials.');
    21.             }
    22.         });
    23.     });
    24. });

    后端部分（Spring Boot + Spring Security）：

    以下是Spring Boot后端的代码，包括用户实体、用户仓库、Spring Security配置、自定义用户详情服务以及密码加密配置，带有中文注释。

    用户实体类（User.java）：
    1. import javax.persistence.*;
    2.  
    3. @Entity
    4. @Table(name = "users")
    5. public class User {
    6.     @Id
    7.     @GeneratedValue(strategy = GenerationType.IDENTITY)
    8.     private Long id;
    9.  
    10.     @Column(unique = true)
    11.     private String username;
    12.     private String password;
    13.  
    14.     // 省略构造函数和其他属性的getter和setter方法
    15.  
    16.     // 注意：这里省略了角色相关的配置，你可以根据需要添加
    17. }

    用户仓库接口（UserRepository.java）：
    1. import org.springframework.data.jpa.repository.JpaRepository;
    2.  
    3. public interface UserRepository extends JpaRepository {
    4.     User findByUsername(String username);
    5. }
    Spring Security配置类（SecurityConfig.java）：
    1. import org.springframework.beans.factory.annotation.Autowired;
    2. import org.springframework.context.annotation.Bean;
    3. import org.springframework.context.annotation.Configuration;
    4. import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
    5. import org.springframework.security.config.annotation.web.builders.HttpSecurity;
    6. import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
    7. import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
    8. import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
    9. import org.springframework.security.crypto.password.PasswordEncoder;
    10.  
    11. @Configuration
    12. @EnableWebSecurity
    13. public class SecurityConfig extends WebSecurityConfigurerAdapter {
    14.  
    15.     @Autowired
    16.     private CustomUserDetailsService customUserDetailsService;
    17.  
    18.     @Override
    19.     protected void configure(HttpSecurity http) throws Exception {
    20.         http
    21.             .authorizeRequests()
    22.                 .antMatchers("/", "/login").permitAll()
    23.                 .antMatchers("/dashboard").authenticated()
    24.             .and()
    25.                 .formLogin()
    26.                 .loginPage("/login")
    27.                 .defaultSuccessURL("/dashboard")
    28.             .and()
    29.                 .logout()
    30.                 .logoutSuccessUrl("/login")
    31.             .and()
    32.                 .csrf().disable();
    33.     }
    34.  
    35.     @Autowired
    36.     public void configureGlobal(AuthenticationManagerBuilder auth) throws Exception {
    37.         auth
    38.             .userDetailsService(customUserDetailsService)
    39.             .passwordEncoder(passwordEncoder());
    40.     }
    41.  
    42.     @Bean
    43.     public PasswordEncoder passwordEncoder() {
    44.         return new BCryptPasswordEncoder();
    45.     }
    46. }
    自定义用户详情服务（CustomUserDetailsService.java）：
    1. import org.springframework.beans.factory.annotation.Autowired;
    2. import org.springframework.security.core.userdetails.UserDetails;
    3. import org.springframework.security.core.userdetails.UserDetailsService;
    4. import org.springframework.security.core.userdetails.UsernameNotFoundException;
    5. import org.springframework.stereotype.Service;
    6.  
    7. @Service
    8. public class CustomUserDetailsService implements UserDetailsService {
    9.  
    10.     @Autowired
    11.     private UserRepository userRepository;
    12.  
    13.     @Override
    14.     public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
    15.         User user = userRepository.findByUsername(username);
    16.         if (user == null) {
    17.             throw new UsernameNotFoundException("用户不存在：" + username);
    18.         }
    19.         return new CustomUserDetails(user);
    20.     }
    21. }
    密码加密配置类（PasswordConfig.java）：
    1. import org.springframework.context.annotation.Bean;
    2. import org.springframework.context.annotation.Configuration;
    3. import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
    4. import org.springframework.security.crypto.password.PasswordEncoder;
    5.  
    6. @Configuration
    7. public class PasswordConfig {
    8.  
    9.     @Bean
    10.     public PasswordEncoder passwordEncoder() {
    11.         return new BCryptPasswordEncoder();
    12.     }
    13. }
    application.properties：
    1. # 数据库连接配置
    2. spring.datasource.url=jdbc:mysql://localhost:3306/mydb
    3. spring.datasource.username=root
    4. spring.datasource.password=your_password
    5. spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
    6.  
    7. # Spring Boot应用程序的端口号
    8. server.port=8080
    9.  
    10. # 数据库连接池配置（这里使用HikariCP）
    11. spring.datasource.hikari.connectionTimeout=20000
    12. spring.datasource.hikari.maximumPoolSize=5
    13.  
    14. # 日志级别配置
    15. logging.level.org.springframework=INFO
    16. logging.level.com.yourpackage=DEBUG
    17.  
    18. # Spring Security配置
    19. # 禁用CSRF保护，因为我们的示例中没有CSRF令牌
    20. security.enable-csrf=false
    21.  
    22. # Spring Security登录页面配置
    23. spring.security.form-login.login-page=/login
    24. spring.security.form-login.default-target-url=/dashboard
    25. spring.security.form-login.login-processing-url=/login
    26.  
    27. # Spring Security注销配置
    28. spring.security.logout.logout-success-url=/login
    29.  
    30. # 数据库方言配置（根据你使用的数据库类型进行设置）
    31. spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL8Dialect

    用于配置应用程序的属性，包括数据库连接、服务器端口等。你可以根据你的实际需求进行修改和扩展。

    将这个配置文件保存为 application.properties 并放置在你的Spring Boot项目的 src/main/resources 目录下。Spring Boot会自动加载这个配置文件并根据其中的配置信息来初始化你的应用程序。

    pom.xml：
    1. "1.0" encoding="UTF-8"?>
    2. "http://maven.apache.org/POM/4.0.0"
    3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    5.     4.0.0
    6.  
    7.     com.example
    8.     my-springboot-app
    9.     1.0.0
    10.  
    11.     
    12.     
    13.         org.springframework.boot
    14.         spring-boot-starter-parent
    15.         2.5.3
    16.     
    17.  
    18.     
    19.         
    20.         
    21.             org.springframework.boot
    22.             spring-boot-starter-web
    23.         
    24.  
    25.         
    26.         
    27.             org.springframework.boot
    28.             spring-boot-starter-data-jpa
    29.         
    30.  
    31.         
    32.         
    33.             org.springframework.boot
    34.             spring-boot-starter-security
    35.         
    36.  
    37.         
    38.         
    39.             mysql
    40.             mysql-connector-java
    41.         
    42.     
    43.  
    44.     
    45.         
    46.             
    47.             
    48.                 org.springframework.boot
    49.                 spring-boot-maven-plugin
    50.             
    51.         
    52.
    注意：

    在Spring Boot项目的pom.xml文件中，还可能包括其他配置项，取决于项目的需求。以下是一些你会可能需要的其他配置项和依赖项：

    1. Spring Boot Starter依赖项：根据你的项目需要，你可以添加其他Spring Boot Starter依赖项，例如Spring Boot Starter Test（用于单元测试）、Spring Boot Starter Data Redis（用于Redis缓存）、Spring Boot Starter Thymeleaf（用于模板引擎）等。

    2. 自定义属性配置：你可以使用application.properties或application.yml文件来配置自定义属性，例如数据库连接信息、日志配置、密钥配置等。

    3. 其他数据库驱动：如果你使用的不是MySQL，而是其他数据库，需要添加相应的数据库驱动依赖项，例如Oracle、PostgreSQL等。

    4. 前端构建工具：如果你的项目包括前端部分，可能需要配置前端构建工具（如Webpack、npm等）和相关依赖项，以构建和管理前端资源。

    5. Spring Boot插件配置：根据项目需求，你可能需要配置Spring Boot Maven插件或Gradle插件的属性，以控制构建和打包行为。

    6. Swagger文档生成：如果你想为API添加Swagger文档，可以添加Swagger相关的依赖项和配置。

    7. 数据库连接池配置：如果你使用的是数据库连接池，可以根据具体的连接池（如HikariCP、Tomcat JDBC等）进行配置。

    8. 安全证书和密钥配置：如果你的应用需要HTTPS支持，需要配置SSL证书和密钥。

    9. 日志配置：根据项目需求，你可能需要配置日志记录的级别、输出目标（文件、控制台等）等。

    10. 国际化和本地化配置：如果你的应用需要多语言支持，可以配置国际化和本地化属性。

    根据具体的项目需求，可能会有其他特定的配置项和依赖项。在开发过程中，根据项目的要求逐步添加和调整这些配置。确保你的pom.xml文件和应用程序配置符合项目的需求和规范。

  • 相关阅读:
    今日睡眠质量记录80分
    解决Mac终端启动每次都要source ~/.bash_profile才能使adb生效的问题
    python强化学习--gym安装与使用
    可缩放矢量图形svg
    云安全：企业上云后不可忽视的安全挑战与解决方案
    MyBatis整合Spring Boot扫描Mapper相关配置
    【计算机视觉】图像的获取和表示——图像传感器技术|主要参数解析、成像原理剖析、传感器处理
    C++ call python with cmake
    jsp科研管理系统Myeclipse开发mysql数据库web结构java编程计算机网页项目
    iOS-系统弹窗调用，
  • 原文地址：https://blog.csdn.net/qq_57747969/article/details/132754475