走進spring之springmvc實戰篇（二）

本篇繼篇一之后加入了jdbc並使用了注解

篇一進行了對spingmvc的基礎配置http://www.cnblogs.com/liuyanhao/p/4798989.html

首先讓我們先了解下注解的好處：

注解方式與配置文件方式相比，使用注解方式可以省略大部分配置文件，並且在IOC方面更能凸顯出其特性。

本篇使用的注解進行歸納總結：

-----持續更新中-------

2015-09-15 11:03:11更新

注意：使用注解就必須在配置文件中加入<context:component-scan base-package=“包名”/>表示在該包中使用注解

@Resource

@Resource的作用相當於@Autowired，只不過@Autowired按byType自動注入，而@Resource默認按 byName自動注入罷了。@Resource有兩個屬性是比較重要的，分是name和type，Spring將@Resource注解的name屬性解析為bean的名字，而type屬性則解析為bean的類型。所以如果使用name屬性，則使用byName的自動注入策略，而使用type屬性時則使用byType自動注入策略。如果既不指定name也不指定type屬性，這時將通過反射機制使用byName自動注入策略。

@Resource注解和@Autowired一樣，也可以標注在字段或屬性的setter方法上，但它默認按名稱裝配。名稱可以通過@Resource的name屬性指定，如果沒有指定name屬性，當注解標注在字段上，即默認取字段的名稱作為bean名稱尋找依賴對象，當注解標注在屬性的setter方法上，即默認取屬性名作為bean名稱尋找依賴對象。
    @Resource(name=“personDaoBean”)
    private PersonDao  personDao;//用於字段上

@Resource注解所提供名字相匹配的“bean name（bean名字）”的Spring管理對象會被注入。 在下面的例子中，Spring會向加了注解的setter方法傳遞bean名為“dataSource”的Spring管理對象的引用。

@Resource(name="dataSource")
public void setDataSource(DataSource dataSource) {
this.dataSource = dataSource;
}

類似的，也可以怎樣：
@Resource
private DataSource dataSource;

@Resource裝配順序
1. 如果同時指定了name和type，則從Spring上下文中找到唯一匹配的bean進行裝配，找不到則拋出異常
2. 如果指定了name，則從上下文中查找名稱（id）匹配的bean進行裝配，找不到則拋出異常
3. 如果指定了type，則從上下文中找到類型匹配的唯一bean進行裝配，找不到或者找到多個，都會拋出異常
4. 如果既沒有指定name，又沒有指定type，則自動按照byName方式進行裝配；如果沒有匹配，則回退為一個原始類型進行匹配，如果匹配則自動裝配； 

@Controller
@Controller 用於標記在一個類上，使用它標記的類就是一個SpringMVC Controller 對象。分發處理器將會掃描使用了該注解的類的方法，並檢測該方法是否使用了@RequestMapping 注解。@Controller 只是定義了一個控制器類，而使用@RequestMapping 注解的方法才是真正處理請求的處理器。

@RequestMapping
當@RequestMapping 標記在Controller 類上的時候，里面使用@RequestMapping 標記的方法的請求地址都是相對於類上的@RequestMapping 而言的；當Controller 類上沒有標記@RequestMapping 注解時，方法上的@RequestMapping 都是絕對路徑。這種絕對路徑和相對路徑所組合成的最終路徑都是相對於根路徑“/ ”而言的。

@RequestMapping

RequestMapping是一個用來處理請求地址映射的注解，可用於類或方法上。用於類上，表示類中的所有響應請求的方法都是以該地址作為父路徑。

RequestMapping注解有六個屬性，下面我們把她分成三類進行說明。

1、 value， method；

value：     指定請求的實際地址，指定的地址可以是URI Template 模式（后面將會說明）；

method：  指定請求的method類型， GET、POST、PUT、DELETE等；

 

2、 consumes，produces；

consumes： 指定處理請求的提交內容類型（Content-Type），例如application/json, text/html;

