springboot修改密码代码逻辑

以下是两种SpringBoot修改密码的代码逻辑：

1.持久层/业务层修改密码[^1]

@Test
public void changePassword() {
    userService.changePassword(9, "hery", "111", "1111");
}

2.Mybatis修改密码逻辑[^2]

@RestController
public class UpdatePasswordController {
    @Autowired
    private UpdatePasswordService updatePasswordService;

    @RequestMapping("update")
    public void updatePassword(@RequestParam(value = "username") String username,
                               @RequestParam(value = "password") String password,
                               @RequestParam(value = "newPsw") String newPsw){
        updatePasswordService.updatePassword(username,password,newPsw);
    }
}

相关问题

SpringBoot用户登录注册找回密码代码

以下是一个简单的 Spring Boot 用户登录注册找回密码的示例，包括基本的 REST API 和一些基本的验证逻辑。

User.java

@Entity
@Table(name = "users")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @NotBlank
    @Size(max = 50)
    @Email
    private String email;

    @NotBlank
    @Size(min = 6, max = 100)
    private String password;

    @NotBlank
    @Size(max = 50)
    private String name;

    // getters and setters
}

UserController.java

@RestController
@RequestMapping("/api/users")
public class UserController {
    @Autowired
    private AuthenticationManager authenticationManager;

    @Autowired
    private JwtTokenProvider tokenProvider;

    @Autowired
    private UserService userService;

    @PostMapping("/login")
    public ResponseEntity<?> authenticateUser(@Valid @RequestBody LoginRequest loginRequest) {

        Authentication authentication = authenticationManager.authenticate(
                new UsernamePasswordAuthenticationToken(
                        loginRequest.getEmail(),
                        loginRequest.getPassword()
                )
        );

        SecurityContextHolder.getContext().setAuthentication(authentication);

        String jwt = tokenProvider.generateToken(authentication);
        return ResponseEntity.ok(new JwtAuthenticationResponse(jwt));
    }

    @PostMapping("/register")
    public ResponseEntity<?> registerUser(@Valid @RequestBody SignUpRequest signUpRequest) {
        if(userService.existsByEmail(signUpRequest.getEmail())) {
            return new ResponseEntity(new ApiResponse(false, "Email Address already in use!"),
                    HttpStatus.BAD_REQUEST);
        }

        // Creating user's account
        User user = new User(signUpRequest.getName(), signUpRequest.getEmail(),
                signUpRequest.getPassword());

        userService.save(user);

        URI location = ServletUriComponentsBuilder
                .fromCurrentContextPath().path("/users/{username}")
                .buildAndExpand(user.getEmail()).toUri();

        return ResponseEntity.created(location).body(new ApiResponse(true, "User registered successfully"));
    }

    @PostMapping("/forgot-password")
    public ResponseEntity<?> forgotPassword(@Valid @RequestBody ForgotPasswordRequest forgotPasswordRequest) {
        User user = userService.findByEmail(forgotPasswordRequest.getEmail());

        if(user == null) {
            return new ResponseEntity(new ApiResponse(false, "Email Address not found"),
                    HttpStatus.BAD_REQUEST);
        }

        // TODO: send reset password email
        // String resetToken = tokenProvider.generateResetToken(user);

        return ResponseEntity.ok(new ApiResponse(true, "Reset password email sent successfully"));
    }

    @PostMapping("/reset-password")
    public ResponseEntity<?> resetPassword(@Valid @RequestBody ResetPasswordRequest resetPasswordRequest) {
        User user = userService.findById(resetPasswordRequest.getUserId());

        if(user == null) {
            return new ResponseEntity(new ApiResponse(false, "User not found"),
                    HttpStatus.BAD_REQUEST);
        }

        // TODO: validate reset password token
        // if(!tokenProvider.isValidResetToken(resetPasswordRequest.getToken(), user)) {
        //     return new ResponseEntity(new ApiResponse(false, "Invalid reset password token"),
        //             HttpStatus.BAD_REQUEST);
        // }

        userService.updatePassword(user, resetPasswordRequest.getPassword());

        return ResponseEntity.ok(new ApiResponse(true, "Password reset successfully"));
    }
}

JwtTokenProvider.java

@Component
public class JwtTokenProvider {

    @Value("${app.jwtSecret}")
    private String jwtSecret;

    @Value("${app.jwtExpirationInMs}")
    private int jwtExpirationInMs;

    public String generateToken(Authentication authentication) {

        UserPrincipal userPrincipal = (UserPrincipal) authentication.getPrincipal();

        Date now = new Date();
        Date expiryDate = new Date(now.getTime() + jwtExpirationInMs);

        return Jwts.builder()
                .setSubject(Long.toString(userPrincipal.getId()))
                .setIssuedAt(new Date())
                .setExpiration(expiryDate)
                .signWith(SignatureAlgorithm.HS512, jwtSecret)
                .compact();
    }

