Lesson 19-Large-Scale Project Architecture

Modular and Component-Based Architecture

Project Layering Design

Three-Layer Architecture Implementation Example:

% Data Layer (Database/File Operations)
classdef DataAccessLayer
    methods (Static)
        function data = loadData(filePath)
            % Load data from file or database
            if endsWith(filePath, '.mat')
                data = load(filePath);
            else
                % Database connection example
                conn = database('myDB', 'user', 'pass');
                data = fetch(conn, ['SELECT * FROM ' filePath]);
                close(conn);
            end
        end
        
        function saveData(data, filePath)
            % Save data to file or database
            if endsWith(filePath, '.mat')
                save(filePath, 'data');
            else
                % Database storage implementation
            end
        end
    end
end

% Algorithm Layer (Core Computation Logic)
classdef AlgorithmLayer
    methods (Static)
        function result = processData(data)
            % Data preprocessing
            preprocessed = preprocess(data);
            
            % Core algorithm
            result = coreAlgorithm(preprocessed);
            
            % Post-processing
            result = postprocess(result);
        end
        
        function preprocessed = preprocess(data)
            % Data standardization/normalization, etc.
        end
        
        function result = coreAlgorithm(data)
            % Core computation logic
        end
    end
end

% UI Layer (GUI/Command Line)
classdef UILayer < handle
    methods
        function obj = UILayer()
            % Initialize interface
            obj.createUI();
        end
        
        function createUI(obj)
            % Create MATLAB App Designer interface
            % Or traditional GUI components
        end
        
        function onRunButtonClicked(obj, ~, ~)
            % Get user input
            inputParams = obj.getUserInput();
            
            % Call algorithm layer
            data = DataAccessLayer.loadData(inputParams.filePath);
            result = AlgorithmLayer.processData(data);
            
            % Display results
            obj.displayResult(result);
        end
    end
end

% System Integration
app = UILayer();  % Launch application

Modular Design Specifications

Functional Module Interface Definition:

% Module interface definition example (using abstract class)
classdef (Abstract) DataProcessorInterface
    methods (Abstract)
        [processedData, metadata] = process(obj, rawData)
        config = getDefaultConfig()
    end
end

% Concrete module implementation
classdef ImageProcessor < DataProcessorInterface
    properties
        Config
    end
    
    methods
        function obj = ImageProcessor(config)
            obj.Config = config;
        end
        
        function [processedImg, meta] = process(obj, rawImg)
            % Image processing concrete implementation
            processedImg = imadjust(rawImg, obj.Config.Contrast);
            meta = struct('ProcessingTime', toc);
        end
        
        function config = getDefaultConfig(obj)
            config = struct('Contrast', [0.2 0.8]);
        end
    end
end

% Module usage example
config = struct('Contrast', [0.1 0.9]);
processor = ImageProcessor(config);
[img, meta] = processor.process(rawImage);

Component-Based Architecture Implementation

Independent Component Design and Dependency Management:

% Component interface definition
classdef (Abstract) AnalyticsComponent
    methods (Abstract)
        results = analyze(component, inputData)
        config = getConfiguration(component)
    end
end

% Component container (dependency management)
classdef ComponentContainer
    properties
        Components map  % Store registered components
    end
    
    methods
        function obj = ComponentContainer()
            obj.Components = containers.Map();
        end
        
        function registerComponent(obj, name, component)
            % Register component instance
            obj.Components(name) = component;
        end
        
        function results = runComponent(obj, name, inputData)
            % Execute specified component
            if isKey(obj.Components, name)
                component = obj.Components(name);
                results = component.analyze(inputData);
            else
                error('Component not registered: %s', name);
            end
        end
    end
end

% Component usage example
container = ComponentContainer();
container.registerComponent('stats', StatisticsComponent());
container.registerComponent('ml', MachineLearningComponent());

% Execute components (dependencies managed by container)
statsResults = container.runComponent('stats', data);
mlResults = container.runComponent('ml', data);

Dependency Injection Pattern

Inversion of Control Container Implementation:

% Simple IoC container implementation
classdef IOCContainer
    properties
        Registrations map  % Store type registration information
    end
    
    methods
        function obj = IOCContainer()
            obj.Registrations = containers.Map();
        end
        
        function register(obj, interfaceName, implementationClass, varargin)
            % Register type mapping
            obj.Registrations(interfaceName) = struct(...
                'Class', implementationClass, ...
                'Parameters', varargin);
        end
        
        function instance = resolve(obj, interfaceName)
            % Resolve dependencies and create instance
            if isKey(obj.Registrations, interfaceName)
                reg = obj.Registrations(interfaceName);
                args = [reg.Parameters];  % Construct parameter list
                instance = feval(reg.Class, args{:});
            else
                error('Unregistered interface: %s', interfaceName);
            end
        end
    end
