spring MVC 框架的搭建（myeclipse +maven）--（下）

 我篇文章主要是在上一篇文章的基础上，整合Hibernate,连接数据库，是我们在springmvc框架下面可以使用Hibernate访问数据库,这里面我主要使用的是mysql数据库，如果有想要使用oracal的也可以参阅此篇文章，对比学习。

 既然我们要使用Hibernate，希望童鞋们可以自己先上网查一查与Hibernate相关的资料，比如我最开始就是去官网直接下载了Hibernate看，虽然没有那么仔细认真的看，但是对学习hibernate还是很有帮助的，所以在这里呢，我就不在给大家做Hibernate相关的介绍了，我主要介绍一下springmvc整合Hibernate的相关步骤。

1、导入与Hibernate相关的jar包

我们因为使用了maven 可以直接在pom.xml文件中添加<dependency>

                <dependency>
			<groupId>org.hibernate</groupId>
			<artifactId>hibernate-core</artifactId>
			<version>4.3.11.Final</version>
		</dependency>
		<dependency>
			<groupId>org.hibernate</groupId>
			<artifactId>hibernate-entitymanager</artifactId>
			<version>4.3.6.Final</version>
		</dependency>
		<dependency>
			<groupId>org.hibernate</groupId>
			<artifactId>hibernate-ehcache</artifactId>
			<version>4.3.6.Final</version>
		</dependency>
		<dependency>
			<groupId>org.hibernate</groupId>
			<artifactId>hibernate-envers</artifactId>
			<version>4.3.6.Final</version>
		</dependency>
    
                <dependency>  
                      <groupId>com.alibaba</groupId>  
                      <artifactId>druid</artifactId>  
                      <version>0.2.15</version>  
              </dependency>

2、导入数据库驱动的jar包

这里我们要连接的是mysql数据库，所以我们导入

    <!-- mysql数据库驱动 -->
    <dependency>
   	 <groupId>mysql</groupId>
       <artifactId>mysql-connector-java</artifactId>
       </span><version>5.1.33</version>
    </dependency>

3、配置hibernate.properties文件（在src/main/resource的META-INF文件下创建这个文件）

hibernate的数据库连接信息就是从这个配置文件中加载的，其中包含了一系列属性的配置，Hibernate将根据这些属性来连接数据库。

对于Hibernate.properties属性文件配置，在其发布包中的etc下，给出了此文件配置的所有属性，初学者可以参照此文件进行配置。

# MySQL
hibernate.dialect = org.hibernate.dialect.MySQLDialect
hibernate.hbm2ddl.auto=none
hibernate.show_sql=true
hibernate.query.substitutions=true 1, false 0
hibernate.default_batch_fetch_size=16
hibernate.max_fetch_depth=2
hibernate.bytecode.use_reflection_optimizer=true
hibernate.cache.use_second_level_cache=false
hibernate.cache.use_query_cache=false
hibernate.cache.region.factory_class=org.hibernate.cache.ehcache.EhCacheRegionFactory
net.sf.ehcache.configurationResourceName=/ehcache_hibernate.xml
hibernate.cache.use_structured_entries=true
hibernate.generate_statistics=true

hibernate.connection.driver_class = com.mysql.jdbc.Driver
hibernate.connection.url=jdbc:mysql://localhost:3306/actdb

hibernate.connection.username =root
hibernate.connection.password  =root


pool.initialSize=1
pool.maxActive=50
pool.minIdle=5
pool.maxWait=3600000

这上面配置的关于Hibernate的属性用途大家如果不知道的话可以参考链接： Hibernate属性及用途

