多对多关系通用操作组件,省时省力的神器

项目上有很多对多操作的场景，建对象，建mapper接口，设置查询条件，查询多对多数据等都是一项极为耗时耗力的工作。因此，搓了这款集建表-保存-查询-设置条件等操作于一体的组件。原理简单，利用$标签动态作些操作。如下xml配置。

<mapper namespace="com.xxx.future.support.dependence.mapper.ManyRelationMapper">

	<!--查找记录-->
    <select id="findRelation" resultType="com.xxx.future.support.dependence.manyrelation.Relation"
            parameterType="com.xxx.future.support.dependence.manyrelation.RelationFind">
        select ${targetKey} as targetId,${sourceKey} as sourceId from ${tableName} where 1=1
        <if test="sourceIds!=null and sourceIds.size>0">
           and ${sourceKey} in
            <foreach collection="sourceIds" separator="," item="sourceId" open="(" close=")">
                #{sourceId}
            </foreach>
        </if>
        <if test="targetIds!=null and targetIds.size>0">
          and  ${targetKey} in
            <foreach collection="targetIds" separator="," item="targetId" open="(" close=")">
                #{targetId}
            </foreach>
        </if>
    </select>

	  <!--删除记录-->
    <delete id="clearRelation" parameterType="com.xxx.future.support.dependence.manyrelation.RelationDelete">
        delete FROM ${tableName}
        <where>
            <if test="sourceIds!=null and sourceIds.size>0">
                AND ${sourceKey} IN
                <foreach collection="sourceIds" separator="," open="(" close=")" item="sId">
                    #{sId}
                </foreach>
            </if>
            <if test="targetIds!=null and targetIds.size>0">
                AND ${targetKey} IN
                <foreach collection="targetIds" separator="," open="(" close=")" item="tId">
                    #{tId}
                </foreach>
            </if>
            <if test="targetApply!=null">
                AND ${targetApply}
            </if>
            <if test="sourceApply!=null">
                AND ${sourceApply}
            </if>
        </where>
    </delete>
   
    <!--mysql批量插入-->
    <insert id="saveRelation" databaseId="mysql"
            parameterType="com.xxx.future.support.dependence.manyrelation.RelationSave">
        INSERT INTO ${tableName}
        (
        ${sourceKey},
        ${targetKey}
        )
        VALUES
        <foreach collection="relations" item="item" separator=",">
            (
            #{item.sourceId},
            #{item.targetId}
            )
        </foreach>
    </insert>
    
   <!--oracle批量插入-->
    <insert id="saveRelation" databaseId="oracle"
            parameterType="com.xxx.future.support.dependence.manyrelation.RelationSave">
        INSERT ALL
        <foreach collection="relations" item="item" separator=" ">
            INTO ${tableName}
            (
            ${sourceKey},
            ${targetKey}
            )
            VALUES
            (
            #{item.sourceId},
            #{item.targetId}
            )
        </foreach>
        SELECT 1 FROM dual
    </insert>

	<!--检查表是否存在-->
    <select id="testExistsTable" resultType="int">
        select count(*) from ${tableName}
    </select>

	<!--mysql库建表-->
    <update id="createRelationTable" databaseId="mysql"
            parameterType="com.xxx.future.support.dependence.manyrelation.RelationTable">
        CREATE TABLE ${tableName} (
            ${sourceKey} varchar(60),
            ${targetKey} varchar(60),
            CONSTRAINT pk_${tableName} PRIMARY KEY(${sourceKey},${targetKey})
        )
    </update>
	<!--oracle库建表-->
    <update id="createRelationTable" databaseId="oracle"
            parameterType="com.xxx.future.support.dependence.domain.entity.RelationTable">
        CREATE TABLE ${tableName} (
            ${sourceKey} varchar2(60),
            ${targetKey} varchar2(60),
            CONSTRAINT pk_${tableName} PRIMARY KEY(${sourceKey},${targetKey})
        )
    </update>
</mapper>

工具类：工具ZYManyHelper怎么封装的就不细看了。太多了。都是一个拼参数，都是调用xml sql里面的查询，删除，保存，建表操作。看了上面xml配置就知道了。

public interface RelationBee {
    // tableName.columnName
    String sourceTable();

    // tableName.columnName
    String targetTable();

