研究，百度，查资料+好友帮助，使用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>
View Code
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
View Code
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
View Code
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>
View Code
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>
View Code
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 }
View Code
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 }
View Code
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 }
View Code
上面有几个需要注意的：
上面大多数都是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 }
View Code
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 }
View Code
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 }
View Code
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 }
View Code
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 }
View Code
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 }
View Code
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>
View Code
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>
View Code
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 }
View Code
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>
View Code
13. 一切准备就绪，把项目部署到tomcat中，启动即可
可能你会说，那要这个view页面做什么？？因为参考别人的嘛 并且，这个页面比较值得钻研
从零搭建基于SpringBoot的秒杀系统(一)：项目准备
