从零开始利用Sping MVC+Spring(4.3.9)+Hibernate(5.2.10)+maven项目搭建

截止目前，所使用的都基本是最新版本了吧。一步一步来。

软件及版本说明：

1.Java编辑器 ：Eclipse ，版本 Version: Neon.3 Release (4.6.3)，下载链接：https://www.eclipse.org/downloads/

2.JDK版本：1.8（1.7及以下也没关系，搭架子用不到1.8版本的特性的），下载地址：http://www.oracle.com/technetwork/java/javase/downloads/index.html

3.Maevn：:apache-maven-3.5.0，下载链接：http://maven.apache.org/download.cgi   

第1步：下载以上三种插件并安装。

Eclipse中集成Maven可能各个版本的Eclipse不太一致，网上攻略太多，这里就不续了。可参考：http://www.cnblogs.com/teach/p/5906425.html

第2步：新建Maven项目：

后面几步按照自己的需求进行配置，最终 Finish即可，

第3步：添加jar包依赖

在maven的pom文件里面加入如下依赖<下面的不一定全加，根据自己的项目需求可多可少>

 <!-- springframework -->
   <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aop</artifactId>
        <scope>compile</scope>
    </dependency>
    
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-beans</artifactId>
        <scope>compile</scope>
    </dependency>
    
   <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <scope>compile</scope>
    </dependency>
    
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-core</artifactId>
        <scope>compile</scope>
    </dependency>
    
    <dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-web</artifactId>
</dependency>
 
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-orm</artifactId>
</dependency>
    
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-expression</artifactId>
        <scope>compile</scope>
    </dependency> 
    
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-tx</artifactId>
        <scope>compile</scope>
    </dependency> 
    
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
        <scope>compile</scope>
    </dependency>
  
    <!-- spring MVC -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <scope>compile</scope>
    </dependency>

Spring 的jar包采用统一的版本控制。在pom文件中继续加入以下的版本控制代码，这样的好处就是要改变Spring 的版本的时候，只需要改变一处即可

<!-- maven spring  版本管理 -->
  <dependencyManagement>
  <dependencies> 
<dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-framework-bom</artifactId>
            <version>4.3.9.RELEASE</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
</dependencies>
  </dependencyManagement>

下面加入 Hibernate 的jar 包依赖

  
  <!-- hibernate  -->
    <dependency>
  <groupId>org.hibernate</groupId>
  <artifactId>hibernate-core</artifactId>
  <version>5.2.10.Final</version>
</dependency>
 
<dependency> 
  <groupId>org.hibernate</groupId>
  <artifactId>hibernate-entitymanager</artifactId>
  <version>5.2.10.Final</version>
</dependency>

<dependency>
  <groupId>org.hibernate</groupId>
  <artifactId>hibernate-ehcache</artifactId>
  <version>5.2.10.Final</version>
</dependency>

<dependency>
   <groupId>org.hibernate.javax.persistence</groupId>
   <artifactId>hibernate-jpa-2.1-api</artifactId>
   <version>1.0.0.Final</version> 
</dependency> 

版本控制依然可以像 Spring 那样调整

引入日志的 jar 包，及数据库的jar ，这里使用MySql5中的某一版本,如果采用C3p0链接的话还需要多一个，顺便可以引入个 JSTL 的jar。

<!-- jstl -->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>jstl</artifactId>
<version>1.2</version>
</dependency> 


  
  <!-- mysql  -->
<dependency>
       <groupId>mysql</groupId>
       <artifactId>mysql-connector-java</artifactId>
       <version>5.1.40</version>
    </dependency>

<!-- logging -->
<dependency>
<groupId>commons-logging</groupId>
<artifactId>commons-logging</artifactId>
<version>1.2</version>
</dependency>

<!-- c3p0 -->
<dependency>
   <groupId>com.mchange</groupId>
   <artifactId>c3p0</artifactId>
   <version>0.9.5.2</version>
</dependency>

<!-- Spring maven 网络加载地址 -->
<repositories>
    <repository>
        <id>io.spring.repo.maven.release</id>
        <url>http://repo.spring.io/release/</url>
        <snapshots><enabled>false</enabled></snapshots>
    </repository>
</repositories> 

下面build里面的内容可根据需求定义，也可先不用，直接用 run As on server 直接用tomcat跑

第四步：建立目录结果

