2. 程式人生 > >基於spring+springmvc+hibernate的maven專案搭建

基於spring+springmvc+hibernate的maven專案搭建

阿新 • • 發佈：2019-02-07

1.新建一個maven專案

（1）選擇工作區間
這裡寫圖片描述

（2）選擇maven-archetype-webapp
這裡寫圖片描述

（3）輸入Group id（包名的字首）和Artifact Id(專案名)，然後finish
這裡寫圖片描述

（4）完成上面的步驟，專案的目錄如下：
這裡寫圖片描述

（5）修改Dynamic Web Module和java的版本
這裡寫圖片描述
（有人可能不理解這個Dynamic Web Module，其實就是：java的web系統有多種型別，比如靜態的和動態的，然後動態的java web project要設定dynamic web module，也就是動態網頁模型，他必須要和對應的伺服器搭配好了才能跑，版本對應如下
dynamic web module 2.4 對應Tomcat 5.5
dynamic web module 2.5 對應Tomcat 6.0
dynamic web module 3.0 對應Tomcat 7.0或更高）

2.配置3個xml檔案

web.xml
web.xml主要配置：ContextLoaderListener和DispatcherServer，程式碼如下：

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

    <!-- 配置web.xml，使其具有springmvc特性，主要配置兩處，一個是ContextLoaderListener，一個是DispatcherServlet -->

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

    <!-- 配置ContextLoaderListener表示，該工程要以spring的方式啟動。啟動時會預設在/WEB-INF目錄下查詢applicationContext.xml
作為spring容器的配置檔案，該檔案裡可以初始化一些bean -->
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>


    <filter>
       <filter-name>SpringOpenSessionInViewFilter</filter-name>
       <filter-class>org.springframework.orm.hibernate4.support.OpenSessionInViewFilter</filter-class>
     </filter>
  <filter-mapping>
    <filter-name>SpringOpenSessionInViewFilter</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>
    <!-- 字符集過濾器 -->  
    <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>
    </filter>
    <filter-mapping>
        <filter-name>encodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>


    <!-- spring mvc 配置 -->
    <!-- 配置DispatcherServlet表示，該工程將採用springmvc的方式。啟動時也會預設在/WEB-INF目錄下查詢XXX-servlet.xml作為配置檔案，
        XXX就是DispatcherServlet的名字，該檔案中將配置兩項重要的mvc特性：HandlerMapping,負責為DispatcherServlet這個前端控制器的請求查詢Controller；
        ViewResolver,負責為DispatcherServlet查詢ModelAndView的檢視解析器。
        此處使用指定的配置檔案spring-mvc.xml -->
    <servlet>
        <servlet-name>contacts</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>  
            <param-name>contextConfigLocation</param-name>  
            <!--<param-value>/WEB-INF/classes/spring-mvc-servlet.xml</param-value>-->
            <param-value>classpath*:/spring-mvc.xml</param-value>
        </init-param>  
        <load-on-startup>1</load-on-startup>  
    </servlet>
    <servlet-mapping>
        <servlet-name>contacts</servlet-name>
        <url-pattern>*.htm</url-pattern>
    </servlet-mapping>

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

applicationContext.xml
配置ContextLoaderListener表示，該工程要以spring的方式啟動。啟動時會預設在/WEB-INF目錄下查詢 applicationContext.xml作為spring容器的配置檔案，這裡可以初始化一些bean，如DataSource等。程式碼如下：

<?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"
    xmlns:p="http://www.springframework.org/schema/p" xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
    http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd 
    http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.1.xsd 
    http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.1.xsd">


    <context:component-scan base-package="ssh.demo"></context:component-scan>

    <bean
        class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="locations">
            <list>
                <value>classpath:database.properties</value>
            </list>

        </property>
    </bean>


    <bean id="dataSource"
        class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="${jdbc.driverClassName}" />
        <property name="url" value="${jdbc.url}" />
        <property name="username" value="${jdbc.username}" />
        <property name="password" value="${jdbc.password}" />
    </bean>

    <!-- Hibernate session factory -->
     <bean id="sessionFactory" class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
       <property name="dataSource" ref="dataSource"/>

       <property name="packagesToScan">
         <list>
           <value>ssh.demo</value>
         </list>
       </property>
