利用全注解实现ssh的一个完整例子

在一个稍大的项目中，通常会有上百个组件，如果这些组件采用xml的bean定义来配置，显然会增加配置文件的体积，查找以及维护起来也不太方便。个人也不喜欢配置那么多的xml文件。下面我们就利用java的注解实现ssh框架，注解相当于一种标记加了注解就等于打上了某种标记，没加，则等于没有某种标记，以后，javac编译器，开发工具包和其他程序可以用反射来了解你的类以及各种元素上有何种标记，看你有什么标记，就去干相应的事，标记可以加载包，类，字段，方法，方法的参数以及局部变量上。关于注解在这里不多说，网上大把资料。

 

先看看完整的工程目录吧

 

 

1.为了使用注解我们需要配置web.xml文件，在web-inf目录下内容如下

[html]  view plain  copy

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <web-app version="2.5"   
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_2_5.xsd">  
7.       
8.       
9.     <!-- 加载spring配置文件 -->  
10.   <context-param>  
11.         <param-name>contextConfigLocation</param-name>  
12.         <param-value>  
13.             classpath*:applicationContext*.xml  
14.         </param-value>  
15.     </context-param>  
16.       
17.     <listener>  
18.      <listener-class>  
19.          org.springframework.web.context.ContextLoaderListener  
20.      </listener-class>  
21.  </listener>  
22.  <!-- struts2 的配置 -->  
23.  <filter>  
24.     <filter-name>struts2</filter-name>  
25.     <filter-class>  
26.         org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter  
27.     </filter-class>  
28.     <init-param>  
29.                <!--  //固定格式-->  
30.                 <param-name>actionPackages</param-name>   
31.                 <param-value>com.ssh</param-value>   
32.     </init-param>   
33.   </filter>  
34.     
35.   <filter-mapping>  
36.     <filter-name>struts2</filter-name>  
37.     <url-pattern>/*</url-pattern>  
38.   </filter-mapping>  
39.   <display-name></display-name>   
40.   <welcome-file-list>  
41.     <welcome-file>index.jsp</welcome-file>  
42.   </welcome-file-list>  
43. </web-app>  

2.接下来看看spring和hibernate的配置文件applicationContext.xml

[html]  view plain  copy

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <beans xmlns="http://www.springframework.org/schema/beans"  
3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"   
4.     xmlns:context="http://www.springframework.org/schema/context"  
5.     xmlns:aop="http://www.springframework.org/schema/aop"  
6.     xmlns:tx="http://www.springframework.org/schema/tx"  
7.     xsi:schemaLocation="  
8.             http://www.springframework.org/schema/beans  
9.             http://www.springframework.org/schema/beans/spring-beans.xsd  
10.             http://www.springframework.org/schema/context  
11.             http://www.springframework.org/schema/context/spring-context.xsd  
12.             http://www.springframework.org/schema/aop  
13.             http://www.springframework.org/schema/aop/spring-aop.xsd  
14.             http://www.springframework.org/schema/tx  
15.             http://www.springframework.org/schema/tx/spring-tx.xsd">  
16.   
17.     <!-- 使用 annotation -->  
18.     <context:annotation-config />  
19.     <!-- 使用 annotation 自动注册bean,并检查@Controller, @Service, @Repository注解已被注入 -->   
20.     <context:component-scan base-package="com.ssh" />  
21.   
22.     <!-- 数据库配置 -->  
23.     <bean id="dataSource"  
24.         class="org.apache.commons.dbcp.BasicDataSource">  
25.         <property name="driverClassName"  
26.             value="com.mysql.jdbc.Driver">  
27.         </property>  
28.         <property name="url"  
29.             value="jdbc:mysql://localhost:3306/myssh">  
30.         </property>  
31.         <property name="username" value="anan"></property>  
32.         <property name="password" value="123456"></property>  
33.     </bean>  
34.   
35.     <!-- sessionFactory -->  
36.     <bean id="sessionFactory"  
37.         class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">  
38.         <property name="dataSource">  
39.             <ref bean="dataSource" />  
40.         </property>  
41.         <property name="hibernateProperties">  
42.             <props>  
43.                 <prop key="hibernate.dialect">  
44.                     org.hibernate.dialect.MySQLDialect  
45.                 </prop>  
46.                 <prop key="hibernate.show_sql">true</prop>  
47.                 <!-- 可以自动创建数据库表(create),不创建(none) -->  
48.                 <prop key="hibernate.hbm2ddl.auto">update</prop>  
49.             </props>  
50.         </property>  
51.         <!-- 包扫描的方式加载注解类(推荐) -->  
52.         <property name="packagesToScan">  
53.             <list>  
54.                 <value>com.ssh.*</value>  
55.             </list>  
56.         </property>  
57.     </bean>  
58.   
59.     <!--JDBC事务管理器,根据你的情况使用不同的事务管理器,如果工程中有Hibernate,就用Hibernate的事务管理器 -->  
60.     <bean id="transactionManager"  
61.         class="org.springframework.jdbc.datasource.DataSourceTransactionManager">  
62.         <property name="dataSource">  
63.             <ref local="dataSource" />  
64.         </property>  
65.     </bean>  
66.   
67.     <!-- 用注解来实现事务管理 -->  
68.     <tx:annotation-driven transaction-manager="transactionManager" />  
69. </beans>  

基本都有注释了，这里不多说了，需要注意的是如果是自己搞回去用千万记得要改上面的数据库配置。

 

3.接下来我们再看看struts的配置文件struts.xml

[html]  view plain  copy

1. <?xml version="1.0" encoding="UTF-8" ?>  
2. <!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 2.1//EN" "http://struts.apache.org/dtds/struts-2.1.dtd">  
3. <struts>  
4.  <!-- 开启使用开发模式，详细错误提示 -->  
5.     <constant name="struts.devMode" value="false" />  
6.     <!-- 将对象交给spring管理 -->  
7.     <constant name="struts.objectFactory" value="spring" />  
8.     <!-- 指定资源编码类型 -->  
9.     <constant name="struts.i18n.encoding" value="UTF-8" />   
10.     <!-- 指定每次请求到达，重新加载资源文件 -->  
11.     <constant name="struts.i18n.reload" value="false" />  
12.     <!-- 指定每次配置文件更改后，自动重新加载 -->  
13.     <constant name="struts.configuration.xml.reload" value="false" />  
14.     <!-- 默认后缀名 -->  
15. <!--     <constant name="struts.action.extension" value="do,action,jhtml,," /> -->  
16.     <!-- Struts Annotation -->  
17. <!--     <constant name="actionPackages" value="com.test1"/> -->  
18. </struts>      

基本上注释写的很详细了吧，我也不是很懂就那样配置着先....

接下来我们就可以安心的写java代码了，先创建如下图所示的包和类

 

先看看实体类User.java

[java]  view plain  copy

1. package com.ssh.user.model;  
2.   
3. import javax.persistence.Column;  
4. import javax.persistence.Entity;  
5. import javax.persistence.GeneratedValue;  
6. import javax.persistence.GenerationType;  
7. import javax.persistence.Id;  
8. import javax.persistence.Table;  
9.   
10. /**      
11.  * 类名称：User    
12.  * 类描述：用户信息实体 
13.  * 创建人：anan    
14.  * 创建时间：2012-12-21 下午10:55:19    
15.  * 修改人：anan   
16.  * 修改时间：2012-12-21 下午10:55:19    
17.  * 修改备注：    
18.  * @version         
19.  * */  
20. @Entity  
21. @Table(name = "user")  
22. public class User {  
23.     /** 
24.      * 用户id 
25.      */  
26.     @Id  
27.     @Column(name = "userId")  
28.     @GeneratedValue(strategy = GenerationType.IDENTITY)  
29.     private int userId;  
30.       
31.     /** 
32.      * 用户名 
33.      */  
34.     @Column(name = "userName", length = 50)  
35.     private String userName;  
36.       
37.     /** 
38.      * 用户登录密码 
39.      */  
40.     @Column(name = "passWord", length = 50)  
41.     private String passWord;  
42.   
43.       
44.     public int getUserId() {  
45.         return userId;  
46.     }  
47.   
48.     public void setUserId(int userId) {  
49.         this.userId = userId;  
50.     }  
51.   
52.     public String getUserName() {  
53.         return userName;  
54.     }  
55.   
56.     public void setUserName(String userName) {  
57.         this.userName = userName;  
58.     }  
59.   
60.     public String getPassWord() {  
61.         return passWord;  
62.     }  
63.   
64.     public void setPassWord(String passWord) {  
65.         this.passWord = passWord;  
66.     }  
67.   
68.     public User(int userId, String userName, String passWord) {  
69.         this.userId = userId;  
70.         this.userName = userName;  
71.         this.passWord = passWord;  
72.     }  
73.   
74.     public User(String userName, String passWord) {  
75.         this.userName = userName;  
76.         this.passWord = passWord;  
77.     }  
78.   
79.     public User(int userId) {  
80.         this.userId = userId;  
81.     }  
82.   
83.     public User() {  
84.           
85.     }  
86.   
87. }  