总体就是各层分开，Entity 里面最好分对应数据库表结构的实体 和 对应于自定义的实体。Dao层和Service层最好用多台实现，就是有接口有实现类

第五步，配置文件

Web.xml

 

<context-param>   
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:applicationContext.xml</param-value>

  </context-param>

 <!-- 配置 spring mvc  -->
  <servlet>
        <servlet-name>springMVC</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
       <!--  配置Spring mvc下的配置文件的位置和名称 -->
       <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:applicationContext.xml</param-value>
       </init-param> 
       <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
        <servlet-name>springMVC</servlet-name>
        <url-pattern>*.action</url-pattern>
  </servlet-mapping>

  <listener>    
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>

 <!-- 字符过滤 encodeing -->  
  <filter>  
      <filter-name>encodingFilter</filter-name>  
      <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>  
      <init-param>  
          <param-name>encoding</param-name>  
          <param-value>UTF-8</param-value>  
      </init-param>  
      <init-param>  
          <param-name>forceEncoding</param-name>  
          <param-value>true</param-value>  
      </init-param>  
  </filter> 

applicationContext.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:aop="http://www.springframework.org/schema/aop"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:mvc="http://www.springframework.org/schema/mvc"
    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/mvc 
        http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd
        http://www.springframework.org/schema/tx
        http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
        ">
        
<!-- 支持注解 -->  
    <mvc:annotation-driven /> 
    
    <!--自动装配DefaultAnnotationHandlerMapping和AnnotationMethodHandlerAdapter -->  
<mvc:default-servlet-handler />
 
<!-- 配置自动扫描的包 -->
    <context:component-scan base-package="com.xingxing" />
    
    <!-- 配置视图解析器如何把handler 方法返回值解析为实际的物理shitu -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    <!-- <property name="viewClass" value="org.springframework.web.servlet.view.JstlView" />   -->
    <property name = "prefix" value="/WEB-INF/views/"></property>
        <property name = "suffix" value = ".jsp"></property>
    </bean>
    
    
    <!-- 加载数据库连接信息 -->
<context:property-placeholder location="classpath:dbconfig.properties"/> 
        
    <!-- 配置数据源 -->
<bean id="c3p0DataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy-method="close">
<property name="driverClass" value="${driverClass}" />
<property name="jdbcUrl" value="${jdbcUrl}" />
<property name="user" value="${user}" />
<property name="password" value="${password}" />
<property name="maxPoolSize" value="${maxPoolSize}" />
<property name="initialPoolSize" value="${initialPoolSize}" />
</bean>

<!-- 配置hibernate session工厂 -->
<bean id="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">    
        <property name="dataSource" ref="c3p0DataSource" />    
        <property name="hibernateProperties">    
            <props>    
                <prop key="hibernate.hbm2ddl.auto">validate</prop>    
                <prop key="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</prop>    
                <prop key="hibernate.show_sql">true</prop>    
                <prop key="hibernate.format_sql">false</prop>    
                <prop key="hibernate.connection.driver_class" >${driverClass}</prop>
                <prop key="hibernate.current_session_context_class">org.springframework.orm.hibernate5.SpringSessionContext</prop>
            </props>    
        </property>
        
        <!-- 自动扫描注解方式配置的hibernate类文件 -->    
        <property name="packagesToScan">    
            <list>    
           <!--   此处与entity实体路径对应  -->   
                <value>com.xingxing.entity.po*</value>    
            </list>    
        </property>       
    </bean>  
    
    <bean id="hibernateTemplate" class="org.springframework.orm.hibernate5.HibernateTemplate">
        <property name="sessionFactory" ref="sessionFactory"/>
    </bean>
    
    <!-- 配置事务管理器 -->    
    <bean name="transactionManager" class="org.springframework.orm.hibernate5.HibernateTransactionManager">    
        <property name="sessionFactory" ref="sessionFactory"></property>    
    </bean>  
    
    
    <!-- 注解方式配置事物 -->    
    <tx:annotation-driven  transaction-manager="transactionManager" proxy-target-class="true" />
        
        
</beans>

需要注意的几点：

1> <prop key="hibernate.hbm2ddl.auto">validate</prop>  Hibernate对数据库的控制，当前配置是验证，也可以配成生成，删除等其他

2>

 这个包的路径是实体类的位置的书写方式.。其他内容都有注释 应该很容易懂。

dbconfig.properties 的文件里面存放数据库连接信息，

第五步：利用hibernate反向工程生成 实体类

