With the rapid development of the modern economy and the continuous improvement of information technology, traditional data information management has evolved into a software-based approach for storage, organization, and centralized processing. This traditional Chinece culture website was developed against this backdrop, designed to help administrators quickly process large volumes of data, improve work efficiency, and achieve optimal results with minimal effort.

Built using the mature SSM framework, the cross-platform Java enterprise development language, and the MySQL relational database management system, the website implements core functions including basic painting data management, painting resource management, literary works management, dance video management, and music resource management. The frontend interface is concise and visually appealing, with a module layout consistent with similar industry websites, and the system also includes practical solutions to address common data security concerns. Overall, this system enables administrators to handle work efficiently while realizing integrated, standardized, and automated data management.

Technical Stack

• Development Language: Java
• Core Framework: SSM (Spring + SpringMVC + MyBatis)
• Frontend Technology: JSP
• Persistence Framework: MyBatis
• Application Server: Tomcat 7/8/9/10
• Database: MySQL 5.7 or higher
• Project Management Tool: Maven
• Development IDE: IntelliJ IDEA / Eclipse

Admin Functional Modules

User Management

The user management page allows administrators to create, delete, and modify user accounts.

Painting Management

The painting management page supports administrators to add, edit, and remove painting records.

Literature Management

The literature management page enables administrators to create, update, and delete literary works.

Dance Management

The dance management page allows administrators to upload, modify, and delete dance video resources.

Code Implementations

API Authentication Interceptor

package com.example.security;

import java.io.IOException;
import java.io.PrintWriter;
import java.util.HashMap;
import java.util.Map;
import com.alibaba.fastjson.JSONObject;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.HandlerInterceptor;

import com.example.annotation.PublicEndpoint;
import com.example.exception.CustomAuthException;
import com.example.entity.TokenInfo;
import com.example.service.TokenManagementService;
import com.example.util.ResponseUtil;

/**
 * Token-based authentication interceptor for API requests
 */
@Component
public class ApiAuthInterceptor implements HandlerInterceptor {

    public static final String AUTH_TOKEN_HEADER = "Token";

    @Autowired
    private TokenManagementService tokenService;
    
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {

        // Configure cross-origin resource sharing (CORS) headers
        response.setHeader("Access-Control-Allow-Methods", "POST, GET, OPTIONS, DELETE");
        response.setHeader("Access-Control-Max-Age", "3600");
        response.setHeader("Access-Control-Allow-Credentials", "true");
        response.setHeader("Access-Control-Allow-Headers", "x-requested-with,request-source,Token, Origin,imgType, Content-Type, cache-control,postman-token,Cookie, Accept,authorization");
        response.setHeader("Access-Control-Allow-Origin", request.getHeader("Origin"));

        PublicEndpoint publicAnnotation;
        if (handler instanceof HandlerMethod) {
            publicAnnotation = ((HandlerMethod) handler).getMethodAnnotation(PublicEndpoint.class);
        } else {
            return true;
        }

        // Extract token from request header
        String authToken = request.getHeader(AUTH_TOKEN_HEADER);
        
        // Skip authentication for public endpoints
        if(publicAnnotation != null) {
            return true;
        }
        
        TokenInfo tokenData = null;
        if(StringUtils.isNotBlank(authToken)) {
            tokenData = tokenService.getValidToken(authToken);
        }
        
        if(tokenData != null) {
            request.getSession().setAttribute("userId", tokenData.getUserId());
            request.getSession().setAttribute("userRole", tokenData.getUserRole());
            request.getSession().setAttribute("associatedTable", tokenData.getTableName());
            request.getSession().setAttribute("username", tokenData.getUsername());
            return true;
        }
        
        PrintWriter responseWriter = null;
        response.setCharacterEncoding("UTF-8");
        response.setContentType("application/json; charset=utf-8");
        try {
            responseWriter = response.getWriter();
            responseWriter.print(JSONObject.toJSONString(ResponseUtil.error(401, "Please log in first")));
        } finally {
            if(responseWriter != null){
                responseWriter.close();
            }
        }
        return false;
    }
}

User Account Authentication Controller

package com.example.controller;

import java.util.Arrays;
import java.util.Calendar;
import java.util.Date;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;

import com.example.annotation.PublicEndpoint;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.example.entity.UserAccount;
import com.example.entity.TokenInfo;
import com.example.service.TokenManagementService;
import com.example.service.UserAccountService;
import com.example.util.CommonUtil;
import com.example.util.MD5EncryptionUtil;
import com.example.util.MybatisPlusUtil;
import com.example.util.PageQueryUtils;
import com.example.util.ResponseUtil;
import com.example.util.ValidationUtils;

/**
 * API endpoints for user account management and authentication
 */
@RequestMapping("accounts")
@RestController
public class AccountController {
    
