java 两个Date 相减获取到秒的差值

qq_33192454

于 2024-07-18 17:24:45 发布

阅读量346

点赞数 8

文章标签： java 开发语言

本文链接：https://blog.csdn.net/qq_33192454/article/details/140515059

版权

在 Java 中，你可以通过减去两个 Date 对象来获取它们之间的差值，以秒为单位。以下是一个示例代码，演示如何实现这一点：

解释

import java.util.Date;
import java.util.concurrent.TimeUnit;

public class DateDifference {
    public static void main(String[] args) {
        // 创建两个 Date 对象
        Date startDate = new Date();
        
        // 模拟一些处理时间，例如等待3秒
        try {
            Thread.sleep(3000); // 等待3秒
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        Date endDate = new Date();

        // 计算两个日期之间的毫秒差值
        long differenceInMilliSeconds = endDate.getTime() - startDate.getTime();

        // 将毫秒差值转换为秒
        long differenceInSeconds = TimeUnit.MILLISECONDS.toSeconds(differenceInMilliSeconds);

        // 输出结果
        System.out.println("Difference in seconds: " + differenceInSeconds);
    }
}

创建 Date 对象:
- startDate 和 endDate 分别表示开始时间和结束时间。
模拟处理时间:
- 使用 Thread.sleep(3000) 模拟一些处理时间，等待3秒钟。
计算毫秒差值:
- endDate.getTime() - startDate.getTime() 计算两个日期对象之间的毫秒差值。
将毫秒差值转换为秒:
- 使用 TimeUnit.MILLISECONDS.toSeconds(differenceInMilliSeconds) 将毫秒差值转换为秒。
输出结果:
- 打印两个日期之间的秒差值。

注意

Thread.sleep(3000) 用于模拟处理时间，实际应用中应根据具体需求来计算时间差。
TimeUnit 类提供了将时间单位之间进行转换的便捷方法，例如从毫秒转换为秒。

通过这种方法，你可以轻松地计算两个 Date 对象之间的秒差值。

oauth2 是否有提供退出的暴露端口，就是类使用 /oauth/token 这样的i恶口

OAuth2 本身的规范并没有定义一个标准的“退出”或“注销”端点。然而，许多实现和扩展通常会提供这样的功能。以下是一些常见的实现方式：

1. 使用自定义的注销端点

你可以创建一个自定义的注销端点来处理注销请求。这通常包括无效化当前的访问令牌和刷新令牌，确保用户会话的终止。

示例实现：

首先，确保在你的项目中有以下依赖：

xml<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-security</artifactId> </dependency> <dependency> <groupId>org.springframework.security.oauth</groupId> <artifactId>spring-security-oauth2</artifactId> </dependency>

然后，创建一个控制器来处理注销请求：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.oauth2.provider.token.ConsumerTokenServices;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import javax.servlet.http.HttpServletRequest;

@RestController
public class LogoutController {

    @Autowired
    private ConsumerTokenServices tokenServices;

    @PostMapping("/oauth/logout")
    public String logout(@RequestParam("token") String accessToken, HttpServletRequest request) {
        if (tokenServices.revokeToken(accessToken)) {
            return "Logout successful";
        } else {
            return "Logout failed";
        }
    }
}

2. 配置 `ConsumerTokenServices`

确保 ConsumerTokenServices 被正确配置，用于管理令牌。

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.oauth2.provider.token.DefaultTokenServices;
import org.springframework.security.oauth2.provider.token.TokenStore;

@Configuration
public class OAuth2Config {

    @Autowired
    private TokenStore tokenStore;

    @Bean
    public DefaultTokenServices tokenServices() {
        DefaultTokenServices defaultTokenServices = new DefaultTokenServices();
        defaultTokenServices.setTokenStore(tokenStore);
        defaultTokenServices.setSupportRefreshToken(true);
        return defaultTokenServices;
    }
}

3. 使用 `TokenStore` 直接无效化令牌

在一些情况下，你可能需要直接操作 TokenStore 来无效化令牌。以下是如何在注销端点中使用 TokenStore 来删除令牌：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.oauth2.provider.token.TokenStore;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import javax.servlet.http.HttpServletRequest;

@RestController
public class LogoutController {

    @Autowired
    private TokenStore tokenStore;

