架构实例之SpringTest

1、开发工具和开发环境

      开发工具： MyEclipse10，JDK1.6.0_13(32位)，Tomcat7.0（32位），mysql5.7.13

开发环境：WIN7

2、SpringTest实现功能

用户登录、用户注册、退出登录。

3、SpringTest使用技术

      本实例使用了JSP、Spring3.1框架、JdbcTemplate来实现用户登录、用户注册和退出登录功能。系统架构图如图一所示：

 

图一：SpringTest系统架构图

4、具体实现

(1)在MyEclipse中新建一个Web项目，并命名为SpringTest。项目建立完成后，鼠标选择该项目并点击右键选择MyEclipse选项，再选择Add Spring Capabilities选项，再选择Spring3.1Core Libraries，最后点击finish按钮即可初步完成Spring框架环境搭建；

（2）在src中会自动生成一个appllicaitonContext.xml文件，此处把该文件放到WebRoot/WEB-INF目录下，并把该文件重新命名为spring-servlet.xml；

（3）在WebRoot/WEB-INF/lib下放入以下三个jar包spring.jar、mysql-connector-java-5.0.8-bin.jar、commons-dbcp.jar，此处即可完成本项目的所有玩家搭建，接下来就是具体代码的书写；

（4）首先，完成web.xml中的相关配置，具体代码如下：

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <web-app version="3.0"
  3.     xmlns="http://java.sun.com/xml/ns/javaee"
  4.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  5.     xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
  6.     http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd">
  7.   <display-name></display-name>    
  8.  
  9.   <filter>
  10.         <filter-name>encodingFilter</filter-name>
  11.         <filter-class>
  12.             org.springframework.web.filter.CharacterEncodingFilter
  13.         </filter-class>
  14.         <init-param>
  15.             <param-name>encoding</param-name>
  16.             <param-value>UTF-8</param-value>
  17.         </init-param>
  18.     </filter>
  19.     <filter-mapping>
  20.         <filter-name>encodingFilter</filter-name>
  21.         <url-pattern>*.do</url-pattern>
  22.     </filter-mapping>
  23.     <servlet>
  24.         <servlet-name>spring</servlet-name>
  25.         <servlet-class>
  26.             org.springframework.web.servlet.DispatcherServlet
  27.         </servlet-class>
  28.         <load-on-startup>1</load-on-startup>
  29.     </servlet>
  30.     <servlet-mapping>
  31.         <servlet-name>spring</servlet-name>
  32.         <url-pattern>*.do</url-pattern>
  33.     </servlet-mapping> 
  34.  
  35.   <welcome-file-list>
  36.     <welcome-file>index.jsp</welcome-file>
  37.   </welcome-file-list>
  38. </web-app

