Vue3+Spring Boot登录系统开发指南

package com.jdwa.login.model;

import lombok.Data;
import java.time.LocalDateTime;

@Data
public class JDWAUser {
    private Long id;
    private String username;
    private String password;
    private String email;
    private String phone;
    private String role;
    private Integer status;
    private LocalDateTime createTime;
    private LocalDateTime updateTime;
    private LocalDateTime lastLoginTime;
}

package com.jdwa.login.dto;

import lombok.Data;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.Size;

@Data
public class JDWALoginRequest {
    @NotBlank(message = "用户名不能为空")
    @Size(min = 3, max = 20, message = "用户名长度必须在3到20个字符之间")
    private String username;
    
    @NotBlank(message = "密码不能为空")
    @Size(min = 6, max = 20, message = "密码长度必须在6到20个字符之间")
    private String password;
}

package com.jdwa.login.dto;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class JDWALoginResponse {
    private String token;
    private JDWAUserDTO user;
}

package com.jdwa.login.dto;

import lombok.Data;

@Data
public class JDWAUserDTO {
    private Long id;
    private String username;
    private String email;
    private String role;
}

package com.jdwa.login.dto;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class JDWAResponse<T> {
    private boolean success;
    private String message;
    private T data;
    
    public static <T> JDWAResponse<T> success(T data) {
        return new JDWAResponse<>(true, "操作成功", data);
    }
    
    public static <T> JDWAResponse<T> success(String message, T data) {
        return new JDWAResponse<>(true, message, data);
    }
    
    public static <T> JDWAResponse<T> fail(String message) {
        return new JDWAResponse<>(false, message, null);
    }
}

package com.jdwa.login.mapper;

import com.jdwa.login.model.JDWAUser;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;

@Mapper
public interface JDWAUserMapper {
    /**
     * 根据用户名查询用户
     * @param username 用户名
     * @return 用户对象
     */
    JDWAUser findByUsername(@Param("username") String username);
    
    /**
     * 更新最后登录时间
     * @param userId 用户ID
     * @return 影响行数
     */
    int updateLastLoginTime(@Param("userId") Long userId);
}

package com.jdwa.login.security;

import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.stereotype.Component;

import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import java.util.function.Function;

@Component
public class JDWAJwtTokenUtil {

    @Value("${jdwa.jwt.secret}")
    private String secret;

    @Value("${jdwa.jwt.expiration}")
    private Long expiration;

    /**
     * 从令牌中获取用户名
     */
    public String getUsernameFromToken(String token) {
        return getClaimFromToken(token, Claims::getSubject);
    }

    /**
     * 从令牌中获取过期时间
     */
    public Date getExpirationDateFromToken(String token) {
        return getClaimFromToken(token, Claims::getExpiration);
    }

    public <T> T getClaimFromToken(String token, Function<Claims, T> claimsResolver) {
        final Claims claims = getAllClaimsFromToken(token);
        return claimsResolver.apply(claims);
    }

    /**
     * 从令牌中获取所有声明
     */
    private Claims getAllClaimsFromToken(String token) {
        return Jwts.parser()
                .setSigningKey(secret)
                .parseClaimsJws(token)
                .getBody();
    }

    /**
     * 检查令牌是否过期
     */
    private Boolean isTokenExpired(String token) {
        final Date expiration = getExpirationDateFromToken(token);
        return expiration.before(new Date());
    }

    /**
     * 为用户生成令牌
     */
    public String generateToken(UserDetails userDetails) {
        Map<String, Object> claims = new HashMap<>();
        return doGenerateToken(claims, userDetails.getUsername());
    }

    /**
     * 生成令牌的具体实现
     */
    private String doGenerateToken(Map<String, Object> claims, String subject) {
        final Date createdDate = new Date();
        final Date expirationDate = new Date(createdDate.getTime() + expiration);

        return Jwts.builder()
                .setClaims(claims)
                .setSubject(subject)
                .setIssuedAt(createdDate)
                .setExpiration(expirationDate)
                .signWith(SignatureAlgorithm.HS512, secret)
                .compact();
    }

    /**
     * 验证令牌
     */
    public Boolean validateToken(String token, UserDetails userDetails) {
        final String username = getUsernameFromToken(token);
        return (username.equals(userDetails.getUsername()) && !isTokenExpired(token));
    }
}

