《精通Spring4.x企业应用开发实战》第二章

　　昨天联系了一下学长，学长说这个项目因为种种原因代码比较混乱，感觉最坏的打算是从头开始写。

　　大概询问了一下学长和xianhua学姐的建议，又看了看网上的资料，这个项目开发的技术栈基本就是SpringBoot + vue + D3，SpringBoot做后端的东西，vue写个前端的东西，D3用来做知识图谱那个图比较好。

　　数据库的话应该要用Neo4j，应该还要加一个关系数据库。

　　

　　先花几天时间突击一下Spring，知乎上推荐这个书的比较多，源码先跑起来看看。废话不多说，从第二章开始看。

　　第二章主要要求做一个Spring的登录模块，首先要建立相应的数据库和表相关。

drop database if exists sampledb;
create database sampledb default character set utf8;
use sampledb;

#创建用户表
create table t_user (
    user_id int auto_increment primary key,
    user_name varchar(30),
    credits int,
    password varchar(32),
    last_visit datetime,
    last_ip varchar(23)
)engine = InnoDB;

#创建用户登录日志表
create table t_login_log (
    login_log_id int auto_increment primary key,
    user_id int,
    ip varchar(23),
    login_datatime datetime
)engine=InnoDB;

#插入初始化数据
insert into t_user (user_name, password) values ('admin', '123456');
commit;

　　为了编码的统一，将IDEA设置成统一的utf8编码。

　　

　　

　　

　　之后就是配置maven和创建项目的详细内容，由于这个博客的主要目的不在于详细记录每一个步骤（具体步骤可以参考书籍中内容），所以只对我觉得关键的步骤和内容进行笔记。

　　类包以分层的方式进行组织,共划分为4个包，分别是dao（持久层）、 domain（领域对象）、 service（业务层）和 web（展现层）。领域对象从严格意义上讲属于业务层，但由于领域对象可能同时被持久层和展现层共享，所以一般将其单独划分到一个包中

　　spring-context.xml是配置文件。

2.3持久层

2.3.1 建立领域对象

　　持久层负责数据的访问和操作，DAO类被上层的业务类调用。Spring 本身支持多种流行的ORM框架（第14章对此进行专门的讲解)，这里使用Spring JDBC作为持久层的实现技术（关于Spring JDBC的详细内容，请参见第13章)。为了方便阅读，我们会对本章涉及的相关知识点进行必要的介绍，所以在不了解Spring JDBC的情况下，相信读者也可以轻松阅读本章的内容。

　　领域对象(Domain Object)也被称为实体类，它代表了业务的状态，且贯穿展现层、业务层和持久层，并最终被持久化到数据库中。领域对象使数据库表操作以面向对象的方式进行，为程序扩展带来了更大的灵活性。领域对象不一定等同于数据库表，不过对于简单的应用来说，领域对象往往拥有对应的数据库表。

　　持久层的主要工作就是从数据库表中加载数据并实例化领域对象，或将领域对象持久化到数据库表中。论坛登录模块需要涉及两个领域对象: User 和 LoginLog，前者代表用户信息，后者代表日志信息，分别对应t_user和t_login_log 数据库表，领域对象类的包为com.smart.domain。

　　

　　

2.3.2 UserDao

　　首先来定义访问User的 DAO，它包括3个方法。

　　getMatchCount():根据用户名和密码获取匹配的用户数。等于1表示用户名/密码正确;等于0表示用户名或密码错误（这是最简单的用户身份认证方法，在实际应用中需要采用诸如密码加密等安全策略)。

　　findUserByUserName():根据用户名获取User对象。

　　updateLoginInfo():更新用户积分、最后登录IP及最后登录时间。下面通过Spring JDBC技术实现这个DAO类，如代码所示。

@Repository
public class UserDao {
    private JdbcTemplate jdbcTemplate;

    private  final static String MATCH_COUNT_SQL = " SELECT count(*) FROM t_user  " +
            " WHERE user_name =? and password=? ";

    public int getMatchCount(String userName, String password) {

        return jdbcTemplate.queryForObject(MATCH_COUNT_SQL, new Object[]{userName, password}, Integer.class);
    }

...

    @Autowired
    public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }
}

　　这里说明了两个注释的作用@Repository //通过Spring 注解定义一个DAO、@Autowired//自动注入 JdbcTemplate的 Bean .