    default String sourceTableName() {
        String sourceTable = sourceTable();
        String[] split = sourceTable.split("\\.");
        return split[0];
    }

    default String sourceColumnName() {
        String sourceTable = sourceTable();
        String[] split = sourceTable.split("\\.");
        return split[1];
    }


    default String targetColumnName() {
        String targetTable = targetTable();
        String[] split = targetTable.split("\\.");
        return split[1];
    }

    default String targetTableName() {
        String targetTable = targetTable();
        String[] split = targetTable.split("\\.");
        return split[0];
    }

    default void joinOne(String sourceId, String targetId) {
        ZYManyHelper.joinOne(this, sourceId, targetId);
    }

    default void join(String sourceId, List<String> targetIds) {
        ZYManyHelper.joinBySourceId(this, sourceId, targetIds);
    }

    default void joinByTargetId(String targetId, List<String> sourceIds) {
        ZYManyHelper.joinByTargetId(this, targetId, sourceIds);
    }


    default void onlyJoin(List<String> sourceIds, List<String> targetIds) {
        ZYManyHelper.join(this, sourceIds, targetIds);
    }

    default void onlyJoin(String sourceId, List<String> targetIds) {
        if (ZYStrUtils.isNotNull(sourceId)) {
            ZYManyHelper.join(this, Collections.singletonList(sourceId), targetIds);
        }
    }

    default void onlyJoin(List<String> sourceIds, String targetId) {
        if (ZYStrUtils.isNotNull(targetId)) {
            ZYManyHelper.join(this, sourceIds, Collections.singletonList(targetId));
        }
    }

    default void clearByTargetIdAndSourceApply(String targetId, String sourceApply) {
        ZYManyHelper.clearByTargetIdsAndSourceApply(this, Collections.singletonList(targetId), sourceApply);
    }

    default void clearBySourceIdAndTargetApply(String sourceIds, String targetApply) {
        ZYManyHelper.clearBySourceIdsAndTargetApply(this, Collections.singletonList(sourceIds), targetApply);
    }

    default void clearByTargetIdsAndSourceApply(List<String> targetIds, String sourceApply) {
        ZYManyHelper.clearByTargetIdsAndSourceApply(this, targetIds, sourceApply);
    }

    default void clearBySourceIdsAndTargetApply(List<String> sourceIds, String targetApply) {
        ZYManyHelper.clearBySourceIdsAndTargetApply(this, sourceIds, targetApply);
    }

    default void clearBySourceId(String sourceId) {
        ZYManyHelper.clearBySourceId(this, sourceId);
    }

    default void clearBySourceIds(List<String> sourceIds) {
        ZYManyHelper.clearBySourceIds(this, sourceIds);
    }

    default void clearByTargetId(String targetId) {
        ZYManyHelper.clearByTargetId(this, targetId);
    }

    default void clearByTargetIds(List<String> targetIds) {
        ZYManyHelper.clearByTargetIds(this, targetIds);
    }

    default void clearBySourceIdAndTargetIds(String sourceId, List<String> targetIds) {
        ZYManyHelper.clearBySourceIdAndTargetIds(this, sourceId, targetIds);
    }

    default void clearByTargetIdAndSourceIds(String targetId, List<String> sourceIds) {
        ZYManyHelper.clearByTargetIdAndSourceIds(this, targetId, sourceIds);
    }

    default Map<String, List<String>> findSourceTargetsMap(List<String> sourceIds) {
        return ZYManyHelper.findSourceTargetsMap(this, sourceIds);
    }

    default Map<String, List<String>> findTargetSourcesMap(List<String> targetIds) {
        return ZYManyHelper.findTargetSourcesMap(this, targetIds);
    }


    default Map<String, List<String>> findSourceTargetsMap() {
        return ZYManyHelper.findSourceTargetsMap(this);
    }

    default Map<String, List<String>> findTargetSourcesMap() {
        return ZYManyHelper.findTargetSourcesMap(this);
    }

    default List<String> findTargetIds(String sourceId) {
        return ZYManyHelper.findTargetIds(this, sourceId);
    }

    default List<String> findTargetIds(List<String> sourceIds) {
        return ZYManyHelper.findTargetIds(this, sourceIds);
    }

