SSH框架总结(环境搭建+框架分析+实例源码下载)

关注

最新推荐文章于 2026-01-24 22:08:31 发布 759 阅读 AI 写同款· GEO 优化 ›

SSH框架实战项目源码解析：高效构建企业级应用本文还有配套的精品资源，点击获取简介：SSH框架是Struts、Spring和Hibernate三个Java Web开发框架的组合，用于构建高效的企业级应用程序。Struts负责基于MVC模式处理Web请求，Spring提供依赖注入和面向切面编程，Hibernate简化数据库操作。本压缩包包含了一个经过测试的SSH项目实例，涵盖了Struts的Action处理、Sprin... 阅读详情

SSH框架总结(环境搭建+框架分析+实例源码下载)

一、SSH框架简介

　　SSH是struts+spring+hibernate集成的web应用程序开源框架。
　　Struts：用来控制的，核心控制器是Controller。
　　Spring：对Struts和Hibernate进行管理，整合的。
　　Hiernate：操控数据库

　　struts标签库：Struts2默认的表达式语言是OGNL(Object-Graph Navigation Language)，通过它可以存取对象的任意属性、调用对象的方法、遍历整个对象的结构图、实现字段类型转换等功能。
　　JSP: HTML文件中插入Java程序段和JSP标记。
　　web.xml: Struts2核心过滤器和监听器
　　struts.xml: 管理应用中的Action映射，及Action处理结果和物理资源之间的映射。
　　applicationContext.xml: 整合了struts和Hibernate。
　　*.hbm.xml:O/R Mapping(Object Relational Mapping)映射文件，实体和表的映射关系通过XML来描述的文件。在项目启动的时候加载到内存中。
　　PO：Persistent Object，持久化对象
　　整体的调用关系：JSP–Action–Service–DAO–PO–数据库

　　在表示层中，首先通过JSP页面实现交互，负责接收请求（request）和传送请求（response），Struts根据配置文件（struts.xml）将ActionServlet（Struts的内置核心控制器组件）接收到的Request请求委派给Action处理。
　　在业务层中，管理服务器组建的Spring IOC容器负责向Action提供业务模型（Model）组件和该组件的协作对象数据处理（DAO）组建完成业务逻辑，并提供事务处理、缓冲池等容器组件以提升和保持数据的完整性。
　　在持久层，依赖于Hibernate的对象化映射和数据库交互，处理DAO组建请求的数据，并返回处理结果。

SSH框架优点：
1.spring管理对象的实例化，把对象的创建和获取放到外部，更加的灵活方便。
2.Hibernate避免了JDBC连接数据库的冗余繁杂。
3.各层分工明细，实现了各层之间的解耦，代码更加灵活。

二、环境搭建

1.IDEA新建maven-webapp项目

2.Maven配置Struts，Spring，Hibernate依赖组件

pom.xml

3.配置web.xml

web.xml

4.配置struts.xml

struts.xml

5.配置applicationContext.xml

applicationContext.xml

6.配置hibernate.cfg.xml

hibernate.cfg.xml

7.配置 .hbm.xml

.hbm.xml

8.数据库连接

db-config.properties

三、框架分析

