Struts2注解+JDBC+MySQL小项目应用

最新推荐文章于 2022-04-19 19:42:25 发布
最新推荐文章于 2022-04-19 19:42:25 发布
阅读量623 收藏
点赞数
分类专栏： Java Java Struts2框架 mysql

很简易的Struts2，用JDBC连接MySQL数据库。用于学习Struts2注解和JDBC基础。

一、创建数据库。安装的MySQL数据库

[sql]  view plain copy print ?
  1. /*  
  2. Navicat MySQL Data Transfer  
  3.   
  4. Source Server         : myStruts  
  5. Source Server Version : 50142  
  6. Source Host           : localhost:3308  
  7. Source Database       : myStrutsDB  
  8.   
  9. Target Server Type    : MYSQL  
  10. Target Server Version : 50142  
  11. File Encoding         : 65001  
  12.   
  13. Date: 2012-01-01 10:30:30  
  14. */  
  15.   
  16. SET FOREIGN_KEY_CHECKS=0;  
  17. -- ----------------------------  
  18. -- Table structure for `user`  
  19. -- ----------------------------  
  20. DROP TABLE IF EXISTS `user`;  
  21. CREATE TABLE `user` (  
  22.   `userName` varchar(20) NOT NULL,  
  23.   `passWord` varchar(20) NOT NULL,  
  24.   `registeredTime` char(12) NOT NULL,  
  25.   PRIMARY KEY (`userName`)  
  26. ) ENGINE=InnoDB DEFAULT CHARSET=utf8;  
  27.   
  28. -- ----------------------------  
  29. -- Records of user  
  30. -- ----------------------------  
  31. INSERT INTO `user` VALUES ('111111', '111111', '201112311022');  
  32. INSERT INTO `user` VALUES ('admin', 'admin', '201112311026');  

二、创建Struts2 Project

New – Dynamic Web Project<myStruts2>

导入jar包

1、项目中各部分介绍

1.1  WEBContent包含：

     1.1.1 login.jsp(可根据url直接登录)

     1.1.2 WEB-INF中： 1.1.2.1 web.xml

                    1.1.2.2 success.jsp

                   1.1.2.3  failure.jsp

PS:一般web应用将jsp放在WEB-INF文件夹下的用意：WEB-INF下面的文件会受到保护，通过浏览器无法直接访问，必须通过servlet，action跳转访问

1.2. src包含:

     1.2.1 action包：所有Action类，必须实现getter/setter，与jsp直接交互

     1.2.2 dao包：连接数据库的类

     1.2.3 dmo包：实体类，与数据表字段对应

     1.2.4 impl包：业务操作的实现类



2、编写web.xml