end

% Usage example
container = IOCContainer();
container.register('ILogger', 'FileLogger', 'log.txt');
container.register('IDataService', 'DatabaseService', 'myDB');

% Obtain dependency-injected instances
logger = container.resolve('ILogger');
dataService = container.resolve('IDataService');

% Business component (dependencies injected via constructor)
classdef ReportGenerator
    properties
        Logger
        DataService
    end
    
    methods
        function obj = ReportGenerator(logger, dataService)
            obj.Logger = logger;
            obj.DataService = dataService;
        end
        
        function generate(obj)
            obj.Logger.log('Starting report generation');
            data = obj.DataService.fetchData();
            % Report generation logic...
        end
    end
end

% Automatic assembly
logger = container.resolve('ILogger');
dataService = container.resolve('IDataService');
reportGen = ReportGenerator(logger, dataService);
reportGen.generate();

Code Reuse Strategies

Abstract Design Pattern Application:

% Template Method Pattern example
classdef DataProcessingPipeline
    methods (Abstract)
        preprocess(obj, data)
        process(obj, data)
        postprocess(obj, data)
    end
    
    methods
        function run(obj, data)
            % Fixed process template
            data = obj.preprocess(data);
            data = obj.process(data);
            result = obj.postprocess(data);
            return result;
        end
    end
end

% Concrete implementation
classdef ImagePipeline < DataProcessingPipeline
    methods
        function preprocess(obj, img)
            % Image-specific preprocessing
            obj.normalizedImg = im2double(img);
        end
        
        function process(obj, img)
            % Image processing algorithm
            obj.filteredImg = medfilt2(obj.normalizedImg);
        end
        
        function result = postprocess(obj, img)
            % Post-processing
            result = imadjust(obj.filteredImg);
        end
    end
end

% Another implementation
classdef TextPipeline < DataProcessingPipeline
    methods
        function preprocess(obj, text)
            % Text preprocessing
            obj.cleanedText = lower(text);
        end
        
        function process(obj, text)
            % Text analysis
            obj.tokens = tokenize(obj.cleanedText);
        end
        
        function result = postprocess(obj, text)
            % Result generation
            result = countFrequency(obj.tokens);
        end
    end
end

Performance Optimization Architecture

Compute-Intensive Task Optimization

GPU Acceleration Implementation Example:

% GPU array conversion and computation
function result = gpuMatrixComputation(A, B)
    % Check GPU availability
    if canUseGPU()
        % Transfer data to GPU
        A_gpu = gpuArray(A);
        B_gpu = gpuArray(B);
        
        % Execute computation on GPU
        C_gpu = A_gpu * B_gpu;  % Matrix multiplication
        D_gpu = fft(C_gpu);     % FFT transform
        
        % Transfer result back to CPU
        result = gather(D_gpu);
    else
        % Fallback to CPU computation
        warning('GPU unavailable, using CPU computation');
        C = A * B;
        result = fft(C);
    end
end

% Parallel computing example (parfor)
function results = parallelParameterSweep(params)
    numParams = length(params);
    results = cell(numParams, 1);
    
    parfor i = 1:numParams
        % Independent computation for each parameter
        results{i} = computeWithParameter(params(i));
    end
end

% Batch processing GPU computation
function batchResults = gpuBatchProcessing(dataBatch)
    numBatches = size(dataBatch, 3);
    batchResults = zeros(size(dataBatch,1), size(dataBatch,2), numBatches);
    
    for i = 1:numBatches
        % Independent GPU computation for each batch
        batchData = dataBatch(:,:,i);
        gpuData = gpuArray(batchData);
        processed = arrayfun(@processElement, gpuData);  % Element-wise GPU computation
        batchResults(:,:,i) = gather(processed);
    end
end

Memory Management Optimization Techniques

Memory Pre-Allocation and Reuse:

% Efficient matrix operations (pre-allocation)
function result = optimizedMatrixCalculation(n)
    % Pre-allocate result matrix
    result = zeros(n, n);
    
    % Pre-allocate temporary variables
    temp = zeros(n, 1);
    
    for i = 1:n
        % Reuse temporary variable
        temp = computeColumn(i);  % Assume returns n×1 vector
        result(:,i) = temp;
    end
end