    default List<String> findSourceIds(String targetId) {
        return ZYManyHelper.findSourceIds(this, targetId);
    }

    default List<String> findSourceIds(List<String> targetIds) {
        return ZYManyHelper.findSourceIds(this, targetIds);
    }

    // select role where id in (select role_id from relation_role_user where user_id='1')
    default void setWrapper(LambdaQueryWrapper<?> wrapper, String targetId) {
        ZYManyHelper.applyRelation(this, wrapper, targetId);
    }

    // select role where id in (select role_id from relation_role_user where user_id='1')
    default void setWrapper(LambdaQueryWrapper<?> wrapper, String sourceColumn, String targetId) {
        ZYManyHelper.applyRelation(this, wrapper, sourceColumn, targetId, false);
    }

    // select role where id in (select role_id from relation_role_user where user_id='1')
    default void setWrapper(QueryWrapper<?> wrapper, String targetId) {
        ZYManyHelper.applyRelation(this, wrapper, targetId);
    }

    // select role where id in (select role_id from relation_role_user where user_id in ('1'))
    default void setInLambdaWrapper(LambdaQueryWrapper<?> wrapper, List<String> targetIds) {
        ZYManyHelper.applyInRelation(this, wrapper, targetIds);
    }

    // select role where id in (select role_id from relation_role_user where user_id in ('1'))
    default void setInLambdaWrapper(LambdaQueryWrapper<?> wrapper, String sourceColumn, List<String> targetIds) {
        ZYManyHelper.applyInRelation(this, wrapper, sourceColumn, targetIds, false);
    }

    // select role where id in (select role_id from relation_role_user where user_id in ('1'))
    default void setInWrapper(QueryWrapper<?> wrapper, List<String> targetIds) {
        ZYManyHelper.applyInRelation(this, wrapper, targetIds);
    }

    // select role where id in (select role_id from relation_role_user where user_id in ('1'))
    default void setInWrapper(QueryWrapper<?> wrapper, String sourceColumn, List<String> targetIds) {
        ZYManyHelper.applyInRelation(this, wrapper, sourceColumn, targetIds, false);
    }


    // select role where id in (select role_id from relation_role_user where user_id='1')
    default void setWrapper(QueryWrapper<?> wrapper, String sourceColumn, String targetId) {
        ZYManyHelper.applyRelation(this, wrapper, sourceColumn, targetId, false);
    }

    // select role where id not in (select role_id from relation_role_user where user_id='1')
    default void setExcludeWrapper(LambdaQueryWrapper<?> wrapper, String targetId) {
        ZYManyHelper.applyExcludeRelation(this, wrapper, targetId);
    }

    // select role where id not in (select role_id from relation_role_user where user_id='1')
    default void setExcludeWrapper(LambdaQueryWrapper<?> wrapper, String sourceColumn, String targetId) {
        ZYManyHelper.applyRelation(this, wrapper, sourceColumn, targetId, true);
    }

    // select role where id not in (select role_id from relation_role_user where user_id='1')
    default void setExcludeWrapper(QueryWrapper<?> wrapper, String targetId) {
        ZYManyHelper.applyExcludeRelation(this, wrapper, targetId);
    }

    // select role where id not in (select role_id from relation_role_user where user_id='1')
    default void setExcludeWrapper(QueryWrapper<?> wrapper, String sourceColumn, String targetId) {
        ZYManyHelper.applyRelation(this, wrapper, sourceColumn, targetId, true);
    }

    // select user where id not in (select user_id from relation_role_user where role_id='1')
    default void setExcludeTargetWrapper(QueryWrapper<?> wrapper, String sourceId) {
        ZYManyHelper.applyExcludeTargetRelation(this, wrapper, sourceId);
    }

    // select user where id not in (select user_id from relation_role_user where role_id='1')
    default void setExcludeTargetWrapper(LambdaQueryWrapper<?> wrapper, String sourceId) {
        ZYManyHelper.applyExcludeTargetRelation(this, wrapper, sourceId);
    }

    // select user where id  in (select user_id from relation_role_user where role_id='1')
    default void setTargetWrapper(QueryWrapper<?> wrapper, String sourceId) {
        ZYManyHelper.applyTargetRelation(this, wrapper, sourceId);
    }