　　传统的JDBC API太底层，即使用户执行一条最简单的数据查询操作，都必须执行如下过程:获取连接→创建Statement→执行数据操作→获取结果→关闭Statement→关闭结果集→关闭连接,除此之外还需要进行异常处理的操作。如果使用传统的JDBC API进行数据访问操作，则可能会产生1/3以上单调乏味的重复性代码。

　　Spring JDBC对传统的JDBC API进行了薄层封装，将样板式的代码和那些必不可少的代码进行了分离，用户仅需要编写那些必不可少的代码，剩余的那些单调乏味的重复性工作则交由Spring JDBC框架处理。简单来说，Spring JDBC通过一个模板类org.springframework.jdbc.core.JdbcTemplate封装了样板式的代码,用户通过模板类就可以轻松地完成大部分数据访问操作。

　　如getMatchCount()方法，我们仅提供了一个查询SQL语句，直接调用模板的queryForInt()方法就可以获取查询，用户不用担心获取连接、关闭连接、异常处理等烦琐的事务。

@Repository
public class UserDao {
    private JdbcTemplate jdbcTemplate;
    private  final static String UPDATE_LOGIN_INFO_SQL = " UPDATE t_user SET " +
            " last_visit=?,last_ip=?,credits=?  WHERE user_id =?";

    public User findUserByUserName(final String userName) {
        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 rs) throws SQLException {
                        user.setUserId(rs.getInt("user_id"));
                        user.setUserName(userName);
                        user.setCredits(rs.getInt("credits"));
                    }
                });
        return user;
    }

    public void updateLoginInfo(User user) {
        jdbcTemplate.update(UPDATE_LOGIN_INFO_SQL, new Object[] { user.getLastVisit(),
                user.getLastIp(),user.getCredits(),user.getUserId()});
    }

    @Autowired
    public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }
}

　　

　　findUserByUserName()方法稍微复杂一些。这里，我们使用了JdbcTemplate#query()方法，该方法的签名为query(String sql,  Object[]args, RowCallbackHandler rch)，它有3个入参。
　　sqlStr:查询的SQL语句，允许使用带“?”的参数占位符。
　　　　args: SQL语句中占位符对应的参数数组。
　　　　RowCallbackHandler:查询结果的处理回调接口，该回调接口有一个方法
　　　　processRow(ResultSet rs)，负责将查询的结果从ResultSet装载到类似于领域对象的对象实例中。
　　findUserByUserName()通过匿名内部类的方式定义了一个RowCallbackHandler回调接口实例，将ResultSet 转换为User对象。

　　updateLoginInfo()方法比较简单，主要通过JdbcTemplatc#update(String sql,Object[])进行数据的更新操作。

