So implementieren Sie mit SpringBoot + SpringSecurity eine Autorisierungsauthentifizierung basierend auf echten Daten

(1) Übersicht

Spring Security ist ein leistungsstarkes und hochgradig anpassbares Authentifizierungs- und Zugriffskontroll-Framework. Spring Security erledigt hauptsächlich zwei Dinge: Authentifizierung und Autorisierung. Ich habe bereits einen Blog über Spring Security geschrieben, aber damals habe ich nur einen Fall vorgestellt, der auf Scheindaten basiert. In dieser Ausgabe werde ich die Implementierung von Authentifizierung und Autorisierung basierend auf echten Daten vorstellen.

(2) Vorläufige Projektkonstruktion

Um SpringSecurity besser zu demonstrieren, erstellen wir zunächst ein einfaches Webprojekt. Thymeleaf-Abhängigkeit einführen

<dependency>
    <groupid>org.springframework.boot</groupid>
    <artifactid>spring-boot-starter-thymeleaf</artifactid>
</dependency>
<dependency>
    <groupid>org.thymeleaf</groupid>
    <artifactid>thymeleaf-spring5</artifactid>
</dependency>
<dependency>
    <groupid>org.thymeleaf.extras</groupid>
    <artifactid>thymeleaf-extras-java8time</artifactid>
</dependency>

Erstellen Sie eine Anmeldeseite, eine Homepage und mehrere verschiedene Ebenen von Anzeigeseiten: login.html

nbsp;html>


    <meta>
    <title>登陆页</title>


<div>
    <form>
        <h3>登陆页</h3>
        <input>
        <input>
        <button>登陆</button>
    </form>
</div>

index.html

nbsp;html>


    <meta>
    <title>首页</title>


<div>
    <h3>首页</h3>
    <a>登陆</a>
    <div>
        <div>
            <h4>level1</h4>
            <a>level-1-1</a>
            <hr>
            <a>level-1-2</a>
        </div>
        <div>
            <h4>level2</h4>
            <a>level-2-1</a>
            <hr>
            <a>level-2-2</a>
        </div>
        <div>
            <h4>level3</h4>
            <a>level-3-1</a>
            <hr>
            <a>level-3-2</a>
        </div>
    </div>
</div>

# 🎜 🎜#Es gibt auch mehrere verschiedene Seitenebenen

Schreiben Sie jeweils die entsprechenden Nummern in den Hauptteil.

nbsp;html>


    <meta>
    <title>Title</title>


level-1-1

Schreiben Sie schließlich einen Controller, um die Anfrage zu erhalten:

@Controller
public class RouteController {

    @RequestMapping({"/","/index"})
    public String index(){
        return "index";
    }

    @RequestMapping("/login")
    public String toLogin(){
        return "login";
    }

    @RequestMapping("/level1/{id}")
    public String level1(@PathVariable("id")String id){
        return "level1/"+id;
    }
    @RequestMapping("/level2/{id}")
    public String level2(@PathVariable("id")String id){
        return "level2/"+id;
    }
    @RequestMapping("/level3/{id}")
    public String level3(@PathVariable("id")String id){
        return "level3/"+id;
    }
}

Der endgültige Effekt ist wie folgt:

#🎜🎜 #Endlich können Levelseiten mit unterschiedlichen Levels entsprechend unterschiedlicher Berechtigungen umgeleitet werden.

Der Hintergrund wird basierend auf Mybatis und der MySQL-Datenbank implementiert. Daher müssen wir zusätzlich zur Einführung von SpringSecurity-Abhängigkeiten auch Mybatis-bezogene Abhängigkeiten einführen: #🎜 🎜#

<dependency>
    <groupid>org.springframework.boot</groupid>
    <artifactid>spring-boot-starter-security</artifactid>
</dependency>
<dependency>
    <groupid>org.springframework.boot</groupid>
    <artifactid>spring-boot-starter-jdbc</artifactid>
</dependency>
<dependency>
    <groupid>mysql</groupid>
    <artifactid>mysql-connector-java</artifactid>
    <scope>runtime</scope>
</dependency>
<dependency>
    <groupid>org.mybatis.spring.boot</groupid>
    <artifactid>mybatis-spring-boot-starter</artifactid>
    <version>2.1.3</version>
</dependency>

Datenquellenbezogene Informationen in der Konfigurationsdatei sowie Mybatis-Konfiguration hinzufügen:

spring.datasource.url=jdbc:mysql://localhost:3306/security?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8
spring.datasource.username=root
spring.datasource.password=123456
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

