spring 4.x + struts 2.x + mybatis 3.x

寫 web 程式時，使用 spring + struts + mybatis 是很流行的架構，這麼多東西怎麼整合呢? 這裡提供一個參考，先看一下寫好的程式裡面有那些檔案…

這不是什麼標準，只是我個人的習慣，僅供參考，接下來逐步說明。這個程式只有兩個功能，一個是顯示所有股票資料，一個是可以新增股票資料，網頁的程式流程如下:

總共有五個網頁，如下:

  1. index.jsp: 首頁，可選擇要「查詢即時資訊」或「維護股票」。
  2. realtimeInfo.jsp: 顯示股票即時資訊。
  3. manageStock.jsp: 可以新增一支股票的基本資料。
  4. result.jsp: 新增成功
  5. error.jsp: 新增失敗
  • 建立一個 Dynamic Web Project

選擇 eclipse 上方選單的「File > New > Dynamic Web Project」，建立起一個專案，建立好之後在專案名稱上按滑鼠右鍵，選擇「Configure > Convert to Maven Project」，轉換好之後，應該可以在專案目錄下看到一個名為 pom.xml 的檔案。

  • 匯入所需的 jar 檔

打開 pom.xml，並將以下內容貼上，這時候 eclipse 會自動從網路上下載這些 jar 檔及其相依的 jar 檔，這裡包含了 spring、struts、mybatis、mysql jdbc driver ... (這個程式的資料庫使用 mysql)

  <dependencies>
      <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-context</artifactId>
          <version>4.1.0.RELEASE</version>
      </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-web</artifactId>
        <version>4.1.0.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
        <version>4.1.0.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-tx</artifactId>
        <version>4.1.0.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
        <version>4.1.0.RELEASE</version>
    </dependency>

    <dependency>
        <groupId>org.apache.struts</groupId>
        <artifactId>struts2-core</artifactId>
        <version>2.3.16.3</version>
    </dependency>
    <dependency>
        <groupId>org.apache.struts</groupId>
        <artifactId>struts2-spring-plugin</artifactId>
        <version>2.3.16.3</version>
    </dependency>
    <dependency>
        <groupId>org.apache.struts</groupId>
        <artifactId>struts2-junit-plugin</artifactId>
        <version>2.3.16.3</version>
    </dependency>

    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.2.7</version>
    </dependency>
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis-spring</artifactId>
        <version>1.2.2</version>
    </dependency>

    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.33</version>
    </dependency>

    <dependency>
        <groupId>ch.qos.logback</groupId>
        <artifactId>logback-classic</artifactId>
        <version>1.1.2</version>
    </dependency>
  </dependencies>
  • 建立 Source Folder

在 src 上按滑鼠右鍵，可以建立 Source Folder，總共要建立三個 - conf、properties、UnitTest，這是為了方便管理程式碼和設定檔，在任何一個 Source Folder 的檔案，會和在 src 底下一樣，在產生 war 檔時放置到同樣的目錄，都在 WEB-INF/classes 目錄下，放置到不同 Source Folder 完全是為了開發上比較方便。這三個 Source Folder 我們打算這麼使用:

  1. conf: 放置 xml 設定檔，通常這些檔案在正式機、測試機上內容是完全一樣的。
  2. properties: 放置 properties 設定檔，這些檔案的內容會隨著環境而改變。
  3. UnitTest: 單元測試的程式放在這。
  • 設定 web.xml

為了讓 spring 和 struts 和 web 整合，請將以下內容貼進 web.xml 裡。這裡設定了一開始會從 beans-config.xml 載入 spring 的相關設定，並且將 / 目錄下所有網頁及 submit 動作後都交由 struts 來處理。