4、配置 spring 的配置文件spring-core.xml文件

 spring-core.xml文件主要配置对Hibernate的事物的管理，该配置文件的参考配置如下：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:aop="http://www.springframework.org/schema/aop" xmlns:context="http://www.springframework.org/schema/context" 
	xmlns:jdbc="http://www.springframework.org/schema/jdbc" xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:jpa="http://www.springframework.org/schema/data/jpa"
	xsi:schemaLocation="
		http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
		http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-4.0.xsd
		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
		http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa-1.3.xsd"
		default-lazy-init="true">

	<description>Spring公共配置</description>
	 <!-- 定义受环境影响易变的变量 -->
	<bean id="propertyPlaceholderConfigurer"
		class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
		<property name="locations">
			<list>
				<value>/WEB-INF/classes/META-INF/hibernate.properties</value>
			</list>
		</property>
	</bean>
	
	<!-- 使用annotation 自动注册bean,并检查@Required,@Autowired的属性已被注入 -->
	<!-- 自动扫描的包名:com.mayday.activiti -->
	<context:component-scan base-package="com.mayday.activiti">
		<context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller" />
		<context:exclude-filter type="annotation" expression="org.springframework.web.bind.annotation.ControllerAdvice" />
	</context:component-scan>
	
	<!-- Transactions 对@Transactional这个注解进行的驱动 -->
	<tx:annotation-driven transaction-manager="transactionManager" />
	
	<!-- 事务管理器 -->  
	<bean id="transactionManager"
		class="org.springframework.orm.hibernate4.HibernateTransactionManager">
		<property name="sessionFactory" ref="sessionFactory" />
		<property name="dataSource" ref="dataSource" />
	</bean>
	
   <!-- Hibernate配置 -->
	<bean id="sessionFactory" class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
		<property name="dataSource" ref="dataSource" />
		<property name="namingStrategy">
			<bean class="org.hibernate.cfg.ImprovedNamingStrategy" />
		</property>
		<property name="hibernateProperties">
			<props>
				<prop key="hibernate.hbm2ddl.auto">${hibernate.hbm2ddl.auto}</prop>
				<prop key="hibernate.dialect">${hibernate.dialect}</prop>
				<prop key="hibernate.show_sql">${hibernate.show_sql}</prop>
				<prop key="hibernate.format_sql">true</prop>
				<prop key="hibernate.query.substitutions">${hibernate.query.substitutions}</prop>
				<prop key="hibernate.default_batch_fetch_size">${hibernate.default_batch_fetch_size}</prop>
				<prop key="hibernate.max_fetch_depth">${hibernate.max_fetch_depth}</prop>
				<prop key="hibernate.generate_statistics">${hibernate.generate_statistics}</prop>
				<prop key="hibernate.bytecode.use_reflection_optimizer">${hibernate.bytecode.use_reflection_optimizer}</prop>
				<prop key="hibernate.cache.use_second_level_cache">${hibernate.cache.use_second_level_cache}</prop>
				<prop key="hibernate.cache.use_query_cache">${hibernate.cache.use_query_cache}</prop>
				<prop key="hibernate.cache.region.factory_class">${hibernate.cache.region.factory_class}</prop>
				<prop key="net.sf.ehcache.configurationResourceName">${net.sf.ehcache.configurationResourceName}</prop>
				<prop key="hibernate.cache.use_structured_entries">${hibernate.cache.use_structured_entries}</prop>
				<prop key="current_session_context_class">thread</prop>
			</props>
		</property>
		<!-- 扫面com.mayday.activiti包下面的实体 -->
		<property value="com.mayday.activiti.**.eneity" name="packagesToScan" />
	</bean>
   
    <!-- 数据库连接池配置 -->
	<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
		init-method="init" destroy-method="close">
		<property name="driverClassName" value="${connection.driver_class}" />
		<property name="url" value="${connection.url}" />
		<property name="username" value="${connection.username}" />
		<property name="password" value="${connection.password}" />
		<!-- 配置初始化大小、最小、最大 -->
		<property name="initialSize" value="${pool.initialSize}" />
		<property name="minIdle" value="${pool.minIdle}" />
		<property name="maxActive" value="${pool.maxActive}" />

		<!-- 配置获取连接等待超时的时间 -->
		<property name="maxWait" value="${pool.maxWait}" />

		<!-- 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒 -->
		<property name="timeBetweenEvictionRunsMillis" value="60000" />

		<!-- 配置一个连接在池中最小生存的时间，单位是毫秒 -->
		<property name="minEvictableIdleTimeMillis" value="300000" />

		<property name="validationQuery" value="SELECT 'x' FROM DUAL" />
		<property name="testWhileIdle" value="true" />
		<!-- 申请连接时执行validationQuery检测连接是否有效,设为TRUE影响性能 -->
		<property name="testOnBorrow" value="false" />
		<!-- 归还连接时执行validationQuery检测连接是否有效,设为TRUE影响性能 -->
		<property name="testOnReturn" value="false" />

		<!-- 打开PSCache，并且指定每个连接上PSCache的大小 -->
		<property name="poolPreparedStatements" value="true" />
		<property name="maxPoolPreparedStatementPerConnectionSize"
			value="100" />
		<!-- 对于长时间不使用的连接强制关闭 -->
		<property name="removeAbandoned" value="true" />
		<!-- 超过30分钟开始关闭空闲连接 -->
		<property name="removeAbandonedTimeout" value="1800" />
		<!-- 将当前关闭动作记录到日志 -->
		<property name="logAbandoned" value="true" />
		<!-- 配置监控统计拦截的filters -->
		<property name="filters" value="stat" />
	</bean>
	
   <!-- 以下建立事务处理 -->
	<aop:aspectj-autoproxy expose-proxy="true" />
    <!-- 需要引入tx的命名空间 -->  
    <!-- 这是事务通知操作，使用的事务管理器引用自 transactionManager -->  
	<tx:advice id="txAdvice" transaction-manager="transactionManager">
		<tx:attributes>
		    <!-- 指定哪些方法需要加入事务，可以使用通配符来只加入需要的方法 -->
			<tx:method name="save*" propagation="REQUIRED" />
			<tx:method name="add*" propagation="REQUIRED" />
			<tx:method name="push*" propagation="REQUIRED" />
			<tx:method name="create*" propagation="REQUIRED" />
			<tx:method name="insert*" propagation="REQUIRED" />
			<tx:method name="update*" propagation="REQUIRED" />
			<tx:method name="merge*" propagation="REQUIRED" />
			<tx:method name="del*" propagation="REQUIRED" />
			<tx:method name="remove*" propagation="REQUIRED" />
			<tx:method name="put*" propagation="REQUIRED" />
			<tx:method name="use*" propagation="REQUIRED" />
			<tx:method name="get*" propagation="REQUIRED" read-only="true" />
			<tx:method name="count*" propagation="REQUIRED" read-only="true" />
			<tx:method name="find*" propagation="REQUIRED" read-only="true" />
			<tx:method name="list*" propagation="REQUIRED" read-only="true" />
			<tx:method name="*" propagation="REQUIRED" read-only="true" />
		</tx:attributes>
	</tx:advice>
	<!-- 需要引入aop的命名空间 --> 
	<aop:config expose-proxy="true">
	     <!-- 切入点指明了在执行service的所有方法时产生事务拦截操作 -->  
		<aop:pointcut id="txPointcut" expression="execution(* com.mayday.activiti..service.*.*(..))" />
		<!-- 定义了将采用何种拦截操作，这里引用到 txAdvice -->  
		<aop:advisor advice-ref="txAdvice" pointcut-ref="txPointcut" />
	</aop:config>
	