（5）接下来，就是spring-servlet.xml中的相关配置，具体代码如下：

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans
  3.     xmlns="http://www.springframework.org/schema/beans"
  4.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  5.     xmlns:p="http://www.springframework.org/schema/p"
  6.     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd">
  7.  
  8.    <!--  配置数据源与事务 -->
  9.     <bean id="dataSource"
  10.         class="org.apache.commons.dbcp.BasicDataSource"
  11.         destroy-method="close">
  12.         <property name="driverClassName">
  13.             <value>com.mysql.jdbc.Driver</value>
  14.         </property>
  15.         <property name="url">
  16.             <value>jdbc:mysql://localhost:3306/demo_test</value>
  17.         </property>
  18.         <property name="username">
  19.             <value>root</value>
  20.         </property>
  21.         <property name="password">
  22.             <value>root</value>
  23.         </property>
  24.     </bean>
  25.     <bean id="transactionManager"
  26.         class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
  27.         <property name="dataSource">
  28.             <ref local="dataSource" />
  29.         </property>
  30.     </bean>
  31.  
  32.     <!-- 定义DAO -->
  33.     <bean id="userDAO" class="com.liu.spring.dao.UserDAO">
  34.         <property name="dataSource">
  35.             <ref local="dataSource" />
  36.         </property>
  37.     </bean>
  38.     <bean id="UserDAOProxy"
  39.         class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
  40.         <property name="transactionManager">
  41.             <ref bean="transactionManager" />
  42.         </property>
  43.         <property name="target">
  44.             <ref local="userDAO" />
  45.         </property>
  46.         <property name="transactionAttributes">
  47.             <props>
  48.                 <prop key="insert*">PROPAGATION_REQUIRED</prop>
  49.                 <prop key="*">PROPAGATION_REQUIRED,readOnly</prop>
  50.             </props>
  51.         </property>
  52.     </bean>
  53.  
  54.       <!-- 定义视图 -->
  55.     <bean id="viewResolver"
  56.         class="org.springframework.web.servlet.view.InternalResourceViewResolver">
  57.         <property name="viewClass">
  58.             <value>
  59.                 org.springframework.web.servlet.view.InternalResourceView
  60.             </value>
  61.         </property>
  62.         <!-- JSP都放在/目录下 -->
  63.         <property name="prefix">
  64.             <value>/</value>
  65.         </property>
  66.         <!-- JSP页面的后缀都四.JSP -->
  67.         <property name="suffix">
  68.             <value>.jsp</value>
  69.         </property>
  70.     </bean>
  71.  
  72.     <!-- 定义映射 -->
  73.     <bean id="loginMapping"
  74.         class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
  75.         <property name="mappings">
  76.             <props>
  77.                 <prop key="/login.do">loginAction</prop>
  78.             </props>
  79.         </property>
  80.     </bean>
  81.     <bean id="logoutMapping"
  82.         class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
  83.         <property name="mappings">
  84.             <props>
  85.                 <prop key="/logout.do">logoutAction</prop>
  86.             </props>
  87.         </property>
  88.     </bean>
  89.     <bean id="registerMapping"
  90.         class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
  91.         <property name="mappings">
  92.             <props>
  93.                 <prop key="/register.do">registerAction</prop>
  94.             </props>
  95.         </property>
  96.     </bean>
  97.  
  98.     <!---定义Action-->
  99.     <bean id="loginAction"
  100.         class="com.liu.spring.actions.LoginAction">
  101.         <property name="commandClass">
  102.             <value>com.liu.spring.forms.LoginForm</value>
  103.         </property>
  104.         <!-- 指定DAO类 -->
  105.         <property name="userDAO">
  106.             <ref local="userDAO" />
  107.         </property>
  108.         <!-- 指定失败要返回的页面 -->
  109.         <property name="formView">
  110.             <value>login</value>
  111.         </property>
  112.         <!-- 指定成功要返回的页面 -->
  113.         <property name="successView">
  114.             <value>welcome</value>
  115.         </property>
  116.     </bean>
  117.     <bean id="logoutAction"
  118.         class="com.liu.spring.actions.LogoutAction">
  119.         <property name="commandClass">
  120.             <value>com.liu.spring.forms.LoginForm</value>
  121.         </property>
  122.         <property name="successView">
  123.             <value>login</value>
  124.         </property>
  125.     </bean>
  126.     <bean id="registerAction"
  127.         class="com.liu.spring.actions.RegisterAction">
  128.         <property name="commandClass">
  129.             <value>com.liu.spring.forms.RegisterForm</value>
  130.         </property>
  131.         <!-- 指定DAO类 -->
  132.         <property name="userDAO">
  133.             <ref local="userDAO" />
  134.         </property>
  135.         <!-- 指定失败要返回的页面 -->
  136.         <property name="formView">
  137.             <value>register</value>
  138.         </property>
  139.         <property name="successView">
  140.             <value>login</value>
  141.         </property>
  142.     </bean>
  143.  
  144. </beans>

（6）用户登录、注册表单类具体代码：

用户登录表单类代码如下：

  1. package com.liu.spring.forms;
  2.  
  3. public class LoginForm {
  4.     private String username;
  5.  
  6.     private String password;
  7.  
  8.     public String getPassword() {
  9.         return password;
  10.     }
  11.  
  12.     public void setPassword(String password) {
  13.         this.password = password;
  14.     }
  15.  
  16.     public String getUsername() {
  17.         return username;
  18.     }
  19.  
  20.     public void setUsername(String username) {
  21.         this.username = username;
  22.     }
  23.  
  24. }

用户注册表单类代码如下：

  1. package com.liu.spring.forms;
  2.  
  3. public class RegisterForm {
  4.     private String username;
  5.  
  6.     private String password1;
  7.  
  8.     private String password2;
  9.  
  10.     private String email;
  11.  
  12.     public String getEmail() {
  13.         return email;
  14.     }
  15.  
  16.     public void setEmail(String email) {
  17.         this.email = email;
  18.     }
  19.  
  20.     public String getPassword1() {
  21.         return password1;
  22.     }
  23.  
  24.     public void setPassword1(String password1) {
  25.         this.password1 = password1;
  26.     }
  27.  
  28.     public String getPassword2() {
  29.         return password2;
  30.     }
  31.  
  32.     public void setPassword2(String password2) {
  33.         this.password2 = password2;
  34.     }
  35.  
  36.     public String getUsername() {
  37.         return username;
  38.     }
  39.  
  40.     public void setUsername(String username) {
  41.         this.username = username;
  42.     }
  43. }