1.建立Action

  1 package com.zsm.ssh.action;
  2 
  3 import com.opensymphony.xwork2.ActionSupport;
  4 import com.zsm.ssh.model.User;
  5 import com.zsm.ssh.service.UserService;
  6 import net.sf.json.JSONObject;
  7 import org.apache.struts2.ServletActionContext;
  8 import org.apache.struts2.convention.annotation.Action;
  9 import org.apache.struts2.convention.annotation.Namespace;
 10 import org.apache.struts2.convention.annotation.ParentPackage;
 11 import org.apache.struts2.convention.annotation.Result;
 12 import org.springframework.beans.factory.annotation.Autowired;
 13 
 14 import javax.servlet.http.HttpServletRequest;
 15 import javax.servlet.http.HttpServletResponse;
 16 import java.io.PrintWriter;
 17 
 18 
 19 /**
 20  * @Author: zengsm.
 21  * @Description:
 22  * @Date:Created in 2017/12/6 15:45.
 23  * @Modified By:
 24  */
 25 //默认可以不写
 26 @ParentPackage("struts-default")
 27 //根命名空间,可以不写
 28 @Namespace("/")
 29 //全局配置,如果方法上不指定result,则使用该Result
 30 //@Results({@Result(name="success",location="/success.jsp"),
 31 //    @Result(name="error",location="/error.jsp")})
 32 public class UserAction extends ActionSupport
 33 {
 34     //前台传到后台需要set，后台传到前台需要get
 35     // 用户名-必须与页面请求的对应表单username值相同
 36     private String username;
 37 
 38     // 密码必须与页面请求的对应表单password值相同
 39     private String password;
 40 
 41     private String resultJson;
 42 
 43     /*
 44     * struts 接收参数三种方式：属性方式接收，JavaBean方式接收，ModelDriven方式接收参数,前两种都必须设置get和set方法
 45     * */
 46     //Spring 注入方式
 47     @Autowired
 48     private UserService userService;
 49 
 50     //@Action(value="login")
 51     @Action(value = "login", results = {
 52         @Result(name = "success", location = "/success.jsp", params = {"resultJson", "resultJson"}),
 53         @Result(name = "error", location = "/error.jsp")})
 54     public String execute() throws Exception
 55     {
 56         HttpServletResponse response = ServletActionContext.getResponse();
 57         HttpServletRequest request = ServletActionContext.getRequest();
 58 
 59         JSONObject result = new JSONObject();
 60         User user = userService.getByName(username);
 61         result.put("user", user);
 62 
 63         if (user != null && user.getUser_name().equals(username) && user.getPassword().equals(password))
 64         {
 65             result.put("message", "登录成功");
 66             result.put("status", "true");
 67             resultJson = result.toString();
 68             request.setAttribute("resultJson", resultJson);
 69             writeResponseData(request, response, result);
 70             return "success";
 71         }
 72         result.put("message", "登录失败");
 73         result.put("status", "false");
 74         resultJson = result.toString();
 75         writeResponseData(request, response, result);
 76         return "error";
 77     }
 78 
 79     private void writeResponseData(HttpServletRequest request, HttpServletResponse response, Object data)
 80     {
 81         response.setContentType("text/html;charset=utf-8");
 82         try
 83         {
 84             PrintWriter out = response.getWriter();
 85             out.println(data.toString());
 86         }
 87         catch (Exception e)
 88         {
 89             e.printStackTrace();
 90         }
 91     }
 92 
 93     public String getUsername()
 94     {
 95         return username;
 96     }
 97 
 98     public void setUsername(String username)
 99     {
100         this.username = username;
101     }
102 
103     public void setPassword(String password)
104     {
105         this.password = password;
106     }
107 
108     public String getResultJson()
109     {
110         return resultJson;
111     }
112 
113     public void setResultJson(String resultJson)
114     {
115         this.resultJson = resultJson;
116     }
117 }