</beans>

 按照上面的步骤，与hibernate相关的配置基本弄完了，下面我们做一下测试

1)创建库（actdb）-->建立user表

2)写测试类

       我提前先在我的mysql数据库下面创建了一个名为：actdb 的数据库，里面没有任何的表，

然后我在编写一个测试类 ，用于在actdb数据库下面创建提前我们学的关于activiti需要的23张数据表，看看能否创建成功，要使用activiti工作流相关的东西我们需要在

1、pom.xml导入与activiti相关的jar包：

<!-- activity 应用包 -->
		<dependency>
        	<groupId>org.activiti</groupId>
        	<artifactId>activiti-engine</artifactId>
        	<version>5.19.0</version>
        </dependency>
        <dependency>
        	<groupId>org.activiti</groupId>
        	<artifactId>activiti-spring</artifactId>
        	<version>5.19.0</version>
        	<exclusions>
        		<exclusion>
        			<artifactId>commons-dbcp</artifactId>
        			<groupId>commons-dbcp</groupId>
        		</exclusion>
        	</exclusions>
        </dependency>
        <dependency>
        	<groupId>org.activiti</groupId>
        	<artifactId>activiti-json-converter</artifactId>
        	<version>5.19.0</version>
        	<exclusions>
        		<exclusion>
        			<artifactId>commons-collections</artifactId>
        			<groupId>commons-collections</groupId>
        		</exclusion>
        	</exclusions>
        </dependency>
        <dependency>
		    <groupId>com.fasterxml.uuid</groupId>
		    <artifactId>java-uuid-generator</artifactId>
		    <version>3.1.3</version>
        	<exclusions>
        		<exclusion>
        			<artifactId>log4j</artifactId>
        			<groupId>log4j</groupId>
        		</exclusion>
        	</exclusions>
		</dependency>

