java - 使用 Spring Security 时，在 bean 中获取当前用户名（即 SecurityContext）信息的正确方法是什么？

Question

我有一个使用 Spring Security 的 Spring MVC Web 应用程序。我想知道当前登录用户的用户名。我正在使用下面给出的代码片段。这是公认的方式吗？

我不喜欢在这个控制器中调用静态方法——这违背了 Spring 的全部目的，恕我直言。有没有办法将应用程序配置为注入当前的 SecurityContext 或当前的身份验证？

  @RequestMapping(method = RequestMethod.GET)
  public ModelAndView showResults(final HttpServletRequest request...) {
    final String currentUser = SecurityContextHolder.getContext().getAuthentication().getName();
    ...
  }

score 270 · Accepted Answer

如果您使用的是Spring 3，最简单的方法是：

 @RequestMapping(method = RequestMethod.GET)   
 public ModelAndView showResults(final HttpServletRequest request, Principal principal) {

     final String currentUser = principal.getName();

 }

score 71 · Accepted Answer

自从回答了这个问题以来，Spring 世界发生了很多变化。Spring 简化了在控制器中获取当前用户的过程。对于其他bean，Spring采纳了作者的建议，简化了'SecurityContextHolder'的注入。更多细节在评论中。

这是我最终采用的解决方案。我不想在我的控制器中使用SecurityContextHolder，而是想注入一些SecurityContextHolder在引擎盖下使用但从我的代码中抽象出类似单例的类的东西。除了滚动我自己的界面之外，我发现没有其他方法可以做到这一点，如下所示：

public interface SecurityContextFacade {

  SecurityContext getContext();

  void setContext(SecurityContext securityContext);

}

现在，我的控制器（或任何 POJO）将如下所示：

public class FooController {

  private final SecurityContextFacade securityContextFacade;

  public FooController(SecurityContextFacade securityContextFacade) {
    this.securityContextFacade = securityContextFacade;
  }

  public void doSomething(){
    SecurityContext context = securityContextFacade.getContext();
    // do something w/ context
  }

}

而且，由于接口是解耦点，单元测试很简单。在此示例中，我使用 Mockito：

public class FooControllerTest {

  private FooController controller;
  private SecurityContextFacade mockSecurityContextFacade;
  private SecurityContext mockSecurityContext;

  @Before
  public void setUp() throws Exception {
    mockSecurityContextFacade = mock(SecurityContextFacade.class);
    mockSecurityContext = mock(SecurityContext.class);
    stub(mockSecurityContextFacade.getContext()).toReturn(mockSecurityContext);
    controller = new FooController(mockSecurityContextFacade);
  }

  @Test
  public void testDoSomething() {
    controller.doSomething();
    verify(mockSecurityContextFacade).getContext();
  }

}

接口的默认实现如下所示：

public class SecurityContextHolderFacade implements SecurityContextFacade {

  public SecurityContext getContext() {
    return SecurityContextHolder.getContext();
  }

  public void setContext(SecurityContext securityContext) {
    SecurityContextHolder.setContext(securityContext);
  }

}

最后，生产 Spring 配置如下所示：

<bean id="myController" class="com.foo.FooController">
     ...
  <constructor-arg index="1">
    <bean class="com.foo.SecurityContextHolderFacade">
  </constructor-arg>
</bean>

看起来有点傻，Spring，一个所有东西的依赖注入容器，没有提供一种注入类似东西的方法。我知道SecurityContextHolder是从 acegi 继承的，但仍然如此。问题是，它们是如此接近——如果只有SecurityContextHolder一个 getter 来获取底层SecurityContextHolderStrategy实例（这是一个接口），你就可以注入它。事实上，我什至为此打开了一个 Jira 问题。

最后一件事 - 我刚刚大大改变了我之前在这里的答案。如果您好奇，请查看历史记录，但正如一位同事向我指出的那样，我之前的答案在多线程环境中不起作用。默认情况下，SecurityContextHolderStrategy使用的底层是的实例，它将s 存储在 a 中。因此，在初始化时直接将 bean 注入 bean 不一定是一个好主意-在多线程环境中，可能需要每次都从 bean 中检索它，因此检索到正确的。SecurityContextHolderThreadLocalSecurityContextHolderStrategySecurityContextThreadLocalSecurityContextThreadLocal

score 22 · Accepted Answer

我同意必须查询当前用户的 SecurityContext 很臭，这似乎是一种非常非 Spring 的方式来处理这个问题。