mybatis.mapper-locations=classpath:mapper/*.xml

(3) Implementierung von Authentifizierung und Autorisierung

3.1 Tabelle Strukturdesign#🎜 🎜#

Authentifizierung und Autorisierung sollten im Tabellendesign in zwei Tabellen unterteilt werden, in denen Benutzerinformationen, einschließlich Passwörter usw., gespeichert sind, und in der anderen Tabelle werden Autorisierungsinformationen gespeichert zwischen Benutzern und Autorisierung. Geben Sie die endgültige Tabellenstruktur an:

CREATE TABLE `roles` (
  `id` int(4) NOT NULL,
  `rolename` varchar(255) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

CREATE TABLE `sysuser` (
  `id` int(4) NOT NULL,
  `username` varchar(255) NOT NULL,
  `password` varchar(255) NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

CREATE TABLE `user_role` (
  `id` int(4) NOT NULL,
  `user_id` int(4) DEFAULT NULL,
  `role_id` int(4) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

Der nächste Schritt sind die Entitätsklassen, Mapper-Schnittstellen und XML-Dateien für diese drei Tabellen implementiert hauptsächlich eine Suche nach Benutzern anhand des Benutzernamens und der zugehörigen Berechtigungsoperation:

@Data
public class Roles {
    private Integer id;
    private String roleName;
}

@Data
public class SysUser {
    private Integer id;
    private String userName;
    private String password;
    private List<roles> roles;
}</roles>

Mapper-Schnittstelle:

public interface UserMapper {
    public SysUser getUserByUserName(@Param("userName") String userName);
}

xml-Implementierung:

<?xml  version="1.0" encoding="UTF-8" ?>
nbsp;mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper>
    <resultmap>
        <id></id>
        <result></result>
        <result></result>
        <collection>
            <result></result>
        </collection>
    </resultmap>
    <select>
        select sysuser.*,roles.rolename
        from sysuser
        LEFT JOIN user_role on sysuser.id= user_role.user_id
        LEFT JOIN roles on user_role.role_id=roles.id
        where username= #{userName}
    </select>
</mapper>

3.2 Authentifizierungsprozess

SpringSecurity Der Authentifizierungsprozess läuft wie folgt ab: Zunächst wird der Benutzer über den Benutzernamen oder eine andere eindeutige ID in der Datenbank gefunden. Das Passwort des Benutzers wird in asymmetrischer Verschlüsselung gespeichert. Nachdem Sie den Benutzer erhalten haben, verschlüsseln Sie das von der Rezeption übermittelte Passwort und vergleichen Sie es mit den verschlüsselten Feldern in der Datenbank, um die Authentifizierung zu bestehen.

Der erste Schritt im obigen Prozess, um den Benutzer anhand des Benutzernamens zu finden, muss über den Service-Service implementiert werden, und dieser Service-Service muss die UserDetailsService-Schnittstelle in SpringSecurity erben. Diese Schnittstelle gibt ein SpringSecurity-Benutzerobjekt zurück.

@Service
public class UserService implements UserDetailsService {

    @Resource
    private UserMapper userMapper;
    //根据用户名找到对应的用户信息
    @Override
    public UserDetails loadUserByUsername(String s) throws UsernameNotFoundException {
        SysUser sysUser = userMapper.getUserByUserName(s);
        if (sysUser!=null){
            List<grantedauthority> roles=new ArrayList();
            sysUser.getRoles().stream().forEach(x->{
                roles.add(new SimpleGrantedAuthority(x.getRoleName()));
            });
            return new User(sysUser.getUserName(),sysUser.getPassword(),roles);
        }
        throw new UsernameNotFoundException("用户未找到");
    }
}</grantedauthority>

3.3 Sicherheitsabfangkonfiguration

Nachdem die oben genannten Schritte abgeschlossen sind, beginnen Sie mit der Konfiguration der SecurityConfig. Die Authentifizierung ist sehr einfach userService-Objekt. Das aus der Datenbank abgerufene Passwort wird automatisch mit dem vom Frontend übergebenen Passwort verglichen. Gleichzeitig wird die Rollensammlung auch im userService übergeben, und am Autorisierungspunkt können unterschiedliche Berechtigungen an verschiedene Seiten angehängt werden.

@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Autowired
    private UserService userService;
    //授权
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        //首页所有人都能访问，level页面只有有权限的人才能访问
        http.authorizeRequests()
                .antMatchers("/").permitAll()
                .antMatchers("/level1/**").hasRole("vip1")
                .antMatchers("/level2/**").hasRole("vip2")
                .antMatchers("/level3/**").hasRole("vip3");
        //没有权限默认跳到登陆页，默认会重定向到/login
        http.formLogin();
    }

    //认证
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.userDetailsService(userService).passwordEncoder(new BCryptPasswordEncoder());

    }
}

3.4 Weitere zu beachtende Punkte

Die Passwortverschlüsselungsmethode, die ich während der Authentifizierung verwende, ist BCryptPasswordEncoder, daher muss das in der Datenbank gespeicherte Passwort ebenfalls verschlüsselt werden. Die häufig verwendete Methode Das Passwort wird bei der Registrierung verschlüsselt und auf die gleiche Weise in der Datenbank gespeichert:

String password="xxx";
BCryptPasswordEncoder bCryptPasswordEncoder = new BCryptPasswordEncoder();
String encode=bCryptPasswordEncoder.encode(password);

Das obige ist der detaillierte Inhalt vonSo implementieren Sie mit SpringBoot + SpringSecurity eine Autorisierungsauthentifizierung basierend auf echten Daten. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!