（7）用户登录、注册、退出Action类具体代码：

用户登录Action类代码

  1. package com.liu.spring.actions;
  2.  
  3. import java.util.Map;
  4.  
  5. import javax.servlet.http.HttpServletRequest;
  6. import javax.servlet.http.HttpServletResponse;
  7.  
  8. import org.springframework.validation.BindException;
  9. import org.springframework.web.servlet.ModelAndView;
  10. import org.springframework.web.servlet.mvc.SimpleFormController;
  11.  
  12. import com.liu.spring.dao.UserDAO;
  13. import com.liu.spring.forms.LoginForm;
  14. import com.liu.spring.util.Constants;
  15.  
  16. public class LoginAction extends SimpleFormController {
  17.     UserDAO userDAO;    
  18.  
  19.     public UserDAO getUserDAO() {
  20.         return userDAO;
  21.     }
  22.  
  23.     public void setUserDAO(UserDAO userDAO) {
  24.         this.userDAO = userDAO;
  25.     }
  26.  
  27.     protected ModelAndView onSubmit(HttpServletRequest request,
  28.             HttpServletResponse response, Object command, BindException errors)
  29.             throws Exception {
  30.         LoginForm loginForm = (LoginForm) command;
  31.         if (isValid(loginForm)) {
  32.             request.getSession().setAttribute(Constants.USERNAME_KEY, loginForm.getUsername());
  33.             return new ModelAndView(getSuccessView());
  34.         } else {
  35.             @SuppressWarnings("unchecked")
  36.             Map<String, Object> modle = errors.getModel();
  37.             modle.put("loginForm", loginForm);
  38.             return new ModelAndView(getFormView(), modle);
  39.         }
  40.     }
  41.  
  42.     public boolean isValid(LoginForm loginForm) {
  43. //        if (loginForm.getUsername().equals("admin")
  44. //                && loginForm.getPassword().equals("admin")) {
  45. //            return true;
  46. //        } else {
  47. //            return false;
  48. //        }
  49.  
  50.         if(userDAO.isValid(loginForm.getUsername(), loginForm.getPassword())) {
  51.             return true;
  52.         } else {
  53.             return false;
  54.         }
  55.     }
  56. }

其中，用户登录中使用了一个USERNAME_KEY字段，此处单独建立一个Constants类来实现，具体代码如下：

  1. package com.liu.spring.util;
  2.  
  3. public class Constants {
  4.     public final static String USERNAME_KEY = "username";
  5.  
  6. }

