4.2 配置Spring Security

发表于 2021-10-13 分类于 Spring实战(第5版) ，第1部分 Spring基础，第4章保护Spring Waline：本文字数： 20k 阅读时长 ≈ 19 分钟

4.2 配置Spring Security

多年以来，出现了多种配置Spring Security的方式，包括冗长的基于XML的配置。幸运的是，最近几个版本的Spring Security都支持基于Java的配置，这种方式更加易于阅读和编写。

在本章结束之前，我们会使用基于Java的Spring Security配置完成Taco Cloud安全性需要的所有设置。但是，首先，我们需要编写程序清单4.1中这个基础的配置类。
程序清单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主页，那么系统依然会提示你进行登录。但是，现在不再是提示HTTP basic认证的对话框，而是会展现如图4.2所示的登录表单。

epub_29101559_31

图4.2 Spring Security为我们免费提供的简单登录页

提示：在进行手动安全测试的时候，你会发现将浏览器设置为私有或隐身模式会非常有用。这能够确保每次打开一个私有/隐身窗口都会有一个新的会话。每次你都需要重新登录应用，但是你尽可以放心，在安全性方面做得所有变更都会生效，旧会话不会有任何残留，妨碍我们看到变更的效果。

这是一个很小的改进，通过Web页面提示登录（尽管看上去非常简陋）要比HTTPbasic对话框更友好一些。在4.3.2小节，我们将会自定义登录页面。不过，我们现在的任务是配置用户存储，使系统能够处理多个用户。

事实上，Spring Security为配置用户存储提供了多个可选方案，包括：

基于内存的用户存储；
基于JDBC的用户存储；
以LDAP作为后端的用户存储；
自定义用户详情服务。

不管使用哪种用户存储，你都可以通过覆盖WebSecurityConfigurerAdapter基础配置类中定义的configure()方法来进行配置。首先，我们可以将如下的方法添加到SecurityConfig类中：

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

现在，我们需要使用指定的AuthenticationManagerBuilder替换上面的省略号，以此来定义在认证过程中如何查找用户。我们先来看一下基于内存的用户存储。

4.2.1 基于内存的用户存储

用户信息可以存储在内存之中。假设我们只有数量有限的几个用户，而且这些用户几乎不会发生变化，在这种情况下，将这些用户定义成安全配置的一部分是非常简单的。

例如，程序清单4.2展示了如何在内存用户存储中配置两个用户，即“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使用构造者（builder）风格的接口来构建认证细节。在本例中，我们在安全配置中调用inMemoryAuthentication()方法来指定用户信息。

每次调用withUser()都会配置一个用户，这个方法给定的值是用户名，而密码和授权信息是通过password()和authorities()方法来指定的。如程序清单4.2中所示，两个用户都授予了ROLE_USER权限。用户buzz的密码为“infinity”，而woody的密码为“bullseye”。

对于测试和简单的应用来讲，基于内存的用户存储是很有用的，但是这种方式不能很方便地编辑用户。如果需要新增、移除或变更用户，那么你要对代码做出必要的修改，然后重新构建和部署应用。

对于Taco Cloud应用来说，我们希望顾客能够在应用中进行注册，并且能够管理自己的用户账号。这明显与内存用户存储的限制不符，所以我们接下来看一下另外一种方式，这种方式允许使用数据库后端作为用户存储。

4.2.2 基于JDBC的用户存储

用户信息通常会在关系型数据库中进行维护，基于JDBC的用户存储方案会更加合理一些。程序清单4.3展示了使用JDBC对存储在关系型数据库中的用户信息进行认证所需的Spring Security配置。

程序清单4.3 基于JDBC用户存储进行认证

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

在这里的configure()实现中，调用了AuthenticationManagerBuilder的jdbcAuthentication()方法。我们必须还要设置一个DataSource，这样它才能知道如何访问数据库。这里的DataSource是通过自动装配的技巧获取到的。

重写默认的用户查询功能

尽管最少配置能够让一切运转起来，但是它对我们的数据库模式有一些要求，预期某些存储用户数据的表已经存在。更具体来说，下面的代码片段来源于SpringSecurity内部，并展现了当查找用户信息时所执行的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所示的方式配置自己的查询：

程序清单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=?");
}

在本例中，我们只重写了认证和基本权限的查询语句，但是通过调用groupAuthorities ByUsername()方法，我们也能够将群组权限重写为自定义的查询语句。

将默认的SQL查询替换为自定义的设计时，很重要的一点就是要遵循查询的基本协议。所有查询都将用户名作为唯一的参数。认证查询会选取用户名、密码以及启用状态信息。权限查询会选取零行或多行包含该用户名及其权限信息的数据。群组权限查询会选取零行或多行数据，每行数据中都会包含群组ID、群组名称以及权限。

使用转码后的密码

看一下上面的认证查询，它预期用户密码存储在了数据库之中。这里唯一的问题在于如果密码明文存储，就很容易受到黑客的窃取。但是，如果数据库中的密码进行了转码，那么认证就会失败，因为它与用户提交的明文密码并不匹配。

为了解决这个问题，我们需要借助passwordEncoder()方法指定一个密码转码器（encoder）：

@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 Security中PasswordEncoder接口的任意实现。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);
}

不管你使用哪一个密码转码器，都需要理解一点，即数据库中的密码是永远不会解码的。用户在登录时所采取的策略与之相反，输入的密码会按照相同的算法进行转码，然后与数据库中已经转码过的密码进行对比。这个对比是在PasswordEncoder的matches()方法中进行的。

