springmvc資料庫配置

㈠ Spring MVC 配置文件講解

使用@Controller定義一個控制器
使用@RequestMapping映射請求
使用@RequestParam綁定請求參數到方法參數
使用@ModelAttribute提供一個從模型到數據的鏈接
使用@SessionAttributes指定存儲在會話中的屬性

<context:annotation-config/>
他的作用是隱式地向 Spring 容器注冊
、
、
、

這 4 個BeanPostProcessor。
例如：
如果想使用@ Resource 、@ PostConstruct、@ PreDestroy等註解就必須聲明。
如果想使用@PersistenceContext註解，就必須聲明的Bean。
如果你想使用@Autowired註解，那麼就必須事先在 Spring 容器中聲明 Bean。傳統聲明方式如下：
<bean class="org.springframework.beans.factory.annotation. "/>
如果想使用 @Required的註解，就必須聲明的Bean。同樣，傳統的聲明方式如下：
<bean class="org.springframework.beans.factory.annotation."/>
記得，使用註解一般都會配置掃描包路徑選項
<context:component-scan base-package=」XX.XX」/>

<servlet>
<servlet-name>dispatcherServlet</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/dispatcherServlet-servlet.xml</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>dispatcherServlet</servlet-name>
<url-pattern>*.do</url-pattern>
</servlet-mapping>
這個配置常常見於web.xml文件中
<load-on-startup>1</load-on-startup>是啟動順序，讓這個Servlet隨Servletp容器一起啟動。
<url-pattern>*.do</url-pattern> 會攔截*.do結尾的請求。

<servlet-name>dispatcherServlet</servlet-name>這個Servlet的名字是dispatcherServlet，可以有多個DispatcherServlet，是通過名字來區分的。每一個DispatcherServlet有自己的WebApplicationContext上下文對象。同時保存的ServletContext中和Request對象中，關於key，以後說明。

在DispatcherServlet的初始化過程中，框架會在web應用的 WEB-INF文件夾下尋找名為[dispatcherServlet]-servlet.xml 的配置文件，生成文件中定義的bean。

<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/dispatcherServlet-servlet.xml</param-value>
</init-param>

指明了配置文件的文件名，不使用默認配置文件名，而使用springMVC.xml配置文件。
其中<param-value>**.xml</param-value> 這里可以使用多種寫法
1、不寫,使用默認值:/WEB-INF/<servlet-name>-servlet.xml
2、<param-value>/WEB-INF/classes/springMVC.xml</param-value>
3、<param-value>classpath*:springMVC-mvc.xml</param-value>
4、多個值用逗號分隔

springMVC-mvc.xml 配置文件片段講解

<context:annotation-config/>
<!-- 自動掃描的包名 -->
<context:component-scan base-package="com.iflysse"/>
<!-- 默認的註解映射的支持 -->
<mvc:annotation-driven/>

<!-- 視圖解釋類 -->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix" value="/WEB-INF/jsp/"/>
<property name="suffix" value=".jsp"/><!--可為空,方便實現自已的依據擴展名來選擇視圖解釋類的邏輯 -->
<property name="viewClass" value="org.springframework.web.servlet.view.JstlView" />
</bean>

<mvc:annotation-driven /> 是一種簡寫形式，完全可以手動配置替代這種簡寫形式，簡寫形式可以讓初學都快速應用默認配置方案。<mvc:annotation-driven /> 會自動注冊與 兩個bean,是spring MVC為@Controllers分發請求所必須的。
並提供了：數據綁定支持，@NumberFormatannotation支持，@DateTimeFormat支持，@Valid支持，讀寫XML的支持（JAXB），讀寫JSON的支持（Jackson）。
後面，我們處理響應ajax請求時，就使用到了對json的支持。
後面，對action寫JUnit單元測試時，要從spring IOC容器中取與 兩個bean，來完成測試，取的時候要知道是<mvc:annotation-driven />這一句注冊的這兩個bean。

<!-- json 支持 -->
<bean id=""
class="org.springframework.http.converter.json.">
<property name="objectMapper" ref="commonObjectMapper"/>
<property name="supportedMediaTypes">
<list>
<value>text/html;charset=UTF-8</value>
</list>
</property>
</bean>

<!-- ObjectMapper json轉換 -->
<bean id="commonObjectMapper" class="cn.com.starit.util.CommonObjectMapper"/>

㈡ springMVC的配置問題 求大神來幫幫忙，謝謝啦！

Spring配置

人們經常會在一台以上的主機上配置一種Web應用程序。例如，在生產中，一個網站可能只有一個實例。除了此實例外，開發人員可以在用於開發的機器上配置其他的（開發）實例。也可以在公司（機構）內部的本地開發伺服器上維護其他應用程序裝置，這將讓您受益匪淺。該實例的目的是使Web設計者可以獲得有質量保證的材料，並為需要為應用程序提供文件資料的人提供准入。

大家都知道，即使是最簡單的場景，也需要安裝、配置和維護三個實例。而對於位於不同地理位置的團隊來說，要從事這樣的項目便更加困難。對於任何不是特別簡單的Web應用程序項目，都需要多名開發人員來安裝項目裝置和本地設置以及運行單元測試的裝置等。

很多組織都將自己開發的產品作為Web應用程序。我們可以在很多產品中發現這種情況，例如電子商務系統、內容管理系統（CMS），以及博客發布平台等。這類產品可在多個伺服器中進行部署。對於成功的多用途Web應用程序來說，他們的開發人員必須要保證他們的應用程序便於安裝，並且能夠與其他Web應用程序完美集成。經過上述討論之後，我們應該明了，作為本文主題的應用程序配置是通用Web應用程序項目開發人員所需要解決的重要問題之一。

諸如CVS或Subversion之類的版本控制系統是開發組織使用的一種標准工具。這種工具代表了一些組織的中心源代碼版本庫，它們被用於保持源代碼的有序。用戶可以跟蹤應用程序源代碼的變化，顯示不同版本的區別，並可以確定項目分支。而且，它們使得在應用程序部署中進行部分更新成為可能。

