Maven搭建SpringMVC+Hibernate項目詳解

Maven搭建SpringMVC+Hibernate項目詳解

搭建SpringMVC+hibernate的框架的思路如下：

     1、設計數據庫：設計好表結構，最好符合3NF，採用Hibernate tools將設計好的表自動生成對應的實體entity。 

     1、創建Maven項目，按需映入Maven包依賴。

     2、搭建spring：配置Spring對控件層Bean的注入。

     3、搭建Hibernate：配置數據源，配置SessionFactory，配置事務，以及二級緩存ehcache的配置。

     4、測試Spring+Hibernate的框架搭建，寫單元測試JUnit，測試事務配置等。

     5、映入SpringMVC：配置SpringMVC配置信息。

     6、配置web.xml容器

     7、測試三個框架的整合：Maven編譯打包部署服務器，測試。

1、數據庫設計

       設計一個權限、角色、用戶的表。自然如果一個用戶可以有多個角色，一個角色多個用戶所擁有；一個角色擁有多個權限，一個權限對應多個角色。所以按照數據庫表結構設計，符合3NF的話我們需要5張表進行存在。表的具體信息就不列出了（可以下在源碼，裏面還有數據庫），表關係如下：

       

      這裏面ID纔用到是Java的UUID（36位）

2、創建Maven項目，編寫pom.xml文件

      創建一個Maven的webapp項目，編寫pom.xml文件，引入所需的包依賴，我這裏就將所需的全部的映入了。

        

      pom.xml文件內容如下:

       

  <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/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>org.andy.sh</groupId>
    <artifactId>springmvc_hibernate_demo</artifactId>
    <packaging>war</packaging>
    <version>0.0.1-SNAPSHOT</version>

    <name>springmvc_hibernate_demo Maven Webapp</name>
    <url>http://maven.apache.org</url>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <spring.version>4.1.4.RELEASE</spring.version>
        <hibernate.version>4.3.8.Final</hibernate.version>
        <jackson.version>2.5.0</jackson.version>
    </properties>

    <dependencies>

        <!-- junit -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>

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

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

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

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

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

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>${spring.version}</version>
            <scope>test</scope>
        </dependency>

        <!-- 使用SpringMVC需配置 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <!-- 關係型數據庫整合時需配置 如hibernate jpa等 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
            <version>${spring.version}</version>
        </dependency>

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

        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-ehcache</artifactId>
            <version>${hibernate.version}</version>
        </dependency>

        <!-- 二級緩存ehcache -->
        <dependency>
            <groupId>net.sf.ehcache</groupId>
            <artifactId>ehcache</artifactId>
            <version>2.9.0</version>
        </dependency>

        <!-- log4j -->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>

        <!-- mysql連接 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.34</version>
        </dependency>

        <!-- c3p0數據源 -->
        <dependency>
            <groupId>com.mchange</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.5-pre10</version>
        </dependency>

        <!-- json -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.3</version>
        </dependency>

        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-annotations</artifactId>
            <version>${jackson.version}</version>
        </dependency>

        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-core</artifactId>
            <version>${jackson.version}</version>
        </dependency>

        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>${jackson.version}</version>
        </dependency>

        <!-- aop -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.4</version>
        </dependency>

        <!-- servlet -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>servlet-api</artifactId>
            <version>3.0-alpha-1</version>
            <scope>provided</scope>
        </dependency>

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

    </dependencies>

    <build>
        <finalName>springmvc_hibernate_demo</finalName>

        <plugins>
            <!-- Run the JUnit unit tests in an isolated classloader -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <version>2.4.2</version>
                <configuration>
                    <skipTests>true</skipTests>
                </configuration>

            </plugin>

            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-war-plugin</artifactId>
                <version>2.3</version>
                <configuration>
                    <webXml>src/main/webapp/WEB-INF/web.xml</webXml>
                </configuration>
            </plugin>

            <!-- generate java doc -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-javadoc-plugin</artifactId>
                <version>2.9.1</version>
                <configuration>
                    <javadocDirectory>target/javadoc</javadocDirectory>
                    <reportOutputDirectory>target/javadoc</reportOutputDirectory>
                    <charset>UTF-8</charset>
                    <encoding>UTF-8</encoding>
                    <docencoding>UTF-8</docencoding>
                    <show>private</show>
                </configuration>
            </plugin>

            <!-- 部署至本機 -->
            <plugin>
                <groupId>org.codehaus.cargo</groupId>
                <artifactId>cargo-maven2-plugin</artifactId>
                <version>1.0</version>
                <configuration>
                    <container>
                        <containerId>tomcat6x</containerId>
                        <home>D:\WebServer\apache-tomcat-6.0.39</home>
                    </container>
                    <configuration>
                        <type>existing</type>
                        <home>D:\WebServer\apache-tomcat-6.0.39</home>
                    </configuration>
                </configuration>
            </plugin>
        </plugins>

    </build>
