AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

最新版使用SSH框架（Struts2.x + Spring4.x + Hibernate5.x）搭建JavaWeb开发环境实例

2017-11-27 1377
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
RDS MySQL Serverless 基础系列，0.5-2RCU 50GB
推荐场景：
学生管理系统数据库设计 搭建个人博客
云数据库 RDS MySQL，集群系列 2核4GB
推荐场景：
搭建个人博客
云数据库 RDS MySQL，高可用系列 2核4GB
简介：

这个项目很简单，只是做一个简单的用户登录即可。由于我没有使用Myeclipse开发，而是使用了eclipse for Java EE来开发，因此所做的步骤相对要多一点O(∩_∩)O~

一 Spring整合Hibernate并测试

1 在MySQL5中创建数据库bookshop，并运行bookshop.sql，导入相关的表和数据

2 创建一个Dynamic Web Project –> “ssh2test1”，导入jar包（所有jar包均存放在WebContent/WEB-INF/lib），接下来创建一个包“com.ssh2test1.entity”，用于存放相关实体类以及配置文件。有关实体类的介绍可自行参考Hibernate相关内容。由于是用户登录，因为我们需要用到数据库中的 users这个表。所以接下来就是在com.ssh2test1.entity里创建一个Users.java和它的配置文件Users.hbm.xml：

Users.java：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
package  com.ssh2test1.entity;
 
import  java.io.Serializable;
 
public  class  Users  implements  Serializable {
     private  static  final  long  serialVersionUID = 1L;
     private  Integer id;
     private  String loginName;
     private  String loginPwd;
     private  String name;
     private  String address;
     private  String phone;
     private  String mail;
     private  Integer userRoleId;
     private  Integer userStateId;
     
     public  Users(){
         
     }
 
     public  Users(Integer id, String loginName, String loginPwd, String name, String address, String phone, String mail,
             Integer userRoleId, Integer userStateId) {
         super ();
         this .id = id;
         this .loginName = loginName;
         this .loginPwd = loginPwd;
         this .name = name;
         this .address = address;
         this .phone = phone;
         this .mail = mail;
         this .userRoleId = userRoleId;
         this .userStateId = userStateId;
     }
 
     public  Integer getId() {
         return  id;
     }
 
     public  void  setId(Integer id) {
         this .id = id;
     }
 
     public  String getLoginName() {
         return  loginName;
     }
 
     public  void  setLoginName(String loginName) {
         this .loginName = loginName;
     }
 
     public  String getLoginPwd() {
         return  loginPwd;
     }
 
     public  void  setLoginPwd(String loginPwd) {
         this .loginPwd = loginPwd;
     }
 
     public  String getName() {
         return  name;
     }
 
     public  void  setName(String name) {
         this .name = name;
     }
 
     public  String getAddress() {
         return  address;
     }
 
     public  void  setAddress(String address) {
         this .address = address;
     }
 
     public  String getPhone() {
         return  phone;
     }
 
     public  void  setPhone(String phone) {
         this .phone = phone;
     }
 
     public  String getMail() {
         return  mail;
     }
 
     public  void  setMail(String mail) {
         this .mail = mail;
     }
 
     public  Integer getUserRoleId() {
         return  userRoleId;
     }
 
     public  void  setUserRoleId(Integer userRoleId) {
         this .userRoleId = userRoleId;
     }
 
     public  Integer getUserStateId() {
         return  userStateId;
     }
 
     public  void  setUserStateId(Integer userStateId) {
         this .userStateId = userStateId;
     }
     
}

Users.hbm.xml：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
<? xml  version = "1.0"  encoding = "utf-8" ?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
 