这是一个基本的pojo类，关键看看那几个注解@Entity表示当前类是一个实体，@Table(name = "user")指定这个类映射到数据库的哪一个表，@Column(name = "userId")表示这个属性映射数据库对应表中的那一列...

接下来看看UserDao.java

[java]  view plain  copy

1. package com.ssh.user.dao;  
2.   
3. import java.util.List;  
4.   
5. import com.ssh.user.model.User;  
6.   
7. /**      
8.  * 类名称：UserDao    
9.  * 类描述：用户控制dao实现数据库操作接口 
10.  * 创建人：anan    
11.  * 创建时间：2012-12-21 下午11:05:46    
12.  * 修改人：anan   
13.  * 修改时间：2012-12-21 下午11:05:46    
14.  * 修改备注：    
15.  * @version         
16.  * */  
17. public interface UserDao {  
18.     public void addUser(User user);  
19.   
20.     public void delUser(int userId);  
21.   
22.     public void updateUser(User user);  
23.   
24.     public List<User> selectUser();  
25.   
26.     public User getUserByUserId(int userId);  
27.   
28.     public boolean isExitByName(String userName);  
29.   
30.     public boolean isExitByNameAndPass(User user);  
31. }  

这是一个接口指定用户操作，定义一些方法

接下来具体实现这些方法，看UserDaoImpl.java

