wlzboy
2026-01-24 2f09efc660bf2cc94cbc5291ad25ca06fc9bdadf
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
package com.ruoyi.system.service.impl;
 
import com.ruoyi.common.utils.HospitalTokenizerUtil;
import com.ruoyi.system.domain.TbHospData;
import com.ruoyi.system.mapper.TbHospDataMapper;
import com.ruoyi.system.service.ITbHospDataService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
 
import java.util.List;
 
/**
 * 医院数据Service业务层处理
 * 
 * @author ruoyi
 */
@Service
public class TbHospDataServiceImpl implements ITbHospDataService
{
    private static final Logger logger = LoggerFactory.getLogger(TbHospDataServiceImpl.class);
    
    @Autowired
    private TbHospDataMapper tbHospDataMapper;
 
    /**
     * 查询医院数据列表
     * 
     * @param tbHospData 医院数据
     * @return 医院数据
     */
    @Override
    public List<TbHospData> selectTbHospDataList(TbHospData tbHospData)
    {
        return tbHospDataMapper.selectTbHospDataList(tbHospData);
    }
 
    /**
     * 根据医院ID查询医院数据
     * 
     * @param hospId 医院ID
     * @return 医院数据
     */
    @Override
    public TbHospData selectTbHospDataById(Long hospId)
    {
        return tbHospDataMapper.selectTbHospDataById(hospId);
    }
 
    /**
     * 根据旧系统医院ID查询医院数据
     * 
     * @param legacyHospId 旧系统医院ID
     * @return 医院数据
     */
    @Override
    public TbHospData selectTbHospDataByLegacyId(Integer legacyHospId)
    {
        return tbHospDataMapper.selectTbHospDataByLegacyId(legacyHospId);
    }
 
    /**
     * 新增医院数据
     * 
     * @param tbHospData 医院数据
     * @return 结果
     */
    @Override
    public int insertTbHospData(TbHospData tbHospData)
    {
        return tbHospDataMapper.insertTbHospData(tbHospData);
    }
 
    /**
     * 修改医院数据
     * 
     * @param tbHospData 医院数据
     * @return 结果
     */
    @Override
    public int updateTbHospData(TbHospData tbHospData)
    {
        return tbHospDataMapper.updateTbHospData(tbHospData);
    }
 
    /**
     * 批量删除医院数据
     * 
     * @param hospIds 需要删除的医院数据ID
     * @return 结果
     */
    @Override
    public int deleteTbHospDataByIds(Long[] hospIds)
    {
        return tbHospDataMapper.deleteTbHospDataByIds(hospIds);
    }
 
    /**
     * 删除医院数据信息
     * 
     * @param hospId 医院数据ID
     * @return 结果
     */
    @Override
    public int deleteTbHospDataById(Long hospId)
    {
        return tbHospDataMapper.deleteTbHospDataById(hospId);
    }
 
    /**
     * 批量生成并更新所有医院的分词
     * 供医院同步时调用
     * 
     * @return 更新的医院数量
     */
    @Override
    public int generateAllHospitalKeywords()
    {
        logger.info("开始批量生成医院分词...");
        
        // 查询所有正常状态的医院
        TbHospData query = new TbHospData();
        query.setStatus("0");
        List<TbHospData> hospitalList = tbHospDataMapper.selectTbHospDataList(query);
        
        logger.info("查询到 {} 个医院需要生成分词", hospitalList.size());
        
        int updateCount = 0;
        for (TbHospData hospital : hospitalList) {
            try {
                // 生成分词
                String keywords = generateKeywordsForHospital(hospital);
                hospital.setHospKeywords(keywords);
                
                // 更新数据库
                int result = tbHospDataMapper.updateTbHospData(hospital);
                if (result > 0) {
                    updateCount++;
                }
            } catch (Exception e) {
                logger.error("生成医院分词失败: hospId={}, hospName={}", 
                    hospital.getHospId(), hospital.getHospName(), e);
            }
        }
        
        logger.info("医院分词生成完成,更新了 {} 个医院", updateCount);
        return updateCount;
    }
 
    /**
     * 为单个医院生成分词
     * 
     * @param tbHospData 医院数据
     * @return 生成的分词
     */
    @Override
    public String generateKeywordsForHospital(TbHospData tbHospData)
    {
        return HospitalTokenizerUtil.tokenize(
            tbHospData.getHospName(),
            tbHospData.getHospShort(),
            tbHospData.getHopsProvince(),
            tbHospData.getHopsCity(),
            tbHospData.getHopsArea(),
            tbHospData.getHospAddress()
        );
    }
}