< hibernate-mapping >
     < class  name = "com.ssh2test1.entity.Users"  table = "users"  catalog = "bookshop" >
         < id  name = "id"  type = "java.lang.Integer" >
             < column  name = "Id"  />
             < generator  class = "native"  />
         </ id >
         < property  name = "loginName"  type = "java.lang.String" >
             < column  name = "LoginName"  length = "50"  />
         </ property >
         < property  name = "loginPwd"  type = "java.lang.String" >
             < column  name = "LoginPwd"  length = "16"  />
         </ property >
         < property  name = "name"  type = "java.lang.String" >
             < column  name = "Name"  length = "16"  />
         </ property >
         < property  name = "address"  type = "java.lang.String" >
             < column  name = "Address"  length = "16"  />
         </ property >
         < property  name = "phone"  type = "java.lang.String" >
             < column  name = "Phone"  length = "16"  />
         </ property >
         < property  name = "mail"  type = "java.lang.String" >
             < column  name = "Mail"  length = "16"  />
         </ property >
         < property  name = "userRoleId"  type = "java.lang.Integer" >
             < column  name = "UserRoleId"  />
         </ property >
         < property  name = "userStateId"  type = "java.lang.Integer" >
             < column  name = "UserStateId"  />
         </ property >
         
     </ class >
</ hibernate-mapping >

3 配置proxool数据库连接池


(1) 在src根目录下创建一个proxool.xml，用于配置数据库连接情况，下面附上代码，里面有详细注释

proxool.xml：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
<? xml  version = "1.0"  encoding = "UTF-8" ?>
< something-else-entirely >
   < proxool >
     < alias >ProxoolPool</ alias >
     < driver-url >jdbc:mysql://127.0.0.1:3306/bookshop?useUnicode=true&amp;characterEncoding=utf-8</ driver-url >
     < driver-class >com.mysql.jdbc.Driver</ driver-class >
     < driver-properties >
       < property  name = "user"  value = "root" />
       < property  name = "password"  value = "root" />
     </ driver-properties >
     
     <!--最大连接数(默认5个),超过了这个连接数,再有请求时,就排在队列中等候,最大的等待请求数由maximum-new-connections决定 --> 
     < maximum-connection-count >100</ maximum-connection-count >
     <!--最小连接数(默认2个)-->   
     < minimum-connection-count >10</ minimum-connection-count >
      <!--proxool自动侦察各个连接状态的时间间隔(毫秒),侦察到空闲的连接就马上回收,超时的销毁默认30秒-->  
     < house-keeping-sleep-time >90000</ house-keeping-sleep-time >
     <!--没有空闲连接可以分配而在队列中等候的最大请求数,超过这个请求数的用户连接就不会被接受-->  
     < maximum-new-connections >10</ maximum-new-connections >
     <!--最少保持的空闲连接数(默认2个)-->   
     < prototype-count >5</ prototype-count >
     <!--在使用之前测试-->   
     < test-before-use >true</ test-before-use >
     <!--用于保持连接的测试语句 -->  
     < house-keeping-test-sql >select CURRENT_DATE</ house-keeping-test-sql >
     
   </ proxool >
 
</ something-else-entirely >

(2) 配置web.xml，注意：在Spring中配置proxool连接池和在Hibernate中配置有很大的不同，一般情况下proxool再web.xml中是这样配置的：

1
2
3
4
5
6
7
8
9
   < servlet >
     < servlet-name >proxoolServletConfigurator</ servlet-name >
     < servlet-class >org.logicalcobwebs.proxool.configuration.ServletConfigurator</ servlet-class >
     < init-param >
           < param-name >xmlFile</ param-name >
           < param-value >WEB-INF/classes/proxool.xml</ param-value > <!--这里对应刚才建立的xml配置文件名-->
     </ init-param >
     < load-on-startup >1</ load-on-startup >
   </ servlet >

但是又因为Spring通过Listener方式启动，这就导致了Spring比proxool先加载，然后程序运行时将会报错：


(7073 ms) [ERROR] [11:40:40] org.logicalcobwebs.proxool.ProxoolDriver – Problem
org.logicalcobwebs.proxool.ProxoolException: Attempt to refer to a unregistered pool by its alias ‘ProxoolPool’
at org.logicalcobwebs.proxool.ConnectionPoolDefinition.doChange(ConnectionPoolDefinition.java:246)
at org.logicalcobwebs.proxool.ConnectionPoolDefinition.<init>(ConnectionPoolDefinition.java:143)
at org.logicalcobwebs.proxool.ProxoolFacade.registerConnectionPool(ProxoolFacade.java:96)
at org.logicalcobwebs.proxool.ProxoolDriver.connect(ProxoolDriver.java:77)
at java.sql.DriverManager.getConnection(DriverManager.java:664)