2.建立Service接口和实现类

 1 package com.zsm.ssh.service;
 2 
 3 import com.zsm.ssh.model.User;
 4 
 5 import java.util.List;
 6 
 7 
 8 /**
 9  * @Author: zengsm.
10  * @Description:
11  * @Date:Created in 2017/12/6 15:30.
12  * @Modified By:
13  */
14 public interface UserService
15 {
16     List<User> findAllUser();
17 
18     int saveEntity(User user);
19 
20     boolean saveOrUpdateEntity(User user);
21 
22     boolean updateEntity(User user);
23 
24     User getByName(String name);
25 
26     User getByNo(String no);
27 
28     boolean deleteUserById(Integer id);
29 
30     boolean deleteUserByNo(String no);
31 
32     boolean deleteUserByEntity(User user);
33 }

  1 package com.zsm.ssh.service.impl;
  2 
  3 import com.zsm.ssh.dao.UserDao;
  4 import com.zsm.ssh.model.User;
  5 import com.zsm.ssh.service.UserService;
  6 import org.springframework.beans.factory.annotation.Autowired;
  7 import org.springframework.stereotype.Service;
  8 import org.springframework.transaction.annotation.Transactional;
  9 
 10 import java.util.List;
 11 
 12 
 13 /**
 14  * @Author: zengsm.
 15  * @Description:
 16  * @Date:Created in 2017/12/6 15:31.
 17  * @Modified By:
 18  */
 19 @Service("userService")
 20 @Transactional
 21 public class UserServiceImpl implements UserService
 22 {
 23     @Autowired
 24     private UserDao userDao;
 25 
 26     @Override
 27     public List<User> findAllUser()
 28     {
 29         List<User> allUser = userDao.findAllUser();
 30         return allUser;
 31     }
 32 
 33     @Override
 34     public int saveEntity(User user)
 35     {
 36         int id = userDao.saveEntity(user);
 37         return id;
 38     }
 39 
 40     @Override
 41     public boolean saveOrUpdateEntity(User user)
 42     {
 43         try
 44         {
 45             userDao.saveOrUpdateEntity(user);
 46             return true;
 47         }
 48         catch (Exception e)
 49         {
 50             e.printStackTrace();
 51             return false;
 52         }
 53     }
 54 
 55     @Override
 56     public boolean updateEntity(User user)
 57     {
 58         try
 59         {
 60             userDao.updateEntity(user);
 61             return true;
 62         }
 63         catch (Exception e)
 64         {
 65             e.printStackTrace();
 66             return false;
 67         }
 68     }
 69 
 70     @Override
 71     public User getByName(String name)
 72     {
 73         try
 74         {
 75             User user = userDao.getByName(name);
 76             return user;
 77         }
 78         catch (Exception e)
 79         {
 80             e.printStackTrace();
 81             return null;
 82         }
 83     }
 84 
 85     @Override
 86     public User getByNo(String no)
 87     {
 88         try
 89         {
 90             User user = userDao.getByNo(no);
 91             return user;
 92         }
 93         catch (Exception e)
 94         {
 95             e.printStackTrace();
 96             return null;
 97         }
 98     }
 99 
100     @Override
101     public boolean deleteUserById(Integer id)
102     {
103         try
104         {
105             userDao.deleteUserById(id);
106             return true;
107         }
108         catch (Exception e)
109         {
110             e.printStackTrace();
111             return false;
112         }
113     }
114 
115     @Override
116     public boolean deleteUserByNo(String no)
117     {
118         try
119         {
120             userDao.deleteUserByNo(no);
121             return true;
122         }
123         catch (Exception e)
124         {
125             e.printStackTrace();
126             return false;
127         }
128     }
129 
130     @Override
131     public boolean deleteUserByEntity(User user)
132     {
133         try
134         {
135             userDao.deleteUserByEntity(user);
136             return true;
137         }
138         catch (Exception e)
139         {
140             e.printStackTrace();
141             return false;
142         }
143     }
144 }