[java]  view plain  copy

1. package com.ssh.user.dao.impl;  
2.   
3. import java.util.ArrayList;  
4. import java.util.Iterator;  
5. import java.util.List;  
6.   
7.   
8.   
9. import org.hibernate.Session;  
10. import org.hibernate.Transaction;  
11. import org.springframework.stereotype.Repository;  
12.   
13. import com.ssh.user.dao.UserDao;  
14. import com.ssh.user.model.User;  
15. import com.ssh.util.MyHibernateDaoSupport;  
16. /**      
17.  * 类名称：UserDaoImpl    
18.  * 类描述：用户控制dao实现数据库操作接口实现 
19.  * 创建人：anan    
20.  * 创建时间：2012-12-21 下午11:07:43    
21.  * 修改人：anan   
22.  * 修改时间：2012-12-21 下午11:07:43    
23.  * 修改备注：    
24.  * @version         
25.  * */  
26. @Repository("userDao")  
27. public class UserDaoImpl extends MyHibernateDaoSupport implements UserDao{  
28.   
29.     public void addUser(User user)  {  
30.         Session session = this.getSession(true);  
31.         Transaction tc = (Transaction) session.beginTransaction();  
32.         session.save(user);  
33.         try {  
34.             tc.commit();  
35.         } catch (Exception e) {  
36.             e.printStackTrace();  
37.         }   
38.         session.close();  
39.     }  
40.   
41.     public void delUser(int userId) {  
42.         Session session = this.getSession(true);  
43.         Transaction tc = (Transaction) session.beginTransaction();  
44.         User u = new User(userId);  
45.         session.delete(u);  
46.         try {  
47.             tc.commit();  
48.         } catch (Exception e) {  
49.             e.printStackTrace();  
50.         }   
51.         session.close();  
52.     }  
53.   
54.     public void updateUser(User user) {  
55.         Session session = this.getSession(true);  
56.         Transaction tc = (Transaction) session.beginTransaction();  
57.         session.update(user);  
58.         try {  
59.             tc.commit();  
60.         } catch (Exception e) {  
61.             e.printStackTrace();  
62.         }  
63.         session.close();  
64.           
65.     }  
66.   
67.     public List<User> selectUser()  {  
68.         List<User> users = new ArrayList<User>();  
69.         Session session = this.getSession(true);  
70.         Transaction tc = (Transaction) session.beginTransaction();  
71.         List list = session.createQuery("From User").list();  
72.         for (Iterator iterator = list.iterator(); iterator.hasNext();) {  
73.             User u = (User) iterator.next();  
74.             users.add(u);  
75.         }  
76.         try {  
77.             tc.commit();  
78.         } catch (Exception e) {  
79.             e.printStackTrace();  
80.         }  
81.         session.close();  
82.         return users;  
83.     }  
84.   
85.     public User getUserByUserId(int userId)  {  
86.         Session session = this.getSession(true);  
87.         Transaction tc = (Transaction) session.beginTransaction();  
88.         //load 是说明数据库中一定存在这条记录，没有则报出：ObjectNotFoundException  
89.         //get 如果查不到记录，返回的是一个null  
90.         User user = (User)session.load(User.class, userId);  
91.         try {  
92.             tc.commit();  
93.         } catch (Exception e) {  
94.             e.printStackTrace();  
95.         }  
96.         session.close();  
97.         return user;  
98.     }  
99.   
100.     public boolean isExitByName(String userName)  {  
101.         Session session = this.getSession(true);  
102.         Transaction tc = (Transaction) session.beginTransaction();  
103.         List user = (List)session.createQuery("From User u where u.userName=:userName").setString("userName", userName).list();  
104.         if(user.size()>0){  
105.             try {  
106.                 tc.commit();  
107.             } catch (Exception e) {  
108.                 e.printStackTrace();  
109.             }  
110.             session.close();  
111.             return true;  
112.         }  
113.         try {  
114.             tc.commit();  
115.         } catch (Exception e) {  
116.             e.printStackTrace();  
117.         }  
118.         session.close();  
119.         return false;  
120.     }  
121.   
122.     public boolean isExitByNameAndPass(User user)  {  
123.         Session session = this.getSession(true);  
124.         Transaction tc = (Transaction) session.beginTransaction();  
125.         List users = (List)session.createQuery("From User u where u.userName=:userName and u.passWord=:passWord").setString("userName", user.getUserName()).setString("passWord", user.getPassWord()).list();  
126.           
127.         if(users.size()>0){  
128.             try {  
129.                 tc.commit();  
130.             } catch (Exception e) {  
131.                 e.printStackTrace();  
132.             }  
133.             session.close();  
134.             return true;  
135.         }  
136.         try {  
137.             tc.commit();  
138.         } catch (Exception e) {  
139.             e.printStackTrace();  
140.         }  
141.         session.close();  
142.         return false;  
143.     }  
144.   
145. }  