因此在这里我们需要proxool也以listener启动，并且还比Spring先启动即可。有大神写了个补丁，我把它命名为ProxoolListener.jar放在lib下了，下面附上现在的web.xml配置情况

web.xml：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
<? xml  version = "1.0"  encoding = "UTF-8" ?>
< web-app  xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"  xmlns = "http://xmlns.jcp.org/xml/ns/javaee"  xsi:schemaLocation = "http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"  version = "3.1" >
 
   < welcome-file-list >
     < welcome-file >index.jsp</ welcome-file >
   </ welcome-file-list >    
       
<!-- proxool改成了以listener方式启动，加载了一个自定义的 ProxoolListener.jar -->
< context-param >  
     < param-name >proxoolConfigLocation</ param-name >  
     < param-value >WEB-INF/classes/proxool.xml</ param-value >  
</ context-param >  
< listener >  
     < listener-class >org.logicalcobwebs.proxool.configuration.ListenerConfigurator</ listener-class >  
</ listener >  
< listener >  
         < listener-class >org.springframework.web.context.ContextLoaderListener</ listener-class >  
</ listener >
   
<!-- spring -->
   < context-param >
       < param-name >contextConfigLocation</ param-name >
       < param-value >WEB-INF/classes/applicationContext.xml</ param-value >
   </ context-param >  
   <!-- 指定以Listener方式启动 -->
   < listener >
       < listener-class >org.springframework.web.context.ContextLoaderListener</ listener-class >
   </ listener >    
 
<!-- 以下3项参数与log4j的配置相关 -->    
   < context-param >  
         < param-name >log4jConfigLocation</ param-name >  
         < param-value >WEB-INF/classes/log4j.properties</ param-value >  
     </ context-param >  
     <!--Spring默认刷新Log4j配置文件的间隔,单位为millisecond-->  
     < context-param >  
         < param-name >log4jRefreshInterval</ param-name >  
         < param-value >60000</ param-value >  
     </ context-param >  
     <!-- Web 项目 Spring 加载 Log4j 的监听 -->
     < listener >  
         < listener-class >  
             org.springframework.web.util.Log4jConfigListener  
         </ listener-class >  
     </ listener >   
 