这一项稍微有点麻烦，需要先在Eclipse中集成Hibernate 插件，直接在Eclipse里面下载的集成就行。

配置完之后配置数据源等，让Eclipse里面能有hibernate 的那个窗口。然后生成实体类

这里面要注意如果数据库设置了外键的话，一定记得选择 一对多 多对一的映射关系。还有下面这个是最好选了。关系到生成多对一的时候数据类型的问题。选了后就不用手动去调整

第六步，编写 BaseDao，的内容。上一步也可以直接生成DAO Code  不过生成的不太好实现。这里建议手动书写BaseDao。强烈需要注意的是事务的问题。还有

Save update delete 的 readOnly 权限的问题。如果发现保存数据出现没权限的问题。有好几种修改办法。这里推荐两种

或者

个人比较推荐第一种。这是调用框架本身的方法。还有其他的解决办法基本很多都没效果，如在WEB.XML进行配置。在application.xml进行配置。其实代码执行到Hibernate中，Session 又成只读的了。不想走太多弯路，可以直接使用上面方法加在 BASEDao的实现方法里面即可。

具体代码我就不贴了。因为我也是从网上扒的。都一样。贴几个比较常用的。接口自己根据实现类编写。

/**
 * 数据访问实现父类；提供对数据库CRUD基本操作的规�?
 * author:duanyongxing
 * create date:2014-12-15
 *
 * modified by:
 * modified date:
 * why: 
 * 
 */


import java.io.Serializable;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.List;


import javax.annotation.Resource;


import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.criterion.DetachedCriteria;
import org.hibernate.criterion.Projections;
import org.springframework.orm.hibernate5.support.HibernateDaoSupport;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Transactional;


import com.xingxing.dao.base.IBaseDao;


@Repository//自动扫描
public abstract class BaseDaoHibernateImpl<T> extends HibernateDaoSupport implements IBaseDao<T> {

// 存储泛型的实际参数
    private Class<T> clazz;


    public BaseDaoHibernateImpl() {
        // 谁实现该类，这就是谁的类字节码
        Class c = this.getClass();
        // 返回表示此 Class 所表示的实体（类、接口、基本类型或 void）的直接超类的 Type
        Type type = c.getGenericSuperclass();
        // 将类型强转为参数化类型
        ParameterizedType pType = (ParameterizedType) type;
        // 获取该类的父类的所有实际类型参数，也就是泛型的实际参数
        // 这里也就是获取BaseDaoImpl的实际类型参数
        Type[] actualTypeArguments = pType.getActualTypeArguments();
        // 将实际类型参数赋值给成员变量
        clazz = (Class<T>) (actualTypeArguments[0]);
    }
    
    @Resource(name = "sessionFactory")
    public void setMySessionFactory(SessionFactory sessionFactory) {
        super.setSessionFactory(sessionFactory);
    }
    


    @Override
    public Serializable save(T entity) {
    //解决save 方法 readOnly 问题 http://blog.csdn.net/baidu_28283827/article/details/52740330
        //return this.getHibernateTemplate().save(entity);
    this.getHibernateTemplate().setCheckWriteOperations(false);  //readonly
        return this.getHibernateTemplate().save(entity);
    }


    @Override
    public void update(T entity) {
    this.getHibernateTemplate().setCheckWriteOperations(false);
        this.getHibernateTemplate().update(entity);
    }


    @Override
    public void saveOrUpdate(T entity) {
    this.getHibernateTemplate().setCheckWriteOperations(false);
        this.getHibernateTemplate().saveOrUpdate(entity);
    }


    @Override
    public void delete(T entity) {
    this.getHibernateTemplate().setCheckWriteOperations(false);
        this.getHibernateTemplate().delete(entity);
    }


    @Override
    public T findById(Serializable oid) {
        return (T) this.getHibernateTemplate().get(this.clazz, oid);
    }


    @Override
    public List<T> findAll() {
        return (List<T>) this.getHibernateTemplate().find("from " + this.clazz.getSimpleName());
    }

第七步：几个关键注解

1.Dao层每个实现类上的 @Repository

2.Service层，实现类上面的 @Service  

3.事务，一般来说在Service 的实现类中，类上面可以加，方法上面也可以加。

@Transactional   //开启事务

4.Action 层中，类上面的@Controller    方法上面的 @RequestMapping

其中@RequestMapping 的值可根据 前面的配置修改

第八步：run as OnServer  。执行增删改查操作就行