Spring入門，一步一步搭建入門Spring Web應用

阿新 • • 發佈：2019-01-08

如何快速搭建一個入門的Spring Web應用？

開發工具：IDEA 2017
環境準備：Maven 3.3，jdk 1.7，mysql 5.5
一步一步搭建一個完整的Spring Web應用，例項應用按持久層、業務層、展現層進行組織。需求就是實現一個簡單的使用者登入驗證與登入資訊更新。

一、環境準備

本例項的工程程式碼會放在 D:\masterSpring\code 資料夾下面。

1.Maven

Maven安裝目錄：D:\masterSpring\apache-maven-3.5.0
配置Maven環境變數:

新建“MAVEN_HOME”環境變數：D:\masterSpring\apache-maven-3.5.0

編輯“Path”環境變數：把%MAVEN_HOME%\bin新增到當前環境變數
在命令列視窗輸入“mvn -v”能看到Maven和jdk版本號即ok

2.資料庫

資料庫名稱：sampledb
資料庫表：

使用者表：t_user(user_id int 主鍵，user_name varchar(32),credits int,password varchar(32),last_visit datetime,last_ip varchar(32))設定主鍵自增長
登入日誌表：t_login_log(login_log_id int 主鍵,user_id int,ip varchar(32),login_datetime datetime)設定主鍵自增長

插入一條資料到使用者表(‘admin’,’123456’)

二、建立工程

三、持久層實現

包結構規劃：

主程式包規劃
測試包規劃

持久層負責資料的訪問和操作，DAO類被上層的業務類呼叫。這裡使用Spring JDBC作為持久層的實現技術。

1.建立領域物件

領域物件（Domain Object）也被成為實體類，它代表了業務的狀態，貫穿展現層、業務層、持久層，並最終被持久化到資料庫中，領域物件往往擁有對應的資料庫表（也可以理解為領域物件裡面的屬性對應資料庫表的欄位）。持久層的主要工作是從資料庫中載入資料並例項化領域物件。

登入驗證例項需要涉及兩個領域物件：User（使用者資訊）對應t_user表和LoginLog（日誌資訊）對應t_login_log表。領域物件包為com.smart.domain。

User.java領域物件

package com.smart.domain;

import java.io.Serializable;
import java.util.Date;
/**
 * Created by Mistra.WR on 2017/8/5/005.
 */
//領域物件一般要實現Serializable介面，以便可以序列化
public class User implements Serializable{
    private int userID;
    private String username;
    private String password;
    private int credits;
    private String lastIp;
    private Date lastVisit;
    //省略get/set方法
}

LoginLog.java領域物件

package com.smart.domain;

import java.io.Serializable;
import java.util.Date;
/**
 * Created by Mistra.WR on 2017/8/5/005.
 */
public class LoginLog implements Serializable{
    private int loginLogid;
    private int userId;
    private String ip;
    private Date loginDate;
}

2.UserDao

package com.smart.dao;
import com.smart.domain.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowCallbackHandler;
import org.springframework.stereotype.Repository;

import java.sql.ResultSet;
import java.sql.SQLException;
/**
 * Created by Mistra.WR on 2017/8/5/005.
 */
@Repository //通過Spring註解定義一個DAO
public class UserDao {
    private JdbcTemplate jdbcTemplate;
    private final static String MATCH_COUNT_SQL =  "select count(*) from t_user"
            + " where user_name = ? and password=?";
    private final static String UPDATE_LOGININFO_SQL = "update t_user set "+
            " last_visit=?,last_ip=?,credits=? where user_id=?";
    @Autowired //自動注入JdbcTemplate的bean
    public void setJdbcTemplatedbcTemplate(JdbcTemplate jdbcTemplate){
        this.jdbcTemplate = jdbcTemplate;
    }
    public int getMatchCount(String userName,String password){//根據使用者名稱密碼獲取匹配的使用者數
        return jdbcTemplate.queryForObject(MATCH_COUNT_SQL,new Object[]{userName,password}, Integer.class).intValue();
    }