    @Autowired
    private UserAccountService userAccountService;
    
    @Autowired
    private TokenManagementService tokenService;

    /**
     * User login endpoint
     */
    @PublicEndpoint
    @PostMapping(value = "/login")
    public ResponseUtil login(String username, String password, String captcha, HttpServletRequest request) {
        UserAccount user = userAccountService.selectOne(new EntityWrapper<UserAccount>().eq("username", username));
        if(user == null || !user.getPassword().equals(password)) {
            return ResponseUtil.error("Invalid username or password");
        }
        String authToken = tokenService.generateToken(user.getId(), username, "users", user.getUserRole());
        return ResponseUtil.success().put("token", authToken);
    }
    
    /**
     * New user registration endpoint
     */
    @PublicEndpoint
    @PostMapping(value = "/register")
    public ResponseUtil register(@RequestBody UserAccount newUser) {
        if(userAccountService.selectOne(new EntityWrapper<UserAccount>().eq("username", newUser.getUsername())) != null) {
            return ResponseUtil.error("Username already exists");
        }
        userAccountService.insert(newUser);
        return ResponseUtil.success();
    }

    /**
     * User logout endpoint
     */
    @GetMapping(value = "logout")
    public ResponseUtil logout(HttpServletRequest request) {
        request.getSession().invalidate();
        return ResponseUtil.success("Logout successful");
    }
    
    /**
     * Reset user password to default
     */
    @PublicEndpoint
    @RequestMapping(value = "/reset-password")
    public ResponseUtil resetPassword(String username, HttpServletRequest request) {
        UserAccount user = userAccountService.selectOne(new EntityWrapper<UserAccount>().eq("username", username));
        if(user == null) {
            return ResponseUtil.error("Account does not exist");
        }
        user.setPassword("123456");
        userAccountService.updateById(user);
        return ResponseUtil.success("Password reset to default: 123456");
    }
    
    /**
     * Paginated user list query
     */
    @RequestMapping("/page")
    public ResponseUtil getPaginatedUsers(@RequestParam Map<String, Object> queryParams, UserAccount filterUser) {
        EntityWrapper<UserAccount> queryWrapper = new EntityWrapper<UserAccount>();
        PageQueryUtils pageResult = userAccountService.queryPage(queryParams, MybatisPlusUtil.sort(MybatisPlusUtil.between(MybatisPlusUtil.allLike(queryWrapper, filterUser), queryParams), queryParams));
        return ResponseUtil.success().put("data", pageResult);
    }

    /**
     * Full user list query
     */
    @RequestMapping("/list")
    public ResponseUtil getAllUsers(UserAccount filterUser) {
        EntityWrapper<UserAccount> queryWrapper = new EntityWrapper<UserAccount>();
        queryWrapper.allEq(MybatisPlusUtil.allEQMapPre(filterUser, "user")); 
        return ResponseUtil.success().put("data", userAccountService.selectListView(queryWrapper));
    }

    /**
     * Get single user details by ID
     */
    @RequestMapping("/info/{userId}")
    public ResponseUtil getUserById(@PathVariable("userId") String userId){
        UserAccount user = userAccountService.selectById(userId);
        return ResponseUtil.success().put("data", user);
    }
    
    /**
     * Get currently logged in user's session info
     */
    @RequestMapping("/current-session")
    public ResponseUtil getCurrentSessionUser(HttpServletRequest request){
        Long userId = (Long)request.getSession().getAttribute("userId");
        UserAccount user = userAccountService.selectById(userId);
        return ResponseUtil.success().put("data", user);
    }

    /**
     * Create new user account
     */
    @PostMapping("/create")
    public ResponseUtil createUser(@RequestBody UserAccount newUser) {
        if(userAccountService.selectOne(new EntityWrapper<UserAccount>().eq("username", newUser.getUsername())) != null) {
            return ResponseUtil.error("Username already exists");
        }
        userAccountService.insert(newUser);
        return ResponseUtil.success();
    }

    /**
     * Update existing user account
     */
    @RequestMapping("/update")
    public ResponseUtil updateUser(@RequestBody UserAccount updatedUser) {
        UserAccount existingUser = userAccountService.selectOne(new EntityWrapper<UserAccount>().eq("username", updatedUser.getUsername()));
        if(existingUser != null && existingUser.getId() != updatedUser.getId() && existingUser.getUsername().equals(updatedUser.getUsername())) {
            return ResponseUtil.error("Username already in use");
        }
        userAccountService.updateById(updatedUser);
        return ResponseUtil.success();
    }

    /**
     * Delete selected user accounts
     */
    @RequestMapping("/delete")
    public ResponseUtil deleteUsers(@RequestBody Long[] userIds){
        userAccountService.deleteBatchIds(Arrays.asList(userIds));
        return ResponseUtil.success();
    }
}