package com.jdwa.login.security;

import com.jdwa.login.mapper.JDWAUserMapper;
import com.jdwa.login.model.JDWAUser;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.stereotype.Service;

import java.util.Collections;

@Service
public class JDWAUserDetailsService implements UserDetailsService {

    @Autowired
    private JDWAUserMapper userMapper;

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        JDWAUser user = userMapper.findByUsername(username);
        
        if (user == null) {
            throw new UsernameNotFoundException("用户不存在: " + username);
        }
        
        // 如果用户被禁用，抛出异常
        if (user.getStatus() != 1) {
            throw new UsernameNotFoundException("用户已被禁用: " + username);
        }
        
        // 授予用户角色权限
        SimpleGrantedAuthority authority = new SimpleGrantedAuthority("ROLE_" + user.getRole());
        
        return new User(
                user.getUsername(),
                user.getPassword(),
                Collections.singletonList(authority)
        );
    }
}

package com.jdwa.login.security;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.web.authentication.WebAuthenticationDetailsSource;
import org.springframework.stereotype.Component;
import org.springframework.web.filter.OncePerRequestFilter;

import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@Component
public class JDWAAuthenticationFilter extends OncePerRequestFilter {

    @Autowired
    private JDWAUserDetailsService userDetailsService;

    @Autowired
    private JDWAJwtTokenUtil jwtTokenUtil;

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain)
            throws ServletException, IOException {

        final String authHeader = request.getHeader("Authorization");
        
        String username = null;
        String jwtToken = null;

        // 如果请求头包含JWT Token
        if (authHeader != null && authHeader.startsWith("Bearer ")) {
            jwtToken = authHeader.substring(7);
            try {
                username = jwtTokenUtil.getUsernameFromToken(jwtToken);
            } catch (Exception e) {
                logger.error("JWT Token解析失败: " + e.getMessage());
            }
        }

        // 一旦我们获取到token，就验证它
        if (username != null && SecurityContextHolder.getContext().getAuthentication() == null) {
            UserDetails userDetails = this.userDetailsService.loadUserByUsername(username);

            // 如果token有效，那么我们手动设置Spring Security的上下文
            if (jwtTokenUtil.validateToken(jwtToken, userDetails)) {
                UsernamePasswordAuthenticationToken authentication = new UsernamePasswordAuthenticationToken(
                        userDetails, null, userDetails.getAuthorities());
                authentication.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
                
                logger.info("认证用户 " + username + "，设置安全上下文");
                SecurityContextHolder.getContext().setAuthentication(authentication);
            }
        }
        chain.doFilter(request, response);
    }
}

package com.jdwa.login.security;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
import org.springframework.web.cors.CorsConfiguration;
import org.springframework.web.cors.CorsConfigurationSource;
import org.springframework.web.cors.UrlBasedCorsConfigurationSource;

import java.util.Arrays;

@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class JDWASecurityConfig extends WebSecurityConfigurerAdapter {

    @Autowired
    private JDWAUserDetailsService userDetailsService;

    @Autowired
    private JDWAAuthenticationFilter jwtAuthenticationFilter;

    @Autowired
    public void configureGlobal(AuthenticationManagerBuilder auth) throws Exception {
        // 配置自定义的UserDetailsService和密码加密方式
        auth.userDetailsService(userDetailsService).passwordEncoder(passwordEncoder());
    }

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }

    @Bean
    @Override
    public AuthenticationManager authenticationManagerBean() throws Exception {
        return super.authenticationManagerBean();
    }

    @Override
    protected void configure(HttpSecurity httpSecurity) throws Exception {
        httpSecurity
                // 禁用CSRF（跨站请求伪造）
                .csrf().disable()
                // 启用CORS
                .cors().and()
                // 基于token，所以不需要session
                .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS).and()
                // 设置权限
                .authorizeRequests()
                // 允许登录接口匿名访问
                .antMatchers("/api/login").permitAll()
                // 其他所有请求需要认证
                .anyRequest().authenticated();

        // 添加JWT token过滤器
        httpSecurity.addFilterBefore(jwtAuthenticationFilter, UsernamePasswordAuthenticationFilter.class);
        
        // 禁用缓存
        httpSecurity.headers().cacheControl();
    }

    @Bean
    CorsConfigurationSource corsConfigurationSource() {
        CorsConfiguration configuration = new CorsConfiguration();
        configuration.setAllowedOrigins(Arrays.asList("*"));
        configuration.setAllowedMethods(Arrays.asList("GET", "POST", "PUT", "DELETE", "OPTIONS"));
        configuration.setAllowedHeaders(Arrays.asList("Authorization", "Cache-Control", "Content-Type"));
        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
        source.registerCorsConfiguration("/**", configuration);
        return source;
    }
}