很明顯，版本控制系統軟體是跟蹤源代碼所必需的，它對於解決應用程序配置問題有非常大的幫助。在本文中，我們將不會把重點放在版本控制系統上，因為這方面已經有很多相關的材料了。在此，我們將關注版本控制問題中的一個小話題：如何使Web應用程序的配置更加便捷（尤其是使用Spring
MVC框架編寫的Web應用程序）。

問題是：我們在此討論的是一種什麼樣的配置？任何Web應用程序都需要一些資源，這些資源通常都是其所運行的伺服器所特有的，例如資料庫URL、發送電子郵件的SMTP伺服器，以及包含專用軟體文件的文件夾等。這樣的設置應該集中，從而使應用程序配置更加簡單。

但是，這只是這個問題最簡單的一種版本。有時候，在應用程序開發中需要更加復雜的配置。這意味著，必須將各次部署中的不同Bean連接起來，而這會使問題更加復雜。

這些應用程序配置問題的解決方案有諸多優勢，包括：簡化應用程序的安裝和配置過程，使源代碼版本控制更加簡便，減少源代碼版本庫中的沖突現象。下面，我們將通過示例詳細討論這個話題。
問題。

我們首先來演示一下上文所提到的最簡單的版本。在這一場景中，我們希望在應用程序部署中改變的是簡單的配置參數，例如鏈接、密碼等。如果您曾經使用Spring
MVC框架開發過Web應用程序，那麼您應該知道這里將用到的兩個配置文件：

/WEB-INF/applicationContext.xml，它讓您可以配置Bean，或者顯示應用程序上下文。通過這個文件，您可以定義自己的業務邏輯Bean、資源以及其他可以與Web埠相關聯的所有Bean。

/WEB-INF/[servlet-name]-servlet.xml，它被用於配置Web層、視圖解析器、控制器、校驗器以及其他所有MVC框架中必需的Bean。[servlet-name]指的是在web.xml部署描述符中定義的Spring
dispatcher servlet的名稱。

那麼問題在哪兒呢？問題就出在applicationContext.xml中將包括一些特定於主機的Bean。本文將定義。其中，最明顯的一個示例就是包含了JDBC連接信息的bean，但是任何一種稍微復雜些的應用程序都有十幾個類似的Bean。看一下下面的示例：

＜bean

class="org.springframework.jdbc.datasource.DriverManagerDataSource"＞
＜property ＞
＜value＞org.postgresql.Driver＜/value＞
＜/property＞
＜property ＞
＜/property＞
＜property ＞
＜value＞postgres＜/value＞
＜/property＞
＜property ＞
＜value＞＜/value＞
＜/property＞

＜/bean＞
這個解決方案的問題在於對applicationContext.xml文件的維護。對於初學者來說，設想一下，項目放在源代碼版本控制系統中，例如CVS。下面，假設您希望在網站中添加新的功能，那麼就需要在應用程序上下文定義中添加額外的Bean定義。問題是如何在生產伺服器上體現這些改變。

通常情況下，應用程序的本地實例不會與活動站點使用同樣的資料庫，因此applicationContext.xml文件將包括讓您能夠訪問本地資料庫的設置。當您想提交在源代碼版本庫中的改變時，就需要注意這些特定於主機屬性的同步性。版本庫中的文件最終可能使用本地設置中的配置。如果想在生產伺服器上更新配置，就必須手動同步這些屬性的值。這是非常枯燥的任務，而且還非常容易出錯。

對於應用程序的每個實例來說，這個問題更加重要。假如有三位開發人員正在使用代碼段基址，而且他們使用的是本地的資料庫。當您提交更改的時候，他們每個人在本地伺服器上更新源代碼的時候都必須非常謹慎。他們會手動同步這些更改，然後提交他們的工作。這樣一來，版本控制系統對於這些配置文件來說已經毫無用處。如果曾經使用過Spring
MVC，那麼您應該知道applicationContext.xml是應用程序中的關鍵組件，因為是它將所有的東西粘合在一起。所以，我們需要一種機制來幫助使應用程序中各項保持有序，這點非常重要。

正如前面所提到的，這是您可能遇到的較簡單的配置問題。更難的問題出現在當需要在不同伺服器中進行不同的Bean連接的時候。這類問題常會出現在日常軟體開發任務中。例如，假如您的產品有一個客戶身份驗證模塊，可以對來自關系資料庫或LDAP伺服器中的用戶進行身份驗證。自然，這一身份驗證模塊可以使用抽象了特定版本庫的Bean進行配置。如果您想改變不同應用程序部署中驗證用戶的方式，就需要在applicationContext.xml文件中進行不同的Bean連接。這種配置問題常見於在部署中有可配置特性的所有應用程序。

在下文中，我們將討論這兩種配置問題。首先我們會關注同步的Bean屬性問題及其解決方案，接下來，我們會討論更加復雜的同步Bean連接問題。

解決方案

同步Bean屬性

這個問題的一種可行的解決方案是將所有特定於主機的參數都放到普通的java屬性文件中，使用Spring的PropertyPlaceHolderConfigurer類，將這些參數寫入Bean屬性中。

使用這一解決方案，我們可以生成如下的屬性文件（/WEB-INF/jdbc.properties）：

jdbc.driver=org.postgresql.Driver

jdbc.url=jdbc:postgresql://localhost/test
jdbc.user=postgres

jdbc.password=

我們的Bean配置如下：

＜bean

class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"＞

＜property ＞
＜value＞/WEB-INF/jdbc.properties＜/value＞
＜/property＞
＜/bean＞

＜bean

class="org.springframework.jdbc.datasource.DriverManagerDataSource"＞
＜property ＞
＜value＞${jdbc.driver}＜/value＞
＜/property＞
＜property ＞
＜value＞${jdbc.url}＜/value＞
＜/property＞
＜property ＞
＜value＞${jdbc.user}＜/value＞
＜/property＞
＜property ＞
＜value＞${jdbc.password}＜/value＞
＜/property＞

