基于XML配置bean（一）

文章目录

    • 1.获取bean的两种方式
        • 1.通过id获取bean（前面用过）
        • 2.通过类型获取bean（单例时使用）
          • 1.案例
          • 2.代码
            • 1.beans.xml
            • 2.SpringBeanTest.java
            • 3.结果
          • 3.注意事项
    • 2.三种基本依赖注入方式
        • 1.通过属性配置bean（前面用过）
        • 2.通过构造器配置bean
          • 1.通过index配置
          • 2.通过name配置
          • 3.通过type配置
          • 4.验证
        • 3.通过p命名空间配置bean
          • 1.配置
          • 2.注意需要alt + enter引入命名空间定义
    • 3.属性注入bean对象的两种方式
        • 1.通过ref注入
          • 1.dao/MemberDao.java
          • 2.MemberDaoImpl.java
          • 3.service/MemberServiceImpl.java
          • 4.beans.xml
          • 5.测试SpringBeanTest
          • 6..解释
        • 2.通过内部bean注入
          • beans.xml
    • 4.不同类型的属性注入方式
        • 1.List
          • 1.Master.java
          • 2.beans.xml
          • 3.测试
        • 2.Map
          • 1.beans.xml
          • 2.测试
        • 3.Set
          • 1.beans.xml
          • 2.测试
        • 4.Array
          • 1.beans.xml
          • 2.测试
        • 5.Properties
          • 1.beans.xml
          • 2.测试
        • 6.util:list
          • 1.BookStore.java
          • 2.beans.xml
          • 3.测试
        • 7.级联属性赋值
          • 1.Dept.java
          • 2.Emp.java
          • 3.beans.xml
          • 4.测试

1.获取bean的两种方式

1.通过id获取bean（前面用过）
2.通过类型获取bean（单例时使用）
1.案例

image-20240216170105886

2.代码
1.beans.xml
    <bean class="com.sxs.spring.bean.Car">
        <property name="name" value="奔驰"/>
        <property name="id" value="100"/>
        <property name="price" value="10.2"/>
    </bean>
2.SpringBeanTest.java
    //通过类型来获取bean对象
    @Test
    public void getBeanByType() {
        ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");
        Car car = ioc.getBean(Car.class);
        System.out.println(car);
    }
3.结果

image-20240216170458002

3.注意事项

image-20240216170600891

2.三种基本依赖注入方式

1.通过属性配置bean（前面用过）
2.通过构造器配置bean
1.通过index配置
    <!--通过索引配置-->
    <bean class="com.sxs.spring.bean.Car" id="car1">
        <constructor-arg index="0" value="100"></constructor-arg>
        <constructor-arg index="1" value="奔驰1"></constructor-arg>
        <constructor-arg index="2" value="300.12"></constructor-arg>
    </bean>
2.通过name配置
    <!--通过名字配置-->
    <bean class="com.sxs.spring.bean.Car" id="car2">
        <constructor-arg name="id" value="200"></constructor-arg>
        <constructor-arg name="name" value="宾利"></constructor-arg>
        <constructor-arg name="price" value="2000000"></constructor-arg>
    </bean>
3.通过type配置
    <!--通过类型配置-->
    <bean class="com.sxs.spring.bean.Car" id="car3">
        <constructor-arg type="java.lang.Integer" value="300"></constructor-arg>
        <constructor-arg type="java.lang.String" value="宝马"></constructor-arg>
        <constructor-arg type="java.lang.Double" value="2332233223"></constructor-arg>
    </bean>
4.验证
    //得到三种方式配置的bean对象
    @Test
    public void Construct() {
        ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");
        Object car1 = ioc.getBean("car1");
        Object car2 = ioc.getBean("car2");
        Object car3 = ioc.getBean("car3");
        System.out.println(car1);
        System.out.println(car2);
        System.out.println(car3);
    }

image-20240216181901460

3.通过p命名空间配置bean
1.配置
    <!--通过p命名空间来配置bean-->
    <bean class="com.sxs.spring.bean.Car" id="car4"
        p:id = "100"
        p:name = "路虎"
        p:price = "121212"
    />
2.注意需要alt + enter引入命名空间定义

