He intentado buscar en Google, pero no he podido encontrar ninguna buena ejemplos en los que un nombre de usuario y la contraseña son revisados con una base de datos para propósitos de autenticación.

Más en palabras simples, ¿cómo puedo crear un simple formulario de inicio de sesión utilizando Spring y Hibernate donde las credenciales se comprueba con la base de datos.

Actualización

Cam cualquier persona que venga con un ejemplo simple donde puedo ver cómo el flujo va y cómo los datos de entrada se pasa a hibernar?

  • Eche un vistazo a esta pregunta de stackoverflow, se tiene un ejemplo en la aceptación de respuesta: stackoverflow.com/questions/2683308/…
  • Estás hablando de la Primavera 3.0 y Spring Security 3 o Primavera 2.5 y Spring Security 2?
  • Así Primavera 3.0 y Spring Security 3
InformationsquelleAutor Thalaivar | 2011-01-06

4 Comentarios

  1. 27

    Primero debe definir este archivo WEB-INF/spring/serurity-context.xml:

    <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-2.0.xsd
                                     http://www.springframework.org/schema/security http://www.springframework.org/schema/security/spring-security-2.0.1.xsd">
    
        <http auto-config="true" />
    
        <beans:bean id="myUserService" class="org.my.UserService" />
        <authentication-provider user-service-ref="myUserService" />
    
    </beans:beans>

    Ahora debe crear org.my.UserService clase e implementar la interfaz de org.springframework.security.core.userdetails.UserDetailsService. Esta interfaz tiene un método:

    UserDetails loadUserByUsername(String username) throws UsernameNotFoundException, org.springframework.dao.DataAccessException

    Y en este método, usted puede usar el modo de Hibernación para cargar un usuario. Si el usuario no existe – acaba de lanzar UsernameNotFoundException, en caso contrario, devuelve nueva intialized UserDetails instancia (no puede proporcionar un montón de cosas como los roles de usuario de cuenta, fecha de vencimiento, etc…).

    Ahora viene web.xml:

    <web-app xmlns="http://java.sun.com/xml/ns/javaee"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
             version="2.5">
    
        <display-name>My Webapp</display-name>
    
        <context-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>
                /WEB-INF/spring/*-context.xml
            </param-value>
        </context-param>
    
        <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>
    
        <listener>
            <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
        </listener>
    
        <servlet>
            <servlet-name>dispatcher</servlet-name>
            <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
            <load-on-startup>1</load-on-startup>
        </servlet>
    
        <servlet-mapping>
            <servlet-name>dispatcher</servlet-name>
            <url-pattern>/*</url-pattern>
        </servlet-mapping>
    
    </web-app>

    Si usted tiene alguna pregunta o algo va mal, no dude en preguntar 🙂

    PS: Así que con UserDetailsService usted no tiene que comprobar la contraseña de si la cuenta de usuario está activo, etc. Usted acaba de proporcionar la primavera de información de seguridad sobre el usuario siempre userName y marco valida usuario. Si usted codificar tus contraseñas con MD5 por ejemplo, que puede utilizar password-encoder como este:

    <beans:bean id="myUserService" class="org.my.UserService" />
    <authentication-provider user-service-ref="myUserService">
        <password-encoder hash="md5"/>
    </authentication-provider>

    Actualización

    Ahora vamos a bucear más profundamente en UserService – mi (simplificado) ejemplo del mundo real.

    UserService clase:

    import org.my_company.my_app.domain.User
    
    public class UserService implements UserDetailsService {
        private UserDao userDao;
    
        public void setUserDao(UserDao userDao) {
            this.userDao = userDao;
        }
    
        public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException, DataAccessException {
            //load user
            User user = userDao.getUser(username);
    
            if (user != null) {
    
                //convert roles
                List<GrantedAuthority> roles = new ArrayList<GrantedAuthority>();
                for (Privilege p : user.getPrivileges()) {
                    roles.add(new GrantedAuthorityImpl(p.getName()));
                }
    
                //initialize user
                SecurityUser securityUser = new SecurityUser(
                    user.getUsername(),
                    user.getLdapAuth() ? getLdapPassword(user.getUsername()) : user.getPassword(),
                    user.getStatus() != User.Status.NOT_COMMITED, user.getStatus() != User.Status.BLOCKED, true, true,
                    roles.toArray(new GrantedAuthority[0])
                );
    
                securityUser.setUser(user);
    
                return securityUser;
            } else {
                throw new UsernameNotFoundException("No user with username '" + username + "' found!");
            }
        }
    }

    Ahora SecurityUser:

    import org.my_company.my_app.domain.User
    
    public class SecurityUser extends org.springframework.security.core.userdetails.User {
    
        private User user;
    
        public User getUser() {
            return user;
        }
    
        public void setUser(User user) {
            this.user = user;
        }
    
        public SecurityUser(String username, String password, boolean enabled, boolean accountNonExpired, boolean credentialsNonExpired, boolean accountNonLocked, GrantedAuthority[] authorities) throws IllegalArgumentException {
            super(username, password, enabled, accountNonExpired, credentialsNonExpired, accountNonLocked, authorities);
        }
    }

    Y finalmente UserDao:

    import org.my_company.my_app.domain.User
    
    public class UserDao extends HibernateDaoSupport {
    
        public User getUser(String username) {
            List users = getHibernateTemplate().find("from User where username = ?", username);
            return users == null || users.size() <= 0 ? null : (User) users.get(0);
        }
    }

    Como puedes ver he usado HibernateTemplate aquí.

    • Ángel, sé que esto es viejo, pero estoy confundido acerca de las Entidades, cuando el uso de Hibernate. En tu ejemplo, hace hibernar detectar automáticamente el Usuario y el Rol de las entidades de la org.springframework.security.core.userdetails paquete y crear las tablas correspondientes?
    • Me pregunto, ¿que te hace creer en tal cosa? Con el fin de utilizar estas clases de Hibernación necesita al menos saber cómo mapa en DB (ya sea a través de anotaciones o asignaciones XML). Entonces usted necesita decirle a Hibernate explícitamente dónde buscar asignaciones/clases persistentes. En mi ejemplo he creado mi propia User clase, que no está relacionado con org.springframework.security.core.userdetails.User.
    • y que fue SecurityUser que se extendió User derecho? O se trataba de una Entidad de otro llamado User? La confusión es que en su UserDao su consulta es from User ... donde la única mención del objeto de Usuario es el único en la primavera paquete de seguridad.
    • He añadido algunas importaciones para que quede claro. Modo de Hibernación sólo sabe acerca de org.my_company.my_app.domain.User. Y esta realidad la razón por la que he utilizado nombre completo para org.springframework.security.core.userdetails.User en SecurityUser clase (para evitar conflictos de nombres, pero sin que esta importación es difícil de adivinar :). Espero que esto deja claro ahora.
    • Gracias, voy a intentar poner en práctica este nuevo más tarde esta noche. Estoy asumiendo que su User implementa User Details? Y que tiene algo así como una Roles Entidad que implementa GrantedAuthorities?
    • Normalmente puedo crear User, Privilege, Group y Role clases de entidad en mis proyectos. Estas clases sería guardado en la DB y administrado por Hibernate. La primavera de la Seguridad del modelo es mucho más simple, y me acabo de adaptar el modelo a la primavera de la seguridad del modelo. SecurityUser sirve como punto de integración entre estos dos modelos en este ejemplo.
    • Puedo usar @Preautorizar de los métodos mediante el uso de este código?

  2. 5

    El básico de xml de configuración se puede ver en el post de «Fácil Ángulo». La parte que mencionó como «myUserService» es un bean que implementa la «UserDetailService»
    Que uno tiene básicamente un método para implementar el cual es el siguiente

    public UserDetails loadUserByUsername(String name) throws UsernameNotFoundException, DataAccessException

    Si utiliza la Primavera, entonces usted probablemente tendrá un Bean, que controla el acceso a su Usuario de la Tabla. Que uno sólo puede inyectar en la clase para recuperar los datos del Usuario, como:

        @Override
        public UserDetails loadUserByUsername(String name) throws UsernameNotFoundException, DataAccessException {
    
            UserTable user = userbean.getUserbyName(name);
            if (user == null) {
                throw new UsernameNotFoundException("User " + name + " not found!");
            }
            Collection<GrantedAuthority> auth = getAuthorities(user.getAuthorities());
            return new User(user.getName(), user.getPassword(), true, true, true, true, auth);
        }

    Ahora en una autenticación de frijol de todo lo que usted necesita es la inyección de este grano y preguntar por el UserDetails. No se puede utilizar para comprobar si las credenciales son correctas y si es así llenar el SecurityContext con la información necesaria para estar conectado.

        @Override
        public Boolean authenticate(String username, String password) {
            UserDetails userdetail = null;
            try {
                userdetail = myUserService.loadUserByUsername(username);
            } catch (UsernameNotFoundException e) {
                return false;
            } catch (DataAccessException e) {
                return false;
            }
            if (!myUserService.encodePassword(password).equals(userdetail.getPassword())) {
                return false;
            }
    
            Authentication auth = new UsernamePasswordAuthenticationToken(userdetail.getUsername(), userdetail.getPassword(),
                    userdetail.getAuthorities());
            SecurityContext sc = new SecurityContextImpl();
    
            ServletRequestAttributes attr = (ServletRequestAttributes)RequestContextHolder.currentRequestAttributes();
            attr.getRequest().getSession().setAttribute(UsernamePasswordAuthenticationFilter.SPRING_SECURITY_LAST_USERNAME_KEY, userdetail.getUsername());
    
            sc.setAuthentication(auth);
            SecurityContextHolder.setContext(sc);
    
            return true;
        }

    Por supuesto que es una versión simplificada de la real. Hay más controles que se deben realizar antes de decir que el usuario es autenticado (SQLInjection, por ejemplo)

  3. 3

    App-fusible le dará un completo ejemplo de trabajo: http://appfuse.org/display/APF/AppFuse+inicio rápido

    O si usted tiene instalado maven simplemente ejecutar:

    mvn archetype:generate -B -DarchetypeGroupId=org.appfuse.archetypes -DarchetypeArtifactId=appfuse-light-spring-security-archetype -DarchetypeVersion=2.1.0-M2 -DgroupId=com.mycompany -DartifactId=myproject

    Que esto va a generar un appfuse la luz del proyecto con spring mvc, spring security y de hibernación.

Dejar respuesta

Please enter your comment!
Please enter your name here