＜/bean＞
如上所述，我們定義了一個PropertyPlaceholderConfigurer類的實例，並將其位置屬性設置為我們的屬性文件。該類被實現為Bean工廠的後處理器，並將使用定義在文件中的屬性來代替所有的佔位符（${...}value）。

利用這種技術，我們可以從applicationContext.xml中移除所有特定於主機的配置屬性。通過這種方式，我們可以自由地為該文件添加新的Bean，而不必擔心特定於主機屬性的同步性。這樣可以簡化生產部署和維護。

同步性連接

上面的技術解決了第一個問題，可是如果您計劃修改不同應用程序部署之間的Bean連接，這一技術便不很適合。針對這一問題的一個解決方案便是額外創建一個名為applicationContext-[hostname].xml
的XML定義文件。其中[hostname]是部署應用程序的主機的名稱。例如，在本地的機器上，這個文件通常名為applicationContext-localhost.xml，而在部署時，它可能更名為applicationContext-somehost.com.xml。

可以猜測，這一文件必須包括特定於某一主機的所有配置Bean。在本文中，我們將假設dataSource
bean定義將位於這類文件中，而不是通用的applicationContext.xml定義。當然，這種機制與前者並非沖突，但是為了更加簡單明了，我們將只關注這種方法。

既然我們已經有了特定的配置，下面我們就來討論一下如何將其整合到整個Spring
MVC配置概念中。要達到這一目的，可以有許多方法，我們將詳細地一一說明。但首先，我們應該注意到，由於有些Bean可能位於獨立的配置文件中，因此在applicationContext.xml中，所有對它們的局部引用都必須更換成全局名稱。

例如，如下引用：

＜property
＞
＜ref local="someBean"/＞
＜/property＞應更改為：

＜property ＞
＜ref bean="someBean"/＞

＜/property＞在這之後，我們有很多可以添加額外的資源以用於配置的方式。其中最明顯的就是使用＜import＞標簽將這一額外資源包含在applicationContext.xml配置文件中。使用時，要將該標簽放在applicationContext.xml文件開頭。例如：

＜import
resource="applicationContext-somehost.com.xml"/＞
現在，在獨立的XML定義文件和普通的應用程序上下文定義文件中的所有通用Bean定義都有了特定於主機的連接。由於大多數的Bean都不是特定於主機的，因此我們可以像處理Web應用程序中的其他資源一樣自由地處理applicationContext.xml文件，並可以通過合適的版本控制系統與其進行同步。

但是，上述方法也有一定的弊端。如果您想保留不同XML文件的不同配置，就仍然必須擔心applicationContext.xml的同步性，因為資源的名稱必須根據不同伺服器進行更改。雖然與原有的解決方案相比有了很大提高，只需更改文件名，但是這還是需要開發人員的手動協助。

由於與applicationContext.xml相比，主機配置不需如此頻繁地進行更改，因此下一步便是將主機配置移動到web.xml文件中（如果可能的話）。幸運的是，我們有一個可用的解決方案。看一下下面關於web.xml配置的片斷：

＜listener＞

＜listener-class＞
org.springframework.web.context.ContextLoaderListener
＜/listener-class＞

＜/listener＞
＜context-param＞
＜param-name＞contextConfigLocation＜/param-name＞
＜param-value＞
/WEB-INF/applicationContext.xml
/WEB-INF/applicationContext-somehost.com.xml
＜/param-value＞

＜/context-param＞正如您所看到的，除了web.xml文件中常有的ContextLoaderListener之外，我們還添加了contextConfigLocation上下文參數配置。這一參數用於指示框架查找這些配置文件的位置。如果這一參數被省略，則Spring就只能到applicationContext.xml中查找。這里我們也定義了特定於主機的配置文件來使用。

利用這種方法，我們將所有特定於主機的配置從applicationContext.xml文件中移除，這樣便減輕了其在不同應用程序部署中的同步性。

如果這種方法成為您的新習慣，您還可以使其更加靈活。通過遵守下列指令，也可以將特定於主機的配置從web.xml文件中移除。

為此，需要創建特定於我們的應用程序上下文的類：

package
net.nighttale.spring.util;

import java.net.InetAddress;

import
org.springframework.web.context.support.XmlWebApplicationContext;

public
class
extends XmlWebApplicationContext {

protected String[] getDefaultConfigLocations() {
String hostname = "localhost";
try {
hostname =
InetAddress.getLocalHost().getHostName();
} catch (Exception e) {

}

String perHostConfiguration =
DEFAULT_CONFIG_LOCATION_PREFIX
+ "applicationContext-"

+ hostname
+ DEFAULT_CONFIG_LOCATION_SUFFIX
logger.debug(
"Adding per host configuration file: "
+ perHostConfiguration
);

if
(getNamespace() != null) {
return new String[] {
DEFAULT_CONFIG_LOCATION_PREFIX
+ getNamespace()
+
DEFAULT_CONFIG_LOCATION_SUFFIX
, perHostConfiguration};
}
else {
return new String[] {
DEFAULT_CONFIG_LOCATION
, perHostConfiguration};
}
}
}

這個類拓展了Spring中常被作為默認值使用的XmlWebApplicationContext。XmlWebApplicationContext類將Web應用程序的配置從XML定義文件中復制過來。默認情況下，它可以配置來自applicationContext.xml和[servlet-name]-servlet.xml文件中的應用程序。這個類執行的惟一一項額外任務便是獲取它所在的主機名稱，並將applicationContext-[hostname].xml文件添加到配置文件列表中。

為了使用這個類，我們需要對其進行編譯，將其包含在類途徑中，並指示Spring框架使用它。前兩步非常簡單，我們就不在此贅述。我們可以指示Sping通過contextClass上下文參數來使用它。除了web.xml文件中的原有配置，我們還可以添加下列內容：

＜context-param＞

