4.2配置Spring Security

4.2配置Spring Security

多年来,有几种配置Spring Security的方法,包括冗长的基于xml的配置。幸运的是,Spring Security的几个最新版本都支持基于Java的配置,这种配置更容易读写。

在本章结束之前,已经在基于JavaSpring Security配置中配置了所有Taco Cloud安全需求。但是在开始之前,可以通过编写下面清单中所示的基本配置类来简化它。程序清单4.1一个基本的Spring Security配置类

package tacos.security;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
}

这个基本的安全配置做了什么?嗯,不是很多,但是它确实离需要的安全功能更近了一步。如果再次尝试访问Taco Cloud主页,仍然会提示需要登录。但是,将看到一个类似于图4.2的登录表单,而不是一个HTTP基本身份验证对话框提示。

![4.2 Spring Security提供了一个免费的普通登录页面](E:\Document\spring-in-action-v5-translate\第一部分Spring基础\第四章Spring安全\4.2 Spring Security提供了一个免费的普通登录页面.jpg)

4.2 Spring Security提供了一个免费的普通登录页面

提示:你可能会发现,在手动测试安全性时,将浏览器设置为privateincognito模式是很有用的。这将确保每次打开私人/隐身窗口时都有一个新的会话。必须每次都登录到应用程序,但是可以放心,你在安全性方面所做的任何更改都将被应用,并且旧session的任何残余都不会阻止你查看你的更改。

这是一个小小的改进 —— 使用web页面进行登录的提示(即使它在外观上相当简单)总是比HTTP基本对话框更友好。将在4.3.2节中自定义登录页面。然而,当前的任务是配置一个能够处理多个用户的用户存储。

事实证明,Spring Security为配置用户存储提供了几个选项,包括:

  • 一个内存用户存储

  • 基于JDBC的用户存储

  • LDAP支持的用户存储

  • 定制用户详细信息服务

无论选择哪个用户存储,都可以通过重写WebSecurityConfigurerAdapter配置基类中定义的configure()方法来配置它。首先,你需要在SecurityConfig类中添加以下方法:

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

现在,只需要使用使用给定AuthenticationManagerBuilder的代码来替换这些省略号,以指定在身份验证期间如何查找用户。首先,将尝试内存用户存储。

4.2.1内存用户存储

用户信息可以保存在内存中。假设只有少数几个用户,这些用户都不可能改变。在这种情况下,将这些用户定义为安全配置的一部分可能非常简单。

例如,下一个清单显示了如何在内存用户存储中配置两个用户 “buzz” 和 “woody”。程序清单4.2在内存用户存储中定义用户

@Override
protected void configure(AuthenticationManagerBuilder auth) throws Exception {
    auth
        .inMemoryAuthentication()
        	.withUser("buzz")
        		.password("infinity")
        		.authorities("ROLE_USER")
        	.and()
        	.withUser("woody")
        		.password("bullseye")
        		.authorities("ROLE_USER");
}

正如你所看到的,AuthenticationManagerBuilder使用构造器风格的API来配置身份验证细节。在这种情况下,对inMemoryAuthentication()方法的调用,可以直接在安全配置本身中指定用户信息。

withUser()的每个调用都会启动用户的配置。给withUser()的值是用户名,而密码和授予的权限是用password()authority()方法指定的。如程序清单4.2所示,两个用户都被授予ROLEUSER权限。用户 “buzz” 的密码被配置为 “_infinity"。同样“woody” 的密码是 “bullseye"。

内存中的用户存储应用于测试或非常简单的应用程序时非常方便,但是它不允许对用户进行简单的编辑。如果需要添加、删除或更改用户,则必须进行必要的更改,然后重新构建、部署应用程序。

对于Taco Cloud应用程序,由于内存中用户存储的闲置,因此希望客户能够注册应用程序并管理自己的用户帐户,这不能够实现。因此让我们看看另一个允许使用数据库支持的用户存储的选项。

4.2.2基于JDBC的用户存储

用户信息通常在关系数据库中维护,基于JDBC的用户存储似乎比较合适。下面的程序清单显示了如何配置Spring Security,并将用户信息通过JDBC保存在关系型数据库中,来进行身份认证。

@Autowired
DataSource dataSource;

@Override
protected void configure(AuthenticationManagerBuilder auth) throws Exception {
    auth
        .jdbcAuthentication()
        .dataSource(dataSource);
}