produces:    指定返回的內容類型，僅當request請求頭中的(Accept)類型中包含該指定類型才返回；

 

3、 params，headers；

params： 指定request中必須包含某些參數值是，才讓該方法處理。

headers： 指定request中必須包含某些指定的header值，才能讓該方法處理請求。

-------分割線---------

這里再講解下JdbcTemplate類
JdbcTemplate將完成JDBC核心處理流程，比如SQL語句的創建、執行，而把SQL語句的生成以及查詢結果的提取工作留給我們的應用代碼。

摘自Spring Framework開發參考手冊：

查詢（SELECT）

一個簡單的例子用於展示如何獲取一個表中的所有行數。

int rowCount = this.jdbcTemplate.queryForInt("select count(0) from t_accrual");

一個簡單的例子展示如何進行參數綁定。

int countOfActorsNamedJoe = this.jdbcTemplate.queryForInt(
        "select count(0) from t_actors where first_name = ?", new Object[]{"Joe"});

查詢一個String。

String surname = (String) this.jdbcTemplate.queryForObject(
        "select surname from t_actor where id = ?", 
        new Object[]{new Long(1212)}, String.class);

查詢並將結果記錄為一個簡單的數據模型。

Actor actor = (Actor) this.jdbcTemplate.queryForObject(
    "select first_name, surname from t_actor where id = ?",
    new Object[]{new Long(1212)},
    new RowMapper() {

        public Object mapRow(ResultSet rs, int rowNum) throws SQLException {
            Actor actor = new Actor();
            actor.setFirstName(rs.getString("first_name"));
            actor.setSurname(rs.getString("surname"));
            return actor;
        }
    });

查詢並組裝多個數據模型。

Collection actors = this.jdbcTemplate.query(
    "select first_name, surname from t_actor",
    new RowMapper() {

        public Object mapRow(ResultSet rs, int rowNum) throws SQLException {
            Actor actor = new Actor();
            actor.setFirstName(rs.getString("first_name"));
            actor.setSurname(rs.getString("surname"));
            return actor;
        }
    });

更新（INSERT/UPDATE/DELETE）

this.jdbcTemplate.update(
        "insert into t_actor (first_name, surname) values (?, ?)", 
        new Object[] {"Leonor", "Watling"});

this.jdbcTemplate.update(
        "update t_actor set weapon = ? where id = ?", 
        new Object[] {"Banjo", new Long(5276)});

this.jdbcTemplate.update(
        "delete from actor where id = ?",
        new Object[] {new Long.valueOf(actorId)});

若仍有些知識點模糊，不要緊，讓我們開始邊學邊練

首先，讓我們梳理下整體步驟：
1）新引入jar包：commons-dbcp.jar,commons-pool.jar,mysql-connector-java.jar
2)修改applicationContext.xml,spring-servlet.xml,web.xml
3)新增service層，dao層，db-config.properties（數據源配置文件）

開始配置！
web.xml

<?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" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" version="2.5">
  <display-name>mvc_loginregist</display-name>
  <servlet>
    <servlet-name>spring</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
        <servlet-name>spring</servlet-name>
     <url-pattern>/</url-pattern>
  </servlet-mapping>
  
  <listener>
    <listener-class>
     org.springframework.web.context.ContextLoaderListener
   </listener-class>
  </listener>
</web-app>

 db-config.propertise

db.url= jdbc:mysql://127.0.0.1/springmvc
db.username=root
db.password=199624
db.dirverClassName= com.mysql.jdbc.Driver