    public User findUserByUserName(final String userName){//根據使用者名稱獲取User物件
        String sqlStr = " SELECT user_id,user_name,credits "
                + " FROM t_user WHERE user_name =? ";
        final User user = new User();
        jdbcTemplate.query(sqlStr, new Object[]{userName},
                new RowCallbackHandler() {//匿名類方式實現的回撥函式
                    public void processRow(ResultSet resultSet) throws SQLException {
                        user.setUserID(resultSet.getInt("user_id"));
                        user.setUsername(userName);
                        user.setCredits(resultSet.getInt("credits"));
                    }
                }
        );
        return user;
    }
    public void updateLoginInfo(User user){//更新使用者積分、最後登入時間和IP
        jdbcTemplate.update(UPDATE_LOGININFO_SQL,new Object[]{user.getLastVisit(),user.getLastIp(),user.getCredits(),user.getUserID()});
    }
}

關於findUserByUserName()方法中的JdbcTemplate.query(String sqlStr，Object[] args,RowCallbackHandler rch)方法：

sqlStr:查詢的SQL語句，允許使用帶”?”的引數佔位符
args:SQL語句中佔位符對應的引數陣列
RowCallbackHandler ：查詢結果的處理回撥介面，該回調介面有一個processRow(ResultSet rs)方法，負責將查詢結果從ResultSet 裝載到類似於領域物件的物件例項中。此處即將ResultSet轉換成User物件。

3.LoginLogDao

package com.smart.dao;

import com.smart.domain.LoginLog;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;
/**
 * Created by Mistra.WR on 2017/8/9/009.
 */
@Repository
public class LoginLogDao {
    private JdbcTemplate jdbcTemplate;

    //儲存登陸日誌
    private final static String INSERT_LOGIN_LOG_SQL = "insert into t_login_log(user_id,ip,login_datetime)" +
            " values(?,?,?)";
    public void insertLoginLog(LoginLog loginLog){
        jdbcTemplate.update(INSERT_LOGIN_LOG_SQL,new Object[]{loginLog.getUserId(),loginLog.getIp(),loginLog.getLoginDate()});
    }
@Autowired
    public void setJdbcTemplate(JdbcTemplate jdbcTemplate){
        this.jdbcTemplate=jdbcTemplate;
    }
}

4.在Spring中裝配Dao

JdbcTemplate本身需要一個DataSource，才能從DataSource中獲取或返回連線。UserDao和LoginLogDao都提供了一個帶@Autowired註解的JdbcTemplate變數，所以我們必須事先宣告一個數據源，然後定義一個JdbcTemplate Bean，通過Spring的容器上下文自動繫結機制進行Bean注入。

在src/resources目錄下建立一個smart-context.xml的Spring配置檔案。(Maven工程中，資原始檔統一放置在resources資料夾中)

<?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: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-4.0.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context-4.0.xsd
       http://www.springframework.org/schema/tx
       http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop-4.0.xsd">

    <!-- 掃描類包，將標註Spring註解的類自動轉化Bean，同時完成Bean的注入 -->
    <context:component-scan base-package="com.smart.dao"/>

    <!-- 配置資料來源 -->
    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
          destroy-method="close"
          p:driverClassName="com.mysql.jdbc.Driver"
          p:url="jdbc:mysql://localhost:3306/sampledb"
          p:username="root"
          p:password="123456" />

    <!-- 配置Jdbc模板  -->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"
          p:dataSource-ref="dataSource" />
</beans>

四、業務層實現

1.UserService

UserService負責將持久層的UserDao和LoginLoginDao組織起來，完成使用者/密碼驗證、登入日誌記錄等操作。

UserService.java

package com.smart.service;

import com.smart.dao.LoginLogDao;
import com.smart.dao.UserDao;
import com.smart.domain.LoginLog;
import com.smart.domain.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

/**
 * Created by Mistra.WR on 2017/8/10/010.
 */