    // select user where id  in (select user_id from relation_role_user where role_id='1')
    default void setTargetWrapper(LambdaQueryWrapper<?> wrapper, String sourceId) {
        ZYManyHelper.applyTargetRelation(this, wrapper, sourceId);
    }
}

调用枚举定义：

   public enum SecurityRelation implements RelationBee {
    // 角色快捷菜单关系
    RELATION_ROLE_QUICK_MENU("role.role_id", "quick_menu.quick_menu_id"),
    // 角色用户关系
    RELATION_ROLE_USER("role.role_id", "user.user_id"),
    // 角色APP菜单关系
    RELATION_ROLE_APP_MENU("role.role_id", "app_menu.app_menu_id"),
    // 角色菜单关系
    RELATION_ROLE_MENU("role.role_id", "menu.menu_id");

    private String sourceTable;

    private String targetTable;


    SecurityRelation(String sourceTable, String targetTable) {
        this.sourceTable = sourceTable;
        this.targetTable = targetTable;
    }

    @Override
    public String sourceTable() {
        return sourceTable;
    }

    @Override
    public String targetTable() {
        return targetTable;
    }
}

在数据库中的数据效果如下图：
在这里插入图片描述

在这里插入图片描述

代码中的调用还是蛮舒服的，基本一条代码搞定，项目中，使用该方法节省了大量的体力劳动和时间，代码也较清爽干净，取得了不错的效果。如下图：

   // 查找登用户有哪些角色id
  List<String> roleIds = SecurityRelation.RELATION_ROLE_USER.findSourceIds(loginUserId);
  // 查找登录用户s有哪些角色ids
  List<String> roleIds = SecurityRelation.RELATION_ROLE_USER.findSourceIds(userIds);
  // 查找登录用户s有哪些角色对应关系
  Map<String, List<String>> userRoleIds = SecurityRelation.RELATION_ROLE_USER.findTargetSourcesMap(userIds);
  // 查找角色有哪些用户
   List<String> userIds = SecurityRelation.RELATION_ROLE_USER.findTargetIds(role.getId());
   // 清理角色用户
   SecurityRelation.RELATION_ROLE_USER.clearByTargetIdAndSourceIds(userId, roleIds);
   //关连角色用户
   SecurityRelation.RELATION_ROLE_USER.onlyJoin(roleIds, userId);
   // 设置查询条件
   SecurityRelation.RELATION_ROLE_USER.setTargetWrapper(wrapper, role.getId());
   // 根据角色删除
   SecurityRelation.RELATION_ROLE_USER.clearBySourceIds(roleIds);
   // 根据用户删除
   SecurityRelation.RELATION_ROLE_USER.clearByTargetId(userId);
   // 全量关连
   SecurityRelation.RELATION_ROLE_USER.join(roleId, userIds);

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mfbz.cn/a/258603.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

25.BFD双向转发检查

25.BFD双向转发检查

BFD双向转发检查 链路故障检测工具&#xff0c;结合三层协议使故障检测更加快速 例如两台路由器之间加了一台二层设备 在修改优先级后&#xff0c;默认选择了下面那条优先级高的路由&#xff0c;R1 ping R2的时候是正常能ping通的 但是&#xff0c;当下面的路由出现故障后&a…
阅读更多...
基于SpringBoot实现的社区人员管理系统

基于SpringBoot实现的社区人员管理系统

一、系统架构 前端&#xff1a;html | js | css | layui 后端&#xff1a;springboot | mybaits-plus | shiro 环境&#xff1a;jdk1.8 | mysql8 | maven 二、代码及数据库 三、功能介绍 01. 登录 02. 首页 03. 常规管理-住户模块-住户管理 04. 常规管理-住户模块-高危…
阅读更多...
DevEco Studio Preview失败

DevEco Studio Preview失败

安装DevEco Studio新建第一个项目后&#xff0c;点击Previewer预览失败&#xff0c;Preview failed Unable to start the previewer. Open PreviewerLog to check for details。 点击File->Settings->Build, Execution, Deployment->Build Tools->Hvigor&#xff…
阅读更多...
音视频直播核心技术介绍

音视频直播核心技术介绍