<?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" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" id="WebApp_ID" version="3.0">
    <display-name>DemoSite</display-name>

    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath*:beans-config.xml</param-value>
    </context-param>

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

    <filter>
        <filter-name>struts2</filter-name>
        <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
    </filter>

    <filter-mapping>
        <filter-name>struts2</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

    <welcome-file-list>
        <welcome-file>index.jsp</welcome-file>
    </welcome-file-list>
  </web-app>
  • 建立 package

在 src 下建立三個 package - idv.steven.demo.dao、idv.steven.demo.dto、idv.steven.demo.action，分別用來放置 DAO、DTO 及 struts 的 action class，什麼是 DAO、DTO ? 不懂的話可以參考 Martin Fowler 的大作「Patterns of Enterprise Application Architecture」(簡稱: PoEAA)。

  • 設定 JDBC 相關設定

所有 JDBC 相關資料放到 datasource.properties，因為一般公司裡為了開發、測試需要，通常至少會有兩個環境，一個是正式環境，就是實際營運的主機，另一個是測試環境，供開發人員及 user 測試時使用，這兩個環境使用的資料庫當然不會一樣，這種隨環境而變動的參數，就放到 properties 檔裡。我使用的資料庫是 mysql，資料庫名稱是 demosite，所以設定如下。

jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://192.168.0.110:3306/demosite
jdbc.username=steven
[email protected]
  • 設定 beans-config.xml

這是 spring 的設定檔，如果程式大的話，設定檔還可以切分成好幾個，因為這個  demo 程式非常小，一個就可以了! 設定檔一開始透過 context:property-placeholder 將 datasource.properties 的內容載入，載入後要引用裡面的值就用 ${ }，如 ${jdbc.driverClassName}。mapperLocations 裡所包含的 StockDao.xml 是 mybatis 要將 sql statement 和 DAO mapping 的設定檔，所以裡面會有相關的 sql statement。而設定檔最後面的 org.mybatis.spring.mapper.MapperScannerConfigurer 是設定，spring 會自動掃描 idv.steven.demo.dao 這個 package 下所有標有 @Repository 的類別，並將其載入。

<?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:c="http://www.springframework.org/schema/c"
    xmlns:cache="http://www.springframework.org/schema/cache"
    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:lang="http://www.springframework.org/schema/lang"
    xmlns:mybatis-spring="http://mybatis.org/schema/mybatis-spring"
    xmlns:p="http://www.springframework.org/schema/p"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:util="http://www.springframework.org/schema/util"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/cache http://www.springframework.org/schema/cache/spring-cache.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-4.1.xsd
        http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee.xsd
        http://www.springframework.org/schema/lang http://www.springframework.org/schema/lang/spring-lang.xsd
        http://mybatis.org/schema/mybatis-spring http://mybatis.org/schema/mybatis-spring.xsd
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd
        http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd">

    <context:property-placeholder location="classpath:datasource.properties" />

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

    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"
        p:dataSource-ref="dataSource"
    />

    <tx:annotation-driven transaction-manager="transactionManager" />

    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
      <property name="dataSource" ref="dataSource" />
      <property name="transactionFactory">
        <bean class="org.apache.ibatis.transaction.managed.ManagedTransactionFactory" />
      </property>
      <property name="mapperLocations">
          <list>
              <value>classpath*:idv/steven/demo/dao/StockDao.xml</value>
          </list>
      </property>
    </bean>

    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer"
        p:sqlSessionFactoryBeanName="sqlSessionFactory"
        p:basePackage="idv.steven.demo.dao"
    />
</beans>
  • 撰寫 DAO

通常一個 table 會有一個 DAO，因為這個程式只有一個名稱 Stock 的 table，所以就在 idv.steven.demo.dao 下建立一個名為 StockDAO 的 interface，如下，只有兩個 method，第一個是將 Stock table 內所有內容傳回來，第二個是新增一筆資料。@Repository 是 spring 提供的 annotation，用以表示這個類別或介面是一個 DAO。

package idv.steven.demo.dao;