該配置文件提供數據庫的屬性

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

    <!-- 屬性文件讀入 -->
    <bean id="db-config"
        class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="locations">
            <list>
                <value>classpath:db-config.properties</value>
            </list>
        </property>
    </bean>

    <!-- 數據源定義，使用jdbc數據源 -->
    <!-- 實際的JDBC連接屬性從一個屬性文件（properties file）解析而來，在這個屬性文件里，關鍵字與提供的${占位符}互相對應， -->
    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
        <property name="driverClassName">
            <value>${db.dirverClassName}</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>

    <!-- 配置JdbcTemplate -->
    <bean id="template" class="org.springframework.jdbc.core.JdbcTemplate"
        abstract="false" lazy-init="false" autowire="default"
    p:dataSource-ref="dataSource"
    />
    
    <!--配置View,引入p標簽-->
    <bean id="view" class="com.htgy.view.View"
    p:loginSuccess="loginSuccess"
    p:login="login"
    p:regist="regist"
    p:registSuccess="registSuccess"
    p:registFail="registFail"
    /> 
</beans>

 spring-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:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="
     http://www.springframework.org/schema/context 
     http://www.springframework.org/schema/context/spring-context-3.0.xsd
http://www.springframework.org/schema/beans 
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">

    <!-- 對模型視圖名稱的解析，即在模型視圖名稱添加前后綴 -->
    <bean
        class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="viewClass"
            value="org.springframework.web.servlet.view.JstlView" /> <!-- 支持JSTL標簽庫 -->
        <property name="prefix" value="/WEB-INF/jsp/" />
        <property name="suffix" value=".jsp" />
    </bean>

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

    <!-- 對web包中的所有類進行掃描，以完成Bean創建和自動依賴注入的功能,base-package為需要掃描的包（含所有子包）-->
    <context:component-scan base-package="com.htgy"/>
    
    <!-- 啟動Spring MVC的注解功能，完成請求和注解POJO的映射 -->
    <bean class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter"/>
</beans>

UserForm.java

package com.htgy.form;

/*
 * 表單類
 */
public class UserForm {
    private String account;
    private String password;
    private String passFirst;
    private String passSecond;
    private String username;
    
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
    public String getAccount() {
        return account;
    }
    public void setAccount(String account) {
        this.account = account;
    }
    public String getPassFirst() {
        return passFirst;
    }
    public void setPassFirst(String passFirst) {
        this.passFirst = passFirst;
    }
    public String getPassSecond() {
        return passSecond;
    }
    public void setPassSecond(String passSecond) {
        this.passSecond = passSecond;
    }
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }

 User.java

package com.htgy.user;
/*
 * 用戶
 */
public class User {
    private String account;
    private String username;
    private String password;
    public String getAccount() {
        return account;
    }
    public void setAccount(String account) {
        this.account = account;
    }
    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;
    }
}

 view.java

package com.htgy.view;

/*
 * 視圖類
 */

//@Component @Component泛指組件，當組件不好歸類的時候，我們可以使用這個注解進行標注。 
public class View {
    private String loginSuccess;
    private String registSuccess;
    private String registFail;
    private String login;
    private String regist;
    public String getLoginSuccess() {
        return loginSuccess;
    }
    public void setLoginSuccess(String loginSuccess) {
        this.loginSuccess = loginSuccess;
    }
    public String getRegistSuccess() {
        return registSuccess;
    }
    public void setRegistSuccess(String registSuccess) {
        this.registSuccess = registSuccess;
    }
    public String getRegistFail() {
        return registFail;
    }
    public void setRegistFail(String registFail) {
        this.registFail = registFail;
    }
    public String getLogin() {
        return login;
    }
    public void setLogin(String login) {
        this.login = login;
    }
    public String getRegist() {
        return regist;
    }
    public void setRegist(String regist) {
        this.regist = regist;
    }
}

UserDAO.java

package com.htgy.userdao;  

/*
 * UserDAO接口
 */
import java.sql.ResultSet;  
import java.sql.SQLException;  
import java.util.Collection;  
import java.util.List;  
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;  
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.ModelAndView;

import com.htgy.user.User;

@SuppressWarnings("all") 
public interface UserDAO{  
    //一個template訪問一個數據庫，也可以繼承JdbcDaoSupport實現
    public JdbcTemplate template = null; 