2.3.4在 Spring 中装配DAO
　　在编写DAO接口的实现类时，大家也许会有一个问题:在以上两个DAO 实现类中都没有打开/释放Connection的代码，DAO类究竟如何访问数据库呢﹖前面说过，样板式的操作都被JdbcTemplate封装起来了，JdbcTemplate本身需要一个DataSource，这样它就可以根据需要从DataSource中获取或返回连接。UserDao和 LoginLog 都提供了一个带@Autowired注解的JdbcTemplate变量，所以我们必须事先声明一个数据源，然后定义一个JdbcTemplate Bean，通过Spring 的容器上下文自动绑定机制进行Bean的注入。
　　在项目工程的src\resources(在Maven工程中，资源文件统一放置在resources文件夹中）目录下创建一个名为smart-context.xml的Spring配置文件，该配置文件的基本结构如下:

<?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">
　　　　...
</beans>

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

    <!-- 扫描类包，将标注Spring注解的类自动转化Bean，同时完成Bean的注入 -->
    <context:component-scan base-package="com.smart.dao"/>
    <context:component-scan base-package="com.smart.service"/>

    <!-- 配置数据源 -->
    <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>

　　我们使用Spring 的<context:component-scan>扫描指定类包下的所有类，这样在类中定义的Spring注解（如@Repository、@Autowired等）才能产生作用。

　　我们使用Jakarta 的 DBCP开源数据源实现方案定义了一个数据源，数据库驱动器类为com.mysql.jdbc.Driver。

　　配置了JdbcTemplate Bean，将声明的dataSource注入JdbcTemplate 中，而这个JdbcTemplate Bean将通过@Autowired自动注入LoginLog和UserDao 的Bean中，可见Spring可以很好地将注解配置和XML配置统一起来。

　　这样就完成了登录模块持久层所有的开发工作，接下来将着手业务层的开发和配置工作。我们将对业务层的业务类方法进行单元测试，到时就可以看到DAO的实际运行效果了，现在暂时把这两个DAO放在一边。

　　总结一下，访问User的 DAO，它包括3个方法：getMatchCount()，findUserByUserName()，updateLoginInfo()，LoginLogDao负责记录用户的登录日志，它仅有一个insertLoginLog()接口方法。

2.4业务层
　　在论坛登录实例中，业务层仅有一个业务类，即 UserService。UserService负责将持久层的UserDao和LoginLoginDao组织起来,完成用户/密码认证、登录日志记录等操作。

2.4.1 UserService
　　UserService 业务接口有3个业务方法，其中，hasMatchUser()方法用于检查用户名/密码的正确性;findUserByUserName()方法以用户名为条件加载User对象;loginSuccess(方法在用户登录成功后调用，更新用户最后登录时间和P信息，同时记录用户登录日志。
　　下面我们来实现这个业务类。UserService的实现类需要调用DAO层的两个DAO完成业务逻辑操作，如代码所示。

@Service
public class UserService {
    private UserDao userDao;
    private LoginLogDao loginLogDao;

    public boolean hasMatchUser(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.setUserId(user.getUserId());
        loginLog.setIp(user.getLastIp());
        loginLog.setLoginDate(user.getLastVisit());
        userDao.updateLoginInfo(user);
        loginLogDao.insertLoginLog(loginLog);
    }

    @Autowired
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    @Autowired
    public void setLoginLogDao(LoginLogDao loginLogDao) {
        this.loginLogDao = loginLogDao;
    }
}

　　首先通过@Service注解将UserService标注为一个服务层的Bean;然后通过@Autowired注入userDao和 loginLogDao 这两个DAO层的Bean;接着通过 hasMatchUser()和findUserByUserName()业务方法简单地调用DAO 完成对应的功能;最后为loginSuccess()方法标注@Transactional事务注解，让该方法运行在事务环境中（因为我们在 Spring事务管理器拦截切入表达式上加入了@Transactional过滤),否则该方法将在无事务方法中运行。loginSuccess()方法根据入参user对象构造出 LoginLog 对象并将user.credits递增5，即用户每登录一次赚取5个积分，然后调用userDao更新到t_user中，再调用loginLogDao向t_login_log表中添加一条记录。

　　loginSuccess()方法将两个DAO组织起来，共同完成一个事务性的数据操作:更新t_user表记录并添加t_login_log表记录。但我们从UserService中却看不出任何事务操作的影子，这正是Spring的高明之处，它让我们从事务操作单调、机械的代码中解脱出来，专注完成那些不可或缺的业务工作。通过Spring声明式事务配置即可让业务类享受EJB声明式事务的好处，下一节我们将了解如何赋予业务类事务管理的能力。

2.4.2 在 Spring 中装配Service
　　事务管理的代码虽然无须出现在程序代码中，但我们必须以某种方式告诉Spring哪些业务类需要工作在事务环境下及事务的规则等内容，以便Spring根据这些信息自动为目标业务类添加事务管理的功能。
打开原来的smart-context.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"
<!-- 1 -- >
    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"/>
　　<!-- 2 -->
　　<context:component-scan base-package="com.smart.service"/>

...

    <!-- 配置事务管理器 -->
　　 <!-- 3 -->

    <bean id="transactionManager"
        class="org.springframework.jdbc.datasource.DataSourceTransactionManager"
        p:dataSource-ref="dataSource" />
        
　　<!-- 4 -->
    <!-- 通过AOP配置提供事务增强，让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>
</beans>

　　①处在<beans>的声明处添加 aop和 tx命名空间的Schema定义文件的说明，这样，在配置文件中就可以使用这两个空间下的配置标签了。
　　②处将com.smart.service添加到上下文扫描路径中，以便使service包中类的Spring注解生效。
　　③处定义了一个基于数据源的DataSourceTransactionManager事务管理器，该事务管理器负责声明式事务的管理。该管理器需要引用dataSource Bean。
　　④处通过aop及tx命名空间的语法，以AOP的方式为com.smart.service包下所有类的所有标注@Transactional注解的方法都添加了事务增强，即它们都将工作在事务环境中（关于Spring事务的配置，详见第11章)。
　　这样就完成了业务层的程序开发和配置工作，接下来需要对该业务类进行简单的单元测试，以便检验业务方法的正确性。

