研究，百度，查资料+好友帮助，使用MyEcplise2015工具，通过maven搭建hibernate+springMVC+spring的项目，数据库采用MySql5.5 不过使用的版本会在项目搭建过程中介绍。
大概就是下面的几个步骤：
1. 设计数据库，得到数据库
2.使用maven搭建项目，导入包的依赖
3.引入spring的配置信息，放在资源文件中
4.引入Log4j日志文件配置
5.配置hibernate
6.配置ehcache.xml
7.使用hibernate tools生成实体
8.创建Dao层、service层
9.配置spring-mvc.xml
10.配置web.xml容器
11.创建Controller层
12.创建view层
13.打包，部署，运行项目
1.设计数据库，并创建数据库
1.1 使用powerDesigner,设计数据表，生成cdm
设计三个数据表分别为角色表，权限表以及用户表，三张表之间分别是多对多的关系。三个实体的主键均使用UUID，因此设计主键长度为varchar(36)
1.2 继续生成pdm
由于三张表之间是多对多，生成两张中间表，分别是角色权限表和用户角色表
这个怎么用就不介绍了，总而言之，最后生成SQL语句，然后在MySQL运行，创建一个新的数据库，生成如下的数据库：
2.创建maven项目，导入项目所需依赖架包
2.1创建maven项目
新创建成的maven项目结构如下，我们将这个项目结构完善
首先将这个项目转化为web项目，项目右键-->properties，在设置过程中，注意Web版本与jave版本的相互支持
项目转成web项目之后，会生成下面的这个目录
我们要做的就是把这个WebRoot目录下的东西放到src下的webapp下，让它符合maven项目的结构标准.然后，删除WebRoot目录即可。
2.2 调一下项目中的小错误
首先双击pom.xml文件，设置web版本
双击Inxde.jsp文件，发现没有httpservlet架包，那我们就进入build path，给项目添加所支持架包
既然改到这里了，我们的JRE版本太低了，把它替换成高的版本，顺便把J2EE的架包也搞进来，以备不时之需
搞进来J2EE的lib
搞进来JRE的lib
此时，小错误全部消除完成，现在的项目结构如下所示：
2.3 现在配置pom.xml。导入项目依赖架包
1 <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"> 2 <modelVersion>4.0.0</modelVersion> 3 <groupId>com.it</groupId> 4 <artifactId>mySecond</artifactId> 5 <version>0.0.1-SNAPSHOT</version> 6 <packaging>war</packaging> 7 <build> 8 <plugins> 9 <plugin> 10 <artifactId>maven-war-plugin</artifactId> 11 <configuration> 12 <version>3.0</version> 13 </configuration> 14 </plugin> 15 </plugins> 16 </build> 17 18 <name>myAgen</name> 19 <url>http://maven.apache.org</url> 20 21 <properties> 22 <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> 23 <spring.version>4.1.4.RELEASE</spring.version> 24 <hibernate.version>4.3.8.Final</hibernate.version> 25 <jackson.version>2.5.0</jackson.version> 26 27 </properties> 28 29 <dependencies> 30 31 <!-- junit --> 32 <dependency> 33 <groupId>junit</groupId> 34 <artifactId>junit</artifactId> 35 <version>4.12</version> 36 <scope>test</scope> 37 </dependency> 38 39 <!-- spring --> 40 <dependency> 41 <groupId>org.springframework</groupId> 42 <artifactId>spring-core</artifactId> 43 <version>${spring.version}</version> 44 </dependency> 45 46 <dependency> 47 <groupId>org.springframework</groupId> 48 <artifactId>spring-beans</artifactId> 49 <version>${spring.version}</version> 50 </dependency> 51 52 <dependency> 53 <groupId>org.springframework</groupId> 54 <artifactId>spring-context</artifactId> 55 <version>${spring.version}</version> 56 </dependency> 57 58 <dependency> 59 <groupId>org.springframework</groupId> 60 <artifactId>spring-tx</artifactId> 61 <version>${spring.version}</version> 62 </dependency> 63 64 <dependency> 65 <groupId>org.springframework</groupId> 66 <artifactId>spring-web</artifactId> 67 <version>${spring.version}</version> 68 </dependency> 69 70 <dependency> 71 <groupId>org.springframework</groupId> 72 <artifactId>spring-test</artifactId> 73 <version>${spring.version}</version> 74 <scope>test</scope> 75 </dependency> 76 77 <!-- 使用SpringMVC需配置 --> 78 <dependency> 79 <groupId>org.springframework</groupId> 80 <artifactId>spring-webmvc</artifactId> 81 <version>${spring.version}</version> 82 </dependency> 83 <!-- spring cglib 代理 --> 84 <dependency> 85 <groupId>cglib</groupId> 86 <artifactId>cglib</artifactId> 87 <version>2.2.2</version> 88 </dependency> 89 <!-- 关系型数据库整合时需配置 如hibernate jpa等 --> 90 <dependency> 91 <groupId>org.springframework</groupId> 92 <artifactId>spring-orm</artifactId> 93 <version>${spring.version}</version> 94 </dependency> 95 96 <!-- hibernate --> 97 <dependency> 98 <groupId>org.hibernate</groupId> 99 <artifactId>hibernate-core</artifactId> 100 <version>${hibernate.version}</version> 101 </dependency> 102 103 <dependency> 104 <groupId>org.hibernate</groupId> 105 <artifactId>hibernate-ehcache</artifactId> 106 <version>${hibernate.version}</version> 107 </dependency> 108 109 <!-- 二级缓存ehcache --> 110 <dependency> 111 <groupId>net.sf.ehcache</groupId> 112 <artifactId>ehcache</artifactId> 113 <version>2.9.0</version> 114 </dependency> 115 116 <!-- log4j --> 117 <dependency> 118 <groupId>log4j</groupId> 119 <artifactId>log4j</artifactId> 120 <version>1.2.17</version> 121 </dependency> 122 123 <!-- mysql连接 --> 124 <dependency> 125 <groupId>mysql</groupId> 126 <artifactId>mysql-connector-java</artifactId> 127 <version>5.1.34</version> 128 </dependency> 129 130 <!-- c3p0数据源 --> 131 <dependency> 132 <groupId>com.mchange</groupId> 133 <artifactId>c3p0</artifactId> 134 <version>0.9.5-pre10</version> 135 </dependency> 136 137 <!-- json --> 138 <dependency> 139 <groupId>com.alibaba</groupId> 140 <artifactId>fastjson</artifactId> 141 <version>1.2.3</version> 142 </dependency> 143 144 <dependency> 145 <groupId>com.fasterxml.jackson.core</groupId> 146 <artifactId>jackson-annotations</artifactId> 147 <version>${jackson.version}</version> 148 </dependency> 149 150 <dependency> 151 <groupId>com.fasterxml.jackson.core</groupId> 152 <artifactId>jackson-core</artifactId> 153 <version>${jackson.version}</version> 154 </dependency> 155 156 <dependency> 157 <groupId>com.fasterxml.jackson.core</groupId> 158 <artifactId>jackson-databind</artifactId> 159 <version>${jackson.version}</version> 160 </dependency> 161 162 <!-- aop --> 163 <dependency> 164 <groupId>org.aspectj</groupId> 165 <artifactId>aspectjweaver</artifactId> 166 <version>1.8.4</version> 167 </dependency> 168 169 <!-- servlet --> 170 <dependency> 171 <groupId>javax.servlet</groupId> 172 <artifactId>servlet-api</artifactId> 173 <version>3.0-alpha-1</version> 174 <scope>provided</scope> 175 </dependency> 176 177 <dependency> 178 <groupId>javax.servlet</groupId> 179 <artifactId>jstl</artifactId> 180 <version>1.2</version> 181 </dependency> 182 183 </dependencies> 184 </project>
3.引入spring的配置信息，放在资源文件中
在
路径下创建config.properties文件,这里面存放的就是一堆的变量，有关hibernate配置的变量
1 #application configs 2 3 #jdbc c3p0 config 4 jdbc.driver = com.mysql.jdbc.Driver 5 jdbc.url = jdbc:mysql://localhost:3306/testdb?useUnicode=true&characterEncoding=utf-8 6 jdbc.username = root 7 jdbc.password = root 8 9 #hibernate config 10 hibernate.dialect = org.hibernate.dialect.MySQLDialect 11 hibernate.show_sql = true 12 hibernate.format_sql = false 13 hibernate.hbm2ddl.auto = update 14 hibernate.cache.use_second_level_cache = true 15 hibernate.cache.use_query_cache = true 16 hibernate.cache.region.factory_class = org.hibernate.cache.ehcache.EhCacheRegionFactory 17 hibernate.cache.provider_configuration_file_resource_path =ehcache.xml
4.引入Log4j日志文件配置
在下创建log4j.properties,
1 ### set log levels ### 2 log4j.rootLogger = INFO , C , D , E 3 4 ### console ### 5 log4j.appender.C = org.apache.log4j.ConsoleAppender 6 log4j.appender.C.Target = System.out 7 log4j.appender.C.layout = org.apache.log4j.PatternLayout 8 log4j.appender.C.layout.ConversionPattern = [springmvc_hibernate_demo][%p] [%-d{yyyy-MM-dd HH:mm:ss}] %C.%M(%L) | %m%n 9 10 ### log file ### 11 log4j.appender.D = org.apache.log4j.DailyRollingFileAppender 12 log4j.appender.D.File = ../logs/springmvc_hibernate_demo.log 13 log4j.appender.D.Append = true 14 log4j.appender.D.Threshold = INFO 15 log4j.appender.D.layout = org.apache.log4j.PatternLayout 16 log4j.appender.D.layout.ConversionPattern = [springmvc_hibernate_demo][%p] [%-d{yyyy-MM-dd HH:mm:ss}] %C.%M(%L) | %m%n 17 18 ### exception ### 19 log4j.appender.E = org.apache.log4j.DailyRollingFileAppender 20 log4j.appender.E.File = ../logs/springmvc_hibernate_demo_error.log 21 log4j.appender.E.Append = true 22 log4j.appender.E.Threshold = ERROR 23 log4j.appender.E.layout = org.apache.log4j.PatternLayout 24 log4j.appender.E.layout.ConversionPattern =[sspringmvc_hibernate_demo][%p] [%-d{yyyy-MM-dd HH\:mm\:ss}] %C.%M(%L) | %m%n
5.配置hibernate
在下创建spring-hibernate.xml，其中配置了数据源dataSource,配置sessionFactory，配置事务管理器。【如果需要连接多干服务器上的多个数据库，那就可以再多配一份同样的dataSource,sessionFacrory，事务管理器，在注入的时候，在Controller中，@Resource（注明是哪个sessionFactory即可）这里可能有误，之后再说】
1 <?xml version="1.0" encoding="UTF-8"?> 2 <beans xmlns="http://www.springframework.org/schema/beans" 3 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 4 xmlns:tx="http://www.springframework.org/schema/tx" 5 xmlns:aop="http://www.springframework.org/schema/aop" 6 xmlns:context="http://www.springframework.org/schema/context" 7 xsi:schemaLocation="http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.1.xsd 8 http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.1.xsd 9 http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.1.xsd 10 http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.1.xsd"> 11 12 <!-- 自动扫描@Controller注入为bean --> 13 <context:property-placeholder location="classpath:config.properties"/> 14 15 16 <!-- 配置数据源 c3p0 --> 17 <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" 18 destroy-method="close"> 19 <property name="driverClass" value="${jdbc.driver}" /> 20 <property name="jdbcUrl" value="${jdbc.url}" /> 21 <property name="user" value="${jdbc.username}" /> 22 <property name="password" value="${jdbc.password}" /> 23 24 <!-- 请求超时时间 --> 25 <property name="checkoutTimeout" value="30000" /> 26 <!-- 每60秒检查所有连接池中的空闲连接。默认值: 0，不检查 --> 27 <property name="idleConnectionTestPeriod" value="30" /> 28 <!-- 连接数据库连接池最大空闲时间 --> 29 <property name="maxIdleTime" value="30" /> 30 <!-- 连接池初始化连接数 --> 31 <property name="initialPoolSize" value="5" /> 32 <property name="minPoolSize" value="5" /> 33 <property name="maxPoolSize" value="20" /> 34 <!--当连接池中的连接耗尽的时候c3p0一次同时获取的连接数。默认值: 3 --> 35 <property name="acquireIncrement" value="5" /> 36 </bean> 37 38 <!-- 配置hibernate的SessionFactory --> 39 <bean id="sessionFactory" 40 class="org.springframework.orm.hibernate4.LocalSessionFactoryBean"> 41 <!-- 注入数据源 相关信息看源码 --> 42 <property name="dataSource" ref="dataSource" /> 43 <!-- hibernate配置信息 --> 44 <property name="hibernateProperties"> 45 <props> 46 <prop key="hibernate.dialect">${hibernate.dialect}</prop> 47 <prop key="hibernate.show_sql">${hibernate.show_sql}</prop> 48 <prop key="hibernate.format_sql">${hibernate.format_sql}</prop> 49 <prop key="hibernate.hbm2ddl.auto">${hibernate.hbm2ddl.auto}</prop> 50 51 <!-- 开启二级缓存 ehcache --> 52 <prop key="hibernate.cache.use_second_level_cache">${hibernate.cache.use_second_level_cache}</prop> 53 <prop key="hibernate.cache.use_query_cache">${hibernate.cache.use_query_cache}</prop> 54 <prop key="hibernate.cache.region.factory_class">${hibernate.cache.region.factory_class}</prop> 55 <prop key="hibernate.cache.provider_configuration_file_resource_path">${hibernate.cache.provider_configuration_file_resource_path} 56 </prop> 57 </props> 58 </property> 59 <!-- 扫描hibernate注解配置的entity --> 60 <property name="packagesToScan" value="com.it.entity" /> 61 </bean> 62 63 <!-- 配置事务管理器 --> 64 <bean id="transactionManager" 65 class="org.springframework.orm.hibernate4.HibernateTransactionManager"> 66 <property name="sessionFactory" ref="sessionFactory" /> 67 </bean> 68 69 70 71 72 73 74 </beans>
6.配置ehcache.xml
在下创建ehcache.xml，配置的二级缓存
1 <?xml version="1.0" encoding="UTF-8"?> 2 <ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../config/ehcache.xsd"> 3 <diskStore path="D:/ehcache" /> 4 <!-- DefaultCache setting. --> 5 <defaultCache 6 maxElementsInMemory="1000" 7 eternal="false" 8 timeToIdleSeconds="120" 9 timeToLiveSeconds="120" 10 maxElementsOnDisk="1000000" 11 overflowToDisk="true" 12 memoryStoreEvictionPolicy="LRU"> 13 14 </defaultCache> 15 16 <!-- Special objects setting. --> 17 18 <cache 19 name="org.andy.work.entity.AcctUser" 20 maxElementsInMemory="2" 21 memoryStoreEvictionPolicy="LRU" 22 eternal="true" 23 diskPersistent="false" 24 overflowToDisk="false" 25 maxElementsOnDisk="1000000" /> 26 27 28 29 </ehcache>
7.使用hibernate tools生成实体
在MyEcplise右上角，点击【如果没有，就点击MyEcplise Java Enterprise 左边的小图标】MyEcplise Hibernate，进入
在这里，New一个新的连接。连接到指定的数据库上
编辑新的连接，下面的这些，必须完全一致，除了账号密码和驱动的路径，但是选择了驱动之后，Driver ClassName必须得是com.mysql.jdbc.Driver【如果是MySQL数据库的话】.
编辑完成之后可以Test Driver一下看看是否可以连接成功。
连接成功之后如下，我们就开始选择所有数据表，点击hibernate反转，生成entity
但是此刻发现我们要选择的folder中不能指定到我们的项目中，我们的项目没有被识别出来。
因此需要点击MyEcplise Jave Enterprise，回去设置我们的项目，让项目支持hibernate，或者说让项目变成hibernate项目
右键项目 --->properties--->Project Facets
完了之后会有两个自动生成的文件，看看是否需要留着，或者删除
然后再回到hibernate tools下面
这次就可以看到本项目了
因为要使用注解的形式，所以，按照下面的选择，
主键使用UUID,注意hibernate的版本的问题，需要注意选择的主键生成策略
包下生成的实体如下：
下面贴出来生成实体的代码：
Authority.java
1 package com.it.entity; 2 3 import java.util.HashSet; 4 import java.util.Set; 5 import javax.persistence.CascadeType; 6 import javax.persistence.Column; 7 import javax.persistence.Entity; 8 import javax.persistence.FetchType; 9 import javax.persistence.GeneratedValue; 10 import javax.persistence.Id; 11 import javax.persistence.ManyToMany; 12 import javax.persistence.Table; 13 import org.hibernate.annotations.GenericGenerator; 14 15 /** 16 * Authority entity. @author MyEclipse Persistence Tools 17 */ 18 @Entity 19 @Table(name = "authority", catalog = "testdb") 20 public class Authority implements java.io.Serializable { 21 22 // Fields 23 24 private String authorityId; 25 private String authorityName; 26 private Set<Role> roles = new HashSet<Role>(0); 27 28 // Constructors 29 30 /** default constructor */ 31 public Authority() { 32 } 33 34 /** full constructor */ 35 public Authority(String authorityName, Set<Role> roles) { 36 this.authorityName = authorityName; 37 this.roles = roles; 38 } 39 40 // Property accessors 41 @GenericGenerator(name = "generator", strategy = "uuid.hex") 42 @Id 43 @GeneratedValue(generator = "generator") 44 @Column(name = "authorityId", unique = true, nullable = false, length = 36) 45 public String getAuthorityId() { 46 return this.authorityId; 47 } 48 49 public void setAuthorityId(String authorityId) { 50 this.authorityId = authorityId; 51 } 52 53 @Column(name = "authorityName", length = 50) 54 public String getAuthorityName() { 55 return this.authorityName; 56 } 57 58 public void setAuthorityName(String authorityName) { 59 this.authorityName = authorityName; 60 } 61 62 @ManyToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY, mappedBy = "authorities") 63 public Set<Role> getRoles() { 64 return this.roles; 65 } 66 67 public void setRoles(Set<Role> roles) { 68 this.roles = roles; 69 } 70 71 }
Myuser.java
1 package com.it.entity; 2 3 import java.sql.Timestamp; 4 import java.util.HashSet; 5 import java.util.Set; 6 import javax.persistence.CascadeType; 7 import javax.persistence.Column; 8 import javax.persistence.Entity; 9 import javax.persistence.FetchType; 10 import javax.persistence.GeneratedValue; 11 import javax.persistence.Id; 12 import javax.persistence.ManyToMany; 13 import javax.persistence.Table; 14 import org.hibernate.annotations.GenericGenerator; 15 16 /** 17 * Myuser entity. @author MyEclipse Persistence Tools 18 */ 19 @Entity 20 @Table(name = "myuser", catalog = "testdb") 21 public class Myuser implements java.io.Serializable { 22 23 // Fields 24 25 private String myUserId; 26 private String myUserName; 27 private String myUserPhone; 28 private Timestamp myUserTime; 29 private Set<Role> roles = new HashSet<Role>(0); 30 31 // Constructors 32 33 /** default constructor */ 34 public Myuser() { 35 } 36 37 /** minimal constructor */ 38 public Myuser(Timestamp myUserTime) { 39 this.myUserTime = myUserTime; 40 } 41 42 /** full constructor */ 43 public Myuser(String myUserName, String myUserPhone, Timestamp myUserTime, 44 Set<Role> roles) { 45 this.myUserName = myUserName; 46 this.myUserPhone = myUserPhone; 47 this.myUserTime = myUserTime; 48 this.roles = roles; 49 } 50 51 // Property accessors 52 @GenericGenerator(name = "generator", strategy = "uuid.hex") 53 @Id 54 @GeneratedValue(generator = "generator") 55 @Column(name = "myUserId", unique = true, nullable = false, length = 36) 56 public String getMyUserId() { 57 return this.myUserId; 58 } 59 60 public void setMyUserId(String myUserId) { 61 this.myUserId = myUserId; 62 } 63 64 @Column(name = "myUserName", length = 20) 65 public String getMyUserName() { 66 return this.myUserName; 67 } 68 69 public void setMyUserName(String myUserName) { 70 this.myUserName = myUserName; 71 } 72 73 @Column(name = "myUserPhone", length = 11) 74 public String getMyUserPhone() { 75 return this.myUserPhone; 76 } 77 78 public void setMyUserPhone(String myUserPhone) { 79 this.myUserPhone = myUserPhone; 80 } 81 82 @Column(name = "myUserTime", nullable = false, length = 19) 83 public Timestamp getMyUserTime() { 84 return this.myUserTime; 85 } 86 87 public void setMyUserTime(Timestamp myUserTime) { 88 this.myUserTime = myUserTime; 89 } 90 91 @ManyToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY, mappedBy = "myusers") 92 public Set<Role> getRoles() { 93 return this.roles; 94 } 95 96 public void setRoles(Set<Role> roles) { 97 this.roles = roles; 98 } 99 100 }
Role.java
1 package com.it.entity; 2 3 import java.util.HashSet; 4 import java.util.Set; 5 import javax.persistence.CascadeType; 6 import javax.persistence.Column; 7 import javax.persistence.Entity; 8 import javax.persistence.FetchType; 9 import javax.persistence.GeneratedValue; 10 import javax.persistence.Id; 11 import javax.persistence.JoinColumn; 12 import javax.persistence.JoinTable; 13 import javax.persistence.ManyToMany; 14 import javax.persistence.Table; 15 import org.hibernate.annotations.GenericGenerator; 16 17 /** 18 * Role entity. @author MyEclipse Persistence Tools 19 */ 20 @Entity 21 @Table(name = "role", catalog = "testdb") 22 public class Role implements java.io.Serializable { 23 24 // Fields 25 26 private String roleId; 27 private String roleName; 28 private Set<Myuser> myusers = new HashSet<Myuser>(0); 29 private Set<Authority> authorities = new HashSet<Authority>(0); 30 31 // Constructors 32 33 /** default constructor */ 34 public Role() { 35 } 36 37 /** full constructor */ 38 public Role(String roleName, Set<Myuser> myusers, Set<Authority> authorities) { 39 this.roleName = roleName; 40 this.myusers = myusers; 41 this.authorities = authorities; 42 } 43 44 // Property accessors 45 @GenericGenerator(name = "generator", strategy = "uuid.hex") 46 @Id 47 @GeneratedValue(generator = "generator") 48 @Column(name = "roleId", unique = true, nullable = false, length = 36) 49 public String getRoleId() { 50 return this.roleId; 51 } 52 53 public void setRoleId(String roleId) { 54 this.roleId = roleId; 55 } 56 57 @Column(name = "roleName", length = 20) 58 public String getRoleName() { 59 return this.roleName; 60 } 61 62 public void setRoleName(String roleName) { 63 this.roleName = roleName; 64 } 65 66 @ManyToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY) 67 @JoinTable(name = "userrole", catalog = "testdb", joinColumns = { @JoinColumn(name = "roleId", nullable = false, updatable = false) }, inverseJoinColumns = { @JoinColumn(name = "myUserId", nullable = false, updatable = false) }) 68 public Set<Myuser> getMyusers() { 69 return this.myusers; 70 } 71 72 public void setMyusers(Set<Myuser> myusers) { 73 this.myusers = myusers; 74 } 75 76 @ManyToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY) 77 @JoinTable(name = "roleauthor", catalog = "testdb", joinColumns = { @JoinColumn(name = "roleId", nullable = false, updatable = false) }, inverseJoinColumns = { @JoinColumn(name = "authorityId", nullable = false, updatable = false) }) 78 public Set<Authority> getAuthorities() { 79 return this.authorities; 80 } 81 82 public void setAuthorities(Set<Authority> authorities) { 83 this.authorities = authorities; 84 } 85 86 }
上面有几个需要注意的：
上面大多数都是Hibernate tools自动生成的，但是有几个需要手动添加：
1、如果这个实体使用二级缓存的话，需要添加@cache注解；
2、如果该实体里面还有集合元素（set， map，list），如果实体要采用二级缓存，那么这些集合元素必须也添加@cache注解。
3、@JsonIgnoreProperties注解是为了防止SpringMVC在json返回时产生循环输出使用，如果不配置的话就会出现json死循环（还有多对多，一对多的属性时）。
4、@JsonIgnore这个是在转换成json是忽略该属性，而@JsonIgnoreProperties(value={"acctUsers", "acctAuthorities"})则是忽略acctRoles里面的acctUsers和acctAuthorites属性。
8.创建Dao层、service层
8.1 创建Dao层，面向接口的思想创建
8.1.1 先要创建一个基础Dao
1 package com.it.dao; 2 3 import java.io.Serializable; 4 import java.util.List; 5 6 public interface GenericDao<T, PK extends Serializable> { 7 8 T load(PK id); 9 10 T get(PK id); 11 12 List<T> findAll(); 13 14 void persist(T entity); 15 16 PK save(T entity); 17 18 void saveOrUpdate(T entity); 19 20 void delete(PK id); 21 22 void flush(); 23 }
8.1.2 再定义具体的接口,继承基础的Dao
1 package com.it.dao; 2 3 import com.it.entity.Myuser; 4 5 /** 6 * MyUser的Dao 7 * @author Administrator 8 * 9 */ 10 public interface MyUserDao extends GenericDao<Myuser, String> { 11 12 }
8.1.3 接着定义具体的DaoImpl的实现类
1 package com.it.dao.Impl; 2 3 import java.util.List; 4 5 6 import org.hibernate.Session; 7 import org.hibernate.SessionFactory; 8 import org.springframework.beans.factory.annotation.Autowired; 9 import org.springframework.stereotype.Repository; 10 11 import com.it.dao.MyUserDao; 12 import com.it.entity.Myuser; 13 14 15 @Repository("myUserDao") 16 public class MyUserDaoImpl implements MyUserDao { 17 18 @Autowired 19 private SessionFactory sessionFactory; 20 21 22 private Session getCurrentSession() { 23 return this.sessionFactory.getCurrentSession(); 24 } 25 26 public Myuser load(String id) { 27 // TODO Auto-generated method stub 28 return (Myuser) this.getCurrentSession().load(Myuser.class, id); 29 } 30 31 public Myuser get(String id) { 32 // TODO Auto-generated method stub 33 return (Myuser) this.getCurrentSession().get(Myuser.class, id); 34 } 35 36 public List<Myuser> findAll() { 37 @SuppressWarnings("unchecked") 38 List<Myuser> allUser = this.getCurrentSession().createQuery("from Myuser").list(); 39 return allUser; 40 } 41 42 public void persist(Myuser entity) { 43 this.getCurrentSession().persist(entity); 44 } 45 46 /** 47 * 可以选择手动控制事务的提交，也可以交给spring自动去提交 48 */ 49 public String save(Myuser entity) { 50 // TODO Auto-generated method stub 51 // Session session = sessionFactory.openSession(); 52 // session.getTransaction().begin(); 53 // session.; 54 // session.getTransaction().commit(); 55 // session.flush(); 56 // session.close(); 57 return (String) this.getCurrentSession().save(entity); 58 } 59 60 public void saveOrUpdate(Myuser entity) { 61 // TODO Auto-generated method stub 62 this.getCurrentSession().saveOrUpdate(entity); 63 } 64 65 public void delete(String id) { 66 // TODO Auto-generated method stub 67 Myuser myuser=this.load(id); 68 this.getCurrentSession().delete(myuser); 69 } 70 71 public void flush() { 72 this.getCurrentSession().flush(); 73 } 74 75 }
8.2 创建service层，也是面向接口的思想创建
8.2.1 创建一个基础Service
1 package com.it.service; 2 3 import java.io.Serializable; 4 import java.util.List; 5 6 public interface GenericService<T, PK extends Serializable> { 7 8 T load(PK id); 9 10 T get(PK id); 11 12 List<T> findAll(); 13 14 void persist(T entity); 15 16 PK save(T entity); 17 18 void saveOrUpdate(T entity); 19 20 void delete(PK id); 21 22 void flush(); 23 }
8.2.2 创建service继承基础的Service
1 package com.it.service; 2 3 import com.it.entity.Myuser; 4 5 public interface MyUserService extends GenericService<Myuser, String> { 6 7 }
8.2.3 创建serviceImpl
1 package com.it.service.Impl; 2 3 import java.util.List; 4 5 import javax.annotation.Resource; 6 7 import org.springframework.beans.factory.annotation.Autowired; 8 import org.springframework.stereotype.Service; 9 import org.springframework.transaction.annotation.Transactional; 10 11 import com.it.dao.MyUserDao; 12 import com.it.entity.Myuser; 13 import com.it.service.GenericService; 14 import com.it.service.MyUserService; 15 16 17 @Service("myUserService") 18 @Transactional 19 public class MyUserServiceImpl implements MyUserService { 20 21 @Resource(name = "myUserDao") 22 private MyUserDao myUserDao; 23 24 25 public Myuser load(String id) { 26 // TODO Auto-generated method stub 27 return myUserDao.load(id); 28 } 29 30 public Myuser get(String id) { 31 // TODO Auto-generated method stub 32 return myUserDao.get(id); 33 } 34 35 public List<Myuser> findAll() { 36 // TODO Auto-generated method stub 37 return myUserDao.findAll(); 38 } 39 40 public void persist(Myuser entity) { 41 // TODO Auto-generated method stub 42 myUserDao.persist(entity); 43 } 44 45 public String save(Myuser entity) { 46 // TODO Auto-generated method stub 47 return myUserDao.save(entity); 48 } 49 50 public void saveOrUpdate(Myuser entity) { 51 // TODO Auto-generated method stub 52 myUserDao.saveOrUpdate(entity); 53 } 54 55 public void delete(String id) { 56 // TODO Auto-generated method stub 57 myUserDao.delete(id); 58 } 59 60 public void flush() { 61 // TODO Auto-generated method stub 62 myUserDao.flush(); 63 } 64 65 }
9.配置spring-mvc.xml
spring-mvc.xml中配置了自动扫描Controller层注解+视图解析器
1 <?xml version="1.0" encoding="UTF-8"?> 2 <beans xmlns="http://www.springframework.org/schema/beans" 3 xmlns:mvc="http://www.springframework.org/schema/mvc" 4 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 5 xmlns:p="http://www.springframework.org/schema/p" 6 xmlns:context="http://www.springframework.org/schema/context" 7 xmlns:tx="http://www.springframework.org/schema/tx" 8 xmlns:aop="http://www.springframework.org/schema/aop" 9 xsi:schemaLocation="http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.1.xsd 10 http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.1.xsd 11 http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.1.xsd 12 http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.1.xsd 13 http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.1.xsd"> 14 15 <!-- 自动扫描@Controller注入为bean --> 16 <context:component-scan base-package="com.it" > 17 18 </context:component-scan> 19 <!-- 标明注解事务 --> 20 <tx:annotation-driven transaction-manager="transactionManager" /> 21 22 <!-- 以下为SpringMVC配置 --> 23 <mvc:annotation-driven> 24 <!-- 返回json数据，@response使用 --> 25 <mvc:message-converters register-defaults="true"> 26 <bean 27 class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter"> 28 <property name="supportedMediaTypes"> 29 <list> 30 <value>text/html;charset=UTF-8</value> 31 <value>application/json;charset=UTF-8</value> 32 </list> 33 </property> 34 35 </bean> 36 </mvc:message-converters> 37 </mvc:annotation-driven> 38 39 <!-- 对模型视图名称的解析，即在模型视图名称添加前后缀 --> 40 <bean 41 class="org.springframework.web.servlet.view.InternalResourceViewResolver"> 42 <property name="viewClass" 43 value="org.springframework.web.servlet.view.JstlView" /> 44 <property name="prefix" value="/WEB-INF/views" /> 45 <property name="suffix" value=".jsp" /> 46 </bean> 47 48 <!-- 下面设置配置事物以及事务管理，是一种事务的处理方式，还可以有另一种 就是不写下面这一大块，直接在service层添加@Transactional 49 解释一下这两种的区别： 50 1.@Transactional 在serviceImpl层使用这个注解，表示默认的事务都是propagation="REQUIRED"，这样不会有下面read-only这一项了，那么比如在查询的时候只要保证这个查询是在一个事务中，将结果查询出来，对这个对象进行修改，不用调用save等方法，事务会自动帮你进行持久化的操作，会将你这个操作保存在数据库中 51 2.使用下面的这两个事务管理，可以自己配置什么方法什么操作【insert、get】，可以自己设置事务的类型，也可以设置read-only。设置了read-only的话，在从数据库中查询出一条记录，对对象进行更改，那就必须调用save或者update方法才能进行保存 52 53 54 配置事务增强处理Bean，指定事务管理器 意思是这个id为transactionAdvice的事务(建议)，他的事务管理者是上面指定的id为transactionManager的事务管理器 55 <tx:advice id="transactionAdvice" transaction-manager="transactionManager" > 56 配置详细事务处理语义 57 <tx:attributes> 58 在指定的如下的这些操作发生时，例如insert插入数据发生时，事务类型的request ，而get等操作，事务类型是supports，并且是只读 59 <tx:method name="insert*" propagation="REQUIRED" /> 60 <tx:method name="update*" propagation="REQUIRED" /> 61 <tx:method name="delete*" propagation="REQUIRED" /> 62 63 <tx:method name="get*" propagation="SUPPORTS" read-only="true" /> 64 <tx:method name="find*" propagation="SUPPORTS" read-only="true" /> 65 <tx:method name="select*" propagation="SUPPORTS" read-only="true" /> 66 <tx:method name="load*" propagation="SUPPORTS" read-only="true" /> 67 68 其他采用默认事务方式 69 <tx:method name="*" propagation="REQUIRED" /> 70 71 </tx:attributes> 72 </tx:advice> 73 74 Spring aop事务管理 75 <aop:config proxy-target-class="true"> 76 配置切入点 指定这个aop:pointcut去引用上面规定的advice，也就是说规定下面的这个expression指定的路径下的service.impl下的所有的方法，都按照上面advice中的规定去执行，碰上什么操作，事务就是什么类型的，这就是事务管理器的好处了 77 解释一下，为什么这个要指定在service层：因为在同一个事务中，可能要对多张表进行多个不同的操作，才是一个完整的逻辑，例如淘宝上买东西，你转账之后你的钱减少了，对方的钱应该增加了，这两个操作在一起才是一个完整的操作，而如果这两个操作不在一个事务中，也就是如果将事务的操作指定在Dao层【MVC的设计模式：Dao层就是对数据库进行最简单的增删改查操作，而service层是进行逻辑处理的，一个完整的逻辑处理就要涉及到多次操作】事务操作失败，发生回滚，那你的帐减少了，对方的帐并没有增加，这样就不美丽的，因此，将事务的管理，指定在了service层 78 <aop:pointcut id="transactionPointcut" 79 expression="execution(* com.it.service..*Impl.*(..))" />expression中表达式所指意思： 所有的文件下的 com.it.service开头的包，以Impl结尾的类下的所有的方法，都执行上面advice的规定 80 指定在txAdvice切入点应用txAdvice事务增强处理 81 <aop:advisor pointcut-ref="transactionPointcut" 82 advice-ref="transactionAdvice" /> 83 </aop:config> --> 84 85 </beans>
10.配置web.xml容器
1 <?xml version="1.0" encoding="UTF-8"?> 2 <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 3 xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" 4 xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" 5 id="WebApp_ID" version="2.5"> 6 <!-- web容器是web项目的大脑 --> 7 <!-- 在web.xml中，执行顺序是：1.先执行listener 2。再执行filter 3.最后执行servlet 这就是执行顺序 8 就像spring-hibernate.xml文件是在执行Listener的时候加载的，那注意这几个配置文件在web.xml中的加载顺序，因为资源文件是在配置文件【xml文件】中加载的，肯定是先加载的资源文件【properties文件】，才能在配置文件中调用资源文件中的变量的值使用 9 10 --> 11 <display-name>springmvc_demo</display-name> 12 <!-- web容器，首先需要引入spring，让spring管理各个框架，并将其注入为bean --> 13 <!-- 这个相当于定一个 变量在web.xml中，在下面的listener org.springframework.web.context.ContextLoaderListener中，加载这个spring-hibernate.xml文件 --> 14 <context-param> 15 <param-name>contextConfigLocation</param-name> 16 <param-value>classpath:spring-hibernate.xml</param-value> 17 </context-param> 18 <!-- 配置控制层的filter信息 --> 19 <filter> 20 <filter-name>encodingFilter</filter-name> 21 <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class> 22 <init-param> 23 <param-name>encoding</param-name> 24 <param-value>utf-8</param-value> 25 </init-param> 26 <init-param> 27 <param-name>forceEncoding</param-name> 28 <param-value>true</param-value> 29 </init-param> 30 </filter> 31 <filter-mapping> 32 <filter-name>encodingFilter</filter-name> 33 <url-pattern>/*</url-pattern> 34 </filter-mapping> 35 36 <!-- openSessionInView配置 作用是延迟session关闭到view层 --> 37 <filter> 38 <filter-name>openSessionInViewFilter</filter-name> 39 <filter-class>org.springframework.orm.hibernate4.support.OpenSessionInViewFilter</filter-class> 40 <init-param> 41 <param-name>singleSession</param-name> 42 <param-value>true</param-value> 43 </init-param> 44 </filter> 45 46 <!-- 监听servletContext，启动contextConfigLocation中的spring配置信息 --> 47 <listener> 48 <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class> 49 </listener> 50 51 52 <!-- 防止spring内存溢出监听器 可用可不用--> 53 <listener> 54 <listener-class>org.springframework.web.util.IntrospectorCleanupListener</listener-class> 55 </listener> 56 57 58 <!-- 类似与servlet 需要在web.xml中都需要配置一样，spring的思想是让这些servlet【controller也是servlet】继承了一个基础的servlet，那就只需在web.xml中配置一个servlet即可。 --> 59 <!-- 这个servlet和下面的servlet-mapping相配合使用，注明了所有的以.htmls结尾的请求都被截取到，去到servlet中去找相对应的方法 进行处理 --> 60 <servlet> 61 <description>spring mvc servlet</description> 62 <servlet-name>rest</servlet-name> 63 <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class> 64 <init-param> 65 <param-name>contextConfigLocation</param-name> 66 <!-- 此处配置的是SpringMVC的配置文件 --> 67 <param-value>classpath:spring-mvc.xml</param-value> 68 </init-param> 69 <load-on-startup>1</load-on-startup> 70 </servlet> 71 <!-- 配置了springmvc拦截的url为以.hmls结尾的请求 --> 72 <servlet-mapping> 73 <servlet-name>rest</servlet-name> 74 <url-pattern>*.htmls</url-pattern> 75 </servlet-mapping> 76 77 <filter-mapping> 78 <filter-name>openSessionInViewFilter</filter-name> 79 <url-pattern>/*</url-pattern> 80 </filter-mapping> 81 82 <!-- 配置session超时时间，单位分钟 --> 83 <session-config> 84 <session-timeout>30</session-timeout> 85 </session-config> 86 <!-- 欢迎界面 默认的项目访问界面 --> 87 <welcome-file-list> 88 <welcome-file>/index.jsp</welcome-file> 89 </welcome-file-list> 90 </web-app>
11.创建Controller层
1 package com.it.controller; 2 3 import java.sql.Timestamp; 4 import java.util.List; 5 import java.util.UUID; 6 7 import javax.annotation.Resource; 8 9 import org.apache.log4j.Logger; 10 import org.springframework.stereotype.Controller; 11 import org.springframework.ui.ModelMap; 12 import org.springframework.web.bind.annotation.PathVariable; 13 import org.springframework.web.bind.annotation.RequestMapping; 14 import org.springframework.web.bind.annotation.ResponseBody; 15 16 import com.it.entity.Myuser; 17 import com.it.service.MyUserService; 18 19 20 21 22 @Controller 23 @RequestMapping("/myuser") 24 public class MyUserController { 25 26 private static final Logger LOGGER = Logger.getLogger(MyUserController.class); 27 28 29 @Resource( name = "myUserService") 30 private MyUserService myUserService; 31 32 33 @RequestMapping("/saveOne") 34 public String saveOne(){ 35 Myuser myuser = new Myuser(); 36 //myuser.setMyUserId(UUID.randomUUID().toString()); 37 myuser.setMyUserName("andy"); 38 myuser.setMyUserPhone("13823237878"); 39 myuser.setMyUserTime(Timestamp.valueOf("1995-09-15 12:12:12")); 40 myUserService.save(myuser); 41 return "/user/showInfo"; 42 } 43 44 @RequestMapping("/showInfo/{userId}") 45 public String showUserInfo(ModelMap model, @PathVariable String userId){ 46 LOGGER.info("查询用户:"+userId); 47 Myuser myuser = myUserService.load(userId); 48 model.addAttribute("userInfo", myuser); 49 return "/user/showInfo"; 50 } 51 52 53 @RequestMapping("/showInfos") 54 public @ResponseBody List<Myuser> showAllUser(){ 55 LOGGER.info("查询所有用户"); 56 List<Myuser> list = myUserService.findAll(); 57 return list; 58 } 59 }
12.创建view视图层
在src/main/webapp/WEB-INF/views下 创建user/showInfo.jsp
1 <%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%> 2 <%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%> 3 <%@taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt"%> 4 5 <% 6 String path = request.getContextPath(); 7 String basePath = request.getScheme() + "://" 8 + request.getServerName() + ":" + request.getServerPort() 9 + path + "/"; 10 %> 11 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"> 12 <html> 13 <head> 14 <base href="<%=basePath%>" /> 15 <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> 16 <script type="text/javascript" src="js/jquery-1.9.1.min.js"></script> 17 <title>用户信息展示</title> 18 </head> 19 <body> 20 用户信息 昵称： ${userInfo.myUserName} 用户id：${userInfo.myUserId} 用户电话:${userInfo.myUserPhone } 注册时间： 21 <fmt:formatDate value="${userInfo.myUserTime }" pattern="yyyy-MM-dd HH:mm:ss" /> 22 角色：[ 23 <c:forEach items="${ userInfo.roles}" var="role"> 24 ${role.roleName } 权限[ 25 <c:forEach items="${ role.authorities}" var="authority"> 26 ${authority.authorityName } 27 </c:forEach> ] 28 </c:forEach> 29 ] 30 31 <br /> ajax显示全部用户信息： 32 <div id="show_all_user"></div> 33 </body> 34 <script type="text/javascript"> 35 $.ajax({ 36 type : "get", 37 url : "myuser/showInfos.htmls", 38 dataType : "json", 39 success : function(data) { 40 $(data).each( 41 function(i, user) { 42 var p = "<p>昵称:" + user.myUserName + " 电话:" 43 + user.myUserPhone + " 注册时间:" 44 + user.myUserTime + " id:" + user.myUserId + 45 "</p>"; 46 $("#show_all_user").append(p); 47 }); 48 }, 49 async : true 50 }); 51 </script> 52 </html>
13. 一切准备就绪，把项目部署到tomcat中，启动即可
可能你会说，那要这个view页面做什么？？因为参考别人的嘛 并且，这个页面比较值得钻研