3.建立Dao接口和实现类

 1 package com.zsm.ssh.dao;
 2 
 3 import com.zsm.ssh.model.User;
 4 
 5 import java.util.List;
 6 
 7 
 8 /**
 9  * @Author: zengsm.
10  * @Description:
11  * @Date:Created in 2017/12/6 15:32.
12  * @Modified By:
13  */
14 public interface UserDao
15 {
16     List<User> findAllUser();
17 
18     int saveEntity(User user);
19 
20     void saveOrUpdateEntity(User user);
21 
22     void updateEntity(User user);
23 
24     User getByName(String name);
25 
26     User getByNo(String no);
27 
28     void deleteUserById(Integer id);
29 
30     void deleteUserByNo(String no);
31 
32     void deleteUserByEntity(User user);
33 }

  1 package com.zsm.ssh.dao.impl;
  2 
  3 import com.zsm.ssh.dao.UserDao;
  4 import com.zsm.ssh.model.User;
  5 import org.hibernate.Query;
  6 import org.hibernate.Session;
  7 import org.hibernate.SessionFactory;
  8 import org.springframework.beans.factory.annotation.Autowired;
  9 import org.springframework.orm.hibernate4.support.HibernateDaoSupport;
 10 import org.springframework.stereotype.Repository;
 11 import org.springframework.transaction.annotation.Propagation;
 12 import org.springframework.transaction.annotation.Transactional;
 13 
 14 import java.util.List;
 15 
 16 
 17 /**
 18  * @Author: zengsm.
 19  * @Description:
 20  * @Date:Created in 2017/12/6 15:36.
 21  * @Modified By:
 22  */
 23 @Repository("userDao")
 24 public class UserDaoImpl extends HibernateDaoSupport implements UserDao
 25 {
 26     //这里的属性名一定要和配置中的属性名一致
 27     @Autowired
 28     private SessionFactory sessionFactory;
 29 
 30     @Override
 31     @Transactional(propagation = Propagation.REQUIRED)
 32     public List<User> findAllUser()
 33     {
 34         Session session = sessionFactory.openSession();
 35         //将所有的数据查询出来并放到List集合里 User是表对应的实例名称
 36         List<User> list = session.createQuery("from User").list();
 37         session.close();
 38         return list;
 39     }
 40 
 41     @Override
 42     @Transactional(propagation = Propagation.REQUIRED)
 43     public int saveEntity(User user)
 44     {
 45         Session session = sessionFactory.getCurrentSession();
 46         //返回插入数据id
 47         Object id = session.save(user);
 48         return Integer.valueOf(id.toString());
 49     }
 50 
 51     @Override
 52     @Transactional(propagation = Propagation.REQUIRED)
 53     public void saveOrUpdateEntity(User user)
 54     {
 55         Session session = sessionFactory.getCurrentSession();
 56         session.saveOrUpdate(user);
 57     }
 58 
 59     @Override
 60     @Transactional(propagation = Propagation.REQUIRED)
 61     public void updateEntity(User user)
 62     {
 63         Session session = sessionFactory.getCurrentSession();
 64         session.update(user);
 65     }
 66 
 67     @Override
 68     @Transactional(propagation = Propagation.REQUIRED)
 69     public User getByName(String name)
 70     {
 71         Session session = sessionFactory.getCurrentSession();
 72         //根据id查询,结果返回 User.class
 73         User user = (User)session.get(User.class, 2);
 74         //将所有的数据查询出来并放到List集合里 User是表对应的实例名称
 75         List users = session.createQuery("from User where user_name='" + name + "'").list();
 76         return (User)users.get(0);
 77     }
 78 
 79     @Override
 80     @Transactional(propagation = Propagation.REQUIRED)
 81     public User getByNo(String no)
 82     {
 83         Session session = sessionFactory.getCurrentSession();
 84         List users = session.createQuery("from User where user_no='" + no + "'").list();
 85         return (User)users.get(0);
 86     }
 87 
 88     @Override
 89     @Transactional(propagation = Propagation.REQUIRED)
 90     public void deleteUserById(Integer id)
 91     {
 92         Session session = sessionFactory.getCurrentSession();
 93         String sql = "delete from User where id=:id";
 94         Query query = session.createQuery(sql);
 95         query.setParameter("id", id);
 96         query.executeUpdate();
 97     }
 98 
 99     @Override
100     @Transactional(propagation = Propagation.REQUIRED)
101     public void deleteUserByNo(String no)
102     {
103         Session session = sessionFactory.getCurrentSession();
104         String sql = "delete from User where user_no=:no";
105         Query query = session.createQuery(sql);
106         query.setParameter("no", no);
107         query.executeUpdate();
108     }
109 
110     @Override
111     @Transactional(propagation = Propagation.REQUIRED)
112     public void deleteUserByEntity(User user)
113     {
114         Session session = sessionFactory.getCurrentSession();
115         //传入实例对象，比较id删除对应行，，没有id匹配就不删除
116         session.delete(User.class.getName(), user);
117     }
118 }