Как можно обновить значение POST запросом не перезаходя в систему SpringSecurity

Question

У меня есть значение в User, money, а так же функция, которая делает в базе данных update запрос, отнимающий десяток от money user'a. На главной странице это значение обновляется только тогда, когда я перелогинюсь в систему, но мне нужно, чтобы оно обновлялось тогда, когда функция (то есть POST запрос) вернет значение. Помогите пожалуйста.

SecurityConfig:


import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.authentication.dao.DaoAuthenticationProvider;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.web.util.matcher.AntPathRequestMatcher;

import net.javaguides.springboot.service.UserService;
import org.springframework.transaction.annotation.EnableTransactionManagement;

@Configuration
@EnableWebSecurity
public class SecurityConfiguration extends WebSecurityConfigurerAdapter {

    @Autowired
    private UserService userService;
    
    @Bean
    public BCryptPasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
    
    @Bean
    public DaoAuthenticationProvider authenticationProvider() {
        DaoAuthenticationProvider auth = new DaoAuthenticationProvider();
        auth.setUserDetailsService(userService);
        auth.setPasswordEncoder(passwordEncoder());
        return auth;
    }
    
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.authenticationProvider(authenticationProvider());
    }
    
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests().antMatchers(
                 "/registration**",
                    "/js/**",
                    "/css/**",
                    "/img/**").permitAll()
        .anyRequest().authenticated()
        .and()
        .formLogin()
        .loginPage("/login")
        .permitAll()
        .and()
        .logout()
        .invalidateHttpSession(true)
        .clearAuthentication(true)
        .logoutRequestMatcher(new AntPathRequestMatcher("/logout"))
        .logoutSuccessUrl("/login?logout")
        .permitAll();
    }

}

User:


import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.userdetails.UserDetails;

import java.io.Serializable;
import java.util.Collection;
import java.util.List;

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.ManyToMany;
import javax.persistence.Table;
import javax.persistence.UniqueConstraint;

@Entity
@Table(name="users", uniqueConstraints={@UniqueConstraint(columnNames={"email"})})
public class User
{
    
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    
//  @Column(unique = true)
    private String email;

    private String password;

    
    @ManyToMany(fetch = FetchType.EAGER, cascade = CascadeType.ALL)
    @JoinTable(
            name = "users_roles",
            joinColumns = @JoinColumn(name = "user_id", referencedColumnName = "id"),
            inverseJoinColumns = @JoinColumn(name = "role_id", referencedColumnName = "id"))
    private Collection<Role> roles;
    private int money;

    public User() {}

    public <T> User(String firstName, String lastName, String email, int money, String encode, List<T> roleUser) {
    }

    public User(int money) {
    }


    public void setMoney(int money) {
        this.money = money;
    }

    public User(String email, String password, int money, Collection<Role> roles) {
        super();
        this.email = email;
        this.password = password;
        this.roles = roles;
        this.money = money;
    }

    public Long getId() {
        return id;
    }
    public int getMoney() {
        return money;
    }