image-20240216182933116

3.属性注入bean对象的两种方式

1.通过ref注入

image-20240216183305643

1.dao/MemberDao.java
package com.sxs.spring.dao;

/**
 * @author 孙显圣
 * @version 1.0
 */
public interface MemberDao {
    public void add();
}
2.MemberDaoImpl.java
package com.sxs.spring.dao;

/**
 * @author 孙显圣
 * @version 1.0
 */
public class MemberDaoImpl implements MemberDao{
    //注意这里有默认的构造方法被调用，因为要反射创建bean对象
    @Override
    public void add() {
        System.out.println("MemberDaoImpl的add方法被调用！");
    }
}
3.service/MemberServiceImpl.java
package com.sxs.spring.service;

import com.sxs.spring.dao.MemberDao;

/**
 * @author 孙显圣
 * @version 1.0
 */
public class MemberServiceImpl {
    //这个service需要使用dao
    MemberDao memberDao;
    public void add() {
        //调用dao的add方法
        memberDao.add();
    }

    //属性注入，需要getter和setter方法

    public MemberDao getMemberDao() {
        return memberDao;
    }

    public void setMemberDao(MemberDao memberDao) {
        this.memberDao = memberDao;
    }
}
4.beans.xml
    <!--反射创建MemberDaoMemberDaoImpl的实现类的对象-->
    <bean class="com.sxs.spring.dao.MemberDaoImpl" id="memberDao"/>

    <!--依赖注入到service中-->
    <bean class="com.sxs.spring.service.MemberServiceImpl" id="memberService">
        <!--这里使用属性注入MemberDaoMemberDaoImpl的对象-->
        <property name="memberDao" ref="memberDao"></property>
    </bean>
5.测试SpringBeanTest
    //通过ref来配置bean
    @Test
    public void refBean() {
        //得到经过依赖注入的MemberServiceImpl类的bean对象，注意千万不要自己创建，因为自己new的对象的属性并没有被注入
        ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");
        //由于只有一个实例，所以可以使用class类型来获取bean对象
        MemberServiceImpl bean = ioc.getBean(MemberServiceImpl.class);
        bean.add();
    }

image-20240216190843457

6…解释
  1. 这里MemberDaoImpl有一个add方法，MemberServiceImpl需要调用这个方法，所以需要这个MemberDao类型的属性
  2. 通过spring反射创建MemberDaoImpl的实例（使用默认构造方法）
  3. 再通过spring反射创建MemberServiceImpl的实例（使用默认构造方法），然后将MemberDao这个属性也通过spring进行依赖注入
  4. 注意：进行依赖注入时如果是属性注入，需要给属性setter方法
  5. 在使用MemberServiceImpl的实例时，不能自己创建实例，因为自己创建的实例没有被依赖注入，是不能正常运行的！！！必须通过spring的ApplicationContext来获取被依赖注入的MemberServiceImpl对象
2.通过内部bean注入
beans.xml
    <!--通过内部bean来配置bean-->
    <bean class="com.sxs.spring.service.MemberServiceImpl" id="memberService2">
        <property name="memberDao">
            <!--这里通过内部的bean来实现依赖注入，将MemberDaoImpl的bean对象给了属性memberDao-->
            <bean class="com.sxs.spring.dao.MemberDaoImpl"/>
        </property>
    </bean>

4.不同类型的属性注入方式

1.List

image-20240216193131340

1.Master.java
package com.sxs.spring.bean;

import org.springframework.objenesis.instantiator.perc.PercInstantiator;

import java.util.*;

/**
 * @author 孙显圣
 * @version 1.0
 */
public class Master {
    private String name;
    private List<Monster> monstersList;
    private Map<String, Monster> monsterMap;
    private Set<Monster> monsterSet;
    private String[] monsterName;
    private Properties pros;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public List<Monster> getMonstersList() {
        return monstersList;
    }

    public void setMonstersList(List<Monster> monstersList) {
        this.monstersList = monstersList;
    }

    public Map<String, Monster> getMonsterMap() {
        return monsterMap;
    }

    public void setMonsterMap(Map<String, Monster> monsterMap) {
        this.monsterMap = monsterMap;
    }

