javaweb學習總結（二）Spring4+SpringMVC4+Hibernate5框架搭建

前言：

由於某種原因，突然想自己搭一個屬於自己的項目框架出來，框架選擇時大致瞭解了市場上流行的SSM（Spring+SpringMVC+MyBatis）和SSH（Struts2+Spring+Hibernate）框架。只是做了簡單瞭解，深層次的瞭解以我現在的水平暫時還達不到。

最後決定使用Spring4+SpringMVC4+Hibernate5來完成我的項目框架。至於爲什麼選擇SpringMVC和Hibernate請自行深究。

整體思路：

1.首先搭建SpringMVC框架

2.搭建Hibernate框架

3.使用Spring整合SpringMVC，Hibernate

引入jar文件：

1.先配置好了Maven，連接的阿里雲倉庫，當添加某個jar包時，會將與這個jar包相關的jar包同時down下來。項目中配置的依賴如下圖：

2.實際根據maven依賴下載的jar包目錄如下圖：

搭建SpringMVC框架：

1.導入jar文件

如上圖所示，如果沒有配置maven，則可以從官網下載的spring framework解壓縮後，libs中所包含的所有jar包，我們只需要將spring-*-4.2.5.RELEASE.jar複製，然後粘貼至工程項目中的lib目錄下。就是將所有以RELEASE.jar結尾的，而不用將以javadoc.jar和sources.jar結尾的jar包放至lib目錄下。

2.配置web.xml

  <servlet>
	<servlet-name>mvc</servlet-name>
	<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
	<init-param>
		<param-name>contextConfigLocation</param-name>
		<param-value>classpath:conf/spring-*.xml</param-value>
	</init-param>
	<load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
	<servlet-name>mvc</servlet-name>
	<url-pattern>/</url-pattern>
  </servlet-mapping>

通過以上配置，所有從前端發送過來的請求，都將交給DispatherServlet處理。關於SpringMVC中一次完整的請求過程請看下邊：

具體執行步驟如下：

1、首先用戶發送請求————>前端控制器，前端控制器根據請求信息（如URL）來決定選擇哪一個頁面控制器進行處理並把請求委託給它，即以前的控制器的控制邏輯部分；圖2-1中的1、2步驟；
2、頁面控制器接收到請求後，進行功能處理，首先需要收集和綁定請求參數到一個對象，這個對象在Spring Web MVC中叫命令對象，並進行驗證，然後將命令對象委託給業務對象進行處理；處理完畢後返回一個ModelAndView（模型數據和邏輯視圖名）；圖2-1中的3、4、5步驟；
3、前端控制器收回控制權，然後根據返回的邏輯視圖名，選擇相應的視圖進行渲染，並把模型數據傳入以便視圖渲染；圖2-1中的步驟6、7；
4、前端控制器再次收回控制權，將響應返回給用戶，圖2-1中的步驟8；至此整個結束。

springmvc核心框架圖：

核心架構的具體流程步驟如下：
1、首先用戶發送請求——>DispatcherServlet，前端控制器收到請求後自己不進行處理，而是委託給其他的解析器進行處理，作爲統一訪問點，進行全局的流程控制；
2、 DispatcherServlet——>HandlerMapping， HandlerMapping將會把請求映射爲HandlerExecutionChain對象（包含一個Handler處理器（頁面控制器）對象、多個HandlerInterceptor攔截器）對象，通過這種策略模式，很容易添加新的映射策略；
3、 DispatcherServlet——>HandlerAdapter，HandlerAdapter將會把處理器包裝爲適配器，從而支持多種類型的處理器，即適配器設計模式的應用，從而很容易支持很多類型的處理器；
4、 HandlerAdapter——>處理器功能處理方法的調用，HandlerAdapter將會根據適配的結果調用真正的處理器的功能處理方法，完成功能處理；並返回一個ModelAndView對象（包含模型數據、邏輯視圖名）；
5、 ModelAndView的邏輯視圖名——> ViewResolver， ViewResolver將把邏輯視圖名解析爲具體的View，通過這種策略模式，很容易更換其他視圖技術；
6、 View——>渲染，View會根據傳進來的Model模型數據進行渲染，此處的Model實際是一個Map數據結構，因此很容易支持其他視圖技術；
7、返回控制權給DispatcherServlet，由DispatcherServlet返回響應給用戶，到此一個流程結束。