    public void setId(Long id) {
        this.id = id;
    }


    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }



    public String getPassword() {
        return password;
    }


    public void setPassword(String password) {
        this.password = password;
    }

    public Collection<Role> getRoles() {
        return roles;
    }

    public void setRoles(Collection<Role> roles) {
        this.roles = roles;
    }



}```

UserDetailsWithMoney(наследник User, который передает в principal getMoney(), который нужен мне в приложении): 
package net.javaguides.springboot.model;

import com.sun.istack.NotNull;
import net.javaguides.springboot.web.dto.UserRegistrationDto;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.core.userdetails.User;

import java.util.Collection;

public class UserDetailsWithMoney extends User {
    private int money;


    private  int summa;
    private int percent;


    public UserDetailsWithMoney(String username, String password, Collection<? extends GrantedAuthority> authorities, int money) {
        super(username, password, authorities);
        this.money = money;
    }





    //геттеры и сеттеры
    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        this.money = money;
    }

    public  int getSumma() {
        return summa;
    }

    public void setSumma(int summa) {
        this.summa = summa;
    }

    public int getPercent() {
        return percent;
    }

    public void setPercent(int percent) {
        this.percent = percent;
    }



}

UserRepository:


import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.jpa.repository.Query;
import org.springframework.stereotype.Repository;

import net.javaguides.springboot.model.User;

@Repository
public interface UserRepository extends JpaRepository<User, Long> {
   User findByEmail(String email);
    
}

UserService:


import net.javaguides.springboot.model.UserDetailsWithMoney;
import net.javaguides.springboot.web.dto.UserRegistrationDto;
import org.springframework.security.core.userdetails.UserDetailsService;

import net.javaguides.springboot.model.User;

public interface UserService extends UserDetailsService {

    User save(UserRegistrationDto registrationDto);


    UserDetailsWithMoney saveMoney(String email, int money);
}

UserServiceImpl:

import java.util.Arrays;
import java.util.Collection;
import java.util.stream.Collectors;


import net.javaguides.springboot.model.UserDetailsWithMoney;
import net.javaguides.springboot.web.dto.UserRegistrationDto;
import org.hibernate.SessionFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.stereotype.Service;

import net.javaguides.springboot.model.Role;
import net.javaguides.springboot.model.User;
import net.javaguides.springboot.repository.UserRepository;

@Service
public class UserServiceImpl implements UserService {

   private UserRepository userRepository;

   private String email;
   
   @Autowired
   private BCryptPasswordEncoder passwordEncoder;


   



   public UserServiceImpl(UserRepository userRepository) {
       super();
       this.userRepository = userRepository;
   }



   private SessionFactory sessionFactory;




   @Override
   public User save(UserRegistrationDto registrationDto) {
       User user=new User(registrationDto.getEmail(),
                       passwordEncoder.encode(registrationDto.getPassword()),
                           registrationDto.getMoney(),
                           Arrays.asList(new Role("ROLE_USER")));
       
       return userRepository.save(user);
   }
   @Override
   public UserDetailsWithMoney saveMoney(String email, int money){
       User user = userRepository.findByEmail(email);
       user.setMoney(money);

       if(user==null)
       {
           throw new UsernameNotFoundException("Invalid Username or password");
       }
       return new UserDetailsWithMoney(user.getEmail(),  user.getPassword(),mapRolesToAuthorities(user.getRoles()), user.getMoney());
   }

   @Override
   public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException 
   {
       
       User user=userRepository.findByEmail(username);
       
       if(user==null)
       {
           throw new UsernameNotFoundException("Invalid Username or password");
       }
       return new UserDetailsWithMoney(user.getEmail(),  user.getPassword(),mapRolesToAuthorities(user.getRoles()), user.getMoney());
   }




   private Collection<? extends GrantedAuthority> mapRolesToAuthorities(Collection<Role> roles){
       return roles.stream().map(role -> new SimpleGrantedAuthority(role.getName())).collect(Collectors.toList());
   }


}

MainController


import net.javaguides.springboot.model.User;
import net.javaguides.springboot.model.UserDetailsWithMoney;
import net.javaguides.springboot.service.UserService;
import net.javaguides.springboot.web.dto.UserRegistrationDto;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.*;

import java.security.Principal;
import java.util.Optional;
import static net.javaguides.springboot.model.UserDetailsWithMoney.DiceWinStatus;
import static net.javaguides.springboot.model.UserDetailsWithMoney.HaveMoney;
import static net.javaguides.springboot.model.UserDetailsWithMoney.BiggerNineTeen;
import static net.javaguides.springboot.model.UserDetailsWithMoney.DiceLoseStatus;



@Controller
public class MainController {



   public UserRegistrationDto UserRegistrationDto()
   {
       return new UserRegistrationDto();
   }
   private UserService userService;

   public MainController(UserService userService) {
       super();
       this.userService = userService;
   }
   @GetMapping("/login")
   public String login() {
       return "login";
   }
   
   @GetMapping("/")
   public String home (User user, Authentication authentication, Principal principal, Model model, UserRegistrationDto registrationDto)
   {
       return "index";
   }


   @PostMapping("/")
   public String play(@ModelAttribute(value = "registrationDto") UserRegistrationDto registrationDto, int summa, int percent, Model model) {
       model.addAttribute("registrationDto", registrationDto);
       Authentication authe = SecurityContextHolder.getContext().getAuthentication();
       String email = authe.getName();
       int newMoney = UserRegistrationDto().playDice(summa, percent);
       userService.saveMoney(email, newMoney);


       return "redirect:/";
   }


   @ModelAttribute("userd")
   public UserDetailsWithMoney userd(Authentication authentication) {
           return (authentication == null) ? null : (UserDetailsWithMoney) authentication.getPrincipal();
       }



} ```

БЛОГ НА HUSL

Как можно обновить значение POST запросом не перезаходя в систему SpringSecurity

Ответы (0 шт):