</project>

3、引入Spring配置

    編寫配置文件，配置文件放在src/main/resources資源目錄下（下同）。

   項目所需的配置信息config.properties

  

#application configs

#jdbc c3p0 config
jdbc.driver = com.mysql.jdbc.Driver
jdbc.url = jdbc:mysql://localhost:3306/work?useUnicode=true&characterEncoding=utf-8
jdbc.username = root
jdbc.password = 12345

#hibernate config
hibernate.dialect = org.hibernate.dialect.MySQLDialect
hibernate.show_sql = true
hibernate.format_sql = false
hibernate.hbm2ddl.auto = update
hibernate.cache.use_second_level_cache = true
hibernate.cache.use_query_cache = true
hibernate.cache.region.factory_class = org.hibernate.cache.ehcache.EhCacheRegionFactory
hibernate.cache.provider_configuration_file_resource_path = ehcache.xml

3.1、spring配置

spring.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.1.xsd
            http://www.springframework.org/schema/context
            http://www.springframework.org/schema/context/spring-context-4.1.xsd">
    <!-- 加載配置文件 -->

    <context:property-placeholder location="classpath:config.properties"/>
    <!-- 掃描service自動注入爲bean -->
    <context:component-scan base-package="org.andy.work.service.impl,org.andy.work.dao.impl" />

</beans>

上面spring配置了對應包下組件bean自動注入管理，我們需要將dao,service的實現類交由spring管理，如（@Repository，@Service）。

3.2、引入日誌文件配置Log4j

  log4j.properties的配置文件如下：

 

### set log levels ###
log4j.rootLogger = INFO , C , D , E

### console ###
log4j.appender.C = org.apache.log4j.ConsoleAppender
log4j.appender.C.Target = System.out
log4j.appender.C.layout = org.apache.log4j.PatternLayout
log4j.appender.C.layout.ConversionPattern = [springmvc_hibernate_demo][%p] [%-d{yyyy-MM-dd HH:mm:ss}] %C.%M(%L) | %m%n

### log file ###
log4j.appender.D = org.apache.log4j.DailyRollingFileAppender
log4j.appender.D.File = ../logs/springmvc_hibernate_demo.log
log4j.appender.D.Append = true
log4j.appender.D.Threshold = INFO
log4j.appender.D.layout = org.apache.log4j.PatternLayout
log4j.appender.D.layout.ConversionPattern = [springmvc_hibernate_demo][%p] [%-d{yyyy-MM-dd HH:mm:ss}] %C.%M(%L) | %m%n

### exception ###
log4j.appender.E = org.apache.log4j.DailyRollingFileAppender
log4j.appender.E.File = ../logs/springmvc_hibernate_demo_error.log
log4j.appender.E.Append = true
log4j.appender.E.Threshold = ERROR
log4j.appender.E.layout = org.apache.log4j.PatternLayout
log4j.appender.E.layout.ConversionPattern = [sspringmvc_hibernate_demo][%p] [%-d{yyyy-MM-dd HH:mm:ss}] %C.%M(%L) | %m%n