用户注册Action类代码

  1. package com.liu.spring.actions;
  2.  
  3. import java.util.Map;
  4.  
  5. import javax.servlet.http.HttpServletRequest;
  6. import javax.servlet.http.HttpServletResponse;
  7.  
  8. import org.springframework.validation.BindException;
  9. import org.springframework.web.servlet.ModelAndView;
  10. import org.springframework.web.servlet.mvc.SimpleFormController;
  11.  
  12. import com.liu.spring.dao.User;
  13. import com.liu.spring.dao.UserDAO;
  14. import com.liu.spring.forms.RegisterForm;
  15.  
  16. public class RegisterAction extends SimpleFormController {
  17.  
  18.     UserDAO userDAO;
  19.  
  20.     public UserDAO getUserDAO() {
  21.         return userDAO;
  22.     }
  23.  
  24.     public void setUserDAO(UserDAO userDAO) {
  25.         this.userDAO = userDAO;
  26.     }
  27.  
  28.     public ModelAndView onSubmit(HttpServletRequest request,
  29.             HttpServletResponse response, Object command, BindException errors)
  30.             throws Exception {
  31.         String method = request.getParameter("method");
  32.         if (method == null || method.equals("init")) {
  33.             return init(command, errors);
  34.         } else if (method.equals("register")) {
  35.             return register(request, response, command, errors);
  36.         } else {
  37.             RegisterForm registerForm = (RegisterForm) command;
  38.             @SuppressWarnings("unchecked")
  39.             Map<String, Object> modle = errors.getModel();
  40.             modle.put(getFormSessionAttributeName(), registerForm);
  41.             return new ModelAndView(getSuccessView(), modle);
  42.         }
  43.     }
  44.  
  45.     public ModelAndView init(Object command, BindException errors)
  46.             throws Exception {
  47.         RegisterForm registerForm = (RegisterForm) command;
  48.         @SuppressWarnings("unchecked")
  49.         Map<String, Object> modle = errors.getModel();
  50.         modle.put(getFormSessionAttributeName(), registerForm);
  51.         return new ModelAndView(getFormView(), modle);
  52.     }
  53.  
  54.     public ModelAndView register(HttpServletRequest request,
  55.             HttpServletResponse response, Object command, BindException errors)
  56.             throws Exception {
  57.         RegisterForm registerForm = (RegisterForm) command;
  58.         if (!isExist(registerForm)) {
  59.             add(registerForm);
  60.             @SuppressWarnings("unchecked")
  61.             Map<String, Object> modle = errors.getModel();
  62.             modle.put(getSuccessView(), registerForm);
  63.             response.sendRedirect("login.do");
  64.             return null;
  65.             //return new ModelAndView(getSuccessView(), modle);
  66.         } else {
  67.             @SuppressWarnings("unchecked")
  68.             Map<String, Object> modle = errors.getModel();
  69.             modle.put(getFormSessionAttributeName(), registerForm);
  70.             return new ModelAndView(getFormView(), modle);
  71.         }
  72.     }
  73.  
  74.     public boolean isExist(RegisterForm registerForm) {
  75. //        if (registerForm.getUsername().equals("admin")) {
  76. //         return true;
  77. //         } else {
  78. //         return false;
  79. //         }
  80.         if (userDAO.isExist(registerForm.getUsername())) {
  81.             return true;
  82.         } else {
  83.             return false;
  84.         }
  85.     }
  86.  
  87.     public void add(RegisterForm registerForm) {
  88.         User user = new User();
  89.         user.setUsername(registerForm.getUsername());
  90.         user.setPassword(registerForm.getPassword1());
  91.         user.setEmail(registerForm.getEmail());
  92.         userDAO.insertUser(user);
  93.     }
  94. }

用户退出Action类代码

  1. package com.liu.spring.actions;
  2.  
  3. import javax.servlet.http.HttpServletRequest;
  4. import javax.servlet.http.HttpServletResponse;
  5.  
  6. import org.springframework.validation.BindException;
  7. import org.springframework.web.servlet.ModelAndView;
  8. import org.springframework.web.servlet.mvc.SimpleFormController;
  9.  
  10. public class LogoutAction extends SimpleFormController {
  11.  
  12.     protected ModelAndView onSubmit(HttpServletRequest request,
  13.             HttpServletResponse response, Object command, BindException errors)
  14.             throws Exception {
  15.         request.getSession().invalidate();
  16.         response.sendRedirect("login.do");
  17.         return null;
  18.         //return new ModelAndView(getSuccessView());
  19.     }
  20. }

（8）用户登录和注册进行数据库验证类代码

使用JDBCTemplate完成POJO类User类的创建，具体代码如下：

  1. package com.liu.spring.dao;
  2.  
  3. public class User {
  4. protected String id;
  5.  
  6.     protected String username;
  7.  
  8.     protected String password;
  9.  
  10.     protected String email;
  11.  
  12.     public String getEmail() {
  13.         return email;
  14.     }
  15.  
  16.     public void setEmail(String email) {
  17.         this.email = email;
  18.     }
  19.  
  20.     public String getId() {
  21.         return id;
  22.     }
  23.  
  24.     public void setId(String id) {
  25.         this.id = id;
  26.     }
  27.  
  28.     public String getPassword() {
  29.         return password;
  30.     }
  31.  
  32.     public void setPassword(String password) {
  33.         this.password = password;
  34.     }
  35.  
  36.     public String getUsername() {
  37.         return username;
  38.     }
  39.  
  40.     public void setUsername(String username) {
  41.         this.username = username;
  42.     }
  43.  
  44. }

