概述
本模块主要涉及以下部分：
- Maven构建web项目的过程
- 登录流程介绍
- 基于Spring JDBC的持久层实现
- 基于Spring 声明式事务的业务层实现
- 基于Spring MVC的展现层实现
- 运行Web应用
功能简介
用户访问login.jsp,返回带有用户名和密码输入框的登录页面
用户输入用户名和密码，提交表单到服务器，Spring根据配置文件调用LoginController控制器响应请求
LoginController调用UserService的hasMatchUser()方法来判断用户是否存在
如果用户不存在，跳转到登录页面，给出提示，否则进入下一步
如果用户存在，LoginController调用UserService的findUserByName方法，进行登录成功后的业务处理：首先调用updateLoginInfo的updateLoginInfo方法 增加5分积分，然后创建一个LoginLog对象，将LoginLog写入数据库
重定向到主页面，将响应返回给用户
环境准备
构建工具Maven
请参考上篇博文 Maven-EclipseEE使用Maven构建Java web项目从0到1
数据库脚本（Oracle）
-- Create table
create table TEMP_USER
(
user_id NUMBER not null,
user_name VARCHAR2(50),
password VARCHAR2(10),
credits NUMBER,
last_visit DATE,
last_ip VARCHAR2(20)
)
tablespace TAB_XGJ
pctfree 10
initrans 1
maxtrans 255
storage
(
initial 64K
minextents 1
maxextents unlimited
);
-- Create/Recreate primary, unique and foreign key constraints
alter table TEMP_USER
add constraint PK_USER_ID primary key (USER_ID)
using index
tablespace TAB_XGJ
pctfree 10
initrans 2
maxtrans 255;
-- Create sequence
create sequence TEMP_USER_ID_SEQ
minvalue 1
maxvalue 999999999
start with 1
increment by 1
cache 20;
-- Create table
create table TEMP_LOGIN_LOG
(
login_log_id NUMBER not null,
user_id NUMBER not null,
ip VARCHAR2(20),
login_datetime DATE
)
tablespace TAB_XGJ
pctfree 10
initrans 1
maxtrans 255
storage
(
initial 64K
minextents 1
maxextents unlimited
);
-- Create/Recreate primary, unique and foreign key constraints
alter table TEMP_LOGIN_LOG
add constraint PK_LOGIN_LOG_ID primary key (LOGIN_LOG_ID)
using index
tablespace TAB_XGJ
pctfree 10
initrans 2
maxtrans 255;
alter table TEMP_LOGIN_LOG
add constraint FK_USER_ID foreign key (USER_ID)
references TEMP_USER (USER_ID);
-- Create sequence
create sequence TEMP_LOGIN_LOG_ID_SEQ
minvalue 1
maxvalue 999999999
start with 1
increment by 1
cache 20;
--simulate data
INSERT INTO TEMP_USER (user_id,user_name,password)
VALUES(TEMP_USER_ID_SEQ.Nextval ,'xgj','123456');
COMMIT;
建立工程
请参考上篇博文 Maven-EclipseEE使用Maven构建Java web项目从0到1
类包及Spring配置文件规划
类包以分层的方式进行组织，供划分为dao、domain、service、web。
domain对象严格意义上讲属于业务层，但是由于domain对象可能同时被持久层和展现层共享，所以一般单独的将其划分在一个包中。
持久层
持久层负责数据的访问和操作，DAO类被上层的业务类调用。
这里使用Spring JDBC作为持久层的实现技术。
建立领域对象
领域对象Domain Object 也被称为实体类，它代表了业务的状态、且贯穿展现层、业务层和持久层，并追踪持久化到数据库中。
领域对象不一定等同于数据库表，但对于简单的应用来讲的话，领域对象往往拥有对应的数据库表。
持久层的主要工作是从数据库表中加载数据并实例化领域对象，或将领域对象持久化到数据库表中。
我们使用的案例中主要涉及两个领域对象 User 和 LoginLog, 分别对应 TEMP_USER 和 TEMP_LOGIN_LOG 表。
用户领域对象
可以看成对TEMP_USER表的对象映射，每个字段对应一个对象属性。
package com.xgj.domain;
import java.io.Serializable;
import java.util.Date;
/**
* @ClassName: User
* @Description: User实体类，可以简单的理解为对 temp_user表的字段映射
* @author: Mr.Yang
* @date: 2017年6月24日 下午6:45:12
*/
// 领域对象一般都要实现Serializable接口，以便可以序列化
public class User implements Serializable {
private int userId;
private String username;
private String password;
private int credit;
private Date lastVisit;
private String lastIP;
public int getUserId() {
return userId;
}
public void setUserId(int userId) {
this.userId = userId;
}
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;
}
public int getCredit() {
return credit;
}
public void setCredit(int credit) {
this.credit = credit;
}
public Date getLastVisit() {
return lastVisit;
}
public void setLastVisit(Date lastVisit) {
this.lastVisit = lastVisit;
}
public String getLastIP() {
return lastIP;
}
public void setLastIP(String lastIP) {
this.lastIP = lastIP;
}
}
登录日志领域对象
对TEMP_LOGIN_LOG 表的对象映射
package com.xgj.domain;
import java.io.Serializable;
import java.util.Date;
/**
*
* @ClassName: LoginLog
*
* @Description: 登录信息实体类，可以简单的理解为对 TEMP_LOGIN_LOG表的字段映射
*
* @author: Mr.Yang
*
* @date: 2017年6月24日 下午8:12:28
*
*
*/
//领域对象一般都要实现Serializable接口，以便可以序列化
public class LoginLog implements Serializable {
private int login_log_id;
private int user_id;
private String ip;
private Date login_datetime;
public int getLogin_log_id() {
return login_log_id;
}
public void setLogin_log_id(int login_log_id) {
this.login_log_id = login_log_id;
}
public int getUser_id() {
return user_id;
}
public void setUser_id(int user_id) {
this.user_id = user_id;
}
public String getIp() {
return ip;
}
public void setIp(String ip) {
this.ip = ip;
}
public Date getLogin_datetime() {
return login_datetime;
}
public void setLogin_datetime(Date login_datetime) {
this.login_datetime = login_datetime;
}
}
UserDao
首先来定义访问User的DAO。
按照设计，主要包括3个方法
- getMatchCount(String username,String passwd)
- findUserbyUsername(tring username)
- updateLoginInfo(User user) 更新用户积分、最后登录IP和最后登录时间
package com.xgj.dao;
import java.sql.ResultSet;
import java.sql.SQLException;
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 com.xgj.domain.User;
/**
*
* @ClassName: UserDao
*
* @Description: 定义访问User的DAO.操作TEMP_USER表
*
* @author: Mr.Yang
*
* @date: 2017年6月24日 下午8:19:34
*
*
*/
@Repository // 通过Spring注解定义一个DAO
public class UserDao {
private JdbcTemplate jdbcTemplate;
private final static String MATCH_COUNT_SQL = " SELECT count(*) FROM temp_user "
+ " WHERE user_name =? and password=? ";
private final static String UPDATE_LOGIN_INFO_SQL = " UPDATE temp_user SET "
+ " last_visit=?,last_ip=?,credits=? WHERE user_id =? ";
@Autowired // 自动注入JdbcTemplate的bean
public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
this.jdbcTemplate = jdbcTemplate;
}
/**
*
*
* @Title: getMatchCount
*
* @Description: 查询是否有匹配的user
*
* @param username
* @param password
*
* @return: int
*/
public int getMatchCount(String username, String password) {
return jdbcTemplate.queryForObject(MATCH_COUNT_SQL, new Object[] { username, password }, Integer.class);
}
/**
*
* @Title: findUserbyUsername
*
* @Description: 根据username查询用户信息
*
* @param username
*
* @return: User
*/
public User findUserbyUsername(final String username) {
String querySql = " SELECT user_id,user_name,credits " + " FROM temp_user WHERE user_name =? ";
final User user = new User();
// 根据username查询用户信息
jdbcTemplate.query(querySql, new Object[] { username }, new RowCallbackHandler() {
public void processRow(ResultSet rs) throws SQLException {
user.setUserId(rs.getInt("user_id"));
user.setUsername(username);
user.setCredit(rs.getInt("credits"));
}
});
return user;
}
/**
* @Title: updateLoginInfo
*
* @Description: updateLoginInfo
*
* @param user
*
* @return: void
*/
public void updateLoginInfo(User user) {
jdbcTemplate.update(UPDATE_LOGIN_INFO_SQL,
new Object[] { user.getLastVisit(), user.getLastIP(), user.getCredit(), user.getUserId() });
}
}
Spring 2.5之后可以使用注解的方式定义Bean，较之XML的配置方式，注解配置的方式更加简单明了，推荐使用。
通过@Repository定义一个DAO Bean，然后使用@Autowired将Spring容器中的Bean注入进来。
操作数据库使用Spring JDBC ，对传统的JDBC API进行了薄层封装。 Spring JDBC通过模板类
org.springframework.jdbc.core.JdbcTemplate封装了样板式的o码，用户可以很轻松的完成大部分数据访问操作。
LoginLogDao
LoginLogDao 负责记录用户的登录日志，仅仅有一个方法 insertLoginLog(LoginLog loginLog)
package com.xgj.dao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;
import com.xgj.domain.LoginLog;
@Repository // 通过Spring注解定义一个DAO
public class LoginLogDao {
private JdbcTemplate jdbcTemplate;
// 保存登陆日志SQL
private final static String INSERT_LOGIN_LOG_SQL = "INSERT INTO TEMP_LOGIN_LOG(login_log_id,user_id,ip,login_datetime) VALUES(TEMP_LOGIN_LOG_ID_SEQ.nextval,?,?,?)";
@Autowired // 自动注入JdbcTemplate的Bean
public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
this.jdbcTemplate = jdbcTemplate;
}
public void insertLoginLog(LoginLog loginLog) {
Object[] args = { loginLog.getUser_id(), loginLog.getIp(), loginLog.getLogin_datetime() };
jdbcTemplate.update(INSERT_LOGIN_LOG_SQL, args);
System.out.println("成功");
}
}
在Spring中装配DAO
我们在编写DAO接口实现类的时候，我们并没有看到打开、释放数据库connection的代码， 那DAO类是如何访问数据库的呢？
是的 JdbcTemplate封装起来了， JdbcTemplate 本身需要一个数据源DataSource，这样它就可以从DataSource中获取或者返回连接。
在UserDAO和LoginDAO都提供了一个带@Autowired注解的JdbcTemplate变量，所以我们必须先声明一个数据源，然后定义一个JdbcTemplate变量，通过Spring的容器上下文自动绑定机制注入bean.
Maven工程，在src\resources(资源文件目录），创建Spring的配置文件
<?xml version="1.0" encoding="UTF-8" ?>
<!--引用Spring的多个Schema空间的格式定义文件-->
<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.3.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-4.3.xsd
<!-- 扫描类包，将标注Spring注解的类自动转化Bean，同时完成Bean的注入 -->
<context:component-scan base-package="com.xgj.dao"/>
<!-- 配置数据源 http://langgufu.iteye.com/blog/2200588-->
<!-- mysql
<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" /> -->
<!-- oracle 两种写法
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
<property name="driverClassName" value="oracle.jdbc.driver.OracleDriver"/>
<property name="url" value="jdbc:oracle:thin:@172.25.246.11:1521:cc"/>
<property name="username" value="cctb"/>
<property name="password" value="zsmart2017"/>
</bean> -->
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
destroy-method="close"
p:driverClassName="oracle.jdbc.driver.OracleDriver"
p:url="jdbc:oracle:thin:@172.25.246.11:1521:cc"
p:username="cctb"
p:password="smart" />
<!-- 配置Jdbc模板 -->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"
p:dataSource-ref="dataSource" />
</beans>
- 我们使用
<context:component-scan base-package="目录名称"/>扫描指定类包下的所有类，这样在类中定义的注解比如@Respoitiry @Autowired等才会产生作用 - 我们使用Jakarta的DBCP开源数据实现方案定义一个数据源
- 配置 将 上一步的DataSource注入到JdbcTemplate中， 而这个JdbcTemplate将通过@Autowired自动注入到LoginDao和UserDao的Bean中， 可见Spring可以很好地将注解配置和XML配置统一起来。
这样 就完成了登录模块的持久层所有的开发工作
业务层
我们设计的登录模块，业务层仅有一个业务类 UserService。
UserService负责将持久层的UserDAO和LoginLogDao组织起来，完成用户密码认证、登录日志记录等操作。
UserService
三个业务方法
- boolean hasMatchUser(String username, String password)
- User findUserByName(String username)
- void loginSuccess(User user)
UserService的实现类需要调用DAO层的两个DAO完成业务逻辑操作。
package com.xgj.service;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import com.xgj.dao.LoginLogDao;
import com.xgj.dao.UserDao;
import com.xgj.domain.LoginLog;
import com.xgj.domain.User;
@Service // 将UserService标注为一个服务层的bean
public class UserService {
private UserDao userDao;
private LoginLogDao loginLogDao;
@Autowired // 注入bean
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
@Autowired // 注入bean
public void setLoginLogDao(LoginLogDao loginLogDao) {
this.loginLogDao = loginLogDao;
}
public boolean hasMatchUser(String username, String password) {
return userDao.getMatchCount(username, password) > 0;
}
public User findUserByName(String username) {
return userDao.findUserbyUsername(username);
}
@Transactional
public void loginSuccess(User user) {
// credit 增加5分
user.setCredit(5 + user.getCredit());
LoginLog loginLog = new LoginLog();
loginLog.setUser_id(user.getUserId());
loginLog.setIp(user.getLastIP());
loginLog.setLogin_datetime(user.getLastVisit());
userDao.updateLoginInfo(user);
loginLogDao.insertLoginLog(loginLog);
}
}
其中 loginSuccess方法将两个DAO组织起来，共同完成一个事务性的数据操作：更新temp_user表 并 添加temp_login_Log表的记录。
我们在UserService中看不出来任何事务操作的影子，这正是Spring的高明之处，通过注解和配置文件配置的方式，将我们从事务操作单调机械的代码中解脱出来。
下面我们来看下Spring是如何装载Service的
在Spring中装配Service
事务管理的代码虽然仅仅是以注解@Transactional的方式出现在程序代码中，但是我们必须告诉Spring哪些业务类需要工作在事务环境下以及事务的规则等，以方便Spring根据这些信息自动为目标业务类添加事务管理的功能。
<?xml version="1.0" encoding="UTF-8" ?>
<!--(1)引入aop以及tx命名空间和对应的Schema文件-->
<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.3.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-4.3.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx-4.3.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-4.3.xsd">
<context:component-scan base-package="com.xgj.dao"/>
<!-- 2）扫描类Service类包，将标注Spring注解的类自动转化Bean，同时完成Bean的注入 -->
<context:component-scan base-package="com.xgj.service"/>
<!-- 配置数据源 http://langgufu.iteye.com/blog/2200588-->
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
destroy-method="close"
p:driverClassName="oracle.jdbc.driver.OracleDriver"
p:url="jdbc:oracle:thin:@172.25.246.11:1521:cc"
p:username="cctb"
p:password="smart" />
<!-- 配置Jdbc模板 -->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"
p:dataSource-ref="dataSource" />
<!-- （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.xgj.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>
查看 （1）（2）（3）（4） 步骤以及说明。
这样就完成了业务层的程序开发和配置工作， 接下来需要对该业务类进行单元测试
使用TestNGN对业务类进行单元测试
TestNG和Junit相比有了重大的改进，我们在这里使用TestNGN使用单元测试。
步骤：
- 添加TestNGN依赖包到跟模块的pom.xml文件中
<dependency>
<groupId>org.testng</groupId>
<artifactId>testng</artifactId>
<version>${testng.version}</version>
<scope>test</scope>
</dependency>其中 版本为 6.8.7
<properties>
<testng.version>6.8.7</testng.version>
</properties>因本模块采用Maven构建 ，所以在约定目录下 src\test\java测试目录下创建和UserService一致的包结构，并创建UserService对应的测试类UserServiceTest ，目录如下：
编写测试代码
package com.xgj.service;
import java.util.Date;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.testng.AbstractTransactionalTestNGSpringContextTests;
import org.testng.annotations.Test;
import static org.testng.Assert.*;
import com.xgj.domain.User;
@ContextConfiguration("classpath*:/spring-context.xml")
public class UserServiceTest extends AbstractTransactionalTestNGSpringContextTests {
@Autowired
private UserService userService;
@Test
public void testHashUserMatch(){
boolean b1 = userService.hasMatchUser("xgj", "123456");
boolean b2 = userService.hasMatchUser("wrongname", "123456");
assertTrue(b1);
assertTrue(!b2);
}
@Test
public void testFindUserByUserName()throws Exception{
for(int i =0; i< 100;i++) {
User user = userService.findUserByName("xgj");
assertEquals(user.getUsername(), "xgj");
}
}
@Test
public void testAddLoginLog() {
User user = userService.findUserByName("xgj");
user.setUserId(1);
user.setUsername("xgj");
user.setLastIP("172.24.21.53");
user.setLastVisit(new Date());
userService.loginSuccess(user);
}
}
Spring4.0的测试框架很好的整合了TestNGN单元测试框架， 测试代码通过扩展Spring测试框架提供的测试基类AbstractTransactionTestNGSpringContextTests来启动测试运行器。
通过@ContextConfiguration注解来指定Spring的配置文件。
使用@Autowired 将Spring容器中的Bean注入到测试类中。
在测试方法前通过TestNGN的@Test注解方法即可将方法标注为测试方法。
- 运行测试类
选中项目，右键 Runas —Maven Test
观察运行结果，确保无错误。
展现层
我们已经开发完成了持久层和业务层 ，是时候提供一个简单的页面了~
在这里我们使用SpringMVC作为展现层的技术选择。
Spring3.0提供了REST风格的ＭＶＣ，使Spring MVC变的更加轻便、已用。
Spring4.0对MVC进行了全面的增强，支持跨域注解@CrossOrigin配置、GroovyWeb集成、Gson、Jackson、Protobuf的HttpMessageConverter消息转换器等。
配置Spring MVC 框架
- 配置web.xml，以便Web容器启动的时候能够自动启动Spring容器。
<?xml version="1.0" encoding="UTF-8"?>
<web-app
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_3_0.xsd"
version="3.0">
<display-name>Archetype Created Web Application</display-name>
<!--(1) 从类路径下加载Spring配置文件，classpath关键字-->
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:spring-context.xml</param-value>
</context-param>
<!--(2)负责启动Spring容器的监听器，它将引用（1）处的上下文参数获得Spring配置文件的地址 -->
<listener>
<listener-class>
org.springframework.web.context.ContextLoaderListener
</listener-class>
</listener>
....
</web-app>在（1）处通过web容器上线文参数指定Spring配置文件的地址，多个配置文件使用逗号或者空格分隔，建议逗号。
然后在（2）处指定Spring所提供的ContextLoaderListener的web容器监听器，该监听器活在web容器启动时自动运行，它会根据contextConfigLocationWeb容器参数获取Spring配置文件，并启动Spring容器。
注意需要将log4j.propertis日志配置文件放在类路径下，以便日志引擎自动生效。
最后需要配置SpringMVC相关的信息， SpringMVC也是通过一个Servlet来截取URL请求，然后再进行相关的处理
<!--(1)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>
<!--(2)Spring MVC 处理的URL-->
<servlet-mapping>
<servlet-name>smart</servlet-name>
<url-pattern>*.html</url-pattern>
</servlet-mapping>在（1）处生命了一个Servlet，Spring MVC 也拥有一个Spring配置文件（后面涉及），该配置文件的文件名称和此处定义的Servlet名有一个契约，即<Servlet名>-servlet.xml的形式.
在这里，我们定义的Servlet的名称为smart ,因此在/WEB-INF目录下必须提供一个名为smart-servlet.xml的Spring MVC 配置文件。但是这个配置文件无需通过web.xml的contextConfigLocation上下文参数进行声明， Spring MVC 会自动将smart-servlet.xml文件和Spring的其他配置文件进行拼装。
在（2）处对这个Servlet的URL路径进行定义，在这里让所有以.html为后缀的URL都能被smart Servlet截获， 进而转由Spring MVC框架进行处理。
这种方式的好处： 使用.html后缀 ，一方面用户不能通过URL直接指导我们采用了何种服务端技术，另一方面.html是静态网页的后缀，可以骗过搜索引擎，增加被收录的概率。 推荐采用这种后缀。
对已那些真正无需任何动态处理的静态网页，则可以使用.htm后缀加以区分，以避免被框架截获。
当请求被Spring MVC截获后，首先根据请求的URL来查找目标的处理控制器，并将请求参数封装“命令”对象一起传给控制器处理， 然后控制器调用Spring容器中的业务Bean完成业务处理工作并返回结果视图。
处理登录请求
POJO控制器类
首先编写LoginController类，负责处理登录请求，完成登录业务。
package com.xgj.web;
import java.util.Date;
import javax.servlet.http.HttpServletRequest;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.servlet.ModelAndView;
import com.xgj.domain.User;
import com.xgj.service.UserService;
//（1）标注称为Spring MVC的Controller
@RestController
public class LoginController{
private UserService userService;
// （2）负责处理 /index.html的请求
@RequestMapping(value = "/index.html")
public String loginPage(){
return "login";
}
// （3）负责处理 /loginCheck.html的请求
@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.findUserByName(loginCommand.getUserName());
user.setLastIP(request.getLocalAddr());
user.setLastVisit(new Date());
userService.loginSuccess(user);
request.getSession().setAttribute("user", user);
return new ModelAndView("main");
}
}
// 自动注入bean
@Autowired
public void setUserService(UserService userService) {
this.userService = userService;
}
}
在（1）处通过Spring ＭＶＣ的 @RestController（或者＠Controller）注解可以将任何一个POJO的类标注为Spring MVC的控制器，处理HTTP请求。 当然了 标注了 @RestController（或者＠Controller）首先是一个Bean，所以可以通过使用@Autowired进行Bean的注入。
一个控制器可以拥有多个处理映射不同HTTP请求路径的方法，比如（2）（3）。
请求参数会根据参数名称默认契约自动绑定到相应方法的入参中。 比如 在（3）中的loginCheck(HttpServletRequest request,LoginCommand loginCommand)方法中，请求参数会按照名称匹配到loginCommand的入参中。
请求响应方法可以返回一个ModelAndView，或者直接返回一个字符串，SoringMVC会解析并转向目标响应页面。
ModelAndView对象既包括视图信息，又包括视图渲染所需要的模型数据信息。
刚才提到的LoginCommand对象是一个POJO，没有继承特定的父类或者实现特定的接口。 LoginCommand仅仅包括用户名和密码这两个属性（和请求的用户密码参数名称一样）
package com.xgj.web;
public class LoginCommand {
private String userName;
private String password;
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
}
Spring MVC 配置文件
编写好LoginCommand后，需要在smart-servlet.xml中声明该控制器，扫描Web路径，指定SpringMVC的视图解析器。
<?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.3.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-4.3.xsd">
<!-- 扫描web包，应用Spring的注解 -->
<context:component-scan base-package="com.xgj.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>ModelAndView的解析配置
在LoginController 控制器类中
.....
return new ModelAndView("login", "error", "密码错误,请重新登录");
......
return new ModelAndView("main");ModelAndView的第一个参数代表视图的逻辑名，第二、第三个参数分别为数据模型名称和数据模型对象，数据模型对象将以数据模型名称为参数名放置到request的属性中
那么Spring是如何将视图逻辑名称解析为具体的视图页面呢？
同样的 我们需要在smart-servlet中提供一个定义解析规则的bean
<!-- 配置视图解析器，将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" />Spring MVC为视图名到具体视图的映射提供了需要到中方法，这里我们使用 InternalResourceViewResolver。
它通过为视图逻辑名添加前后缀的方式进行进行解析。
比如 逻辑视图名为 “login”,将根据配置解析为/WEB-INF/jsp/login.jsp ,同样的 逻辑视图名为“main”，将解析为/WEB-INF/jsp/main.jsp
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>
JSTL标签中中引用了 error变量正是LoginController中返回的 return new ModelAndView(“login”, “error”, “密码错误,请重新登录”); 对象所声明的error参数。
由于我们将 jsp放在了 WEB-INF/jsp目录下，所以无法通过URL直接访问，必须通过LoginController控制类中标注了@RequestMapping(value = “/index.html”)的loginPage()方法进行转发。
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.credit};
</body>
</html>main页面 仅适用JSTL标签显示一条欢迎信息。
运行Web应用
第一种方式 maven插件部署web应用服务器
这里我们使用jetty服务器插件，首先在pom.xml中配置插件
<!-- 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>8080</port>
<maxIdleTime>60000</maxIdleTime>
</connector>
</connectors>
<contextPath>/${project.artifactId}</contextPath>
<scanIntervalSeconds>5</scanIntervalSeconds>
</configuration>
</plugin>运行： 选中项目，右键 Run as - Run Jetty
http://localhost:8080/hello-spring4/index.html
第二种方式 部署到容器中
在eclipse中配置 Tomcat 容器，然后
选中项目，右键 Run as - Run on Server
同样可以达到访问的目的
总结
虽然是一个小的登录模块，重点是体会开发的过程，使用Spring MVC、SpringJDBC、Spring声明式事务等技术。
附件 pom.xml
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.xgj</groupId>
<artifactId>hello-spring4</artifactId>
<packaging>war</packaging>
<version>0.0.1-SNAPSHOT</version>
<name>hello-spring4 Maven Webapp</name>
<url>http://maven.apache.org</url>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>3.8.1</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>${servlet.version}</version>
<scope>provided</scope>
</dependency>
<!-- spring 依赖 -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-beans</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context-support</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>commons-dbcp</groupId>
<artifactId>commons-dbcp</artifactId>
<version>${commons-dbcp.version}</version>
</dependency>
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>${aspectj.version}</version>
</dependency>
<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>
<!-- 添加oracle jdbc driver -->
<dependency>
<groupId>com.oracle</groupId>
<artifactId>ojdbc6</artifactId>
<version>${oracle.version}</version>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>jstl</artifactId>
<version>${jstl.version}</version>
</dependency>
</dependencies>
<build>
<finalName>hello-spring4</finalName>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.1</version>
<configuration>
<source>1.7</source>
<target>1.7</target>
</configuration>
</plugin>
<!-- 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>8080</port>
<maxIdleTime>60000</maxIdleTime>
</connector>
</connectors>
<contextPath>/${project.artifactId}</contextPath>
<scanIntervalSeconds>5</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>
<properties>
<file.encoding>UTF-8</file.encoding>
<spring.version>4.3.9.RELEASE</spring.version>
<servlet.version>3.1.0</servlet.version>
<aspectj.version>1.8.1</aspectj.version>
<commons-dbcp.version>1.4</commons-dbcp.version>
<jetty.version>8.1.8.v20121106</jetty.version>
<slf4j.version>1.7.5</slf4j.version>
<testng.version>6.8.7</testng.version>
<oracle.version>11.2.0.4.0</oracle.version>
<jstl.version>1.2</jstl.version>
</properties>
</project>
本文标题：Spring-Spring MVC + Spring JDBC + Spring Transaction + Maven 构建web登录模块
本文链接：https://blog.quwenai.cn/post/6148.html
版权声明：本文不使用任何协议授权，您可以任何形式自由转载或使用。
还没有评论，来说两句吧...