4、Hibernate配置

      Hibernate的配置主要包括：配置數據源c3p0，配置SessionFactory，配置事務管理器，配置事務管理，其spring-hibernate.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:tx="http://www.springframework.org/schema/tx"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-4.1.xsd
        http://www.springframework.org/schema/tx
        http://www.springframework.org/schema/tx/spring-tx-4.1.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop-4.1.xsd">

    <!-- 配置數據源 c3p0 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"
        destroy-method="close">
        <property name="driverClass" value="${jdbc.driver}" />
        <property name="jdbcUrl" value="${jdbc.url}" />
        <property name="user" value="${jdbc.username}" />
        <property name="password" value="${jdbc.password}" />

        <!-- 請求超時時間 -->
        <property name="checkoutTimeout" value="30000" />
        <!-- 每60秒檢查所有連接池中的空閒連接。默認值: 0，不檢查 -->
        <property name="idleConnectionTestPeriod" value="30" />
        <!-- 連接數據庫連接池最大空閒時間 -->
        <property name="maxIdleTime" value="30" />
        <!-- 連接池初始化連接數 -->
        <property name="initialPoolSize" value="5" />
        <property name="minPoolSize" value="5" />
        <property name="maxPoolSize" value="20" />
        <!--當連接池中的連接耗盡的時候c3p0一次同時獲取的連接數。默認值: 3 -->
        <property name="acquireIncrement" value="5" />
    </bean>

    <!-- 配置hibernate的SessionFactory -->
    <bean id="sessionFactory"
        class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
        <!-- 注入數據源 相關信息看源碼 -->
        <property name="dataSource" ref="dataSource" />
        <!-- hibernate配置信息 -->
        <property name="hibernateProperties">
            <props>
                <prop key="hibernate.dialect">${hibernate.dialect}</prop>
                <prop key="hibernate.show_sql">${hibernate.show_sql}</prop>
                <prop key="hibernate.format_sql">${hibernate.format_sql}</prop>
                <prop key="hibernate.hbm2ddl.auto">${hibernate.hbm2ddl.auto}</prop>

                <!-- 開啓二級緩存 ehcache -->
                <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="hibernate.cache.provider_configuration_file_resource_path">${hibernate.cache.provider_configuration_file_resource_path}
                </prop>
            </props>
        </property>
        <!-- 掃描hibernate註解配置的entity -->
        <property name="packagesToScan" value="org.andy.work.entity" />
    </bean>

    <!-- 配置事務管理器 -->
    <bean id="transactionManager"
        class="org.springframework.orm.hibernate4.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory" />
    </bean>

    <!-- 配置事務增強處理Bean，指定事務管理器 -->
    <tx:advice id="transactionAdvice" transaction-manager="transactionManager">
        <!-- 配置詳細事務處理語義 -->
        <tx:attributes>
            <tx:method name="insert*" propagation="REQUIRED" />
            <tx:method name="update*" propagation="REQUIRED" />
            <tx:method name="delete*" propagation="REQUIRED" />

            <tx:method name="get*" propagation="SUPPORTS" read-only="true" />
            <tx:method name="find*" propagation="SUPPORTS" read-only="true" />
            <tx:method name="select*" propagation="SUPPORTS" read-only="true" />
            <tx:method name="load*" propagation="SUPPORTS" read-only="true" />

            <!-- 其他採用默認事務方式 -->
            <tx:method name="*" />

        </tx:attributes>
    </tx:advice>

    <!-- Spring aop事務管理 -->
    <aop:config>
        <!-- 配置切入點 -->
        <aop:pointcut id="transactionPointcut"
            expression="execution(* org.andy.work.service..*Impl.*(..))" />
        <!-- 指定在txAdvice切入點應用txAdvice事務增強處理 -->
        <aop:advisor pointcut-ref="transactionPointcut"
            advice-ref="transactionAdvice" />
    </aop:config>

</beans>

     上面配置了二級緩存，ehcache，相關的具體信息查看上一篇Hibernate二級緩存以及ehcache的搭建配置，下面是二級緩存的配置。

4.1、ehcache.xml的配置

       

