spring security登录成功后跳转回登录前的页面

确保实现“spring security登录成功后跳转回登录前的页面”的功能，需要进行以下步骤：

1. 配置页面跳转
   在spring的配置文件中，需要将页面跳转的路径配置到spring security中。可以使用默认的登录页，也可以自定义一个登录页。

使用默认的登录页：

<http>
    <form-login login-page="/login" default-target-url="/home" authentication-failure-url="/login-error"/>
</http>

这里的login-page用于指定登录页，default-target-url用于指定登录成功后跳转的页面，authentication-failure-url是指定认证失败后跳转的页面。

自定义登录页：

<http>
    <form-login login-processing-url="/login.do"
            username-parameter="username" password-parameter="password"
            authentication-failure-url="/login?error"
            authentication-success-handler-ref="myAuthenticationSuccessHandler"
            login-page="/login.jsp"/>
</http>

这里的login-processing-url用于指定处理登录请求的URL，username-parameter和password-parameter用于指定用户名和密码参数名称，authentication-failure-url和login-page与默认登录页一样。需要注意的是，myAuthenticationSuccessHandler是一个自定义的登录成功后处理器，会在后面进行详细讲解。

1. 配置登录后的处理器
   在上述的自定义登录页面配置文件中，需要在form-login标签中添加一个authentication-success-handler-ref属性，用于指定一个登录成功后的处理器。

<bean id="myAuthenticationSuccessHandler" class="com.example.MyAuthenticationSuccessHandler"/>

这里的myAuthenticationSuccessHandler就是一个自定义的登录成功后的处理器。下面是一个示例：

public class MyAuthenticationSuccessHandler extends SavedRequestAwareAuthenticationSuccessHandler {

    private RedirectStrategy redirectStrategy = new DefaultRedirectStrategy();

    @Override
    public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response,
            Authentication authentication) throws IOException, ServletException {

        HttpServletRequestWrapper requestWrapper = new HttpServletRequestWrapper(request) {

            @Override
            public String getServletPath() {
                String servletPath = super.getServletPath();
                HttpSession session = super.getSession();
                // 从session中获取之前被拦截的请求路径，并将其放入请求参数中。
                if (servletPath == null || "/".equals(servletPath)) {
                    return String.valueOf(session.getAttribute("requestUri"));
                }
                return servletPath;
            }
        };

        SavedRequest savedRequest = new HttpSessionRequestCache().getRequest(request, response);
        if (savedRequest != null && savedRequest.getRedirectUrl() != null) {
            // 将被拦截的请求路径放入session中，以便在登录成功后获取。
            HttpSession session = request.getSession();
            session.setAttribute("requestUri", savedRequest.getRedirectUrl());
        }

        String targetUrl = determineTargetUrl(requestWrapper, response);
        redirectStrategy.sendRedirect(requestWrapper, response, targetUrl);
    }

    protected String determineTargetUrl(HttpServletRequest request, HttpServletResponse response) {
        // 获取登录成功后要跳转的页面
        // 如果之前有被拦截的请求，则跳转回被拦截的请求路径。
        HttpSession session = request.getSession(false);
        String targetUrl = null;
        if (session != null) {
            String redirectUrl = (String) session.getAttribute("requestUri");
            if (redirectUrl != null) {
                targetUrl = redirectUrl;
                session.removeAttribute("requestUri");
            }
        } 
        if (targetUrl == null) {
            // 如果没有被拦截的请求，则跳转到指定的页面。
            targetUrl = "/home";
        }
        return targetUrl;
    }

}

在这个处理器中，需要重写onAuthenticationSuccess方法。在该方法中，首先需要通过request.getSession()获取之前记住的请求路径。

如果该路径不为空，则需要将请求路径设置到HttpServletRequestWrapper对象中。通过继承HttpServletRequestWrapper，可以重新定义请求路径，使得请求路径变成之前被拦截的路径。

如果没有被拦截的请求，则通过determineTargetUrl方法获取登录成功后要跳转的页面。

到这里，完整的攻略已经介绍完毕。下面是两个使用示例：

1. 使用默认登录页，使用XML配置页面跳转

<http>
    <form-login login-page="/login" default-target-url="/home" authentication-failure-url="/login-error"/>
</http>

在这个示例中，我们使用了默认的登录页，只需要添加一个default-target-url属性就可以了。

1. 使用自定义登录页，使用Java配置页面跳转

@Configuration
@EnableWebSecurity
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {

    @Autowired
    private MyAuthenticationSuccessHandler myAuthenticationSuccessHandler;

    @Override
    protected void configure(HttpSecurity http) throws Exception {

        http
            .authorizeRequests()
                .antMatchers("/", "/home").permitAll()
                .anyRequest().authenticated()
                .and()
            .formLogin()
                .loginPage("/login")
                .loginProcessingUrl("/login.do")
                .usernameParameter("username")
                .passwordParameter("password")
                .successHandler(myAuthenticationSuccessHandler)
                .failureUrl("/login?error")
                .permitAll()
                .and()
            .logout()
                .permitAll();
    }

    @Autowired
    public void configureGlobal(AuthenticationManagerBuilder auth) throws Exception {
        auth.inMemoryAuthentication()
            .withUser("user").password("{noop}password").roles("USER");
    }
}

在这个示例中，我们自定义了登录页，使用Java配置了页面跳转。其中myAuthenticationSuccessHandler就是我们自定义的处理器。在formLogin标签中添加了successHandler属性，将我们自定义的处理器注入到formLogin中。

以上两个示例只是提供了大概的思路，具体代码实现还需要根据自己的业务需求进行修改。