使用reflect-metadata实现数据校验与日志记录

npm install reflect-metadata
// 或者
yarn add reflect-metadata

import 'reflect-metadata';

class Person {
    constructor(public name: string, public age: number) {}
}

function CreatedBy(name: string) {
    return function(target: Function) {
        Reflect.defineMetadata('createdBy', name, target);
    }
}

@CreatedBy('Alice')
class Person {
    constructor(public name: string, public age: number) {}
}

// 获取元数据
const creator = Reflect.getMetadata('createdBy', Person);
console.log(creator); // 输出：Alice

function Type(type: string) {
    return function(target: any, propertyKey: string) {
        Reflect.defineMetadata('type', type, target, propertyKey);
    }
}

class Person {
    @Type('string')
    public name: string;

    @Type('number')
    public age: number;

    constructor(name: string, age: number) {
        this.name = name;
        this.age = age;
    }
}

const nameType = Reflect.getMetadata('type', Person.prototype, 'name');
const ageType = Reflect.getMetadata('type', Person.prototype, 'age');
console.log(nameType); // 输出：string
console.log(ageType); // 输出：number

function LogMethod(description: string) {
    return function(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
        Reflect.defineMetadata('description', description, target, propertyKey);
    }
}

class Person {
    constructor(public name: string, public age: number) {}

    @LogMethod('This method logs a greeting message.')
    greet() {
        console.log(`Hello, my name is ${this.name} and I am ${this.age} years old.`);
    }
}

const greetDescription = Reflect.getMetadata('description', Person.prototype, 'greet');
console.log(greetDescription); // 输出：This method logs a greeting message.

const INJECTABLE_KEY = 'design:paramtypes';

function Injectable() {
    return function (target: Function) {
        // 这里不需要做什么，只是标记这个类是可注入的
    }
}

function Inject(target: any, propertyKey: string, index: number) {
    const existingInjectedParams = Reflect.getMetadata(INJECTABLE_KEY, target) || [];
    existingInjectedParams[index] = true;
    Reflect.defineMetadata(INJECTABLE_KEY, existingInjectedParams, target);
}

class Container {
    private providers = new Map();

    register<T>(token: new (...args: any[]) => T, provider: T) {
        this.providers.set(token, provider);
    }

    resolve<T>(target: new (...args: any[]) => T): T {
        const paramsTypes = Reflect.getMetadata('design:paramtypes', target) || [];
        const injectedParams = Reflect.getMetadata(INJECTABLE_KEY, target) || [];

        const params = paramsTypes.map((paramType: any, index: number) => {
            if (injectedParams[index]) {
                return this.providers.get(paramType);
            }
            return new paramType();
        });

        return new target(...params);
    }
}

@Injectable()
class Engine {
    start() {
        console.log('Engine started');
    }
}

@Injectable()
class Car {
    constructor(@Inject private engine: Engine) {}

    drive() {
        this.engine.start();
        console.log('Car is driving');
    }
}

// 创建依赖注入容器
const container = new Container();

// 注册依赖关系
container.register(Engine, new Engine());

// 解析并创建 Car 对象
const car = container.resolve(Car);
car.drive(); // 输出：Engine started, Car is driving

const VALIDATION_METADATA_KEY = 'validation';

function Required(target: any, propertyKey: string) {
    Reflect.defineMetadata(VALIDATION_METADATA_KEY, { required: true }, target, propertyKey);
}

function MinLength(length: number) {
    return function(target: any, propertyKey: string) {
        Reflect.defineMetadata(VALIDATION_METADATA_KEY, { minLength: length }, target, propertyKey);
    }
}

function validate(obj: any): boolean {
    for (let key of Object.keys(obj)) {
        const metadata = Reflect.getMetadata(VALIDATION_METADATA_KEY, obj, key);
        if (metadata) {
            if (metadata.required && !obj[key]) {
                console.error(`${key} is required.`);
                return false;
            }
            if (metadata.minLength && obj[key].length < metadata.minLength) {
                console.error(`${key} should have at least ${metadata.minLength} characters.`);
                return false;
            }
        }
    }
    return true;
}

class User {
    @Required
    name: string;

    @MinLength(6)
    password: string;

    constructor(name: string, password: string) {
        this.name = name;
        this.password = password;
    }
}

const user = new User('Alice', '12345');
if (validate(user)) {
    console.log('Validation passed.');
} else {
    console.log('Validation failed.');
}
// 输出：password should have at least 6 characters.

function LogExecutionTime(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
    const originalMethod = descriptor.value;

    descriptor.value = function (...args: any[]) {
        const start = performance.now();
        const result = originalMethod.apply(this, args);
        const end = performance.now();
        console.log(`${propertyKey} executed in ${(end - start).toFixed(2)} ms`);
        return result;
    };
}

class Example {
    @LogExecutionTime
    doSomething() {
        for (let i = 0; i < 1e6; i++) {} // 模拟耗时操作
    }
}

const example = new Example();
example.doSomething(); // 输出：doSomething executed in X.XX ms