我写了一个静态的“助手”类来处理这个问题；这很脏，因为它是一种全局和静态方法，但我认为如果我们更改与安全性相关的任何内容，至少我只需要在一个地方更改细节：

/**
* Returns the domain User object for the currently logged in user, or null
* if no User is logged in.
* 
* @return User object for the currently logged in user, or null if no User
*         is logged in.
*/
public static User getCurrentUser() {

    Object principal = SecurityContextHolder.getContext().getAuthentication().getPrincipal()

    if (principal instanceof MyUserDetails) return ((MyUserDetails) principal).getUser();

    // principal object is either null or represents anonymous user -
    // neither of which our domain User object can represent - so return null
    return null;
}


/**
 * Utility method to determine if the current user is logged in /
 * authenticated.
 * <p>
 * Equivalent of calling:
 * <p>
 * <code>getCurrentUser() != null</code>
 * 
 * @return if user is logged in
 */
public static boolean isLoggedIn() {
    return getCurrentUser() != null;
}

score 22 · Accepted Answer

要使其仅显示在您的 JSP 页面中，您可以使用 Spring Security Tag Lib：

http://static.springsource.org/spring-security/site/docs/3.0.x/reference/taglibs.html

要使用任何标签，您必须在 JSP 中声明安全标签库：

<%@ taglib prefix="security" uri="http://www.springframework.org/security/tags" %>

然后在一个jsp页面中做这样的事情：

<security:authorize access="isAuthenticated()">
    logged in as <security:authentication property="principal.username" /> 
</security:authorize>

<security:authorize access="! isAuthenticated()">
    not logged in
</security:authorize>

注意：正如@SBerg413 评论中提到的，您需要添加

使用表达式=“真”

到 security.xml 配置中的“http”标签以使其正常工作。

score 16 · Accepted Answer

如果您使用的是 Spring Security ver >= 3.2，则可以使用@AuthenticationPrincipal注解：

@RequestMapping(method = RequestMethod.GET)
public ModelAndView showResults(@AuthenticationPrincipal CustomUser currentUser, HttpServletRequest request) {
    String currentUsername = currentUser.getUsername();
    // ...
}

在这里，CustomUser是一个自定义对象，它实现UserDetails了由 custom 返回UserDetailsService。

更多信息可以在Spring Security 参考文档的@AuthenticationPrincipal章节中找到。

score 13 · Accepted Answer

我通过 HttpServletRequest.getUserPrincipal(); 获得了经过身份验证的用户；

例子：

import javax.servlet.http.HttpServletRequest;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.web.authentication.preauth.RequestHeaderAuthenticationFilter;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.servlet.support.RequestContext;

import foo.Form;

@Controller
@RequestMapping(value="/welcome")
public class IndexController {

    @RequestMapping(method=RequestMethod.GET)
    public String getCreateForm(Model model, HttpServletRequest request) {

        if(request.getUserPrincipal() != null) {
            String loginName = request.getUserPrincipal().getName();
            System.out.println("loginName : " + loginName );
        }

        model.addAttribute("form", new Form());
        return "welcome";
    }
}

score 10 · Accepted Answer

在 Spring 3+ 中，您有以下选项。

选项1 ：

@RequestMapping(method = RequestMethod.GET)    
public String currentUserNameByPrincipal(Principal principal) {
    return principal.getName();
}

选项 2：

@RequestMapping(method = RequestMethod.GET)
public String currentUserNameByAuthentication(Authentication authentication) {
    return authentication.getName();
}

选项 3：

@RequestMapping(method = RequestMethod.GET)    
public String currentUserByHTTPRequest(HttpServletRequest request) {
    return request.getUserPrincipal().getName();

}

选项 4：花式一个：查看此以获取更多详细信息

public ModelAndView someRequestHandler(@ActiveUser User activeUser) {
  ...
}

score 6 · Accepted Answer

6

我会这样做：

request.getRemoteUser();

于 2010-04-01T19:44:15.950 回答

score 5 · Accepted Answer

是的，静态通常很糟糕 - 通常，但在这种情况下，静态是您可以编写的最安全的代码。由于安全上下文将 Principal 与当前运行的线程相关联，因此最安全的代码将尽可能直接地从线程访问静态。将访问隐藏在注入的包装类后面，为攻击者提供了更多攻击点。他们不需要访问代码（如果 jar 已签名，他们将很难更改代码），他们只需要一种覆盖配置的方法，这可以在运行时完成或将一些 XML 滑入类路径。即使在签名代码中使用注解注入也可以被外部 XML 覆盖。此类 XML 可能会向正在运行的系统注入恶意主体。