＜param-name＞contextClass＜/param-name＞
＜param-value＞
net.nighttale.spring.util.
＜/param-value＞

＜/context-param＞
如果我們使用這一配置片斷，將會有三個文件被用於初始化這個框架：[servlet-name]-servlet.xml、applicationContext-[hostname].xml以及applicationContext.xml。

正如您所看到的，applicationContext.xml和web.xml文件已經完全擺脫了任何特定的配置細節，而且您也不必擔心會在更新應用程序時破壞配置。

但是，這種方法有一個不足之處。因為，不論是否會使用，都需要在應用程序部署中有第三個配置文件。在這種情況下，便不需要特定於主機的配置。例如：

＜?xml
version="1.0" encoding="UTF-8"?＞
＜!DOCTYPE beans PUBLIC "-//SPRING//DTD
BEAN//EN"
"http://www.springframework.org/dtd/spring-beans.dtd"＞

＜beans＞＜/beans＞
最後，需要知道應用程序上下文類需要查找的特定主機名。檢查主機名稱的最簡單的方法是在機器上運行下列代碼：

System.out.println(InetAddress.getLocalHost().getHostName())
可以將其作為Java代碼執行，也可在喜歡使用的腳本語言（如BeanShell或Groovy）中作為一個具有Java風格語法的腳本執行。在獲取了主機的名稱之後，應該創建一個默認的/WEB-INF/applicationContext-[hostname].xml空文件夾（如我們上面所定義的），然後便可以開始了。

㈢ springmvc中的怎麼配置多個

場景描述：有多個資料庫，每個資料庫可能分布在不同的mysql instance上面，有多個存儲過程，每個存儲過程可能分布在不同的資料庫中，需要有兩個配置文件。

1. mysql 資料庫映射：
A.driverClassName=com.mysql.jdbc.Driver
A.url=jdbc:mysql://172.20.7.51:3308/blog
A.username=trappuser
A.password=Opera1!

B.driverClassName=com.mysql.jdbc.Driver
B.url=jdbc:mysql://localhost:3306/wedding
B.username=root
B.password=opera
上面定義的A、B為兩個mysql instance的縮寫。
2. 存儲過程與mysql instance的映射關系：
SP_Get_User=A
GetStocks=B

定義兩個模擬存儲過程，第一個資料庫「SP_Get_User「是在資料庫A下面，第二個資料庫」GetStocks「是在資料庫B下面。
3. 建立自定義的sessionFactory
3.1 xml配置的datasource及sessionFactory如下：
<bean class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close" id="dataSource">
<property name="driverClassName" value="${database.driverClassName}"/>
<property name="url" value="${database.url}"/>
<property name="username" value="${database.username}"/>
<property name="password" value="${database.password}"/>
</bean>

<bean id="sessionFactory" class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
<property name="dataSource" ref="dataSource"/>
<property name="packagesToScan" value="com.xx.assetcommander">
</property>

<property name="hibernateProperties">
<props>
<prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
<prop key="hibernate.show_sql">true</prop>
</props>

</property>
</bean>
此處我們定義的sessionFactory的類型為LocalSessionFactoryBean，它是一個工廠對象，與我們再需要的 SessionFactory不是一回事，我們需要的sessionfactory是org.hibernate.SessionFactory，這個對象可以被第一個sessionFactory的getObject()方法生成。

3.2 由於我們連接的是多個mysql instance， 不方便在xml中配置多個datasource和多個sessionFactory，故可以通過純java的形式開發，可以使用map來存儲存儲過程與mysql database的關系，將存儲過程的名字和資料庫建議關系，這樣通過存儲過程的名稱就能得到資料庫的縮寫名，通過資料庫的縮寫名能夠找到對應的mysql instance，使用純java開發的過程類似於xml配置，如下：
ds.setDriverClassName(getDriver());
ds.setUrl(getUrl());
ds.setUsername(getUsername());
ds.setPassword(getPassword());
LocalSessionFactoryBean sessionFactory = new LocalSessionFactoryBean();
sessionFactory.setDataSource(ds);
sessionFactory.setPackagesToScan("com.xx.assetcommander");
Properties params = new Properties();
params.setProperty("hibernate.dialect",
"org.hibernate.dialect.MySQLDialect");
params.setProperty("hibernate.show_sql", "true");
sessionFactory.setHibernateProperties(params);

當我們獲得可以使用的LocalSessionFactoryBean時候，在調用getObject()獲得SessionFactory之前，必須要調用afterPropertiesSet()方法，否則得到的sessionFactory為空。
public Session getDsBySp(String spName) throws IOException {
//get the corresponding mysql database shortname by sp name
String dbName = getDbForSP(str);
//get the corresponding mysql instance connection by mysql database shortname
LocalSessionFactoryBean fB = getDsByDb(dbName);
// don't forget this line or null will be returned when you call getObject() method.
fB.afterPropertiesSet();
return fB.getObject().openSession();
}

註：在tomcat啟動時，如果沒有配置任何datasource，會出現如下錯誤：
org.springframework.beans.factory.NoSuchBeanDefinitionException: No qualifying bean of type [javax.persistence.EntityManagerFactory] is defined
故需要配置默認的datasource.
這種方式需要做到不同的資料庫instance直接業務的完全獨立，不可以出現跨資料庫的表join，否則處理難度會增加。
還有就是對於多資料庫直接的事務管理如何去處理？

㈣ spring mvc需要配置嗎

需要配置的
一、Spring MVC環境搭建：（Spring 2.5.6 + Hibernate 3.2.0）
1. jar包引入
Spring 2.5.6：spring.jar、spring-webmvc.jar、commons-logging.jar、cglib-nodep-2.1_3.jar
Hibernate 3.6.8：hibernate3.jar、hibernate-jpa-2.0-api-1.0.1.Final.jar、antlr-2.7.6.jar、commons-collections-3.1、dom4j-1.6.1.jar、javassist-3.12.0.GA.jar、jta-1.1.jar、slf4j-api-1.6.1.jar、slf4j-nop-1.6.4.jar、相應資料庫的驅動jar包