到这里数据库操作基本搞完，接下来写业务逻辑代码，先看看UserService.java

 

[java]  view plain  copy

1. package com.ssh.user.service;  
2.   
3. import java.util.List;  
4.   
5. import com.ssh.user.model.User;  
6.   
7.   
8. /**      
9.  * 类名称：UserService    
10.  * 类描述：用户业务逻辑接口 
11.  * 创建人：anan    
12.  * 创建时间：2012-12-21 下午10:58:32    
13.  * 修改人：anan   
14.  * 修改时间：2012-12-21 下午10:58:32    
15.  * 修改备注：    
16.  * @version         
17.  * */  
18. public interface UserService {  
19.     /** 
20.      * 判断用户是否存在 
21.      * @param userName 
22.      * @return user 
23.      * @  
24.      * */  
25.     public boolean isExitUser(String userName) ;  
26.       
27.     /** 
28.      * 判断用户是否存在 
29.      * @param userName passWord 
30.      * @return user 
31.      * @  
32.      * */  
33.     public boolean isExitByNameAndPass(User user) ;  
34.       
35.     /** 
36.      * 保存用户 
37.      * @param user 
38.      * @return boolean 
39.      * @  
40.      * */  
41.     public void save(User user) ;  
42.       
43.     /** 
44.      * 查询所有用户 
45.      * @param  
46.      * @return List<User> 
47.      * @  
48.      * */  
49.     public List<User> getUsers() ;  
50.     /** 
51.      * 删除用户 
52.      * @param userId 
53.      * @return  
54.      * @  
55.      * */  
56.     public void del(int userId) ;  
57.       
58.     /** 
59.      * 修改用户 
60.      * @param user 
61.      * @return  
62.      * @  
63.      * */  
64.     public void update(User user) ;  
65.       
66.     /** 
67.      * 根据id获得user 
68.      * @param userId 
69.      * @return user 
70.      * @  
71.      * */  
72.     public User getUserById(int userId) ;  
73.       
74.       
75. }  

这个只是一个接口，定义我们接下来需要的方法。下面是具体的实现类UserServiceImpl.java

[java]  view plain  copy

