Auf Wiedersehen Shiro!

1. Einleitung

Als Hintergrundentwickler sollte der Begriff „Berechtigung“ als sehr vertraut gelten. Sogar Klassen in Java haben „Berechtigungen“ wie öffentlich und privat. Shiro wurde in früheren Projekten als Framework für die Rechteverwaltung verwendet. Um ehrlich zu sein, ist Shiro zwar ziemlich mächtig, hat aber auch viele Nachteile. Shiros Standard-Anmeldeadresse ist immer noch login.jsp, und viele Kategorien müssen neu geschrieben werden, wenn Shiro im Front-End- und Back-End-Trennmodus verwendet wird; das Speichern von Benutzerinformationen auf dem Mobiltelefon, das Beibehalten des Anmeldestatus usw. ist ebenfalls ein Problem Problem für Shiro.

In verteilten Projekten wie E-Commerce-Projekten besteht eigentlich keine Notwendigkeit für eine klare Autoritätsaufteilung. Um es ganz klar auszudrücken: Ich denke, es besteht keine Notwendigkeit, zu viel umständliches Autoritätsmanagement durchzuführen, und alles ist einfach gehalten. Darüber hinaus ist Shiro für verschiedene verteilte Frameworks wie SpringCloud einfach eine „Katastrophe“. Jedes Subsystem muss etwas über Shiro schreiben, und langsam wird es immer ekelhafter. Das Zuul-Gateway ist hier, um seine Talente zu zeigen, indem es die Anmeldung des Benutzers kontrolliert, die Berechtigung des Benutzers authentifiziert und so weiter. Das Zuul-Gateway steuert die Benutzeranmeldung, die nach der Authentifizierung ausführlich erläutert wird. Meine bescheidene Meinung oben.

Dann habe ich kürzlich jcasbin entdeckt, ein weiteres Berechtigungsframework. Obwohl es im Internet nicht viele Blogs gibt, kann ich es verwenden, nachdem ich es eine Weile gelesen habe.

Github-Adresse: https://github.com/casbin/jcasbin

2. Bereiten Sie sich vor

Ich werde nicht die Grundlagen von Spring Boot vorstellen. Es wird empfohlen, sich dieses praktische Projekt anzusehen:

https://github.com/javastacks/spring-boot-best-practice

1. Einführung des Mavan-Lagers

<dependency>
    <groupId>org.casbin</groupId>
    <artifactId>jcasbin</artifactId>
    <version>1.1.0</version>
</dependency>
<dependency>
    <groupId>org.casbin</groupId>
    <artifactId>jdbc-adapter</artifactId>
    <version>1.1.0</version>
</dependency>

2. Konfigurationsdatei

jcasbin fügt die Rollen- und Berechtigungsinformationen (Zugriffspfad) des Benutzers in die Konfigurationsdatei ein und liest die Konfigurationsdatei dann über den Eingabestream. Es gibt zwei Hauptkonfigurationsdateien: model.conf und Policy.csv. Die einfache Verwendung von GitHub wurde erwähnt, daher werde ich hier nicht näher darauf eingehen.

Tatsächlich können Sie auch die Rollenberechtigungskonfiguration der Datenbank lesen. So können wir die Informationen über die Datenbank extrahieren und dynamisch festlegen.

@Configuration
@ConfigurationProperties(prefix = org.jcasbin)
public class EnforcerConfigProperties {

  private String url;

  private String driverClassName;

  private String username;

  private String password;

  private String modelPath;

  public String getUrl() {
    return url;
  }

  public void setUrl(String url) {
    this.url = url;
  }

  public String getDriverClassName() {
    return driverClassName;
  }

  public void setDriverClassName(String driverClassName) {
    this.driverClassName = driverClassName;
  }

  public String getUsername() {
    return username;
  }

  public void setUsername(String username) {
    this.username = username;
  }

  public String getPassword() {
    return password;
  }

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

  public String getModelPath() {
    return modelPath;
  }

  public void setModelPath(String modelPath) {
    this.modelPath = modelPath;
  }

  @Override
  public String toString() {
    return EnforcerConfigProperties [url= + url + , driverClassName= + driverClassName + , username=
        + username + , password= + password + , modelPath= + modelPath + ];
  }

}

