diff --git a/klp-ui/src/views/wms/coil/do/acid.vue b/klp-ui/src/views/wms/coil/do/acid.vue
index e2beacef..8fbabf0c 100644
--- a/klp-ui/src/views/wms/coil/do/acid.vue
+++ b/klp-ui/src/views/wms/coil/do/acid.vue
@@ -1,13 +1,340 @@
 <template>
-  <div class="app-container">
+  <div class="app-container acid-do-container">
     <el-row :gutter="20">
+      <!-- 左侧：物料列表 -->
       <el-col :span="12">
-        <!-- 领料 -->
-        
+        <div class="section-card material-section">
+          <div class="section-header">
+            <h3 class="section-title">待领物料列表</h3>
+            <el-button size="mini" icon="el-icon-refresh" @click="getMaterialCoil">刷新</el-button>
+          </div>
+          
+          <!-- 搜索栏 -->
+          <el-form :model="materialQueryParams" ref="materialQueryForm" size="small" :inline="true" class="query-form">
+            <el-form-item label="入场钢卷号" prop="enterCoilNo">
+              <el-input
+                v-model="materialQueryParams.enterCoilNo"
+                placeholder="请输入入场钢卷号"
+                clearable
+                @keyup.enter.native="handleMaterialQuery"
+                style="width: 150px;"
+              />
+            </el-form-item>
+            <el-form-item label="当前钢卷号" prop="currentCoilNo">
+              <el-input
+                v-model="materialQueryParams.currentCoilNo"
+                placeholder="请输入当前钢卷号"
+                clearable
+                @keyup.enter.native="handleMaterialQuery"
+                style="width: 150px;"
+              />
+            </el-form-item>
+            <el-form-item>
+              <el-button type="primary" icon="el-icon-search" size="mini" @click="handleMaterialQuery">搜索</el-button>
+              <el-button icon="el-icon-refresh" size="mini" @click="resetMaterialQuery">重置</el-button>
+            </el-form-item>
+          </el-form>
+
+          <!-- 物料卡片列表 -->
+          <div v-loading="materialLoading" class="card-grid-container">
+            <div v-if="materialCoilList.length === 0" class="empty-state">
+              <i class="el-icon-box"></i>
+              <p>暂无待领物料</p>
+            </div>
+            <div
+              v-for="(item, index) in materialCoilList"
+              :key="item.coilId || index"
+              class="material-card"
+            >
+              <div class="card-header">
+                <div class="header-left">
+                  <el-tag type="info" size="small" class="coil-no-tag">{{ item.currentCoilNo }}</el-tag>
+                  <span class="material-type">{{ item.materialType || '原料' }}</span>
+                  <el-popover
+                    v-if="item.rawMaterial || item.product"
+                    placement="top"
+                    width="280"
+                    trigger="hover"
+                    popper-class="material-params-popover"
+                  >
+                    <div class="material-params-content">
+                      <div class="params-title">
+                        {{ item.itemType === 'raw_material' ? (item.rawMaterial && item.rawMaterial.rawMaterialName || '—') : (item.product && item.product.productName || '—') }}
+                      </div>
+                      <div class="params-list">
+                        <div class="param-item" v-if="item.itemType === 'raw_material' && item.rawMaterial">
+                          <div class="param-row" v-if="item.rawMaterial.rawMaterialCode">
+                            <span class="param-label">编号：</span>
+                            <span class="param-value">{{ item.rawMaterial.rawMaterialCode }}</span>
+                          </div>
+                          <div class="param-row" v-if="item.rawMaterial.specification">
+                            <span class="param-label">规格：</span>
+                            <span class="param-value">{{ item.rawMaterial.specification }}</span>
+                          </div>
+                          <div class="param-row" v-if="item.rawMaterial.steelGrade">
+                            <span class="param-label">钢种：</span>
+                            <span class="param-value">{{ item.rawMaterial.steelGrade }}</span>
+                          </div>
+                          <div class="param-row" v-if="item.rawMaterial.thickness">
+                            <span class="param-label">厚度：</span>
+                            <span class="param-value">{{ item.rawMaterial.thickness }}mm</span>
+                          </div>
+                          <div class="param-row" v-if="item.rawMaterial.width">
+                            <span class="param-label">宽度：</span>
+                            <span class="param-value">{{ item.rawMaterial.width }}mm</span>
+                          </div>
+                        </div>
+                        <div class="param-item" v-else-if="item.itemType === 'product' && item.product">
+                          <div class="param-row" v-if="item.product.productCode">
+                            <span class="param-label">编号：</span>
+                            <span class="param-value">{{ item.product.productCode }}</span>
+                          </div>
+                          <div class="param-row" v-if="item.product.specification">
+                            <span class="param-label">规格：</span>
+                            <span class="param-value">{{ item.product.specification }}</span>
+                          </div>
+                          <div class="param-row" v-if="item.product.thickness">
+                            <span class="param-label">厚度：</span>
+                            <span class="param-value">{{ item.product.thickness }}mm</span>
+                          </div>
+                          <div class="param-row" v-if="item.product.width">
+                            <span class="param-label">宽度：</span>
+                            <span class="param-value">{{ item.product.width }}mm</span>
+                          </div>
+                        </div>
+                        <div class="param-divider"></div>
+                        <div class="param-item">
+                          <div class="param-row" v-if="item.grossWeight">
+                            <span class="param-label">毛重：</span>
+                            <span class="param-value">{{ item.grossWeight }}t</span>
+                          </div>
+                          <div class="param-row" v-if="item.netWeight">
+                            <span class="param-label">净重：</span>
+                            <span class="param-value">{{ item.netWeight }}t</span>
+                          </div>
+                          <div class="param-row" v-if="item.team">
+                            <span class="param-label">班组：</span>
+                            <span class="param-value">{{ item.team }}</span>
+                          </div>
+                          <div class="param-row" v-if="item.updateTime">
+                            <span class="param-label">更新时间：</span>
+                            <span class="param-value">{{ parseTime(item.updateTime, '{y}-{m}-{d} {h}:{i}') }}</span>
+                          </div>
+                          <div class="param-row" v-if="item.updateBy">
+                            <span class="param-label">更新人：</span>
+                            <span class="param-value">{{ item.updateBy }}</span>
+                          </div>
+                          <div class="param-row" v-if="item.remark">
+                            <span class="param-label">备注：</span>
+                            <span class="param-value">{{ item.remark }}</span>
+                          </div>
+                        </div>
+                      </div>
+                    </div>
+                    <i slot="reference" class="el-icon-setting param-icon"></i>
+                  </el-popover>
+                </div>
+              </div>
+              
+              <div class="card-body">
+                <div class="info-list">
+                  <div class="info-item">
+                    <span class="info-label">入场：</span>
+                    <span class="info-value" :title="item.enterCoilNo">{{ item.enterCoilNo || '—' }}</span>
+                  </div>
+                  <div class="info-item">
+                    <span class="info-label">厂家：</span>
+                    <span class="info-value" :title="item.supplierCoilNo">{{ item.supplierCoilNo || '—' }}</span>
+                  </div>
+                  <div class="info-item">
+                    <span class="info-label">库位：</span>
+                    <span class="info-value" :title="item.warehouseName">{{ item.warehouseName || '—' }}</span>
+                  </div>
+                  <div class="info-item">
+                    <span class="info-label">库区：</span>
+                    <span class="info-value" :title="item.actualWarehouseName">{{ item.actualWarehouseName || '—' }}</span>
+                  </div>
+                  <div class="info-item">
+                    <span class="info-label">重量：</span>
+                    <span class="info-value">{{ item.netWeight || '—' }}t</span>
+                  </div>
+                </div>
+              </div>
+              
+              <div class="card-footer">
+                <el-button
+                  type="primary"
+                  icon="el-icon-check"
+                  size="mini"
+                  @click="handlePickMaterial(item)"
+                  :loading="item.picking"
+                  class="action-btn"
+                >领料</el-button>
+              </div>
+            </div>
+          </div>
+
+          <!-- 分页 -->
+          <pagination
+            v-show="materialTotal > 0"
+            :total="materialTotal"
+            :page.sync="materialQueryParams.pageNum"
+            :limit.sync="materialQueryParams.pageSize"
+            @pagination="getMaterialCoil"
+          />
+        </div>
       </el-col>
 
+      <!-- 右侧：待操作列表 -->
       <el-col :span="12">
-        <!-- 待操作 -->
+        <div class="section-card action-section">
+          <div class="section-header">
+            <h3 class="section-title">酸连轧工序待操作</h3>
+            <el-button size="mini" icon="el-icon-refresh" @click="getPendingAction">刷新</el-button>
+          </div>
+
+          <!-- 搜索栏 -->
+          <el-form :model="actionQueryParams" ref="actionQueryForm" size="small" :inline="true" class="query-form">
+            <el-form-item label="钢卷号" prop="currentCoilNo">
+              <el-input
+                v-model="actionQueryParams.currentCoilNo"
+                placeholder="请输入钢卷号"
+                clearable
+                @keyup.enter.native="handleActionQuery"
+                style="width: 150px;"
+              />
+            </el-form-item>
+            <el-form-item label="操作状态" prop="actionStatus">
+              <el-select v-model="actionQueryParams.actionStatus" placeholder="请选择状态" clearable style="width: 120px;">
+                <el-option label="待处理" :value="0" />
+                <el-option label="处理中" :value="1" />
+                <el-option label="已完成" :value="2" />
+                <el-option label="已取消" :value="3" />
+              </el-select>
+            </el-form-item>
+            <el-form-item>
+              <el-button type="primary" icon="el-icon-search" size="mini" @click="handleActionQuery">搜索</el-button>
+              <el-button icon="el-icon-refresh" size="mini" @click="resetActionQuery">重置</el-button>
+            </el-form-item>
+          </el-form>
+
+          <!-- 待操作卡片列表 -->
+          <div v-loading="actionLoading" class="card-grid-container">
+            <div v-if="pendingActionList.length === 0" class="empty-state">
+              <i class="el-icon-document"></i>
+              <p>暂无待操作任务</p>
+            </div>
+            <div
+              v-for="(item, index) in pendingActionList"
+              :key="item.actionId || index"
+              class="action-card"
+              :class="{
+                'urgent-card': item.priority === 2,
+                'important-card': item.priority === 1
+              }"
+            >
+              <div class="card-header">
+                <el-tag type="info" size="small" class="coil-no-tag">{{ item.currentCoilNo }}</el-tag>
+                <div class="status-tags">
+                  <el-tag v-if="item.actionStatus === 0" type="info" size="mini">待处理</el-tag>
+                  <el-tag v-else-if="item.actionStatus === 1" type="warning" size="mini">处理中</el-tag>
+                  <el-tag v-else-if="item.actionStatus === 2" type="success" size="mini">已完成</el-tag>
+                  <el-tag v-else-if="item.actionStatus === 3" type="danger" size="mini">已取消</el-tag>
+                  <el-tag v-if="item.priority === 2" type="danger" size="mini">紧急</el-tag>
+                  <el-tag v-else-if="item.priority === 1" type="warning" size="mini">重要</el-tag>
+                </div>
+              </div>
+              
+              <div class="card-body">
+                <div class="info-list">
+                  <div class="info-item">
+                    <span class="info-label">类型：</span>
+                    <dict-tag :options="dict.type.action_type" :value="item.actionType" class="action-type-tag"></dict-tag>
+                  </div>
+                  <div class="info-item">
+                    <span class="info-label">来源：</span>
+                    <span class="info-value">
+                      <el-tag v-if="item.sourceType === 'scan'" type="success" size="mini">扫码</el-tag>
+                      <el-tag v-else type="info" size="mini">手动</el-tag>
+                    </span>
+                  </div>
+                  <div class="info-item">
+                    <span class="info-label">创建人：</span>
+                    <span class="info-value">{{ item.createBy || '—' }}</span>
+                  </div>
+                  <div class="info-item">
+                    <span class="info-label">操作人：</span>
+                    <span class="info-value">{{ item.operatorName || '—' }}</span>
+                  </div>
+                  <div class="info-item">
+                    <span class="info-label">扫码时间：</span>
+                    <span class="info-value">{{ parseTime(item.scanTime, '{m}-{d} {h}:{i}') || '—' }}</span>
+                  </div>
+                  <div class="info-item">
+                    <span class="info-label">处理时间：</span>
+                    <span class="info-value">{{ parseTime(item.processTime, '{m}-{d} {h}:{i}') || '—' }}</span>
+                  </div>
+                </div>
+              </div>
+              
+              <div class="card-footer">
+                <!-- 待处理状态显示操作按钮 -->
+                <template v-if="item.actionStatus === 0">
+                  <el-button
+                    type="primary"
+                    icon="el-icon-edit"
+                    size="mini"
+                    @click="handleProcess(item)"
+                    class="action-btn"
+                  >操作</el-button>
+                  <el-button
+                    type="danger"
+                    icon="el-icon-delete"
+                    size="mini"
+                    @click="handleDeleteAction(item)"
+                    class="action-btn"
+                  >删除</el-button>
+                </template>
+                <!-- 处理中状态显示继续按钮 -->
+                <template v-else-if="item.actionStatus === 1">
+                  <el-button
+                    type="warning"
+                    icon="el-icon-edit"
+                    size="mini"
+                    @click="handleProcess(item)"
+                    class="action-btn"
+                  >继续</el-button>
+                  <el-button
+                    type="info"
+                    icon="el-icon-close"
+                    size="mini"
+                    @click="handleCancel(item)"
+                    class="action-btn"
+                  >取消</el-button>
+                </template>
+                <!-- 已完成或已取消状态显示删除按钮 -->
+                <template v-else>
+                  <el-button
+                    type="danger"
+                    icon="el-icon-delete"
+                    size="mini"
+                    @click="handleDeleteAction(item)"
+                    class="action-btn"
+                  >删除</el-button>
+                </template>
+              </div>
+            </div>
+          </div>
+
+          <!-- 分页 -->
+          <pagination
+            v-show="actionTotal > 0"
+            :total="actionTotal"
+            :page.sync="actionQueryParams.pageNum"
+            :limit.sync="actionQueryParams.pageSize"
+            @pagination="getPendingAction"
+          />
+        </div>
       </el-col>
     </el-row>
   </div>