    // 此方法把USEMBO表對應的字段查詢出來依次放入userPO中  
    // public Collection<UserPO> doquery();
    // public User doquery(final String account,final String password);

    //按賬號查詢
    public User queryAccount(String account);

    //按用戶名查詢
    public User queryUsername(String username);

    //增加
    public void insert(String account,String password,String username);

    //        class UserRowMapper implements RowMapper;
    //        public List findAllByRowMapperResultReader(String accont);
}

UserDAOImpl.java

package com.htgy.userdao.impl;

/*
 * UserDAOImpl實現
 */
import java.sql.ResultSet;
import java.sql.SQLException;
import javax.annotation.Resource;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.stereotype.Repository;

import com.htgy.userdao.UserDAO;
import com.htgy.user.User;

@Repository("dao")
public class UserDAOImpl implements UserDAO{
    //一個template訪問一個數據庫，也可以繼承JdbcDaoSupport實現
    @Resource
    private JdbcTemplate template;  
    // 此方法把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;  
//            }  
//        });  
    
//        public User doquery(final String account,final String password){
//         User user = (User) this.template.queryForObject(
//                "SELECT account, password FROM user WHERE account=?",
//                new Object[]{account},
//                new RowMapper() {
//                    public Object mapRow(ResultSet rs, int rowNum) throws SQLException {
//                        User user = new User();
//                        user.setAccount(rs.getString(account));
//                        user.setPassword(rs.getString(password));
//                        return user;
//                    }
//                });
//        return user;
//    }  
    
        //按賬號查詢，若賬號不存在則報錯
        @SuppressWarnings({ "unchecked", "rawtypes" })
        @Override
        public User queryAccount(String account){
            User user = (User) this.template.queryForObject(
                    "SELECT account, password FROM user WHERE account=?",
                    new Object[]{account}, 
                    new RowMapper() {
                        public Object mapRow(ResultSet rs, int rowNum) throws SQLException {
                            User user = new User();
                            user.setAccount(rs.getString("account")); 
                            user.setPassword(rs.getString("password"));
                            return user;
                        }
                    });
            return user;
        }  
        
        //按用戶名查詢，不存在則報錯
        @SuppressWarnings({ "unchecked", "rawtypes" })
        @Override
        public User queryUsername(String username){
            User user = (User) this.template.queryForObject(
                    "SELECT account, password FROM user WHERE username=?",
                    new Object[]{username},
                    new RowMapper() {
                        public Object mapRow(ResultSet rs, int rowNum) throws SQLException {
                            User user = new User();
                            user.setAccount(rs.getString("account")); 
                            user.setPassword(rs.getString("password"));
                            return user;
                        }
                    });
            return user;
        }  
        
        //增加用戶
        @Override
        public void insert(String account,String password,String username){
            this.template.update(
                    "INSERT INTO user (account, password,username) values (?, ?, ?)", 
                    new Object[] {account,password,username});
        }

//        class UserRowMapper implements RowMapper {  
//            public Object mapRow(ResultSet rs, int index) throws SQLException {  
//                User user = new User();  
//                user.setAccount(rs.getString("account"));
//                user.setPassword(rs.getString("password"));
//                return user;  
//            }  
//        }  
//          
//        public List findAllByRowMapperResultReader(String accont) {  
//            String sql = "SELECT * FROM USER";  
//            return this.template.queryForObject(sql,new UserRowMapper());  
//        }  
}

 

ServiceInterface.java

package com.htgy.service;

/*
 * Service接口 @Service服務層組件，用於標注業務層組件,表示定義一個bean.   
 * 自動根據bean的類名實例化一個首寫字母為小寫的bean，例如Chinese實例化為chinese，如果需要自己改名字則:@Service("你自己改的bean名")。
 */