使用JDBCTemplate完成数据操作类UserDAO类的创建，具体代码如下：

  1. package com.liu.spring.dao;
  2.  
  3. import java.sql.ResultSet;
  4. import java.sql.SQLException;
  5. import java.util.ArrayList;
  6. import java.util.List;
  7.  
  8. import javax.sql.DataSource;
  9.  
  10. import org.springframework.jdbc.core.JdbcTemplate;
  11. import org.springframework.jdbc.core.RowMapper;
  12.  
  13. public class UserDAO {
  14.     private DataSource dataSource;
  15.  
  16.     public DataSource getDataSource() {
  17.         return dataSource;
  18.     }
  19.  
  20.     public void setDataSource(DataSource dataSource) {
  21.         this.dataSource = dataSource;
  22.     }
  23.  
  24.     public boolean isValid(String username, String password) {
  25.         @SuppressWarnings("rawtypes")
  26.         List userList = new ArrayList();
  27.         JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
  28.         userList = jdbcTemplate.query("SELECT * FROM userInfo WHERE username='"
  29.                 + username + "' and password='" + password + "'",
  30.                 new RowMapper() {
  31.                     public Object mapRow(ResultSet rs, int rowNum)
  32.                             throws SQLException {
  33.                         User user = new User();
  34.                         user.setId(rs.getString("ID"));
  35.                         user.setUsername(rs.getString("username"));
  36.                         user.setPassword(rs.getString("password"));
  37.                         user.setEmail(rs.getString("email"));
  38.                         return user;
  39.                     }
  40.                 });
  41.         if (userList.size() > 0) {
  42.             return true;
  43.         } else {
  44.             return false;
  45.         }
  46.     }
  47.  
  48.     public boolean isExist(String username) {
  49.         JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
  50.         int count = jdbcTemplate.queryForInt("SELECT count(*) FROM userInfo WHERE username='" + username
  51.                 + "'");
  52.         if (count > 0) {
  53.             return true;
  54.         } else {
  55.             return false;
  56.         }
  57.     }
  58.  
  59.     public void insertUser(User user) {
  60.         String username = user.getUsername();
  61.         String password = user.getPassword();
  62.         String email = user.getEmail();
  63.         JdbcTemplate jt = new JdbcTemplate(getDataSource());
  64.         jt.update("insert into userInfo(username,password,email) values ('"
  65.                 + username + "','" + password + "','" + email + "');");
  66.     }
  67. }

（9）视图层用户登录，用户注册和登录成功后JSP界面代码

用户登录JSP页面代码（login.jsp）

  1. <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
  2. <%
  3. String path = request.getContextPath();
  4. String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
  5. %>
  6.  
  7. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
  8. <html>
  9.   <head>
  10.     <base href="<%=basePath%>">
  11.  
  12.     <title>My JSP 'login.jsp' starting page</title>
  13.  
  14.     <meta http-equiv="pragma" content="no-cache">
  15.     <meta http-equiv="cache-control" content="no-cache">
  16.     <meta http-equiv="expires" content="0">
  17.     <meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
  18.     <meta http-equiv="description" content="This is my page">
  19.     <!--
  20.     <link rel="stylesheet" type="text/css" href="styles.css">
  21.     -->
  22.  
  23.   </head>
  24.  
  25.   <body>
  26.     <form name="form1" action="login.do" method="post">
  27. <table width="200" border="1">
  28.     <tr>
  29.         <td colspan="2">登录窗口</td>
  30.     </tr>
  31.     <tr>
  32.         <td>用户名</td>
  33.         <td><input type="text" name="username" size="10"></td>
  34.     </tr>
  35.     <tr>
  36.         <td>密码</td>
  37.         <td><input type="password" name="password" size="10"></td>
  38.     </tr>
  39.     <tr>
  40.         <td colspan="2"><input type="submit" name="submit" value="登录"> <a
  41.             href="register.do?method=init">注册新用户</a></td>
  42.     </tr>
  43. </table>
  44. </form>
  45.  
  46.   </body>
  47. </html>