<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../config/ehcache.xsd">
    <diskStore path="D:/ehcache" />
    <!-- DefaultCache setting. -->
     <defaultCache
            maxElementsInMemory="1000"
            eternal="false"
            timeToIdleSeconds="120"
            timeToLiveSeconds="120"
            maxElementsOnDisk="1000000"
            overflowToDisk="true"
            memoryStoreEvictionPolicy="LRU">

    </defaultCache>

    <!-- Special objects setting. -->

    <cache
         name="org.andy.work.entity.AcctUser"
         maxElementsInMemory="2"
         memoryStoreEvictionPolicy="LRU"
         eternal="true"
         diskPersistent="false"
         overflowToDisk="false"
         maxElementsOnDisk="1000000" />



</ehcache>

   上面Hibernate二級緩存ehcache存放磁盤是D:/ehcache

5、生成業務entity實體

      設計好數據表後，Hibernate的實體有工具Hibernate tools自動生成，Eclipse需要安裝Hibernate tools插件（我在線安裝過幾次都不成功，推薦使用links離線安裝，附錄將介紹），所以不需要手工的書寫，下面就貼一個用戶信息的實體，AcctUser.java

     

package org.andy.work.entity;

// Generated 2015-2-3 10:43:00 by Hibernate Tools 4.0.0

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

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.ManyToMany;
import javax.persistence.Table;
import javax.persistence.Temporal;
import javax.persistence.TemporalType;

import org.hibernate.annotations.Cache;
import org.hibernate.annotations.CacheConcurrencyStrategy;

import com.fasterxml.jackson.annotation.JsonIgnoreProperties;

/**
 * AcctUser generated by hbm2java
 */
@Entity
@Table(name = "acct_user", catalog = "work")
@Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
public class AcctUser implements java.io.Serializable {

    /**
     *
     */
    private static final long serialVersionUID = 6980093847795726310L;
    private String id;
    private String nickName;
    private String telephone;
    private Date registerTime;
    private Set<AcctRole> acctRoles = new HashSet<AcctRole>(0);

    public AcctUser() {

    }

    public AcctUser(String id, String nickName) {
        this.id = id;
        this.nickName = nickName;
    }

    public AcctUser(String id, String nickName, String telephone,
            Date registerTime, Set<AcctRole> acctRoles) {
        this.id = id;
        this.nickName = nickName;
        this.telephone = telephone;
        this.registerTime = registerTime;
        this.acctRoles = acctRoles;
    }

    @Id
    @Column(name = "id", unique = true, nullable = false, length = 36)
    public String getId() {
        return this.id;
    }

    public void setId(String id) {
        this.id = id;
    }

    @Column(name = "nick_name", nullable = false)
    public String getNickName() {
        return this.nickName;
    }

    public void setNickName(String nickName) {
        this.nickName = nickName;
    }

    @Column(name = "telephone")
    public String getTelephone() {
        return this.telephone;
    }

    public void setTelephone(String telephone) {
        this.telephone = telephone;
    }

    @Temporal(TemporalType.TIMESTAMP)
    @Column(name = "register_time", length = 19)
    public Date getRegisterTime() {
        return this.registerTime;
    }

    public void setRegisterTime(Date registerTime) {
        this.registerTime = registerTime;
    }

    @JsonIgnoreProperties(value={"acctUsers", "acctAuthorities"})
    @ManyToMany(fetch = FetchType.LAZY)
    @Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
    @JoinTable(name = "acct_user_role", catalog = "work", joinColumns = { @JoinColumn(name = "user_id", nullable = false, updatable = false) }, inverseJoinColumns = { @JoinColumn(name = "role_id", nullable = false, updatable = false) })
    public Set<AcctRole> getAcctRoles() {
        return this.acctRoles;
    }

    public void setAcctRoles(Set<AcctRole> acctRoles) {
        this.acctRoles = acctRoles;
    }

}

上面有幾個需要注意的：

     上面大多數都是Hibernate tools自動生成的，但是有幾個需要手動添加：

              1、如果這個實體使用二級緩存的話，需要添加@cache註解；

              2、如果該實體裏面還有集合元素（set， map，list），如果實體要採用二級緩存，那麼這些集合元素必須也添加@cache註解。

              3、@JsonIgnoreProperties註解是爲了防止SpringMVC在json返回時產生循環輸出使用，如果不配置的話就會出現json死循環（還有多對多，一對多的屬性時）。

             4、@JsonIgnore這個是在轉換成json是忽略該屬性，而@JsonIgnoreProperties(value={"acctUsers", "acctAuthorities"})則是忽略acctRoles裏面的acctUsers和acctAuthorites屬性。