@Service//將UserService標註為一個服務層的Bean
public class UserService {
    private UserDao userDao;
    private LoginLogDao loginLogDao;

    @Autowired//注入userDao  Bean
    private void setUserDao(UserDao userDao){
        this.userDao = userDao;
    }

    @Autowired//注入loginLogDao  Bean
    private void setLoginLogDao(LoginLogDao loginLogDao){
        this.loginLogDao = loginLogDao;
    }

    public boolean hasMatcherUser(String username,String password){
        int matchCount = userDao.getMatchCount(username,password);
        return matchCount > 0;
    }

    public User findUserByUserName(String username){
        return userDao.findUserByUserName(username);
    }

    @Transactional//標註事物註解，讓該方法執行在事物環境中
    public void loginSuccess(User user){
        user.setCredits( 5 + user.getCredits());
        LoginLog loginLog = new LoginLog();
        loginLog.setIp(user.getLastIp());
        loginLog.setUserId(user.getUserID());
        loginLog.setLoginDate(user.getLastVisit());
        userDao.updateLoginInfo(user);
        loginLogDao.insertLoginLog(loginLog);
    }
}

2.在Spring中裝配Service

開啟原來的smart-context.xml檔案，新增如下配置

    <!-- ①掃描service類包，應用Spring的註解配置-->
    <context:component-scan base-package="com.smart.service"/>
    <!-- ②配置事務管理器 -->
    <bean id="transactionManager"
          class="org.springframework.jdbc.datasource.DataSourceTransactionManager"
          p:dataSource-ref="dataSource" />

    <!-- ③通過AOP配置提供事務增強，讓com.smart.service包下所有Bean的所有方法擁有事務 -->
    <aop:config proxy-target-class="true">
        <aop:pointcut id="serviceMethod"
                      expression="(execution(* com.smart.service..*(..))) and (@annotation(org.springframework.transaction.annotation.Transactional))" />
        <aop:advisor pointcut-ref="serviceMethod" advice-ref="txAdvice" />
    </aop:config>
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="*" />
        </tx:attributes>
    </tx:advice>

①處將com.smart.service新增到上下文掃描路徑中，以便service包中類的Spring註解生效。
②處定義了一個基於資料來源的DataSourceTransactionManager事務管理器，該事物管理器負責宣告式事務的管理。該管理器需要引用dataSource Bean
③處以AOP的方式為com.smart.service包下所有類的所有標註@Transactional註解的方法都添加了事務增強，即它們都將工作在事務環境中。

3.單元測試

單元測試採用TestNG框架，確保下面的TestNG依賴包新增到了你的pom.xml檔案中。

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

在src/test/java/com.smart/service包下面新建UserServiceTest.java

UserServiceTest.java

package com.smart.service;

import java.util.Date;
import org.springframework.test.context.testng.AbstractTransactionalTestNGSpringContextTests;
import org.testng.annotations.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import com.smart.domain.User;
import static org.testng.Assert.*;

@ContextConfiguration("classpath*:/smart-context.xml")//啟動spring容器
public class UserServiceTest extends AbstractTransactionalTestNGSpringContextTests {

    @Autowired
    private UserService userService;

    @Test//標註測試方法
    public void testHasMatchUser() {
        boolean b1 = userService.hasMatcherUser("admin", "123456");
        boolean b2 = userService.hasMatcherUser("admin", "1111");
        assertTrue(b1);//判斷一個條件是true還是false
        assertTrue(!b2);
    }

    @Test
    public void testFindUserByUserName()throws Exception{
        for(int i =0; i< 100;i++) {
            User user = userService.findUserByUserName("admin");
            assertEquals(user.getUsername(), "admin");// 判斷是否相等，可以指定輸出錯誤資訊。第一個引數是期望值，第二個引數是實際的值
        }
    }

    @Test
    public void testAddLoginLog() {
        User user = userService.findUserByUserName("admin");
        user.setUserID(1);
        user.setUsername("admin");
        user.setLastIp("192.168.12.7");
        user.setLastVisit(new Date());
        userService.loginSuccess(user);
    }
}