2.4.3单元测试
　　TestNG和JUnit 相比有了重大的改进，本书示例所有的单元测试统一采用TestNG框架。请确保已经将TestNG依赖包添加到根模块pom.xml文件中。在 chapter2\srcltest测试目录下创建与UserService一致的包结构，即com.smart.service，并创建UserService对应的测试类UserServiceTest，编写如代码所示的测试代码。

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

    @Autowired
    private UserService userService;

    @Test
    public void testHasMatchUser() {
        boolean b1 = userService.hasMatchUser("admin", "123456");
        boolean b2 = userService.hasMatchUser("admin", "1111");
        assertTrue(b1);
        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);
    }
}

　　Spring 4.0的测试框架很好地整合了TestNG单元测试框架，示例UserServiceTest通过扩展Spring测试框架提供测试基类 AbstractTransactionalTestNGSpringContextTests来启动测试运行器。　　　　　　@ContextConfiguration也是Spring 提供的注解，用于指定Spring的配置文件。
　　可以使用Spring 的@Autowired 将Spring容器中的Bean注入测试类中。在测试方法前通过TestNG的@Test注解即可将方法标注为测试方法
　　在 IDEA 中执行当前测试类，通过右键菜单Run ‘UserServiceTest'来运行该测试用例，以检验业务类方法的正确性。

2.5展现层

　　业务层和持久层的开发任务已经完成，该是为程序提供界面的时候了。Spring4.0对MVC进行了全面增强，支持跨域注解@CrossOrigin 配置，Groovy Web集成，Gson、Jackson、Protobuf的 HttpMessageConverter消息转换器等,Spring MVC的功能更加丰富、强大(读者将在第18章学习到Spring MVC的详细内容)。

2.5.1配置Spring MVC框架
　　首先需要对web.xml文件进行配置,以便Web容器启动时能够自动启动Spring容器，如代码所示。

　　

　　

<?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">
　　<!-- 1-->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:smart-context.xml</param-value>
    </context-param>

　　<!-- 2-->
    <listener>
        <listener-class>
            org.springframework.web.context.ContextLoaderListener
        </listener-class>
    </listener>
　　
　　
　　<!-- 3 -->
    <servlet>
        <servlet-name>smart</servlet-name>
        <servlet-class>
            org.springframework.web.servlet.DispatcherServlet
        </servlet-class>
        <load-on-startup>3</load-on-startup>
    </servlet>
　　<!-- 4 -->
    <servlet-mapping>
        <servlet-name>smart</servlet-name>
        <url-pattern>*.html</url-pattern>
    </servlet-mapping>
</web-app>

　　然后通过Web容器上下文参数指定Spring 配置文件的地址，如①所示。多个配置文件可用逗号或空格分隔，建议采用逗号分隔的方式。然后在②处指定Spring所提供的ContextLoaderListener的Web容器监听器，该监听器在 Web容器启动时自动运行，它会根据contextConfigLocation Web容器参数获取 Spring配置文件，并启动Spring容器。注意，需要将log4J.propertis日志配置文件放置在类路径下,以便日志引擎自动生效。

　　最后需要配置Spring MVC 相关的信息。Spring MVC像 Struts一样，也通过一个Servlet来截获URL 请求，然后再进行相关的处理.

　　在3处声明了一个 Servlet, Spring MVC 也拥有一个Spring配置文件(稍后将涉及)，该配置文件的文件名和此处定义的Servlet名有一个契约,即使用<Servlet 名>-servlet.xml的形式。在这里,Servlet名为smart,则在/WEB-INF目录下必须提供一个名为smart-servlet.xml 的Spring MVC配置文件，但这个配置文件无须通过web.xml的contextConfigLocation上下文参数进行声明，因为Spring MVC 的 Servlet会自动将smart-servlet.xml文件和Spring 的其他配置文件(smart-dao.xml、smart-service.xml)进行拼装。

　　在4处对这个Servlet的URL路径映射进行定义，在这里让所有以.html为后缀的URL都能被smart Servlet截获，进而转由Spring MVC框架进行处理。我们知道，在Struts框架中一般将URL后缀配置为*.do，而在 WebWork 中一般配置为*.action。其实，框架本身和URL模式没有任何关系，用户大可使用喜欢的任何后缀。使用.html后缀，一方面，用户不能通过URL直接知道我们采用了何种服务器端技术;另一方面，.html是静态网页的后缀，可以骗过搜索引擎，增加被收录的概率，所以我们推荐采用这种后缀。对于那些真正无须任何动态处理的静态网页，则可以使用.htm后缀加以区分，以避免被框架截获。