SpringMVC是一個基於DispatcherServlet的MVC框架，每一個請求最先訪問的都是DispatcherServlet，DispatcherServlet負責轉發每一個Request請求給相應的Handler，Handler處理以後再返回相應的視圖(View)和模型(Model)，返回的視圖和模型都可以不指定，即可以只返回Model或只返回View或都不返回。
DispatcherServlet是繼承自HttpServlet的，既然SpringMVC是基於DispatcherServlet的，那麼我們先來配置一下DispatcherServlet，好讓它能夠管理我們希望它管理的內容。HttpServlet是在web.xml文件中聲明的。

<!-- Spring MVC配置 -->
<!-- ====================================== -->
<servlet>
<servlet-name>spring</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<!-- 可以自定義servlet.xml配置文件的位置和名稱，默認為WEB-INF目錄下，名稱為[<servlet-name>]-servlet.xml，如spring-servlet.xml
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/spring-servlet.xml</param-value> 默認
</init-param>
-->
<load-on-startup>1</load-on-startup>
</servlet>

<servlet-mapping>
<servlet-name>spring</servlet-name>
<url-pattern>*.do</url-pattern>
</servlet-mapping>

<!-- Spring配置 -->
<!-- ====================================== -->
<listener>
<listenerclass>
org.springframework.web.context.ContextLoaderListener
</listener-class>
</listener>

<!-- 指定Spring Bean的配置文件所在目錄。默認配置在WEB-INF目錄下 -->
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:config/applicationContext.xml</param-value>
</context-param>

spring-servlet.xml配置
spring-servlet這個名字是因為上面web.xml中<servlet-name>標簽配的值為spring（<servlet-name>spring</servlet-name>），再加上「-servlet」後綴而形成的spring-servlet.xml文件名，如果改為springMVC，對應的文件名則為springMVC-servlet.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"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
http://www.springframework.org/schema/context <a href="http://www.springframework.org/schema/context/spring-context-3.0.xsd">http://www.springframework.org/schema/context/spring-context-3.0.xsd</a>">

<!-- 啟用spring mvc 註解 -->
<context:annotation-config />

<!-- 設置使用註解的類所在的jar包 -->
<context:component-scan base-package="controller"></context:component-scan>

<!-- 完成請求和註解POJO的映射 -->
<bean class="org.springframework.web.servlet.mvc.annotation." />

<!-- 對轉向頁面的路徑解析。prefix：前綴， suffix：後綴 -->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" p:prefix="/jsp/" p:suffix=".jsp" />
</beans>

DispatcherServlet會利用一些特殊的bean來處理Request請求和生成相應的視圖返回。
關於視圖的返回，Controller只負責傳回來一個值，然後到底返回的是什麼視圖，是由視圖解析器控制的，在jsp中常用的視圖解析器是InternalResourceViewResovler，它會要求一個前綴和一個後綴
在上述視圖解析器中，如果Controller返回的是blog/index，那麼通過視圖解析器解析之後的視圖就是/jsp/blog/index.jsp。

主要是說說Controller.
一個類使用了@Controller進行標記的都是Controller

package controller;

import javax.servlet.http.HttpServletRequest;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;

import entity.User;

@Controller //類似Struts的Action
public class TestController {

@RequestMapping("test/login.do") // 請求url地址映射，類似Struts的action-mapping
public String testLogin(@RequestParam(value="username")String username, String password, HttpServletRequest request) {
// @RequestParam是指請求url地址映射中必須含有的參數(除非屬性required=false)
// @RequestParam可簡寫為：@RequestParam("username")

if (!"admin".equals(username) || !"admin".equals(password)) {
return "loginError"; // 跳轉頁面路徑（默認為轉發），該路徑不需要包含spring-servlet配置文件中配置的前綴和後綴
}
return "loginSuccess";
}

@RequestMapping("/test/login2.do")
public ModelAndView testLogin2(String username, String password, int age){
// request和response不必非要出現在方法中，如果用不上的話可以去掉
// 參數的名稱是與頁面控制項的name相匹配，參數類型會自動被轉換

if (!"admin".equals(username) || !"admin".equals(password) || age < 5) {
return new ModelAndView("loginError"); // 手動實例化ModelAndView完成跳轉頁面（轉發），效果等同於上面的方法返回字元串
}
return new ModelAndView(new RedirectView("../index.jsp")); // 採用重定向方式跳轉頁面
// 重定向還有一種簡單寫法
// return new ModelAndView("redirect:../index.jsp");
}

@RequestMapping("/test/login3.do")
public ModelAndView testLogin3(User user) {
// 同樣支持參數為表單對象，類似於Struts的ActionForm，User不需要任何配置，直接寫即可
String username = user.getUsername();
String password = user.getPassword();
int age = user.getAge();

if (!"admin".equals(username) || !"admin".equals(password) || age < 5) {
return new ModelAndView("loginError");
}
return new ModelAndView("loginSuccess");
}

@Resource(name = "loginService") // 獲取applicationContext.xml中bean的id為loginService的，並注入
private LoginService loginService; //等價於spring傳統注入方式寫get和set方法，這樣的好處是簡潔工整，省去了不必要得代碼

@RequestMapping("/test/login4.do")
public String testLogin4(User user) {
if (loginService.login(user) == false) {
return "loginError";
}
return "loginSuccess";
}
}

以上4個方法示例，是一個Controller里含有不同的請求url，也可以採用一個url訪問，通過url參數來區分訪問不同的方法，代碼如下：

package controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