現在對SpringMVC應該已經有了一個大致的瞭解。

配置好了web.xml(整個web應用的配置文件)之後，接下來我們需要配置spring-mvc.xml。

下面是spring-mvc的具體配置：

<?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:jdbc="http://www.springframework.org/schema/jdbc"  
	xmlns:jee="http://www.springframework.org/schema/jee" 
	xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:aop="http://www.springframework.org/schema/aop" 
	xmlns:mvc="http://www.springframework.org/schema/mvc"
	xmlns:util="http://www.springframework.org/schema/util"
	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.3.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd
		http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-4.3.xsd
		http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-4.3.xsd
		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.3.xsd
		http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa-4.3.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd
		http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.3.xsd
		http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.3.xsd">
		
	<!-- 配置註解掃描包，這裏爲 com.myframework.controller,
		  將掃描這個包下面所有帶有@Controller的類，這些類被視爲Controller-->
	<context:component-scan base-package="com.myframework"/>
	
	<!-- 開啓註解掃描驅動 -->
	<mvc:annotation-driven/>
	
	<!-- 配置視圖渲染關係，這裏所有請求處理後將渲染爲/WEB-INF/views下的jsp文件，
		   到底是哪個jsp文件呢這就看請求處理動作到時候具體返回的是哪個文件了 -->   
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">  
        <property name="prefix">  
            <value>/WEB-INF/views/</value>  
        </property>  
        <property name="suffix">  
            <value>.jsp</value>  
        </property>  
    </bean>
</beans>

好了，現在對web應用的配置，springmvc的配置已經完成了，萬事俱備，只欠東風，我們具體的執行動作呢？

package com.myframework.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;

@Controller
public class TestController {
	@RequestMapping("/test.do")
	public ModelAndView testMVC() {
		System.out.println("這裏測試springMVC配置。");
		ModelAndView modelAndView = new ModelAndView("/test");
		modelAndView.addObject("info", "Hello,myFramework!");
		return modelAndView;
	}
}

@Controller 將該類標識爲一個Controller

@RequestMapping 表示匹配請求動作，這裏將匹配 test 這個請求動作(使用value配置)

ModelAndView modelAndView = new ModelAndView("/test"); 表示返回test.jsp，並且是/WEB-INF/views下的jsp文件(前面講過的)

我們來看看超級簡單的test.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
	pageEncoding="UTF-8"%>
${info} !!!

現在我們來做一個測試：

訪問地址：http://localhost:8085/com.myframework/test.do,在瀏覽器中得到如下顯示：

至此，我們的SpringMVC框架已經搭建完成，向前走了一小步。下面我們更進一步，來看看Hibernate框架的搭建.

搭建Hibernate框架：

第一步，導入jar包(前面都說明了，這裏就不多說了)

第二步，建立POJO對象

package com.myframework.entity;

import java.io.Serializable;

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

@Entity
@Table(name = "USER_ZY")
public class User implements Serializable{
	
	private static final long serialVersionUID = 1L;
	
	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	private String id;
	@Column
	private String userName;
	@Column
	private String password;
	@Column
	private int valid;
	
	public User() {
		
	}
	
	public User(String id, String userName, String password, int valid) {
		super();
		this.id = id;
		this.userName = userName;
		this.password = password;
		this.valid = valid;
	}
	
	public String getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
	public String getUserName() {
		return userName;
	}
	public void setUserName(String userName) {
		this.userName = userName;
	}
	public String getPassword() {
		return password;
	}
	public void setPassword(String password) {
		this.password = password;
	}
	public int getValid() {
		return valid;
	}
	public void setValid(int valid) {
		this.valid = valid;
	}
	