score 4 · Accepted Answer

对于我编写的最后一个 Spring MVC 应用程序，我没有注入 SecurityContext 持有者，但我确实有一个基本控制器，我有两个与此相关的实用方法... isAuthenticated() 和 getUsername()。在内部，他们执行您描述的静态方法调用。

至少，如果您以后需要重构，它只会出现一次。

score 4 · Accepted Answer

您可以使用 Spring AOP 方法。例如，如果您有一些服务，则需要知道当前的委托人。您可以引入自定义注释，即 @Principal ，这表明该服务应该依赖于主体。

public class SomeService {
    private String principal;
    @Principal
    public setPrincipal(String principal){
        this.principal=principal;
    }
}

然后在我认为需要扩展 MethodBeforeAdvice 的建议中，检查特定服务是否具有 @Principal 注释并注入 Principal 名称，或者将其设置为“ANONYMOUS”。

score 2 · Accepted Answer

唯一的问题是，即使在使用 Spring Security 进行身份验证后，容器中也不存在用户/主体 bean，因此依赖注入将很困难。在我们使用 Spring Security 之前，我们将创建一个具有当前 Principal 的会话范围 bean，将其注入到“AuthService”中，然后将该服务注入到应用程序中的大多数其他服务中。所以这些服务只需调用 authService.getCurrentUser() 来获取对象。如果您的代码中有一个位置可以在会话中获得对同一主体的引用，则可以简单地将其设置为会话范围 bean 上的属性。

score 2 · Accepted Answer

如果您使用 Spring 3 并且需要控制器中经过身份验证的主体，最好的解决方案是执行以下操作：

import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.userdetails.User;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;

    @Controller
    public class KnoteController {
        @RequestMapping(method = RequestMethod.GET)
        public java.lang.String list(Model uiModel, UsernamePasswordAuthenticationToken authToken) {

            if (authToken instanceof UsernamePasswordAuthenticationToken) {
                user = (User) authToken.getPrincipal();
            }
            ...

    }

score 1 · Accepted Answer

试试这个

身份验证身份验证 = SecurityContextHolder.getContext().getAuthentication();
String userName = authentication.getName();

score 1 · Accepted Answer

我@AuthenticationPrincipal在类和带注释的@Controller类中@ControllerAdvicer使用注释。前任。：

@ControllerAdvice
public class ControllerAdvicer
{
    private static final Logger LOGGER = LoggerFactory.getLogger(ControllerAdvicer.class);


    @ModelAttribute("userActive")
    public UserActive currentUser(@AuthenticationPrincipal UserActive currentUser)
    {
        return currentUser;
    }
}

我用于登录用户服务的类在哪里UserActive，并从org.springframework.security.core.userdetails.User. 就像是：

public class UserActive extends org.springframework.security.core.userdetails.User
{

    private final User user;

    public UserActive(User user)
    {
        super(user.getUsername(), user.getPasswordHash(), user.getGrantedAuthorities());
        this.user = user;
    }

     //More functions
}

真的很容易。

score 1 · Accepted Answer

在您的控制器方法中定义Principal为依赖项，spring 将在调用时将当前经过身份验证的用户注入您的方法中。

score -1 · Accepted Answer

我喜欢在 freemarker 页面上分享我支持用户详细信息的方式。一切都非常简单并且工作完美！

您只需在default-target-url（表单登录后的页面）上放置身份验证重新请求这是我对该页面的 Controler 方法：

@RequestMapping(value = "/monitoring", method = RequestMethod.GET)
public ModelAndView getMonitoringPage(Model model, final HttpServletRequest request) {
    showRequestLog("monitoring");


    Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
    String userName = authentication.getName();
    //create a new session
    HttpSession session = request.getSession(true);
    session.setAttribute("username", userName);

    return new ModelAndView(catalogPath + "monitoring");
}

这是我的 ftl 代码：

<@security.authorize ifAnyGranted="ROLE_ADMIN, ROLE_USER">
<p style="padding-right: 20px;">Logged in as ${username!"Anonymous" }</p>
</@security.authorize>

就是这样，用户名将在授权后出现在每个页面上。

java - 使用 Spring Security 时，在 bean 中获取当前用户名（即 SecurityContext）信息的正确方法是什么？

17 回答 17

Related

Reference