@Controller
@RequestMapping("/test2/login.do") // 指定唯一一個*.do請求關聯到該Controller
public class TestController2 {

@RequestMapping
public String testLogin(String username, String password, int age) {
// 如果不加任何參數，則在請求/test2/login.do時，便默認執行該方法

if (!"admin".equals(username) || !"admin".equals(password) || age < 5) {
return "loginError";
}
return "loginSuccess";
}

@RequestMapping(params = "method=1", method=RequestMethod.POST)
public String testLogin2(String username, String password) {
// 依據params的參數method的值來區分不同的調用方法
// 可以指定頁面請求方式的類型，默認為get請求

if (!"admin".equals(username) || !"admin".equals(password)) {
return "loginError";
}
return "loginSuccess";
}

@RequestMapping(params = "method=2")
public String testLogin3(String username, String password, int age) {
if (!"admin".equals(username) || !"admin".equals(password) || age < 5) {
return "loginError";
}
return "loginSuccess";
}
}

其實RequestMapping在Class上，可看做是父Request請求url，而RequestMapping在方法上的可看做是子Request請求url，父子請求url最終會拼起來與頁面請求url進行匹配，因此RequestMapping也可以這么寫：

package controller;

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

@Controller
@RequestMapping("/test3/*") // 父request請求url
public class TestController3 {

@RequestMapping("login.do") // 子request請求url，拼接後等價於/test3/login.do
public String testLogin(String username, String password, int age) {
if (!"admin".equals(username) || !"admin".equals(password) || age < 5) {
return "loginError";
}
return "loginSuccess";
}
}

在SpringMVC中常用的註解還有@PathVariable，@RequestParam，@PathVariable標記在方法的參數上，利用它標記的參數可以利用請求路徑傳值，看下面一個例子
@RequestMapping(value="/comment/{blogId}", method=RequestMethod.POST)
public void comment(Comment comment,@PathVariable int blogId, HttpSession session, HttpServletResponse response) throws IOException {

}

在該例子中，blogId是被@PathVariable標記為請求路徑變數的，如果請求的是/blog/comment/1.do的時候就表示blogId的值為1. 同樣@RequestParam也是用來給參數傳值的，但是它是從頭request的參數裡面取值，相當於request.getParameter("參數名")方法。
在Controller的方法中，如果需要WEB元素HttpServletRequest，HttpServletResponse和HttpSession，只需要在給方法一個對應的參數，那麼在訪問的時候SpringMVC就會自動給其傳值，但是需要注意的是在傳入Session的時候如果是第一次訪問系統的時候就調用session會報錯，因為這個時候session還沒有生成。

㈤ 有沒有大神給我講一下springmvc操作資料庫

一直用的是ssh，因為公司要用到SpringMVC，以前也沒接觸過，所以今天來和大家一起學習一下這個框架，以便工作需要。

例子大家可以到我上傳的資源處http://download.csdn.net/download/tjcyjd/4251483下載。

首先我們先來了解一下什麼是模式，模式就是解決某一類問題的方法論，把解決這類問題的解決方法歸總到理論的高度，這就是模式。模式是一種指導，在一個良好的指導下，有助於開發人員完成任務。做出一個優秀的設計方案，能達到事半功倍的效果。而且會得到解決問題的最佳辦法。

mvc模式起源於Smalltalk語言，mvc是Model-View-Controller的簡寫。mvc減弱了業務邏輯介面和數據介面之間的耦合。使用MVC模式的好處有很多，可靠性強，高重用和可適應性，較低的生命周期成本，快速的部署，可維護性強等。裡面的細節在這兒就不作過多的講解。

SpringMVC的特點：

1、清晰的角色劃分，Spring在Model、View和Controller方面提供了一個非常清晰的劃分，這3個方面真正是各司其職，各負其責。

2、靈活的配置功能，因為Spring的核心是IOC,同樣在實現MVC上，也可以把各種類當做Bean來通過XML進行配置。

3、提供了大量的控制器介面和實現類，這樣開發人員可以使用Spring提供的控制器實現類，也可以自己實現控制器介面。

4、SpringMVC是真正的View層實現無關的，它不會強制開發員使用JSP,我們可以使用其他View技術，比如Velocity，Xskt等。

5、國際化支持，Spring的ApplicationContext提供了對國際化的支持，在這里可以很方便的使用。

6、面向介面編程，其實這不僅是springMVC的特點，整個Spring來看，這個特點都是很明顯的，因為它使開發人員對程序易於進行測試，並且很方便的進行管理。

7、Spring提供了Web應用開發的一整套流程，而不僅僅是MVC，他們之間可以很方便的結合在一起。下面有一個自己做得例子，做完這個例子後真的體會到了SpringMVC的強大。

下面開始配置我們的Springmvc工程：

首先我們配置WEB-INF目錄下的web.xml:

<?xml version="1.0" encoding="UTF-8"?>

<web-app version="2.5"

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_2_5.xsd">

<servlet>

<!--springmvc的核心是DispatcherServlet，它負責控制整個頁面的請求路徑-->

<servlet-name>dispatcherServlet</servlet-name>

<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

<!--初始化參數>/WEB-INF/classes/相當於src目錄-->

<init-param>

<!-- 這個param-name必須是contextConfigLocation-->

<param-name>contextConfigLocation</param-name>

<param-value>/WEB-INF/classes/applicationContext.xml</param-value>

</init-param>

<load-on-startup>2</load-on-startup>

</servlet>

<!--攔截所有以do結尾的請求-->

<servlet-mapping>

<servlet-name>dispatcherServlet</servlet-name>

<url-pattern>*.do</url-pattern>

</servlet-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>

<welcome-file-list>

<welcome-file>index.jsp</welcome-file>

</welcome-file-list>

</web-app>

每次配置好一個文件後建議先啟動伺服器看看是否產生異常，不然到後期會很難調試和找到異常所在。

WEB.XML配置好以後我們還需要在SRC目錄下創建一個db-config.properties文件來存放我們的數據源配置信息：

內容如下：

db.url= jdbc:mysql:///springmvcdb?useUnicode=true&characterEncoding=utf8

db.username=root

db.password=root

db.dirverClass= com.mysql.jdbc.Driver

db-config.properties配置好以後就開始配置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"

xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans-2.5.xsd">

<!-- 定義個預設的控制適配器 -->

<bean

class="org.springframework.web.servlet.mvc."/>

