Spring Security + Hibernate XML示例

最新推荐文章于 2024-08-04 11:07:52 发布
最新推荐文章于 2024-08-04 11:07:52 发布
阅读量142 收藏
点赞数
文章标签： java 数据库 web.xml
Spring休眠徽标

在本教程中，我们将向您展示如何在Spring Security XML配置示例中集成Hibernate 4。

注意
对于注释版本，请阅读此Spring Security + Hibernate注释示例 。

使用的技术：

  1. 春天3.2.8。发布
  2. Spring Security 3.2.3发布
  3. 休眠4.2.11.Final
  4. MySQL服务器5.6
  5. JDK 1.6
  6. Maven 3
  7. Eclipse 4.3

快速笔记

  1. 使用hibernate4.LocalSessionFactoryBean创建一个会话工厂
  2. 将会话工厂注入UserDao
  3. 要与Spring Security集成，请创建一个实现UserDetailsService接口的类，并使用UserDao加载User
  4. 必须声明事务管理器，否则Hibernate在Spring中将无法工作

1.项目目录

最终项目目录结构。

Spring安全休眠目录

2.项目依赖性

POM文件中项目的依赖项列表。

pom.xml 
<properties>
		<spring.version>3.2.8.RELEASE</spring.version>
		<spring.security.version>3.2.3.RELEASE</spring.security.version>
		<jstl.version>1.2</jstl.version>
		<mysql.connector.version>5.1.30</mysql.connector.version>
		<logback.version>1.1.2</logback.version>
		<slf4j.version>1.7.6</slf4j.version>
		<hibernate.version>4.2.11.Final</hibernate.version>
		<dbcp.version>1.4</dbcp.version>
		<servletapi.version>2.5</servletapi.version>
	</properties>

	<dependencies>

		<!-- database pool -->
		<dependency>
			<groupId>commons-dbcp</groupId>
			<artifactId>commons-dbcp</artifactId>
			<version>${dbcp.version}</version>
		</dependency>

		<!-- Hibernate ORM -->
		<dependency>
			<groupId>org.hibernate</groupId>
			<artifactId>hibernate-core</artifactId>
			<version>${hibernate.version}</version>
		</dependency>

		<!-- Spring 3 dependencies -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-core</artifactId>
			<version>${spring.version}</version>
			<exclusions>
			  <exclusion>
				<groupId>commons-logging</groupId>
				<artifactId>commons-logging</artifactId>
			  </exclusion>
			</exclusions>
		</dependency>

		<!-- Spring MVC -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-webmvc</artifactId>
			<version>${spring.version}</version>
		</dependency>

		<!-- Spring + aspects -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-aspects</artifactId>
			<version>${spring.version}</version>
		</dependency>

		<!-- ORM integration, e.g Hibernate -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-orm</artifactId>
			<version>${spring.version}</version>
		</dependency>

		<!-- Spring Security -->
		<dependency>
			<groupId>org.springframework.security</groupId>
			<artifactId>spring-security-web</artifactId>
			<version>${spring.security.version}</version>
		</dependency>

		<dependency>
			<groupId>org.springframework.security</groupId>
			<artifactId>spring-security-config</artifactId>
			<version>${spring.security.version}</version>
		</dependency>

		<!-- Spring Security JSP Taglib -->
		<dependency>
			<groupId>org.springframework.security</groupId>
			<artifactId>spring-security-taglibs</artifactId>
			<version>${spring.security.version}</version>
		</dependency>

		<!-- jstl for jsp page -->
		<dependency>
			<groupId>jstl</groupId>
			<artifactId>jstl</artifactId>
			<version>${jstl.version}</version>
		</dependency>

		<!-- MySql Driver -->
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<version>${mysql.connector.version}</version>
		</dependency>

		<!-- logging, slf4j -->
		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>slf4j-api</artifactId>
			<version>${slf4j.version}</version>
		</dependency>

		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>jcl-over-slf4j</artifactId>
			<version>${slf4j.version}</version>
		</dependency>

		<dependency>
			<groupId>ch.qos.logback</groupId>
			<artifactId>logback-classic</artifactId>
			<version>${logback.version}</version>
		</dependency>

		<dependency>
			<groupId>javax.servlet</groupId>
			<artifactId>servlet-api</artifactId>
			<version>${servletapi.version}</version>
			<scope>provided</scope>
		</dependency>

	</dependencies>