6、創建Dao層

6.1Dao接口

              Dao層和Service層我們肯定採用的是面相接口編程的思想，所以，我們先定義一個通用的Dao接口，GenericDao.java

            

package org.andy.work.dao;

import java.io.Serializable;
import java.util.List;

/**
 * 創建時間：2015-2-6 下午2:26:42
 *
 * @author andy
 * @version 2.2
 *
 * Dao通用接口
 */

interface GenericDao<T, PK extends Serializable> {

    T load(PK id);

    T get(PK id);

    List<T> findAll();

    void persist(T entity);

    PK save(T entity);

    void saveOrUpdate(T entity);

    void delete(PK id);

    void flush();
}

            在定義具體的UserDao.java接口

           

package org.andy.work.dao;

import org.andy.work.entity.AcctUser;

/**
 * 創建時間：2015-2-6 下午2:43:50
 *
 * @author andy
 * @version 2.2
 *
 * 用戶Dao接口
 */

public interface UserDao extends GenericDao<AcctUser, String> {

}

6.2、Dao層實現類

    我們需要將Dao層的實現類注入爲bean，所以需要添加@Repository註解，UserDaoImpl如下：

package org.andy.work.dao.impl;

import java.util.List;

import org.andy.work.dao.UserDao;
import org.andy.work.entity.AcctUser;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;

/**
 * 創建時間：2015-2-6 下午2:45:14
 *
 * @author andy
 * @version 2.2
 */
@Repository("userDao")
public class UserDaoImpl implements UserDao {

    @Autowired
    private SessionFactory sessionFactory;

    private Session getCurrentSession() {
        return this.sessionFactory.getCurrentSession();
    }

    @Override
    public AcctUser load(String id) {
        return (AcctUser) this.getCurrentSession().load(AcctUser.class, id);
    }

    @Override
    public AcctUser get(String id) {
        return (AcctUser) this.getCurrentSession().get(AcctUser.class, id);
    }

    @SuppressWarnings("unchecked")
    @Override
    public List<AcctUser> findAll() {
        List<AcctUser> acctUsers = this.getCurrentSession().createQuery("from AcctUser").setCacheable(true).list();
        return acctUsers;
    }

    @Override
    public void persist(AcctUser entity) {
        this.getCurrentSession().persist(entity);

    }

    @Override
    public String save(AcctUser entity) {
        return (String) this.getCurrentSession().save(entity);
    }

    @Override
    public void saveOrUpdate(AcctUser entity) {
        this.getCurrentSession().saveOrUpdate(entity);
    }

    @Override
    public void delete(String id) {
        AcctUser entity = this.load(id);
        this.getCurrentSession().delete(entity);
    }

    @Override
    public void flush() {
        this.getCurrentSession().flush();

    }

}

7、創建Service層

  7.1、Service層接口

package org.andy.work.service;

import java.util.List;

import org.andy.work.entity.AcctUser;

/**
 * 創建時間：2015-2-6 下午3:18:57
 *
 * @author andy
 * @version 2.2
 *  userService接口
 */

public interface UserService {
    AcctUser load(String id);

    AcctUser get(String id);

    List<AcctUser> findAll();

    void persist(AcctUser entity);

    String save(AcctUser entity);

    void saveOrUpdate(AcctUser entity);

    void delete(String id);

    void flush();
}

  7.2、service層實現類

   UserServiceImpl就需要注入上面定義的Dao層bean。

 

package org.andy.work.service.impl;

import java.util.List;

import org.andy.work.dao.UserDao;
import org.andy.work.entity.AcctUser;
import org.andy.work.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

/**
 * 創建時間：2015-2-6 下午3:24:16
 *
 * @author andy
 * @version 2.2 UserService 的實現
 */
@Service("userService")
public class UserServiceImpl implements UserService {