% Large data processing (chunked processing)
function result = processLargeData(filePath, blockSize)
    fid = fopen(filePath, 'r');
    result = [];
    
    while ~feof(fid)
        % Read data in chunks
        block = fread(fid, blockSize, 'double');
        
        % Process current chunk
        processedBlock = processBlock(block);
        
        % Accumulate results
        result = [result; processedBlock];  % Note memory growth
    end
    
    fclose(fid);
    
    % Better implementation: pre-allocate final result size (if known)
end

% Using tall arrays for ultra-large data processing
function stats = analyzeTallData(filePath)
    % Create tall array
    t = tall(readtable(filePath));
    
    % Perform lazy computation
    meanVal = mean(t.Value);
    stdVal = std(t.Value);
    
    % Force computation and gather results
    stats = gather(struct('Mean', meanVal, 'StdDev', stdVal));
end

Data Storage Optimization Solutions

Memory-Mapped File Application:

% Create memory-mapped file
function createMemoryMappedFile(filename, dataSize)
    % Define data type and size
    dataType = 'double';
    numElements = prod(dataSize);
    
    % Create mapped file
    fid = fopen(filename, 'w');
    fwrite(fid, zeros(numElements,1, dataType), dataType);
    fclose(fid);
    
    % Create memory mapping
    m = memmapfile(filename, ...
        'Format', {dataType, [numElements,1], 'Data'}, ...
        'Writable', true);
    
    % Return mapping object
    m
end

% Process using memory mapping for large data
function processWithMemoryMapping(m)
    % Directly operate on memory-mapped data
    m.Data(1:100) = rand(100,1);  % Modify partial data
    
    % Large-scale computation (without loading all into memory)
    partialSum = sum(m.Data(1:1e6));  % Access only first 1M elements
end

% Combine tall arrays with memory mapping
function tallAnalysis(filename)
    % Create memory mapping
    m = createMemoryMappedFile(filename, [1e8 1]);
    
    % Convert to tall array
    t = tall(array2table(m.Data));
    
    % Perform distributed computation
    result = gather([
        mean(t.Data), ...
        std(t.Data), ...
        max(t.Data)
    ]);
end

Distributed Computing Architecture

Parallel Server Cluster Configuration:

% Connect to cluster
cluster = parcluster('myClusterProfile');

% Submit batch job
job = batch(@myParallelFunction, 1, ...
    {'inputData'}, ...
    'Pool', 4, ...          % Number of workers per job
    'Cluster', cluster, ...
    'Name', 'DistributedAnalysis');

% Monitor job status
wait(job);
results = fetchOutputs(job);

% Distributed array computation
function result = distributedMatrixCalculation(A, B)
    % Convert matrices to distributed arrays
    dA = distributed(A);
    dB = distributed(B);
    
    % Distributed matrix multiplication
    dC = dA * dB;
    
    % Gather results (use cautiously, large data may cause memory issues)
    result = gather(dC);
end

% Use spmd block for parallel computing
function spmdParallelExample()
    spmd
        % Independent data per worker
        localData = rand(1000, 'codistributed');
        
        % Distributed computation
        localResult = svd(localData);
        
        % Global synchronization point
        result = gplus(localResult);
    end
    
    % Master process obtains result
    finalResult = result{1};
end

Startup Optimization Techniques

Fast Startup Configuration:

% Pre-load commonly used functions (auto-executed on startup)
function startup()
    % Pre-compile frequently used functions
    mcc -m -R -singleCompThread myFrequentFunction;
    
    % Pre-load into memory
    persistent preloadedData
    if isempty(preloadedData)
        preloadedData = load('frequentData.mat');
    end
    
    % Initialize parallel pool (on demand)
    if isempty(gcp('nocreate'))
        parpool('local', 4);
    end
end

% Reduce startup dependencies
function lightweightStartup()
    % Load only necessary paths
    addpath(fullfile(pwd, 'coreFunctions'));
    
    % Delay loading large toolboxes
    setenv('DELAY_TOOLBOX_LOAD', 'true');
end

% Use MATLAB Compiler to generate standalone application
% Exclude unnecessary toolbox dependencies during compilation
mcc -m myApp.m -N -p /path/to/required/toolbox

Security Architecture Design

Data Encryption Implementation

AES Encryption Example:

% AES-256-CBC encryption function
function [encryptedData, iv] = aesEncrypt(data, key)
    % Validate key length (256-bit = 32 bytes)
    if numel(key) ~= 32
        error('Key must be 256-bit (32 bytes)');
    end
    
    % Generate random initialization vector
    iv = randi([0 255], 1, 16, 'uint8');
    
    % Create encryption object
    cipher = java.security.spec.AlgorithmParameterSpec();
    cipher = javax.crypto.spec.IvParameterSpec(iv);
    
    % Initialize encryptor
    keySpec = javax.crypto.spec.SecretKeySpec(key, 'AES');
    encryptor = javax.crypto.Cipher.getInstance('AES/CBC/PKCS5Padding');
    encryptor.init(javax.crypto.Cipher.ENCRYPT_MODE, keySpec, cipher);
    
    % Perform encryption
    dataBytes = typecast(data, 'uint8');
    encryptedBytes = encryptor.doFinal(dataBytes);
    
    % Convert to MATLAB array
    encryptedData = uint8(encryptedBytes);
end

% AES decryption function
function decryptedData = aesDecrypt(encryptedData, key, iv)
    % Validate input
    if numel(key) ~= 32
        error('Invalid key length');
    end
    
    % Create decryptor
    keySpec = javax.crypto.spec.SecretKeySpec(key, 'AES');
    cipher = javax.crypto.spec.IvParameterSpec(iv);
    decryptor = javax.crypto.Cipher.getInstance('AES/CBC/PKCS5Padding');
    decryptor.init(javax.crypto.Cipher.DECRYPT_MODE, keySpec, cipher);
    
    % Perform decryption
    decryptedBytes = decryptor.doFinal(uint8(encryptedData));
    
    % Convert back to original data type
    decryptedData = typecast(decryptedBytes, 'double');  % Adjust based on original type
end

% Usage example
key = randi([0 255], 1, 32, 'uint8');  % 256-bit key
data = rand(1, 100);                   % Data to encrypt

[encrypted, iv] = aesEncrypt(data, key);
decrypted = aesDecrypt(encrypted, key, iv);

% Verify result
assert(isequal(data, decrypted), 'Decryption verification failed');

User Authentication System

Password Management and Permission Control:

% Password hash storage
classdef UserAuthSystem
    properties
        UserDB map  % Username -> password hash mapping
        Salt map   % Username -> salt mapping
    end
    
    methods
        function obj = UserAuthSystem()
            obj.UserDB = containers.Map();
            obj.Salt = containers.Map();
        end
        
        function obj = registerUser(obj, username, plainPassword)
            % Generate random salt
            salt = randi([0 255], 1, 32, 'uint8');
            
            % Compute password hash (PBKDF2)
            iterations = 10000;
            keyLength = 32;  % 256-bit
            hash = pbkdf2('SHA-256', plainPassword, salt, iterations, keyLength);
            
            % Store user information
            obj.UserDB(username) = uint8(hash);
            obj.Salt(username) = uint8(salt);
        end
        
        function authenticated = authenticate(obj, username, plainPassword)
            if ~isKey(obj.UserDB, username)
                authenticated = false;
                return;
            end
            
            % Retrieve stored hash and salt
            storedHash = obj.UserDB(username);
            salt = obj.Salt(username);
            
            % Compute hash of input password
            iterations = 10000;
            keyLength = 32;
            inputHash = pbkdf2('SHA-256', plainPassword, salt, iterations, keyLength);
            
            % Compare hashes
            authenticated = isequal(storedHash, uint8(inputHash));
        end
    end
end

% Permission control system
classdef AccessControl
    properties
        RolePermissions map  % Role -> permission list mapping
    end
    
    methods
        function obj = AccessControl()
            % Initialize role permissions
            obj.RolePermissions = containers.Map(...
                {'admin', 'user', 'guest'}, ...
                {{'read','write','delete'}, {'read'}, {'read'}});
        end
        
        function hasAccess = checkPermission(obj, role, requiredPermission)
            if ~isKey(obj.RolePermissions, role)
                hasAccess = false;
                return;
            end
            
            permissions = obj.RolePermissions(role);
            hasAccess = any(strcmp(permissions, requiredPermission));
        end
    end
end

Code Security Protection

Input Validation and Injection Protection:

% Secure database query
classdef SafeDatabaseAccess
    properties
        Conn matlab.database.DBConnection
    end
    
    methods
        function obj = SafeDatabaseAccess(connectionString)
            obj.Conn = database(connectionString);
        end
        
        function data = safeQuery(obj, tableName, conditions)
            % Use parameterized query to prevent SQL injection
            query = sprintf('SELECT * FROM %s WHERE ', tableName);
            
            % Build parameterized conditions
            paramValues = {};
            paramPlaceholders = {};
            for i = 1:2:length(conditions)
                field = conditions{i};
                value = conditions{i+1};
                
                paramPlaceholders{end+1} = sprintf('%s = ?', field);
                paramValues{end+1} = value;
            end
            
            query = [query, strjoin(paramPlaceholders, ' AND ')];
            
            % Execute parameterized query
            curs = exec(obj.Conn, query, paramValues);
            data = fetch(curs);
        end
    end
