如何在Enterprise Architect中将Java开源软件源码目录导入为数据库？

Got it, let’s walk through exactly how to get your Java source code into Enterprise Architect (EA) and turn it into a relational database—complete with all those critical class associations intact. You’re right that this is totally feasible, so let’s break it down step by step:

First up, get your code into EA as a UML model:

• Open EA, create a new project (or use an existing one), then go to Project > Import > Source Code from the top menu.
• In the import wizard, select Java as the target language. Navigate to your root source code directory, check the packages/classes you want to import, and tweak settings like including private members, comments, or nested classes—adjust based on which metrics you plan to extract later.
• Once the import finishes, you’ll see your Java classes rendered as UML class diagrams. Take a minute to verify that all associations (inheritance, composition, aggregation, field references) are correctly mapped—EA usually picks these up from extends, implements, and class fields, but it’s good to double-check for edge cases.

Now turn those UML classes into database tables with preserved relationships:

• Select the root package or node containing your imported classes. Right-click and choose Code Engineering > Generate DDL.
• In the DDL wizard, pick your target database (MySQL, PostgreSQL, SQL Server—whichever you’ll use for queries).
• Configure key settings to preserve relationships:
  • For inheritance, choose between single-table, joined-table, or table-per-hierarchy mapping (EA lets you set this per inheritance chain).
  • Make sure the option to generate foreign keys for composition/aggregation is enabled—this is how your class associations translate to table relationships.
  • Adjust naming conventions (like camelCase to snake_case) if your database prefers a specific style.
• Generate the DDL script: you can run it directly against your database from EA (if you set up a connection) or save it as a .sql file to execute manually later.

Don’t skip this—you want to make sure everything transferred correctly:

• Connect to your database and inspect the tables. Confirm that class fields map to columns with the right data types (e.g., Java String → SQL VARCHAR, int → INT).
• Check that foreign keys exist for associations. For example, if a Customer class has a List<Order> field, the orders table should have a customer_id foreign key linking to the customers table’s primary key.
• Validate inheritance mappings match what you chose (e.g., joined-table strategy will have a base table and child tables with foreign keys to the base).

With your database set up, you can write SQL to pull the metrics you need. Here are a few starter examples (adjust table/column names to match your EA-generated schema):

• Count classes per package:

  SELECT package_name, COUNT(*) AS class_count
  FROM classes
  GROUP BY package_name;
  

• Total number of table associations (foreign keys):

  SELECT COUNT(*) AS total_associations
  FROM foreign_keys;
  

• Average number of fields per class:

  SELECT AVG(field_count) AS avg_fields_per_class
  FROM (
      SELECT class_id, COUNT(*) AS field_count
      FROM class_fields
      GROUP BY class_id
  ) AS field_totals;
  

• Clean your code first: Remove unused classes, interfaces, or fields before importing—this keeps your database model clean and metrics accurate.
• Validate your EA model: Run Project > Validate Model before generating DDL to catch inconsistencies like missing associations or invalid data types.
• Save often: Importing and generating can be resource-heavy, so don’t risk losing your work mid-process.

内容的提问来源于stack exchange，提问作者Bilal_01