Please address the comments from this code review:

## Overall Comments
- Catching all exceptions in the JSON parsing block with a bare `except` can hide real errors; consider catching `json.JSONDecodeError` (and other specific exceptions if needed) instead.
- The `json` module is imported inside `_post_send`; it would be cleaner and more efficient to move this import to the module level.
- With the new logic, non-template markdown messages are now sent as plain `content` with `msg_type: 0` instead of using `MarkdownPayload` and `msg_type: 2`; please double-check whether you want to preserve markdown rendering for non-template messages and adjust the branching accordingly.

## Individual Comments

### Comment 1
<location path="astrbot/core/platform/sources/qqofficial/qqofficial_message_event.py" line_range="150-151" />
<code_context>
+                template_data = json.loads(plain_text)
+                if isinstance(template_data, dict) and "markdown" in template_data and "custom_template_id" in template_data["markdown"]:
+                    is_template_message = True
+        except:
+            pass
+        
+        if is_template_message and template_data:
</code_context>
<issue_to_address>
**issue (bug_risk):** Avoid bare `except` and silently swallowing all exceptions during JSON parsing.

Swallowing all exceptions here makes real bugs harder to detect. Prefer catching `json.JSONDecodeError` (and possibly `TypeError`) to treat only malformed JSON as “not a template”, and let other exceptions either propagate or be logged so unexpected issues remain visible.
</issue_to_address>

### Comment 2
<location path="astrbot/core/platform/sources/qqofficial/qqofficial_message_event.py" line_range="144-151" />
<code_context>
+            # 尝试解析plain_text为JSON，检查是否包含custom_template_id
+            if plain_text:
+                template_data = json.loads(plain_text)
+                if isinstance(template_data, dict) and "markdown" in template_data and "custom_template_id" in template_data["markdown"]:
+                    is_template_message = True
+        except:
+            pass
</code_context>
<issue_to_address>
**suggestion (bug_risk):** Guard against unexpected `markdown` structure when checking for `custom_template_id`.

This condition relies on `template_data["markdown"]` supporting `in` for membership and having the same structure you later send in the payload. To avoid unexpected behavior (e.g., if `markdown` is a list or string) and potential API rejections, ensure `template_data["markdown"]` is a dict before checking for `"custom_template_id"` so the check matches the expected payload shape.

```suggestion
        try:
            # 尝试解析plain_text为JSON，检查是否包含custom_template_id
            if plain_text:
                template_data = json.loads(plain_text)
                if isinstance(template_data, dict):
                    markdown = template_data.get("markdown")
                    # 仅当 markdown 为字典时才检查 custom_template_id，确保结构与后续 payload 一致
                    if isinstance(markdown, dict) and "custom_template_id" in markdown:
                        is_template_message = True
        except Exception:
            # JSON 解析失败或结构异常时，回退为普通文本消息模式
            pass
```
</issue_to_address>

### Comment 3
<location path="astrbot/core/platform/sources/qqofficial/qqofficial_message_event.py" line_range="139" />
<code_context>
-            "msg_type": 2,
-            "msg_id": self.message_obj.message_id,
-        }
+        # 检查消息是否包含模板信息
+        import json
+        is_template_message = False
</code_context>
<issue_to_address>
**issue (complexity):** Consider extracting the JSON template parsing into a helper and using it to drive a simpler payload-selection branch in `_post_send`.

You can keep the new behavior but isolate the complexity and make the flow clearer with two small helpers and a narrower exception.

### 1. Extract template parsing into a helper

This keeps `_post_send` from doing ad‑hoc JSON parsing and reduces nesting:

```python
# at module level
import json

def _parse_template_markdown(plain_text: str) -> dict | None:
    if not plain_text:
        return None

    try:
        data = json.loads(plain_text)
    except json.JSONDecodeError:
        return None

    if not isinstance(data, dict):
        return None

    markdown = data.get("markdown")
    if isinstance(markdown, dict) and "custom_template_id" in markdown:
        return markdown

    return None
```

### 2. Simplify payload construction in `_post_send`

Use the helper to drive a shallow, explicit branch instead of inline parsing and `bare except`:

```python
template_markdown = _parse_template_markdown(plain_text)

if template_markdown is not None:
    # 模板消息模式
    payload = {
        "markdown": template_markdown,
        "msg_type": 2,
        "msg_id": self.message_obj.message_id,
    }
else:
    # 普通文本消息模式
    payload = {
        "content": plain_text,
        "msg_type": 0,
        "msg_id": self.message_obj.message_id,
    }
```

This keeps all current behavior (auto-detection via JSON, `msg_type` 2 vs 0, same payload shapes), but:

- Removes the inline `import json`.
- Replaces `except:` with a targeted `json.JSONDecodeError`.
- Keeps `_post_send` focused on “choose payload shape” rather than parsing and validating JSON.
</issue_to_address>