import java.util.HashMap;
public interface Serviceinterface {
    public boolean queryAccount(String account);
    public boolean queryUsername(String username);
    public void insert(String account,String password,String username);
    public boolean doquery(String account,String password);
    public HashMap<String, Object> dealNull();
    public HashMap<String, Object> loginSuccess();
    public HashMap<String, Object> error();
    public HashMap<String, Object> intact();
    public HashMap<String, Object> correct();
    public HashMap<String, Object> consistent();
    public HashMap<String, Object> accountExist();
    public HashMap<String, Object> usernameExist();
}

ServiceImpl.java

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import javax.annotation.Resource;
import org.springframework.stereotype.Service;

import com.htgy.service.Serviceinterface;
import com.htgy.user.User;
import com.htgy.userdao.impl.UserDAOImpl;

@Service("sI") 
//@Service服務層組件，用於標注業務層組件,表示定義一個bean.   
//自動根據bean的類名實例化一個首寫字母為小寫的bean，例如Chinese實例化為chinese，如果需要自己改名字則:@Service("你自己改的bean名")。
//此處將ServiceImpl初始化為名稱為"sI"的bean
public class ServiceImpl implements Serviceinterface{
    @Resource
    private UserDAOImpl dao;
    
    //賬號或密碼不能為空
    public HashMap<String, Object> dealNull(){
        HashMap<String, Object> map = new HashMap<String,Object>();
        List<String> msgList = new ArrayList<String>(); 
        msgList.add("賬號或密碼不能為空");
        map.put("msg", msgList);
        return map;
    }
    //登錄成功
    public HashMap<String, Object> loginSuccess(){
        HashMap<String, Object> map = new HashMap<String,Object>();
        List<String> msgList = new ArrayList<String>(); 
        msgList.add("恭喜您，登錄成功");
        map.put("msg", msgList);
        return map;
    }
    //賬號或密碼錯誤
    public HashMap<String, Object> error(){
        HashMap<String, Object> map = new HashMap<String,Object>();
        List<String> msgList = new ArrayList<String>(); 
        msgList.add("賬號或密碼錯誤");
        map.put("msg", msgList);
        return map;
    }
    //信息不完整
    public HashMap<String, Object> intact(){
        HashMap<String, Object> map = new HashMap<String,Object>();
        List<String> msgList = new ArrayList<String>(); 
        msgList.add("請將信息填寫完整");
        map.put("msg", msgList);
        return map;
    }
    //信息不正確
    public HashMap<String, Object> correct(){
        HashMap<String, Object> map = new HashMap<String,Object>();
        List<String> msgList = new ArrayList<String>(); 
        msgList.add("請正確填寫信息");
        map.put("msg", msgList);
        return map;
    }
    //密碼不一致
    public HashMap<String, Object> consistent(){
        HashMap<String, Object> map = new HashMap<String,Object>();
        List<String> msgList = new ArrayList<String>(); 
        msgList.add("兩次輸入的密碼不一致");
        map.put("msg", msgList);
        return map;
    }
    //賬號存在
    public HashMap<String, Object> accountExist(){
        HashMap<String, Object> map = new HashMap<String,Object>();
        List<String> msgList = new ArrayList<String>(); 
        msgList.add("賬號已存在");
        map.put("msg", msgList);
        return map;
    }
    //用戶名存在
    public HashMap<String, Object> usernameExist(){
        HashMap<String, Object> map = new HashMap<String,Object>();
        List<String> msgList = new ArrayList<String>(); 
        msgList.add("用戶名已存在");
        map.put("msg", msgList);
        return map;
    }


    //按賬號查詢
    public boolean queryAccount(String account){
        try{
            dao.queryAccount(account);
            return true;
        }catch(Exception e){
            return false;
        }
    }
    //按用戶名查詢
    public  boolean queryUsername(String username){
        try{
            dao.queryUsername(username);
            return true;
        }catch(Exception e){
            return false;
        }
    }
    //查詢
    public boolean doquery(String account,String password){
        try{
            User user=dao.queryAccount(account);
            if(user.getAccount().equals(account)&&user.getPassword().equals(password)){
                return true;
            }
            else{
                return false;
            }
        }catch(Exception e){
            return false;
        }
    }
    //查找
    public void insert(String account,String password,String username){
        dao.insert(account,password,username);
    }
}

  LRController.java

 