import idv.steven.demo.dto.Stock;
import java.util.List;
import org.springframework.stereotype.Repository;

@Repository
public interface StockDAO {
    public List<Stock> findAll();
    public int createStock(Stock stock);
}
  • 撰寫 DTO

上面 DAO 中可以看到一個類別 Stock，這個傳遞的類別就稱為 DTO (Data Transfer Object)，用來傳遞物件和資料庫間的資料，這裡將它定義如下，剛好是 Stock table 的所有欄位。這個類別有 override toString，這並非必要的，只是在除錯時比較方便輸出 DTO 各欄位的資料。

package idv.steven.demo.dto;

public class Stock {
    private String iD;
    private String name;
    private Double fluctuation;
    private Integer amount;
    private Double price;

    public String getID() {
        return iD;
    }
    public void setID(String iD) {
        this.iD = iD;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Double getFluctuation() {
        return fluctuation;
    }
    public void setFluctuation(Double fluctuation) {
        this.fluctuation = fluctuation;
    }
    public Integer getAmount() {
        return amount;
    }
    public void setAmount(Integer amount) {
        this.amount = amount;
    }
    public Double getPrice() {
        return price;
    }
    public void setPrice(Double price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "Stock [iD=" + iD + ", name=" + name + ", fluctuation="
                + fluctuation + ", amount=" + amount + ", price=" + price + "]";
    }
}
  • O/R mapping

這是 mybatis 做 O/R mapping 的設定檔，namespace 必須是 DAO 的全名 (含 package)，這個檔裡可以看到 findAll 和 createStock 剛好對應著 DAO 中的兩個 method。

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">  

<mapper namespace="idv.steven.demo.dao.StockDAO">
     <sql id="fields">iD, name, fluctuation, amount, price</sql>

    <resultMap type="idv.steven.demo.dto.Stock" id="stock">
        <id column="iD" property="iD"/>
        <result column="name" property="name"/>
        <result column="fluctuation" property="fluctuation"/>
        <result column="amount" property="amount"/>
        <result column="price" property="price"/>
    </resultMap>

    <select id="findAll" resultMap="stock">
        select <include refid="fields"/>
        from Stock
    </select>