	@Override
	public String toString() {
		return "User [id=" + id + ", userName=" + userName + ", password=" + password + ", valid=" + valid + "]";
	}
	
}

這個對象將與數據庫中的某一張表對應，對於數據庫的增刪改查，可以抽象到對象這個層次。

第三步，建立對象映射文件(User.hbm.xml)

<?xml version="1.0" encoding="UTF-8"?>
<hibernate-mapping>
    <!-- 實體類，對應的數據表 -->  
    <class name="com.myframework.entity.User" table="user_zy">
        <!-- 自增長 -->  
        <id column="id" name="id"></id>  
        <property column="userName" name="userName"></property>  
        <property column="password" name="password"></property>  
        <property column="valid" name="valid"></property>
    </class>  
</hibernate-mapping>

第四步，建立Hibernate配置文件hibernate.cfg.xml(包含數據庫連接信息等)

<?xml version="1.0" encoding="UTF-8"?>
<hibernate-configuration>  
    <session-factory>
        <!-- 分別爲：數據庫驅動類型，數據庫鏈接URL，數據庫賬號，數據庫密碼 -->  
        <property name="hibernate.connection.driver_class">oracle.jdbc.driver.OracleDriver</property>  
        <property name="hibernate.connection.url">jdbc:oracle:thin:@localhost:1521:orcl</property>  
        <property name="hibernate.connection.username">userName</property>  
        <property name="hibernate.connection.password">password</property>  
         
        <!-- 分別爲：是否顯示SQL，是否格式輸出SQL，自動創建|更新|驗證數據庫表結構 ，數據庫方言-->  
        <property name="hibernate.show_sql">true</property>  
        <property name="hibernate.format_sql">true</property>  
        <!-- <property name="hibernate.hbm2ddl.auto">update</property>   -->
        <property name="hibernate.dialect">org.hibernate.dialect.Oracle10gDialect</property> 
         
        <!-- 匹配的POJO映射文件 --> 
        <mapping resource="com/myframework/entity/User.hbm.xml"></mapping>
        
    </session-factory>  
</hibernate-configuration>

第五步，新增數據，測試

package com.myframework.textclass;

import java.util.UUID;

import org.junit.Before;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.myframework.entity.User;
import java.util.List;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.query.Query;

public class TestAddUser {
	
	Transaction tx = null;
	Session session = null;
	
	@Before
	public void before() {
	//讀取hibernate.cfg.xml配置，並初始化配置
        Configuration cfg = new Configuration();  
        cfg.configure();  
        
        //根據配置獲取sessionFactory,然後開啓事務
        SessionFactory sessionFactory = cfg.buildSessionFactory();  
        session = sessionFactory.openSession();  
        tx = session.beginTransaction(); 
	}

	@Test
	public void testAddUser() {
	//初始化一個POJO對象
        User user = new User();
        user.setUserName("馬漢");
        user.setPassword("12345678910987654321");
        user.setId(UUID.randomUUID().toString());
        user.setValid(1);
        
        //使用HQL語句查詢
        Query query = session.createQuery("from User");
        List<User> userList = query.getResultList();
        System.out.println(userList.size());
        
        //存入user對象至user表中
        session.save(user);
        
        //提交事務，關閉會話
        tx.commit();  
        session.close();  
	}
}

現在我們來查看一下後臺數據庫：

至此，我們的hibernate框架也搭建完畢，下面我們來用Spring整合SpringMVC，Hibernate。這個過程可能較以上兩個過程而言要麻煩一些，但是不必擔心，慢慢來。

Spring 整合SpringMVC和Hibernate：

在開始這個步驟之前，我們需要了解一些東西：

1.SpringMVC是Spring框架的一部分，所以它能很好的和Spring配合使用。

2.下面我們將使用全註解方式來完成整合，所以你必須對Spring的註解有一個詳細的瞭解。