1. package com.ssh.user.service.Impl;  
2.   
3. import java.util.List;  
4.   
5. import javax.annotation.Resource;  
6.   
7. import org.springframework.stereotype.Service;  
8. import org.springframework.transaction.annotation.Propagation;  
9. import org.springframework.transaction.annotation.Transactional;  
10.   
11. import com.ssh.user.dao.UserDao;  
12. import com.ssh.user.model.User;  
13. import com.ssh.user.service.UserService;  
14.   
15.   
16. /**      
17.  * 类名称：UserServiceImpl    
18.  * 类描述：用户信息操作业务逻辑接口实现 
19.  * 创建人：anan    
20.  * 创建时间：2012-12-21 下午11:08:18    
21.  * 修改人：anan   
22.  * 修改时间：2012-12-21 下午11:08:18    
23.  * 修改备注：    
24.  * @version         
25.  * */  
26. @Service  
27. public class UserServiceImpl implements UserService {  
28.     @Resource  
29.     private UserDao userDao;  
30.   
31.     public boolean isExitUser(String userName) {  
32.         return userDao.isExitByName(userName);  
33.     }  
34.   
35.     public void save(User user) {  
36.         userDao.addUser(user);  
37.     }  
38.   
39.     public List<User> getUsers() {  
40.         List<User> users = userDao.selectUser();  
41.         return users;  
42.     }  
43.   
44.     public void del(int userId) {  
45.         userDao.delUser(userId);  
46.   
47.     }  
48.   
49.     public void update(User user) {  
50.         userDao.updateUser(user);  
51.   
52.     }  
53.   
54.     public User getUserById(int userId) {  
55.         return userDao.getUserByUserId(userId);  
56.     }  
57.   
58.     public boolean isExitByNameAndPass(User user) {  
59.         return userDao.isExitByNameAndPass(user);  
60.     }  
61.   
62. }  

业务逻辑在这里包括了判断用户是否存在，保存用户信息，获取用户信息，删除用户，更新用户信息等

通过上面两个类业务逻辑层也就完成了，接下来写视图控制器，这里只是写了一个简单的登录控制器LoginAction.java

[java]  view plain  copy

1. package com.ssh.user.action;  
2.   
3. import javax.annotation.Resource;  
4.   
5. import org.apache.struts2.convention.annotation.Action;  
6. import org.apache.struts2.convention.annotation.Result;  
7.   
8. import com.opensymphony.xwork2.ActionSupport;  
9. import com.ssh.user.dao.UserDao;  
10. import com.ssh.user.model.User;  
11.   
12. /**      
13.  * 类名称：LoginAction    
14.  * 类描述：用户控制器的实现 
15.  * 创建人：anan    
16.  * 创建时间：2012-12-21 下午11:17:36    
17.  * 修改人：anan   
18.  * 修改时间：2012-12-21 下午11:17:36    
19.  * 修改备注：    
20.  * @version         
21.  * */  
22. @Action(value = "loginAction", results = {  
23.         @Result(name = "loginSuccess", location = "/loginSuss.jsp"),  
24.         @Result(name = "loginFailer", location = "/loginFailer.jsp") })  
25. public class LoginAction extends ActionSupport {  
26.     private static final long serialVersionUID = -2266695172069461659L;  
27.     @Resource  
28.     private UserDao userDao;  
29.     private User user;  
30.       
31.     public User getUser() {  
32.         return user;  
33.     }  
34.   
35.     public void setUser(User user) {  
36.         this.user = user;  
37.     }  
38.   
39.     public String login(){  
40.         boolean flag = userDao.isExitByNameAndPass(user);  
41.         if(flag){  
42.             return "loginSuccess";  
43.         }  
44.         return "loginFailer";  
45.     }  
46. }  

这个就是控制层。

再写几个jsp文件来测试一下

 

内容如下：

index.jsp

[html]  view plain  copy

1. <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>  
2. <%@taglib prefix="s" uri="/struts-tags"%>  
3. <%  
4. String path = request.getContextPath();  
5. String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+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 'index.jsp' starting page</title>  
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.   </head>  
23.     
24.   <body>  
25.          <s:form action="loginAction!login">  
26.               <s:textfield name="user.userName" label="userName"></s:textfield>  
27.               <s:textfield name="user.passWord" label="passWord"></s:textfield>  
28.               <s:submit value="login"></s:submit>  
29.          </s:form>  
30.   </body>  
31. </html>  

loginFailer.jsp

[html]  view plain  copy

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 'loginFailer.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.                   登录失败  </body>  
27. </html>  

loginSuss.jsp

[html]  view plain  copy

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 'loginSuss.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.     登录成功 <br>  
27.   </body>  
28. </html>  

启动tomcat我们可以看到数据库自动生成一个user表。我们添加一条记录为下面测试

 

 

接下来打开浏览器，输入http://localhost:8080/ssh/可以看到下图页面就可以测试了

 

 

觉得使用了ssh结构之后整个工程的层次感就那样出来了。搞鼓一下收获还是蛮大的，基于注解的ssh是比xml方便很多，看大家喜欢吧

源码下地址

http://download.csdn.net/detail/yunji3344/4915649