XML de seguridad de primavera

Spring Security es una forma poderosa de proporcionar autenticación y autorización a la aplicación Spring. Spring Security es una poderosa herramienta que proporciona la función de configuración de seguridad personalizada para el usuario. La configuración de seguridad en Spring se puede personalizar de dos maneras, como se indica a continuación:

• Configuración basada en XML
• Configuración Java.

Implementación: aquí crearemos una aplicación web Spring MVC y agregaremos una configuración basada en xml.

Prerrequisitos : Introducción a Spring

Pasos para crear una configuración basada en XML en Spring MVC

Paso 1: Cree un proyecto de aplicación web maven , estamos usando Eclipse IDE para crear este proyecto. Al crear un proyecto maven, seleccione el arquetipo para este proyecto como maven-archetype-webapp. Ingrese la identificación del grupo y la identificación del artefacto para su proyecto y haga clic en ‘ Finalizar ‘.

Paso 2: después de crear el proyecto, la estructura de su proyecto se vería así:

El archivo pom.xml define todas las dependencias necesarias para el proyecto. Asegúrese de agregar todas las dependencias mencionadas en este archivo para que su proyecto funcione correctamente.

Archivo: pom.xml  

<?xml version="1.0" encoding="UTF-8"?>
  
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  
  <groupId>com.gfg</groupId>
  <artifactId>SpringSecurityXmlConfig</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>war</packaging>
  
  <name>SpringSecurityXmlConfig Maven Webapp</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>
  
  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.7</maven.compiler.source>
    <maven.compiler.target>1.7</maven.compiler.target>
  </properties>
  
  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.3.16</version>
</dependency>
  
<!-- https://mvnrepository.com/artifact/org.springframework.security/spring-security-web -->
<dependency>
    <groupId>org.springframework.security</groupId>
    <artifactId>spring-security-web</artifactId>
    <version>5.6.2</version>
</dependency>
  
<!-- https://mvnrepository.com/artifact/org.springframework.security/spring-security-core -->
<dependency>
    <groupId>org.springframework.security</groupId>
    <artifactId>spring-security-core</artifactId>
    <version>5.6.2</version>
</dependency>
  
  <!-- https://mvnrepository.com/artifact/org.springframework.security/spring-security-config -->
<dependency>
    <groupId>org.springframework.security</groupId>
    <artifactId>spring-security-config</artifactId>
    <version>5.6.2</version>
</dependency>
  
  
            
<!-- https://mvnrepository.com/artifact/javax.servlet/javax.servlet-api -->
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <version>4.0.1</version>
    <scope>provided</scope>
</dependency>
  
  </dependencies>
  
  <build>
    <finalName>SpringSecurityXmlConfig</finalName>
    <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
      <plugins>
        <plugin>
          <artifactId>maven-clean-plugin</artifactId>
          <version>3.1.0</version>
        </plugin>
        <!-- see http://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_war_packaging -->
        <plugin>
          <artifactId>maven-resources-plugin</artifactId>
          <version>3.0.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-compiler-plugin</artifactId>
          <version>3.8.0</version>
        </plugin>
        <plugin>
          <artifactId>maven-surefire-plugin</artifactId>
          <version>2.22.1</version>
        </plugin>
        <plugin>
          <artifactId>maven-war-plugin</artifactId>
          <version>3.2.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-install-plugin</artifactId>
          <version>2.5.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-deploy-plugin</artifactId>
          <version>2.8.2</version>
        </plugin>
      </plugins>
    </pluginManagement>
  </build>
</project>

El web.xml define el mapeo con diferentes URL y servlets para manejar las requests de esas URL. Spring DelegatingFilterProxy proporciona un enlace entre web.xml y el contexto de la aplicación.

Archivo: web.xml