用户注册JSP页面代码（register.jsp）

  1. <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
  2. <%String path = request.getContextPath();
  3.             String basePath = request.getScheme() + "://"
  4.                     + request.getServerName() + ":" + request.getServerPort()
  5.                     + path + "/";
  6. %>
  7.  
  8. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
  9. <html>
  10. <head>
  11. <base href="<%=basePath%>">
  12.  
  13. <title>My JSP 'register.jsp' starting page</title>
  14.  
  15. <meta http-equiv="pragma" content="no-cache">
  16. <meta http-equiv="cache-control" content="no-cache">
  17. <meta http-equiv="expires" content="0">
  18. <meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
  19. <meta http-equiv="description" content="This is my page">
  20.  
  21. <!--
  22.     <link rel="stylesheet" type="text/css" href="styles.css">
  23.     -->
  24. </head>
  25.  
  26. <body>
  27. <form name="form1" action="register.do?method=register" method="post">
  28. <table width="200" border="1">
  29.     <tr>
  30.         <td colspan="2">注册窗口</td>
  31.     </tr>
  32.     <tr>
  33.         <td>用户名</td>
  34.         <td><input type="text" name="username" size="10"></td>
  35.     </tr>
  36.     <tr>
  37.         <td>密码</td>
  38.         <td><input type="password" name="password1" size="10"></td>
  39.     </tr>
  40.     <tr>
  41.         <td>确认密码</td>
  42.         <td><input type="password" name="password2" size="10"></td>
  43.     </tr>
  44.     <tr>
  45.         <td>Email</td>
  46.         <td><input type="text" name="email" size="10"></td>
  47.     </tr>
  48.     <tr>
  49.         <td colspan="2"><input type="submit" name="submit" value="登录"> <a
  50.             href="login.do">返回</a></td>
  51.     </tr>
  52. </table>
  53. </form>
  54.  
  55. </body>
  56. </html>

登录成功后JSP页面代码（welcome.jsp）

  1. <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
  2. <%
  3. String path = request.getContextPath();
  4. String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
  5. %>
  6.  
  7. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
  8. <html>
  9.   <head>
  10.     <base href="<%=basePath%>">
  11.  
  12.     <title>My JSP 'welcome.jsp' starting page</title>
  13.  
  14.     <meta http-equiv="pragma" content="no-cache">
  15.     <meta http-equiv="cache-control" content="no-cache">
  16.     <meta http-equiv="expires" content="0">
  17.     <meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
  18.     <meta http-equiv="description" content="This is my page">
  19.     <!--
  20.     <link rel="stylesheet" type="text/css" href="styles.css">
  21.     -->
  22.  
  23.   </head>
  24.  
  25.   <body>
  26.     <form name="form1" action="logout.do" method="post">
  27.         <table width="200" border="1">
  28.             <tr>
  29.                 <td colspan="2">登录成功</td>
  30.             </tr>
  31.             <tr>
  32.                 <td>欢迎你，</td>
  33.                 <td><%=(String) session.getAttribute("username")%></td>
  34.             </tr>
  35.             <tr>
  36.                 <td colspan="2"><input type="submit" name="submit" value="退出"></td>
  37.             </tr>
  38.         </table>
  39.         </form>
  40.   </body>
  41. </html>

5、运行结果

开启Tomcat服务后，打开浏览器输入：http://localhost:8080/SpringTest/login.jsp，将会出现下图二所示结果：

图二：用户登录界面

点击注册新用户，将会出现以下图三所示结果（点击登陆，如果注册成功就会返回到登陆界面，如果未成功则保留在注册界面）：

图三：用户注册界面

用上图中注册的账号进行登陆，登陆成功后出现下图四所示结果：

图四：用户登陆成功后界面

PS：本项目具体源码GitHub链接：https://github.com/miaomiaoqiushui/SpringTest

