System Functionality Overview

The SSM-based pet adoption management system supports two primary user roles:

Administrator Capabilities:

• Pet category management
• Adoption process control
• Pet product inventory management
• User account administration
• Pet boarding services management
• Lost pet information tracking
• Order processing and management

User Functionality:

• Account registration and authentication
• Favorite items and comment system
• Shopping cart and order placement
• Pet adoption requests
• Pet boarding reservations

Technical Architecture

Backend Framework: SSM (Spring, Spring MVC, MyBatis) Frontend Technologies: Bootstrap, JSP, CSS, JavaScript, jQuery, Vue.js

Framework Components

Spring functions as the application's core dependency injection container, managing bean lifecycle and implementing inversion of control principles. Spring MVC handles HTTP request routing through its DispatcherServlet, mapping requests to appropriate controller methods. MyBatis abstracts database operations by mapping SQL statements to Java interfaces via XML configuration files.

Data base Selection

MySQL serves as the relational database management system, chosen for its optimal balance of performance, reliability, and cost-effectiveness. The database supports both version 5.7 and 8.x, providing flexibility in deployment environments.

Development Environment Specifications

• Java Version: JDK 1.8 (recommended)
• IDE Compatibility: IntelliJ IDEA or Eclipse
• Servlet Container: Tomcat 7-10
• Database: MySQL 5.7/8.x
• Build Tool: Maven (any version)
• Operating System: Windows

Core Implementation Details

Database Configuraton

database.url=jdbc:mysql://localhost:3306/pet_adoption_db?characterEncoding=utf8&useSSL=false&serverTimezone=UTC&rewriteBatchedStatements=true&allowPublicKeyRetrieval=true
database.username=root
database.password=root

Authentication Controller Implementation

package com.adoption.controller;

import java.util.Arrays;
import java.util.Map;
import javax.servlet.http.HttpServletRequest;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import com.adoption.annotation.AuthExclusion;
import com.adoption.entity.UserAccount;
import com.adoption.service.AuthTokenService;
import com.adoption.service.UserAccountService;
import com.adoption.util.PageHandler;
import com.adoption.util.QueryBuilder;
import com.adoption.util.ResponseWrapper;

@RestController
@RequestMapping("/api/auth")
public class AuthenticationController {
    
    @Autowired
    private UserAccountService accountService;
    
    @Autowired
    private AuthTokenService tokenService;

    @AuthExclusion
    @PostMapping("/signin")
    public ResponseWrapper authenticateUser(@RequestParam String username, 
                                           @RequestParam String password,
                                           HttpServletRequest request) {
        UserAccount account = accountService.findByUsername(username);
        if(account == null || !account.getPasswordHash().equals(password)) {
            return ResponseWrapper.error("Invalid credentials provided");
        }
        String authToken = tokenService.generateAuthToken(account.getId(), 
                                                         username, 
                                                         "users", 
                                                         account.getRole());
        return ResponseWrapper.success().addData("authToken", authToken);
    }
    
    @AuthExclusion
    @PostMapping("/register")
    public ResponseWrapper createAccount(@RequestBody UserAccount newUser) {
        if(accountService.findByUsername(newUser.getUsername()) != null) {
            return ResponseWrapper.error("Username already exists");
        }
        accountService.createUser(newUser);
        return ResponseWrapper.success();
    }

    @GetMapping("/signout")
    public ResponseWrapper invalidateSession(HttpServletRequest request) {
        request.getSession().invalidate();
        return ResponseWrapper.success("Session terminated successfully");
    }
    
    @AuthExclusion
    @PostMapping("/reset-password")
    public ResponseWrapper resetPassword(@RequestParam String username) {
        UserAccount account = accountService.findByUsername(username);
        if(account == null) {
            return ResponseWrapper.error("Account not found");
        }
        accountService.resetPassword(account.getId(), "default123");
        return ResponseWrapper.success("Password reset to: default123");
    }
    
    @GetMapping("/users")
    public ResponseWrapper getUserList(@RequestParam Map<String, Object> params, 
                                      UserAccount filter) {
        QueryBuilder query = new QueryBuilder(filter);
        PageHandler page = accountService.getPaginatedResults(params, 
                                        QueryBuilder.sort(QueryBuilder.filter(query, params), params));
        return ResponseWrapper.success().addData("users", page);
    }
    
    @GetMapping("/users/{userId}")
    public ResponseWrapper getUserProfile(@PathVariable("userId") Long userId) {
        UserAccount account = accountService.findById(userId);
        return ResponseWrapper.success().addData("user", account);
    }
    
    @PostMapping("/users")
    public ResponseWrapper addUser(@RequestBody UserAccount user) {
        if(accountService.findByUsername(user.getUsername()) != null) {
            return ResponseWrapper.error("User account already exists");
        }
        accountService.createUser(user);
        return ResponseWrapper.success();
    }
    
    @PutMapping("/users")
    public ResponseWrapper updateUser(@RequestBody UserAccount user) {
        accountService.updateUser(user);
        return ResponseWrapper.success();
    }
    
    @DeleteMapping("/users")
    public ResponseWrapper removeUsers(@RequestBody Long[] userIds) {
        accountService.batchDelete(Arrays.asList(userIds));
        return ResponseWrapper.success();
    }
}