直播流程 采集&#xff1a; 是视频直播开始的第一个环节&#xff0c;用户可以通过不同的终端采集视频&#xff0c;比如 iOS、Android、Mac、Windows 等。 前处理&#xff1a;主要就是美颜美型技术&#xff0c;以及还有加水印、模糊、去噪、滤镜等图像处理技术等等。 编码&#…
阅读更多...
任意文件下载漏洞的利用思考

任意文件下载漏洞的利用思考

0x01 前言 任意文件下载漏洞作为最常见的WEB漏洞之一&#xff0c;在平常的渗透测试中经常遇到&#xff0c;但是很多人却并没有深入去想该如何利用这种漏洞&#xff0c;导致忽略了一些细节的信息。 0x02 传统利用 1&#xff09; 下载配置文件连数据库 通过任意文件下载漏洞下载网…
阅读更多...
翻译: LLMs关于人工智能的担忧 Concerns about AI

翻译: LLMs关于人工智能的担忧 Concerns about AI

在短时间内&#xff0c;获取生成人工智能的能力已经在全球范围内传播&#xff0c;使许多人能够生成高质量的文章、图片和音频。随着这些惊人的能力的出现&#xff0c;也带来了许多关于人工智能的担忧。我认为即使在生成人工智能兴起之前&#xff0c;我们就已经生活在许多焦虑之…
阅读更多...
charles和谷歌浏览器在Mac上进行软件安装，桌面上会显示一个虚拟磁盘，关掉页面推出磁盘内容都消失掉了 需要再次安装问题解决

charles和谷歌浏览器在Mac上进行软件安装，桌面上会显示一个虚拟磁盘，关掉页面推出磁盘内容都消失掉了 需要再次安装问题解决

其他软件也会有这种情况&#xff0c;这里我们以charles为例。绿色背景的内容是重点步骤。 1.如图&#xff0c;我下载了一个charles一个版本的dmg文件。 2.打开后&#xff0c;选择Agree 3.桌面会出现一个磁盘和如下页面 4.错误操作------可以不看 直接看第5步正确操作 常规情…
阅读更多...
为什么GRU和LSTM能够缓解梯度消失或梯度爆炸问题？

为什么GRU和LSTM能够缓解梯度消失或梯度爆炸问题？

1、什么是梯度消失&#xff08;gradient vanishing&#xff09;&#xff1f; 参数更新过小&#xff0c;在每次更新时几乎不会移动&#xff0c;导致模型无法学习。 2、什么是梯度爆炸&#xff08;gradient exploding&#xff09;&#xff1f; 参数更新过小大&#xff0c;破坏了…
阅读更多...
亚马逊、沃尔玛、eBay：通过优化测评策略，提高店铺排名的秘诀

亚马逊、沃尔玛、eBay：通过优化测评策略，提高店铺排名的秘诀

目前&#xff0c;亚马逊平台不仅考虑产品和店铺的排名&#xff0c;还会对产品列表进行排名。不同的排名有不同的影响因素。以下是亚马逊影响商品详情页排名的因素&#xff1a; 1.销售排行&#xff1a;卖家可以通过查看BSR榜单来了解自己的销售排名。销售排名反映了你的产品的销…
阅读更多...
第二天使用seleninum创建创建员工

第二天使用seleninum创建创建员工

上一篇我们已经登录进了系统，下面看下怎么自动创建用户信息。 一：知识准备 创建用户前，我们学习下seleninum的页面元素获取和填写数据方法 send_keys 发送数据 find_element_by_xpath 通过xpath定位，这个上一节我们说过 二：查看页面结构 进入系统以后，我们要做的…
阅读更多...
27.BGP边界网关路由协议

27.BGP边界网关路由协议

BGP边界网关路由协议 外部网关路由协议 ospf能承载的路由条目有限 用在运营商与运营商之间&#xff0c;国与国之间 BGP运行在IGP之上&#xff08;内部网关路由&#xff09; IGP都是在物理链路上直连的基础之上才能建立邻居关系&#xff0c;BGP可以跨路由器建立邻居关系&…
阅读更多...
做一个类似东郊到家系统需要哪些功能？

做一个类似东郊到家系统需要哪些功能？