    public Long getUserIdFromJWT(String token) {
        Claims claims = Jwts.parser()
                .setSigningKey(jwtSecret)
                .parseClaimsJws(token)
                .getBody();

        return Long.parseLong(claims.getSubject());
    }

    public boolean validateToken(String authToken) {
        try {
            Jwts.parser().setSigningKey(jwtSecret).parseClaimsJws(authToken);
            return true;
        } catch (SignatureException ex) {
            logger.error("Invalid JWT signature");
        } catch (MalformedJwtException ex) {
            logger.error("Invalid JWT token");
        } catch (ExpiredJwtException ex) {
            logger.error("Expired JWT token");
        } catch (UnsupportedJwtException ex) {
            logger.error("Unsupported JWT token");
        } catch (IllegalArgumentException ex) {
            logger.error("JWT claims string is empty.");
        }
        return false;
    }
}

UserService.java

@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;

    public User save(User user) {
        return userRepository.save(user);
    }

    public boolean existsByEmail(String email) {
        return userRepository.existsByEmail(email);
    }

    public User findByEmail(String email) {
        return userRepository.findByEmail(email);
    }

    public User findById(Long id) {
        return userRepository.findById(id).orElse(null);
    }

    public void updatePassword(User user, String password) {
        user.setPassword(password);
        userRepository.save(user);
    }
}

LoginRequest.java

public class LoginRequest {
    @NotBlank
    @Email
    private String email;

    @NotBlank
    private String password;

    // getters and setters
}

SignUpRequest.java

public class SignUpRequest {
    @NotBlank
    @Size(min = 4, max = 40)
    private String name;

    @NotBlank
    @Size(max = 40)
    @Email
    private String email;

    @NotBlank
    @Size(min = 6, max = 20)
    private String password;

    // getters and setters
}

ForgotPasswordRequest.java

public class ForgotPasswordRequest {
    @NotBlank
    @Email
    private String email;

    // getters and setters
}

ResetPasswordRequest.java

public class ResetPasswordRequest {
    @NotBlank
    private Long userId;

    @NotBlank
    private String password;

    @NotBlank
    private String token;

    // getters and setters
}

ApiResponse.java

public class ApiResponse {
    private Boolean success;
    private String message;

    public ApiResponse(Boolean success, String message) {
        this.success = success;
        this.message = message;
    }

    // getters and setters
}

JwtAuthenticationResponse.java

public class JwtAuthenticationResponse {
    private String accessToken;
    private String tokenType = "Bearer";

    public JwtAuthenticationResponse(String accessToken) {
        this.accessToken = accessToken;
    }

    // getters and setters
}

UserPrincipal.java

public class UserPrincipal implements UserDetails {
    private Long id;

    private String name;

    private String email;

    private String password;

    // getters and setters
}

以上代码只是一个简单的示例，可以根据实际需求进行更改和扩展。

用java代码示例springboot中修改密码的接口

好的，以下是一个简单的示例代码：

@RestController
@RequestMapping("/api/user")
public class UserController {
    
    @Autowired
    private UserService userService;
    
    @PutMapping("/{userId}/password")
    public ResponseEntity<String> updatePassword(@PathVariable Long userId, @RequestBody PasswordUpdateRequest request) {
        userService.updatePassword(userId, request.getOldPassword(), request.getNewPassword());
        return ResponseEntity.ok("Password updated successfully.");
    }
}

public class PasswordUpdateRequest {
    private String oldPassword;
    private String newPassword;

    // getters and setters
}

@Service
public class UserService {
    
    @Autowired
    private UserRepository userRepository;
    
    public void updatePassword(Long userId, String oldPassword, String newPassword) {
        User user = userRepository.findById(userId).orElseThrow(() -> new UserNotFoundException(userId));
        if (!user.getPassword().equals(oldPassword)) {
            throw new InvalidPasswordException("Old password is incorrect.");
        }
        user.setPassword(newPassword);
        userRepository.save(user);
    }
}

public class User {
    private Long id;
    private String username;
    private String password;

    // getters and setters
}

public interface UserRepository extends JpaRepository<User, Long> {}

public class UserNotFoundException extends RuntimeException {
    public UserNotFoundException(Long userId) {
        super("User not found with id: " + userId);
    }
}

public class InvalidPasswordException extends RuntimeException {
    public InvalidPasswordException(String message) {
        super(message);
    }
}

这个示例中，我们定义了一个 `UserController`，其中有一个 `updatePassword` 方法，用于修改用户的密码。在 `UserService` 中，我们实现了修改密码的逻辑，并在出现异常的情况下抛出自定义的异常。最后，我们使用 `UserRepository` 来与数据库进行交互，完成密码的修改。