System Overview

The rapid expansion of internet infrastructure and the global spread of anime culture has transformed the animation industry into a diverse entertainment domain. Anime enthusiasts exhibit strong interest in discovering preferred works, creating substantial demand for domestic animation recommendation systems. As the industry grows, users' expectations for personalized and precise recommendations have increased. Traditional approaches often fall short in meeting these varied needs, making the development of efficient recommendation systems crucial.

The diversity of individual preferences necessitates advanced systems capable of accurately capturing user-specific tastes. Such systems leverage big data analytics and machine learning techniques to deliver tailored experiences. An effective recommendation platform enhances user satisfaction and engagement by quickly connecting users with relevant content.

Government support for the animation and creative industries has fostered favorable conditions for such systems. With increasing market competition, platforms are seeking innovative solutions to attract and retain users through improved recommendation capabilities.

Technical Framework

Java Programming Language

Java, developed by Oracle, is an object-oriented language widely used in web and desktop applications since its introduction in 1995. Key features include:

• Object-oriented programming with classes, interfaces, and inheritance
• Distributed computing support via network APIs and RMI
• Robustness through strong typing, exception handling, and garbage collection
• Security mechanisms preventing malicious code execution
• Platform independence with bytecode compilation
• Portability across different hardware and software environments
• Interpretation through JVM for cross-platform compatibility

HTML Web Technologies

HTML (HyperText Markup Language) is a markup language created in 1990 for structuring web documents. It uses tags to unify document formats across the internet, enabling logical connections between scattered resources. HTML files require web browsers for rendering, combining text, graphics, animations, audio, tables, links, and images.

MySQL Database

MySQL has evolved significantly from version 4 to 5, offering enhanced functionality including data compression and encryption for security. Recent versions improve database performance, streamline administration, and enhance spatial data handling capabilities. These improvements make MySQL suitable for complex data management tasks.

SpringBoot Framework

SpringBoot, introduced by Pivotal in 2013, simplifies initial setup and development of Spring applications. It provides auto-configuration features, embedded servers, and starter dependencies that reduce configuration overhead. Key characteristics include:

• Creation of independent Spring applications with executable JARs/WARs
• Embedded servlet containers like Tomcat or Jetty
• Simplified Maven configurations through starters
• Automatic Spring container configuration
• Built-in features like metrics, health checks, and externalized configuration
• No code generation required, eliminating XML configuration

Vue.js Framework

Vue.js is a progressive JavaScript framework for building user interfaces. It features:

• Reactive data binding that automaticallly updates views when data changes
• Component-based architecture for modular development
• Comprehensive directive system for DOM manipulation and interaction
• Extensive plugin ecosystem for extended functionality

Element UI

Element UI is a desktop component library for Vue.js 2.0, offering:

• Complete UI solution covering basic controls to complex components
• Intuitive API design with detailed documentation
• Modern aesthetic design with customizable themes
• Extensibility through hooks and events

System Analysis

Feasibility Assessment

Technical Viability

The system utilizes Java with SpringBoot backend, Vue.js frontend, and MySQL database. As a computer science student, the developer has adequate experience with these technologies.

Economic Viability

All tools and frameworks used are free, requiring no financial investment for development.

Operational Viability

The interface prioritizes simplicity and ease of use, ensuring users can navigate without training.

Performance Requirements

• Page response time under 3 seconds (maximum 4 seconds)
• Clean, intuitive interface matching user habits
• High storage capacity with robust database support
• Simple learning curve for users
• Stable operation without display issues

Functional Modules

The system includes user management, menu control, permission management, homepage, article management, category handling, tag administration, comment management, review processes, personal profiles, and administrative controls.

System Design

Architecture

The system adopts a B/S architecture accessible through web browsers, consisting of:

1. Frontend: Learning and communication platform with search, viewing, commenting, liking, and rewarding features
2. Backend: Administrative interface for managing users, articles, comments, and statistics

Structural Components

System modules include user authentication, content menagement, data processing, and administrative functions.

Database Schema

The database structure includes entities such as user information, roles, permissions, menus, articles, and comments with defined relationships.

Code Implemantation

Spring Boot Configuration

server:
  tomcat:
    uri-encoding: UTF-8
  port: 8080
  servlet:
    context-path: /springboot0t8ql