Auf diese Weise können wir verwandte Konfigurationen in application.properties konfigurieren. model.conf ist eine feste Datei. Kopieren Sie sie einfach und platzieren Sie sie im neu erstellten Ordner auf derselben Ebene wie src. Der Inhalt von Policy.csv kann aus der Datenbank gelesen werden.

org.jcasbin.url=jdbc:mysql://localhost:3306/casbin?useSSL=false
org.jcasbin.driver-class-name=com.mysql.jdbc.Driver
org.jcasbin.username=root
org.jcasbin.password=root
org.jcasbin.model-path=conf/authz_model.conf

3. Lesen Sie die Berechtigungsinformationen für die Initialisierung

Wir müssen die Enforcer-Klasse initialisieren und die Informationen in die Konfigurationsdatei laden. Deshalb schreiben wir eine Klasse zur Implementierung von InitializingBean und initialisieren diese Klasse, wenn der Container für die spätere Verwendung geladen wird.

@Component
public class EnforcerFactory implements InitializingBean {

  private static Enforcer enforcer;

  @Autowired
  private EnforcerConfigProperties enforcerConfigProperties;
  private static EnforcerConfigProperties config;

  @Override
  public void afterPropertiesSet() throws Exception {
    config = enforcerConfigProperties;
    //从数据库读取策略
    JDBCAdapter jdbcAdapter = new JDBCAdapter(config.getDriverClassName(),config.getUrl(),config.getUsername(),
                          config.getPassword(), true);
    enforcer = new Enforcer(config.getModelPath(), jdbcAdapter);
    enforcer.loadPolicy();//Load the policy from DB.
  }

  /**
   * 添加权限
   * @param policy
   * @return
   */
  public static boolean addPolicy(Policy policy){
    boolean addPolicy = enforcer.addPolicy(policy.getSub(),policy.getObj(),policy.getAct());
    enforcer.savePolicy();

    return addPolicy;
  }

  /**
   * 删除权限
   * @param policy
   * @return
   */
  public static boolean removePolicy(Policy policy){
    boolean removePolicy = enforcer.removePolicy(policy.getSub(),policy.getObj(),policy.getAct());
    enforcer.savePolicy();

    return removePolicy;
  }

  public static Enforcer getEnforcer(){
    return enforcer;
  }

}

In dieser Klasse injizieren wir die geschriebene Konfigurationsklasse, konvertieren sie dann in statisch, instanziieren den Enforcer in der Methode afterPropertiesSet und laden die Richtlinie (Strategie, Rollenberechtigung/URL-Korrespondenz).

Gleichzeitig werden zwei Methoden zum Hinzufügen und Löschen von Richtlinien geschrieben: Policy ist eine benutzerdefinierte Klasse, die die offizielle Sammlung/das offizielle Array kapselt.

public class Policy {
  /**想要访问资源的用户 或者角色*/
  private String sub;

  /**将要访问的资源，可以使用 * 作为通配符，例如/user/* */
  private String obj;

  /**用户对资源执行的操作。HTTP方法，GET、POST、PUT、DELETE等，可以使用 * 作为通配符*/
  private String act;

  public Policy() {
    super();
  }

  /**
   * 
   * @param sub 想要访问资源的用户 或者角色
   * @param obj 将要访问的资源，可以使用 * 作为通配符，例如/user/*
   * @param act 用户对资源执行的操作。HTTP方法，GET、POST、PUT、DELETE等，可以使用 * 作为通配符
   */
  public Policy(String sub, String obj, String act) {
    super();
    this.sub = sub;
    this.obj = obj;
    this.act = act;
  }

  public String getSub() {
    return sub;
  }

  public void setSub(String sub) {
    this.sub = sub;
  }

  public String getObj() {
    return obj;
  }

  public void setObj(String obj) {
    this.obj = obj;
  }

  public String getAct() {
    return act;
  }

  public void setAct(String act) {
    this.act = act;
  }

  @Override
  public String toString() {
    return Policy [sub= + sub + , obj= + obj + , act= + act + ];
  }

}

4. Verwendung

1. Autoritätskontrolle

Die Berechtigungskontrolle von jcasbin ist sehr einfach. Sie können einen Filter anpassen und prüfen, ob eine Beurteilung möglich ist. Ja, so einfach ist das.