在IDEA中執行當前測試類，通過右鍵選單Run ‘UserServiceTest’來執行該測試用例。

測試結果

看到三個方法已經成功執行。在資料庫可以看到t_login_log表增加了一條日誌資料。

五、展現層實現

1.配置Spring MVC框架

開啟webapp/WEB-INF/web.xml檔案，增加Spring MVC配置

<?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">
  <!--①從類路徑下載入Spring配置檔案，classpath關鍵字特指類路徑下載入-->
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:smart-context.xml</param-value>
  </context-param>
  <!--②負責啟動Spring容器的監聽器，它將引用①處的上下文引數獲得Spring配置檔案的地址-->
  <listener>
    <listener-class>
      org.springframework.web.context.ContextLoaderListener
    </listener-class>
  </listener>

  <!--Spring MVC的主控Servlet-->
  <servlet>
    <servlet-name>smart</servlet-name>
    <servlet-class>
      org.springframework.web.servlet.DispatcherServlet
    </servlet-class>
    <load-on-startup>3</load-on-startup>
  </servlet>
<!--③Spring MVC處理的URL-->
  <servlet-mapping>
    <servlet-name>smart</servlet-name>
    <url-pattern>*.html</url-pattern>
  </servlet-mapping>
</web-app>

①處多個配置檔案可用逗號分隔
②處的Web容器監聽器會在Web容器啟動時自動執行，它會根據contextConfigLocation Web容器引數獲取Spring配置檔案，並啟動Spring容器。
③處Servlet對映，這裡讓所有以*.html為字尾的URL都能被smart Servlet截獲，進而轉由Spring MVC框架進行處理。請求被Spring MVC截獲後，首先根據請求的URL查詢到目標的處理控制器，並將請求引數封裝到物件中（或者封裝到入參欄位中），交給控制器處理。

2.登入控制器

請求命令物件LoginCommand.java

package com.smart.web;

/**
 * Created by Mistra.WR on 2017/8/14/014.
 */
public class LoginCommand {
    private String username;
    private String password;
    //省略了get/set方法
}

登入控制器LoginController.java

package com.smart.web;

import com.smart.domain.User;
import com.smart.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import java.util.Date;

/**
 * Created by Mistra.WR on 2017/8/14/014.
 */
@Controller//①標註成為一個Spring MVC的Controller
public class LoginController {
    private UserService userService;

    @Autowired
    public void setUserService(UserService userService){
        this.userService = userService;
    }

    //②負責處理/index.html的請求
    @RequestMapping(value = "/index.html")
    public String loginPage(){
        return "login";
    }
    //③負責處理/loginCheck.html的請求
    @RequestMapping(value = "/loginCheck.html")
    public ModelAndView loginCheck(HttpServletRequest request,LoginCommand loginCommand){
        boolean isValidUser = userService.hasMatcherUser(loginCommand.getUsername(),loginCommand.getPassword());
        if (!isValidUser){
            return new ModelAndView("login","error","使用者名稱或密碼錯誤");//④
        }else{
            User user = userService.findUserByUserName(loginCommand.getUsername());
            user.setLastIp(request.getLocalAddr());
            user.setLastVisit(new Date());
            userService.loginSuccess(user);
            request.getSession().setAttribute("user",user);
            return new ModelAndView("main");
        }
    }    
}

請求引數會根據引數名稱預設契約自動繫結到相應方法的入參中。在③處請求引數會按照名稱匹配繫結到loginCommand的入參中。
請求響應方法可以返回一個ModelAndView，或直接返回一個字串，Spring MVC會解析之並轉向目標頁面。
ModelAndView物件既包括檢視資訊，又包括檢視渲染所需的模型資料資訊。
在④處ModelAndView(“login”,”error”,”使用者名稱或密碼錯誤”);第一個引數代表檢視的邏輯名，第二個引數代表資料模型名，第三個引數代表資料模型物件，資料模型物件將以資料模型名稱為引數名放置到request的屬性中。