@@ -15,25 +342,659 @@
 
 <script>
 import { listMaterialCoil } from '@/api/wms/coil'
-import { listPendingAction, startProcess, cancelAction } from '@/api/wms/pendingAction'
+import { listPendingAction, startProcess, cancelAction, delPendingAction, addPendingAction } from '@/api/wms/pendingAction'
+import { parseTime } from '@/utils/klp'
+import ProductInfo from '@/components/KLPService/Renderer/ProductInfo'
+import RawMaterialInfo from '@/components/KLPService/Renderer/RawMaterialInfo'
 
 export default {
   name: 'AcidDo',
   dicts: ['action_type'],
+  components: {
+    ProductInfo,
+    RawMaterialInfo
+  },
+  data() {
+    return {
+      // 物料列表相关
+      materialLoading: false,
+      materialCoilList: [],
+      materialTotal: 0,
+      materialQueryParams: {
+        pageNum: 1,
+        pageSize: 20,
+        dataType: 1,
+        materialType: '原料',
+        enterCoilNo: null,
+        currentCoilNo: null
+      },
+      
+      // 待操作列表相关
+      actionLoading: false,
+      pendingActionList: [],
+      actionTotal: 0,
+      actionQueryParams: {
+        pageNum: 1,
+        pageSize: 20,
+        currentCoilNo: null,
+        actionType: null, // 将在created中设置为酸连轧工序的actionType
+        actionStatus: null
+      }
+    }
+  },
+  computed: {
+    // 获取酸连轧工序的actionType值
+    acidRollingActionType() {
+      if (!this.dict.type.action_type) return null
+      const acidAction = this.dict.type.action_type.find(item => {
+        const label = item.label || ''
+        return label.includes('酸连轧') || label.includes('酸连')
+      })
+      return acidAction ? parseInt(acidAction.value) : null
+    }
+  },
+  watch: {
+    // 监听字典数据加载，当acidRollingActionType有值时自动加载待操作列表
+    acidRollingActionType(newVal) {
+      if (newVal && !this.actionQueryParams.actionType) {
+        this.actionQueryParams.actionType = newVal
+        // 如果待操作列表为空，则加载数据
+        if (this.pendingActionList.length === 0) {
+          this.getPendingAction()
+        }
+      }
+    }
+  },
+  created() {
+    // 立即加载物料列表（不依赖字典）
+    this.getMaterialCoil()
+    
+    // 尝试加载待操作列表（如果字典已加载）
+    this.$nextTick(() => {
+      if (this.acidRollingActionType) {
+        this.actionQueryParams.actionType = this.acidRollingActionType
+        this.getPendingAction()
+      }
+    })
+  },
+  mounted() {
+    // 确保在mounted时也尝试加载（字典数据可能此时才加载完成）
+    this.$nextTick(() => {
+      if (this.acidRollingActionType && !this.actionQueryParams.actionType) {
+        this.actionQueryParams.actionType = this.acidRollingActionType
+        this.getPendingAction()
+      }
+    })
+  },
   methods: {
-    // 获取当前待领的料
+    parseTime,
+    
+    // ========== 物料列表相关方法 ==========
+    /** 查询物料列表 */
     getMaterialCoil() {
-      listMaterialCoil({ dataType: 1, materialType: '原料' }).then(res => {
-        this.materialCoilList = res.data
+      this.materialLoading = true
+      listMaterialCoil(this.materialQueryParams).then(response => {
+        this.materialCoilList = response.rows || []
+        this.materialTotal = response.total || 0
+        this.materialLoading = false
+      }).catch(() => {
+        this.materialLoading = false
       })
     },
-    // 获取待操作列表
+    /** 物料搜索 */
+    handleMaterialQuery() {
+      this.materialQueryParams.pageNum = 1
+      this.getMaterialCoil()
+    },
+    /** 重置物料搜索 */
+    resetMaterialQuery() {
+      this.resetForm('materialQueryForm')
+      this.materialQueryParams.enterCoilNo = null
+      this.materialQueryParams.currentCoilNo = null
+      this.handleMaterialQuery()
+    },
+    /** 领料操作 */
+    handlePickMaterial(row) {
+      if (!this.acidRollingActionType) {
+        this.$message.error('未找到酸连轧工序操作类型，请检查字典配置')
+        return
+      }
+      
+      this.$set(row, 'picking', true)
+      
+      const pendingData = {
+        coilId: row.coilId,
+        currentCoilNo: row.currentCoilNo,
+        actionType: this.acidRollingActionType,
+        actionStatus: 0, // 待处理
+        sourceType: 'manual', // 手动创建
+        warehouseId: row.warehouseId,
+        priority: 0, // 默认普通优先级
+        remark: `PC端领料创建-酸连轧工序`
+      }
+      
+      addPendingAction(pendingData).then(response => {
+        if (response.code === 200) {
+          this.$message.success('领料成功，已创建待操作任务')
+          this.getPendingAction() // 刷新待操作列表
+        } else {
+          this.$message.error(response.msg || '领料失败')
+        }
+      }).catch(error => {
+        console.error('领料失败：', error)
+        this.$message.error('领料失败，请重试')
+      }).finally(() => {
+        this.$set(row, 'picking', false)
+      })
+    },
+    
+    // ========== 待操作列表相关方法 ==========
+    /** 查询待操作列表 */
     getPendingAction() {
-      listPendingAction().then(res => {
-        this.pendingActionList = res.data
+      // 确保只查询酸连轧工序的待操作
+      if (!this.acidRollingActionType) {
+        console.warn('未找到酸连轧工序操作类型，请检查字典配置')
+        this.pendingActionList = []
+        this.actionTotal = 0
+        this.actionLoading = false
+        return
+      }
+      
+      this.actionLoading = true
+      // 强制使用酸连轧工序的 actionType，忽略查询参数中的 actionType
+      const queryParams = {
+        ...this.actionQueryParams,
+        actionType: this.acidRollingActionType
+      }
+      listPendingAction(queryParams).then(response => {
+        this.pendingActionList = response.rows || []
+        this.actionTotal = response.total || 0
+        this.actionLoading = false
+      }).catch(() => {
+        this.actionLoading = false
       })
     },
-
+    /** 待操作搜索 */
+    handleActionQuery() {
+      this.actionQueryParams.pageNum = 1
+      // 确保始终使用酸连轧工序的 actionType
+      if (this.acidRollingActionType) {
+        this.actionQueryParams.actionType = this.acidRollingActionType
+      }
+      this.getPendingAction()
+    },
+    /** 重置待操作搜索 */
+    resetActionQuery() {
+      this.resetForm('actionQueryForm')
+      this.actionQueryParams.currentCoilNo = null
+      this.actionQueryParams.actionStatus = null
+      // 确保始终使用酸连轧工序的 actionType
+      if (this.acidRollingActionType) {
+        this.actionQueryParams.actionType = this.acidRollingActionType
+      }
+      this.handleActionQuery()
+    },
+    /** 处理操作 - 跳转到对应页面 */
+    handleProcess(row) {
+      const actionType = parseInt(row.actionType)
+      
+      // 特殊处理：发货和移库操作不需要跳转
+      if (actionType === 4 || actionType === 5) {
+        this.$message.info(actionType === 4 ? '发货操作已在移动端完成' : '移库操作已在移动端完成')
+        return
+      }
+      
+      // 根据操作类型跳转到不同页面
+      let path = ''
+      
+      // 分条操作：100-199
+      if (actionType >= 100 && actionType <= 199) {
+        path = '/wms/split'
+      } 
+      // 合卷操作：200-299
+      else if (actionType == 200) {
+        path = '/wms/merge'
+      }
+      // 其他操作类型
+      else {
+        path = '/wms/typing'
+      }
+      
+      if (!path) {
+        this.$message.error('未知的操作类型: ' + row.actionType)
+        return
+      }
+      
+      // 更新状态为处理中
+      startProcess(row.actionId).then(response => {
+        if (response.code !== 200) {
+          this.$message.error(response.msg || '更新状态失败')
+          return
+        }
+        
+        // 跳转并传递参数
+        this.$router.push({
+          path: path,
+          query: {
+            coilId: row.coilId,
+            actionId: row.actionId
+          }
+        })
+      }).catch(error => {
+        console.error('更新状态失败:', error)
+        this.$message.error('更新状态失败: ' + (error.message || error))
+      })
+    },
+    /** 取消操作 */
+    handleCancel(row) {
+      this.$confirm('是否确认取消该操作?', '提示', {
+        confirmButtonText: '确定',
+        cancelButtonText: '取消',
+        type: 'warning'
+      }).then(() => {
+        return cancelAction(row.actionId)
+      }).then(() => {
+        this.$message.success('操作已取消')
+        this.getPendingAction()
+      }).catch(() => {})
+    },
+    /** 删除待操作 */
+    handleDeleteAction(row) {
+      const actionId = row.actionId
+      this.$confirm('是否确认删除该待操作记录?', '警告', {
+        confirmButtonText: '确定',
+        cancelButtonText: '取消',
+        type: 'warning'
+      }).then(() => {
+        return delPendingAction(actionId)
+      }).then(() => {
+        this.getPendingAction()
+        this.$message.success('删除成功')
+      }).catch(() => {})
+    },
+    /** 获取物品名称 */
+    getItemName(item) {
+      if (item.itemType === 'product' && item.product) {
+        return item.product.productName || ''
+      } else if (item.itemType === 'raw_material' && item.rawMaterial) {
+        return item.rawMaterial.rawMaterialName || ''
+      }
+      return '—'
+    },
   }
 }
-</script>
\ No newline at end of file
+</script>
+
+<style scoped lang="scss">
+.acid-do-container {
+  background-color: #f5f7fa;
+  padding: 20px;
+  min-height: calc(100vh - 84px);
+}
+
+.section-card {
+  background-color: #ffffff;
+  border: 1px solid #e4e7ed;
+  border-radius: 4px;
+  padding: 16px;
+  box-shadow: 0 2px 4px rgba(0, 0, 0, 0.05);
+}
+
+.section-header {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  margin-bottom: 16px;
+  padding-bottom: 12px;
+  border-bottom: 2px solid #e4e7ed;
+}
+
+.section-title {
+  margin: 0;
+  font-size: 16px;
+  font-weight: 600;
+  color: #303133;
+}
+
+.material-section {
+  .section-header {
+    border-bottom-color: #409eff;
+  }
+  .section-title {
+    color: #409eff;
+  }
+}
+
+.action-section {
+  .section-header {
+    border-bottom-color: #67c23a;
+  }
+  .section-title {
+    color: #67c23a;
+  }
+}
+
+.query-form {
+  margin-bottom: 16px;
+  padding: 12px;
+  background-color: #fafafa;
+  border-radius: 4px;
+  border: 1px solid #e4e7ed;
+}
+
+// 卡片网格容器
+.card-grid-container {
+  display: grid;
+  grid-template-columns: repeat(3, 1fr);
+  gap: 8px;
+  max-height: calc(100vh - 320px);
+  overflow-y: auto;
+  padding-right: 4px;
+  
+  &::-webkit-scrollbar {
+    width: 6px;
+  }
+  
+  &::-webkit-scrollbar-track {
+    background: #f1f1f1;
+    border-radius: 3px;
+  }
+  
+  &::-webkit-scrollbar-thumb {
+    background: #c1c1c1;
+    border-radius: 3px;
+    
+    &:hover {
+      background: #a8a8a8;
+    }
+  }
+  
+  @media (min-width: 1600px) {
+    grid-template-columns: repeat(4, 1fr);
+  }
+}
+
+// 空状态
+.empty-state {
+  text-align: center;
+  padding: 60px 20px;
+  color: #909399;
+  
+  i {
+    font-size: 48px;
+    margin-bottom: 16px;
+    display: block;
+    color: #c0c4cc;
+  }
+  
+  p {
+    margin: 0;
+    font-size: 14px;
+  }
+}
+
+// 物料卡片
+.material-card {
+  background-color: #ffffff;
+  border: 1px solid #e4e7ed;
+  border-radius: 3px;
+  display: flex;
+  flex-direction: column;
+  transition: all 0.3s ease;
+  height: 100%;
+  
+  &:hover {
+    border-color: #409eff;
+    box-shadow: 0 2px 6px rgba(64, 158, 255, 0.12);
+  }
+  
+  .card-header {
+    padding: 6px 8px;
+    border-bottom: 1px solid #e4e7ed;
+    background-color: #fafafa;
+    
+    .header-left {
+      display: flex;
+      align-items: center;
+      gap: 6px;
+    }
+    
+    .coil-no-tag {
+      font-weight: 600;
+      font-size: 11px;
+      padding: 2px 6px;
+    }
+    
+    .material-type {
+      font-size: 11px;
+      color: #606266;
+      font-weight: 500;
+    }
+    
+    .param-icon {
+      font-size: 13px;
+      color: #909399;
+      cursor: pointer;
+      transition: color 0.3s;
+      
+      &:hover {
+        color: #409eff;
+      }
+    }
+  }
+  
+  .card-body {
+    padding: 8px;
+    flex: 1;
+    
+    .info-list {
+      .info-item {
+        display: flex;
+        align-items: center;
+        margin-bottom: 4px;
+        font-size: 11px;
+        line-height: 1.4;
+        
+        &:last-child {
+          margin-bottom: 0;
+        }
+        
+        .info-label {
+          color: #909399;
+          white-space: nowrap;
+          margin-right: 4px;
+          min-width: 40px;
+          font-size: 11px;
+        }
+        
+        .info-value {
+          color: #303133;
+          flex: 1;
+          overflow: hidden;
+          text-overflow: ellipsis;
+          white-space: nowrap;
+          font-size: 11px;
+        }
+      }
+    }
+  }
+  
+  .card-footer {
+    padding: 6px 8px;
+    border-top: 1px solid #e4e7ed;
+    background-color: #fafafa;
+    display: flex;
+    justify-content: center;
+    
+    .action-btn {
+      width: 100%;
+      padding: 5px 10px;
+      font-size: 11px;
+    }
+  }
+}
+
+// 待操作卡片
+.action-card {
+  background-color: #ffffff;
+  border: 1px solid #e4e7ed;
+  border-radius: 4px;
+  display: flex;
+  flex-direction: column;
+  transition: all 0.3s ease;
+  height: 100%;
+  
+  &:hover {
+    border-color: #67c23a;
+    box-shadow: 0 2px 8px rgba(103, 194, 58, 0.15);
+  }
+  
+  &.urgent-card {
+    border-left: 4px solid #f56c6c;
+    background-color: #fef0f0;
+    
+    &:hover {
+      border-color: #f56c6c;
+      box-shadow: 0 2px 8px rgba(245, 108, 108, 0.2);
+    }
+  }
+  
+  &.important-card {
+    border-left: 4px solid #e6a23c;
+    background-color: #fdf6ec;
+    
+    &:hover {
+      border-color: #e6a23c;
+      box-shadow: 0 2px 8px rgba(230, 162, 60, 0.2);
+    }
+  }
+  
+  .card-header {
+    padding: 10px 12px;
+    border-bottom: 1px solid #e4e7ed;
+    background-color: #fafafa;
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    
+    .coil-no-tag {
+      font-weight: 600;
+      font-size: 12px;
+    }
+    
+    .status-tags {
+      display: flex;
+      gap: 4px;
+      flex-wrap: wrap;
+    }
+  }
+  
+  .card-body {
+    padding: 12px;
+    flex: 1;
+    
+    .info-list {
+      .info-item {
+        display: flex;
+        align-items: center;
+        margin-bottom: 8px;
+        font-size: 12px;
+        
+        &:last-child {
+          margin-bottom: 0;
+        }
+        
+        .info-label {
+          color: #909399;
+          white-space: nowrap;
+          margin-right: 6px;
+          min-width: 50px;
+        }
+        
+        .info-value {
+          color: #303133;
+          flex: 1;
+          overflow: hidden;
+          text-overflow: ellipsis;
+          white-space: nowrap;
+        }
+        
+        .action-type-tag {
+          font-size: 11px;
+        }
+      }
+    }
+  }
+  
+  .card-footer {
+    padding: 10px 12px;
+    border-top: 1px solid #e4e7ed;
+    background-color: #fafafa;
+    display: flex;
+    justify-content: center;
+    gap: 6px;
+    
+    .action-btn {
+      flex: 1;
+      font-size: 12px;
+      padding: 6px 8px;
+    }
+  }
+}
+
+// 分页样式
+::v-deep .pagination-container {
+  margin-top: 16px;
+  padding: 12px;
+  background-color: #fafafa;
+  border-radius: 4px;
+  border: 1px solid #e4e7ed;
+}
+
+// 参数弹出框样式
+::v-deep .material-params-popover {
+  .material-params-content {
+    .params-title {
+      font-size: 14px;
+      font-weight: 600;
+      color: #303133;
+      margin-bottom: 12px;
+      padding-bottom: 8px;
+      border-bottom: 1px solid #e4e7ed;
+    }
+    
+    .params-list {
+      .param-item {
+        .param-row {
+          display: flex;
+          margin-bottom: 6px;
+          font-size: 12px;
+          line-height: 1.5;
+          
+          &:last-child {
+            margin-bottom: 0;
+          }
+          
+          .param-label {
+            color: #909399;
+            min-width: 70px;
+            margin-right: 8px;
+          }
+          
+          .param-value {
+            color: #303133;
+            flex: 1;
+            word-break: break-all;
+          }
+        }
+      }
+      
+      .param-divider {
+        height: 1px;
+        background-color: #e4e7ed;
+        margin: 10px 0;
+      }
+    }
+  }
+}
+</style>
\ No newline at end of file
diff --git a/klp-ui/src/views/wms/coil/merge.vue b/klp-ui/src/views/wms/coil/merge.vue
index d04ec4c7..aff85417 100644
--- a/klp-ui/src/views/wms/coil/merge.vue
+++ b/klp-ui/src/views/wms/coil/merge.vue
@@ -220,8 +220,8 @@
 <script>
 import { getMaterialCoil, mergeMaterialCoil } from '@/api/wms/coil';
 import { listWarehouse } from '@/api/wms/warehouse';
-import { listRawMaterial } from '@/api/wms/rawMaterial';
-import { listProduct } from '@/api/wms/product';
+import { listRawMaterialWithBom } from '@/api/wms/rawMaterial';
+import { listProductWithBom } from '@/api/wms/product';
 import { listPendingAction, completeAction } from '@/api/wms/pendingAction';
 import CoilSelector from '@/components/CoilSelector';
 import ActualWarehouseSelect from "@/components/KLPService/ActualWarehouseSelect";
@@ -259,12 +259,9 @@ export default {
       currentSelectIndex: -1,
       // 库区列表
       warehouseList: [],
-      // 原材料和产品列表
+      // 原材料和产品列表（实时搜索，不再保存完整备份）
       rawMaterialList: [],
       productList: [],
-      // 原始完整列表备份（用于搜索过滤）
-      allRawMaterials: [],
-      allProducts: [],
       itemSearchLoading: false,
       // 只读模式
       readonly: false,
@@ -317,8 +314,8 @@ export default {
     // 加载库区列表
     await this.loadWarehouses();
 
-    // 🔥 页面加载时直接加载所有原料和产品列表
-    await this.loadAllItems();
+    // 不再一次性加载所有数据，改为实时搜索
+    // await this.loadAllItems();
 
     // 从路由参数获取coilId、actionId和readonly
     const coilId = this.$route.query.coilId;
@@ -378,15 +375,15 @@ export default {
       // 清空物品选择
       this.$set(this.targetCoil, 'itemId', null);
 
-      // 根据材料类型设置物品类型并恢复完整列表
+      // 根据材料类型设置物品类型
       if (value === '成品') {
         this.$set(this.targetCoil, 'itemType', 'product');
-        // 恢复完整产品列表
-        this.productList = [...this.allProducts];
+        // 清空列表，等待用户搜索
+        this.productList = [];
       } else if (value === '原料' || value === '废品') {
         this.$set(this.targetCoil, 'itemType', 'raw_material');
-        // 恢复完整原料列表
-        this.rawMaterialList = [...this.allRawMaterials];
+        // 清空列表，等待用户搜索
+        this.rawMaterialList = [];
       }
     },
 
@@ -435,10 +432,7 @@ export default {
           this.targetCoil.warehouseId = data.warehouseId;
           this.targetCoil.actualWarehouseId = data.actualWarehouseId;
 
-          // 加载对应的物品列表
-          if (data.itemType) {
-            await this.loadItemList(data.itemType);
-          }
+          // 不再预加载物品列表，改为实时搜索
         }
       } catch (error) {
         this.$message.error('加载钢卷信息失败');
@@ -576,113 +570,59 @@ export default {
       }
     },
 
-    // 页面加载时一次性加载所有原料和产品列表
-    async loadAllItems() {
-      try {
-        // 同时加载原料和产品
-        const [rawMaterialRes, productRes] = await Promise.all([
-          listRawMaterial({ pageNum: 1, pageSize: 99999, withBom: true }),
-          listProduct({ pageNum: 1, pageSize: 99999, withBom: true })
-        ]);
+    // 已移除 loadAllItems，改为实时搜索
 
-        if (rawMaterialRes.code === 200) {
-          this.rawMaterialList = rawMaterialRes.rows || [];
-          this.allRawMaterials = rawMaterialRes.rows || []; // 保存完整备份
-        }
+    // 已移除 loadItemList，改为实时搜索
 
-        if (productRes.code === 200) {
-          this.productList = productRes.rows || [];
-          this.allProducts = productRes.rows || []; // 保存完整备份
-        }
-      } catch (error) {
-        console.error('加载物品列表失败', error);
-      }
-    },
-
-    // 加载物品列表（根据类型）
-    async loadItemList(itemType) {
-      if (!itemType) {
-        return;
-      }
-
-      try {
-        this.itemSearchLoading = true;
-        if (itemType === 'raw_material') {
-          const response = await listRawMaterial({
-            pageNum: 1,
-            pageSize: 100,
-            withBom: true
-          });
-          if (response.code === 200) {
-            this.rawMaterialList = response.rows || [];
-          }
-        } else if (itemType === 'product') {
-          const response = await listProduct({
-            pageNum: 1,
-            pageSize: 100,
-            withBom: true
-          });
-          if (response.code === 200) {
-            this.productList = response.rows || [];
-          }
-        }
-      } catch (error) {
-        console.error('merge.vue 加载物品列表失败', error);
-      } finally {
-        this.itemSearchLoading = false;
-      }
-    },
-
-    // 搜索物品（前端过滤，支持名称和规格搜索）
+    // 实时搜索物品（后端搜索）
     async searchItems(query) {
       if (!this.targetCoil.itemType) {
         this.$message.warning('请先选择材料类型');
         return;
       }
 
-      // 如果没有输入，恢复完整列表
+      // 如果没有输入，清空列表
       if (!query || query.trim() === '') {
         if (this.targetCoil.itemType === 'raw_material') {
-          this.rawMaterialList = [...this.allRawMaterials];
+          this.rawMaterialList = [];
         } else if (this.targetCoil.itemType === 'product') {
-          this.productList = [...this.allProducts];
+          this.productList = [];
         }
         return;
       }
 
-      // 前端过滤：在已加载的数据中搜索
-      const searchQuery = query.toLowerCase().trim();
+      try {
+        this.itemSearchLoading = true;
+        const searchQuery = query.trim();
 
-      if (this.targetCoil.itemType === 'raw_material') {
-        // 从备份列表中过滤原材料
-        this.rawMaterialList = this.allRawMaterials.filter(item => {
-          // 搜索名称
-          const nameMatch = item.rawMaterialName && item.rawMaterialName.toLowerCase().includes(searchQuery);
-          // 搜索规格
-          const specMatch = item.specification && item.specification.toLowerCase().includes(searchQuery);
-          // 搜索 参数 参数
-          const bomMatch = item.bomItems && item.bomItems.some(bom =>
-            (bom.attrKey && bom.attrKey.toLowerCase().includes(searchQuery)) ||
-            (bom.attrValue && bom.attrValue.toLowerCase().includes(searchQuery))
-          );
-
-          return nameMatch || specMatch || bomMatch;
-        });
-      } else if (this.targetCoil.itemType === 'product') {
-        // 从备份列表中过滤产品
-        this.productList = this.allProducts.filter(item => {
-          // 搜索名称
-          const nameMatch = item.productName && item.productName.toLowerCase().includes(searchQuery);
-          // 搜索规格
-          const specMatch = item.specification && item.specification.toLowerCase().includes(searchQuery);
-          // 搜索 参数 参数
-          const bomMatch = item.bomItems && item.bomItems.some(bom =>
-            (bom.attrKey && bom.attrKey.toLowerCase().includes(searchQuery)) ||
-            (bom.attrValue && bom.attrValue.toLowerCase().includes(searchQuery))
-          );
-
-          return nameMatch || specMatch || bomMatch;
-        });
+        if (this.targetCoil.itemType === 'raw_material') {
+          // 后端搜索原材料（支持名称或规格模糊搜索）
+          const response = await listRawMaterialWithBom({
+            pageNum: 1,
+            pageSize: 20,
+            rawMaterialName: searchQuery,
+            specification: searchQuery  // 同时传入，后端会使用 OR 条件
+          });
+          if (response.code === 200) {
+            this.rawMaterialList = response.rows || [];
+          }
+        } else if (this.targetCoil.itemType === 'product') {
+          // 后端搜索产品（支持名称或规格模糊搜索）
+          const response = await listProductWithBom({
+            pageNum: 1,
+            pageSize: 20,
+            productName: searchQuery,
+            specification: searchQuery  // 同时传入，后端会使用 OR 条件
+          });
+          if (response.code === 200) {
+            this.productList = response.rows || [];
+          }
+        }
+      } catch (error) {
+        console.error('搜索物品失败', error);
+        this.$message.error('搜索失败，请重试');
+      } finally {
+        this.itemSearchLoading = false;
       }
     },
 
diff --git a/klp-ui/src/views/wms/coil/split.vue b/klp-ui/src/views/wms/coil/split.vue
index eb3ce070..98c986e5 100644
--- a/klp-ui/src/views/wms/coil/split.vue
+++ b/klp-ui/src/views/wms/coil/split.vue
@@ -200,8 +200,8 @@
 <script>
 import { getMaterialCoil, splitMaterialCoil } from '@/api/wms/coil';
 import { listWarehouse } from '@/api/wms/warehouse';
-import { listRawMaterial } from '@/api/wms/rawMaterial';
-import { listProduct } from '@/api/wms/product';
+import { listRawMaterialWithBom } from '@/api/wms/rawMaterial';
+import { listProductWithBom } from '@/api/wms/product';
 import { completeAction } from '@/api/wms/pendingAction';
 import CoilSelector from '@/components/CoilSelector';
 import ActualWarehouseSelect from "@/components/KLPService/ActualWarehouseSelect";
@@ -249,12 +249,9 @@ export default {
       coilSelectorVisible: false,
       // 库区列表
       warehouseList: [],
-      // 原材料和产品列表
+      // 原材料和产品列表（实时搜索，不再保存完整备份）
       rawMaterialList: [],
       productList: [],
-      // 原始完整列表备份（用于搜索过滤）
-      allRawMaterials: [],
-      allProducts: [],
       itemSearchLoading: false,
       // 只读模式
       readonly: false,
@@ -268,8 +265,8 @@ export default {
     // 先加载库区列表
     await this.loadWarehouses();
 
-    // 🔥 页面加载时直接加载所有原料和产品列表
-    await this.loadAllItems();
+    // 不再一次性加载所有数据，改为实时搜索
+    // await this.loadAllItems();
 
     // 从路由参数获取coilId、actionId和readonly
     const coilId = this.$route.query.coilId;
@@ -296,15 +293,15 @@ export default {
       // 清空物品选择
       this.$set(item, 'itemId', null);
 
-      // 根据材料类型设置物品类型并恢复完整列表
+      // 根据材料类型设置物品类型
       if (item.materialType === '成品') {
         this.$set(item, 'itemType', 'product');
-        // 恢复完整产品列表
-        this.productList = [...this.allProducts];
+        // 清空列表，等待用户搜索
+        this.productList = [];
       } else if (item.materialType === '原料' || item.materialType === '废品') {
         this.$set(item, 'itemType', 'raw_material');
-        // 恢复完整原料列表
-        this.rawMaterialList = [...this.allRawMaterials];
+        // 清空列表，等待用户搜索
+        this.rawMaterialList = [];
       }
     },
 
@@ -379,13 +376,12 @@ export default {
       return displayName;
     },
 
-    // 物品类型变化
-    handleItemTypeChange(index) {
-      this.splitList[index].itemId = null;
-      this.loadItemListForSplit(this.splitList[index].itemType);
-    },
+    // 物品类型变化（已移除，改为实时搜索）
+    // handleItemTypeChange(index) {
+    //   this.splitList[index].itemId = null;
+    // },
 
-    // 搜索子卷物品（前端过滤，支持名称和规格搜索）
+    // 实时搜索子卷物品（后端搜索）
     async searchItemsForSplit(query, index) {
       const item = this.splitList[index];
 
@@ -395,109 +391,55 @@ export default {
         return;
       }
 
-      // 如果没有输入，恢复完整列表
+      // 如果没有输入，清空列表
       if (!query || query.trim() === '') {
         if (itemType === 'raw_material') {
-          this.rawMaterialList = [...this.allRawMaterials];
+          this.rawMaterialList = [];
         } else if (itemType === 'product') {
-          this.productList = [...this.allProducts];
+          this.productList = [];
         }
         return;
       }
 
-      // 前端过滤：在已加载的数据中搜索
-      const searchQuery = query.toLowerCase().trim();
-
-      if (itemType === 'raw_material') {
-        // 从备份列表中过滤原材料
-        this.rawMaterialList = this.allRawMaterials.filter(item => {
-          // 搜索名称
-          const nameMatch = item.rawMaterialName && item.rawMaterialName.toLowerCase().includes(searchQuery);
-          // 搜索规格
-          const specMatch = item.specification && item.specification.toLowerCase().includes(searchQuery);
-          // 搜索 参数 参数
-          const bomMatch = item.bomItems && item.bomItems.some(bom =>
-            (bom.attrKey && bom.attrKey.toLowerCase().includes(searchQuery)) ||
-            (bom.attrValue && bom.attrValue.toLowerCase().includes(searchQuery))
-          );
-
-          return nameMatch || specMatch || bomMatch;
-        });
-      } else if (itemType === 'product') {
-        // 从备份列表中过滤产品
-        this.productList = this.allProducts.filter(item => {
-          // 搜索名称
-          const nameMatch = item.productName && item.productName.toLowerCase().includes(searchQuery);
-          // 搜索规格
-          const specMatch = item.specification && item.specification.toLowerCase().includes(searchQuery);
-          // 搜索 参数 参数
-          const bomMatch = item.bomItems && item.bomItems.some(bom =>
-            (bom.attrKey && bom.attrKey.toLowerCase().includes(searchQuery)) ||
-            (bom.attrValue && bom.attrValue.toLowerCase().includes(searchQuery))
-          );
-
-          return nameMatch || specMatch || bomMatch;
-        });
-      }
-    },
-
-    // 页面加载时一次性加载所有原料和产品列表
-    async loadAllItems() {
-      try {
-        // 同时加载原料和产品
-        const [rawMaterialRes, productRes] = await Promise.all([
-          listRawMaterial({ pageNum: 1, pageSize: 99999, withBom: true }),
-          listProduct({ pageNum: 1, pageSize: 99999, withBom: true })
-        ]);
-
-        if (rawMaterialRes.code === 200) {
-          this.rawMaterialList = rawMaterialRes.rows || [];
-          this.allRawMaterials = rawMaterialRes.rows || []; // 保存完整备份
-        }
-
-        if (productRes.code === 200) {
-          this.productList = productRes.rows || [];
-          this.allProducts = productRes.rows || []; // 保存完整备份
-        }
-      } catch (error) {
-        console.error('加载物品列表失败', error);
-      }
-    },
-
-    // 加载子卷物品列表
-    async loadItemListForSplit(itemType) {
-      if (!itemType) {
-        return;
-      }
-
       try {
         this.itemSearchLoading = true;
+        const searchQuery = query.trim();
+
         if (itemType === 'raw_material') {
-          const response = await listRawMaterial({
+          // 后端搜索原材料（支持名称或规格模糊搜索）
+          const response = await listRawMaterialWithBom({
             pageNum: 1,
-            pageSize: 100,
-            withBom: true
+            pageSize: 20,
+            rawMaterialName: searchQuery,
+            specification: searchQuery  // 同时传入，后端会使用 OR 条件
           });
           if (response.code === 200) {
             this.rawMaterialList = response.rows || [];
           }
         } else if (itemType === 'product') {
-          const response = await listProduct({
+          // 后端搜索产品（支持名称或规格模糊搜索）
+          const response = await listProductWithBom({
             pageNum: 1,
-            pageSize: 100,
-            withBom: true
+            pageSize: 20,
+            productName: searchQuery,
+            specification: searchQuery  // 同时传入，后端会使用 OR 条件
           });
           if (response.code === 200) {
             this.productList = response.rows || [];
           }
         }
       } catch (error) {
-        console.error('split.vue 加载物品列表失败', error);
+        console.error('搜索物品失败', error);
+        this.$message.error('搜索失败，请重试');
       } finally {
         this.itemSearchLoading = false;
       }
     },
 
+    // 已移除 loadAllItems，改为实时搜索
+
+    // 已移除 loadItemListForSplit，改为实时搜索
+
     // 显示钢卷选择器
     showCoilSelector() {
       this.coilSelectorVisible = true;
@@ -717,10 +659,7 @@ export default {
         // 不复制 itemType 和 itemId，让它们由 materialType 自动决定
       });
 
-      // 加载物品列表
-      if (this.motherCoil.itemType) {
-        this.loadItemListForSplit(this.motherCoil.itemType);
-      }
+      // 不再预加载物品列表，改为实时搜索
 
       this.$message.success('已复制到所有子卷');
     }
diff --git a/klp-ui/src/views/wms/coil/typing.vue b/klp-ui/src/views/wms/coil/typing.vue
index edbcac80..46076acd 100644
--- a/klp-ui/src/views/wms/coil/typing.vue
+++ b/klp-ui/src/views/wms/coil/typing.vue
@@ -218,8 +218,8 @@
 import { getMaterialCoil, updateMaterialCoil, getMaterialCoilTrace } from '@/api/wms/coil';
 import { completeAction } from '@/api/wms/pendingAction';
 import { listWarehouse } from '@/api/wms/warehouse';
-import { listRawMaterial } from '@/api/wms/rawMaterial';
-import { listProduct } from '@/api/wms/product';
+import { listRawMaterialWithBom } from '@/api/wms/rawMaterial';
+import { listProductWithBom } from '@/api/wms/product';
 import ActualWarehouseSelect from "@/components/KLPService/ActualWarehouseSelect";
 
 export default {
@@ -300,12 +300,9 @@ export default {
       warehouseList: [],
       historySteps: [],
       actionId: null,
-      // 原材料和产品列表
+      // 原材料和产品列表（实时搜索，不再保存完整备份）
       rawMaterialList: [],
       productList: [],
-      // 原始完整列表备份（用于搜索过滤）
-      allRawMaterials: [],
-      allProducts: [],
       itemSearchLoading: false,
       // 只读模式
       readonly: false
@@ -352,8 +349,8 @@ export default {
     // 先加载库区列表
     await this.loadWarehouses();
 
-    // 🔥 页面加载时直接加载所有原料和产品列表
-    await this.loadAllItems();
+    // 不再一次性加载所有数据，改为实时搜索
+    // await this.loadAllItems();
 
     // 从路由参数获取coilId和actionId
     const coilId = this.$route.query.coilId;
@@ -382,12 +379,12 @@ export default {
       // 根据材料类型设置物品类型
       if (value === '成品') {
         this.$set(this.updateForm, 'itemType', 'product');
-        // 恢复完整产品列表
-        this.productList = [...this.allProducts];
+        // 清空列表，等待用户搜索
+        this.productList = [];
       } else if (value === '原料' || value === '废品') {
         this.$set(this.updateForm, 'itemType', 'raw_material');
-        // 恢复完整原料列表
-        this.rawMaterialList = [...this.allRawMaterials];
+        // 清空列表，等待用户搜索
+        this.rawMaterialList = [];
       }
     },
 
@@ -406,10 +403,7 @@ export default {
             nextWarehouseName: this.getWarehouseName(data.warehouseId),
           };
 
-          // 加载对应类型的物品列表
-          if (data.itemType) {
-            await this.loadItemList(data.itemType);
-          }
+          // 不再预加载物品列表，改为实时搜索
 
           // 加载变更历史
           this.loadHistory();
@@ -492,115 +486,59 @@ export default {
       }
     },
 
-    // 页面加载时一次性加载所有原料和产品列表
-    async loadAllItems() {
-      try {
-        // 同时加载原料和产品
-        const [rawMaterialRes, productRes] = await Promise.all([
-          listRawMaterial({ pageNum: 1, pageSize: 99999, withBom: true }),
-          listProduct({ pageNum: 1, pageSize: 99999, withBom: true })
-        ]);
+    // 已移除 loadAllItems，改为实时搜索
 
-        if (rawMaterialRes.code === 200) {
-          this.rawMaterialList = rawMaterialRes.rows || [];
-          this.allRawMaterials = rawMaterialRes.rows || []; // 保存完整备份
-        }
+    // 已移除 loadItemList，改为实时搜索
 
-        if (productRes.code === 200) {
-          this.productList = productRes.rows || [];
-          this.allProducts = productRes.rows || []; // 保存完整备份
-        }
-      } catch (error) {
-        console.error('加载物品列表失败', error);
-      }
-    },
-
-    // 加载物品列表（根据类型）
-    async loadItemList(itemType) {
-      if (!itemType) {
-        return;
-      }
-
-      try {
-        this.itemSearchLoading = true;
-        if (itemType === 'raw_material') {
-          // 使用带参数的接口
-          const response = await listRawMaterial({
-            pageNum: 1,
-            pageSize: 100,
-            withBom: true  // 请求包含参数信息
-          });
-          if (response.code === 200) {
-            this.rawMaterialList = response.rows || [];
-          }
-        } else if (itemType === 'product') {
-          // 使用带参数的接口
-          const response = await listProduct({
-            pageNum: 1,
-            pageSize: 100,
-            withBom: true  // 请求包含参数信息
-          });
-          if (response.code === 200) {
-            this.productList = response.rows || [];
-          }
-        }
-      } catch (error) {
-        console.error('加载物品列表失败', error);
-      } finally {
-        this.itemSearchLoading = false;
-      }
-    },
-
-    // 搜索物品（前端过滤，支持名称和规格搜索）
+    // 实时搜索物品（后端搜索）
     async searchItems(query) {
       if (!this.updateForm.itemType) {
         this.$message.warning('请先选择材料类型');
         return;
       }
 
-      // 如果没有输入，恢复完整列表
+      // 如果没有输入，清空列表
       if (!query || query.trim() === '') {
         if (this.updateForm.itemType === 'raw_material') {
-          this.rawMaterialList = [...this.allRawMaterials];
+          this.rawMaterialList = [];
         } else if (this.updateForm.itemType === 'product') {
-          this.productList = [...this.allProducts];
+          this.productList = [];
         }
         return;
       }
 
-      // 前端过滤：在已加载的数据中搜索
-      const searchQuery = query.toLowerCase().trim();
+      try {
+        this.itemSearchLoading = true;
+        const searchQuery = query.trim();
 
-      if (this.updateForm.itemType === 'raw_material') {
-        // 从备份列表中过滤原材料
-        this.rawMaterialList = this.allRawMaterials.filter(item => {
-          // 搜索名称
-          const nameMatch = item.rawMaterialName && item.rawMaterialName.toLowerCase().includes(searchQuery);
-          // 搜索规格
-          const specMatch = item.specification && item.specification.toLowerCase().includes(searchQuery);
-          // 搜索 参数 参数
-          const bomMatch = item.bomItems && item.bomItems.some(bom =>
-            (bom.attrKey && bom.attrKey.toLowerCase().includes(searchQuery)) ||
-            (bom.attrValue && bom.attrValue.toLowerCase().includes(searchQuery))
-          );
-
-          return nameMatch || specMatch || bomMatch;
-        });
-      } else if (this.updateForm.itemType === 'product') {
-        // 从备份列表中过滤产品
-        this.productList = this.allProducts.filter(item => {
-          // 搜索名称
-          const nameMatch = item.productName && item.productName.toLowerCase().includes(searchQuery);
-          // 搜索规格
-          const specMatch = item.specification && item.specification.toLowerCase().includes(searchQuery);
-          // 搜索 参数 参数
-          const bomMatch = item.bomItems && item.bomItems.some(bom =>
-            (bom.attrKey && bom.attrKey.toLowerCase().includes(searchQuery)) ||
-            (bom.attrValue && bom.attrValue.toLowerCase().includes(searchQuery))
-          );
-
-          return nameMatch || specMatch || bomMatch;
-        });
+        if (this.updateForm.itemType === 'raw_material') {
+          // 后端搜索原材料（支持名称或规格模糊搜索）
+          const response = await listRawMaterialWithBom({
+            pageNum: 1,
+            pageSize: 20,
+            rawMaterialName: searchQuery,
+            specification: searchQuery  // 同时传入，后端会使用 OR 条件
+          });
+          if (response.code === 200) {
+            this.rawMaterialList = response.rows || [];
+          }
+        } else if (this.updateForm.itemType === 'product') {
+          // 后端搜索产品（支持名称或规格模糊搜索）
+          const response = await listProductWithBom({
+            pageNum: 1,
+            pageSize: 20,
+            productName: searchQuery,
+            specification: searchQuery  // 同时传入，后端会使用 OR 条件
+          });
+          if (response.code === 200) {
+            this.productList = response.rows || [];
+          }
+        }
+      } catch (error) {
+        console.error('搜索物品失败', error);
+        this.$message.error('搜索失败，请重试');
+      } finally {
+        this.itemSearchLoading = false;
       }
     },
 
diff --git a/klp-wms/src/main/java/com/klp/controller/WmsProductController.java b/klp-wms/src/main/java/com/klp/controller/WmsProductController.java
index 013f6790..ba7519f3 100644
--- a/klp-wms/src/main/java/com/klp/controller/WmsProductController.java
+++ b/klp-wms/src/main/java/com/klp/controller/WmsProductController.java
@@ -51,6 +51,10 @@ public class WmsProductController extends BaseController {
      */
     @GetMapping("/listWithBom")
     public TableDataInfo<WmsProductVo> listWithBom(WmsProductBo bo, PageQuery pageQuery) {
+        // 限制最大 pageSize 为 1000，防止查询过多数据导致性能问题
+        if (pageQuery.getPageSize() != null && pageQuery.getPageSize() > 1000) {
+            pageQuery.setPageSize(1000);
+        }
         return iWmsProductService.queryPageListWithBom(bo, pageQuery);
     }
 
diff --git a/klp-wms/src/main/java/com/klp/controller/WmsRawMaterialController.java b/klp-wms/src/main/java/com/klp/controller/WmsRawMaterialController.java
index abbdcba4..4ede3ec9 100644
--- a/klp-wms/src/main/java/com/klp/controller/WmsRawMaterialController.java
+++ b/klp-wms/src/main/java/com/klp/controller/WmsRawMaterialController.java
@@ -50,6 +50,10 @@ public class WmsRawMaterialController extends BaseController {
      */
     @GetMapping("/listWithBom")
     public TableDataInfo<WmsRawMaterialVo> listWithBom(WmsRawMaterialBo bo, PageQuery pageQuery) {
+        // 限制最大 pageSize 为 1000，防止查询过多数据导致性能问题
+        if (pageQuery.getPageSize() != null && pageQuery.getPageSize() > 1000) {
+            pageQuery.setPageSize(1000);
+        }
         return iWmsRawMaterialService.queryPageListWithBom(bo, pageQuery);
     }
 
diff --git a/klp-wms/src/main/java/com/klp/domain/vo/WmsMaterialCoilVo.java b/klp-wms/src/main/java/com/klp/domain/vo/WmsMaterialCoilVo.java
index 37cc332f..b5e807b0 100644
--- a/klp-wms/src/main/java/com/klp/domain/vo/WmsMaterialCoilVo.java
+++ b/klp-wms/src/main/java/com/klp/domain/vo/WmsMaterialCoilVo.java
@@ -211,6 +211,82 @@ public class WmsMaterialCoilVo extends BaseEntity {
      */
     private String packagingRequirement;
 
+    // ========== 联查临时字段（用于优化查询性能，避免单独查询） ==========
+    
+    /**
+     * 原材料ID（联查字段）
+     */
+    private Long rawMaterialId;
+    
+    /**
+     * 原材料编号（联查字段）
+     */
+    private String rawMaterialCode;
+    
+    /**
+     * 原材料名称（联查字段）
+     */
+    private String rawMaterialName;
+    
+    /**
+     * 原材料规格（联查字段）
+     */
+    private String rawMaterialSpecification;
+    
+    /**
+     * 原材料钢种（联查字段）
+     */
+    private String rawMaterialSteelGrade;
+    
+    /**
+     * 原材料厚度（联查字段）
+     */
+    private BigDecimal rawMaterialThickness;
+    
+    /**
+     * 原材料宽度（联查字段）
+     */
+    private BigDecimal rawMaterialWidth;
+    
+    /**
+     * 原材料BOM ID（联查字段）
+     */
+    private Long rawMaterialBomId;
+    
+    /**
+     * 产品ID（联查字段）
+     */
+    private Long productId;
+    
+    /**
+     * 产品编号（联查字段）
+     */
+    private String productCode;
+    
+    /**
+     * 产品名称（联查字段）
+     */
+    private String productName;
+    
+    /**
+     * 产品规格（联查字段）
+     */
+    private String productSpecification;
+    
+    /**
+     * 产品厚度（联查字段）
+     */
+    private BigDecimal productThickness;
+    
+    /**
+     * 产品宽度（联查字段）
+     */
+    private BigDecimal productWidth;
+    
+    /**
+     * 产品BOM ID（联查字段）
+     */
+    private Long productBomId;
 
 }
 
diff --git a/klp-wms/src/main/java/com/klp/service/impl/WmsMaterialCoilServiceImpl.java b/klp-wms/src/main/java/com/klp/service/impl/WmsMaterialCoilServiceImpl.java
index c3c66b15..626e9b68 100644
--- a/klp-wms/src/main/java/com/klp/service/impl/WmsMaterialCoilServiceImpl.java
+++ b/klp-wms/src/main/java/com/klp/service/impl/WmsMaterialCoilServiceImpl.java
@@ -26,6 +26,7 @@ import com.klp.domain.bo.WmsStockBo;
 import com.klp.domain.vo.WmsStockVo;
 import com.klp.mapper.WmsMaterialCoilMapper;
 import com.klp.mapper.WmsStockMapper;
+import com.klp.mapper.WmsGenerateRecordMapper;
 import com.klp.service.IWmsMaterialCoilService;
 import com.klp.service.IWmsStockService;
 import com.klp.service.IWmsGenerateRecordService;
@@ -61,6 +62,7 @@ public class WmsMaterialCoilServiceImpl implements IWmsMaterialCoilService {
     private final WmsMaterialCoilMapper baseMapper;
     private final IWmsStockService stockService;
     private final IWmsGenerateRecordService generateRecordService;
+    private final WmsGenerateRecordMapper generateRecordMapper;
     private final IWmsWarehouseService warehouseService;
     private final IWmsActualWarehouseService actualWarehouseService;
     private final IWmsRawMaterialService rawMaterialService;
@@ -84,7 +86,153 @@ public class WmsMaterialCoilServiceImpl implements IWmsMaterialCoilService {
     }
 
     /**
-     * 填充关联对象信息
+     * 批量填充关联对象信息（优化版本，避免N+1查询）
+     */
+    private void fillRelatedObjectsBatch(List<WmsMaterialCoilVo> voList) {
+        if (voList == null || voList.isEmpty()) {
+            return;
+        }
+
+        // 收集所有需要查询的ID
+        Set<Long> warehouseIds = new HashSet<>();
+        Set<Long> nextWarehouseIds = new HashSet<>();
+        Set<Long> actualWarehouseIds = new HashSet<>();
+        Set<Long> qrcodeRecordIds = new HashSet<>();
+        Set<Long> rawMaterialIds = new HashSet<>();
+        Set<Long> productIds = new HashSet<>();
+        Set<Long> bomIds = new HashSet<>();
+
+        for (WmsMaterialCoilVo vo : voList) {
+            if (vo.getWarehouseId() != null) warehouseIds.add(vo.getWarehouseId());
+            if (vo.getNextWarehouseId() != null) nextWarehouseIds.add(vo.getNextWarehouseId());
+            if (vo.getActualWarehouseId() != null) actualWarehouseIds.add(vo.getActualWarehouseId());
+            if (vo.getQrcodeRecordId() != null) qrcodeRecordIds.add(vo.getQrcodeRecordId());
+            if ("raw_material".equals(vo.getItemType()) && vo.getItemId() != null) {
+                rawMaterialIds.add(vo.getItemId());
+            }
+            if ("product".equals(vo.getItemType()) && vo.getItemId() != null) {
+                productIds.add(vo.getItemId());
+            }
+        }
+
+        // 批量查询库区信息
+        Map<Long, WmsWarehouseVo> warehouseMap = new HashMap<>();
+        if (!warehouseIds.isEmpty()) {
+            for (Long id : warehouseIds) {
+                WmsWarehouseVo warehouse = warehouseService.queryById(id);
+                if (warehouse != null) {
+                    warehouseMap.put(id, warehouse);
+                }
+            }
+        }
+        if (!nextWarehouseIds.isEmpty()) {
+            for (Long id : nextWarehouseIds) {
+                if (!warehouseMap.containsKey(id)) {
+                    WmsWarehouseVo warehouse = warehouseService.queryById(id);
+                    if (warehouse != null) {
+                        warehouseMap.put(id, warehouse);
+                    }
+                }
+            }
+        }
+
+        // 批量查询实际库区信息
+        Map<Long, WmsActualWarehouseVo> actualWarehouseMap = new HashMap<>();
+        if (!actualWarehouseIds.isEmpty()) {
+            for (Long id : actualWarehouseIds) {
+                WmsActualWarehouseVo actualWarehouse = actualWarehouseService.queryById(id);
+                if (actualWarehouse != null) {
+                    actualWarehouseMap.put(id, actualWarehouse);
+                }
+            }
+        }
+
+        // 批量查询二维码信息
+        Map<Long, WmsGenerateRecordVo> qrcodeMap = new HashMap<>();
+        if (!qrcodeRecordIds.isEmpty()) {
+            for (Long id : qrcodeRecordIds) {
+                WmsGenerateRecordVo qrcode = generateRecordService.queryById(id);
+                if (qrcode != null) {
+                    qrcodeMap.put(id, qrcode);
+                }
+            }
+        }
+
+        // 批量查询原材料信息
+        Map<Long, WmsRawMaterialVo> rawMaterialMap = new HashMap<>();
+        if (!rawMaterialIds.isEmpty()) {
+            for (Long id : rawMaterialIds) {
+                WmsRawMaterialVo rawMaterial = rawMaterialService.queryById(id);
+                if (rawMaterial != null) {
+                    rawMaterialMap.put(id, rawMaterial);
+                    if (rawMaterial.getBomId() != null) {
+                        bomIds.add(rawMaterial.getBomId());
+                    }
+                }
+            }
+        }
+
+        // 批量查询产品信息
+        Map<Long, WmsProductVo> productMap = new HashMap<>();
+        if (!productIds.isEmpty()) {
+            for (Long id : productIds) {
+                WmsProductVo product = productService.queryById(id);
+                if (product != null) {
+                    productMap.put(id, product);
+                    if (product.getBomId() != null) {
+                        bomIds.add(product.getBomId());
+                    }
+                }
+            }
+        }
+
+        // 批量查询BOM信息
+        Map<Long, List<WmsBomItemVo>> bomItemMap = new HashMap<>();
+        if (!bomIds.isEmpty()) {
+            for (Long bomId : bomIds) {
+                WmsBomItemBo bomItemBo = new WmsBomItemBo();
+                bomItemBo.setBomId(bomId);
+                List<WmsBomItemVo> bomItemList = bomItemService.queryList(bomItemBo);
+                if (bomItemList != null && !bomItemList.isEmpty()) {
+                    bomItemMap.put(bomId, bomItemList);
+                }
+            }
+        }
+
+        // 填充到VO对象中
+        for (WmsMaterialCoilVo vo : voList) {
+            if (vo.getWarehouseId() != null && warehouseMap.containsKey(vo.getWarehouseId())) {
+                vo.setWarehouse(warehouseMap.get(vo.getWarehouseId()));
+            }
+            if (vo.getNextWarehouseId() != null && warehouseMap.containsKey(vo.getNextWarehouseId())) {
+                vo.setNextWarehouse(warehouseMap.get(vo.getNextWarehouseId()));
+            }
+            if (vo.getActualWarehouseId() != null && actualWarehouseMap.containsKey(vo.getActualWarehouseId())) {
+                WmsActualWarehouseVo actualWarehouse = actualWarehouseMap.get(vo.getActualWarehouseId());
+                vo.setActualWarehouseName(actualWarehouse.getActualWarehouseName());
+            }
+            if (vo.getQrcodeRecordId() != null && qrcodeMap.containsKey(vo.getQrcodeRecordId())) {
+                vo.setQrcodeRecord(qrcodeMap.get(vo.getQrcodeRecordId()));
+            }
+            if ("raw_material".equals(vo.getItemType()) && vo.getItemId() != null && rawMaterialMap.containsKey(vo.getItemId())) {
+                WmsRawMaterialVo rawMaterial = rawMaterialMap.get(vo.getItemId());
+                vo.setRawMaterial(rawMaterial);
+                if (rawMaterial.getBomId() != null && bomItemMap.containsKey(rawMaterial.getBomId())) {
+                    vo.setBomItemList(bomItemMap.get(rawMaterial.getBomId()));
+                }
+            }
+            if ("product".equals(vo.getItemType()) && vo.getItemId() != null && productMap.containsKey(vo.getItemId())) {
+                WmsProductVo product = productMap.get(vo.getItemId());
+                vo.setProduct(product);
+                if (product.getBomId() != null && bomItemMap.containsKey(product.getBomId())) {
+                    vo.setBomItemList(bomItemMap.get(product.getBomId()));
+                }
+            }
+        }
+    }
+
+    /**
+     * 填充关联对象信息（单个对象，保留用于兼容性）
      */
     private void fillRelatedObjects(WmsMaterialCoilVo vo) {
         // 查询所在库区信息
@@ -150,9 +298,9 @@ public class WmsMaterialCoilServiceImpl implements IWmsMaterialCoilService {
         QueryWrapper<WmsMaterialCoil> qw = buildQueryWrapperPlus(bo);
         Page<WmsMaterialCoilVo> result = baseMapper.selectVoPagePlus(pageQuery.build(), qw);
 
-        // 填充每个记录的产品或原材料对象
+        // 从联查结果中构建产品和原材料对象（避免单独查询）
         for (WmsMaterialCoilVo vo : result.getRecords()) {
-            fillItemObject(vo);
+            buildItemObjectFromJoin(vo);
         }
 
         return TableDataInfo.build(result);
@@ -211,16 +359,53 @@ public class WmsMaterialCoilServiceImpl implements IWmsMaterialCoilService {
         QueryWrapper<WmsMaterialCoil> lqw = buildQueryWrapperPlus(bo);
         List<WmsMaterialCoilVo> list = baseMapper.selectVoListWithDynamicJoin(lqw);
 
-        // 填充每个记录的产品或原材料对象
+        // 从联查结果中构建产品和原材料对象（避免单独查询）
         for (WmsMaterialCoilVo vo : list) {
-            fillItemObject(vo);
+            buildItemObjectFromJoin(vo);
         }
 
         return list;
     }
 
     /**
-     * 填充物品对象（产品或原材料）
+     * 从联查结果中构建物品对象（产品或原材料）
+     * 直接从VO的临时字段中获取数据构建对象，避免单独查询数据库
+     */
+    private void buildItemObjectFromJoin(WmsMaterialCoilVo vo) {
+        if (vo.getItemId() == null || vo.getItemType() == null) {
+            return;
+        }
+
+        // 构建原材料对象
+        if ("raw_material".equals(vo.getItemType()) && vo.getRawMaterialId() != null) {
+            WmsRawMaterialVo rawMaterial = new WmsRawMaterialVo();
+            rawMaterial.setRawMaterialId(vo.getRawMaterialId());
+            rawMaterial.setRawMaterialCode(vo.getRawMaterialCode());
+            rawMaterial.setRawMaterialName(vo.getRawMaterialName());
+            rawMaterial.setSpecification(vo.getRawMaterialSpecification());
+            rawMaterial.setSteelGrade(vo.getRawMaterialSteelGrade());
+            rawMaterial.setThickness(vo.getRawMaterialThickness());
+            rawMaterial.setWidth(vo.getRawMaterialWidth());
+            rawMaterial.setBomId(vo.getRawMaterialBomId());
+            vo.setRawMaterial(rawMaterial);
+        }
+
+        // 构建产品对象
+        if ("product".equals(vo.getItemType()) && vo.getProductId() != null) {
+            WmsProductVo product = new WmsProductVo();
+            product.setProductId(vo.getProductId());
+            product.setProductCode(vo.getProductCode());
+            product.setProductName(vo.getProductName());
+            product.setSpecification(vo.getProductSpecification());
+            product.setThickness(vo.getProductThickness());
+            product.setWidth(vo.getProductWidth());
+            product.setBomId(vo.getProductBomId());
+            vo.setProduct(product);
+        }
+    }
+
+    /**
+     * 填充物品对象（产品或原材料）- 保留作为备用方法
      */
     private void fillItemObject(WmsMaterialCoilVo vo) {
         if (vo.getItemId() == null || vo.getItemType() == null) {
@@ -1034,7 +1219,7 @@ public class WmsMaterialCoilServiceImpl implements IWmsMaterialCoilService {
     @Override
     public Map<String, Object> queryTrace(String enterCoilNo, String currentCoilNo) {
         try {
-            // 1. 查询所有相关的二维码记录（包括分卷后的独立二维码）
+            // 优化1: 使用LIKE查询替代查询所有记录，大幅提升性能
             List<WmsGenerateRecordVo> allQrRecords = new ArrayList<>();
 
             // 首先查询主二维码（以入场钢卷号为序列号的）
@@ -1043,14 +1228,21 @@ public class WmsMaterialCoilServiceImpl implements IWmsMaterialCoilService {
             List<WmsGenerateRecordVo> mainQrRecords = generateRecordService.queryList(qrBo);
             allQrRecords.addAll(mainQrRecords);
 
-            // 然后查询所有以该入场钢卷号开头的二维码（分卷后的二维码）
-            WmsGenerateRecordBo splitQrBo = new WmsGenerateRecordBo();
-            List<WmsGenerateRecordVo> allRecords = generateRecordService.queryList(splitQrBo);
-            for (WmsGenerateRecordVo record : allRecords) {
-                if (record.getSerialNumber() != null &&
-                    record.getSerialNumber().startsWith(enterCoilNo + "-") &&
-                    !allQrRecords.contains(record)) {
+            // 优化：使用LIKE查询所有以该入场钢卷号开头的二维码（分卷后的二维码）
+            // 而不是查询所有记录然后在内存中过滤
+            LambdaQueryWrapper<com.klp.domain.WmsGenerateRecord> splitWrapper = Wrappers.lambdaQuery();
+            splitWrapper.like(com.klp.domain.WmsGenerateRecord::getSerialNumber, enterCoilNo + "-");
+            List<WmsGenerateRecordVo> splitRecords = generateRecordMapper.selectVoList(splitWrapper);
+            
+            // 去重：使用recordId作为唯一标识
+            Set<Long> existingRecordIds = allQrRecords.stream()
+                .map(WmsGenerateRecordVo::getRecordId)
+                .collect(Collectors.toSet());
+            
+            for (WmsGenerateRecordVo record : splitRecords) {
+                if (record.getRecordId() != null && !existingRecordIds.contains(record.getRecordId())) {
                     allQrRecords.add(record);
+                    existingRecordIds.add(record.getRecordId());
                 }
             }
 
@@ -1058,14 +1250,16 @@ public class WmsMaterialCoilServiceImpl implements IWmsMaterialCoilService {
                 throw new RuntimeException("未找到对应的二维码记录");
             }
 
+            // 优化2: ObjectMapper在循环外创建，避免重复创建
+            ObjectMapper objectMapper = new ObjectMapper();
+            
             // 2. 合并所有二维码的steps信息，去重并重新编号
             Map<String, Map<String, Object>> uniqueSteps = new HashMap<>(); // 用于去重
             Set<String> allCoilNos = new HashSet<>();
 
             for (WmsGenerateRecordVo qrRecord : allQrRecords) {
-                ObjectMapper objectMapper = new ObjectMapper();
                 @SuppressWarnings("unchecked")
-                Map<String, Object> contentMap = objectMapper.readValue(qrRecord.getContent(), Map.class);
+                Map<String, Object> contentMap = (Map<String, Object>) objectMapper.readValue(qrRecord.getContent(), Map.class);
 
                 @SuppressWarnings("unchecked")
                 List<Map<String, Object>> steps = (List<Map<String, Object>>) contentMap.get("steps");
@@ -1125,32 +1319,41 @@ public class WmsMaterialCoilServiceImpl implements IWmsMaterialCoilService {
                     .collect(Collectors.toSet());
             }
 
+            // 优化3: 使用IN查询替代多个OR条件，提升查询性能
             // 4. 根据提取的钢卷号反向查询数据库
             List<WmsMaterialCoilVo> result = new ArrayList<>();
             if (!filteredCoilNos.isEmpty()) {
                 LambdaQueryWrapper<WmsMaterialCoil> lqw = Wrappers.lambdaQuery();
                 lqw.eq(WmsMaterialCoil::getEnterCoilNo, enterCoilNo);
 
-                // 查询包含提取出的钢卷号的记录
-                final Set<String> finalCoilNos = filteredCoilNos;
-                lqw.and(wrapper -> {
-                    int count = 0;
-                    for (String coilNo : finalCoilNos) {
-                        if (count == 0) {
-                            wrapper.eq(WmsMaterialCoil::getCurrentCoilNo, coilNo);
-                        } else {
-                            wrapper.or().eq(WmsMaterialCoil::getCurrentCoilNo, coilNo);
-                        }
-                        count++;
+                // 优化：使用IN查询替代多个OR条件（当钢卷号数量较少时）
+                // 如果数量太多（>1000），分批查询避免SQL过长
+                List<String> coilNoList = new ArrayList<>(filteredCoilNos);
+                if (coilNoList.size() <= 1000) {
+                    lqw.in(WmsMaterialCoil::getCurrentCoilNo, coilNoList);
+                } else {
+                    // 分批查询
+                    int batchSize = 1000;
+                    for (int i = 0; i < coilNoList.size(); i += batchSize) {
+                        int end = Math.min(i + batchSize, coilNoList.size());
+                        List<String> batch = coilNoList.subList(i, end);
+                        LambdaQueryWrapper<WmsMaterialCoil> batchLqw = Wrappers.lambdaQuery();
+                        batchLqw.eq(WmsMaterialCoil::getEnterCoilNo, enterCoilNo);
+                        batchLqw.in(WmsMaterialCoil::getCurrentCoilNo, batch);
+                        batchLqw.orderByAsc(WmsMaterialCoil::getCreateTime);
+                        List<WmsMaterialCoilVo> batchResult = baseMapper.selectVoList(batchLqw);
+                        result.addAll(batchResult);
                     }
-                });
+                }
 
-                lqw.orderByAsc(WmsMaterialCoil::getCreateTime);
-                result = baseMapper.selectVoList(lqw);
+                if (coilNoList.size() <= 1000) {
+                    lqw.orderByAsc(WmsMaterialCoil::getCreateTime);
+                    result = baseMapper.selectVoList(lqw);
+                }
 
-                // 填充每个记录的关联对象信息（如库区）
-                for (WmsMaterialCoilVo vo : result) {
-                    fillRelatedObjects(vo);
+                // 优化4: 批量填充关联对象，避免N+1查询
+                if (!result.isEmpty()) {
+                    fillRelatedObjectsBatch(result);
                 }
             }
 
@@ -1161,9 +1364,9 @@ public class WmsMaterialCoilServiceImpl implements IWmsMaterialCoilService {
                 lqw.orderByAsc(WmsMaterialCoil::getCreateTime);
                 result = baseMapper.selectVoList(lqw);
 
-                // 填充每个记录的关联对象信息
-                for (WmsMaterialCoilVo vo : result) {
-                    fillRelatedObjects(vo);
+                // 优化：批量填充关联对象
+                if (!result.isEmpty()) {
+                    fillRelatedObjectsBatch(result);
                 }
             }
 
diff --git a/klp-wms/src/main/java/com/klp/service/impl/WmsProductServiceImpl.java b/klp-wms/src/main/java/com/klp/service/impl/WmsProductServiceImpl.java
index cb246a01..d781f404 100644
--- a/klp-wms/src/main/java/com/klp/service/impl/WmsProductServiceImpl.java
+++ b/klp-wms/src/main/java/com/klp/service/impl/WmsProductServiceImpl.java
@@ -92,7 +92,24 @@ public class WmsProductServiceImpl implements IWmsProductService {
         Map<String, Object> params = bo.getParams();
         LambdaQueryWrapper<WmsProduct> lqw = Wrappers.lambdaQuery();
         lqw.eq(StringUtils.isNotBlank(bo.getProductCode()), WmsProduct::getProductCode, bo.getProductCode());
-        lqw.like(StringUtils.isNotBlank(bo.getProductName()), WmsProduct::getProductName, bo.getProductName());
+        
+        // 如果同时传入了名称和规格，且值相同（搜索关键词），使用 OR 条件
+        boolean hasName = StringUtils.isNotBlank(bo.getProductName());
+        boolean hasSpec = StringUtils.isNotBlank(bo.getSpecification());
+        if (hasName && hasSpec && bo.getProductName().equals(bo.getSpecification())) {
+            // 搜索关键词：匹配名称或规格
+            String searchKey = bo.getProductName();
+            lqw.and(wrapper -> wrapper
+                .like(WmsProduct::getProductName, searchKey)
+                .or()
+                .like(WmsProduct::getSpecification, searchKey)
+            );
+        } else {
+            // 分别处理名称和规格
+            lqw.like(hasName, WmsProduct::getProductName, bo.getProductName());
+            lqw.like(hasSpec, WmsProduct::getSpecification, bo.getSpecification());
+        }
+        
         lqw.eq(StringUtils.isNotBlank(bo.getOwner()), WmsProduct::getOwner, bo.getOwner());
         lqw.eq(bo.getBaseMaterialId() != null, WmsProduct::getBaseMaterialId, bo.getBaseMaterialId());
         lqw.eq(bo.getSurfaceTreatmentId() != null, WmsProduct::getSurfaceTreatmentId, bo.getSurfaceTreatmentId());
@@ -104,8 +121,6 @@ public class WmsProductServiceImpl implements IWmsProductService {
         lqw.eq(bo.getIsEnabled() != null, WmsProduct::getIsEnabled, bo.getIsEnabled());
         lqw.eq(bo.getBomId() != null, WmsProduct::getBomId, bo.getBomId());
         lqw.eq(StringUtils.isNotBlank(bo.getType()), WmsProduct::getType, bo.getType());
-        //规格模糊匹配
-        lqw.like(StringUtils.isNotBlank(bo.getSpecification()), WmsProduct::getSpecification, bo.getSpecification());
         lqw.eq(StringUtils.isNotBlank(bo.getMaterial()), WmsProduct::getMaterial, bo.getMaterial());
         lqw.eq(StringUtils.isNotBlank(bo.getSurfaceTreatmentDesc()), WmsProduct::getSurfaceTreatmentDesc, bo.getSurfaceTreatmentDesc());
         lqw.eq(StringUtils.isNotBlank(bo.getManufacturer()), WmsProduct::getManufacturer, bo.getManufacturer());
diff --git a/klp-wms/src/main/java/com/klp/service/impl/WmsRawMaterialServiceImpl.java b/klp-wms/src/main/java/com/klp/service/impl/WmsRawMaterialServiceImpl.java
index 3f35ae9f..c56e80a3 100644
--- a/klp-wms/src/main/java/com/klp/service/impl/WmsRawMaterialServiceImpl.java
+++ b/klp-wms/src/main/java/com/klp/service/impl/WmsRawMaterialServiceImpl.java
@@ -184,7 +184,24 @@ public class WmsRawMaterialServiceImpl implements IWmsRawMaterialService {
         Map<String, Object> params = bo.getParams();
         LambdaQueryWrapper<WmsRawMaterial> lqw = Wrappers.lambdaQuery();
         lqw.eq(StringUtils.isNotBlank(bo.getRawMaterialCode()), WmsRawMaterial::getRawMaterialCode, bo.getRawMaterialCode());
-        lqw.like(StringUtils.isNotBlank(bo.getRawMaterialName()), WmsRawMaterial::getRawMaterialName, bo.getRawMaterialName());
+        
+        // 如果同时传入了名称和规格，且值相同（搜索关键词），使用 OR 条件
+        boolean hasName = StringUtils.isNotBlank(bo.getRawMaterialName());
+        boolean hasSpec = StringUtils.isNotBlank(bo.getSpecification());
+        if (hasName && hasSpec && bo.getRawMaterialName().equals(bo.getSpecification())) {
+            // 搜索关键词：匹配名称或规格
+            String searchKey = bo.getRawMaterialName();
+            lqw.and(wrapper -> wrapper
+                .like(WmsRawMaterial::getRawMaterialName, searchKey)
+                .or()
+                .like(WmsRawMaterial::getSpecification, searchKey)
+            );
+        } else {
+            // 分别处理名称和规格
+            lqw.like(hasName, WmsRawMaterial::getRawMaterialName, bo.getRawMaterialName());
+            lqw.like(hasSpec, WmsRawMaterial::getSpecification, bo.getSpecification());
+        }
+        
         lqw.eq(StringUtils.isNotBlank(bo.getSteelGrade()), WmsRawMaterial::getSteelGrade, bo.getSteelGrade());
         lqw.eq(StringUtils.isNotBlank(bo.getTargetColdGrade()), WmsRawMaterial::getTargetColdGrade, bo.getTargetColdGrade());
         lqw.eq(bo.getBaseMaterialId() != null, WmsRawMaterial::getBaseMaterialId, bo.getBaseMaterialId());
@@ -206,8 +223,6 @@ public class WmsRawMaterialServiceImpl implements IWmsRawMaterialService {
         lqw.eq(StringUtils.isNotBlank(bo.getInspectionResult()), WmsRawMaterial::getInspectionResult, bo.getInspectionResult());
         lqw.eq(bo.getIsEnabled() != null, WmsRawMaterial::getIsEnabled, bo.getIsEnabled());
         lqw.eq(bo.getBomId() != null, WmsRawMaterial::getBomId, bo.getBomId());
-        //规格模糊匹配
-        lqw.like(StringUtils.isNotBlank(bo.getSpecification()), WmsRawMaterial::getSpecification, bo.getSpecification());
         lqw.eq(StringUtils.isNotBlank(bo.getMaterial()), WmsRawMaterial::getMaterial, bo.getMaterial());
         lqw.eq(StringUtils.isNotBlank(bo.getSurfaceTreatmentDesc()), WmsRawMaterial::getSurfaceTreatmentDesc, bo.getSurfaceTreatmentDesc());
         lqw.eq(StringUtils.isNotBlank(bo.getManufacturer()), WmsRawMaterial::getManufacturer, bo.getManufacturer());
diff --git a/klp-wms/src/main/resources/mapper/klp/WmsMaterialCoilMapper.xml b/klp-wms/src/main/resources/mapper/klp/WmsMaterialCoilMapper.xml
index 4d4f5f62..40f7d0f1 100644
--- a/klp-wms/src/main/resources/mapper/klp/WmsMaterialCoilMapper.xml
+++ b/klp-wms/src/main/resources/mapper/klp/WmsMaterialCoilMapper.xml
@@ -94,11 +94,41 @@ PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
             mc.packaging_requirement,
             mc.packing_status,
             w.warehouse_name AS warehouseName,
-            aw.actual_warehouse_name AS actualWarehouseName
+            aw.actual_warehouse_name AS actualWarehouseName,
+            -- 原材料字段
+            rm.raw_material_id AS rawMaterialId,
+            rm.raw_material_code AS rawMaterialCode,
+            rm.raw_material_name AS rawMaterialName,
+            rm.specification AS rawMaterialSpecification,
+            rm.steel_grade AS rawMaterialSteelGrade,
+            rm.thickness AS rawMaterialThickness,
+            rm.width AS rawMaterialWidth,
+            rm.bom_id AS rawMaterialBomId,
+            -- 产品字段
+            p.product_id AS productId,
+            p.product_code AS productCode,
+            p.product_name AS productName,
+            p.specification AS productSpecification,
+            p.thickness AS productThickness,
+            p.width AS productWidth,
+            p.bom_id AS productBomId,
+            -- 物品名称和编号（用于兼容）
+            CASE
+                WHEN mc.item_type = 'raw_material' THEN rm.raw_material_name
+                WHEN mc.item_type = 'product' THEN p.product_name
+                ELSE NULL
+            END as itemName,
+            CASE
+                WHEN mc.item_type = 'raw_material' THEN rm.raw_material_code
+                WHEN mc.item_type = 'product' THEN p.product_code
+                ELSE NULL
+            END as itemCode
         FROM wms_material_coil mc
-                 LEFT JOIN wms_warehouse w ON mc.warehouse_id = w.warehouse_id
-                 LEFT JOIN wms_actual_warehouse aw ON mc.actual_warehouse_id = aw.actual_warehouse_id
-            ${ew.customSqlSegment}
+        LEFT JOIN wms_warehouse w ON mc.warehouse_id = w.warehouse_id
+        LEFT JOIN wms_actual_warehouse aw ON mc.actual_warehouse_id = aw.actual_warehouse_id
+        LEFT JOIN wms_raw_material rm ON mc.item_type = 'raw_material' AND mc.item_id = rm.raw_material_id
+        LEFT JOIN wms_product p ON mc.item_type = 'product' AND mc.item_id = p.product_id
+        ${ew.customSqlSegment}
     </select>
     <!-- 查询不同类型的钢卷在不同库区的分布情况 -->
     <select id="getDistributionByItemType" resultType="java.util.Map">
@@ -141,7 +171,25 @@ PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
     <select id="selectVoListWithDynamicJoin" resultType="com.klp.domain.vo.WmsMaterialCoilVo">
         SELECT mc.*,
                w.warehouse_name AS warehouseName,
-               aw.warehouse_name AS actualWarehouseName,
+               aw.actual_warehouse_name AS actualWarehouseName,
+               -- 原材料字段
+               rm.raw_material_id AS rawMaterialId,
+               rm.raw_material_code AS rawMaterialCode,
+               rm.raw_material_name AS rawMaterialName,
+               rm.specification AS rawMaterialSpecification,
+               rm.steel_grade AS rawMaterialSteelGrade,
+               rm.thickness AS rawMaterialThickness,
+               rm.width AS rawMaterialWidth,
+               rm.bom_id AS rawMaterialBomId,
+               -- 产品字段
+               p.product_id AS productId,
+               p.product_code AS productCode,
+               p.product_name AS productName,
+               p.specification AS productSpecification,
+               p.thickness AS productThickness,
+               p.width AS productWidth,
+               p.bom_id AS productBomId,
+               -- 物品名称和编号（用于兼容）
                CASE
                    WHEN mc.item_type = 'raw_material' THEN rm.raw_material_name
                    WHEN mc.item_type = 'product' THEN p.product_name
@@ -153,11 +201,11 @@ PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
                    ELSE NULL
                    END as itemCode
         FROM wms_material_coil mc
-                 LEFT JOIN wms_raw_material rm ON mc.item_type = 'raw_material' AND mc.item_id = rm.raw_material_id
-                 LEFT JOIN wms_product p ON mc.item_type = 'product' AND mc.item_id = p.product_id
-            LEFT JOIN wms_warehouse w ON mc.warehouse_id = w.warehouse_id
-            LEFT JOIN wms_actual_warehouse aw ON mc.actual_warehouse_id = aw.actual_warehouse_id
-            ${ew.customSqlSegment}
+        LEFT JOIN wms_raw_material rm ON mc.item_type = 'raw_material' AND mc.item_id = rm.raw_material_id
+        LEFT JOIN wms_product p ON mc.item_type = 'product' AND mc.item_id = p.product_id
+        LEFT JOIN wms_warehouse w ON mc.warehouse_id = w.warehouse_id
+        LEFT JOIN wms_actual_warehouse aw ON mc.actual_warehouse_id = aw.actual_warehouse_id
+        ${ew.customSqlSegment}
     </select>
     <select id="getDistributionByActualWarehouse" resultType="java.util.Map">
         SELECT