configure()的这个实现在给定的AuthenticationManagerBuilder上调用jdbcAuthentication()。然后,必须设置DataSource,以便它知道如何访问数据库。这里使用的数据源是由自动装配提供的。

重写默认用户查询

虽然这个最小配置可以工作,但它对数据库模式做了一些假设。它期望已经存在某些表,用户数据将保存在这些表中。更具体地说,以下来自Spring Security内部的代码片段显示了在查找用户详细信息时将执行的SQL查询:

public static final String DEF_USERS_BY_USERNAME_QUERY =
    "select username,password,enabled " +
    "from users " +
    "where username = ?";

public static final String DEF_AUTHORITIES_BY_USERNAME_QUERY =
    "select username,authority " +
    "from authorities " +
    "where username = ?";

public static final String DEF_GROUP_AUTHORITIES_BY_USERNAME_QUERY =
    "select g.id, g.group_name, ga.authority " +
    "from groups g, group_members gm, group_authorities ga " +
    "where gm.username = ? " +
    "and g.id = ga.group_id " +
    "and g.id = gm.group_id";

第一个查询检索用户的用户名、密码以及是否启用它们,此信息用于对用户进行身份验证;下一个查询查询用户授予的权限,以进行授权;最后一个查询查询作为组的成员授予用户的权限。

如果可以在数据库中定义和填充满足这些查询的表,那么就没有什么其他要做的了。但是,数据库很可能不是这样的,需要对查询进行更多的控制。在这种情况下,可以配置自己的查询。程序清单4.4自定义用户详情查询

@Override
protected void configure(AuthenticationManagerBuilder auth) throws Exception {
    auth
        .jdbcAuthentication()
        	.dataSource(dataSource)
        	.usersByUsernameQuery(
        		"select username, password, enabled from Users " +
        		"where username=?")
        	.authoritiesByUsernameQuery(
        		"select username, authority from UserAuthorities " +
        		"where username=?");
}

在本例中,仅重写了身份验证和基本授权查询,也可以通过使用自定义查询调用groupAuthoritiesByUsername()来重写组权限查询。

在将默认SQL查询替换为自己设计的查询时,一定要遵守查询的基本约定。它们都以用户名作为唯一参数。身份验证查询选择用户名、密码和启用状态;授权查询选择包含用户名和授予的权限的零个或多个行的数据;组权限查询选择零个或多个行数据,每个行有一个group id、一个组名和一个权限。

使用编码密码

以身份验证查询为重点,可以看到用户密码应该存储在数据库中。唯一的问题是,如果密码以纯文本形式存储,就会受到黑客的窥探。但是如果在数据库中对密码进行编码,身份验证将失败,因为它与用户提交的明文密码不匹配。

为了解决这个问题,你需要通过调用passwordEncoder()方法指定一个密码编码器:

@Override
protected void configure(AuthenticationManagerBuilder auth) throws Exception {
    auth
        .jdbcAuthentication()
        	.dataSource(dataSource)
        	.usersByUsernameQuery(
        		"select username, password, enabled from Users " +
        		"where username=?")
        	.authoritiesByUsernameQuery(
        		"select username, authority from UserAuthorities " +
        		"where username=?")
        	.passwordEncoder(new StandardPasswordEncoder("53cr3t");
}

passwordEncoder()方法接受Spring SecuritypasswordEncoder接口的任何实现。Spring Security的加密模块包括几个这样的实现:

  • BCryptPasswordEncoder —— 采用bcrypt强哈希加密
  • NoOpPasswordEncoder —— 不应用任何编码
  • Pbkdf2PasswordEncoder —— 应用PBKDF2加密
  • SCryptPasswordEncoder —— 应用了scrypt散列加密
  • StandardPasswordEncoder —— 应用SHA-256散列加密

上述代码使用了StandardPasswordEncoder。但是,如果没有现成的实现满足你的需求,你可以选择任何其他实现,甚至可以提供你自己的自定义实现。PasswordEncoder接口相当简单:

public interface PasswordEncoder {
    String encode(CharSequence rawPassword);
    boolean matches(CharSequence rawPassword, String encodedPassword);
}

无论使用哪种密码编码器,重要的是要理解数据库中的密码永远不会被解码。相反,用户在登录时输入的密码使用相同的算法进行编码,然后将其与数据库中编码的密码进行比较。比较是在PasswordEncodermatches()方法中执行的。

最后,将在数据库中维护Taco Cloud用户数据。但是,我没有使用jdbcAuthentication(),而是想到了另一个身份验证选项。但在此之前,让我们先看看如何配置Spring Security以依赖于另一个常见的用户数据源:使用LDAP(轻量级目录访问协议)接入的用户存储。

4.2.3 LDAP支持的用户存储

要为基于LDAP的身份验证配置Spring Security,可以使用ldapAuthentication()方法。这个方法与jdbcAuthentication()类似。下面的configure()方法显示了用于LDAP身份验证的简单配置:

@Override
protected void configure(AuthenticationManagerBuilder auth) throws Exception {
    auth
        .ldapAuthentication()
        	.userSearchFilter("(uid={0})")
        	.groupSearchFilter("member={0}");
}

userSearchFilter()groupSearchFilter()方法用于为基本LDAP查询提供过滤器,这些查询用于搜索用户和组。默认情况下,用户和组的基本查询都是空的,这表示将从LDAP层次结构的根目录进行搜索。但你可以通过指定一个查询基数来改变这种情况:

@Override
protected void configure(AuthenticationManagerBuilder auth) throws Exception {
    auth
        .ldapAuthentication()
        	.userSearchBase("ou=people")
        	.userSearchFilter("(uid={0})")
        	.groupSearchBase("ou=groups")
        	.groupSearchFilter("member={0}");
}

userSearchBase()方法提供了查找用户的基本查询。同样,groupSearchBase()方法指定查找组的基本查询。这个示例不是从根目录进行搜索,而是指定要搜索用户所在的组织单元是people,组应该搜索组织单元所在的group

配置密码比较

针对LDAP进行身份验证的默认策略是执行绑定操作,将用户通过LDAP服务器直接进行验证。另一种选择是执行比较操作,这包括将输入的密码发送到LDAP目录,并要求服务器将密码与用户的密码属性进行比较。因为比较是在LDAP服务器中进行的,所以实际的密码是保密的。

如果希望通过密码比较进行身份验证,可以使用passwordCompare()方法进行声明:

@Override
protected void configure(AuthenticationManagerBuilder auth) throws Exception {
    auth
        .ldapAuthentication()
        	.userSearchBase("ou=people")
        	.userSearchFilter("(uid={0})")
        	.groupSearchBase("ou=groups")
        	.groupSearchFilter("member={0}")
        	.passwordCompare();
}

默认情况下,登录表单中给出的密码将与用户LDAP条目中的userPassword属性值进行比较。如果密码保存在不同的属性中,可以使用passwordAttribute()指定密码属性的名称:

@Override
protected void configure(AuthenticationManagerBuilder auth) throws Exception {
    auth
        .ldapAuthentication()
        	.userSearchBase("ou=people")
        	.userSearchFilter("(uid={0})")
        	.groupSearchBase("ou=groups")
        	.groupSearchFilter("member={0}")
        	.passwordCompare()
        	.passwordEncoder(new BCryptPasswordEncoder())
        	.passwordAttribute("passcode");
}

在本例中,指定密码属性应该与给定的密码进行比较。此外,还可以指定密码编码器,在进行服务器端密码比较时,最好在服务器端对实际密码加密。但是尝试的密码仍然会通过网络传递到LDAP服务器,并且可能被黑客截获。为了防止这种情况,可以通过调用passwordEncoder()方法来指定加密策略。

在前面的示例中,使用bcrypt密码散列函数对密码进行加密,这里的前提是密码在LDAP服务器中也是使用bcrypt加密的。

引用远程LDAP服务器

到目前为止,我们忽略了LDAP服务器和数据实际驻留的位置,虽然已经将Spring配置为根据LDAP服务器进行身份验证,但是该服务器在哪里呢?

默认情况下,Spring SecurityLDAP身份验证假设LDAP服务器正在本地主机上监听端口33389。但是,如果LDAP服务器位于另一台机器上,则可以使用contextSource()方法来配置位置:

@Override
protected void configure(AuthenticationManagerBuilder auth) throws Exception {
    auth
        .ldapAuthentication()
        	.userSearchBase("ou=people")
        	.userSearchFilter("(uid={0})")
        	.groupSearchBase("ou=groups")
        	.groupSearchFilter("member={0}")
        	.passwordCompare()
        	.passwordEncoder(new BCryptPasswordEncoder())
        	.passwordAttribute("passcode")
        	.contextSource()
        		.url("ldap://tacocloud.com:389/dc=tacocloud,dc=com");
}

contextSource()方法返回ContextSourceBuilder,其中提供了url()方法,它允许指定LDAP服务器的位置。

配置嵌入式LDAP服务器

如果没有LDAP服务器去做身份验证,Spring Security可提供一个嵌入式LDAP服务器。可以通过root()方法为嵌入式服务器指定根后缀,而不是将URL设置为远程LDAP服务器:

@Override
protected void configure(AuthenticationManagerBuilder auth) throws Exception {
    auth
        .ldapAuthentication()
        	.userSearchBase("ou=people")
        	.userSearchFilter("(uid={0})")
        	.groupSearchBase("ou=groups")
        	.groupSearchFilter("member={0}")
        	.passwordCompare()
        	.passwordEncoder(new BCryptPasswordEncoder())
        	.passwordAttribute("passcode")
        	.contextSource()
        		.root("dc=tacocloud,dc=com");
}

LDAP服务器启动时,它将尝试从类路径中找到的任何LDIF文件进行数据加载。LDIF(LDAP数据交换格式)是在纯文本文件中表示LDAP数据的标准方法,每个记录由一个或多个行组成,每个行包含一个name:value对,记录之间用空行分隔。

如果不希望Spring在类路径中寻找它能找到的LDIF文件,可以通过调用ldif()方法来更明确地知道加载的是哪个LDIF文件:

@Override
protected void configure(AuthenticationManagerBuilder auth) throws Exception {
    auth
        .ldapAuthentication()
        	.userSearchBase("ou=people")
        	.userSearchFilter("(uid={0})")
        	.groupSearchBase("ou=groups")
        	.groupSearchFilter("member={0}")
        	.passwordCompare()
        	.passwordEncoder(new BCryptPasswordEncoder())
        	.passwordAttribute("passcode")
        	.contextSource()
        		.root("dc=tacocloud,dc=com")
        		.ldif("classpath:users.ldif");
}

这里,特别要求LDAP服务器从位于根路径下的users.ldif文件中加载数据。如果你感兴趣,这里有一个LDIF文件,你可以使用它来加载内嵌LDAP服务器的用户数据:

dn: ou=groups,dc=tacocloud,dc=com
objectclass: top
objectclass: organizationalUnit
ou: groups
dn: ou=people,dc=tacocloud,dc=com
objectclass: top
objectclass: organizationalUnit
ou: people
dn: uid=buzz,ou=people,dc=tacocloud,dc=com
objectclass: top
objectclass: person
objectclass: organizationalPerson
objectclass: inetOrgPerson
cn: Buzz Lightyear
sn: Lightyear
uid: buzz
userPassword: password
dn: cn=tacocloud,ou=groups,dc=tacocloud,dc=com
objectclass: top
objectclass: groupOfNames
cn: tacocloud
member: uid=buzz,ou=people,dc=tacocloud,dc=com

Spring Security的内置用户存储非常方便,涵盖了一些常见的用例。但是Taco Cloud应用程序需要一些特殊的东西。当开箱即用的用户存储不能满足需求时,需要创建并配置一个定制的用户详细信息服务。

4.2.4自定义用户身份验证

在上一章中,决定了使用Spring Data JPA作为所有taco、配料和订单数据的持久化选项。因此,以同样的方式持久化用户数据是有意义的,这样做的话,数据最终将驻留在关系型数据库中,因此可以使用基于JDBC的身份验证。但是更好的方法是利用Spring Data存储库来存储用户。

不过,还是要先做重要的事情,让我们创建表示和持久存储用户信息的域对象和存储库接口。

Taco Cloud用户注册应用程序时,他们需要提供的不仅仅是用户名和密码。他们还会告诉你,他们的全名、地址和电话号码,这些信息可以用于各种目的,不限于重新填充订单(更不用说潜在的营销机会

为了捕获所有这些信息,将创建一个User类,如下所示。程序清单4.5定义用户实体

package tacos;

import java.util.Arrays;
import java.util.Collection;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.userdetails.UserDetails;
import lombok.AccessLevel;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.RequiredArgsConstructor;

@Entity
@Data
@NoArgsConstructor(access=AccessLevel.PRIVATE, force=true)
@RequiredArgsConstructor
public class User implements UserDetails {
    private static final long serialVersionUID = 1L;

    @Id
    @GeneratedValue(strategy=GenerationType.AUTO)
    private Long id;

    private final String username;
    private final String password;
    private final String fullname;
    private final String street;
    private final String city;
    private final String state;
    private final String zip;
    private final String phoneNumber;

    @Override
    public Collection<? extends GrantedAuthority> getAuthorities() {
        return Arrays.asList(new SimpleGrantedAuthority("ROLE_USER"));
    }

    @Override
    public boolean isAccountNonExpired() {
        return true;
    }

    @Override
    public boolean isAccountNonLocked() {
        return true;
    }

    @Override
    public boolean isCredentialsNonExpired() {
        return true;
    }

    @Override
    public boolean isEnabled() {
        return true;
    }
}

毫无疑问,你已经注意到User类比第3章中定义的任何其他实体都更加复杂。除了定义一些属性外,User还实现了来自Spring SecurityUserDetails接口。

UserDetails的实现将向框架提供一些基本的用户信息,比如授予用户什么权限以及用户的帐户是否启用。

getAuthorities()方法应该返回授予用户的权限集合。各种isXXXexpired()方法返回一个布尔值,指示用户的帐户是否已启用或过期。

对于User实体,getAuthorities()方法仅返回一个集合,该集合指示所有用户将被授予ROLE_USER权限。而且,至少现在,Taco Cloud还不需要禁用用户,所以所有的isXXXexpired()方法都返回true来表示用户处于活动状态。

定义了User实体后,现在可以定义存储库接口:

package tacos.data;
import org.springframework.data.repository.CrudRepository;
import tacos.User;

public interface UserRepository extends CrudRepository<User, Long> {
    User findByUsername(String username);
}

除了通过扩展CrudRepository提供的CRUD操作之外,UserRepository还定义了一个findByUsername()方法,将在用户详细信息服务中使用该方法根据用户名查找User

如第3章所述,Spring Data JPA将在运行时自动生成该接口的实现。因此,现在可以编写使用此存储库的自定义用户详细信息服务了。

创建用户详细信息服务

Spring SecurityUserDetailsService是一个相当简单的接口:

public interface UserDetailsService {
    UserDetails loadUserByUsername(String username)
        throws UsernameNotFoundException;
}

这个接口的实现是给定一个用户的用户名,期望返回一个UserDetails对象,如果给定的用户名没有显示任何结果,则抛出一个UsernameNotFoundException

由于User类实现了UserDetails,同时UserRepository提供了一个findByUsername()方法,因此它们非常适合在自定义UserDetailsService实现中使用。下面的程序清单显示了将在Taco Cloud应用程序中使用的用户详细信息服务。程序清单4.6定义用户详细信息服务

package tacos.security;

import org.springframework.beans.factory.annotation.Autowired;
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 tacos.User;
import tacos.data.UserRepository;

@Service
public class UserRepositoryUserDetailsService implements UserDetailsService {

    private UserRepository userRepo;

    @Autowired
    public UserRepositoryUserDetailsService(UserRepository userRepo) {
        this.userRepo = userRepo;
    }

    @Override
    public UserDetails loadUserByUsername(String username)
        throws UsernameNotFoundException {
        User user = userRepo.findByUsername(username);
        if (user != null) {
            return user;
        }

        throw new UsernameNotFoundException("User '" + username + "' not found");
    }
}

UserRepositoryUserDetailsService通过UserRepository实例的构造器进行注入。然后,在它的loadByUsername()方法中,它调用UserRepository中的findByUsername()方法去查找User

loadByUsername()方法只有一个简单的规则:不允许返回null。因此如果调用findByUsername()返回nullloadByUsername()将会抛出一个UsernameNotFoundExcepition。除此之外,被找到的User将会被返回。

你会注意到UserRepositoryUserDetailsService上有@Service注解。这是Spring的另一种构造型注释,它将该类标记为包含在Spring的组件扫描中,因此不需要显式地将该类声明为beanSpring将自动发现它并将其实例化为bean

但是,仍然需要使用Spring Security配置自定义用户详细信息服务。因此,将再次返回到configure()方法:

@Autowired
private UserDetailsService userDetailsService;

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

这次,只需调用userDetailsService()方法,将自动生成的userDetailsService实例传递给SecurityConfig

与基于JDBC的身份验证一样,也可以(而且应该)配置密码编码器,以便可以在数据库中对密码进行编码。为此,首先声明一个PasswordEncoder类型的bean,然后通过调用PasswordEncoder()将其注入到用户详细信息服务配置中:

@Bean
public PasswordEncoder encoder() {
    return new StandardPasswordEncoder("53cr3t");
}

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

我们必须讨论configure()方法中的最后一行,它出现了调用encoder()方法并将其返回值传递给passwordEncoder()。但实际上,因为encoder()方法是用@Bean注释的,所以它将被用于在Spring应用程序上下文中声明一个PasswordEncoder bean,然后拦截对encoder()的任何调用,以从应用程序上下文中返回bean实例。

既然已经有了一个通过JPA存储库读取用户信息的自定义用户详细信息服务,那么首先需要的就是一种让用户进入数据库的方法。需要为Taco Cloud用户创建一个注册页面,以便注册该应用程序。

用户注册

尽管Spring Security处理安全性的很多方面,但它实际上并不直接涉及用户注册过程,因此将依赖于Spring MVC来处理该任务。下面程序清单中的RegistrationController类展示并处理注册表单。程序清单4.7用户注册控制器

package tacos.security;

import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import tacos.data.UserRepository;

@Controller
@RequestMapping("/register")
public class RegistrationController {

    private UserRepository userRepo;
    private PasswordEncoder passwordEncoder;

    public RegistrationController(
        UserRepository userRepo, PasswordEncoder passwordEncoder) {
        this.userRepo = userRepo;
        this.passwordEncoder = passwordEncoder;
    }

    @GetMapping
    public String registerForm() {
        return "registration";
    }

    @PostMapping
    public String processRegistration(RegistrationForm form) {
        userRepo.save(form.toUser(passwordEncoder));
        return "redirect:/login";
    }
}

与任何典型的Spring MVC控制器一样,RegistrationController使用@Controller进行注解,以将其指定为控制器,并将其标记为组件扫描。它还使用@RequestMapping进行注解,以便处理路径为/register的请求。

更具体地说,registerForm()方法将处理/registerGET请求,它只返回注册的逻辑视图名。下面的程序清单显示了定义注册视图的Thymeleaf模板。程序清单4.8 Thymeleaf注册表单视图

<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml" xmlns:th="http://www.thymeleaf.org">
  <head>
    <title>Taco Cloud</title>
  </head>

  <body>
    <h1>Register</h1>
    <img th:src="@{/images/TacoCloud.png}" />

    <form method="POST" th:action="@{/register}" id="registerForm">
      <label for="username">Username: </label>
      <input type="text" name="username" /><br />

      <label for="password">Password: </label>
      <input type="password" name="password" /><br />

      <label for="confirm">Confirm password: </label>
      <input type="password" name="confirm" /><br />

      <label for="fullname">Full name: </label>
      <input type="text" name="fullname" /><br />

      <label for="street">Street: </label>
      <input type="text" name="street" /><br />

      <label for="city">City: </label>
      <input type="text" name="city" /><br />

      <label for="state">State: </label>
      <input type="text" name="state" /><br />

      <label for="zip">Zip: </label>
      <input type="text" name="zip" /><br />

      <label for="phone">Phone: </label>
      <input type="text" name="phone" /><br />

      <input type="submit" value="Register" />
    </form>
  </body>
</html>

提交表单时,HTTP POST请求将由processRegistration()方法处理。processRegistration()RegistrationForm对象绑定到请求数据,并使用以下类定义:

package tacos.security;

import org.springframework.security.crypto.password.PasswordEncoder;
import lombok.Data;
import tacos.User;

@Data
public class RegistrationForm {

    private String username;
    private String password;
    private String fullname;
    private String street;
    private String city;
    private String state;
    private String zip;
    private String phone;

    public User toUser(PasswordEncoder passwordEncoder) {
        return new User(
            username, passwordEncoder.encode(password),
            fullname, street, city, state, zip, phone);
    }
}

在大多数情况下,RegistrationForm只是一个支持Lombok的基本类,只有少量属性。但是toUser()方法使用这些属性创建一个新的User对象,processRegistration()将使用注入的UserRepository保存这个对象。

毫无疑问,RegistrationController被注入了一个密码编码器。这与之前声明的PasswordEncoder bean完全相同。在处理表单提交时,RegistrationController将其传递给toUser()方法,该方法使用它对密码进行编码,然后将其保存到数据库。通过这种方式,提交的密码以编码的形式写入,用户详细信息服务将能够根据编码的密码进行身份验证。

现在Taco Cloud应用程序拥有完整的用户注册和身份验证支持。但是如果在此时启动它,你会注意到,如果不是提示你登录,你甚至无法进入注册页面。这是因为,默认情况下,所有请求都需要身份验证。让我们看看web请求是如何被拦截和保护的,以便可以修复这种奇怪的先有鸡还是先有蛋的情况。

上一页
下一页