    public Set<Monster> getMonsterSet() {
        return monsterSet;
    }

    public void setMonsterSet(Set<Monster> monsterSet) {
        this.monsterSet = monsterSet;
    }

    public String[] getMonsterName() {
        return monsterName;
    }

    public void setMonsterName(String[] monsterName) {
        this.monsterName = monsterName;
    }

    public Properties getPros() {
        return pros;
    }

    public void setPros(Properties pros) {
        this.pros = pros;
    }

    @Override
    public String toString() {
        return "Master{" +
                "name='" + name + '\'' +
                ", monstersList=" + monstersList +
                ", monsterMap=" + monsterMap +
                ", monsterSet=" + monsterSet +
                ", monsterName=" + Arrays.toString(monsterName) +
                ", pros=" + pros +
                '}';
    }
}
2.beans.xml
    <!--属性注入：List类型-->
    <bean class="com.sxs.spring.bean.Master" id="master">
        <property name="name" value="list"/>
        <!--list类型的属性内部用list标签包裹，然后放入对象-->
        <property name="monstersList">
            <list>
                <!--1.引用bean对象-->
                <ref bean="monster"/>
                <ref bean="monster2"/>
                <!--2.反射创建bean对象-->
                <bean class="com.sxs.spring.bean.Monster">
                    <property name="name" value="111"/>
                    <property name="skill" value="111"/>
                    <property name="monsterId" value="111"/>
                </bean>
            </list>
        </property>
    </bean>
3.测试
    //依赖注入：list类型
    @Test
    public void List_() {
        ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");
        Master master = ioc.getBean("master", Master.class);
        System.out.println(master);
    }

image-20240216195540484

2.Map
1.beans.xml
    <!--属性注入：Map类型-->
    <bean class="com.sxs.spring.bean.Master" id="master2">
        <property name="name" value="map"/>
        <property name="monsterMap">
            <map>
                <entry>
                    <!--key的配置-->
                    <key>
                        <value>monster</value>
                    </key>
                    <!--value的配置，这里是引用的bean对象-->
                    <ref bean="monster"/>
                </entry>
                <!--第二个K-V配置-->
                <entry>
                    <!--key的配置-->
                    <key>
                        <value>monster1</value>
                    </key>
                    <!--value的配置，这里是内部bean对象-->
                    <bean class="com.sxs.spring.bean.Monster" id="monster1">
                        <property name="name" value="222"/>
                        <property name="monsterId" value="222"/>
                        <property name="skill" value="222"/>
                    </bean>
                </entry>
            </map>
        </property>
    </bean>
2.测试
    //依赖注入：map类型
    @Test
    public void Map_() {
        ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");
        Master master = ioc.getBean("master2", Master.class);
        System.out.println(master);
    }

image-20240216202240728

3.Set
1.beans.xml
    <!--属性注入：Set类型-->
    <bean class="com.sxs.spring.bean.Master" id="master3">
        <property name="monsterSet">
            <set>
                <!--跟list相似不过是在set标签下放对象-->
                <!--引用bean对象-->
                <ref bean="monster"/>
                <!--内部bean对象-->
                <bean class="com.sxs.spring.bean.Monster">
                    <property name="name" value="222"/>
                    <property name="monsterId" value="222"/>
                    <property name="skill" value="222"/>
                </bean>
            </set>
        </property>
    </bean>
2.测试
    //依赖注入：Set类型
    @Test
    public void Set_() {
        ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");
        Master master = ioc.getBean("master3", Master.class);
        System.out.println(master);
    }

image-20240216203249023

4.Array
1.beans.xml
    <!--属性注入：数组类型-->
    <bean class="com.sxs.spring.bean.Master" id="master4">
        <property name="monsterName">
            <array>
                <!--由于这里使用的是String类型，所以直接使用value标签即可，具体根据业务来使用！-->
                <value>小妖怪</value>
                <value>中妖怪</value>
                <value>大妖怪</value>
            </array>
        </property>
    </bean>
2.测试
    //依赖注入：Array类型
    @Test
    public void Array_() {
        ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");
        Master master = ioc.getBean("master4", Master.class);
        System.out.println(master);
    }