    @Autowired
    private UserDao userDao;

    @Override
    public AcctUser load(String id) {
        return userDao.load(id);
    }

    @Override
    public AcctUser get(String id) {
        return userDao.get(id);
    }

    @Override
    public List<AcctUser> findAll() {
        return userDao.findAll();
    }

    @Override
    public void persist(AcctUser entity) {
        userDao.persist(entity);
    }

    @Override
    public String save(AcctUser entity) {
        return userDao.save(entity);
    }

    @Override
    public void saveOrUpdate(AcctUser entity) {
        userDao.saveOrUpdate(entity);
    }

    @Override
    public void delete(String id) {
        userDao.delete(id);
    }

    @Override
    public void flush() {
        userDao.flush();
    }

}

8、測試Spring和Hibernate的整合

    我們可以在src/test/java編寫測試類，測試上面的配置，如果測試成功已經基本大功告成。

 

package org.andy.work.service;

import java.util.Date;
import java.util.List;
import java.util.UUID;

import org.andy.work.entity.AcctUser;
import org.apache.log4j.Logger;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import com.alibaba.fastjson.JSON;

/**
 * 創建時間：2015-2-6 下午3:31:07
 *
 * @author andy
 * @version 2.2
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = { "classpath:spring.xml",
        "classpath:spring-hibernate.xml" })
public class TestUserService {

    private static final Logger LOGGER = Logger
            .getLogger(TestUserService.class);

    @Autowired
    private UserService userService;

    @Test
    public void save() {
        AcctUser acctUser = new AcctUser();
        acctUser.setId(UUID.randomUUID().toString());
        acctUser.setNickName("andy");
        acctUser.setRegisterTime(new Date());
        acctUser.setTelephone("13022221111");
        String id = userService.save(acctUser);
        LOGGER.info(JSON.toJSONString(id));
    }

}

9、引入SpringMVC

     添加spring-mvc.xml文件

  

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:p="http://www.springframework.org/schema/p" 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.1.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context-4.1.xsd
        http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc-4.1.xsd">

    <!-- 自動掃描@Controller注入爲bean -->
    <context:component-scan base-package="org.andy.work.controller" />

    <!-- 以下爲SpringMVC配置 -->
    <mvc:annotation-driven>
        <!-- 返回json數據，@response使用 -->
        <mvc:message-converters register-defaults="true">
            <bean
                class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
                <property name="supportedMediaTypes">
                    <list>
                        <value>text/html;charset=UTF-8</value>
                        <value>application/json;charset=UTF-8</value>
                    </list>
                </property>

            </bean>
        </mvc:message-converters>
    </mvc:annotation-driven>

    <!-- 對模型視圖名稱的解析，即在模型視圖名稱添加前後綴 -->
    <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 name="suffix" value=".jsp" />
    </bean>

</beans>

   上面配置了包掃描Controller，將@Controller注入爲spring的bean。以及springmvc的json處理，和視圖層的配置。

10、配置web.xml容器

      web容器是web項目的大腦，所以web容器，首先需要引入spring，讓spring管理各個框架，並將其注入爲bean。然後配置控制層的filter信息。並且配置了springmvc攔截的url爲以.hmls結尾的請求。

web.xml文件如下：

 

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
    id="WebApp_ID" version="2.5">

    <display-name>springmvc_demo</display-name>

    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:spring.xml,classpath:spring-hibernate.xml</param-value>
    </context-param>

    <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>
    <filter-mapping>
        <filter-name>encodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

    <!-- openSessionInView配置 作用是延遲session關閉到view層 -->
    <filter>
        <filter-name>openSessionInViewFilter</filter-name>
        <filter-class>org.springframework.orm.hibernate4.support.OpenSessionInViewFilter</filter-class>
        <init-param>
            <param-name>singleSession</param-name>
            <param-value>true</param-value>
        </init-param>
    </filter>

    <!-- 監聽servletContext，啓動contextConfigLocation中的spring配置信息 -->
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>

    <!-- 防止spring內存溢出監聽器 -->
    <listener>
        <listener-class>org.springframework.web.util.IntrospectorCleanupListener</listener-class>
    </listener>

    <servlet>
        <description>spring mvc servlet</description>
        <servlet-name>rest</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <!-- 此處配置的是SpringMVC的配置文件 -->
            <param-value>classpath:spring-mvc.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>

    <servlet-mapping>
        <servlet-name>rest</servlet-name>
        <url-pattern>*.htmls</url-pattern>
    </servlet-mapping>

    <filter-mapping>
        <filter-name>openSessionInViewFilter</filter-name>
        <url-pattern>*.htmls</url-pattern>
    </filter-mapping>

    <!-- 配置session超時時間，單位分鐘 -->
    <session-config>
        <session-timeout>30</session-timeout>
    </session-config>

    <welcome-file-list>
        <welcome-file>/index.jsp</welcome-file>
    </welcome-file-list>
</web-app>

11、創建控制層Controller

     控制層UserController

package org.andy.work.controller;

import java.util.List;

import org.andy.work.entity.AcctUser;
import org.andy.work.service.UserService;
import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.ModelMap;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

/**
 * 創建時間：2015-2-7 上午11:49:00
 * @author andy
 * @version 2.2
 * 描述： 用戶Controller
 */