package com.htgy.actions;

/*
 * Controller類
 */
import javax.annotation.Resource;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;  
import com.htgy.form.UserForm;
import com.htgy.service.impl.ServiceImpl;
import com.htgy.view.View;

@Controller //@Controller用於標注控制層組件(如struts中的action)
public class LRController {
    @Resource
    private ServiceImpl sI;
    @Resource
    private View view;

    //跳轉到注冊頁面
    @RequestMapping("/toRegist") // 請求URL地址映射
    public ModelAndView toRegist(){  
        return new ModelAndView("regist"); // 手動實例化ModelAndView完成跳轉頁面，效果等同於下面返回字符串的方法
        //return new ModelAndView(new RedirectView("../index.jsp"));  采用重定向方式跳轉頁面 
        //return new ModelAndView("redirect:../index.jsp"); 另一種簡單的方法
    }
    //跳轉到登錄頁面
    @RequestMapping({"/","/toLogin"}) // "/"表示訪問首頁的請求
    public String toLogin(){
        return "login"; 

    }
    //登錄
    @RequestMapping("/doLogin")
    protected ModelAndView doLogin(UserForm userForm){
        // request和response不必非要出現在方法中，如果用不上的話可以去掉
        // 支持參數為表單對象
        String account = userForm.getAccount();
        String password = userForm.getPassword();
        if(account.equals("")&&password.equals("")){
            return new ModelAndView(view.getLogin(),sI.dealNull());
        }
        else if(sI.doquery(account,password)){
            return new ModelAndView(view.getLoginSuccess(),sI.loginSuccess());
        }
        else{
            return new ModelAndView(view.getLogin(),sI.error());
        }
    }

    //注冊
    @RequestMapping("/doRegist")
    protected ModelAndView doRegist(UserForm userform){
        String account = userform.getAccount();
        String passFirst = userform.getPassFirst();
        String passSecond = userform.getPassSecond();
        String username = userform.getUsername();
        //判斷
        if(account.equals("")||passFirst.equals("")
                ||passSecond.equals("")||username.equals("")){
            return new ModelAndView(view.getRegist(),sI.intact());
        }
        else if(account.length()<4||passFirst.length()<4
                ||passSecond.length()<4){
            return new ModelAndView(view.getRegist(),sI.correct());
        }
        else if(!passFirst.equals(passSecond)){
            return new ModelAndView(view.getRegist(),sI.consistent());
        }

        else if(sI.queryAccount(account)){
            return new ModelAndView(view.getRegist(),sI.accountExist());
        }
        else if(sI.queryUsername(username)){
            return new ModelAndView(view.getRegist(),sI.usernameExist());
        }
        else{
            sI.insert(account,passFirst,username);
            return new ModelAndView(view.getRegistSuccess());
        }
    }
}

剩下的就只需配置Jsp頁面了，在篇一中已經配置

總結：

1）注解@Controller的基本目標是擔任所注解的類的原型的角色，指明它的職責。 Dispatcher將會在這樣被注解的類中掃描映射的方法，探測注解@RequestMapping

　  @Controller 只是定義了一個控制器類，而使用@RequestMapping 注解的方法才是真正處理請求的處理器.使用@Controller后就無需繼SimpleFormController

2）@Service用於標注業務層組件

     @Controller用於標注控制層組件（如struts中的action）

     @Repository用於標注數據訪問組件，即DAO組件

     @Component泛指組件，當組件不好歸類的時候，我們可以使用這個注解進行標注。

 

------本篇為筆者原創，若想轉載請在標題上標明，請尊重筆者勞動成果，謝謝！--------