    @PostMapping("/oauth/logout")
    public String logout(@RequestParam("token") String accessToken, HttpServletRequest request) {
        OAuth2AccessToken token = tokenStore.readAccessToken(accessToken);
        if (token != null) {
            tokenStore.removeAccessToken(token);
            return "Logout successful";
        } else {
            return "Logout failed";
        }
    }
}

总结

虽然 OAuth2 规范本身没有定义一个标准的注销端点，但通过自定义实现，你可以有效地处理用户的注销请求。上述示例展示了如何通过 Spring Security OAuth2 配置一个自定义的注销端点。这个端点接受一个访问令牌，并将其从存储中移除，以完成注销操作。

oauth2 中的 /oauth/access_token 是做什么用的啊

在 OAuth2 中，/oauth/token（或 /oauth/access_token，但 /oauth/token 更常见）端点用于获取和刷新访问令牌（Access Tokens）。这是授权服务器暴露出来的一个端点，用于客户端应用程序获取访问资源服务器所需的令牌。

主要用途

获取访问令牌：
- 客户端使用各种授权授权方式（例如授权码授权、密码授权、客户端凭据授权或刷新令牌授权）向 /oauth/token 端点请求访问令牌。
刷新访问令牌：
- 当访问令牌过期时，客户端可以使用刷新令牌（Refresh Token）来请求新的访问令牌，而不需要再次向用户请求授权。

请求流程

1. 使用授权码获取访问令牌

假设客户端已经从授权服务器获得了授权码，接下来它需要向 /oauth/token 端点发送请求来获取访问令牌：

请求示例：

POST /oauth/token HTTP/1.1
Host: authorization-server.com
Authorization: Basic base64(client_id:client_secret)
Content-Type: application/x-www-form-urlencoded

grant_type=authorization_code&code=AUTHORIZATION_CODE&redirect_uri=REDIRECT_URI

参数：

grant_type：授权类型（这里是 authorization_code）。
code：授权码。
redirect_uri：与授权码请求中使用的重定向 URI 相同。

响应示例：

json

{
  "access_token": "ACCESS_TOKEN",
  "token_type": "bearer",
  "expires_in": 3600,
  "refresh_token": "REFRESH_TOKEN",
  "scope": "read write"
}

2. 使用刷新令牌获取新的访问令牌

当访问令牌即将过期时，客户端可以使用刷新令牌来获取新的访问令牌：

请求示例：

http

POST /oauth/token HTTP/1.1
Host: authorization-server.com
Authorization: Basic base64(client_id:client_secret)
Content-Type: application/x-www-form-urlencoded

grant_type=refresh_token&refresh_token=REFRESH_TOKEN

参数：

grant_type：授权类型（这里是 refresh_token）。
refresh_token：上一次获取到的刷新令牌。

响应示例：

{
  "access_token": "NEW_ACCESS_TOKEN",
  "token_type": "bearer",
  "expires_in": 3600,
  "refresh_token": "NEW_REFRESH_TOKEN",
  "scope": "read write"
}

json

使用 Spring Security OAuth2 的 `/oauth/token` 端点

在 Spring Security OAuth2 中，/oauth/token 端点由 TokenEndpoint 类处理，该类位于 org.springframework.security.oauth2.provider.endpoint 包中。

示例配置

如果你需要配置授权服务器并定义 /oauth/token 端点，可以使用以下示例：

import org.springframework.context.annotation.Configuration;
import org.springframework.security.oauth2.config.annotation.configurers.ClientDetailsServiceConfigurer;
import org.springframework.security.oauth2.config.annotation.web.configuration.AuthorizationServerConfigurerAdapter;
import org.springframework.security.oauth2.config.annotation.web.configuration.EnableAuthorizationServer;
import org.springframework.security.oauth2.config.annotation.web.configurers.AuthorizationServerEndpointsConfigurer;
import org.springframework.security.oauth2.config.annotation.web.configurers.AuthorizationServerSecurityConfigurer;

@Configuration
@EnableAuthorizationServer
public class OAuth2AuthorizationServerConfig extends AuthorizationServerConfigurerAdapter {

    @Override
    public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
        clients.inMemory()
                .withClient("client_id")
                .secret("client_secret")
                .authorizedGrantTypes("authorization_code", "refresh_token", "password", "client_credentials")
                .scopes("read", "write")
                .redirectUris("http://localhost:8080/callback");
    }

    @Override
    public void configure(AuthorizationServerEndpointsConfigurer endpoints) throws Exception {
        // 配置token存储, token服务, 授权模式等
    }