最终，我们实现了在数据库中维护Taco Cloud用户数据。但是，我并没有采用jdbcAuthentication()，因为我想到了另外一种认证方案。在介绍该方案之前，我们先看一下如何配置Spring Security依赖另一种通用的用户数据源：使用LDAP（Lightweight Directory Access Protocol，轻量级目录访问协议）访问的用户存储。

4.2.3 以LDAP作为后端的用户存储

为了配置Spring Security使用基于LDAP认证，我们可以使用ldapAuthentication()方法。这个方法在功能上类似于jdbcAuthentication()，只不过是LDAP版本。如下的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的组织单元下搜索而不是从根开始，而组应该在名为groups的组织单元下搜索。

配置密码比对

基于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");
}

在本例中，我们指定了要与给定密码进行比对的是“passcode”属性。另外，我们还可以指定密码转码器。在进行服务器端密码比对时，有一点非常好，那就是实际的密码在服务器端是私密的。但是进行尝试的密码还是需要通过线路传输到LDAP服务器上，这可能会被黑客所拦截。为了避免这一点，我们可以通过调用passwordEncoder()方法指定加密策略。

在前面的例子中，密码使用bcrypt密码哈希函数加密。这需要LDAP服务器上的密码也使用bcrypt进行了加密。

引用远程的LDAP服务器

到目前为止，我们忽略的一件事就是LDAP和实际的数据在哪里。我们很开心地配置Spring使用LDAP服务器进行认证，但是服务器在哪里呢？

默认情况下，Spring Security的LDAP认证假设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服务器。我们不再需要设置远程LDAP服务器的URL，只需通过root()方法指定嵌入式服务器的根前缀就可以了：

@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 Data Interchange Format，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 repository来存储用户。

要事优先，在此之前，我们首先要创建领域对象，以及展现和持久化用户信息的repository接口。

定义用户领域对象和持久化

当Taco Cloud的顾客注册应用的时候，它们需要提供除用户名和密码之外的更多信息。他们会提供全名、地址和电话号码。这些信息可以用于各种目的，包括预先填充表单（更不用说潜在的市场销售机会）。

为了捕获这些信息，我们要创建程序清单4.5所示的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 Security的UserDetails接口。

通过实现UserDetails接口，我们能够提供更多信息给框架，比如用户都被授予了哪些权限以及用户的账号是否可用。

getAuthorities()方法应该返回用户被授予权限的一个集合。各种is…Expired()方法要返回一个boolean值，表明用户的账号是否可用或过期。

对于User实体来说，getAuthorities()方法只是简单地返回一个集合，这个集合表明所有的用户都被授予了ROLE_USER权限。至少就现在来说，Taco Cloud没有必要禁用用户，所以所有的is…Expired()方法均返回true，表明用户是处于活跃状态的。

User实体定义完之后，我们就可以定义repository接口了：

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会在运行时自动生成这个接口的实现。所以，我们现在就可以编写使用该repository的用户详情接口了。

创建用户详情服务

Spring Security的UserDetailsService是一个相当简单直接的接口：

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

正如我们所看到的，这个接口的实现会得到一个用户的用户名，并且要么返回查找到的UserDetails对象，要么在根据用户名无法得到任何结果的情况下抛出Username NotFoundException。

因为我们的User类实现了UserDetails，并且UserRepository提供了findByUsername()方法，所以它们非常适合用在UserDetailsService实现中。程序清单4.6展现了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()返回null，那么loadByUsername()将会抛出UsernameNotFoundException；否则，将会返回查找到的User。

我们注意到UserRepositoryUserDetailsService上添加了@Service。这是Spring的另外一个构造型（stereotype）注解，它表明这个类要包含到Spring的组件扫描中，所以我们不需要再明确将这个类声明为bean了。Spring将会自动发现它并将其初始化为一个bean。

但是，我们依然需要将这个自定义的用户详情服务与Spring Security配置在一起。因此，我们再次回到configure()方法：

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

在这里，我们只是简单地调用userDetailsService()方法，并将自动装配到SecurityConfig中的UserDetailsService实例传递了进去。

像基于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应用上下文中声明PasswordEncoderbean。对于encoder()的任何调用都会被拦截，并且会返回应用上下文中的bean实例。

现在，我们已经有了自定义的用户详情服务，它会通过JPA repository读取用户信息，接下来我们需要一种将用户存放到数据库中的办法。为了做到这一点，我们需要为Taco Cloud创建一个注册页面，供用户注册本应用。

注册用户

尽管在安全性方面，Spring Security会为我们处理很多事情，但是它没有直接涉及用户注册的流程，所以我们需要借助Spring MVC的一些技能来完成这个任务。程序清单4.7所示的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”的请求了。具体来讲，对“/register”的GET请求会由registerForm()方法来处理，它只是简单地返回一个逻辑视图名registration。程序清单4.8展现了定义registration视图的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>

当表单提交的时候，processRegistration()方法会处理HTTP POST请求。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，这其实就是我们在前面所声明的PasswordEncoder。在处理表单提交的时候，RegistrationController将其传递给toUser()方法，在将密码保存到数据库之前，会使用它对密码进行转码。通过这种方式，用户的密码可以以转码后的形式写入到数据库中，用户详情服务就能基于转码后的密码对用户进行认证了。

现在，Taco Cloud应用已经有了完整的用户注册和认证功能。但是，如果你现在启动应用，就会发现我们无法进入注册页面，也不会提示进行登录。这是因为在默认情况下，所有的请求都需要认证。接下来，我们看一下Web请求是如何被拦截和保护的，这样我们才能解决这个先有鸡还是先有蛋的诡异问题。