架构实例之SpringTest的更多相关文章

  1. 架构实例之Demo_JSP_JavaBean_Servlet

    架构实例之Demo_JSP_JavaBean_Servlet 1.开发工具和开发环境       开发工具: MyEclipse10,JDK1.6.0_13(32位),Tomcat7.0(32位),m ...

  2. 架构实例之Demo_JSP_JavaBean

    架构实例之Demo_JSP_JavaBean 1.开发工具和开发环境      开发工具: MyEclipse10,JDK1.6.0_13(32位),Tomcat7.0(32位),mysql5.7.1 ...

  3. 架构实例之Demo_JSP

    架构实例之Demo_JSP 1.开发工具和开发环境       开发工具: MyEclipse10,JDK1.6.0_13(32位),Tomcat7.0(32位),mysql5.7.13 开发环境:W ...

  4. 【DDD】领域驱动设计实践 —— 架构风格及架构实例

    概述 DDD为复杂软件的设计提供了指导思想,其将易发生变化的业务核心域放置在限定上下文中,在确保核心域一致性和内聚性的基础上,DDD可以被多种语言和多种技术框架实现,具体的框架实现需要根据实际的业务场 ...

  5. JavaWeb学习之三层架构实例（三）

    引言 通过上一篇博客JavaWeb学习之三层架构实例(二)我们基本上已经实现了对学生信息列表的增删改查操作(UI除外),但是不难看出,代码冗余度太高了,尤其是StudentDao这个类,其中的增删改查 ...

  6. JavaWeb学习之三层架构实例（二）

    引言 这个实例是上一个实例JavaWeb学习 三层架构实例(一)的加强版,实现的是在前端对数据库中student表的 增.删.改.查 操作.关于三层组成云云,这里就不再叙述. 实例 效果图 先来看一下 ...

  7. linux驱动由浅入深系列：高通sensor架构实例分析之二(驱动代码结构)【转】

    本文转载自:https://blog.csdn.net/radianceblau/article/details/73498303 本系列导航: linux驱动由浅入深系列:高通sensor架构实例分 ...

  8. linux驱动由浅入深系列：高通sensor架构实例分析之三(adsp上报数据详解、校准流程详解)【转】

    本文转载自:https://blog.csdn.net/radianceblau/article/details/76180915 本系列导航: linux驱动由浅入深系列:高通sensor架构实例分 ...

  9. java：Session（概述，三层架构实例（实现接口封装JDBC），Session实现简单购物车实例）

    1.Session概述: Session:在计算机中,尤其是在网络应用中,称为“会话控制”.Session 对象存储特定用户会话所需的属性及配置信息.这样,当用户在应用程序的 Web 页之间跳转时,存 ...

随机推荐

  1. 编辑IL文件 修改DLL文件

    本文章只是技术探讨,学习,技术上的研究而已.请支持正版. 如:KS.Gantt.DLL 为例 使用ILSpy反编译 工具 利用ildasm反编译 KS.Gantt.dll  生成IL中间代码 一般会生 ...

  2. poj2186--tarjan+缩点

    题目大意:       每一头牛的愿望就是变成一头最受欢迎的牛.现在有N头牛,给你M对整数(A,B),表示牛A认为牛B受欢迎. 这 种关系是具有传递性的,如果A认为B受欢迎,B认为C受欢迎,那么牛A也 ...

  3. python之最强王者（1）——python入门简介

    1.Python简介 Python是一种解释型.面向对象.动态数据类型的高级程序设计语言. Python由Guido van Rossum于1989年底发明,第一个公开发行版发行于1991年. 像Pe ...

  4. 25、ASP.NET MVC入门到精通——Spring.net-业务层仓储

    本系列目录:ASP.NET MVC4入门到精通系列目录汇总 上一节,我们已经把项目框架的雏形搭建好了,那么现在我来开始业务实现,在业务实现的过程当中,不断的来完善我们现有的框架. 1.假设我们来做一个 ...

  5. 精心挑选10款优秀的 jQuery 图片左右滚动插件

    在现代的网页设计中,图片和内容滑块是一种极为常见和重要的元素.你可以从头开始编写自己的滑动效果,但是这将浪费很多时间,因为网络上已经有众多的优秀的 jQuery 滑块插件.当然,如果要从大量的 jQu ...

  6. PresentViewController切换界面

    视图切换,没有NavigationController的情况下,一般会使用presentViewController来切换视图并携带切换时的动画, 其中切换方法如下: – presentViewCon ...

  7. asp.net mvc 中 一种简单的 URL 重写

    asp.net mvc 中 一种简单的 URL 重写 Intro 在项目中想增加一个公告的功能,但是又不想直接用默认带的那种路由,感觉好low逼,想弄成那种伪静态化的路由 (别问我为什么不直接静态化, ...

  8. 商业智能SAAS走向中小企业

    20多年前,Gartner提出了商业智能的概念,并将其定义为“一类由数据仓库.查询报表.数据分析.数据挖掘等部分组成的,以帮助企业决策的技术及应用”.从技术上讲,商业智能是数据仓库.OLAP和数据挖掘 ...

  9. sharePoint 2016 弃用和删除的功能

    前言 sharepoint 2016版本正式发布,但是相比较2013版本,还是删除或者准备删除一些功能,我们需要了解一下哪些功能已经被删除掉或者在下一个版本中移除,因为这些可能影响我们现有系统是否能够 ...

  10. 回收ImageView占用的图像内存

    使用方法: RecycleBitmap.recycleImageView(mSelectorView);   参数为imageview /** * 回收ImageView占用的图像内存; * 使用了本 ...