image-20240216204147279

5.Properties
1.beans.xml
    <!--属性注入：Properties类型-->
    <bean class="com.sxs.spring.bean.Master" id="master5">
        <property name="pros">
            <!--注意：properties是key-value类型的并且key和value都是String类型的-->
            <props>
                <prop key="username">111111</prop>
                <prop key="psssword">222222</prop>
                <prop key="ip">127.0.0.1</prop>
            </props>
        </property>
    </bean>
2.测试
    //依赖注入：Properties类型
    @Test
    public void Properties_() {
        ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");
        Master master = ioc.getBean("master5", Master.class);
        System.out.println(master);
    }
6.util:list
1.BookStore.java
package com.sxs.spring.bean;

import java.util.List;

/**
 * @author 孙显圣
 * @version 1.0
 */
public class BookStore {
    private List<String> bookList; //使用util:list进行属性注入

    //无参构造
    public BookStore() {}

    public List<String> getBookList() {
        return bookList;
    }

    public void setBookList(List<String> bookList) {
        this.bookList = bookList;
    }
}
2.beans.xml
    <!--使用util：list配置bean-->
    <util:list id="myBookList">
        <value>三国演义</value>
        <value>水浒传</value>
        <value>红楼梦</value>
        <value>西游记</value>
    </util:list>

    <bean class="com.sxs.spring.bean.BookStore" id="bookStore">
        <!--直接将list引进去即可-->
        <property name="bookList" ref="myBookList"/>
    </bean>
3.测试
    //依赖注入：util:list
    @Test
    public void UtilList() {
        ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");
        BookStore bean = ioc.getBean(BookStore.class);
        System.out.println(bean);
    }

image-20240218100020663

7.级联属性赋值

image-20240218100201828

1.Dept.java
package com.sxs.spring.bean;

/**
 * @author 孙显圣
 * @version 1.0
 */
public class Dept {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Dept{" +
                "name='" + name + '\'' +
                '}';
    }
}
2.Emp.java
package com.sxs.spring.bean;

/**
 * @author 孙显圣
 * @version 1.0
 */
public class Emp {
    private String name;
    private Dept dept;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Dept getDept() {
        return dept;
    }

    public void setDept(Dept dept) {
        this.dept = dept;
    }

    @Override
    public String toString() {
        return "Emp{" +
                "name='" + name + '\'' +
                ", dept=" + dept +
                '}';
    }
}
3.beans.xml
    <!--级联属性赋值-->
    <!--这个bean对象先不要配置name，留给后面的直接配置-->
    <bean class="com.sxs.spring.bean.Dept" id="dept"/>
    <bean class="com.sxs.spring.bean.Emp" id="emp">
        <property name="name" value="王二虎"/>
        <property name="dept" ref="dept"/>
        <!--为属性的属性赋值-->
        <property name="dept.name" value="财务部"/>
    </bean>
4.测试
    //级联属性赋值
    @Test
    public void cascadingAttributes() {
        ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");
        Emp bean = ioc.getBean(Emp.class);
        System.out.println(bean.getDept().getName());
    }

image-20240218101558063

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

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

相关文章

Eureka基础介绍和使用

Eureka基础介绍和使用

目录 一.理论基础 二.父项目 2.1 新建父项目 2.2 管理依赖 三.子项目 3.1 新建子项目 3.2 注册中心Server依赖和启动类和配置文件 3.3 生产者Client 依赖和启动类和配置文件 3.5 消费者Custmer依赖和配置类、启动类和配置文件 四.心跳 五.公共资源项目 5.1新建实体…
阅读更多...
BUG：vue表单验证校验不报错，必填都有信息，就是不能正常往下进行

BUG：vue表单验证校验不报错，必填都有信息，就是不能正常往下进行

vue表单验证未报错却出现异常 框架bug场景解决办法 框架 UI&#xff1a;element-UI 前端&#xff1a;vue2 bug场景 正常表单里面&#xff0c;有的信息要求必填或者加了一些限制&#xff0c;作为校验验证&#xff0c;只有走到校验才会执行其他行为&#xff0c;比如调用保存接…
阅读更多...
labelimg安装和使用（解决闪退问题）