随着移动互联网的普及&#xff0c;越来越多的人开始通过手机预约按摩服务。按摩预约小程序&#xff0c;作为一种方便快捷的预约方式&#xff0c;让用户可以随时随地预约按摩服务。那么&#xff0c;按摩预约小程序的开发周期是多长呢&#xff1f;它又有哪些功能呢&#xff1f;本…
阅读更多...
死锁产生的条件是什么？？？如何进行死锁判断？？？

死锁产生的条件是什么？？？如何进行死锁判断？？？

死锁是指两个或多个线程相互等待对方释放所持有的资源&#xff0c;导致程序无法继续执行的情况。死锁产生的条件是&#xff1a; 互斥条件&#xff1a;至少有一个资源必须处于非分享状态&#xff0c;即一次只能被一个线程占用。占有且等待条件&#xff1a;线程持有至少一个资源…
阅读更多...
【QML】QML复制文件或文件夹，显示进度，多线程复制

【QML】QML复制文件或文件夹，显示进度，多线程复制

1. 效果 可以显示复制文件和文件夹的进度 复制文件&#xff1a; bool copyFileFunc(QString _from, QString _to);复制文件夹&#xff1a;bool copyDirectoryFiles(const QString &_from, const QString &_to);举例&#xff1a; //复制文件copyhelper.copyFileToDir(&…
阅读更多...
手机技巧：手机膜种类介绍，你真的了解吗

手机技巧：手机膜种类介绍，你真的了解吗

目录 一、材质分类 水凝膜 钢化玻璃膜 二、功能分类 抗蓝光膜 防窥膜 磨砂膜 三、最后 鉴于智能手机越来越“娇贵”的体质&#xff0c;能让手机“裸奔”的大神相信不在多数。 然而比较注重手机保养的朋友都会选择给手机贴膜&#xff0c;这样能防止手机刮划&#xff0c;…
阅读更多...
数据结构--图（更新ing~）

数据结构--图（更新ing~）

树具有灵活性&#xff0c;并且存在许多不同的树的应用&#xff0c;但是就树本身而言有一定的局限性&#xff0c;树只能表示层次关系&#xff0c;比如父子关系。而其他的比如兄弟关系只能够间接表示。 推广--- 图 图形结构中&#xff0c;数据元素之间的关系是任意的。 一、图…
阅读更多...
Java：语法速通

Java：语法速通

参考 菜鸟教程 java 继承 class 父类 { }class 子类 extends 父类 { }继承的特性&#xff1a; 子类拥有父类非private的属性和方法子类可以对父类进行扩展子类可以重写父类的方法使用extends只能单继承&#xff0c;使用implements可以变相的多继承&#xff0c;即一个类继承…
阅读更多...
24_28-Golang函数详解

24_28-Golang函数详解

**Golang **函数详解 主讲教师&#xff1a;&#xff08;大地&#xff09; 合作网站&#xff1a;www.itying.com** **&#xff08;IT 营&#xff09; 我的专栏&#xff1a;https://www.itying.com/category-79-b0.html 1、函数定义 :::info 函数是组织好的、可重复使用的、用…
阅读更多...
雪花算法（几种常见的雪花算法生成ID方案简单介绍：Hutool、百度Uid-Generator、美团Leaf、Yitter）

雪花算法（几种常见的雪花算法生成ID方案简单介绍：Hutool、百度Uid-Generator、美团Leaf、Yitter）

文章目录 1.生成id的几种方式2. 雪花算法2.1 雪花算法介绍2.2 市面上几种雪花算法的实现2.2.1 hutool版2.2.1.1 hutool版本雪花算法 关于时钟回拨的处理&#xff1a; ---------------百度UidGenerator 介绍开始--------------2.2.2 百度版&#xff1a;[UidGenerator](https://g…
阅读更多...
vue 流光边框矩形圆形容器

vue 流光边框矩形圆形容器

实现流光边框一般是用渐变背景加动画实现&#xff0c;然后使用内部盒子遮挡内部空间&#xff0c;达到边框流光的效果 思路&#xff1a;背景渐变旋转动画 功能&#xff1a; 自定义渐变&#xff08;是否渐变<不渐变没有流光效果>&#xff0c;渐变颜色&#xff0c;渐变角…
阅读更多...
最新文章

Copyright @ 2022~2023

友情链接： 我的编程经验分享 一条长河网 尧图网站开发 尧图建网站