使用基于token的认证

基于token的认证是一种常见的身份验证方式，其基本思想是在用户登录成功后，服务器颁发一个令牌（token），并将该令牌发送给客户端，客户端将该令牌保存起来，以后每次向服务器发送请求时，都需要将该令牌携带在请求头中，以便服务器根据令牌来验证用户的身份。这种方式相对于传统的基于cookie的认证方式，具有更好的安全性和可扩展性，因为token不会被浏览器自动发送，而且可以方便地扩展为分布式系统。

相关问题

能帮我写一个基于token认证的drf的认证代码吗

### 回答1：
当然可以! 下面是一个使用 `TokenAuthentication` 的例子:

from rest_framework.authentication import TokenAuthentication

class ExampleView(APIView):
    authentication_classes = [TokenAuthentication]
    permission_classes = [IsAuthenticated]

    def get(self, request, format=None):
        content = {
            'status': 'request was permitted'
        }
        return Response(content)

这段代码中，我们使用 `TokenAuthentication` 作为认证类，并使用 `IsAuthenticated` 权限类。这样，只有在认证成功时，才会允许请求通过。

希望这能帮到你!

### 回答2：
当然可以帮你写一个基于token认证的DRF（Django Rest Framework）的认证代码。首先，确保你已经在Django的MIDDLEWARE设置中添加了以下中间件：

MIDDLEWARE = [
    ...
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    ...
]

然后，在你的项目的设置文件（settings.py）中，添加REST_FRAMEWORK的配置项：

REST_FRAMEWORK = {
    'DEFAULT_AUTHENTICATION_CLASSES': [
        'rest_framework.authentication.TokenAuthentication',
    ],
}

接下来，创建一个自定义的认证类，用于处理token认证逻辑。在你的应用的认证文件（auth.py）里面，添加如下代码：

from rest_framework.authentication import TokenAuthentication
from rest_framework import exceptions

class CustomTokenAuthentication(TokenAuthentication):
    def authenticate_credentials(self, key):
        model = self.get_model()
        try:
            token = model.objects.get(key=key)
        except model.DoesNotExist:
            raise exceptions.AuthenticationFailed('Invalid token')

        if not token.user.is_active:
            raise exceptions.AuthenticationFailed('User inactive or deleted')

        return (token.user, token)

然后，在你的视图文件（views.py）中，使用这个自定义的认证类进行认证：

from rest_framework.views import APIView
from rest_framework.authentication import SessionAuthentication
from .auth import CustomTokenAuthentication

class ExampleView(APIView):
    authentication_classes = [CustomTokenAuthentication, SessionAuthentication]

    def get(self, request, format=None):
        # 处理GET请求的逻辑
        ...

这样，你的DRF视图就使用了基于token认证的自定义认证类了。

注意，你还需要在数据库中创建Token模型，并在每次用户登录或注册时生成一个唯一的token，并将其保存在数据库中。另外，需要为每个用户关联一个token。

### 回答3：
当然可以帮您编写一个基于Token认证的Django REST framework（DRF）的认证代码。

首先，您需要在DRF的设置文件中启用Token认证。在settings.py中添加以下内容：

REST_FRAMEWORK = {
    'DEFAULT_AUTHENTICATION_CLASSES': [
        'rest_framework.authentication.TokenAuthentication',
    ],
}

接下来，您需要创建一个用于Token认证的自定义视图。在您的views.py文件中添加以下代码：

from rest_framework.authtoken.views import ObtainAuthToken
from rest_framework.authtoken.models import Token
from rest_framework.response import Response

class CustomAuthToken(ObtainAuthToken):
    def post(self, request, *args, **kwargs):
        serializer = self.serializer_class(data=request.data, context={'request': request})
        serializer.is_valid(raise_exception=True)
        user = serializer.validated_data['user']
        token, created = Token.objects.get_or_create(user=user)
        return Response({'token': token.key})

这个自定义视图继承自DRF自带的ObtainAuthToken视图，并覆写了post方法。在post方法中，我们验证用户的凭证，然后获取或创建对应的Token，并返回给用户。

最后，您需要将自定义视图添加到URL路由中。在您的urls.py文件中添加以下代码：

from .views import CustomAuthToken

urlpatterns = [
    # ...其他URL配置...
    path('api/token-auth/', CustomAuthToken.as_view(), name='token_auth'),
]

配置完以上代码后，您可以向`/api/token-auth/` URL发送POST请求，包含正确的用户名和密码，即可获得Token作为响应。

以上就是一个基于Token认证的DRF认证代码的示例。您可以根据自己的项目需求进行调整和扩展。希望能够帮到您！

websocket配合spring-security使用token认证

可以通过在Spring Security中配置一个Token认证过滤器来实现基于WebSocket的Token认证。具体步骤如下：

1. 创建一个TokenAuthenticationFilter类，继承自OncePerRequestFilter并实现doFilterInternal方法。该类负责检查请求中是否包含有效的Token，并进行相应的认证处理。

public class TokenAuthenticationFilter extends OncePerRequestFilter {

    private final TokenProvider tokenProvider;