<!-- struts2 --> 
   < filter >
       < filter-name >struts2</ filter-name >
       < filter-class >
           org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter
       </ filter-class >
   </ filter > 
   < filter-mapping > 
      < filter-name >struts2</ filter-name > 
      < url-pattern >/*</ url-pattern > 
   </ filter-mapping >    
  
</ web-app >

(3) 在src根目录下新建applicationContext.xml，用于配置相关数据源和实例对象，以实现依赖关系的注入。在这里先配置proxool数据源和sessionFactory


applicationContext.xml：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
<? xml  version = "1.0"  encoding = "UTF-8" ?>
< beans
     xmlns = "http://www.springframework.org/schema/beans"
     xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
     xmlns:p = "http://www.springframework.org/schema/p"
     xsi:schemaLocation = "http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd" >
     
<!-- 配置数据源，proxool数据库连接池 -->
     < bean  id = "dataSource" 
         class = "org.springframework.jdbc.datasource.DriverManagerDataSource"  >
         < property  name = "driverClassName"  value = "org.logicalcobwebs.proxool.ProxoolDriver"  />
         <!-- proxool配置文件中的别名要一致 -->
         < property  name = "url"  value = "proxool.ProxoolPool"  />
     </ bean >
         
     <!-- 配置sessionFactory -->
     < bean  id = "sessionFactory"
         class = "org.springframework.orm.hibernate4.LocalSessionFactoryBean" >
        < property  name = "dataSource"  ref = "dataSource" ></ property >
        < property  name = "hibernateProperties" >
            < props >
               < prop  key = "hibernate.dialect" >org.hibernate.dialect.MySQLDialect</ prop >
               < prop  key = "hibernate.show_sql" >true</ prop >
            </ props >
        </ property >
        
        < property  name = "mappingResources" >
             < list >
<!-- 加载实体配置文件 -->            < value >com/ssh2test1/entity/Users.hbm.xml</ value >
             </ list >
         </ property >
     </ bean >
     
</ beans >

4 创建一个包“com.ssh2test1.dao”，封装的是数据库操作。里面有一个接口UserDAO.java和它的实现类UserDAOImpl.java

UserDAO.java：

1
2
3
4
5
6
7
8
9
package  com.ssh2test1.dao;
 
import  java.util.List;
 
import  com.ssh2test1.entity.Users;
 
public  interface  UserDAO {
     public  List<Users> search(Users user);
}

UserDAOImpl.java：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
package  com.ssh2test1.dao;
 
import  java.util.List;
import  org.hibernate.HibernateException;
import  org.hibernate.Query;
import  org.hibernate.Session;
import  org.springframework.orm.hibernate5.HibernateCallback;
import  org.springframework.orm.hibernate5.support.HibernateDaoSupport;
 
import  com.ssh2test1.entity.Users;
 
public  class  UserDAOImpl  extends  HibernateDaoSupport  implements  UserDAO {
 
     public  List<Users> search(Users user) {
         Object execute =  super .getHibernateTemplate().execute( new  HibernateCallback<Object>() {
             public  Object doInHibernate(Session session)  throws  HibernateException{
                 Query query =  null ;
                 if (user !=  null ){
                     if (user.getLoginName() !=  null  && !user.getLoginName().equals( "" ) && user.getLoginPwd() !=  null  && !user.getLoginPwd().equals( "" )){
                         String hql =  "from Users user where user.loginName = :loginName and user.loginPwd = :loginPwd" ;
                         query = session.createQuery(hql);
                         query.setString( "loginName" , user.getLoginName());
                         query.setString( "loginPwd" , user.getLoginPwd());
                         
                     }
                     
                 }
                 
                 return  query.list();
             }
             
         });
         return  (List)execute;
     }
 
}

5 创建一个包“com.ssh2test1.biz”，这是业务逻辑层，里面有一个接口“UserBiz.java”和它的实现类“UserBizImpl.java”，封装了登录操作


UserBiz.java：

1
2
3
4
5
6
7
8
9
package  com.ssh2test1.biz;
 
import  java.util.List;
 
import  com.ssh2test1.entity.Users;
 
public  interface  UserBiz {
     public  List<Users> login(Users user);
}

UserBizImpl.java：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package  com.ssh2test1.biz;
 
import  java.util.List;
 
import  com.ssh2test1.dao.UserDAO;
import  com.ssh2test1.entity.Users;
 
public  class  UserBizImpl  implements  UserBiz {
     //依赖注入
     UserDAO userDAO;
     
     public  void  setUserDAO(UserDAO userDAO) {
         this .userDAO = userDAO;
     }
 
     public  List<Users> login(Users user) {   
         return  userDAO.search(user);
     }
 
}

6 在applicationContext.xml里面添加UserDAO和UserBiz的实例，在上面的配置后面添加节点：

1
2
3
4
5
6
7
8
9
<!-- UserDAO实例 -->
     < bean  id = "userDAO"  class = "com.ssh2test1.dao.UserDAOImpl" >
         < property  name = "sessionFactory"  ref = "sessionFactory"  />
     </ bean >
     
     <!-- UserBiz实例 -->
     < bean  id = "userBiz"  class = "com.ssh2test1.biz.UserBizImpl" >
         < property  name = "userDAO"  ref = "userDAO" />
     </ bean >

7 Spring和Hibernate的整合到这里差不多就可以了，接下来在WebContent里新建testHibernateSpring.jsp，对前面的配置进行测试：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
<%@ page language="java" contentType="text/html; charset=UTF-8"
     pageEncoding="UTF-8"%>
<%@page import="org.springframework.context.ApplicationContext"%>    
<%@page import="org.springframework.context.support.ClassPathXmlApplicationContext"%>  
<%@page import="com.ssh2test1.biz.UserBiz"%>  
<%@page import="com.ssh2test1.entity.Users"%>  
<%@page import="java.util.List"%>  
 
<%
     ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
     UserBiz userBiz = (UserBiz) context.getBean("userBiz");
     Users user = new Users();
     user.setLoginName("admin");
     user.setLoginPwd("admin");
     List list = userBiz.login(user);
     
     if(list.size() > 0)
         System.out.println("登录成功");
     else
         System.out.println("登录失败");
     
     
     %>

wKiom1ZX8CewOBHHAABQ1d3QCnk820.png

如果启动项目后运行testHibernateSpring.jsp文件显示上图这样的提示，则说明我们上面的Spring+Hibernate整合配置已经成功了


二 Spring整合Struts2并测试

1 编写视图页面login.jsp和login_success.jsp

login.jsp：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
<%@ page language="java" contentType="text/html; charset=UTF-8"
     pageEncoding="UTF-8"%>
<%@ taglib prefix="s" uri="/struts-tags"%>    
<%
String path = request.getContextPath();
String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
%>
<!DOCTYPE html>
< html >
< head >
< meta  http-equiv = "Content-Type"  content = "text/html; charset=UTF-8" >
     < base  href="<%=basePath%>">
     < title >用户登录</ title >
</ head >
< body >
     < div  align = "right" >
         < s:a  href = "" >
             < h5 >< font  color = "blue" >还未注册？点击注册</ font ></ h5 >
         </ s:a >
     </ div >< br >< br >
     < div  align = "center"  style = "color:#6DA500" >
         < s:form  action = "login"  method = "post" >
             < s:textfield  name = "username"  label = "账号" ></ s:textfield >
             < s:textfield  name = "password"  label = "密码" ></ s:textfield >
             < s:submit  value = "登录" ></ s:submit >
         </ s:form >
     </ div >
 
</ body >
</ html >

login_success.jsp：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
<%@ page language="java" contentType="text/html; charset=UTF-8"
     pageEncoding="UTF-8"%>
<%@ taglib prefix="s" uri="/struts-tags"%>    
<%
String path = request.getContextPath();
String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
%>
<!DOCTYPE html>
< html >
< head >
< meta  http-equiv = "Content-Type"  content = "text/html; charset=UTF-8" >
     < base  href="<%=basePath%>">
     < title >我的主页</ title >
</ head >
< body >
     < h4  align = "right" >< font  color = "blue" >欢迎您，${user }</ font ></ h4 >
</ body >
</ html >

2 web.xml里添加Struts2过滤器

1
2
3
4
5
6
7
8
9
10
11
<!-- struts2 --> 
   < filter >
       < filter-name >struts2</ filter-name >
       < filter-class >
           org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter
       </ filter-class >
   </ filter > 
   < filter-mapping > 
      < filter-name >struts2</ filter-name > 
      < url-pattern >/*</ url-pattern > 
   </ filter-mapping >

3 在applicationContext.xml中添加Struts2的Action的实例

1
2
3
4
<!-- UserManagerAction实例 -->
     < bean  id = "umAction"  class = "com.ssh2test1.action.UserManagerAction" >
         < property  name = "userBiz"  ref = "userBiz"  />
     </ bean >

4 在src根目录下新建struts.xml，并配置。注意的是，在这里class属性不再使用类的全名，而是使用applicationContext.xml中定义的Action的Bean实例名称


struts.xml：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
<? xml  version = "1.0"  encoding = "UTF-8"  ?>
<!DOCTYPE struts PUBLIC
     "-//Apache Software Foundation//DTD Struts Configuration 2.3//EN"
     "http://struts.apache.org/dtds/struts-2.3.dtd">
 
< struts >
     < constant  name = "struts.action.extension"  value = "do,action" ></ constant >
     < constant  name = "struts.i18n.encoding"  value = "utf-8" ></ constant >
     
     < package  name = "default"  extends = "struts-default" >
         < action  name = "login"  class = "umAction" >
             < result  name = "error" >login.jsp</ result >
             < result  name = "success"  type = "redirect" >login_success.jsp</ result >
         </ action >
         
     </ package >
</ struts >

5 新建包“com.ssh2test1.action”，并创建一个Action类“UserManagerAction.java”，调用userBiz里的login()方法进行登录判断


UserManagerAction.java：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
package  com.ssh2test1.action;
 
import  java.util.List;
import  java.util.Map;
 
import  com.opensymphony.xwork2.ActionContext;
import  com.opensymphony.xwork2.ActionSupport;
import  com.ssh2test1.biz.UserBiz;
import  com.ssh2test1.entity.Users;
 
public  class  UserManagerAction  extends  ActionSupport {
     private  static  final  long  serialVersionUID = 1L;
     private  String username,password;
     UserBiz userBiz;
     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  void  setUserBiz(UserBiz userBiz) {
         this .userBiz = userBiz;
     }
     
     public  String execute() throws  Exception{
         Users user =  new  Users();
         user.setLoginName(username);
         user.setLoginPwd(password);
         
         List<Users> list = userBiz.login(user);
         
         if (list.size() >  0 ){
             ActionContext context = ActionContext.getContext();
             Map<String, Object> session = context.getSession();
             session.put( "user" , username);
             
             return  SUCCESS;
         }
         else
             return  ERROR;
     }
     
}

6 整个项目的配置步骤到此结束，现在启动项目后运行login.jsp进行测试，用户名：admin，密码：admin。如果登录成功后显示下图这样的页面，则表示全部配置已经成功了

wKioL1ZX8VuQ1vpPAAAuxESeN6I081.png

wKiom1ZX8PzjZvVvAAAupmCryCg412.png




本文转自 pangfc 51CTO博客，原文链接：http://blog.51cto.com/983836259/1717447，如需转载请自行联系原作者

文章标签：
云数据库 RDS MySQL 版
Java
Spring
数据库连接
网络安全
Web App开发
关键词：
Spring hibernate
框架Spring
Spring实例
Spring开发环境
ssh实例
相关实践学习
如何在云端创建MySQL数据库
开始实验后，系统会自动创建一台自建MySQL的 源数据库 ECS 实例和一台 目标数据库 RDS。
全面了解阿里云能为你做什么
阿里云在全球各地部署高效节能的绿色数据中心，利用清洁计算为万物互联的新世界提供源源不断的能源动力，目前开服的区域包括中国（华北、华东、华南、香港）、新加坡、美国（美东、美西）、欧洲、中东、澳大利亚、日本。目前阿里云的产品涵盖弹性计算、数据库、存储与CDN、分析与搜索、云通信、网络、管理与监控、应用服务、互联网中间件、移动服务、视频服务等。通过本课程，来了解阿里云能够为你的业务带来哪些帮助 &nbsp; &nbsp; 相关的阿里云产品：云服务器ECS 云服务器 ECS（Elastic Compute Service）是一种弹性可伸缩的计算服务，助您降低 IT 成本，提升运维效率，使您更专注于核心业务创新。产品详情: https://www.aliyun.com/product/ecs
技术小阿哥
目录
相关文章
WXM
|
2月前
|
Java 应用服务中间件 Maven
Spring Boot开发环境搭建和项目启动
WXM
56 2
香吧香
|
2月前
|
消息中间件 Java Kafka
Spring boot 自定义kafkaTemplate的bean实例进行生产消息和发送消息
Spring boot 自定义kafkaTemplate的bean实例进行生产消息和发送消息
香吧香
43 5
xxxlsc
|
2月前
|
Java Maven 开发工具
Spring Boot开发环境的搭建
IDEA Maven JDK Spring Boot
xxxlsc
36 3
热爱技术的小郑
|
15天前
|
XML Java 数据库
Spring5入门到实战------10、操作术语解释--Aspectj注解开发实例。AOP切面编程的实际应用
这篇文章是Spring5框架的实战教程，详细解释了AOP的关键术语，包括连接点、切入点、通知、切面，并展示了如何使用AspectJ注解来开发AOP实例，包括切入点表达式的编写、增强方法的配置、代理对象的创建和优先级设置，以及如何通过注解方式实现完全的AOP配置。
热爱技术的小郑
25 0
VipSoft
|
19天前
|
Java Spring
Spring Boot Admin 离线实例
Spring Boot Admin 离线实例
VipSoft
13 0
小竹笋
|
3月前
|
Java Maven Spring
Spring中AOP最简单实例-@注解形式
Spring中AOP最简单实例-@注解形式
小竹笋
32 0
小竹笋
|
3月前
|
XML Java Maven
Spring中AOP最简单实例-XML形式
Spring中AOP最简单实例-XML形式
小竹笋
17 0
小竹笋
|
3月前
|
网络安全 数据安全/隐私保护
分布式系统详解--框架（Hadoop-Ssh免密登陆配置）
分布式系统详解--框架（Hadoop-Ssh免密登陆配置）
小竹笋
31 0
opencv学堂
|
3月前
|
移动开发 Java Maven
基于OSGi的Virgo Server最简单Spring web实例
基于OSGi的Virgo Server最简单Spring web实例
opencv学堂
39 0
go-Jack
|
JavaScript Java 数据库连接
spring对hibernate的集成中的回调（CallBack）机制
spring对hibernate的集成中的回调（CallBack）机制
go-Jack
198 0
spring对hibernate的集成中的回调（CallBack）机制

热门文章

最新文章

  • 1
    CentOS7增加或修改SSH端口号
  • 2
    git生成SSH秘钥
  • 3
    Hibernate 一对一连接表单向关联
  • 4
    Hibernate 一对多双向映射及乐观锁使用
  • 5
    java学习：Hibernate入门
  • 6
    3.[精通Hibernate笔记]Hibernate检索方式
  • 7
    Spring+SpringMVC+Hibernate简单整合（转）
  • 8
    hibernate笔记--双向一对多映射方法
  • 9
    Hibernate Ehcache 配置
  • 10
    Hibernate中Session接口的用法
  • 1
    17：缓存机制-Java Spring
    76
  • 2
    16：事务-Java Spring
    42
  • 3
    15：MyBatis对象关系与映射结构-Java Spring
    71
  • 4
    从前端Vue到后端Spring Boot：接收JSON数据的正确姿势
    176
  • 5
    Spring AOP的切点是通过使用AspectJ的切点表达式语言来定义的。
    52
  • 6
    Spring缓存是如何实现的？如何扩展使其支持过期删除功能？
    40
  • 7
    Springboot整合与使用log4j2日志框架【详解版】
    293
  • 8
    Springboot实战篇--Springboot框架通过@Scheduled实现定时任务
    42
  • 9
    Springboot框架整合Spring JDBC操作数据
    46
  • 10
    Springboot框架整合Spring Data JPA操作数据
    53

    • 相关课程

    更多
  • 全面讲解Spring Cloud Alibaba技术栈（知识精讲+项目实战）第三阶段
  • 精通Spring Cloud Alibaba
  • 微服务框架 Spring Cloud 快速入门
  • Java Web开发系列课程 - Spring框架入门
  • Spring Boot 2.5.x开发实战
  • Spring Cloud微服务架构设计与开发实战

    • 相关电子书

    更多
  • 云栖社区特邀专家徐雷Java Spring Boot开发实战系列课程（第20讲）：经典面试题与阿里等名企内部招聘求职面试技巧
  • 微服务架构模式与原理Spring Cloud开发实战
  • 阿里特邀专家徐雷Java Spring Boot开发实战系列课程（第18讲）：制作Java Docker镜像与推送到DockerHub和阿里云Docker仓库

    • 相关实验场景

    更多
  • 每个IT人都想学的“Web应用上云经典架构”实战
  • Rocketmq-spring入门与实践
  • 从零搭建Spring Boot的Hello World
  • 搭建Java Web开发环境
    • 下一篇
    云函数