基于SSH框架的流浪动物领养平台 - 源码深度解析

SSH框架JavaJavaScriptHTMLCSSMySQL
2026-02-128 浏览

文章摘要

本项目是一款基于SSH（Struts2 + Spring + Hibernate）框架开发的流浪动物领养平台，旨在解决流浪动物救助信息分散、领养流程不透明、管理效率低下等核心痛点。平台通过线上化整合救助资源，为流浪动物与潜在领养人建立可信赖的连接渠道，其核心业务价值在于提升领养匹配效率、规范领养流程...

流浪动物领养平台技术解析

流浪动物救助与领养一直是社会关注的重要议题，传统线下模式存在信息不对称、流程不透明、管理效率低等问题。本平台通过技术手段构建了一个完整的线上领养生态系统，将流浪动物信息数字化、领养流程标准化，为救助机构和领养人提供高效便捷的服务。

系统架构与技术栈

平台采用经典的SSH（Struts2 + Spring + Hibernate）框架组合，构建了分层清晰、耦合度低的企业级应用架构。表现层使用Struts2框架处理用户请求与页面跳转，通过配置struts.xml文件定义Action映射关系，实现请求的精准路由。

<!-- struts.xml配置示例 -->
<action name="petAction_*" class="petAction" method="{1}">
    <result name="success">/pet_list.jsp</result>
    <result name="input">/pet_edit.jsp</result>
</action>

业务层基于Spring框架的IoC容器实现组件管理，通过依赖注入降低各层之间的耦合度。声明式事务管理确保业务操作的数据一致性。

<!-- applicationContext.xml事务配置 -->
<bean id="transactionManager" 
      class="org.springframework.orm.hibernate3.HibernateTransactionManager">
    <property name="sessionFactory" ref="sessionFactory"/>
</bean>

<tx:advice id="txAdvice" transaction-manager="transactionManager">
    <tx:attributes>
        <tx:method name="save*" propagation="REQUIRED"/>
        <tx:method name="update*" propagation="REQUIRED"/>
    </tx:attributes>
</tx:advice>

数据持久层采用Hibernate ORM框架，通过实体类与数据库表的映射关系，简化数据操作。HQL查询语言提供了面向对象的数据库访问方式。

// Hibernate实体映射示例
@Entity
@Table(name = "t_user")
public class User implements Serializable {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;
    
    @Column(name = "username", length = 255)
    private String username;
    
    @Column(name = "password", length = 255)
    private String password;
    
    // 其他字段和方法
}

数据库设计亮点分析

用户表设计优化

用户表（t_user）的设计体现了对系统安全性和扩展性的充分考虑：