labelimg安装和使用（解决闪退问题）

&#x1f308;个人主页&#xff1a;Rookie Maker &#x1f525; 系列专栏&#xff1a;计算机视觉 &#x1f3c6;&#x1f3c6;关注博主&#xff0c;随时获取更多关于IT的优质内容&#xff01;&#x1f3c6;&#x1f3c6; &#x1f600;欢迎来到我的代码世界~ &#x1f601; 喜…
阅读更多...
C++修炼之路之list--C++中的双向循环链表

C++修炼之路之list--C++中的双向循环链表

目录 前言 一&#xff1a;正式之前先回顾数据结构中的双向循环链表 二&#xff1a;list的简介 三&#xff1a;STL中list常用接口函数的介绍及使用 1.构造函数接口 2.list迭代器 范围for 3.数据的修改接口函数 4.list容量操作函数 5.list的迭代器失效 6.演示代码和测…
阅读更多...
【网络编程】Web服务器shttpd源码剖析——线程池调度

【网络编程】Web服务器shttpd源码剖析——线程池调度

hello &#xff01;大家好呀&#xff01; 欢迎大家来到我的网络编程系列之web服务器shttpd源码剖析——线程池调度&#xff0c;在这篇文章中&#xff0c;你将会学习到在Linux内核中如何创建一个自己的并发服务器shttpd&#xff0c;并且我会给出源码进行剖析&#xff0c;以及手绘…
阅读更多...
allure2教程-3-测试报告定制

allure2教程-3-测试报告定制

领取资料&#xff0c;咨询答疑&#xff0c;请➕wei: June__Go 上一小节&#xff0c;我们学习一下pytestallure2生成html测试报告的方法&#xff0c;本小节我们学习一下allure2测试报告的定制。 allure2报告预览 预览网址&#xff1a;https://demo.qameta.io/allure/# allur…
阅读更多...
[leetcode] minimum-falling-path-sum

[leetcode] minimum-falling-path-sum

. - 力扣&#xff08;LeetCode&#xff09; 给你一个 n x n 的 方形 整数数组 matrix &#xff0c;请你找出并返回通过 matrix 的下降路径 的 最小和 。 下降路径 可以从第一行中的任何元素开始&#xff0c;并从每一行中选择一个元素。在下一行选择的元素和当前行所选元素最多…
阅读更多...
归并排序了解吗？手撕一个我看看？

归并排序了解吗？手撕一个我看看？

目录 1- 归并排序原理1-1 主要思想1-2 实现步骤 2- 归并排序代码实现(双指针)⭐ 归并排序 ——实现思路 3- ACM模式实现 1- 归并排序原理 1-1 主要思想 归并排序基于分治 将序列中待排序的数数字分为若干组&#xff0c;每个数字分为一组 将若干组两两合并&#xff0c;保证合…
阅读更多...
3D模型处理的多进程并行【Python】

3D模型处理的多进程并行【Python】

今天我们将讨论如何使用 Python 多进程来处理大量3D数据。 我将讲述一些可能在手册中找到的一般信息&#xff0c;并分享我发现的一些小技巧&#xff0c;例如将 tqdm 与多处理 imap 结合使用以及并行处理存档。 NSDT工具推荐&#xff1a; Three.js AI纹理开发包 - YOLO合成数据生…
阅读更多...
【蓝桥杯2025备赛】素数判断:从O(n^2)到O(n)学习之路

【蓝桥杯2025备赛】素数判断:从O(n^2)到O(n)学习之路

素数判断:从O( n 2 n^2 n2)到O(n)学习之路 背景:每一个初学计算机的人肯定避免不了碰到素数&#xff0c;素数是什么&#xff0c;怎么判断&#xff1f; 素数的概念不难理解:素数即质数&#xff0c;指的是在大于1的自然数中&#xff0c;除了1和它本身不再有其他因数的自然数。 …
阅读更多...
4.18作业

4.18作业

顺序栈&#xff1a; #include "seq_stack.h" seq_p creat_stack() //从堆区申请顺序栈的空间 {seq_p S(seq_p)malloc(sizeof(seq_stack));if(SNULL){printf("空间申请失败\n");return NULL;}bzero(S->data,sizeof(S->data));S->top-1;return S; …
阅读更多...
OpenGL：图元