　　请求被Spring MVC截获后，首先根据请求的URL查找到目标的处理控制器，并将请求参数封装“命令”对象一起传给控制器处理;然后，控制器调用Spring容器中的业务Bean完成业务处理工作并返回结果视图。

　

2.5.2处理登录请求
1. POJO控制器类。

　　首先需要编写的是LoginController，它负责处理登录请求，完成登录业务，并根据登录成功与否转向欢迎页面或失败页面。

//1
@Controller
public class LoginController{
    private UserService userService;
    
　　//2
    @RequestMapping(value = "/index.html")
    public String loginPage(){
        return "login";
    }
    
　　//3
    @RequestMapping(value = "/loginCheck.html")
    public ModelAndView loginCheck(HttpServletRequest request,LoginCommand loginCommand){
        boolean isValidUser =  userService.hasMatchUser(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");
        }
    }

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

　　在①处通过Spring MVC的@Controller注解可以将任何一个POJO的类标注为Spring MVC的控制器，处理HTTP的请求。当然，标注了@Controller 的类首先会是一个Bean，所以可以使用@Autowired进行 Bean的注入。

　　一个控制器可以拥有多个处理映射不同HTTP请求路径的方法，通过@RequestMapping指定方法如何映射请求路径，如②和③处所示。

　　请求参数会根据参数名称默认契约自动绑定到相应方法的入参中。例如，在③处的loginCheck(HttpServletRequest request,LoginCommand loginCommand)方法中，请求参数会按名称匹配绑定到loginCommand 的入参中。

　　请求响应方法可以返回一个ModelAndView，或直接返回一个字符串，Spring MVC会解析之并转向目标响应页面。ModelAndView对象既包括视图信息，又包括视图渲染所需的模型数据信息。在这里用户仅需要了解它代表一张视图即可，在后面的内容中，读者将了解到Spring MVC如何根据这个对象转向真正的页面。前面用到的LoginCommand对象是一个POJO，没有继承特定的父类或实现特定的接口。LoginCommand 类仅包括用户/密码这两个属性（和请求的用户/密码参数名称一样)。

　　在代码的②和③处，控制器根据登录处理结果分别返回 ModelAndView("login" , " error", "用户名或密码错误。")和 ModelAndView("main")。ModelAndView的第一个参数代表视图的逻辑名，第二、第三个参数分别为数据模型名称和数据模型对象，数据模型对象将以数据模型名称为参数名放置到request的属性中。

　　编写好LoginCommand后，需要在smart-servlet.xml中声明该控制器，扫描Web路径，指定Spring MVC的视图解析器。

<?xml version="1.0" encoding="UTF-8" ?>
<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="http://www.springframework.org/schema/beans"
       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/p ">
    <!-- 扫描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>

　　Spring MVC为视图名到具体视图的映射提供了许多可供选择的方法。在这里，我们使用InternalResourceViewResolver，它通过为视图逻辑名添加前、后缀的方式进行解析。如视图逻辑名为“login”，将解析为/WEB-INFjsp/login.jsp;视图逻辑名为“main”,将解析为/WEB-INF/jsp/main.jsp。

　　

2.5.3JSP视图页面

　　论坛登录模块共包括两个JSP页面，分别是登录页面login.jsp和欢迎页面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"%>
<html>
    <head>
        <title>小春论坛登录</title>
    </head>
    <body> 
　　　　　<!-- 1 -->
        <c:if test="${!empty error}">
            <font color="red"><c:out value="${error}" /></font>
        </c:if>
　　　　  <!-- 2 -->
        <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标签对登录错误返回的信息进行处理。在JSTL标签中引用了error变量,这个变量正是LoginController中返回的ModelAndView("login" , " error", "用户名或密码错误。")对象所声明的error参数。

　　login.jsp的登录表单提交到/loginController.html，如②所示。<c:url value="/loginController.html"/>的JSTL标签会在URL 前自动加上应用部署根目录。假设应用部署在网站的 bbt目录下，则<c:url>标签将输出/bbt/loginController.html。通过<c:url>标签很好地解决了开发和应用部署目录不一致的问题。
　　由于login.jsp放置在 WEB-INF/jsp目录下，无法直接通过URL进行调用，所以它由LoginController控制类中标注了@RequestMapping(value= "/index.html")的 loginPage()进行转发.