2、编写与activitix要加载的配置文件：spring-activiti.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

    <bean id="uuidGenerator" class="org.activiti.engine.impl.persistence.StrongUuidGenerator" />

    <!-- activity 关联配置 -->	
	<bean id="processEngineConfiguration" class="org.activiti.spring.SpringProcessEngineConfiguration">
  	<property name="dataSource" ref="dataSource" />
  	<property name="transactionManager" ref="transactionManager" />
  	<property name="databaseSchemaUpdate" value="true" />
  	<property name="jobExecutorActivate" value="false" />
    <property name="enableDatabaseEventLogging" value="false" />
    <property name="idGenerator" ref="uuidGenerator"/>
   <!-- <property name="typedEventListeners">
      <map>
        <entry key="PROCESS_COMPLETED" >
          <list>
            <bean class="com.wondersgroup.hism.flow.listener.ProcessCompletedListener" />
          </list>
        </entry>
      </map>
    </property>
     <property name="databaseSchema" value="act"/> -->
    <!-- <property name="customFormTypes">
      <list>
        <bean class="org.activiti.explorer.form.UserFormType"/>
        <bean class="org.activiti.explorer.form.ProcessDefinitionFormType"/> 
        <bean class="org.activiti.explorer.form.MonthFormType"/>   
      </list>
    </property> -->
  </bean>
  
  <bean id="processEngine" class="org.activiti.spring.ProcessEngineFactoryBean" destroy-method="destroy">
  	<property name="processEngineConfiguration" ref="processEngineConfiguration" />
  </bean>
  
  <bean id="repositoryService" factory-bean="processEngine" factory-method="getRepositoryService" />
  <bean id="runtimeService" factory-bean="processEngine" factory-method="getRuntimeService" />
  <bean id="taskService" factory-bean="processEngine" factory-method="getTaskService" />
  <bean id="formService" factory-bean="processEngine" factory-method="getFormService" />
  <bean id="historyService" factory-bean="processEngine" factory-method="getHistoryService" />
  <bean id="managementService" factory-bean="processEngine" factory-method="getManagementService" />
  <bean id="identityService" factory-bean="processEngine" factory-method="getIdentityService" /> 
</beans>

接下来我们利用Junit单元测试，我们还需要在pom.xml文件添加：

              <pluginManagement>
			<plugins>
				<!-- compiler插件, 设定JDK版本 -->
				<plugin>
					<groupId>org.apache.maven.plugins</groupId>
					<artifactId>maven-compiler-plugin</artifactId>
					<version>3.1</version>
					<configuration>
						<source>${java.version}</source>
						<target>${java.version}</target>
						<showWarnings>true</showWarnings>
						<compilerArguments>
							<extdirs>src\main\webapp\WEB-INF\lib</extdirs>
						</compilerArguments>
					</configuration>
				</plugin>
				<!-- resource插件 -->
				<plugin>
					<groupId>org.apache.maven.plugins</groupId>
					<artifactId>maven-resources-plugin</artifactId>
					<version>2.6</version>
				</plugin>

				<!-- test插件, 仅测试名称为*Test的类, 使用支持分组测试的surefire-junit47 driver -->
				<plugin>
					<groupId>org.apache.maven.plugins</groupId>
					<!-- maven-surefire-plugin是maven测试器 -->
					<artifactId>maven-surefire-plugin</artifactId>
					<version>2.16</version>
					<configuration>
						<includes>
							<include>**/*Test.java</include>
						</includes>
					</configuration>
					<dependencies>
						<dependency>
							<groupId>org.apache.maven.surefire</groupId>
							<artifactId>surefire-junit47</artifactId>
							<version>2.16</version>
						</dependency>
					</dependencies>
				</plugin>
              </plugins>
    </pluginManagement>

现在我们开始编写测试类，在src/test/java下添加

ActivitiTest.java测试类代码如下：

public class ActivitiTest{

	/**使用代码的方式创建流程需要的23张数据表*/
	@Test
	public void createTab(){
		
		//1、创建Activiti配置对象的实例
		ProcessEngineConfiguration  processEngineConfiguration =ProcessEngineConfiguration.createStandaloneProcessEngineConfiguration();
		//2、设置数据库的连接信息
		//设置数据库的驱动
		processEngineConfiguration.setJdbcDriver("com.mysql.jdbc.Driver"); 
		//设置数据库的连接地址
		processEngineConfiguration.setJdbcUrl("jdbc:mysql://localhost:3306/actdb?useUnicode=true&characterEncoding=utf8");
		//用户名
		processEngineConfiguration.setJdbcUsername("root");
		//密码
		processEngineConfiguration.setJdbcPassword("root");
		//设置数据库建表策略
		/**
		   DB_SCHEMA_UPDATE_FALSE = "false";不能自动创建表，需要表的存在
		   DB_SCHEMA_UPDATE_CREATE_DROP = "create-drop";先删除表，在创建表
		   DB_SCHEMA_UPDATE_TRUE = "true";如果表不存在，就自动创建表
		*/
		processEngineConfiguration.setDatabaseSchemaUpdate(ProcessEngineConfiguration.DB_SCHEMA_UPDATE_TRUE);
		//4、使用配置对象创建流程引擎的实例（工作流的核心对象ProcessEngine对象）
	    ProcessEngine processEngine = processEngineConfiguration.buildProcessEngine();
	    System.out.println("processEngine:" +processEngine);

	}
	

然后测试Run As-->JUnit Test,运行完成之后，我们可以去数据库看看23张表已经创建成功了：

至此springMVC整合HIbernate完成，后面还会自己进行测试，看看是否还有问题。