CREATE TABLE `t_user` (
  `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '主键ID',
  `address` varchar(255) DEFAULT NULL COMMENT '地址',
  `ctime` varchar(255) DEFAULT NULL COMMENT '创建时间',
  `password` varchar(255) DEFAULT NULL COMMENT '密码',
  `phone` varchar(255) DEFAULT NULL COMMENT '手机号',
  `role` int(11) NOT NULL COMMENT '角色',
  `truename` varchar(255) DEFAULT NULL COMMENT '真实姓名',
  `userlock` int(11) NOT NULL COMMENT '用户锁定状态',
  `username` varchar(255) DEFAULT NULL COMMENT '用户名',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8 COLLATE=utf8_general_ci COMMENT='用户表'

设计亮点分析：

  1. 角色权限控制：role字段实现了基于角色的访问控制（RBAC），支持普通用户、救助站管理员、系统管理员等多级权限管理
  2. 安全机制完善：userlock字段提供账户锁定功能，防止暴力破解攻击
  3. 信息完整性：包含真实姓名、手机号等必要信息，确保领养流程的真实性验证
  4. 索引优化：主键ID自增设计提高查询效率，适合高并发场景

用户管理界面

订单表结构设计

订单表（t_orderform）的设计支持复杂的业务场景：

CREATE TABLE `t_orderform` (
  `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '主键ID',
  `address` varchar(255) DEFAULT NULL COMMENT '收货地址',
  `createtime` varchar(255) DEFAULT NULL COMMENT '创建时间',
  `details` text DEFAULT NULL COMMENT '订单详情',
  `name` varchar(255) DEFAULT NULL COMMENT '收货人姓名',
  `orderid` varchar(255) DEFAULT NULL COMMENT '订单编号',
  `payment` varchar(255) DEFAULT NULL COMMENT '支付方式',
  `phone` varchar(255) DEFAULT NULL COMMENT '联系电话',
  `remark` text DEFAULT NULL COMMENT '备注',
  `status` varchar(255) DEFAULT NULL COMMENT '订单状态',
  `total` double NOT NULL COMMENT '订单总额',
  `userid` int(11) DEFAULT NULL COMMENT '用户ID',
  `pids` varchar(255) DEFAULT NULL COMMENT '商品ID集合',
  `psl` varchar(255) DEFAULT NULL COMMENT '商品数量集合',
  PRIMARY KEY (`id`),
  KEY `FK7F0556E748E361B6` (`userid`),
  CONSTRAINT `FK7F0556E748E361B6` FOREIGN KEY (`userid`) REFERENCES `t_user` (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=8 DEFAULT CHARSET=utf8 COLLATE=utf8_general_ci COMMENT='订单表'

技术特色：

  1. 状态管理灵活：status字段使用varchar类型，支持多种订单状态（待审核、已通过、已完成等）
  2. 数据冗余设计：虽然存在用户表外键关联，但仍存储收货地址、联系方式等冗余信息，确保历史订单数据的完整性
  3. 商品信息存储：pids和psl字段采用集合存储方式，支持一个订单包含多个领养申请
  4. 外键约束：通过外键确保数据一致性，防止孤儿记录产生

订单管理界面

核心功能实现解析

宠物信息管理系统

宠物管理模块采用MVC模式实现，Action层处理业务逻辑，Service层实现数据操作，DAO层负责持久化。

// PetAction.java - 宠物相关请求处理
public class PetAction extends ActionSupport {
    private PetService petService;
    private List<Pet> petList;
    private Pet pet;
    private Integer petId;
    
    // 获取宠物列表
    public String list() {
        petList = petService.findAllPets();
        return SUCCESS;
    }
    
    // 根据ID查询宠物详情
    public String detail() {
        pet = petService.findPetById(petId);
        return SUCCESS;
    }
    
    // 添加新宠物
    public String add() {
        try {
            petService.savePet(pet);
            addActionMessage("宠物信息添加成功！");
        } catch (Exception e) {
            addActionError("添加失败：" + e.getMessage());
            return INPUT;
        }
        return SUCCESS;
    }
    
    // Getter和Setter方法
    public PetService getPetService() { return petService; }
    public void setPetService(PetService petService) { 
        this.petService = petService; 
    }
    // 其他getter/setter...
}

// PetServiceImpl.java - 宠物业务逻辑实现
@Service("petService")
@Transactional
public class PetServiceImpl implements PetService {
    
    @Autowired
    private PetDAO petDAO;
    
    @Override
    @Transactional(readOnly = true)
    public List<Pet> findAllPets() {
        return petDAO.findAll();
    }
    
    @Override
    @Transactional(readOnly = true)
    public Pet findPetById(Integer id) {
        return petDAO.findById(id);
    }
    
    @Override
    public void savePet(Pet pet) {
        petDAO.save(pet);
    }
    
    @Override
    public void updatePet(Pet pet) {
        petDAO.update(pet);
    }
    
    @Override
    public void deletePet(Integer id) {
        Pet pet = petDAO.findById(id);
        if (pet != null) {
            petDAO.delete(pet);
        }
    }
}

宠物管理界面

购物车与订单流程

购物车模块实现商品暂存、数量调整、价格计算等功能，通过Session管理用户购物车状态。

// CartAction.java - 购物车功能实现
public class CartAction extends ActionSupport {
    private CartService cartService;
    private User user;
    private Integer productId;
    private Integer quantity;
    private Double totalAmount;
    
    // 添加商品到购物车
    public String addToCart() {
        User currentUser = (User) ActionContext.getContext()
                            .getSession().get("currentUser");
        if (currentUser == null) {
            addActionError("请先登录！");
            return LOGIN;
        }
        
        try {
            cartService.addItemToCart(currentUser.getId(), 
                                    productId, quantity);
            addActionMessage("商品已成功添加到购物车！");
        } catch (Exception e) {
            addActionError("添加失败：" + e.getMessage());
            return ERROR;
        }
        return SUCCESS;
    }
    
    // 更新购物车商品数量
    public String updateCart() {
        User currentUser = (User) ActionContext.getContext()
                            .getSession().get("currentUser");
        cartService.updateCartItem(currentUser.getId(), 
                                 productId, quantity);
        return SUCCESS;
    }
    
    // 计算购物车总价
    public String calculateTotal() {
        User currentUser = (User) ActionContext.getContext()
                            .getSession().get("currentUser");
        totalAmount = cartService.calculateTotal(currentUser.getId());
        return SUCCESS;
    }
}

// OrderService.java - 订单业务逻辑
@Service("orderService")
@Transactional
public class OrderServiceImpl implements OrderService {
    
    @Autowired
    private OrderDAO orderDAO;
    
    @Autowired
    private CartService cartService;
    
    @Override
    public String createOrder(Integer userId, String address, 
                            String payment) {
        // 获取用户购物车信息
        List<Cart> cartItems = cartService.getCartByUserId(userId);
        if (cartItems.isEmpty()) {
            throw new RuntimeException("购物车为空，无法创建订单");
        }
        
        // 计算订单总价
        Double total = calculateOrderTotal(cartItems);
        
        // 生成订单号
        String orderId = generateOrderId();
        
        // 创建订单对象
        Order order = new Order();
        order.setOrderid(orderId);
        order.setUserid(userId);
        order.setAddress(address);
        order.setPayment(payment);
        order.setTotal(total);
        order.setCreatetime(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss")
                          .format(new Date()));
        order.setStatus("待处理");
        
        // 保存订单
        orderDAO.save(order);
        
        // 清空购物车
        cartService.clearCart(userId);
        
        return orderId;
    }
    
    private Double calculateOrderTotal(List<Cart> cartItems) {
        return cartItems.stream()
                .mapToDouble(item -> item.getTotal() * item.getZhekou())
                .sum();
    }
    
    private String generateOrderId() {
        return "ORD" + System.currentTimeMillis() + 
               String.valueOf((int)(Math.random() * 1000));
    }
}

提交订单界面

用户权限管理系统

系统实现基于角色的权限控制，不同角色拥有不同的操作权限。

// 用户登录验证
public class LoginAction extends ActionSupport {
    private String username;
    private String password;
    private UserService userService;
    
    public String execute() {
        try {
            User user = userService.authenticate(username, password);
            if (user != null) {
                if (user.getUserlock() == 1) {
                    addActionError("账户已被锁定，请联系管理员");
                    return ERROR;
                }
                
                // 将用户信息存入Session
                ActionContext.getContext().getSession()
                    .put("currentUser", user);
                
                // 根据角色跳转到不同页面
                if (user.getRole() == 0) {
                    return "user";
                } else if (user.getRole() == 1) {
                    return "admin";
                } else {
                    return "rescue";
                }
            } else {
                addActionError("用户名或密码错误");
                return ERROR;
            }
        } catch (Exception e) {
            addActionError("登录失败：" + e.getMessage());
            return ERROR;
        }
    }
}

<!-- 权限拦截器配置 -->
<interceptors>
    <interceptor name="authInterceptor" 
                class="com.example.interceptor.AuthInterceptor"/>
    <interceptor-stack name="authStack">
        <interceptor-ref name="authInterceptor"/>
        <interceptor-ref name="defaultStack"/>
    </interceptor-stack>
</interceptors>

<action name="admin_*" class="adminAction" method="{1}">
    <interceptor-ref name="authStack"/>
    <result name="success">/admin/{1}.jsp</result>
    <result name="login">/login.jsp</result>
</action>

图片管理系统

图片表设计支持多用途图片存储，包括宠物照片、救助站环境图等。

CREATE TABLE `t_pic` (
  `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '主键ID',
  `href` varchar(255) DEFAULT NULL COMMENT '链接地址',
  `info` varchar(255) DEFAULT NULL COMMENT '图片信息',
  `path` varchar(255) DEFAULT NULL COMMENT '图片路径',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8 COLLATE=utf8_general_ci COMMENT='图片表'

// 图片上传处理
public class FileUploadAction extends ActionSupport {
    private File upload;
    private String uploadFileName;
    private String uploadContentType;
    private PicService picService;
    
    public String upload() {
        try {
            if (upload != null) {
                // 生成唯一文件名
                String extension = uploadFileName.substring(
                    uploadFileName.lastIndexOf("."));
                String newFileName = UUID.randomUUID() + extension;
                
                // 保存文件到服务器
                String savePath = ServletActionContext.getServletContext()
                    .getRealPath("/uploads");
                File destFile = new File(savePath, newFileName);
                FileUtils.copyFile(upload, destFile);
                
                // 保存图片信息到数据库
                Pic pic = new Pic();
                pic.setPath("/uploads/" + newFileName);
                pic.setInfo("上传的宠物图片");
                picService.save(pic);
                
                addActionMessage("图片上传成功！");
            }
        } catch (Exception e) {
            addActionError("上传失败：" + e.getMessage());
            return ERROR;
        }
        return SUCCESS;
    }
}

宠物详情界面

实体模型设计

系统采用面向对象的设计思想，通过Hibernate实现对象关系映射。核心实体包括用户、宠物、订单、购物车等，它们之间通过关联关系构建完整的业务模型。

// 宠物实体类
@Entity
@Table(name = "t_product")
public class Pet implements Serializable {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;
    
    @Column(name = "pet_name")
    private String petName;
    
    @Column(name = "category")
    private String category;
    
    @Column(name = "age")
    private Integer age;
    
    @Column(name = "health_status")
    private String healthStatus;
    
    @Column(name = "description", length = 1000)
    private String description;
    
    @Column(name = "adoption_status")
    private String adoptionStatus;
    
    @ManyToOne
    @JoinColumn(name = "rescue_station_id")
    private RescueStation rescueStation;
    
    @OneToMany(mappedBy = "pet", cascade = CascadeType.ALL)
    private Set<AdoptionApplication> applications;
    
    // 构造方法、getter、setter等
}

// 领养申请实体类
@Entity
@Table(name = "t_adoption_application")
public class AdoptionApplication implements Serializable {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;
    
    @ManyToOne
    @JoinColumn(name = "user_id")
    private User applicant;
    
    @ManyToOne
    @JoinColumn(name = "pet_id")
    private Pet pet;
    
    @Column(name = "apply_time")
    private Date applyTime;
    
    @Column(name = "status")
    private String status; // 待审核、已通过、已拒绝
    
    @Column(name = "application_reason", length = 500)
    private String applicationReason;
    
    @Column(name = "family_environment", length = 500)
    private String familyEnvironment;
    
    // 其他字段和方法
}

功能展望与优化方向

1. 引入Redis缓存提升性能

当前系统在处理高并发查询时可能存在性能瓶颈。未来可以引入Redis作为缓存层，存储热点数据如宠物列表、用户信息等。

// Redis缓存配置示例
@Configuration
@EnableCaching
public class RedisConfig extends CachingConfigurerSupport {
    
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);
        template.setKeySerializer(new StringRedisSerializer());
        template.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        return template;
    }
}

// 使用缓存注解
@Service
public class PetServiceImpl implements PetService {
    
    @Cacheable(value = "pets", key = "#category")
    public List<Pet> findPetsByCategory(String category) {
        // 数据库查询逻辑
        return petDAO.findByCategory(category);
    }
    
    @CacheEvict(value = "pets", allEntries = true)
    public void updatePet(Pet pet) {
        petDAO.update(pet);
    }
}

2

本文关键词
SSH框架流浪动物领养平台源码解析Struts2SpringHibernate

上下篇

上一篇
没有更多文章
下一篇
没有更多文章