end

% Secure file operations
classdef SecureFileHandler
    methods
        function data = safeReadFile(filename)
            % Validate file path (prevent directory traversal attacks)
            [filepath, name, ext] = fileparts(filename);
            
            % Allow only specific extensions
            allowedExtensions = {'.mat', '.csv', '.txt'};
            if ~any(strcmpi(ext, allowedExtensions))
                error('Unsupported file type');
            end
            
            % Resolve to absolute path and validate
            fullPath = fullfile(filepath, [name ext]);
            if ~startsWith(fullPath, '/safe/directory/')  % Restrict root directory
                error('Illegal file path');
            end
            
            % Secure read
            if strcmpi(ext, '.mat')
                data = load(fullPath);
            else
                % Handling for other file types
            end
        end
    end
end

Data Privacy Protection

Data Anonymization Techniques:

% Data desensitization processing
classdef DataAnonymizer
    methods
        function anonymized = anonymizePII(data)
            % Process personally identifiable information
            anonymized = data;
            
            % Name replacement
            if isfield(anonymized, 'name')
                anonymized.name = arrayfun(@anonymizeName, anonymized.name);
            end
            
            % Email hashing
            if isfield(anonymized, 'email')
                anonymized.email = arrayfun(@hashEmail, anonymized.email);
            end
            
            % ID number partial masking
            if isfield(anonymized, 'idNumber')
                anonymized.idNumber = arrayfun(@maskIDNumber, anonymized.idNumber);
            end
        end
        
        function anonymizedName = anonymizeName(name)
            % Simple example: replace with random string
            anonymizedName = ['User_' num2str(randi([1e6 9e6]))];
        end
        
        function hashedEmail = hashEmail(email)
            % Hash email using SHA-256
            hashedEmail = char(digest('sha256', email));
        end
        
        function maskedID = maskIDNumber(id)
            % Display first 3 and last 4 digits, mask middle with *
            len = numel(id);
            if len > 7
                maskedID = [id(1:3), repmat('*', 1, len-7), id(end-3:end)];
            else
                maskedID = id;  % No processing if too short
            end
        end
    end
end

% Differential privacy implementation example
classdef DifferentialPrivacy
    methods
        function noisyResult = addNoise(data, epsilon)
            % ε-differential privacy noise addition
            sensitivity = 1;  % Query sensitivity
            scale = sensitivity / epsilon;
            
            % Generate Laplace noise
            noise = laprnd(1, size(data), 0, scale);
            
            % Add noise
            noisyResult = data + noise;
        end
    end
end

% Laplace distribution random number generation
function r = laprnd(m, n, mu, b)
    % Generate m×n Laplace-distributed random numbers
    u = rand(m, n) - 0.5;
    r = mu - b * sign(u) .* log(1 - 2 * abs(u));
end

Secure Programming Practices

Secure Coding Specification Example:

% Secure file download function
function safeDownloadFile(url, savePath)
    % Input validation
    if ~isValidURL(url)
        error('Invalid URL format');
    end
    
    % Path security validation
    if ~isSafePath(savePath)
        error('Unsafe save path');
    end
    
    % Set timeout and retries
    options = weboptions('Timeout', 30, 'MaxAttempts', 3);
    
    try
        % Download file
        websave(savePath, url, options);
        
        % Validate download integrity
        if ~validateFile(savePath)
            delete(savePath);
            error('File validation failed after download');
        end
    catch ME
        % Secure error handling
        logSecurityEvent('download_failed', url, ME.message);
        rethrow(ME);
    end
end

% Auxiliary security functions
function valid = isValidURL(url)
    % Simple URL validation
    validSchemes = {'http://', 'https://'};
    valid = any(startsWith(url, validSchemes));
end

function safe = isSafePath(path)
    % Path security check
    basePath = '/safe/directory/';
    safe = startsWith(path, basePath) && ...
           ~contains(path, '..') &&  % Prevent directory traversal
           ~endsWith(path, '~');     % Prevent temporary files
end

function logSecurityEvent(eventType, details, errorMessage)
    % Security event logging
    logEntry = struct(...
        'Timestamp', datetime('now'), ...
        'EventType', eventType, ...
        'Details', details, ...
        'Error', errorMessage);
    
    % Write to security log file
    fid = fopen('security_audit.log', 'a');
    fprintf(fid, '%s\n', jsonencode(logEntry));
    fclose(fid);
end
Share your love