<!-- 獲取配置文件 -->

<bean id="config"

class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">

<property name="locations">

<list>

<value>classpath:db-config.properties</value>

</list>

</property>

</bean>

<!-- 獲取數據源 -->

<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">

<property name="driverClassName">

<value>${db.dirverClass}</value>

</property>

<property name="url">

<value>${db.url}</value>

</property>

<property name="username">

<value>${db.username}</value>

</property>

<property name="password">

<value>${db.password}</value>

</property>

</bean>

<!--

URL到處理器的映射列表可以配置多個

mappings屬性健值為URL程序文件地址，而值為處理器的Bean名字，URL程序文件地址可採用路徑匹配的模式，如：

com/mvc/t?st.jsp:匹配com/mvc/test.jsp、com/mvc/tast.jsp等 com/mvc /*.jsp

：匹配所有com/mvc/下帶jsp後綴的URL com/mvc

/**/test.jsp：匹配所有在com/mvc路徑下或子孫路徑下的test.jsp com/mvc

/**/*.jsp：匹配所有com/mvc路徑下或子孫路徑下帶.jsp後綴的URL cn/**/web/bla.jsp：匹配

cn/option/web/dog.jsp cn/option/test/web/dog.jsp cn/web/dog.jsp的請求

-->

<bean class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">

<property name="mappings">

<value>

user.do=userAction

</value>

</property>

</bean>

<!--定義視圖通過internalResourceView來表示使用的是Servlet/jsp技術-->

<bean id="viewResolver"

class="org.springframework成都erp系統軟體開發公司http://www.yingtaow.com/erp/?web.servlet.view.InternalResourceViewResolver">

<property name="viewClass">

<value>org.springframework.web.servlet.view.InternalResourceView

</value>

</property>

<!--jsp存放的目錄-->

<property name="prefix">

<value>/jsp/</value>

</property>

<!--jsp文件的後綴-->

<property name="suffix">

<value>.jsp</value>

</property>

</bean>

<bean id="userDao" class="com.yjde.springmvc.UserDao">

<property name="dataSource"ref="dataSource"></property>

</bean>

<!--定義控制器-->

<bean id="userAction" class="com.yjde.springmvc.UserController">

<property name="">

<ref bean="userDao"/>

</property>

<property name="commandClass">

<value>com.yjde.springmvc.UserDao</value>

</property>

<property name="viewpage">

<value>userInfo</value>

</property>

</bean>

</beans>

ApplicationContext.xml文件配置好以後我們開始編寫具體的JAVA類，我們需要一個Dao類，一個controller類和一個PO

我們在MySql中創建了一張USERMBO表，裡面有三個欄位 USERID，USERNAME，USERAGE

UserDao類:

package com.yjde.springmvc;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.util.Collection;

import java.util.List;

import org.springframework.jdbc.core.RowMapper;

import org.springframework.jdbc.core.support.JdbcDaoSupport;

@SuppressWarnings("all")

public class UserDao extends JdbcDaoSupport {

private String msg;

public String getMsg() {

return msg;

}

public void setMsg(String msg) {

this.msg = msg;

}

// 此方法把USEMBO表對應的欄位查詢出來依次放入userPO中

public Collection<UserPO> doquery() {

String sql = "SELECT T.USERID,T.USERNAME,T.USERAGE FROM USERMBO T";

return super.getJdbcTemplate().query(sql, new RowMapper() {

public Object mapRow(ResultSet rs, int num) throws SQLException {

UserPO user = new UserPO();

user.setUserId(rs.getInt("USERID"));

user.setUserName(rs.getString("USERNAME"));

user.setUserAge(rs.getInt("USERAGE"));

return user;

}

});

}

}

JdbcTemplate是core包的核心類。它替我們完成了資源的創建以及釋放工作，從而簡化了我們對JDBC的使用。它還可以幫助我們避免一些常見的錯誤，比如忘記關閉資料庫連接。具體請參閱API

Controller類：

package com.yjde.springmvc;

import java.io.PrintWriter;

import java.util.ArrayList;

import java.util.Collection;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import org.springframework.validation.BindException;

import org.springframework.web.servlet.ModelAndView;

import org.springframework.web.servlet.mvc.SimpleFormController;

@SuppressWarnings("all")

// SimpleFormController是spring提供的表單控制器，把頁面中Form中的元素名稱設定為和bean中的一樣，當傳入的時候Spring會自動抓取form中和Bean名稱一樣的元素值，把它轉換成一個bean,使得開發人員可以很方便的使用。

public class UserController extends SimpleFormController {

private String viewpage;

private UserDao ;

public String getViewpage() {

return viewpage;

}

public void setViewpage(String viewpage) {

this.viewpage = viewpage;

}

@Override

protected ModelAndView onSubmit(HttpServletRequest request,

HttpServletResponse response, Object command, BindException errors)

throws Exception {

UserDao tmp = (UserDao) command;

Collection<UserPO> list = .doquery();

List<UserPO> users = new ArrayList<UserPO>();

UserPO user;

for (UserPO userPO : list) {

user = new UserPO();

user.setUserId(userPO.getUserId());

user.setUserName(userPO.getUserName());

user.setUserAge(userPO.getUserAge());

users.add(user);

}

Map mp = new HashMap();

mp.put("list", users);

return new ModelAndView(getViewpage(), mp);

}

public void setDao(UserDao ) {

this. = ;

}

}

UserPO類:

package com.yjde.springmvc;

public class UserPO {

private Integer userId;

private String userName;

private Integer userAge;

public Integer getUserId() {

return userId;

}

public void setUserId(Integer userId) {

this.userId = userId;

}

public String getUserName() {

return userName;

}

public void setUserName(String userName) {

this.userName = userName;

}

public Integer getUserAge() {

return userAge;

}

public void setUserAge(Integer userAge) {

this.userAge = userAge;

}

}

類創建完成以後我們編寫兩個JSP進行測試：

Index.jsp:

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>

<%

String path = request.getContextPath();