[html]  view plain copy print ?
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  3.     xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"  
  4.     xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"  
  5.     id="WebApp_ID" version="2.5">  
  6.   
  7.     <display-name>myStruts2</display-name>  
  8.   
  9.     <!-- 用户键入的URL不包含action名称、JSP页面或其他资源，依次寻找文件 -->  
  10.     <welcome-file-list>  
  11.         <welcome-file>login.jsp</welcome-file>  
  12.     </welcome-file-list>  
  13.   
  14.     <filter>  
  15.         <!--过滤器名字 -->  
  16.         <filter-name>struts2</filter-name>  
  17.         <!-- struts2过滤器支持的StrutsPrepareFilter类 -->  
  18.         <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>  
  19.   
  20.         <!-- 添加使用注解必须的参数,指定查找Action类的路径 -->  
  21.         <!--   
  22.         <init-param>  
  23.             <param-name>actionPackages</param-name>  
  24.             <param-value>action</param-value>  
  25.         </init-param>  
  26.         -->  
  27.     </filter>  
  28.   
  29.     <filter-mapping>  
  30.         <!--过滤器拦截名字 -->  
  31.         <filter-name>struts2</filter-name>  
  32.         <!--过滤器拦截文件路径名字 -->  
  33.         <!-- 通配符/*表示拦截所有HTTP请求 -->  
  34.         <url-pattern>/*</url-pattern>  
  35.     </filter-mapping>  
  36.   
  37. </web-app>  

3、编写login.jsp

[javascript]  view plain copy print ?
  1. <%@ page language="java" contentType="text/html; charset=utf-8"  
  2.     pageEncoding="utf-8"%>  
  3. <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"   
  4. "http://www.w3.org/TR/html4/loose.dtd">  
  5. <html>  
  6. <head>  
  7. <meta http-equiv="Content-Type" content="text/html; charset=utf-8">  
  8. <title>login</title>  
  9. </head>  
  10.   
  11. <body>  
  12.   
  13. <form action="register!register.action">  
  14. <table>  
  15.     <tr>  
  16.         <td>用户名:</td>  
  17.         <td colspan=2><input type="text" name="userName" /></td>  
  18.     </tr>  
  19.     <tr>  
  20.         <td>密码:</td>  
  21.         <td colspan=2><input type="password" name="passWord" /></td>  
  22.     </tr>  
  23.     <tr>  
  24.         <td><input type="reset" name="reset" value="重置" /></td>  
  25.         <td colspan=2><input type="submit" name="register" value="注册" /></td>  
  26.     </tr>  
  27. </table>  
  28. </form>  
  29.   
  30. <form action="login!login.action">  
  31. <table>  
  32.     <tr>  
  33.         <td>用户名:</td>  
  34.         <td colspan=2><input type="text" name="userName" /></td>  
  35.     </tr>  
  36.     <tr>  
  37.         <td>密码:</td>  
  38.         <td colspan=2><input type="password" name="passWord" /></td>  
  39.     </tr>  
  40.     <tr>  
  41.         <td><input type="reset" name="reset" value="重置" /></td>  
  42.         <td colspan=2><input type="submit" name="login" value="登录" /></td>  
  43.     </tr>  
  44. </table>  
  45. </form>  
  46.   
  47. </body>  
  48. </html>  

4、创建操作结果提示JSP<success.jsp/failure.jsp>

success.jsp

[javascript]  view plain copy print ?
  1. <pre class="html" name="code"><%@ page language="java" contentType="text/html; charset=UTF-8"  
  2.     pageEncoding="UTF-8"%>  
  3. <!-- Struts2标签taglib -->  
  4. <%@ taglib prefix="s" uri="/struts-tags"%>  
  5. <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">  
  6. <html>  
  7. <head>  
  8. <meta http-equiv="Content-Type" content="text/html; charset= UTF-8">  
  9. <title> success </title>  
  10. </head>  
  11. <body>  
  12. <!-- 用session传输数据 -->  
  13. ${sessionScope.userName}  
  14. <!-- 先声明taglib，value即对应传输数据，对应字段名；为接收到数据时，显示默认default -->  
  15. success<h1><s:property value="resultMsg" default="未接收到信息"/></h1>  
  16. </body>  
  17. </html></pre>  
  18. <pre></pre>  
  19. failure.jsp  
  20. <p></p>  
  21. <p></p>  
  22. <pre class="html" name="code"><%@ page language="java" contentType="text/html; charset=UTF-8"  
  23.     pageEncoding="UTF-8"%>  
  24. <!-- Struts2标签taglib -->  
  25. <%@ taglib prefix="s" uri="/struts-tags"%>  
  26. <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">  
  27. <html>  
  28. <head>  
  29. <meta http-equiv="Content-Type" content="text/html; charset= UTF-8">  
  30. <title>failure</title>  
  31. </head>  
  32. <body>  
  33. failure<h1><s:property value="resultMsg" default="未接收到信息"/></h1>  
  34. </body>  
  35. </html></pre><br>  
  36. 5、创建JDBC连接<dao.DBConn.java><br>  
  37. <p>     </p>  
  38. <pre class="java" name="code">package dao;  
  39.   
  40. import java.sql.Connection;  
  41. import java.sql.DriverManager;  
  42. import java.sql.SQLException;  
  43.   
  44. /** 
  45.  *  
  46.  * 数据库操作 
  47.  * 
  48.  * @author 莫小哆_ly 2011-12-31 
  49.  */  
  50. public class DBConn {  
  51.       
  52.     private Connection conn;  
  53.     /** 
  54.      * 连接数据库 
  55.      * @return 
  56.      */  
  57.     public Connection getConn(){  
  58.         String url = "jdbc:mysql://localhost:3308/myStrutsDB"; // 数据库地址[jdbc:mysql://<IP>:<db-port>/<db-name>]  
  59.         String user = "root"; // 数据库用户名  
  60.         String pwd = ""; // 数据库密码  
  61.         try {  
  62.             Class.forName("com.mysql.jdbc.Driver"); // 加载驱动  
  63.             conn = DriverManager.getConnection(url, user, pwd);// 注册驱动程序  
  64.             if (!conn.isClosed()) {  
  65.                 System.out.println("连接成功");  
  66.             }  
  67.             if (conn == null) {  
  68.                 System.out.println("连接数据库失败，从检查后重新启动！");  
  69.             }  
  70.   
  71.         } catch (ClassNotFoundException e) {  
  72.             e.printStackTrace();  
  73.         } catch (SQLException e) {  
  74.             e.printStackTrace();  
  75.         }  
  76.         return conn;  
  77.     }  
  78.     /** 
  79.      * 关闭数据库连接 
  80.      */  
  81.     public void closeConn(){  
  82.         if(conn!=null) {  
  83.             try{  
  84.                 conn.close();  
  85.             }catch(Exception e){  
  86.                 e.printStackTrace();  
  87.             }  
  88.         }  
  89.     }  
  90. }</pre>6、创建实体类<dmo.User.java>  
  91. <p></p>  
  92. <p></p>  
  93. <pre class="java" name="code">package dmo;  
  94.   
  95. /** 
  96.  *  
  97.  * 用户信息 
  98.  * 
  99.  * @author 莫小哆_ly 2012-1-1 
  100.  */  
  101. public class User {  
  102.     /** 
  103.      * 用户名 
  104.      */  
  105.     private String userName;  
  106.     /** 
  107.      * 密码 
  108.      */  
  109.     private String passWord;  
  110.     /** 
  111.      * 注册时间yyMMddHHmmss 
  112.      */  
  113.     private String registeredTime;  
  114.       
  115.     public User() {  
  116.           
  117.     }  
  118.     public User(String userName,String passWord,String registeredTime) {  
  119.         this.userName = userName;  
  120.         this.passWord = passWord;  
  121.         this.registeredTime = registeredTime;  
  122.     }  
  123.       
  124.     public String getUserName() {  
  125.         return userName;  
  126.     }  
  127.     public void setUserName(String userName) {  
  128.         this.userName = userName;  
  129.     }  
  130.     public String getPassWord() {  
  131.         return passWord;  
  132.     }  
  133.     public void setPassWord(String passWord) {  
  134.         this.passWord = passWord;  
  135.     }  
  136.     public String getRegisteredTime() {  
  137.         return registeredTime;  
  138.     }  
  139.     public void setRegisteredTime(String registeredTime) {  
  140.         this.registeredTime = registeredTime;  
  141.     }  
  142. }</pre><br>  
  143. 7、创建业务实现类，包括登录、注册、数据库操作<impl>  
  144. <p></p>  
  145. 7.1 impl. InsertConOpera.java(实现insert操作)  
  146. <p></p>  
  147. <p></p>  
  148. <pre class="java" name="code">package impl;  
  149.   
  150. import java.sql.Connection;  
  151. import java.sql.SQLException;  
  152. import java.sql.Statement;  
  153. import java.text.SimpleDateFormat;  
  154. import java.util.Date;  
  155.   
  156. import dao.DBConn;  
  157.   
  158. /** 
  159.  *  
  160.  * 本页代码包含 【insert】功能 
  161.  *  
  162.  * @author 莫小哆_ly 2011-12-31 
  163.  */  
  164. public class InsertConOpera {  
  165.       
  166.     //注册时间yyMMddHHmmss  
  167.     private String registeredTime;  
  168.       
  169.     /** 
  170.      * 用户注册功能 
  171.      * @param userName 
  172.      * @param passWord 
  173.      */  
  174.     public int save(String userName, String passWord) {  
  175.         int count = 0;  
  176.         try {  
  177.             DBConn db = new DBConn();  
  178.             Connection conn = db.getConn();  
  179.               
  180.             // 执行静态SQL语句  
  181.             Statement stmt = conn.createStatement();  
  182.               
  183.             //生成注册时间  
  184.             Date now = new Date();  
  185.             SimpleDateFormat format = new SimpleDateFormat("yyMMddHHmmss");  
  186.             registeredTime = format.format(now);  
  187.   
  188.             String sql0 = "INSERT INTO user(userName,passWord,registeredTime) " + " VALUES (" + "'"  
  189.                     + userName + "','" + passWord + "','" + registeredTime + "')";  
  190.             count = stmt.executeUpdate(sql0);  
  191.             if (stmt != null) { // 关闭声明  
  192.                 try {  
  193.                     stmt.close();  
  194.                 } catch (SQLException e) {  
  195.                     e.printStackTrace();  
  196.                 }  
  197.             }  
  198.             if (conn != null) { // 关闭连接对象  
  199.                 try {  
  200.                     conn.close();  
  201.                 } catch (SQLException e) {  
  202.                     e.printStackTrace();  
  203.                 }  
  204.             }  
  205.             db.closeConn();  
  206.         } catch (SQLException e) {  
  207.             e.printStackTrace();  
  208.         }  
  209.         return count;  
  210.     }  
  211. }</pre><br>  
  212. 7.2 impl. SelectConOper.java (实现select操作)<br>  
  213. <p></p>  
  214. <p></p>  
  215. <pre class="java" name="code">package impl;  
  216.   
  217. import java.sql.Connection;  
  218. import java.sql.PreparedStatement;  
  219. import java.sql.ResultSet;  
  220. import java.sql.SQLException;  
  221. import java.sql.Statement;  
  222.   
  223. import dao.DBConn;  
  224. /** 
  225.  *  
  226.  * 本页代码包含 【select】功能 
  227.  * 
  228.  * @author 莫小哆_ly 2012-1-1 
  229.  */  
  230. public class SelectConOper {  
  231.       
  232.     /** 
  233.      * 注册时检测功能 
  234.      * @param userName 
  235.      * @return 
  236.      */  
  237.     public int select(String userName) {  
  238.         int count=0;  
  239.         try {  
  240.             DBConn db = new DBConn();  
  241.             Connection conn = db.getConn();  
  242.             Statement stmt = conn.createStatement() ;  
  243.               
  244.             String sq20 = "SELECT count(*) FROM user WHERE userName = "   
  245.                 + "'" + userName + "'";  
  246.             //执行给定的 SQL 语句，该语句返回单个 ResultSet对象  
  247.             ResultSet rs = stmt.executeQuery(sq20) ;  
  248.             while(rs.next()){   
  249.                 count = rs.getInt(1);  
  250.             }  
  251.             if(rs != null){ // 关闭记录集  
  252.                 try{   
  253.                     rs.close() ;   
  254.                 }catch(SQLException e){   
  255.                     e.printStackTrace() ;  
  256.                 }   
  257.             }   
  258.             if(stmt != null){ // 关闭声明   
  259.                 try{  
  260.                     stmt.close() ;   
  261.                 }catch(SQLException e){  
  262.                     e.printStackTrace() ;  
  263.                 }  
  264.             }   
  265.             if(conn != null){ // 关闭连接对象  
  266.                 try{  
  267.                     conn.close() ;  
  268.                 }catch(SQLException e){   
  269.                     e.printStackTrace() ;   
  270.                 }  
  271.             }  
  272.             db.closeConn();  
  273.         } catch (SQLException e) {  
  274.             e.printStackTrace();  
  275.         }  
  276.         return count;  
  277.     }  
  278.       
  279.     /** 
  280.      * 静态SQL语句 
  281.      * @param userName 
  282.      * @param passWord 
  283.      * @return 
  284.      */  
  285.     public int selectStatement(String userName,String passWord) {  
  286.         int count=0;  
  287.         try {  
  288.             DBConn db = new DBConn();  
  289.             Connection conn = db.getConn();  
  290.             Statement stmt = conn.createStatement() ;  
  291.               
  292.             String sq20 = "SELECT count(*) FROM user WHERE userName = "   
  293.                 + "'" + userName + "' and userName = '" + passWord + "'";  
  294.               
  295.             ResultSet rs = stmt.executeQuery(sq20) ;  
  296.             while(rs.next()){   
  297.                 count = rs.getInt(1);  
  298.             }  
  299.             if(rs != null){ // 关闭记录集  
  300.                 try{   
  301.                     rs.close() ;   
  302.                 }catch(SQLException e){   
  303.                     e.printStackTrace() ;  
  304.                 }   
  305.             }   
  306.             if(stmt != null){ // 关闭声明   
  307.                 try{  
  308.                     stmt.close() ;   
  309.                 }catch(SQLException e){  
  310.                     e.printStackTrace() ;  
  311.                 }  
  312.             }   
  313.             if(conn != null){ // 关闭连接对象  
  314.                 try{  
  315.                     conn.close() ;  
  316.                 }catch(SQLException e){   
  317.                     e.printStackTrace() ;   
  318.                 }  
  319.             }  
  320.             db.closeConn();  
  321.         } catch (SQLException e) {  
  322.             e.printStackTrace();  
  323.         }  
  324.         return count;  
  325.     }  
  326.       
  327.     /** 
  328.      * 动态SQL语句 
  329.      * @param userName 
  330.      * @param passWord 
  331.      * @return 
  332.      */  
  333.     public int selectPreparedStatement(String userName,String passWord) {  
  334.         int count=0;  
  335.         try {  
  336.             DBConn db = new DBConn();  
  337.             Connection conn = db.getConn();  
  338.               
  339.             String sq30 = "SELECT count(*) FROM user WHERE userName = ? and passWord = ?";  
  340.             PreparedStatement pstmt = conn.prepareStatement(sq30);  
  341.               
  342.             pstmt.setString(1,userName);  
  343.             pstmt.setString(2,passWord);  
  344.               
  345.             ResultSet rs = pstmt.executeQuery() ;  
  346.               
  347.             while(rs.next()){   
  348.                 count = rs.getInt(1);  
  349.             }  
  350.             if(rs != null){ // 关闭记录集  
  351.                 try{   
  352.                     rs.close() ;   
  353.                 }catch(SQLException e){   
  354.                     e.printStackTrace() ;  
  355.                 }   
  356.             }   
  357.             if(pstmt != null){ // 关闭声明   
  358.                 try{  
  359.                     pstmt.close() ;   
  360.                 }catch(SQLException e){  
  361.                     e.printStackTrace() ;  
  362.                 }  
  363.             }   
  364.             if(conn != null){ // 关闭连接对象  
  365.                 try{  
  366.                     conn.close() ;  
  367.                 }catch(SQLException e){   
  368.                     e.printStackTrace() ;   
  369.                 }  
  370.             }  
  371.         } catch (SQLException e) {  
  372.             e.printStackTrace();  
  373.         }  
  374.         return count;  
  375.     }  
  376. }</pre><br>  
  377. 此处动态SQL和静态SQL二选其一即可。  
  378. <p></p>  
  379. <p>7.3 impl.RegisterImpl.java (实现注册相关业务操作)<br>  
  380. </p>  
  381. <p></p>  
  382. <pre class="java" name="code">package impl;  
  383.   
  384. /** 
  385.  *  
  386.  * 实现注册相关业务 
  387.  * 
  388.  * @author 莫小哆_ly 2012-1-1 
  389.  */  
  390. public class RegisterImpl {  
  391.    
  392.     SelectConOper selectConn = new SelectConOper();  
  393.     InsertConOpera insertConn = new InsertConOpera();  
  394.       
  395.     //校验业务,select  
  396.     public int findByUserName(String userName) {  
  397.         int count = selectConn.select(userName);  
  398.         return count;  
  399.     }  
  400.       
  401.     //注册业务，insert  
  402.     public int register(String userName, String passWord) {  
  403.         int count = insertConn.save(userName,passWord);  
  404.         return count;  
  405.     }  
  406. }</pre><br>  
  407. 7.4 impl. LoginImpl.java (实现insert操作)<br>  
  408. <p></p>  
  409. <p></p>  
  410. <pre class="java" name="code">package impl;  
  411.   
  412. import dmo.User;  
  413.   
  414. /** 
  415.  *  
  416.  * 实现登录相关业务 
  417.  * 
  418.  * @author 莫小哆_ly 2012-1-1 
  419.  */  
  420. public class LoginImpl {  
  421.       
  422.     SelectConOper selectConn = new SelectConOper();  
  423.       
  424.     //登录业务，select  
  425.     public int login(User user) {  
  426.         int count = selectConn.selectStatement(user.getUserName(), user.getPassWord());  
  427.         return count;  
  428.     }  
  429. }</pre><br>  
  430. 8、编写Action类，与jsp交互<action.LoginAction.ava>  
  431. <p></p>  
  432. <p></p>  
  433. <pre class="java" name="code">package action;  
  434.   
  435. import java.util.Map;  
  436.   
  437. import org.apache.struts2.convention.annotation.Action;  
  438. import org.apache.struts2.convention.annotation.Namespace;  
  439. import org.apache.struts2.convention.annotation.Result;  
  440. import org.apache.struts2.convention.annotation.Results;  
  441.   
  442. import impl.RegisterImpl;  
  443. import impl.SelectConOper;  
  444.   
  445. import com.opensymphony.xwork2.ActionContext;  
  446. import com.opensymphony.xwork2.ActionSupport;  
  447.   
  448. @Namespace("")  
  449. @Results({ @Result(name = "loginSuccess", location = "/WEB-INF/success.jsp"),  
  450.         @Result(name = "loginFailure", location = "/WEB-INF/failure.jsp"),  
  451.         @Result(name = "checkSuccess", location = "/WEB-INF/success.jsp"),  
  452.         @Result(name = "checkFailure", location = "/WEB-INF/failure.jsp") })  
  453. public class LoginAction extends ActionSupport {  
  454.   
  455.     private static final long serialVersionUID = 1L;  
  456.   
  457.     private String            userName;  
  458.     private String            passWord;  
  459.     private String            resultMsg;  
  460.     private int               resultInt;  
  461.       
  462.     RegisterImpl              regImpl          = new RegisterImpl();  
  463.   
  464.     // 对应的jsp:  
  465.     // Namespace/类名!方法名.action  
  466.     // <form action="action/login!login.action">  
  467.   
  468.     // Action!方法名.action  
  469.     // <form action="login!login.action">  
  470.   
  471.     // 提交注册  
  472.     @Action("register")  
  473.     public String register() {  
  474.         // 验证用户名是否重复  
  475.         resultInt = regImpl.findByUserName(userName);  
  476.         if (resultInt != 0) {  
  477.             resultMsg = "用户名已被使用，请重新输入";  
  478.             return "registerFailure";  
  479.         } else {  
  480.             resultInt = regImpl.register(userName, passWord);  
  481.             if (1 == resultInt) {  
  482.                 // 1. 将用户信息保存到Session中。  
  483.                 Map<String, Object> session = ActionContext.getContext().getSession();  
  484.                 session.put("userName", userName);  
  485.                 session.put("passWord", passWord);  
  486.                 // 2. taglib标识传递  
  487.                 resultMsg = "注册成功";  
  488.                 return "registerSuccess";  
  489.             } else {  
  490.                 resultMsg = "注册失败";  
  491.                 return "registerFailure";  
  492.             }  
  493.         }  
  494.     }  
  495.   
  496.     // 登录  
  497.     @Action("login")  
  498.     public String login() {  
  499.         resultMsg = null;  
  500.         // 对用户的输入格式进行验证//应定义在jsp页面javScript  
  501.         if ("".equals(userName) || userName == null) {  
  502.             resultMsg = "用户名不能为空";  
  503.             return "checkFailure";  
  504.         } else if ("".equals(passWord) || passWord == null) {  
  505.             resultMsg = "密码不能为空";  
  506.             return "checkFailure";  
  507.         } else {  
  508.             if (passWord.length() < 4 || passWord.length() > 10) {  
  509.                 resultMsg = "密码必须在4到10之间";  
  510.                 return "checkFailure";  
  511.             }  
  512.         }  
  513.         // 数据库查询，根据用户输入与数据库中数据匹配情况  
  514.         SelectConOper selectConOpe = new SelectConOper();  
  515.         int resultInt = selectConOpe.selectStatement(userName, passWord);  
  516.         // int resultInt =  
  517.         // selectConOpe.selectPreparedStatement(userName,passWord);  
  518.   
  519.         if (1 == resultInt) {  
  520.             resultMsg = "登录成功";  
  521.             return "loginSuccess";  
  522.         } else {  
  523.             resultMsg = "登录失败";  
  524.             return "loginFailure";  
  525.         }  
  526.     }  
  527.   
  528.     public String getUserName() {  
  529.         return userName;  
  530.     }  
  531.   
  532.     public void setUserName(String userName) {  
  533.         this.userName = userName;  
  534.     }  
  535.   
  536.     public String getPassWord() {  
  537.         return passWord;  
  538.     }  
  539.   
  540.     public void setPassWord(String passWord) {  
  541.         this.passWord = passWord;  
  542.     }  
  543.   
  544.     public String getResultMsg() {  
  545.         return resultMsg;  
  546.     }  
  547.   
  548.     public void setResultMsg(String resultMsg) {  
  549.         this.resultMsg = resultMsg;  
  550.     }  
  551. }</pre><br>  
  552. 这样，一个很简单的Struts2注解的WEB项目，就完成了。 