    public TokenAuthenticationFilter(TokenProvider tokenProvider) {
        this.tokenProvider = tokenProvider;
    }

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
        String token = getTokenFromRequest(request);
        if (StringUtils.hasText(token) && tokenProvider.validateToken(token)) {
            Authentication authentication = tokenProvider.getAuthentication(token);
            SecurityContextHolder.getContext().setAuthentication(authentication);
        }
        filterChain.doFilter(request, response);
    }

    private String getTokenFromRequest(HttpServletRequest request) {
        String bearerToken = request.getHeader("Authorization");
        if (StringUtils.hasText(bearerToken) && bearerToken.startsWith("Bearer ")) {
            return bearerToken.substring(7);
        }
        return null;
    }
}

2. 创建一个TokenProvider类，用于生成Token和验证Token的有效性，并根据Token获取用户信息。

@Component
public class TokenProvider {

    private static final String SECRET_KEY = "my-secret-key";

    private static final long EXPIRATION_TIME = 86400000; // 1 day

    public String generateToken(Authentication authentication) {
        UserPrincipal principal = (UserPrincipal) authentication.getPrincipal();
        Date expirationDate = new Date(System.currentTimeMillis() + EXPIRATION_TIME);
        return Jwts.builder()
                .setSubject(Long.toString(principal.getId()))
                .setIssuedAt(new Date())
                .setExpiration(expirationDate)
                .signWith(SignatureAlgorithm.HS512, SECRET_KEY)
                .compact();
    }

    public boolean validateToken(String token) {
        try {
            Jwts.parser().setSigningKey(SECRET_KEY).parseClaimsJws(token);
            return true;
        } catch (Exception e) {
            return false;
        }
    }

    public Authentication getAuthentication(String token) {
        Claims claims = Jwts.parser().setSigningKey(SECRET_KEY).parseClaimsJws(token).getBody();
        Long userId = Long.parseLong(claims.getSubject());
        UserPrincipal principal = new UserPrincipal(userId);
        return new UsernamePasswordAuthenticationToken(principal, "", principal.getAuthorities());
    }
}

3. 在配置类中注册TokenAuthenticationFilter和TokenProvider，并将TokenAuthenticationFilter添加到Spring Security的过滤器链中。

@Configuration
@EnableWebSocketMessageBroker
public class WebSocketConfig implements WebSocketMessageBrokerConfigurer {

    @Autowired
    private TokenProvider tokenProvider;

    @Override
    public void configureMessageBroker(MessageBrokerRegistry config) {
        config.enableSimpleBroker("/topic");
        config.setApplicationDestinationPrefixes("/app");
    }

    @Override
    public void registerStompEndpoints(StompEndpointRegistry registry) {
        registry.addEndpoint("/ws").setAllowedOriginPatterns("*").withSockJS();
    }

    @Override
    public void configureClientInboundChannel(ChannelRegistration registration) {
        registration.interceptors(new ChannelInterceptorAdapter() {
            @Override
            public Message<?> preSend(Message<?> message, MessageChannel channel) {
                StompHeaderAccessor accessor = MessageHeaderAccessor.getAccessor(message, StompHeaderAccessor.class);
                if (StompCommand.CONNECT.equals(accessor.getCommand())) {
                    String token = accessor.getFirstNativeHeader("Authorization");
                    if (StringUtils.hasText(token) && token.startsWith("Bearer ")) {
                        token = token.substring(7);
                        TokenAuthenticationFilter filter = new TokenAuthenticationFilter(tokenProvider);
                        SecurityContextHolder.getContext().setAuthentication(filter.getAuthentication(token));
                    }
                }
                return message;
            }
        });
    }

    @Override
    public void configureClientOutboundChannel(ChannelRegistration registration) {
    }

    @Override
    public void addArgumentResolvers(List<HandlerMethodArgumentResolver> argumentResolvers) {
    }

    @Override
    public void addReturnValueHandlers(List<HandlerMethodReturnValueHandler> returnValueHandlers) {
    }

    @Override
    public boolean configureMessageConverters(List<MessageConverter> messageConverters) {
        return true;
    }

    @Override
    public void configureWebSocketTransport(WebSocketTransportRegistration registry) {
    }

    @Bean
    public TokenAuthenticationFilter tokenAuthenticationFilter() throws Exception {
        TokenAuthenticationFilter filter = new TokenAuthenticationFilter(tokenProvider);
        filter.setAuthenticationManager(authenticationManager());
        return filter;
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.csrf().disable().authorizeRequests()
                .antMatchers("/api/auth/**").permitAll()
                .anyRequest().authenticated();
    }

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.userDetailsService(userDetailsService())
                .passwordEncoder(passwordEncoder());
    }

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

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

    @Override
    @Bean
    public UserDetailsService userDetailsService() {
        return new UserDetailsServiceImpl();
    }

}

在上述代码中，我们通过重写configureClientInboundChannel方法，在连接到WebSocket时获取请求中的Token，并使用TokenAuthenticationFilter进行认证。注意，我们需要将TokenAuthenticationFilter添加到Spring Security的过滤器链中，以便它能够在WebSocket连接期间对请求进行拦截。

最后，我们需要在客户端的连接请求中添加Authorization头部，以便在服务端进行Token认证。例如：

stompClient.connect({},
    function(frame) {
        console.log('Connected: ' + frame);
        stompClient.subscribe('/topic/greetings', function(greeting) {
            showGreeting(JSON.parse(greeting.body).content);
        });
    },
    function(error) {
        console.log('Error: ' + error);
    },
    {"Authorization": "Bearer " + token});