3.Spring MVC配置檔案

在webapp/WEB-INF資料夾下新建Spring MVC配置檔案smart-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-4.0.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context-4.0.xsd">
    <!-- 掃描web包，應用Spring的註解 -->
    <context:component-scan base-package="com.smart.web"/>
    <!-- ①②配置檢視解析器，將ModelAndView及字串解析為具體的頁面 -->
    <bean
            class="org.springframework.web.servlet.view.InternalResourceViewResolver"
            p:viewClass="org.springframework.web.servlet.view.JstlView"
            p:prefix="/WEB-INF/jsp/"
            p:suffix=".jsp" />
</beans>

①處配置的檢視解析器，它通過為檢視邏輯名新增前、字尾的方式進行解析。如邏輯名為”login”，將解析為“/WEB-INF/jsp/login.jsp”。

4.JSP檢視頁面

登入頁面login.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
<html>
    <head>
        <title>登入</title>
    </head>
    <body>
        <c:if test="${!empty error}">
            <font color="red"><c:out value="${error}" /></font>
        </c:if>
        <form action="<c:url value="loginCheck.html"/>" method="post">
            使用者名稱：
            <input type="text" name="username">
            <br>
            密 碼：
            <input type="password" name="password">
            <br>
            <input type="submit" value="登入" />
            <input type="reset" value="重置" />
        </form>
    </body>
</html>

login.jsp頁面既作為登入頁面，又作為登入失敗之後的響應頁面。在JSTL標籤中引用了”error”變數，這個變數正是LoginController中返回的ModelAndView(“login”,”error”,”使用者名稱或密碼錯誤”)物件所宣告的error引數。
login.jsp的登入表單將提交到/loginCheck.html,< c:url value=”loginCheck.html”/>的JSTL標籤會在URL前自動加上應用部署根目錄。假設應用部署在容器的workbenck目錄下，則< c:url>標籤將輸出/workbenck/loginCheck.html。通過< c:url>標籤很好的解決了開發和應用部署目錄不一致的問題。

歡迎頁面main.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>小春論壇</title>
</head>
<body>
    ${user.username},歡迎您進入論壇，您當前積分為${user.credits};①
</body>
</html>

①處訪問Session域中的user物件，顯示使用者名稱和積分資訊。

六、執行Web應用

Maven工程，執行Web應用有兩種方式：第一種是在IDE工具中配置Web應用伺服器；第二種是在pom.xml檔案中配置Web應用伺服器外掛。推薦採用第二種。這裡我們在pom.xml檔案中配置Jetty應用伺服器外掛。

 <build>
        <plugins>
            <!-- jetty外掛 -->
            <plugin>
                <groupId>org.mortbay.jetty</groupId>
                <artifactId>maven-jetty-plugin</artifactId>
                <version>6.1.25</version>
                <configuration>
                    <connectors>
                        <connector implementation="org.mortbay.jetty.nio.SelectChannelConnector">
                            <port>8000</port>
                            <maxIdleTime>60000</maxIdleTime>
                        </connector>
                    </connectors>
                    <contextPath>/bbs</contextPath>
                    <scanIntervalSeconds>0</scanIntervalSeconds>
                </configuration>
            </plugin>

            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <version>2.17</version>
                <configuration>
                    <parallel>methods</parallel>
                    <threadCount>10</threadCount>
                </configuration>
            </plugin>
        </plugins>
    </build>

在pom.xml中配置好Jetty外掛之後，在IDEA工程右邊的Maven Projects管理視窗工具欄中單擊圖示，更新依賴包和外掛。
雙擊jetty:run以執行模式啟動Jetty伺服器。如果想DeBug，右鍵選擇DeBug啟動就好。

Maven Projects

登入首頁

輸入錯誤密碼

登入失敗

輸入正確密碼

登入成功

至此，一個入門的Spring Web應用就實現了。下篇介紹運用Spring Boot更加快速犀利的搭建Spring Web應用。