3.用户表

创建表以存储用户和用户角色的SQL脚本。

mysql.sql 
CREATE  TABLE users (
  username VARCHAR(45) NOT NULL ,
  password VARCHAR(60) NOT NULL ,
  enabled TINYINT NOT NULL DEFAULT 1 ,
  PRIMARY KEY (username));

CREATE TABLE user_roles (
  user_role_id int(11) NOT NULL AUTO_INCREMENT,
  username varchar(45) NOT NULL,
  role varchar(45) NOT NULL,
  PRIMARY KEY (user_role_id),
  UNIQUE KEY uni_username_role (role,username),
  KEY fk_username_idx (username),
  CONSTRAINT fk_username FOREIGN KEY (username) REFERENCES users (username));

INSERT INTO users(username,password,enabled)
VALUES ('mkyong','$2a$10$04TVADrR6/SPLBjsK0N30.Jf5fNjBugSACeGv1S69dZALR7lSov0y', true);
INSERT INTO users(username,password,enabled)
VALUES ('alex','$2a$10$04TVADrR6/SPLBjsK0N30.Jf5fNjBugSACeGv1S69dZALR7lSov0y', true);

INSERT INTO user_roles (username, role)
VALUES ('mkyong', 'ROLE_USER');
INSERT INTO user_roles (username, role)
VALUES ('mkyong', 'ROLE_ADMIN');
INSERT INTO user_roles (username, role)
VALUES ('alex', 'ROLE_USER');

4.用户模型+ Hibernate XML映射

模型类及其XML映射文件。

User.java 
package com.mkyong.users.model;

import java.util.HashSet;
import java.util.Set;

public class User {
	
	private String username;
	private String password;
	private boolean enabled;
	private Set<UserRole> userRole = new HashSet<UserRole>(0);
	
	//getter and setter methods
}
UserRole.java 
package com.mkyong.users.model;

public class UserRole{

	private Integer userRoleId;
	private User user;
	private String role;

	//getter and setter methods
}
Users.hbm.xml 
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
    <class name="com.mkyong.users.model.User" table="users" catalog="test">
        <id name="username" type="string">
            <column name="username" length="45" />
            <generator class="assigned" />
        </id>
        <property name="password" type="string">
            <column name="password" length="60" not-null="true" />
        </property>
        <property name="enabled" type="boolean">
            <column name="enabled" not-null="true" />
        </property>
        <set name="userRole" table="user_roles" inverse="true" lazy="true" fetch="select">
            <key>
                <column name="username" length="45" not-null="true" />
            </key>
            <one-to-many class="com.mkyong.users.model.UserRole" />
        </set>
    </class>
</hibernate-mapping>
UserRoles.hbm.xml 
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
    <class name="com.mkyong.users.model.UserRole" table="user_roles" catalog="test">
        <id name="userRoleId" type="java.lang.Integer">
            <column name="user_role_id" />
            <generator class="identity" />
        </id>
        <many-to-one name="user" class="com.mkyong.users.model.User" fetch="select">
            <column name="username" length="45" not-null="true" />
        </many-to-one>
        <property name="role" type="string">
            <column name="role" length="45" not-null="true" />
        </property>
    </class>
</hibernate-mapping>

5. DAO类

创建一个UserDao类，以通过Hibernate从数据库中加载用户。

UserDao.java 
package com.mkyong.users.dao;

import com.mkyong.users.model.User;

public interface UserDao {

	User findByUserName(String username);

}
UserDaoImpl.java 
package com.mkyong.users.dao;

import java.util.ArrayList;
import java.util.List;
import org.hibernate.SessionFactory;

import com.mkyong.users.model.User;

public class UserDaoImpl implements UserDao {

	private SessionFactory sessionFactory;

	@SuppressWarnings("unchecked")
	public User findByUserName(String username) {

		List<User> users = new ArrayList<User>();

		users = getSessionFactory().getCurrentSession()
			.createQuery("from User where username=?")
			.setParameter(0, username).list();

		if (users.size() > 0) {
			return users.get(0);
		} else {
			return null;
		}

	}

	public SessionFactory getSessionFactory() {
		return sessionFactory;
	}

	public void setSessionFactory(SessionFactory sessionFactory) {
		this.sessionFactory = sessionFactory;
	}

}