spring:
  datasource:
    driverClassName: com.mysql.jdbc.Driver
    url: jdbc:mysql://127.0.0.1:3306/springboot0t8ql?useUnicode=true&characterEncoding=utf-8&useJDBCCompliantTimezoneShift=true&useLegacyDatetimeCode=false&serverTimezone=GMT%2B8
    username: root
    password: 123456

  servlet:
    multipart:
      max-file-size: 10MB
      max-request-size: 10MB
  resources:
    static-locations: classpath:/testStatic/,classpath:/META-INF/resources/,classpath:/resources/,classpath:/static/,classpath:/public/

mybatis-plus:
  mapper-locations: classpath*:mapper/*.xml
  typeAliasesPackage: com.entity
  global-config:
    id-type: 1
    field-strategy: 2
    db-column-underline: true
    refresh-mapper: true
    logic-delete-value: -1
    logic-not-delete-value: 0
    sql-injector: com.baomidou.mybatisplus.mapper.LogicSqlInjector
  configuration:
    map-underscore-to-camel-case: true
    cache-enabled: false
    call-setters-on-nulls: true
    jdbc-type-for-null: 'null'

User Authentication Implementation

@RestController
@RequestMapping("user")
public class UserController extends BaseController<User, UserService> {
    @Autowired
    private AccessTokenService tokenService;

    @PostMapping("login")
    public Map<String, Object> login(@RequestBody Map<String, String> data, HttpServletRequest httpServletRequest) {
        String username = data.get("username");
        String password = data.get("password");
        List resultList = null;
        Map<String, String> map = new HashMap<>();
        map.put("username", username);
        resultList = service.select(map, new HashMap<>()).getResultList();
        
        if (resultList == null || password == null) {
            return error(30000, "Account or password cannot be empty");
        }
        
        User byUsername = (User) resultList.get(0);
        String md5password = service.encryption(password);
        
        if (byUsername.getPassword().equals(md5password)) {
            AccessToken accessToken = new AccessToken();
            accessToken.setToken(UUID.randomUUID().toString().replaceAll("-", ""));
            accessToken.setUser_id(byUsername.getUserId());
            tokenService.save(accessToken);
            
            JSONObject user = JSONObject.parseObject(JSONObject.toJSONString(byUsername));
            user.put("token", accessToken.getToken());
            JSONObject ret = new JSONObject();
            ret.put("obj", user);
            return success(ret);
        } else {
            return error(30000, "Incorrect account or password");
        }
    }
}

MD5 Encryption Utility

public class MD5Utils {
    private static final Logger logger = LoggerFactory.getLogger(MD5Utils.class);
    
    public static String GetMD5Code(String strObj) {
        if (StringUtils.isEmpty(strObj)) {
            return "";
        }
        String resultString = null;
        try {
            resultString = new String(strObj);
            MessageDigest md = MessageDigest.getInstance("MD5");
            resultString = byteToString(md.digest(strObj.getBytes()));
        } catch (NoSuchAlgorithmException ex) {
            ex.printStackTrace();
        }
        return resultString;
    }
    
    private static String byteToString(byte[] bByte) {
        StringBuffer sBuffer = new StringBuffer();
        for (int i = 0; i < bByte.length; i++) {
            sBuffer.append(byteToArrayString(bByte[i]));
        }
        return sBuffer.toString();
    }
    
    private static String byteToArrayString(byte bByte) {
        int iRet = bByte;
        if (iRet < 0) {
            iRet += 256;
        }
        int iD1 = iRet / 16;
        int iD2 = iRet % 16;
        return strDigits[iD1] + strDigits[iD2];
    }
}

Testing Process

Test Objectives

System testing ensures proper functionality, identifies bugs, and validates operational stability. Testing should occur throughout the development lifecycle, not just at completion.

Testing Approach

The system employs black-box testing methods for comprehensive evaluation. Tests focus on verifying:

• Interface consistency with user requirements
• Design standards and aesthetic appeal
• Functional correctness and error handling

Login Verification

Test scenarios include:

1. Invalid credentials result in error messages
2. Correct credentials enable successful login
3. Account status verification before access

Results

Testing revealed minor visual inconsistencies and code redundancy issues. These will be addressed in future iterations to improve system efficiency and maintainability.