qq19930130
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Struts2+mysql（含数据库等）
08-04
可以参考下，包含DIGITAL数据库，里面还有登录注册页面已及验证器验证
Struts2 +JDBC——简单登录
so_sss的专栏
09-02 5450
struts2+JDBC的简单登录注册
java+Eclipse+struts2+Tomcat+Mysql开发的小例子
cslog的博客
12-17 5158
本学期的一个小项目总算是完工了，一开始啥也不懂，看了许多博客，走了很多弯路，才把环境配置完成。为了让大家将时间更多地放在代码上，而不是浪费在环境配置上，下面我就来向大家介绍一下java+Eclipse+struts2+Tomcat+Mysql开发的实例。 俗话说“万事开头难”，就让我们迎难而上吧。 一、环境配置 1.新建工程 打开Eclipse,点击File->new->Dynam
struts2框架做的学生信息查询系统
11-02
采用Struts2框架，完成数据库操作（增删改查），完成分页，模糊查询，
struts2+spring2.5+jpa 注解开发框架
12-09
使用注解进行开发: ...该项目完全可以运行，包含了所有的JAR包，数据库默认使用ORACLE,MYSQL(需要改下jdbc.property配置文件，修改很方便) 该包绝对适用，超值 上传日期：2010-12-14 作者：王金川
s2sh + extjs4 办公平台架构
07-09
3、系统利用struts2 拦截器 判断用户是否登录哦 4、使用p6spy 打印出hibernate 中已经替换了占位符参数的sql语句，为hibernate的调试不在感到苦恼 系统部署我使用的ant 部署，代码包含ant部署文件 skyline\...
SSH2项目(WeExam)源码
05-25
2、修改src/jdbc.properties内的连接参数，及test/hibernate.cfg.xml（用于单元测试）的连接参数 3、打开一下连接初始化数据库：http://127.0.0.1:8080/WeExam/initialize 4、管理后台为：...
Struts2+MySQL登录注册
03-10
Struts2+MySQL登录注册
用Struts2+JDBC+Mysql写的增删改查,分页
07-24
自己学习时候写的, 下载了注意添加Jar包就OK. 数据库很简单, 看User类就OK. 连数据库 自己修改一下DBConn类里面的 连接地址.
Struts2+spring+jdbc+mysql搭建
06-27
Struts2+spring+jdbc+mysql环境搭建，适用于小型的web项目开发，舍弃hibernate，直接对mysql数据库进行应用，整个文档详细的介绍环境的搭建步骤
使用struts2+MySQL做简单的登录验证
Falleyes
10-22 1万+
环境： JDK：1.8 IDE：NetBeans 8.0.2 struts：2.3.15 MySQL：5.6.26 1. 在MySQL中创建相应的数据库和表，提供初始的测试数据 -- 创建数据库 CREATE DATABASE `attendance`; -- 创建表 CREATE TABLE `admin` ( `id` varchar(10) NOT NULL, `pwd
Struts2 + MySql 数据库实现登录
Barving的专栏
08-21 4365
原文地址 ：http://liyazhouhappy.blog.163.com/blog/static/1777910542012719101644256/ Struts2 + MySql 数据库实现登录   2012-08-19 10:33:36|  分类： 4. Struts2|举报|字号 订阅 一、搭建Struts2环境 1.所需Jar
struts2+JDBC项目小试验
mht1829的博客
10-22 777
step1：创建一个动态web应用，配置web.xml文件。导入struts2和连接mysql的架包，并添加到环境变量中。<display-name>struts2-02</display-name> <welcome-file-list> <welcome-file>index.html</welcome-file> </welcome-file-list> <filter>
struts2框架+mysql，实现用户登录、注册功能
热门推荐
amateur_RD的博客
04-19 1万+
说明：所有源码已上传到笔者GitHub上，欢迎follow、star。感谢！！！ 一、Demo介绍 本Demo具体实现了以下功能： 1.基于struts2框架+MySQL数据库验证，实现了用户登录、注册功能。 2.用户注册时，分别使用客户端校验和服务器端校验两种校验方式，实现了对用户输入信息的校验，对不符合要求的信息，予以提示且不允许注册，需重新填写注册。 二、主要代码 1...
【编程不良人】MyBatis从入门到精通学习笔记05---Spring+Mybatis+Struts2练习项目
Mr.Cui的Java学习之路
04-19 384
作业： 用户与身份信息展示分析： 用户和身份信息添加分析： 1. 创建Maven-webapp项目，新建java、resources目录以及test目录下的java、resources 2. 在pom.xml中引入依赖 <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version&...
struts2 mysql项目_JSP+Struts2+JDBC+Mysql实现的校园宿舍管理系统
weixin_36190812的博客
01-26 170
项目简介本系统基于JSP+Struts2+JDBC+Mysql的校园宿舍管理系统。该系统没有使用全套的SSH框架，只使用了跳转层Struts2，非常适合学习Struts2时使用。难度等级：中等技术栈编辑器Eclipse Version: 2019-12 (4.14.0)前端技术基础：html+css+JavaScript框架：无后端技术JSP+Struts2+JDBC数据库：mysql 5.7.2...
子比主题ACG美化插件全开源
最新发布
05-25
子比主题ACG美化插件[全开源] 不要改人家原作者版权，不要用于违法乱纪
struts2增删改查项目mysql
05-21
Struts2 是一个基于 MVC 设计模式的 Web 应用程序框架，可以用于快速开发 Java Web 应用程序，而 MySQL 是一个流行的关系型数据库管理系统，可以存储和管理数据。下面是一个简单的 Struts2 增删改查项目，使用 MySQL...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值