6. UserDetailsS​​ervice

创建一个自定义UserDetailsService ，从UserDao加载用户，然后构建用户的权限。

注意
示例是从此Spring的JdbcDaoImpl中引用的

MyUserDetailsService.java 
package com.mkyong.users.service;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;

import com.mkyong.users.dao.UserDao;
import com.mkyong.users.model.UserRole;

public class MyUserDetailsService implements UserDetailsService {

	private UserDao userDao;

	@Override
	public UserDetails loadUserByUsername(final String username) 
               throws UsernameNotFoundException {

		com.mkyong.users.model.User user = userDao.findByUserName(username);
		List<GrantedAuthority> authorities = buildUserAuthority(user.getUserRole());

		return buildUserForAuthentication(user, authorities);
		

	}

	// Converts com.mkyong.users.model.User user to
	// org.springframework.security.core.userdetails.User
	private User buildUserForAuthentication(com.mkyong.users.model.User user, 
		List<GrantedAuthority> authorities) {
		return new User(user.getUsername(), 
			user.getPassword(), user.isEnabled(), 
                        true, true, true, authorities);
	}

	private List<GrantedAuthority> buildUserAuthority(Set<UserRole> userRoles) {

		Set<GrantedAuthority> setAuths = new HashSet<GrantedAuthority>();

		// Build user's authorities
		for (UserRole userRole : userRoles) {
			setAuths.add(new SimpleGrantedAuthority(userRole.getRole()));
		}

		List<GrantedAuthority> Result = new ArrayList<GrantedAuthority>(setAuths);

		return Result;
	}

	public UserDao getUserDao() {
		return userDao;
	}

	public void setUserDao(UserDao userDao) {
		this.userDao = userDao;
	}

}

7. Spring Security XML

阅读评论，应该不言自明。

spring-security.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-3.0.xsd
	http://www.springframework.org/schema/security
	http://www.springframework.org/schema/security/spring-security-3.2.xsd">

	<!-- enable use-expressions -->
	<http auto-config="true" use-expressions="true">
		<intercept-url pattern="/admin**" access="hasRole('ROLE_ADMIN')" />

		<!-- access denied page -->
		<access-denied-handler error-page="/403" />
		<form-login 
		    login-page="/login" 
		    default-target-url="/welcome"
			authentication-failure-url="/login?error" 
			username-parameter="username"
			password-parameter="password" />
		<logout logout-success-url="/login?logout" />
		<!-- enable csrf protection -->
		<csrf />
	</http>

	<authentication-manager>
		<authentication-provider user-service-ref="myUserDetailsService" >
			<password-encoder hash="bcrypt" />    
		</authentication-provider>
	</authentication-manager>

</beans:beans>
spring-database.xml 
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
	xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
	http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 
	http://www.springframework.org/schema/aop 
	http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
	http://www.springframework.org/schema/tx
    http://www.springframework.org/schema/tx/spring-tx-3.0.xsd">

	<!-- MySQL data source -->
	<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
		destroy-method="close">

		<property name="driverClassName" value="com.mysql.jdbc.Driver" />
		<property name="url" value="jdbc:mysql://localhost:3306/test" />
		<property name="username" value="root" />
		<property name="password" value="password" />
	</bean>

	<!-- Hibernate session factory -->
	<bean id="sessionFactory"
		class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
		<property name="dataSource" ref="dataSource" />
		<property name="mappingResources">
			<list>
				<value>orm/Users.hbm.xml</value>
				<value>orm/UserRoles.hbm.xml</value>
			</list>
		</property>
		<property name="hibernateProperties">
		    <props>
			<prop key="hibernate.dialect">
                           org.hibernate.dialect.MySQL5Dialect
                        </prop>
			<prop key="hibernate.format_sql">true</prop>
			<prop key="hibernate.show_sql">true</prop>
		    </props>
		</property>
	</bean>

	<bean id="userDao" class="com.mkyong.users.dao.UserDaoImpl">
		<property name="sessionFactory" ref="sessionFactory" />
	</bean>

	<bean id="myUserDetailsService" 
                class="com.mkyong.users.service.MyUserDetailsService">
		<property name="userDao" ref="userDao" />
	</bean>

	<!-- MUST have transaction manager, using aop and aspects  -->
	<bean id="transactionManager"
		class="org.springframework.orm.hibernate4.HibernateTransactionManager">
		<property name="sessionFactory" ref="sessionFactory"></property>
	</bean>

	<tx:advice id="txAdvice" transaction-manager="transactionManager">
	    <tx:attributes>
		<tx:method name="get*" read-only="true" />
		<tx:method name="find*" read-only="true" />
		<tx:method name="*" />
	    </tx:attributes>
	</tx:advice>

	<aop:config>
	    <aop:pointcut id="userServicePointCut"
		expression="execution(* com.mkyong.users.service.*Service.*(..))" />
	    <aop:advisor advice-ref="txAdvice" pointcut-ref="userServicePointCut" />
	</aop:config>