package com.jdwa.login.service;

import com.jdwa.login.dto.JDWALoginRequest;
import com.jdwa.login.dto.JDWALoginResponse;
import com.jdwa.login.dto.JDWAUserDTO;
import com.jdwa.login.mapper.JDWAUserMapper;
import com.jdwa.login.model.JDWAUser;
import com.jdwa.login.security.JDWAJwtTokenUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.authentication.BadCredentialsException;
import org.springframework.security.authentication.DisabledException;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.stereotype.Service;

@Service
public class JDWAUserService {

    @Autowired
    private AuthenticationManager authenticationManager;

    @Autowired
    private JDWAJwtTokenUtil jwtTokenUtil;

    @Autowired
    private UserDetailsService userDetailsService;

    @Autowired
    private JDWAUserMapper userMapper;

    /**
     * 用户登录
     * @param loginRequest 登录请求
     * @return 登录响应（包含token和用户信息）
     * @throws Exception 认证异常
     */
    public JDWALoginResponse login(JDWALoginRequest loginRequest) throws Exception {
        try {
            // 认证用户凭据
            authenticate(loginRequest.getUsername(), loginRequest.getPassword());

            // 加载用户详情
            final UserDetails userDetails = userDetailsService.loadUserByUsername(loginRequest.getUsername());
            
            // 生成JWT令牌
            final String token = jwtTokenUtil.generateToken(userDetails);
            
            // 获取用户信息
            JDWAUser user = userMapper.findByUsername(loginRequest.getUsername());
            
            // 更新最后登录时间
            userMapper.updateLastLoginTime(user.getId());
            
            // 构建返回DTO
            JDWAUserDTO userDTO = new JDWAUserDTO();
            userDTO.setId(user.getId());
            userDTO.setUsername(user.getUsername());
            userDTO.setEmail(user.getEmail());
            userDTO.setRole(user.getRole());
            
            return new JDWALoginResponse(token, userDTO);
        } catch (Exception e) {
            throw e;
        }
    }

    /**
     * 认证用户
     * @param username 用户名
     * @param password 密码
     * @throws Exception 认证异常
     */
    private void authenticate(String username, String password) throws Exception {
        try {
            authenticationManager.authenticate(new UsernamePasswordAuthenticationToken(username, password));
        } catch (DisabledException e) {
            throw new Exception("用户已禁用", e);
        } catch (BadCredentialsException e) {
            throw new Exception("用户名或密码错误", e);
        }
    }
}

package com.jdwa.login.controller;

import com.jdwa.login.dto.JDWALoginRequest;
import com.jdwa.login.dto.JDWALoginResponse;
import com.jdwa.login.dto.JDWAResponse;
import com.jdwa.login.service.JDWAUserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import javax.validation.Valid;

@RestController
@RequestMapping("/api")
public class JDWALoginController {

    @Autowired
    private JDWAUserService userService;

    /**
     * 用户登录接口
     * @param loginRequest 登录请求
     * @return 登录响应
     */
    @PostMapping("/login")
    public ResponseEntity<?> login(@Valid @RequestBody JDWALoginRequest loginRequest) {
        try {
            JDWALoginResponse response = userService.login(loginRequest);
            return ResponseEntity.ok(JDWAResponse.success("登录成功", response));
        } catch (Exception e) {
            return ResponseEntity.badRequest().body(JDWAResponse.fail(e.getMessage()));
        }
    }

    /**
     * 用户信息接口（需要认证）
     * @return 用户信息
     */
    @GetMapping("/user/info")
    public ResponseEntity<?> getUserInfo() {
        return ResponseEntity.ok(JDWAResponse.success("获取成功", "当前用户已认证"));
    }
}

package com.jdwa.login;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class JDWALoginApplication {

    public static void main(String[] args) {
        SpringApplication.run(JDWALoginApplication.class, args);
    }
}