@Controller
@RequestMapping("/user")
public class UserController {

    private static final Logger LOGGER = Logger.getLogger(UserController.class);

    @Autowired
    private UserService userService;

    @RequestMapping("/showInfo/{userId}")
    public String showUserInfo(ModelMap modelMap, @PathVariable String userId){
        LOGGER.info("查詢用戶：" + userId);
        AcctUser userInfo = userService.load(userId);
        modelMap.addAttribute("userInfo", userInfo);
        return "/user/showInfo";
    }

    @RequestMapping("/showInfos")
    public @ResponseBody List<AcctUser> showUserInfos(){
        LOGGER.info("查詢用戶全部用戶");
        List<AcctUser> userInfos = userService.findAll();
        return userInfos;
    }
}

12、創建視圖層

   在src/main/webapp/WEB-INF/views下 創建user/showInfo.jsp

      

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
<%@taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt"%>

<%
    String path = request.getContextPath();
    String basePath = request.getScheme() + "://"
            + request.getServerName() + ":" + request.getServerPort()
            + path + "/";
%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<base href="<%=basePath%>" />
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<script type="text/javascript" src="js/jquery-1.9.1.min.js"></script>
<title>userInfo</title>
</head>
<body>
    用戶信息 暱稱： ${userInfo.nickName} 用戶id：${userInfo.id} 用戶電話:${userInfo.telephone } 註冊時間：
    <fmt:formatDate value="${userInfo.registerTime }" pattern="yyyy-MM-dd HH:mm:ss" />
    角色：[
    <c:forEach items="${ userInfo.acctRoles}" var="role">
                        ${role.name }   權限[
                           <c:forEach items="${ role.acctAuthorities}" var="authority">
                             ${authority.name }
                           </c:forEach> ]
                      </c:forEach>
    ]

    <br /> ajax顯示全部用戶信息：
    <div id="show_all_user"></div>
</body>
<script type="text/javascript">
    $.ajax({
        type : "get",
        url : "user/showInfos.htmls",
        dataType : "json",
        success : function(data) {
            $(data).each(
                    function(i, user) {
                        var p = "<p>暱稱:" + user.nickName + "    電話:"
                                + user.telephone + "    註冊時間:"
                                + user.registerTime + "    id:" + user.id +
                        "</p>";
                        $("#show_all_user").append(p);
                    });
        },
        async : true
    });
</script>
</html>

13、部署服務器測試

          使用Maven打包部署：clean compile  package

          部署到tomcat，測試

          主要測試上面的  http://localhost:8080/springmvc_hibernate_demo/user/showInfo/6e5afb1d-50e1-45fe-b6fe-b9e399415387.htmls

                                  和http://localhost:8080/springmvc_hibernate_demo/user/showInfos.htmls  （json數據返回）

          上面視圖層就包含了這兩條url請求的測試：

        

     ok，到此Spring+SpringMVC+Hibernate搭建完畢。