<?xml version="1.0" encoding="UTF-8"?>  
<!DOCTYPE xml>  
    <web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"  
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee  
         http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"  
         version="3.1">  
            
        <servlet>  
            <servlet-name>gfg</servlet-name>  
            <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>  
            <load-on-startup>1</load-on-startup>  
        </servlet>  
        <servlet-mapping>  
            <servlet-name>gfg</servlet-name>  
            <url-pattern>/</url-pattern>  
        </servlet-mapping>  
            
        <listener>  
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>  
        </listener>  
        
        <filter>  
            <filter-name>springSecurityFilterChain</filter-name>  
            <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>  
        </filter>  
        <filter-mapping>  
            <filter-name>springSecurityFilterChain</filter-name>  
            <url-pattern>/*</url-pattern>  
        </filter-mapping>  
            
        <context-param>  
            <param-name>contextConfigLocation</param-name>  
            <param-value>  
                /WEB-INF/gfg-servlet.xml  
                /WEB-INF/spring-security.xml  
            </param-value>  
        </context-param>  
</web-app>

El archivo gfg-servlet.xml maneja todas las requests HTTP para las aplicaciones web. Las clases basadas en anotaciones habilitan las clases de anotaciones de primavera. El análisis de componentes localiza y asigna beans de acuerdo con la anotación definida. La configuración del bean ayuda a identificar y localizar archivos JSP en el proyecto.

Archivo: gfg-servlet.xml

<?xml version="1.0" encoding="UTF-8"?>  
<beans xmlns="http://www.springframework.org/schema/beans"  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  xmlns:mvc="http://www.springframework.org/schema/mvc"  
xmlns:context="http://www.springframework.org/schema/context"  
xsi:schemaLocation="  http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd  http://www.springframework.org/schema/beans  
http://www.springframework.org/schema/beans/spring-beans.xsd  
http://www.springframework.org/schema/context   
http://www.springframework.org/schema/context/spring-context.xsd">  
  
   <mvc:annotation-driven />  
     
   <context:component-scan base-package="com.gfg.controller">  
     
   </context:component-scan>  
     
   <context:annotation-config></context:annotation-config>  
     
   <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">  
      <property name="prefix" value="/WEB-INF/views/"></property>  
      <property name="suffix" value=".jsp"></property>  
   </bean>  
     
</beans>

Aquí es donde define la configuración para Spring Security, el bean http ayuda a interceptar todas las llamadas http mencionadas en el archivo, el servicio de usuario en el proveedor de autenticación en el administrador de autenticación crea un usuario para la aplicación con el nombre de usuario, contraseña y el rol de ese usuario. 

<?xml version="1.0" encoding="UTF-8"?> 
<beans:beans xmlns="http://www.springframework.org/schema/security" 
xmlns:beans="http://www.springframework.org/schema/beans" 
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
xsi:schemaLocation="http://www.springframework.org/schema/beans 
http://www.springframework.org/schema/beans/spring-beans.xsd 
http://www.springframework.org/schema/security 
http://www.springframework.org/schema/security/spring-security.xsd"> 
  
    <http auto-config="true"> 
            <intercept-url pattern="/admin" access="hasRole('ROLE_ADMIN')" /> 
    </http> 
    <authentication-manager> 
        <authentication-provider> 
           <user-service> 
                   <user name="admin" password="{noop}pass" authorities="ROLE_ADMIN" /> 
           </user-service> 
       </authentication-provider> 
   </authentication-manager> 
   <beans:bean id ="passwordEncoder" 
      class = "org.springframework.security.crypto.password.NoOpPasswordEncoder" 
      factory-method = "getInstance">
   </beans:bean> 
</beans:beans>

La clase WelcomeController en el paquete com.gfg.controller define las asignaciones para url, en este proyecto hemos definido dos métodos GET para dos URL. El método de bienvenida redirige a la página de vista de inicio y el método de administración lo hace para la página de vista de administración .

Archivo: WelcomeController.java

// Java Program to Illustrate WelcomeController Class
  
package com.gfg.controller;
  
// Importing required classes
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
  
// Annotation
@Controller
// Class
public class WelcomeController {
  
    // Method 1
    @RequestMapping(value = "/", method = RequestMethod.GET)
    public String welcome()
    {
        return "welcome";
    }
  
    // Method 2
    @RequestMapping(value = "/admin",
                    method = RequestMethod.GET)
    public String
    admin()
    {
        return "admin";
    }
}

Esta es la página admin.jsp en la carpeta de vistas.

<html>  
<head>  
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">  
    <title>Admin</title>  
    </head>  
<body>  
    Welcome Admin
    <form action="<%=request.getContextPath()%>/appLogout" method="POST">
       <input type="submit" value="Logout"/>
       <input type="hidden" name="${_csrf.parameterName}" value="${_csrf.token}"/>        
     </form> 
</body>  
</html>

Esta es la página welcome.jsp en la carpeta de vistas.

<html>  
<head>  
    <meta content="text/html; charset=UTF-8">  
    <title>Home Page</title>  
</head>  
<body>  
    <h2>Welcome to Spring Security using XML Configuration!</h2>  
</body>  
</html>

Paso 3: Después de crear todos los archivos de configuración y las clases, su proyecto se vería así:

Paso 4: ahora que hemos completado nuestro proyecto, es hora de ejecutarlo en un servidor Tomcat, simplemente inicie el servidor Tomcat y escriba http:localhost:8080/SpringSecurityXmlConfig/login .