@hadss/turbo-trans-json-plugin 1.0.0-rc.0 → 1.0.0-rc.1

package/src/core/analyzers/ClassAnalyzer.ts

@@ -26,15 +26,16 @@ import {
 } from 'ts-morph';
 import {
   ClassAnalysis,
-  InterfaceAnalysis,
   ClassDecorators,
   ConstructorParam,
   DeserializationMode,
   GenericInfo,
   InheritanceInfo,
+  InterfaceAnalysis,
   PropertyAnalysis,
   PropertyDecorators,
   PropertyKind,
+  PropertyVisibility,
   SerializableOptions,
   TypeStructure
 } from '../Types';
@@ -45,7 +46,6 @@ import { CustomTypeAnalyzer } from './CustomTypeAnalyzer';
 import { CustomError, ErrorCodes } from '../utils/CustomError';
 import { Logger } from '../logger/Logger';
 import { TsMorphUtil } from '../utils/TsMorphUtil';
-import { logger } from 'handlebars';
 
 export class ClassAnalyzer {
   /**
@@ -97,14 +97,15 @@ export class ClassAnalyzer {
   }
 
   /**
-     * 分析接口的完整结构，包括属性、继承关系等信息
-     * @param interfaceDecl 接口声明节点
-     * @returns 接口分析结果
-     */
+   * 分析接口的完整结构，包括属性、继承关系等信息
+   * @param interfaceDecl 接口声明节点
+   * @returns 接口分析结果
+   */
   public static analyzeInterface(interfaceDecl: InterfaceDeclaration): InterfaceAnalysis {
     const interfaceName = interfaceDecl.getName();
     if (!interfaceName) {
-      throw new CustomError(`Interface name is undefined in ${interfaceDecl.getSourceFile().getFilePath()}`, ErrorCodes.CLASS_DECLARATION_NOT_FOUND);
+      throw new CustomError(`Interface name is undefined in ${interfaceDecl.getSourceFile().getFilePath()}`,
+        ErrorCodes.CLASS_DECLARATION_NOT_FOUND);
     }
     const sourceFilePath = interfaceDecl.getSourceFile().getFilePath();
     const generics: GenericInfo = {
@@ -141,7 +142,8 @@ export class ClassAnalyzer {
    */
   private static analyzeInheritanceInfo(cls: ClassDeclaration | InterfaceDeclaration): InheritanceInfo {
     const heritageClaus = cls.getHeritageClauses();
-    Logger.debug(`分析类的继承信息: ${cls.getName()} ${heritageClaus.length} ${heritageClaus.map(c => c.getText()).join(',')}`);
+    Logger.debug(
+      `分析类的继承信息: ${cls.getName()} ${heritageClaus.length} ${heritageClaus.map(c => c.getText()).join(',')}`);
     for (const clause of heritageClaus) {
       const token = clause.getToken();
       // 接口实现
@@ -155,7 +157,8 @@ export class ClassAnalyzer {
       Logger.debug(`继承信息: text: ${className} getTypeArguments: ${args.map(type => type.getText()).join(', ')}`);
       const classDecl = CustomTypeAnalyzer.getInstance().findClassDeclFromClassName(className, cls.getSourceFile());
       if (!classDecl) {
-        throw new CustomError(`class ${className} decl does not exist ${cls.getName} implement ${className}`, ErrorCodes.CLASS_DECLARATION_NOT_FOUND);
+        throw new CustomError(`class ${className} decl does not exist ${cls.getName} implement ${className}`,
+          ErrorCodes.CLASS_DECLARATION_NOT_FOUND);
       }
       if (classDecl instanceof InterfaceDeclaration) {
         const baseClassAnalysis = this.analyzeInterface(classDecl);
@@ -343,7 +346,7 @@ export class ClassAnalyzer {
           } else {
             // 未知类型且没有 @Transient 或自定义序列化器，抛出清晰错误
             throw new CustomError(`不支持的类型 '${propertyAnalysis.type.sourceText}' 用于属性 '${propertyAnalysis.name
-              }' (接口: ${cls.getName()})`, ErrorCodes.TYPE_NOT_SUPPORT);
+            }' (接口: ${cls.getName()})`, ErrorCodes.TYPE_NOT_SUPPORT);
           }
         }
       }
@@ -441,9 +444,33 @@ export class ClassAnalyzer {
 
     // 3. 递归处理更上层祖先，传递泛型参数
     if (classAnalysis.inheritance.isInherited && classAnalysis.inheritance.baseClassAnalysis) {
+      // 关键修复: 需要解析父类的泛型参数，将其中的泛型引用替换为当前映射的具体类型
+      const parentGenericTypeArgs = classAnalysis.inheritance.genericTypeArguments || [];
+
+      // 对父类的泛型参数进行替换，解决泛型参数引用问题
+      // 例如: CrudRepository<T> extends Repository<T, number>
+      // 这里的 T 需要替换为当前映射中的 UserEntity
+      const resolvedParentGenericArgs = parentGenericTypeArgs.map(typeArg => {
+        // 解析类型参数为 TypeStructure
+        const typeStructure = TypeHandlerRegistry.getInstance().parseType(typeArg, {
+          depth: 0,
+          genericParams: parentGenericParams // 使用父类的泛型参数上下文
+        });
+
+        // 如果是泛型引用,进行替换
+        if (typeStructure.kind === PropertyKind.GENERIC && genericMapping.has(typeStructure.sourceText)) {
+          return genericMapping.get(typeStructure.sourceText)!;
+        }
+
+        // 否则保持原样
+        return typeArg;
+      });
+
+      Logger.debug(`[CollectAncestors] Resolved parent generic args: ${resolvedParentGenericArgs.map(a => a.getText()).join(', ')}`);
+
       const ancestorProperties = this.collectAllAncestorProperties(
         classAnalysis.inheritance.baseClassAnalysis,
-        classAnalysis.inheritance.genericTypeArguments || [], // 传递当前层的泛型参数
+        resolvedParentGenericArgs, // 传递解析后的泛型参数
         currentClassGenericParams // 保持传递当前类的泛型参数
       );
       allProperties.push(...ancestorProperties);
@@ -494,18 +521,25 @@ export class ClassAnalyzer {
       throw new CustomError(`无法分析属性 '${name}' 的类型。请检查属性声明。`, ErrorCodes.TYPE_NOT_SUPPORT);
     }
 
-    const defaultValue: string | undefined = prop instanceof PropertyDeclaration ? this.analyzeDefaultValue(prop, constructorParams) : undefined;
+    const defaultValue: string | undefined = prop instanceof PropertyDeclaration ?
+      this.analyzeDefaultValue(prop, constructorParams) : undefined;
     const decorators = prop instanceof PropertyDeclaration ? this.analyzePropertyDecorators(prop) : undefined;
     const type = TypeHandlerRegistry.getInstance().parseType(typeNode, { genericParams: genericParameters, depth: 0 });
     type.isOptional = prop.hasQuestionToken();
 
+    // 检测属性可见性修饰符
+    const visibility: PropertyVisibility =
+      prop.hasModifier(SyntaxKind.PrivateKeyword) ? PropertyVisibility.PRIVATE :
+        prop.hasModifier(SyntaxKind.ProtectedKeyword) ? PropertyVisibility.PROTECTED :
+          PropertyVisibility.PUBLIC;
+
     const constructorParam = constructorParams.find((param) => param.name === name);
 
     // 计算构造函数参数的可选性（用于后续验证）
     const isParamOptional = constructorParam
       ? constructorParam.isOptional ||
-        constructorParam.defaultValue !== undefined ||
-        this.hasUndefinedInUnion(constructorParam.type)
+      constructorParam.defaultValue !== undefined ||
+      this.hasUndefinedInUnion(constructorParam.type)
       : true;
 
     let isMust: boolean;
@@ -539,7 +573,8 @@ export class ClassAnalyzer {
       defaultValue,
       decorators,
       type,
-      isMust
+      isMust,
+      visibility
     };
   }
 
@@ -598,7 +633,8 @@ export class ClassAnalyzer {
     return typeText;
   }
 
-  private static getTypeFromInitializer(prop: PropertyDeclaration | PropertySignature, propName: string): TypeNode | undefined {
+  private static getTypeFromInitializer(prop: PropertyDeclaration | PropertySignature,
+    propName: string): TypeNode | undefined {
     const initializer = prop.getInitializer();
     if (!initializer) {
       return undefined;
@@ -626,7 +662,8 @@ export class ClassAnalyzer {
     }
 
     const exprText = expression.getText();
-    const supportedTypes = ['Map', 'Set', 'WeakMap', 'WeakSet', 'Array', 'Object', 'ArrayList', 'HashMap', 'HashSet', 'LinkedList', 'Decimal', 'List'];
+    const supportedTypes = ['Map', 'Set', 'WeakMap', 'WeakSet', 'Array', 'Object', 'ArrayList', 'HashMap', 'HashSet',
+      'LinkedList', 'Decimal', 'List'];
 
     if (!supportedTypes.includes(exprText)) {
       return undefined;
@@ -651,7 +688,8 @@ export class ClassAnalyzer {
    * @param type 类型结构
    * @returns 是否为可选属性
    */
-  private static isOptional(node: PropertyDeclaration | PropertySignature, defaultValue: string | undefined, type: TypeStructure): boolean {
+  private static isOptional(node: PropertyDeclaration | PropertySignature, defaultValue: string | undefined,
+    type: TypeStructure): boolean {
     // 1. 语法上带 ?（prop?: T, param?: T）
     if (node.hasQuestionToken()) {
       return true;
@@ -770,6 +808,7 @@ export class ClassAnalyzer {
     const decorators = prop.getDecorators();
     let isRequired: boolean = false;
     let isTransient: boolean = false;
+    let isPlainValue: boolean = false;
     let serialName: string | undefined;
     let _with: string | undefined;
 
@@ -786,6 +825,9 @@ export class ClassAnalyzer {
         case DecoratorConstants.TRANSIENT:
           isTransient = true;
           break;
+        case DecoratorConstants.PLAIN_VALUE:
+          isPlainValue = true;
+          break;
         case DecoratorConstants.SERIALIZABLE:
           _with = this.parseSerializableOptions(decorator)!.with;
       }
@@ -803,6 +845,9 @@ export class ClassAnalyzer {
       if (_with) {
         conflictingDecorators.push('@Serializable');
       }
+      if (isPlainValue) {
+        conflictingDecorators.push('@PlainValue');
+      }
 
       if (conflictingDecorators.length > 0) {
         throw new CustomError(
@@ -814,9 +859,20 @@ export class ClassAnalyzer {
       }
     }
 
+    // 注解互斥检查：@PlainValue 与自定义序列化器互斥
+    if (isPlainValue && _with) {
+      throw new CustomError(
+        `属性 '${prop.getName()}' 的注解冲突：@PlainValue 与 @Serializable(with:) 不能同时使用。\n` +
+        `@PlainValue 跳过类型转换直接使用原始值，与自定义序列化器冲突。\n` +
+        `请移除 @PlainValue 或移除自定义序列化器。`,
+        ErrorCodes.ANNOTATION_CONFLICT
+      );
+    }
+
     return {
       isRequired,
       isTransient,
+      isPlainValue,
       serialName,
       with: _with
     };

package/src/core/analyzers/CustomTypeAnalyzer.ts

@@ -17,7 +17,6 @@ import {
   ClassDeclaration,
   EnumDeclaration,
   InterfaceDeclaration,
-  Project,
   SourceFile,
   TypeAliasDeclaration
 } from 'ts-morph';

package/src/core/constants/DecoratorConstants.ts

@@ -22,6 +22,7 @@ export class DecoratorConstants {
   static readonly SERIAL_NAME = 'SerialName'
   static readonly REQUIRED = 'Required'
   static readonly TRANSIENT = 'Transient'
+  static readonly PLAIN_VALUE = 'PlainValue'
 
-  static readonly SERIAL_DECORATORS = [this.SERIALIZABLE, this.SERIAL_NAME, this.REQUIRED, this.TRANSIENT];
+  static readonly SERIAL_DECORATORS = [this.SERIALIZABLE, this.SERIAL_NAME, this.REQUIRED, this.TRANSIENT, this.PLAIN_VALUE];
 }

package/src/core/constants/StringConstants.ts

@@ -13,8 +13,6 @@
  * limitations under the License.
  */
 
-import { PropertyKind } from '../Types';
-
 /**
  * 字符串常量统一管理
  * 避免硬编码字符串散布在代码中

package/src/core/handlers/CustomClassHandler.ts

@@ -240,9 +240,6 @@ export class CustomClassHandler extends BaseTypeHandler implements ITypeHandler
       throw new CustomError(`Type ${classDetails.classDecl.getName()} is not sendable.
         please add @Sendable or @Serializable({ generateSendable: true })`, ErrorCodes.NOT_SENDABLE);
     }
-
-    // 未启用generateSendable，返回原类型
-    return structure.sourceText;
   }
 
   generatePropertyConversion(structure: TypeStructure, sourceValue: string, direction: ConversionDirection): string {

package/src/core/handlers/TypeHandlerRegistry.ts

@@ -13,7 +13,7 @@
  * limitations under the License.
  */
 
-import { TypeNode, SyntaxKind, InferTypeNode } from 'ts-morph';
+import { TypeNode, SyntaxKind } from 'ts-morph';
 import { ITypeHandler, TypeContext } from './ITypeHandler';
 import { PropertyKind, TypeStructure, Logger } from '..';
 import { CustomError, ErrorCodes } from '../utils/CustomError';

package/src/core/import-rewrite/services/BuildProfileUpdater.ts

@@ -13,7 +13,7 @@
  * limitations under the License.
  */
 
-import { ITaskContext, Logger } from '../..';
+import { Logger } from '../..';
 import { ITargetContext } from '../../../json-plugin/interfaces/ITargetContext';
 import SerializationPathUtil from '../../utils/SerializationPathUtil';
 

package/src/core/import-rewrite/services/ImportRewriteService.ts

@@ -17,8 +17,6 @@ import { ITaskContext, ImportRewriteOptions, Logger } from '../..';
 import { GeneratedFileInfo, ImportRewriteService as IImportRewriteService } from '../types/ImportRewriteTypes';
 import { ImportTransformServiceImpl } from './ImportTransformService';
 import SerializationPathUtil from '../../utils/SerializationPathUtil';
-import { BuildProfileUpdaterImpl } from './BuildProfileUpdater';
-import { ITargetContext } from '../../../json-plugin/interfaces/ITargetContext';
 
 /**
  * 导入重写主服务实现

package/src/core/services/CodeAnalysisService.ts

@@ -13,7 +13,7 @@
  * limitations under the License.
  */
 
-import { ClassDeclaration, ModuleKind, Project, ScriptTarget } from 'ts-morph';
+import { ClassDeclaration } from 'ts-morph';
 import { ClassAnalysis, DecoratorConstants, Logger } from '..';
 import { ClassAnalyzer } from '../analyzers/ClassAnalyzer';
 import { TsMorphUtil } from '../utils/TsMorphUtil';

package/src/core/services/CodeGenerationService/CodeGenerationService.ts

@@ -13,7 +13,6 @@
  * limitations under the License.
  */
 
-import { IndentationText, Project, QuoteKind } from 'ts-morph';
 import { OriginalClassGenerator } from './generators/OriginalClassGenerator';
 import { SendableClassGenerator } from './generators/SendableClassGenerator';
 import { SerializerGenerator } from './generators/SerializerGenerator';
@@ -69,7 +68,7 @@ export class CodeGenerationService {
     }
 
     // 生成原始类结构
-    this.originalClassGenerator.generate(outputSourceFile, originalSourceFile, results, context);
+    this.originalClassGenerator.generate(outputSourceFile, originalSourceFile, results);
 
     for (const content of serializableGeneratorContext) {
       this.serializerGenerator.generateRegistration(outputSourceFile, content);

package/src/core/services/CodeGenerationService/generators/MergedSendableClassGenerator.ts

@@ -89,22 +89,6 @@ export class MergedSendableClassGenerator {
     classDecl.addImplements(['ITSerializable', 'lang.ISendable']);
   }
 
-  private generateGetTypeMethod(classDecl: ClassDeclaration, classAnalysis: ClassAnalysis): void {
-    // 检查是否已存在该方法
-    if (classDecl.getMethod('getType')) {
-      Logger.warn(`类 ${classAnalysis.className} 已存在getType方法，跳过生成`);
-      return;
-    }
-
-    const methodBody = `return ${classAnalysis.className};`;
-
-    classDecl.addMethod({
-      name: 'getType',
-      returnType: 'Function',
-      statements: [methodBody]
-    });
-  }
-
   /**
    * 生成toSendable方法
    * 对于合并版Sendable类，直接返回自身（因为类本身已经是Sendable）
@@ -162,19 +146,6 @@ export class MergedSendableClassGenerator {
 
     const methodBody = 'return TJSON.toString(this, typeKey)';
 
-    // 获取类的泛型参数
-    const genericParameters = classAnalysis.generics.parameters;
-
-    // 构建完整的类型名（包含泛型参数）
-    let fullTypeName: string;
-    if (genericParameters.length > 0) {
-      // 对于泛型类：ClassName<T, U>
-      fullTypeName = `${classDecl.getNameOrThrow()}<${genericParameters.join(', ')}>`;
-    } else {
-      // 对于非泛型类：ClassName
-      fullTypeName = classDecl.getNameOrThrow();
-    }
-
     classDecl.addMethod({
       name: 'toJson',
       returnType: 'string',

package/src/core/services/CodeGenerationService/generators/OriginalClassGenerator.ts

@@ -13,8 +13,8 @@
  * limitations under the License.
  */
 
-import { ClassDeclaration, Project, SourceFile } from 'ts-morph';
-import { ClassAnalysis, PropertyAnalysis, Logger, PropertyKind, ITaskContext } from '../../..';
+import { ClassDeclaration, SourceFile } from 'ts-morph';
+import { ClassAnalysis, PropertyAnalysis, Logger, PropertyKind } from '../../..';
 import { ImportManager } from '../shared/ImportManager';
 import SerializationPathUtil from '../../../utils/SerializationPathUtil';
 import { ConversionDirection } from '../../../handlers/ITypeHandler';
@@ -32,7 +32,7 @@ export class OriginalClassGenerator {
     this.mergedSendableGenerator = new MergedSendableClassGenerator();
   }
 
-  generate(outputSourceFile: SourceFile, originalSourceFile: SourceFile, results: ClassAnalysis[], context: ITaskContext): void {
+  generate(outputSourceFile: SourceFile, originalSourceFile: SourceFile, results: ClassAnalysis[]): void {
     this.registerImports();
 
     // 1. 获取原始源文件的完整内容并移除原始import语句
@@ -53,7 +53,7 @@ export class OriginalClassGenerator {
         this.mergedSendableGenerator.generate(targetClass, result);
       } else {
         this.addITSerializableInterface(targetClass);
-        this.addStaticSerialName(targetClass, result, context);
+        this.addStaticSerialName(targetClass, result);
         this.generateConvertToSendableMethod(targetClass, result);
         this.generateToJsonMethod(targetClass, result);
       }
@@ -129,14 +129,7 @@ export class OriginalClassGenerator {
     Logger.debug(`为类 ${classDecl.getName()} 添加ITSerializable接口实现`);
   }
 
-  private generateSerialNameConstant(result: ClassAnalysis, context: ITaskContext): string {
-    const relativePath = context.calculateSourceRootToModuleRoot(result.sourceFilePath);
-    const serialName = SerializationPathUtil.join(context.getPackageName(), relativePath, result.className + '.class')
-      .replaceAll(SerializationPathUtil.sep, '/');
-    return result.decorators.serialName || serialName;
-  }
-
-  private addStaticSerialName(classDecl: ClassDeclaration, result: ClassAnalysis, context: ITaskContext): void {
+  private addStaticSerialName(classDecl: ClassDeclaration, result: ClassAnalysis): void {
     // 添加静态属性
     classDecl.addProperty({
       name: 'SERIAL_NAME',
@@ -148,22 +141,6 @@ export class OriginalClassGenerator {
     Logger.debug(`为类 ${classDecl.getName()} 添加静态属性 serialName`);
   }
 
-  private generateGetTypeMethod(classDecl: ClassDeclaration, result: ClassAnalysis): void {
-    // 检查是否已存在该方法
-    if (classDecl.getMethod('getType')) {
-      Logger.warn(`类 ${result.className} 已存在getType方法，跳过生成`);
-      return;
-    }
-
-    const methodBody = `return ${result.className};`;
-
-    classDecl.addMethod({
-      name: 'getType',
-      returnType: 'Function',
-      statements: [methodBody]
-    });
-  }
-
   private generateConvertToSendableMethod(classDecl: ClassDeclaration, result: ClassAnalysis): void {
     // 检查是否已存在该方法
     if (classDecl.getMethod('toSendable')) {
@@ -205,19 +182,6 @@ export class OriginalClassGenerator {
 
     const methodBody = 'return TJSON.toString(this, typeKey)';
 
-    // 获取类的泛型参数
-    const genericParameters = result.generics.parameters;
-
-    // 构建完整的类型名（包含泛型参数）
-    let fullTypeName: string;
-    if (genericParameters.length > 0) {
-      // 对于泛型类：ClassName<T, U>
-      fullTypeName = `${classDecl.getNameOrThrow()}<${genericParameters.join(', ')}>`;
-    } else {
-      // 对于非泛型类：ClassName
-      fullTypeName = classDecl.getNameOrThrow();
-    }
-
     classDecl.addMethod({
       name: 'toJson',
       returnType: 'string',
@@ -233,7 +197,7 @@ export class OriginalClassGenerator {
   private registerImports(): void {
     this.importManager.registerJsonImports(['ITSerializable', 'TJSON']);
 
-    this.importManager.registerCoreImports(['TypeKey', 'Serializable']);
+    this.importManager.registerCoreImports(['TypeKey', 'Serializable', 'Encoder', 'SerialDescriptor']);
   }
 
   // ============= toSendable方法生成 =============

package/src/core/services/CodeGenerationService/generators/SerializerGenerator.ts

@@ -50,12 +50,14 @@ export class SerializerGenerator {
     this.templateEngine = new HandlebarsTemplateEngine();
   }
 
-  generate(sourceFile: SourceFile, result: ClassAnalysis | InterfaceAnalysis, context: ITaskContext): GenerationContext | string {
+  generate(sourceFile: SourceFile, result: ClassAnalysis | InterfaceAnalysis,
+    context: ITaskContext): GenerationContext | string {
     // 检查是否使用自定义序列化器
     if (result.decorators?.serializable?.with) {
-      sourceFile.addStatements(this.generateBuiltinSerializerRegistrationForSupplementary(context, result as ClassAnalysis));
+      sourceFile.addStatements(
+        this.generateBuiltinSerializerRegistrationForSupplementary(context, result as ClassAnalysis));
       // 使用自定义序列化器，仅生成注册语句
-      return this.generateCustomSerializerRegistration(sourceFile, result as ClassAnalysis);
+      return this.generateCustomSerializerRegistration(result as ClassAnalysis);
     }
 
     // 1. 注册必要的导入
@@ -103,7 +105,8 @@ export class SerializerGenerator {
     // 基础导入 + 动态内置序列化器导入
     this.importManager.registerCoreImports([
       'Serializer', 'SerialDescriptor', 'buildClassSerialDescriptor',
-      'Encoder', 'Decoder', 'registerAutoGeneratedSerializerEntry', 'registerAutoGeneratedSerializerEntryProviderForSupplementary',
+      'Encoder', 'Decoder', 'registerAutoGeneratedSerializerEntry', 'ObjectUtils',
+      'registerAutoGeneratedSerializerEntryProviderForSupplementary',
       ...requiredBuiltinSerializers
     ]);
 
@@ -201,17 +204,17 @@ export class SerializerGenerator {
       }
 
       // 注册属性相关的序列化器导入
-      this.execPropertyImports(property.type.dependencies);
+      this.execPropertyImports(property.type.dependencies, !!property.decorators?.with);
     }
   }
 
-  private execPropertyImports(dependencies: TypeDependency[]): void {
+  private execPropertyImports(dependencies: TypeDependency[], hasWithParam: boolean): void {
     dependencies.forEach((dependency: TypeDependency) => {
-      this.processDependency(dependency);
+      this.processDependency(dependency, hasWithParam);
     });
   }
 
-  private processDependency(dependency: TypeDependency): void {
+  private processDependency(dependency: TypeDependency, hasWithParam: boolean): void {
     const source = dependency.source;
 
     // 提前返回，减少嵌套
@@ -226,16 +229,16 @@ export class SerializerGenerator {
     // 根据类型种类分别处理
     switch (dependency.typeKind) {
       case TypeKind.CLASS:
-        this.processClassDependency(dependency, source);
+        this.processClassDependency(dependency, source, hasWithParam);
         break;
 
       case TypeKind.INTERFACE:
-        this.processInterfaceDependency(dependency);
+        this.processInterfaceDependency(dependency, hasWithParam);
         break;
     }
   }
 
-  private processClassDependency(dependency: TypeDependency, source: DependencySource): void {
+  private processClassDependency(dependency: TypeDependency, source: DependencySource, hasWithParam: boolean): void {
     const classDetails = dependency.details as ClassDetails;
     const tempClassAnalysis = ClassAnalyzer.analyzeClass(classDetails.classDecl);
 
@@ -249,6 +252,10 @@ export class SerializerGenerator {
     if (tempClassAnalysis.decorators.serializable) {
       this.handleSerializableClass(dependency, source, serializerName);
     } else {
+      if (hasWithParam) {
+        // 有自定义序列化器，无需关注这个导入了
+        return;
+      }
       // 从 tempSerializer 目录（index.ets）导入
       this.importManager.registerTempSerializerImport(`${dependency.typeName}${serializerName}`);
     }
@@ -263,7 +270,11 @@ export class SerializerGenerator {
     }
   }
 
-  private processInterfaceDependency(dependency: TypeDependency): void {
+  private processInterfaceDependency(dependency: TypeDependency, hasWithParam: boolean): void {
+    if (hasWithParam) {
+      // 有自定义序列化器，无需关注这个导入了
+      return;
+    }
     const interfaceDetails = dependency.details as InterfaceDetails;
     const tempClassAnalysis = ClassAnalyzer.analyzeInterface(interfaceDetails.interfaceDecl);
     TempSerializerGenerator.getInstance().generateSerializer(tempClassAnalysis);
@@ -275,13 +286,11 @@ export class SerializerGenerator {
     this.importManager.registerTempSerializerImport(`${dependency.typeName}${serializerName}`);
   }
 
-  private generateCustomSerializerRegistration(sourceFile: SourceFile, result: ClassAnalysis): string {
+  private generateCustomSerializerRegistration(result: ClassAnalysis): string {
     this.importManager.registerCoreImports(['registerAutoGeneratedSerializerEntry']);
 
     const customSerializer = result.decorators.serializable!.with;
-    const registrationCode = `registerAutoGeneratedSerializerEntry(${result.className}, ${customSerializer});`;
-
-    return registrationCode;
+    return `registerAutoGeneratedSerializerEntry(${result.className}, ${customSerializer});`;
   }
 
   private generateBuiltinSerializerRegistrationForSupplementary(context: ITaskContext, result: ClassAnalysis): string {
@@ -289,10 +298,8 @@ export class SerializerGenerator {
     const serialNameConstant = this.generateSerialNameConstant(result, context);
 
     const customSerializer = result.decorators.serializable!.with;
-    const registrationCode = `const ${result.className}_SERIAL_NAME = '${serialNameConstant}';\n
+    return `const ${result.className}_SERIAL_NAME = '${serialNameConstant}';\n
     registerAutoGeneratedSerializerEntryProviderForSupplementary(${result.className}_SERIAL_NAME, () => [${result.className}, ${customSerializer}]);`;
-
-    return registrationCode;
   }
 
   private getAllRequiredSerializers(properties: PropertyAnalysis[]): string[] {

package/src/core/template/HandlebarsTemplateEngine.ts

@@ -230,6 +230,11 @@ export class HandlebarsTemplateEngine {
     this.registerHelper('genericParametersESObjString', (parameters: string[]) => {
       return parameters.map(() => 'ESObject').join(', ');
     });
+
+    // 过滤出泛型类型的属性(用于生成静态方法的泛型序列化器参数)
+    this.registerHelper('filterGenericProperties', (properties: PropertyGenerationInfo[]) => {
+      return properties.filter(p => p.analysis.type.kind === PropertyKind.GENERIC && !p.analysis.decorators?.isTransient);
+    });
   }
 
   private registerPropertyAnalysisHelpers(): void {

package/src/core/utils/DeepCopyUtil.ts

@@ -25,7 +25,8 @@ export class DeepCopyUtil {
       defaultValue: original.defaultValue,
       decorators: this.copyPropertyDecorators(original.decorators),
       isMust: original.isMust,
-      type: this.copyTypeStructure(original.type)
+      type: this.copyTypeStructure(original.type),
+      visibility: original.visibility
     };
   }
 
@@ -37,6 +38,7 @@ export class DeepCopyUtil {
       serialName: original.serialName,
       isRequired: original.isRequired,
       isTransient: original.isTransient,
+      isPlainValue: original.isPlainValue,
       with: original.with
     };
   }