<!-- 
        <property name="mappingLocations">
          <list>
            <value>classpath:**/*.hbm.xml</value>
          </list>
        </property>
-->
        <property name="hibernateProperties">
            <props>
                <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
                <prop key="hibernate.show_sql">true</prop>
                <!-- <prop key="hibernate.hbm2ddl.auto">update</prop> -->
                <prop key="hibernate.current_session_context_class">
                   org.springframework.orm.hibernate4.SpringSessionContext
                </prop>
                <prop key="hibernate.jdbc.batch_size">50</prop>
                <prop key="hibernate.enable_lazy_load_no_trans">true</prop>
            </props>
        </property>
     </bean>   

    <!-- 例項化jdbcTemplate,同時注入資料來源 -->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"
        p:dataSource-ref="dataSource" />

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

    <!-- 事務掃描開始(開啟@Tranctional) -->
    <tx:annotation-driven transaction-manager="transactionManager" proxy-target-class="true"/> 

</beans>

spring-mvc.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:p="http://www.springframework.org/schema/p"    
xmlns:context="http://www.springframework.org/schema/context" 
xmlns:mvc="http://www.springframework.org/schema/mvc"
xsi:schemaLocation="http://www.springframework.org/schema/beans    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd    
http://www.springframework.org/schema/context    http://www.springframework.org/schema/context/spring-context-3.0.xsd 
http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd"
default-lazy-init="true">

<!-- 此行語句使得resource autowired 等四個註解可以使用 -->
   <context:annotation-config />
   <context:component-scan base-package="ssh.demo" >
   </context:component-scan>  

</beans>

3.新增必須的包依賴到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>ssh.demo</groupId>
  <artifactId>ssh_Demo</artifactId>
  <packaging>war</packaging>
  <version>0.0.1-SNAPSHOT</version>
  <name>ssh_Demo Maven Webapp</name>
  <url>http://maven.apache.org</url>
 <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <!-- <spring.ver>4.1.8.RELEASE</spring.ver> -->
        <spring.ver>4.2.5.RELEASE</spring.ver>
        <hibernate.ver>4.3.11.Final</hibernate.ver>
        <hibernate.common.anno.ver>5.0.0.Final</hibernate.common.anno.ver>
        <hibernate.validator.ver>5.1.3.Final</hibernate.validator.ver>
        <mysql.connector.ver>5.1.36</mysql.connector.ver>
        <aspectj.ver>1.8.6</aspectj.ver>
        <jackson.ver>2.6.4</jackson.ver>
        <commons-file.ver>1.3.1</commons-file.ver>
        <common.csv.ver>1.2</common.csv.ver>        
        <reflection.ver>0.9.10</reflection.ver>
    </properties>

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

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

        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-redis</artifactId>
            <version>1.6.0.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>${spring.ver}</version>
            <scope>test</scope>
        </dependency>
        <!-- json config section -->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>${jackson.ver}</version>
        </dependency>

        <!-- spring configure section -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${spring.ver}</version>
        </dependency>

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

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

        <!-- AspectJ -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjrt</artifactId>
            <version>${aspectj.ver}</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>${aspectj.ver}</version>
        </dependency>

        <dependency>
            <groupId>commons-fileupload</groupId>
            <artifactId>commons-fileupload</artifactId>
            <version>${commons-file.ver}</version>
        </dependency>
        <!-- hibernate configure section -->

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

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

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

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

        <dependency>
            <groupId>org.hibernate.common</groupId>
            <artifactId>hibernate-commons-annotations</artifactId>
            <version>${hibernate.common.anno.ver}</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>${mysql.connector.ver}</version>
        </dependency>

        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-csv</artifactId>
            <version>${common.csv.ver}</version>
        </dependency>

        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.1.0</version>
        </dependency>

        <dependency>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-resources-plugin</artifactId>
            <version>2.4.3</version>
        </dependency>

    </dependencies>
  <build>
    <finalName>ssh_Demo</finalName>
  </build>
</project>

4.寫一個簡單的新增功能驗證專案

User.java

package ssh.demo.domain;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class User {

    @Id @GeneratedValue(strategy=GenerationType.AUTO)
    private int id;

    private String name;

    public int getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "User:[id="+id+",name="+name+"]";
    }
}

UserDao.java

package ssh.demo.dao;

import javax.transaction.Transactional;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.criterion.Restrictions;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;

import ssh.demo.domain.User;

@Repository
public class UserDao {

    @Autowired
    private SessionFactory sessionFactory;


    public Session getCurrentSession(){
        return sessionFactory.getCurrentSession();
    }

    public void save(User u){
        getCurrentSession().save(u);
    }

    public User getByName(String name){
        return (User) getCurrentSession().createCriteria(User.class)
                .add(Restrictions.eq("name", name)).uniqueResult();
    }

    public User getById(int id){
        return (User) getCurrentSession().createCriteria(User.class)
                .add(Restrictions.eq("id", id)).uniqueResult();
    }

}

Test.java

package ssh.demo.test;

import java.util.Date;

import javax.annotation.Resource;

import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import ssh.demo.dao.UserDao;
import ssh.demo.domain.User;


@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class Test {
    @Resource
    private UserDao userDao;



    @org.junit.Test
    public void saveStu(){
        User stu=new User();
        stu.setName("zs");
        userDao.save(stu);
    }
}

測試結果：

這裡寫圖片描述
這裡寫圖片描述

這個專案搭建其實還是挺簡單，不過中途會遇到一些問題，耐心點，慢慢研究下，程式碼就不放到github啦，自己試一次，印象深刻很多的。

相關推薦

基於spring+springmvc+hibernate的maven專案搭建

1.新建一個maven專案 （1）選擇工作區間 （2）選擇maven-archetype-webapp （3）輸入Group id（包名的字首）和Artifact Id(專案名)，然後finish （4）完成上面的步驟，專案的目

基於Spring+SpringMVC+Mybatis分散式敏捷開發系統架構zhen專案

目前看過做完整的專案，大家一起學習一下，詳情請點選原專案連結的地址 前言 　　zheng專案創建於2016年10月4日，正在慢慢成長中，目的不僅僅是一個開發架構，而是努力打造一套從 前端模板 - 基礎框架 - 分散式架構 - 開源專案 - 持續整合 - 自動化部署 -

intellij idea 構建 基於spring springmvc hibernate的maven專案《一》

下載軟體環境暫且不提 基本步驟如下 1.在intellij idea中建立project 填寫工程名，包名 下面一直next知道finish。這樣一個工程就建立了。 剛建立的工程目錄結構如下 2.點選工程右鍵 Add Frameworks Support按如下選擇sp

基於spring和mybatis專案的JUnit測試用例的實現

主要目的：實現JUnit的Crud 專案目前情況：spring+mybatis 想在前後端分離的情況下， 後端實現各個模組CRUD的junit 遇到的最大問題先是注入之後提示nullPointException 接著很快反應過來 是junit執行單個檔案的時候並沒有在啟動容器

spring+springmvc+mybatis環境搭建報錯問題（二）

1.啟動程式報錯： org.mybatis.spring.transaction.SpringManagedTransaction.getTimeout()Ljava/lang/Integer;          

Spring-Boot web專案搭建

Spring-Boot快速搭建web專案詳細總結 最近在學習Spring Boot 相關的技術，剛接觸就有種相見恨晚的感覺，因為用spring boot進行專案的搭建是在太方便了，我們往往只需要很簡單的幾步，便可完成一個spring MVC專案的搭建，感覺就是下圖：  好，下

spring cloud 實戰專案搭建

spring cloud 實戰專案搭建     Spring Cloud簡介   Spring Cloud是一個基於Spring Boot實現的雲應用開發工具，它為基於JVM的雲應用開發中的配置管理、服務發現、斷路器、智慧路由、微代理、控制匯流排、全

Dubbo+SpringBoot+Spring+SpringMVC+MyBatis框架搭建的Demo中遇到的錯誤

遇到的報錯問題： com.alibaba.dubbo.remoting.RemotingException: message can not send, because channel is closed . url:dubbo://192.168.43.177:20880/com.test.s

spring---入門測試專案搭建

本博文參考傳智播客、黑馬程式設計師視訊講座 spring簡介 簡單的說，spring是一個裝物件的容器。兩個重要思想：IoC和AOP 專案搭建 導包 核心包（對應上面的圖Core Container下的四個）+日誌包

【原創】基於Spring-SpringMVC-Mybatis 的 Shiro 安全框架使用教程--轉載請註明出處

Shiro使用說明文件 宣告： 我們所使用的框架為SSM框架+Shiro許可權控制框架，在以下部分中，將會描述如何使用一個Shiro框架。 框架使用概述： Shiro安全框架為我們提供了一個較為完善的許可權管理系統。我們將使用該框架提供的使用者登入，登出，使用者許可權

基於Spring+SpringMVC+Mybatis分散式敏捷開發系統架構---許可權管理系統

 README.md zheng     交流QQ群：133107819(群內含各種工具和文件下載) 前言 　　zheng專案創建於2016年10月4日，正在慢慢成長中，目的不僅僅是一個開發架構，而是努力打造一套從 前端模板 - 基礎框架 - 分散式架構 - 開源專案 - 持續整合 - 自動化部署 -

Spring MVC入門-專案搭建步驟解析

詳細Spring MVC專案搭建過程見連結：AAAAAAAAAAAAAAAAAA 此處使用Maven專案管理工具來管理SpringMVC專案。 第一步：Maven安裝和專案搭建 第二步：Spring MVC專案 1、pom.xml檔案配置 <!-- 頭部專案

SSM框架——Spring+SpringMVC+Mybatis的搭建教程

一：概述SSM框架在專案開發中經常使用到，相比於SSH框架，它在僅幾年的開發中運用的更加廣泛。Spring作為一個輕量級的框架，有很多的拓展功能，最主要的我們一般專案使用的就是IOC和AOP。SpringMVC是Spring實現的一個Web層，相當於Struts的框架，但是比

關於spring+springMVC+mybatis+maven搭建中的nested exception is org.apache.ibatis.binding.BindingException

以前沒用maven的時候啥都很好，但是現在專案使用了maven，我也就把專案轉換成了maven的方式。 專案中的mybatis使用的是mapper代理的方式進行開發，專案未遷移之前可以正常執行，但是遷移之後就一直報一個錯誤， org.apache.ibatis.bindi

vue基於vue-cli的專案搭建及部分依賴的新增

前言 vue-cli作為一款mvvm框架語言(vue)的腳手架，集成了webpack環境及主要依賴，對於專案的搭建、打包、維護管理等都非常方便快捷。在開始專案之前，建議先熟悉vue.js基本語法。

Spring+Springmvc+Hibernate框架搭建，簡單例項

最近學習spring框架，學習中總是磕磕絆絆的，出現這樣或者那樣的問題，於是就像寫一篇筆記，將spring，springmvc，hibernate框架整合的過程，以及簡單的實現記錄下來，一來加深印象，二來一遍以後忘記好找資料（...）當然，初學者也可以借鑑一下。廢話不多說，

IDEA Spring + websocket + tomcat專案搭建及打包部署

1 概述 本專案實現通過UDP從終端接收資料，並通過websocket轉發到手持裝置的示例來演示搭建過程。websocket是基於tomcat來提供功能的，並且websocket沒有新增認證策略，僅用於演示。 2 開發環境 IDEA 2017.1.

一篇文章學會Spring+SpringMVC+Mybatis+Maven搭建和部署，記一次Spring+SpringMVC+Mybatis+Maven的整合

之前一直沒有用過maven和Mybatis最近自己搭建一個基於Maven的Spring+SpringMVC+Mybatis開發環境。注：有的時候沒有自己動手真正搭過環境（脫離教學的方式），可能有些地方的問題注意不到的。會在介紹搭建的同時記錄一些遇見的坑和一些知識點。首先放上M

Spring Boot+MongoDB專案搭建

MongoDB是一個基於文件(Document)的儲存型的資料庫，使用面向物件的思想，每一條資料記錄都是文件的物件。 - 1.Spring對MongoDB的支援 Spring對MongoDB的支援主要是通過Spring Data MongoDB來實現的，

spring boot的專案搭建遇到一個小問題

再用idea建立springboot專案時,maven所引入的jar包不會自動匯入到專案中,這是pom.xml檔案<?xml version="1.0" encoding="UTF-8"?> <proj