@WebFilter(urlPatterns = /* , filterName = JCasbinAuthzFilter)
@Order(Ordered.HIGHEST_PRECEDENCE)//执行顺序，最高级别最先执行，int从小到大
public class JCasbinAuthzFilter implements Filter {

  private static final Logger log = LoggerFactory.getLogger(JCasbinAuthzFilter.class);

  private static Enforcer enforcer;

  @Override
  public void init(FilterConfig filterConfig) throws ServletException {
  }

  @Override
  public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain chain)
      throws IOException, ServletException {
    HttpServletRequest request = (HttpServletRequest) servletRequest;
        HttpServletResponse response = (HttpServletResponse) servletResponse;

        String user = request.getParameter(username);
        String path = request.getRequestURI();
        String method = request.getMethod();

        enforcer = EnforcerFactory.getEnforcer();
        if (path.contains(anon)) {
          chain.doFilter(request, response);
    }else if (enforcer.enforce(user, path, method)) {
      chain.doFilter(request, response);
    } else {
      log.info(无权访问);
      Map<String, Object> result = new HashMap<String, Object>();
            result.put(code, 1001);
            result.put(msg, 用户权限不足);
            result.put(data,null);
            response.setCharacterEncoding(UTF-8);
            response.setContentType(application/json);
            response.getWriter().write(JSONObject.toJSONString(result,SerializerFeature.WriteMapNullValue));
      }

  }

  @Override
  public void destroy() {

  }

}

Verwenden Sie hauptsächlich die Methode „enforcer.enforce“ (Benutzer, Pfad, Methode), um Benutzer, Zugriffsressourcen und Methoden abzugleichen. Die Logik hier kann entsprechend Ihrem eigenen Unternehmen implementiert werden. Vor diesem Filter können Sie auch einen Filter hinzufügen, um festzustellen, ob der Benutzer angemeldet ist.

2. Berechtigungen hinzufügen und löschen

Rufen Sie für Berechtigungsvorgänge einfach die entsprechende Methode in der oben beschriebenen EnforcerFactory auf. Darüber hinaus kann der Effekt der Synchronisation erzielt werden. Das heißt, ohne Neustart des Servers oder anderer Vorgänge wird nach dem Hinzufügen oder Löschen von Benutzerberechtigungen der entsprechende Zugriff des Benutzers beeinträchtigt.

@PutMapping(/anon/role/per)
  public ResultBO<Object> addPer(){

    EnforcerFactory.addPolicy(new Policy(alice, /user/list, *));

    return ResultTool.success();
  }

  @DeleteMapping(/anon/role/per)
  public ResultBO<Object> deletePer(){

    EnforcerFactory.removePolicy(new Policy(alice, /user/list, *));

    return ResultTool.success();
  }

5. Endlich

Tatsächlich kann jcasbin mit zuul von SpringCloud kombiniert werden, um eine einheitliche Anmeldung und Berechtigungskontrolle von Benutzern zu realisieren. Sie können einen Filter so anpassen, dass er ZuulFilter erbt. An anderen Stellen gibt es grundsätzlich keinen Unterschied. Ich werde später darüber schreiben.

Urheberrechtserklärung: Dieser Artikel ist ein Originalartikel des CSDN-Bloggers „Red Lotus Root Fragrance, Residual Jade and Autumn“ und folgt der Urheberrechtsvereinbarung CC 4.0 BY-SA. Zum Nachdruck fügen Sie bitte den Originalquellenlink und diese Erklärung bei. Ursprünglicher Link: https://blog.csdn.net/WayneLee0809/article/details/85702551

Aktuelle Empfehlung für einen heißen Artikel:

1. Über 1.000 Fragen und Antworten zu Java-Interviews (neueste Version 2022)

2. Genial! Java-Coroutinen kommen. . .

3. Spring Boot 2.x-Tutorial, zu umfassend!

4. Füllen Sie den Bildschirm nicht mit Explosionen und Explosionen, probieren Sie den Dekorationsmodus aus, das ist der elegante Weg! !

5. Laden Sie die neueste Version des „Java Development Manual (Songshan Edition)“ schnell herunter!

Fühlen Sie sich wohl, vergessen Sie nicht zu liken + weiterzuleiten!