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

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

2017-11-27 1521
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
RDS MySQL DuckDB 分析主实例，基础系列 4核8GB
RDS MySQL DuckDB 分析主实例，集群系列 4核8GB
RDS AI 助手，专业版
简介：

这个项目很简单，只是做一个简单的用户登录即可。由于我没有使用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
ssh框架
Spring开发环境
Spring hibernate
Spring实例
相关实践学习
每个IT人都想学的“Web应用上云经典架构”实战
本实验从Web应用上云这个最基本的、最普遍的需求出发，帮助IT从业者们通过“阿里云Web应用上云解决方案”，了解一个企业级Web应用上云的常见架构，了解如何构建一个高可用、可扩展的企业级应用架构。
MySQL数据库入门学习
本课程通过最流行的开源数据库MySQL带你了解数据库的世界。 &nbsp; 相关的阿里云产品：云数据库RDS MySQL 版 阿里云关系型数据库RDS（Relational Database Service）是一种稳定可靠、可弹性伸缩的在线数据库服务，提供容灾、备份、恢复、迁移等方面的全套解决方案，彻底解决数据库运维的烦恼。 了解产品详情:&nbsp;https://www.aliyun.com/product/rds/mysql&nbsp;
技术小阿哥
目录
相关文章
蓝易云
|
6月前
|
Java 数据库连接 网络安全
SSH框架的核心原理与工作流程解析
以上描述了SSH框架中各个部分的职责和大致的工作流程，详细运作时还涉及更多的组件和配置细节，每个部分都有相应的最佳实践和性能调优策略，但这些都建立在理解其核心原理基础之上。
蓝易云
501 11
啦啦啦191
|
8月前
|
Java 数据库连接 API
Java 8 + 特性及 Spring Boot 与 Hibernate 等最新技术的实操内容详解
本内容涵盖Java 8+核心语法、Spring Boot与Hibernate实操，按考试考点分类整理，含技术详解与代码示例，助力掌握最新Java技术与应用。
啦啦啦191
238 2
Quan_Chen
|
12月前
|
Java 微服务 Spring
微服务——SpringBoot使用归纳——Spring Boot中使用拦截器——拦截器使用实例
本文主要讲解了Spring Boot中拦截器的使用实例，包括判断用户是否登录和取消特定拦截操作两大场景。通过token验证实现登录状态检查，未登录则拦截请求；定义自定义注解@UnInterception实现灵活取消拦截功能。最后总结了拦截器的创建、配置及对静态资源的影响，并提供两种配置方式供选择，帮助读者掌握拦截器的实际应用。
Quan_Chen
551 0
Dylaniou
|
Java 数据库连接 数据库
让星星⭐月亮告诉你，SSH框架01、Spring概述
Spring是一个轻量级的Java开发框架，旨在简化企业级应用开发。它通过IoC（控制反转）和DI（依赖注入）降低组件间的耦合度，支持AOP（面向切面编程），简化事务管理和数据库操作，并能与多种第三方框架无缝集成，提供灵活的Web层支持，是开发高性能应用的理想选择。
Dylaniou
194 1
Yaiba123
|
XML JSON Java
使用IDEA+Maven搭建整合一个Struts2+Spring4+Hibernate4项目，混合使用传统Xml与@注解，返回JSP视图或JSON数据，快来给你的SSH老项目翻新一下吧
本文介绍了如何使用IntelliJ IDEA和Maven搭建一个整合了Struts2、Spring4、Hibernate4的J2EE项目，并配置了项目目录结构、web.xml、welcome.jsp以及多个JSP页面，用于刷新和学习传统的SSH框架。
Yaiba123
566 0
使用IDEA+Maven搭建整合一个Struts2+Spring4+Hibernate4项目，混合使用传统Xml与@注解，返回JSP视图或JSON数据，快来给你的SSH老项目翻新一下吧
香吧香
|
消息中间件 Java Kafka
Spring boot 自定义kafkaTemplate的bean实例进行生产消息和发送消息
Spring boot 自定义kafkaTemplate的bean实例进行生产消息和发送消息
香吧香
948 5
wljslmz
|
Java 数据库连接 数据库
Spring Data JPA 与 Hibernate 之区别
【8月更文挑战第21天】
wljslmz
564 0
热爱技术的小郑
|
XML Java 数据库
Spring5入门到实战------10、操作术语解释--Aspectj注解开发实例。AOP切面编程的实际应用
这篇文章是Spring5框架的实战教程，详细解释了AOP的关键术语，包括连接点、切入点、通知、切面，并展示了如何使用AspectJ注解来开发AOP实例，包括切入点表达式的编写、增强方法的配置、代理对象的创建和优先级设置，以及如何通过注解方式实现完全的AOP配置。
热爱技术的小郑
260 0
VipSoft
|
Java Spring
Spring Boot Admin 离线实例
Spring Boot Admin 离线实例
VipSoft
207 0
学编程的小程
|
SQL 缓存 Java
框架分析（9）-Hibernate
框架分析（9）-Hibernate
学编程的小程
226 2

热门文章

最新文章

  • 1
    将ssh key添加到ssh-agent使用命令ssh-add ~/.ssh/id_rsa结果报错
  • 2
    jsch jar包连接不上ssh报Algorithm negotiation fail 错误
  • 3
    linux 本地终端 SSH 连接 gcp (Google Cloud Platform ) 配置教程
  • 4
    Linux巩固篇009-Linux ssh服务管理
  • 5
    GitLab 配置 SSH 密钥（详细流程）
  • 6
    openwrt ssh scp 打开配置dropbear
  • 7
    SSH框架与SSI框架的区别
  • 8
    ssh注解要注意的
  • 9
    ssh 免密码登陆
  • 10
    完美解决窃取ssh private key问题
  • 1
    Java一分钟之-Hibernate：ORM框架实践
    318
  • 2
    Java从入门到精通：3.1.2深入学习Java EE技术——Hibernate与MyBatis等ORM框架的掌握
    229
  • 3
    使用Hibernate-Validate进行参数校验
    237
  • 4
    hibernate注解实体类（Emp.java）
    170
  • 5
    hibernate注解实体类（Dept.java）
    158
  • 6
    Hibernate中使用Criteria查询及注解——（Emp.java）
    114
  • 7
    Hibernate中使用Criteria查询及注解——（Dept.java）
    128
  • 8
    ssh(Spring+Spring mvc+hibernate)——Emp.java
    91
  • 9
    使用Hibernate JSP 303 整合到SSM项目
    143
  • 10
    Hibernate - QBC和本地SQL对象检索详解
    189

    • 相关课程

    更多
  • 全面讲解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仓库
    • 下一篇
    极速数仓ClickHouse步入云原生新纪元