</beans>

做完了

注意
那些JSP，web.xml和控制器文件被省略，这是一个标准的代码，如果您对此感兴趣，请在文章末尾下载完整的源代码。

8.项目演示

以下视频演示用于使用JDBC教程登录Spring Security数据库 。 由于本教程生成了相同的输出，但是使用了Hibernate来加载User，因此可以重用视频演示。

8.1进入密码保护页面：http：// localhost：8080 / spring-security-hibernate / admin，显示登录页面。

Spring安全冬眠1

8.2输入用户“ mkyong”和密码“ 123456”。

Spring安全冬眠2

8.3尝试使用用户“ alex”和密码“ 123456”访问/admin页面，将显示403页面。

Spring安全冬眠3

下载源代码

下载它– spring-security-hibernate.zip （30 KB）

参考文献

  1. SpringORM –休眠
  2. Spring Hibernate4 LocalSessionFactoryBean JavaDoc
  3. Spring Hibernate3 LocalSessionFactoryBean JavaDoc
  4. Spring交易管理
  5. Hibernate ORM文档
  6. 使用JDBC和数据库使用Spring Security Form登录
  7. Hibernate：找不到当前线程的会话
标签：

翻译自: https://mkyong.com/spring-security/spring-security-hibernate-xml-example/

cyan20115
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
基于springsecurity+springmvc+spring+hibernate的权限管理系统（免积分）
01-16
基于springsecurity+springmvc+spring+hibernate的权限管理系统，实现资源、用户、权限、角色的增删改查，角色-资源管理，用户-角色管理等基础功能，可以作为springmvc+spring+hibernate的增删改查入门项目，也可以对spring-security简单了解，界面使用bootstrap3，非常简洁，免积分
Spring Security 4 整合Hibernate 实现持久化登录验证（带源码）
明明如月的技术博客
05-05 8480
上一篇文章：Spring Security 4 整合Hibernate Bcrypt密码加密（带源码） 原文地址：http://websystique.com/spring-security/spring-security-4-remember-me-example-with-hibernate/ 【相关已翻译的本系列其他文章，点击分类里面的spring security 4】
Spring Security 4 Hibernate整合 注解和xml例子（带源码）
明明如月的技术博客
05-05 6204
【相关已翻译的本系列其他文章，点击分类里面的spring security 4】 【剩余文章，将尽快翻译完毕，敬请期待。 翻译by 明明如月 QQ 605283073】 原文地址： http://websystique.com/spring-security/spring-security-4-hibernate-annotation-example/ 本教程通过注解和x
SpringMVC+springAOP+spring security+Hibernate整合实例代码
01-12
SpringMVC+springAOP+spring security+Hibernate整合实例代码，包含框架jar包
Spring4 整合SpringMVC, Hibernate5, SpringSecurity4.2 源码
04-09
Spring4 整合SpringMVC, Hibernate5, SpringSecurity4.2 源码。 直接可用于项目开发。
Spring MVC4 + Spring Security4 + Hibernate实例
weixin_34138056的博客
01-25 233
http://www.yiibai.com/spring-security/spring-mvc-4-and-spring-security-4-integration-example.html 在这篇教程文章中，我们将使用Spring Security，Hibernate+MySQL数据库来集成构建一个成熟的Spring MVC应用程序。处理多对多映射关系，同时利用BCrypt格式加密密码存储，...
springsecurity+springmvc+spring+hibernate
01-18
基于springsecurity+springmvc+spring+hibernate的权限管理系统，实现资源、用户、权限、角色的增删改查，角色-资源管理，用户-角色管理等基础功能
Spring Security搭配hibernate,Mysql
u013571243的专栏
08-18 933
原文点击打开链接   基于原文的学习,和配置,源码未改,就是认识了如何配置Spring Security,自定义jsp等,Spring Security类似.net MVC5自带的用户管理,可以让我们安全可靠的配置用户这一模块 1.pom.xml配置 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http:/
Hibernate 5.1概述
成长的足迹
05-24 2586
Hibernate是一个针对Java应用的ORM解决方案。 1. 从架构上说，Hibernate在JDBC基础之上，基于JPA或Hibernate Native API，为应用提供统一的访问层，如下图所示： 2. Hibernate实现了2组数据访问的API，一个是JavaEE标准的JPA，另一个是Hibernate独有的Hibernate Native API。 2组API
基于Spring MVC+Hibernate+Spring Security+Mysql 的B/S应用系统平台设计与实现
秋风瑟瑟
04-27 4836
摘要：进入二十一世纪，信息化发展潮流越来越快，很多企业（包括中小企业）为了节省企业成本，提高生产效率，加快企业发展步伐而进入企业信息化改造，对于整个社会企业的发展蓝图来讲，无疑是一件很好的事情。 但是随着企业的发展不断向前，信息化改造越来越高的要求变化，结合当前应用系统的发展，权限设计成了信息化改造的头等大事，因为权限问题出现的企业保密问题案例屡见不鲜。当然，对于中小企业来讲，比起大型企业要简单得多。
Spring boot+Spring Security 4配置整合实例
威尼斯的泪
03-22 5384
本例所覆盖的内容：1. 使用Spring Security管理用户身份认证、登录退出2. 用户密码加密及验证3. 采用数据库的方式实现Spring Security的remember-me功能4. 获取登录用户信息。5.使用Spring Security管理url和权限 本例所使用的框架：1. Spring boot2. Spring MVC3. Spring Security4. Spring ...
枚举工具类
qq_43049583的博客
08-04 222
java枚举工具类
等待唤醒机制两种实现方法-阻塞队列
最新发布
泰勒今天想展开的博客
08-04 286
桌子上有面条-》吃货执行桌子上没面条-》生产者制造执行。
社区养老服务小程序的设计
Karen198的博客
07-31 617
管理员账户功能包括：系统首页，个人中心，用户管理，服务人员管理，服务产品管理，服务预约管理，服务状态管理，服务退订管理，活动管理，视频管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。服务器：SpringBoot自带 apache tomcat。微信端账号功能包括：系统首页，服务产品，活动，视频，我的。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发工具：IDEA(推荐)开发系统：Windows。
Springboot+Websocket+Security+Vue 实现弹幕推送功能
Gemini1995的博客
08-01 565
【代码】Springboot+Websocket+Security+Vue 实现弹幕推送功能。
JavaSE面向对象进阶
qq_45348840的博客
07-30 531
需求：在实际开发中，经常会遇到一些数组使用的工具类;请按照如下要求编写一个数组的工具类：ArrayUtil提供一个工具类方法printArr,用于返回整数数组的内容。返回的字符串格式如：[10,20,50,34,100 ]（只考虑整数数组，且只考虑一维数组)提供这样一个工具方法getAerage,用于返回平均分。（只考虑浮点型数组，且只考虑一维数组)定义一个测试类TestDemo,调用该工具类的工具方法，并返回结果。// 私有化构造方法// 定义静态方法，方便调用。i++) {
花几千上万学习Java，真没必要！（三十五）
wehpd的博客
07-30 704
集合之Map
26.jdk源码阅读之ConcurrentLinkedQueue
前端、移动端、后端源码级底层原理分享
07-29 1016
ConcurrentLinkedQueue 是 Java 中提供的一个基于无界非阻塞算法的线程安全队列。它是一个适用于高并发环境的队列实现，基于链表结构。
javaweb_03：在ide中配置tomcat
qq_52200849的博客
08-01 190
④创建artifact。②点击加号创建，选择。
Struts2.0+Spring2.0+Hibernate3.1集成应用：权限管理实践
本资源是一个基于Struts2.0、Spring2.0和Hibernate3.1的Web应用程序示例，该示例集成了ACEGI安全框架进行权限管理。开发者通过此示例展示了如何将这三个流行的技术框架整合在一起，构建一个功能完善的Web应用。 **...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值