OpenGL：图元

OpenGL的图元 点 GL_POINTS： 将顶点绘制成单个的点 线 GL_LINES：将顶点用于创建线段，2个点成为一条单独的线段。如果顶点个数是奇数，则忽略最后一个。 顶点：v0, v1, v2, v3, … , vn，线段：v0-v1， v2-v3, v4-v5, … , vn-1 - vn GL_LINE_STRIP：将顶点用于创建线段，…
阅读更多...
在Linux系统中，禁止有线以太网使用NTP服务器进行时间校准的几种方法

在Linux系统中，禁止有线以太网使用NTP服务器进行时间校准的几种方法

目录标题 方法 1&#xff1a;修改NTP配置以禁止所有同步方法 2&#xff1a;通过网络配置禁用NTP同步方法 3&#xff1a;禁用NTP服务 在Linux系统中&#xff0c;如果想要禁止有线以太网使用NTP服务器进行时间校准&#xff0c;可以通过以下几种方法之一来实现&#xff1a; 方法 …
阅读更多...
tcp网络编程——2

tcp网络编程——2

1.一个服务器只能有一个客户端连接&#xff08;下面代码&#xff09; ​​​​​​​tcp网络编程&#xff08;基础&#xff09;-CSDN博客 2.一个服务器可以有多个客户端连接&#xff08;多线程&#xff09; server端创建多个线程&#xff0c;每个线程与不同的client端建立连…
阅读更多...
代码签名证书的作用及申请

代码签名证书的作用及申请

代码签名证书新兴的数字证书的一种&#xff0c;应用范围相对于传统的数字证书而言要稍微少一些。用于验证软件代码的来源和完整性&#xff0c;并提供了一种防止代码被篡改或损坏的机制。常用于软件开发上&#xff0c;代码签名证书由签名证书公钥和私钥证书两部分组成&#xff0…
阅读更多...
day05-Elasticsearch01

day05-Elasticsearch01

1.初识elasticsearch 1.1.了解ES 1.1.1.elasticsearch的作用 elasticsearch 是一款非常强大的开源搜索引擎&#xff0c;具备非常多强大功能&#xff0c;可以帮助我们从海量数据中快速找到需要的内容 例如&#xff1a; 在 GitHub 搜索代码在电商网站搜索商品在百度搜索答案在打…
阅读更多...
【工位ubuntu的配置】补充

【工位ubuntu的配置】补充

软件 安装桌面图标的问题 登录密码 root的密码为&#xff1a;19980719 按照如下的链接进行配置&#xff1a; https://blog.csdn.net/zhangmingfie/article/details/131102331?spm1001.2101.3001.6650.3&utm_mediumdistribute.pc_relevant.none-task-blog-2%7Edefault%7E…
阅读更多...
永久免费次数ChatGPT国内镜像网站【强烈建议收藏】

永久免费次数ChatGPT国内镜像网站【强烈建议收藏】

gctohttps://chat.tomyres.com/#/pages/web/index?n0 觉得分享的网站好用的话&#xff0c;记得点赞收藏哦。
阅读更多...
lettcode179.最大数

lettcode179.最大数

问题描述&#xff1a; 给定一组非负整数 nums&#xff0c;重新排列每个数的顺序&#xff08;每个数不可拆分&#xff09;使之组成一个最大的整数。 注意&#xff1a;输出结果可能非常大&#xff0c;所以你需要返回一个字符串而不是整数。 示例一&#xff1a; 输入nums [10…
阅读更多...
街景图片语义分割后像素类别提取，用于计算各种指标。

街景图片语义分割后像素类别提取，用于计算各种指标。

语义分割代码见之前博文&#xff08;免费&#xff09;&#xff1a;deeplabv3街景图片语义分割&#xff0c;无需训练模型&#xff0c;看不懂也没有影响&#xff0c;直接使用。cityscapes 语义分割之后&#xff0c;如下图&#xff0c;想要统计各类像素所占的比例&#xff0c;用于…
阅读更多...
最新文章

Copyright @ 2022~2023