    @Override
    public void configure(AuthorizationServerSecurityConfigurer security) throws Exception {
        security.tokenKeyAccess("permitAll()")
                .checkTokenAccess("isAuthenticated()");
    }
}

这个配置定义了客户端如何与授权服务器进行交互，尤其是如何使用 /oauth/token 端点来获取和刷新访问令牌。

Is there an unresolvable circular reference 导入 feign 接口的时候报错

在使用 Spring Cloud Feign（OpenFeign）时，如果你遇到 "Is there an unresolvable circular reference" 错误，这通常是由于两个或多个 Spring beans 互相依赖，导致 Spring 容器无法完成 bean 的初始化。

常见原因和解决办法

Circular Dependency：
- 你可能在应用程序中有两个或多个 bean 互相依赖，直接或间接导致循环依赖。
Improper Bean Configuration：
- 检查是否有不正确的配置导致 FeignClient 与其他组件之间的循环依赖。

解决办法

1. 使用 `@Lazy` 延迟初始化

如果一个 bean 不需要立即初始化，可以使用 @Lazy 注解来延迟初始化。

import org.springframework.context.annotation.Lazy;

@Service
public class MyService {
    
    private final AnotherService anotherService;

    @Autowired
    public MyService(@Lazy AnotherService anotherService) {
        this.anotherService = anotherService;
    }
}

2. 使用构造函数注入

构造函数注入在编译期就能发现循环依赖的问题，有助于你更早地发现和解决循环依赖。

@Service
public class MyService {

    private final AnotherService anotherService;

    @Autowired
    public MyService(AnotherService anotherService) {
        this.anotherService = anotherService;
    }
}

3. 重新设计依赖关系

重新审视和设计你的依赖关系，尽量避免循环依赖。可能需要拆分某些功能或者引入中间层来打破循环依赖。

4. 检查 FeignClient 配置

确保 FeignClient 的配置没有引起循环依赖。例如，不要让 FeignClient 和其调用的服务在同一个类中定义。

5. 使用 `@Qualifier` 和 `@Primary`

有时候可以使用 @Qualifier 和 @Primary 注解来解决特定的依赖注入问题。

@Bean
@Primary
public MyService myService() {
    return new MyServiceImpl();
}

示例

假设你有一个 FeignClient 和两个服务，它们之间存在循环依赖。

@FeignClient(name = "myFeignClient", url = "http://example.com")
public interface MyFeignClient {
    @GetMapping("/endpoint")
    String callEndpoint();
}

@Service
public class ServiceA {

    private final ServiceB serviceB;

    @Autowired
    public ServiceA(ServiceB serviceB) {
        this.serviceB = serviceB;
    }

    public void methodA() {
        serviceB.methodB();
    }
}

@Service
public class ServiceB {

    private final MyFeignClient myFeignClient;
    private final ServiceA serviceA;

    @Autowired
    public ServiceB(MyFeignClient myFeignClient, @Lazy ServiceA serviceA) {
        this.myFeignClient = myFeignClient;
        this.serviceA = serviceA;
    }

    public void methodB() {
        serviceA.methodA();
    }
}

在这个示例中，ServiceB 中注入 ServiceA 时使用 @Lazy 注解，避免了循环依赖。

调试建议

检查堆栈跟踪：
- 仔细查看错误堆栈跟踪，找出具体的循环依赖路径。
逐步排查：
- 注释掉部分代码，逐步启用，找出具体引起循环依赖的部分。
日志和调试：
- 使用日志和调试工具进一步分析依赖关系和 Spring 容器的初始化过程。

通过上述方法，你应该能够解决 FeignClient 导致的循环依赖问题。如果问题仍然存在，请提供更多代码细节，我可以进一步帮助你调试。

qq_33192454

关注

8
点赞
踩
13

收藏

觉得还不错? 一键收藏
0
评论
java 两个Date 相减获取到秒的差值

你可以创建一个自定义的注销端点来处理注销请求。这通常包括无效化当前的访问令牌和刷新令牌，确保用户会话的终止。虽然 OAuth2 规范本身没有定义一个标准的注销端点，但通过自定义实现，你可以有效地处理用户的注销请求。上述示例展示了如何通过 Spring Security OAuth2 配置一个自定义的注销端点。这个端点接受一个访问令牌，并将其从存储中移除，以完成注销操作。oauth2 中的 /oauth/access_token 是做什么用的啊在 OAuth2 中，（或，但。
复制链接

扫一扫