    <insert id="createStock">
          insert into Stock (<include refid="fields"/>)
          values (#{iD}, #{name}, #{fluctuation}, #{amount}, #{price})
    </insert>
</mapper>
  • 網頁

如一開頭所說的，共有五個網頁，其中 result.jsp 及 error.jsp 只是單純顯示成功或失敗的訊息，就不列出來，其餘三頁程式碼及畫面如下:

    • index.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<%@taglib prefix="s" uri="/struts-tags" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>首頁</title>
</head>
<body>

<s:form action="index">
    <s:combobox label="請選擇功能"
        headerKey="-1" headerValue="--- Select ---"
        list="#{‘1‘:‘查詢即時資訊‘, ‘2‘:‘維護股票‘}"
        size="20" maxlength="20" name="function"
    />

    <s:submit key="gotoFunc" value="送出" />
</s:form> 

</body>
</html>

    • realtimeInfo.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<%@taglib prefix="s" uri="/struts-tags" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>查詢即時資訊</title>
</head>
<body>

股市即時資訊<br/>
-----------<br/>
<s:iterator value="#session.all" status="a">
    股票代號: <s:property value="iD"/><br/>
    股票名稱: <s:property value="name"/><br/>
    成交價格: <s:property value="price"/><br/>
    漲跌價格: <s:property value="fluctuation"/><br/>
    交量總量: <s:property value="amount"/><br/>
    -----<br/>
</s:iterator>

</body>
</html>

    • manageStock.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<%@taglib prefix="s" uri="/struts-tags" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>維護股票</title>
</head>
<body>

<s:form action="manage">
    <s:textfield name="iD" label="股票代號" />
    <s:textfield name="name" label="股票名稱" />
    <s:textfield name="price" label="成交價格" />
    <s:textfield name="fluctuation" label="漲跌價格" />
    <s:textfield name="amount" label="交量總量" />
    <s:submit key="gotoManage" value="送出" />
</s:form> 

</body>
</html>

  • Controller

在開頭的程式流程裡，除了有五個網頁外，還有兩個 action，這是 struts MVC 架構中的 Controller，其程式碼如下:

    • IndexAction.java
package idv.steven.demo.action;

import idv.steven.demo.dao.StockDAO;
import idv.steven.demo.dto.Stock;

import java.util.List;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;

import com.opensymphony.xwork2.ActionContext;
import com.opensymphony.xwork2.ActionSupport;

@Controller("indexAction")
public class IndexAction extends ActionSupport {
    private static final long serialVersionUID = -7906717067696579644L;
    final static Logger logger = LoggerFactory.getLogger(IndexAction.class);

    @Autowired
    private StockDAO stockDAO;

    private String function;

    public String getFunction() {
        return function;
    }

    public void setFunction(String function) {
        this.function = function;
    }

    public String execute() throws Exception {

        if ("1".equals(getFunction())) {
            List<Stock> all = stockDAO.findAll();
            ActionContext.getContext().getSession().put("all", all);
            //ActionContext.getContext().getValueStack().set("all", all);

            return "realtimeInfo";
        }
        else if ("2".equals(getFunction())) {
            return "manageStock";
        }

        return ERROR;
    }

}

注意看上面這個類別裡，宣告了一個 StockDAO 並在前面加上 @Autowired，這個 @Autowired 是 spring 的 annotation，表示這個類別要由 spring 自動注入。當然，這個類別也一定要在 beans-config.xml 中有先定義，或像這裡用 org.mybatis.spring.mapper.MapperScannerConfigurer 這個類別將它先行載入才行。Actoin 一開頭有個 annotation -- Controller，其括號內的名稱需與之後會說明的 struts 設定檔裡的名稱相對應。而 Action 的返回值也要和 struts 設定檔裡的 result name 相對應。

    • ManageStock.java
package idv.steven.demo.action;

import idv.steven.demo.dao.StockDAO;
import idv.steven.demo.dto.Stock;

import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;

import com.opensymphony.xwork2.ActionContext;
import com.opensymphony.xwork2.ActionSupport;

@Controller("manageAction")
public class ManageAction extends ActionSupport {
    private static final long serialVersionUID = 3655885881246145901L;
    final static Logger logger = LoggerFactory.getLogger(ManageAction.class);

    @Autowired
    private StockDAO stockDAO;

    private String iD;
    private String name;
    private Double fluctuation;
    private Integer amount;
    private Double price;

    public String execute() throws Exception {
        if (StringUtils.isEmpty(iD) || StringUtils.isEmpty(name)) {
            logger.error("ID = " + iD);
            logger.error("name = " + name);
            return ERROR;
        }

        Stock stock = new Stock();
        stock.setID(iD);
        stock.setName(name);
        stock.setFluctuation(fluctuation);
        stock.setPrice(price);
        stock.setAmount(amount);

        int count = stockDAO.createStock(stock);

        if (count == 1) {
            ActionContext.getContext().getSession().put("stock", stock);
            logger.debug(stock.toString());
            return SUCCESS;
        }
        else
            return ERROR;
    }

    //getter & setter method
    public String getID() {
        return iD;
    }

    public void setID(String iD) {
        this.iD = iD;
    }

    public String getName() {
        return name;
    }

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

    public Double getFluctuation() {
        return fluctuation;
    }

    public void setFluctuation(Double fluctuation) {
        this.fluctuation = fluctuation;
    }

    public Integer getAmount() {
        return amount;
    }

    public void setAmount(Integer amount) {
        this.amount = amount;
    }

    public Double getPrice() {
        return price;
    }

    public void setPrice(Double price) {
        this.price = price;
    }
}
  • struts 設定檔

這個設定檔正是規範了這文章一開頭所畫的那個程式流程，Action 名稱與實際的 Action 類別名稱並不需要對應，只是依習慣這個設定檔如果命名為 index，則 Action 類別就會命名為 IndexAction，而 IndexAction 前的 @Controller 這個 annotation 中所規範的名稱才是重點，必須是這裡的 action name 加上 Action!! 就像這裡命名為 index 及 manage，則 @Controller 裡的名稱就要是 indexAction 及 manageAction。

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

<!DOCTYPE struts PUBLIC
    "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
    "http://struts.apache.org/dtds/struts-2.0.dtd">

<struts>
  <constant name="struts.enable.DynamicMethodInvocation" value="false" />
  <constant name="struts.devMode" value="false" />
  <!-- 資源檔的檔名 -->
  <constant name="struts.custom.i18n.resources" value="caption" />
  <!-- 資源檔的編碼 -->
  <constant name="struts.i18n.econding" value="BIG5" />

  <package name="default" extends="struts-default">
    <action name="index" class="idv.steven.demo.action.IndexAction">
      <result name="realtimeInfo">/jsp/realtimeInfo.jsp</result>
      <result name="manageStock">/jsp/manageStock.jsp</result>
    </action>

    <action name="manage" class="idv.steven.demo.action.ManageAction">
      <result name="success">/jsp/result.jsp</result>
      <result name="error">/jsp/error.jsp</result>
    </action>
  </package>
</struts>
  • 單元測試

寫 java 的人應該都會很習慣用 JUnit 作單元測試，我也一樣，每寫好一個 DAO 就會有一個相對應的單元測試程式，這裡只非常簡單的做一個測試，真正在開發會寫的比較完整。注意看一下單元測試類別的一開頭有 @ContextConfiguration 這個 annotation，用來載入 spring 的設定檔 beans-config.xml，這樣就不需要再使用 ClassPathXmlApplicationContext 來載入。

package idv.steven.demo.dao;

import static org.junit.Assert.*;
import idv.steven.demo.dto.Stock;

import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
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;

@ContextConfiguration("classpath:beans-config.xml")
@RunWith(SpringJUnit4ClassRunner.class)
public class StockDAOTest {
    @Autowired
    private StockDAO stockDAO;

    @AfterClass
    public static void tearDownAfterClass() throws Exception {
    }

    @Before
    public void setUp() throws Exception {
    }

    @After
    public void tearDown() throws Exception {
    }

    @Test
    public void testCreateStock() {
        Stock stock = new Stock();
        stock.setID("2409");
        stock.setName("友達");
        stock.setPrice(12.8);
        stock.setFluctuation(0.05);
        stock.setAmount(34827);

        int i = stockDAO.createStock(stock);
        assertEquals(1, i);
    }
}
时间： 2024-08-12 14:15:13

spring 4.x + struts 2.x + mybatis 3.x的相关文章

spring mvc 与Struts的认识

首先,纠正一个概念上的错误.ssh一般意义上是指 struts,spring framework以及hibernate.这三个框架作用是不一样的.hibernate主要是用于持久层,struts主要是用于mvc,而spring主要用于aop和ioc.再来看 spring mvc.从名字来看,就知道这是一个mvc框架,所以,spring mvc和ssh根本就没有可比性,他们不是一个东西.spring mvc和struts都是mvc框架,他俩才有比较的意义.回到正题,spring mvc和strut

Spring 4与Struts 2项目基于XML的集成实战

Spring 4与Struts 2项目基于XML的集成实战 作者:chszs,版权所有,未经同意,不得转载.博主主页:http://blog.csdn.net/chszs 为什么要写这篇Hello World级别的文章.大约十年前,我开始使用Spring 2和Struts 1开发Web应用,构建工具使用的是Ant.早些年,把多个框架集成在一起并不容易,各框架间的兼容性也没有现在这么好.不管怎么样,这些基础的框架伴随我们多年.如今十年过去了,沧海桑田,Spring框架和Struts框架都经过了无数

Spring学习（五）——集成MyBatis

本篇我们将在上一篇http://www.cnblogs.com/wenjingu/p/3829209.html的Demo程序的基础上将 MyBatis 代码无缝地整合到 Spring 中. 数据库仍然采用前一篇文章中定义的数据库sampledb. 1.修改gradle文件,增加依赖包,代码如下: apply plugin: 'idea' apply plugin: 'java' repositories { mavenCentral() maven { url "http://repo.spri

Spring Boot学习记录(三)--整合Mybatis

Spring Boot学习记录(三)–整合Mybatis 标签(空格分隔): spring-boot 控制器,视图解析器前面两篇都已弄好,这一篇学习持久层框架整合. 1.数据源配置 数据源使用druid,maven引入相关依赖,包括spring-jdbc依赖,mysql依赖 1.转换问题 配置的过程要学会为什么这样配置,而不是只学会了配置.这里我们可以和以前的配置方式对比: 以前版本 <!--配置数据库连接池Druid--> <bean id="dataSource"

结合项目（Spring+(基于注解的)SpringMVC和Mybatis+uploadify文件上传）--poi解析Excel文件

poi解析Excel文件 1.上传文件至服务器 2.解析Excel文件并返回数据集合 3.将数据保存到服务器 框架======Spring+(基于注解的)SpringMVC和Mybatis===== 第一步: 前台: jsp文件采用的是uploadify <div id="fileQueue"></div> <input type="file" id="brandFile"> js: <script ty

spring boot 1.5.4 整合 mybatis（十二）

上一篇:spring boot 1.5.4 整合log4j2(十一) Spring Boot集成Mybatis 更多更详细的配置参考文件:application.properties和<SpringBoot之application配置详解>(新版本新增属性缺失)  或参考官网http://projects.spring.io/spring-boot/ Spring Boot集成Mybatis有两种方式: 方式一:传统的引入外部资源配置的方式,方便对mybatis的控制: 方式二:mybatis

Spring Boot （七）： Mybatis极简配置

Spring Boot (七): Mybatis极简配置 1. 前言 ORM 框架的目的是简化编程中的数据库操作,经过这么多年的发展,基本上活到现在的就剩下两家了,一个是宣称可以不用写 SQL 的 Hibernate ,一个是对 SQL 非常友好的 Mybaties ,,两者各有特点,在企业级系统开发中可以根据需求灵活使用.发现一个有趣的现象:传统企业大都喜欢使用 Hibernate ,互联网行业通常使用 Mybatis . Hibernate 特点就是所有的 SQL 都用 Java 代码来生成

Spring Boot （八）： Mybatis 增强工具 MyBatis-Plus

1. 简介 在上一篇文章<Spring Boot (七): Mybatis极简配置> 中我们介绍了在 Spring Boot 中 Mybatis 的基础使用方式,其中有一部分美中不足的是 Mybatis 本身并未提供分页功能,还需要我们自己手动添加 PageHelper 插件或者自己实现分页的工具类,并且对单表的操作并不友好,简单的 insert . update . delete 还需我们添加 SQL 语句,在目前微服务的架构模式下,每个服务拥有自己的单独的数据库,单表的使用场景会越来越多,

Spring Boot 2.X(五)：MyBatis 多数据源配置

前言 MyBatis 多数据源配置,最近在项目建设中,需要在原有系统上扩展一个新的业务模块,特意将数据库分库,以便减少复杂度.本文直接以简单的代码示例,如何对 MyBatis 多数据源配置. 准备 创建数据库 db_test SET NAMES utf8mb4; SET FOREIGN_KEY_CHECKS = 0; -- ---------------------------- -- Table structure for t_user -- -------------------------