String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";

%>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">

<html>

<head>

<base href="<%=basePath%>">

<title>My JSP 'index.jsp' starting page</title>

<meta http-equiv="pragma" content="no-cache">

<meta http-equiv="cache-control" content="no-cache">

<meta http-equiv="expires" content="0">

<meta http-equiv="keywords" content="keyword1,keyword2,keyword3">

<meta http-equiv="description" content="This is my page">

<!--

<link rel="stylesheet" type="text/css" href="styles.css">

-->

</head>

<body>

<form action="user.do" method="post">

請輸入<input name="msg" type="text" />

<input type="submit" value="提交">

</form>

</body>

</html>

㈥ springmvc使用weblogic發布，怎麼配置

一般來說我們都是在應用程序裡面配置jdbc數據源，因為這樣可以脫離web伺服器的設置，比較容易移植，但是也有情況使我們必須使用web容器配置數據源，例如如果要用的多個資料庫時，在中間件中配置數據源就比較方便。
先講下如何在weblogic中配置數據源，以weblogic9.3.2為例。啟動weblogic，進入console頁面， 在左側Domain Structure面板選擇Services，然後選擇jdbc—-Data Sources，在這里將會顯示現有的所有數據源，點擊頁面左上角的Lock&Edit，然後點New來新建一個數據源，Name跟JNDI Name由用戶命名，一般用相同的，如test，Database Type則是選擇你要連接的資料庫類型，驅動會自己幫你選擇，一般不用做修改。接下來的，用戶都應該很熟悉，無非是ip地址，sid，用戶名密碼等。完成後將在DataSource列表裡看到剛新建的數據源，jndi name就是我們待會再Spring中要用到的。在數據源configuration–connection pool中可以配置連接池的初始大小，以及最大大小，以及每次增長長度。
在Spring中ApplicationContext.xml中配置如下，一個jndiTemplate，裡面可以設置一些屬性，這里就不再介紹， dataSource中主要寫對jndi的name就ok了，這樣這個dataSource就可用了。

㈦ springmvc配置mysql數據源的時候啟動報錯，原先是orcal的資料庫

莫總。/com/mysql/jdbc/integration/jboss/ExtendedMysqlExceptionSorter.class我也是少這個

㈧ spring+springmvc+mybatis是怎麼連接資料庫的

創建資料庫
選擇開始菜單中→程序→【management
sql
server
2008】→【sql
server
management
studio】命令，打開【sql
server
management
studio】窗口，並使用windows或
sql
server身份驗證建立連接。
在【對象資源管理器】窗口中展開伺服器，然後選擇【資料庫】節點
右鍵單擊【資料庫】節點，從彈出來的快捷菜單中選擇【新建資料庫】命令。
執行上述操作後，會彈出【新建資料庫】對話框。在對話框、左側有3個選項，分別是【常規】、【選項】和【文件組】。完成這三個選項中的設置會後，就完成了資料庫的創建工作，
在【資料庫名稱】文本框中輸入要新建資料庫的名稱。例如，這里以「新建的資料庫」。
在【所有者】文本框中輸入新建資料庫的所有者，如sa。根據資料庫的使用情況，選擇啟用或者禁用【使用全文索引】復選框。
在【資料庫文件】列表中包括兩行，一行是資料庫文件，而另一行是日記文件。通過單擊下面的【添加】、【刪除】按鈕添加或刪除資料庫文件。
切換到【選項頁】、在這里可以設置資料庫的排序規則、恢復模式、兼容級別和其他屬性。
切換到【文件組】頁，在這里可以添加或刪除文件組。
完成以上操作後，單擊【確定】按鈕關閉【新建資料庫】對話框。至此「新建的數據」資料庫創建成功。新建的資料庫可以再【對象資源管理器】窗口看到。

㈨ springmvc spring hibernate 怎麼配置連接兩個資料庫

persistent.xml配置
<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="http://java.sun.com/xml/ns/persistence" version="2.0">
<persistence-unit name="userPU" transaction-type="RESOURCE_LOCAL">
<!--jpa的提供者-->
<provider>org.hibernate.ejb.HibernatePersistence</provider>
<properties>
<!--聲明資料庫連接的驅動-->
<property name="hibernate.connection.driver_class" value="com.mysql.jdbc.Driver"/>
<!--jdbc資料庫的連接地址-->
<property name="hibernate.connection.url" value="jdbc:mysql://localhost:3306/manager?characterEncoding=gbk"/>
<property name="hibernate.connection.username" value="root"/>
<property name="hibernate.connection.password" value="123456"/>
<!--配置方言-->
<property name="hibernate.dialect" value="org.hibernate.dialect.MySQL5Dialect"/>
<!--激活查詢日誌功能-->
<property name="hibernate.show_sql" value="true"/>
<!--優雅地輸出Sql-->
<property name="hibernate.format_sql" value="true"/>
<!--添加一條解釋型標注-->
<property name="hibernate.use_sql_comments" value="false"/>
<!--配置如何根據java模型生成資料庫表結構,常用update,validate-->
<property name="hibernate.hbm2ddl.auto" value="update"/>
</properties>
</persistence-unit>
</persistence>
applicationContext.xml配置
<!--第二步-->
<!--定義實體的工廠bean-->
<bean id="entityManagerFactory" class="org.springframework.orm.jpa.">
<property name="persistenceUnitName" value="userPU" />
<property name="persistenceXmlLocation" value="classpath:persistence.xml"></property>
</bean>

<!--第三步-->
<!--定義事務管理器-->
<bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
<property name="entityManagerFactory" ref="entityManagerFactory"/>
</bean>

㈩ spring mvc 怎麼用sql server

spring mvc 是個MVC框架，如果你需要使用資料庫,一般是在spring 的上下文中，配置使用SQL server 和其他的資料庫都差不多，
1.資料庫對應的jar包
2.spring 配置文件中配置。
這里的順序大致為，datasource 配置，jdbc template/mybatis/hibernate等框架的配置