3.對IOC(控制反轉)，DI(依賴注入)要有一定了解。

4.熟悉MVC分層架構(對於Controller,Service,DAO有一定了解)。

5.Spring管理hibernate，其實管理的就是Hibernate的sessionFactory。

下面我們來一一剖析

第一步，配置web.xml文件

增加一個spring-hibernate.xml配置文件。

<param-value>classpath:conf/spring-*.xml</param-value>

前面我們的這種寫法會自動讀取到以spring-開頭的並且以.xml結尾的所有配置文件。

在上面的配置中我們看到，指定了一個spring全局配置文件spring-hibernate.xml(這個名字你任意取，這是在指定情況下)。默認情況applicationContext.xml。

第二步，配置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:context="http://www.springframework.org/schema/context" 
	xmlns:jdbc="http://www.springframework.org/schema/jdbc"  
	xmlns:jee="http://www.springframework.org/schema/jee" 
	xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:aop="http://www.springframework.org/schema/aop" 
	xmlns:mvc="http://www.springframework.org/schema/mvc"
	xmlns:util="http://www.springframework.org/schema/util"
	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.3.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd
		http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-4.3.xsd
		http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-4.3.xsd
		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.3.xsd
		http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa-4.3.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd
		http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.3.xsd
		http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.3.xsd">
	
	<!-- dbcp連接池配置，引入jar包：commons-dbcp2.jar -->
	<bean id = "dataSource" class = "org.apache.commons.dbcp2.BasicDataSource">
		<property name = "driverClassName" value = "oracle.jdbc.driver.OracleDriver"/>
		<property name = "url" value = "jdbc:oracle:thin:@localhost:1521:orcl"/>
		<property name = "username" value = "username"/>
		<property name = "password" value = "password"/>
		<!-- <property name = "maxActive" value = "150"/> -->
	</bean>
	
	<!-- 使用spring來配置sessionFactory。
	還可以使用spring加載hibernate.cfg.xml配置文件的方式來配置sessionFactory -->
	<bean id = "sessionFactory" class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
		<property name = "dataSource" ref = "dataSource"></property>
		<!-- mappingResources屬性用來列出全部映射文件 -->
		<property name="mappingResources">
			<list>
				<!-- 以下用來列出所有的PO映射文件 -->
				<value>com/myframework/entity/User.hbm.xml</value>
			</list>
		</property>
		
		<property name = "hibernateProperties">
			<props>
				<!-- 數據庫方言 -->
				<prop key="hibernate.dialect">org.hibernate.dialect.Oracle10gDialect</prop>
				<prop key="hibernate.show_sql">true</prop>
				<prop key="hibernate.format_sql">true</prop>
			</props>
		</property>
	</bean>
</beans>

這個文件的配置很重要，對於各個配置點的具體信息，詳細情況，請查閱更多資料。

第三步，建立MVC結構

總結：

至此Spring4+SpringMVC4+Hibernate5框架就搭建完畢了，細心的朋友到這裏應該並沒有鬆一口氣，因爲MVC結構雖然建立好了，但並沒有提供詳細代碼，在其中會使用到Spring種種註解以及DI（依賴注入）。

雖然這些也是至關重要的，但要初步瞭解並進行使用也是非常簡單的，所以就留給大家一些自己發揮的空間。

在搭建的過程中，遇到的問題大大小小數十個，請靜下心來一個一個的解決它們，否則它就像一堵牆一樣將會永遠阻礙着你前行。

javaweb學習總結（二）Spring4+SpringMVC4+Hibernate5框架搭建

前言：

整體思路：

搭建SpringMVC框架：

搭建Hibernate框架：

Spring 整合SpringMVC和Hibernate：

通過jar中的pom查看衝突的jar包

Hibernate中數據庫方言（dialect）

javaweb學習總結（二）Spring4+SpringMVC4+Hibernate5框架搭建

javaweb學習總結（一）文件上傳和下載(轉載)

spring mvc 註解配置StringHttpMessageConverter不生效

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結