基于XML配置bean（二）

文章目录

    • 1.工厂中获取bean
        • 1.静态工厂
          • 1.MyStaticFactory.java
          • 2.beans.xml
          • 3.测试
        • 2.实例工厂
          • 1.MyInstanceFactory.java
          • 2.beans.xml
          • 3.测试
        • 3.FactoryBean（重点）
          • 1.MyFactoryBean.java
          • 2.beans.xml
          • 3.测试
    • 2.bean配置信息重用
        • 继承抽象bean
          • 1.beans.xml
          • 2.测试
    • 3.bean细节介绍
        • 1.bean的创建顺序
          • 1.depends-on关键字
          • 2.问题引出
        • 2.bean对象的单例和多例
          • 1.应用实例
          • 2.使用细节
          • 3.单例与多例对比
            • 单例（非懒加载）
            • 单例（懒加载）
            • 多例
        • 3.bean的生命周期
          • 1.基本介绍
          • 2.简化来说
          • 3.生命周期演示案例
            • 1.House.java
            • 2.beans.xml
            • 3.测试
          • 4.配置bean后置处理器（难点）
            • 1.MyBeanPostProcessor.java
            • 2.beans02.xml
            • 3.测试
          • 5.通过属性文件配置bean
            • 1.src下创建my.properties
            • 2.beans03.xml
            • 3.测试
          • 6.自动装配bean
            • 1.OrderDao.java
            • 2.OrderService.java
            • 3.OrderServlet.java
            • 4.通过类型自动装配
            • 5.通过名字自动装配
            • 6.测试
          • 7.Spring El表达式（了解）

1.工厂中获取bean

1.静态工厂
1.MyStaticFactory.java
package com.sxs.spring.bean;

import java.util.HashMap;
import java.util.Map;

/**
 * @author 孙显圣
 * @version 1.0
 */
public class MyStaticFactory {
    //hashmap存储对象
    private static Map<String, Monster> monsterHashMap;

    //静态代码块进行初始化
    static {
        monsterHashMap = new HashMap<>();
        //放进去两个对象
        monsterHashMap.put("monster01", new Monster(1, "牛魔王", "芭蕉扇"));
        monsterHashMap.put("monster01", new Monster(2, "牛魔王", "芭蕉扇"));
    }

    //提供get方法获取bean对象
    public static Monster getMonster(String key) {
        return monsterHashMap.get(key);
    }
}
2.beans.xml
    <!--静态工厂获取bean-->
    <!--不需要创建MyStaticFactory的对象，通过类加载就可以初始化工厂-->
    <bean class="com.sxs.spring.bean.MyStaticFactory" id="staticFactory" factory-method="getMonster">
        <constructor-arg value="monster01"/>
    </bean>
3.测试
    //静态工厂获取bean对象
    @Test
    public void staticFactory() {
        ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");
        Monster bean = ioc.getBean("staticFactory", Monster.class);
        System.out.println(bean);
    }

image-20240218103817182

2.实例工厂
1.MyInstanceFactory.java
package com.sxs.spring.bean;

import java.util.HashMap;
import java.util.Map;

/**
 * @author 孙显圣
 * @version 1.0
 */
public class MyInstanceFactory {
    //map存储monster对象
    private Map<String, Monster> monsterMap;
    //普通代码块进行初始化
    {
        monsterMap = new HashMap<>();
        //放进去两个对象
        monsterMap.put("monster01", new Monster(1, "牛魔王", "芭蕉扇"));
        monsterMap.put("monster01", new Monster(2, "牛魔王", "芭蕉扇"));
    }
    //提供get方法获取对象
    public Monster getMonster(String key) {
        return monsterMap.get(key);
    }
}
2.beans.xml
    <!--实例工厂获取bean-->
    <!--创建bean对象，初始化两个实例工厂-->
    <bean class="com.sxs.spring.bean.MyInstanceFactory" id="instanceFactory1"/>
    <bean class="com.sxs.spring.bean.MyInstanceFactory" id="instanceFactory2"/>
    <!--从第一个bean工厂中获取bean对象-->
    <bean class="com.sxs.spring.bean.MyInstanceFactory" factory-bean="instanceFactory1" id="instanceFactory_1" factory-method="getMonster">
        <constructor-arg value="monster01"/>
    </bean>
    <!--从第二个bean工厂中获取bean对象-->
    <bean class="com.sxs.spring.bean.MyInstanceFactory" factory-bean="instanceFactory2" id="instanceFactory_2" factory-method="getMonster">
        <constructor-arg value="monster01"/>
    </bean>
3.测试
    //通过实例工厂获取bean对象
    @Test
    public void instanceFactory() {
        ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");
        //从第一个实例工厂中获取bean对象
        Monster monster1 = ioc.getBean("instanceFactory_1", Monster.class);
        //从第二个实例工厂中获取bean对象
        Monster monster2 = ioc.getBean("instanceFactory_2", Monster.class);
        System.out.println(monster1 == monster2);
    }

image-20240218111113422

3.FactoryBean（重点）
1.MyFactoryBean.java
package com.sxs.spring.bean;

import org.springframework.beans.factory.FactoryBean;

import java.util.HashMap;
import java.util.Map;

/**
 * @author 孙显圣
 * @version 1.0
 */
public class MyFactoryBean implements FactoryBean<Monster> {

    //bean工厂中的key,要取的key是什么就设置成什么
    private String key;
    //bean工厂
    private Map<String, Monster> monsterMap;

    //初始化bean工厂
    {
        monsterMap = new HashMap<>();
        //放进去两个对象
        monsterMap.put("monster01", new Monster(1, "牛魔王", "芭蕉扇"));
        monsterMap.put("monster02", new Monster(2, "牛魔王", "芭蕉扇"));
    }

    //设置key的方法（用于属性注入）
    public void setKey(String key) {
        this.key = key;
    }

    //根据key返回要得到的bean对象
    @Override
    public Monster getObject() throws Exception {
        return this.monsterMap.get(key);
    }

    //返回bean对象的类型
    @Override
    public Class<?> getObjectType() {
        return Monster.class;
    }

    //返回是否是单例的
    @Override
    public boolean isSingleton() {
        return true;
    }
}
2.beans.xml
    <!--通过FactoryBean来获取bean-->
    <bean class="com.sxs.spring.bean.MyFactoryBean" id="myFactoryBean">
        <!--直接对要获取的key进行属性注入即可-->
        <property name="key" value="monster01"/>
    </bean>
3.测试
    //通过factorybean获取bean对象
    @Test
    public void factoryBean() {
        ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");
        Monster myFactoryBean = ioc.getBean("myFactoryBean", Monster.class);
        System.out.println(myFactoryBean);
    }

image-20240218140602472

2.bean配置信息重用

继承抽象bean
1.beans.xml
    <!--抽象bean对象，不能够被实例化只能够被继承，-->
    <bean class="com.sxs.spring.bean.Monster" id="Abstractmonster" abstract="true">
        <property name="monsterId" value="200"/>
        <property name="name" value="孙悟空"/>
        <property name="skill" value="金箍棒"/>
    </bean>
    <!--继承抽象bean对象（也可以继承抽象的bean对象），则属性与其一样-->
    <bean class="com.sxs.spring.bean.Monster" id="monster3" parent="Abstractmonster"/>
2.测试
    //bean配置信息重用
    @Test
    public void configureInformationReuse() {
        ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");
        Monster monster03 = ioc.getBean("monster3", Monster.class);
        System.out.println(monster03);
    }

image-20240218142301845

3.bean细节介绍

1.bean的创建顺序
1.depends-on关键字
    <!--默认情况下是car5先创建，但是如果有depends-on绑定了car6，则在获取容器的时候是car6先创建-->
    <bean class="com.sxs.spring.bean.Car" id="car5" depends-on="car6"/>
    <bean class="com.sxs.spring.bean.Car" id="car6"/>
2.问题引出

image-20240218143948657

2.bean对象的单例和多例
1.应用实例
    <!--单例模式，默认的，每次都读取配置文件反射创建对象，然后将其放到容器中的字段里-->
    <bean class="com.sxs.spring.bean.Monster" id="monster4" scope="singleton"/>
    <!--多例模式，每次getBean的时候才会创建新对象-->
    <bean class="com.sxs.spring.bean.Monster" id="monster5" scope="prototype"/>
2.使用细节

image-20240218145932813

3.单例与多例对比
单例（非懒加载）
  1. 获取ioc容器
    1. 读取配置文件
    2. 反射创建bean对象
    3. 放到ioc容器的字段中
  2. getBean直接从字段中获取
单例（懒加载）
  1. 获取ioc容器
    1. 读取配置文件
  2. getBean的时候创建bean对象
  3. 将bean对象放到ioc容器的字段中
  4. 下次getBean还是从该字段中获取
多例
  1. 获取ioc容器
    1. 读取配置文件
  2. getBean的时候创建bean对象
  3. 下次getBean再穿件bean对象
3.bean的生命周期
1.基本介绍

image-20240218150756890

2.简化来说
  1. 反射创建bean对象
  2. 依赖注入
  3. 初始化bean
  4. getBean
  5. 销毁bean（容器关闭才会调用）
3.生命周期演示案例
1.House.java
package com.sxs.spring.bean;

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        System.out.println("setName方法被调用！");
        this.name = name;
    }
    //自定义的初始化方法，名字可以任意
    public void init() {
        System.out.println("bean初始化");
    }
    //自定义的销毁方法密码，名字可以任意
    public void destory() {
        System.out.println("bean对象被销毁");
    }
}
2.beans.xml
    <!--bean生命周期案例-->
    <bean class="com.sxs.spring.bean.House" id="house" init-method="init" destroy-method="destory">
        <property name="name" value="北京豪宅"/>
    </bean>
3.测试
    //生命周期案例演示
    @Test
    public void lifeCycle() {
        //1.反射创建bean对象，2.依赖注入
        ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");
        //3.初始化bean
        //4.getBean
        House house = ioc.getBean("house", House.class);
        //5.销毁bean
        ((ConfigurableApplicationContext)ioc).close();
    }

image-20240218154121983

4.配置bean后置处理器（难点）

image-20240219090132082

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

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;

/**
 * @author 孙显圣
 * @version 1.0
 */
//bean的后置处理器对象
public class MyBeanPostProcessor implements BeanPostProcessor {
    /**
     * 在bean的init方法前被调用
     * @param bean 传入的在ioc容器中创建的bean
     * @param beanName 传入的在ioc容器中配置的bean的id
     * @return
     * @throws BeansException
     */
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        //判断是否bean对象是house，如果是，将名字改为豪宅
        if (bean instanceof House) {
            ((House) bean).setName("豪宅");
        }
        System.out.println("postProcessBeforeInitialization被调用 " + bean + "beanName=" + beanName);
        return bean;
    }

    /**
     * 在bean的init方法后被调用
     * @param bean
     * @param beanName
     * @return
     * @throws BeansException
     */
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("postProcessAfterInitialization被调用 " + bean + "beanName=" + beanName);
        return bean;
    }
}
2.beans02.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--配置bean的后置处理器，会作用于所有的bean-->
    <bean class="com.sxs.spring.bean.MyBeanPostProcessor" id="beanPostProcessor"/>

    <bean class="com.sxs.spring.bean.House" id="house" init-method="init" destroy-method="destory">
        <property name="name" value="北京豪宅"/>
    </bean>
    <bean class="com.sxs.spring.bean.House" id="house02" init-method="init" destroy-method="destory">
        <property name="name" value="香港豪宅"/>
    </bean>
</beans>
3.测试
    //后置处理器演示
    @Test
    public void MyBeanPostProcessor() {
        ApplicationContext ioc = new ClassPathXmlApplicationContext("beans02.xml");
        House house = ioc.getBean("house", House.class);
        //关闭bean
        ((ConfigurableApplicationContext)ioc).close();
    }

image-20240219090412968

5.通过属性文件配置bean
1.src下创建my.properties

如果是中文则自己将中文转换成unicode编码

name=jack
skill=\u5403\u996d
monsterId=111
2.beans03.xml
    <!--设置配置文件的位置-->
    <context:property-placeholder location="classpath:my.properties"/>
    <!--使用${name}来读取配置文件中的信息-->
    <bean class="com.sxs.spring.bean.Monster" id="monster">
        <property name="name" value="${name}"/>
        <property name="skill" value="${skill}"/>
        <property name="monsterId" value="${monsterId}"/>
    </bean>
3.测试
    //测试使用配置文件配置bean
    @Test
    public void profiles() {
        ApplicationContext ioc = new ClassPathXmlApplicationContext("beans03.xml");
        Monster monster = ioc.getBean("monster", Monster.class);
        System.out.println(monster);
    }

image-20240219093101698

6.自动装配bean
1.OrderDao.java
package com.sxs.spring.dao;

/**
 * @author 孙显圣
 * @version 1.0
 */
public class OrderDao {
    public void saveOrder() {
        System.out.println("保存订单");
    }
}
2.OrderService.java
package com.sxs.spring.service;

import com.sxs.spring.dao.OrderDao;

/**
 * @author 孙显圣
 * @version 1.0
 */
public class OrderService {
    OrderDao orderDao;

    public OrderDao getOrderDao() {
        return orderDao;
    }

    public void setOrderDao(OrderDao orderDao) {
        this.orderDao = orderDao;
    }
}
3.OrderServlet.java
package com.sxs.spring.web;

import com.sxs.spring.service.OrderService;

/**
 * @author 孙显圣
 * @version 1.0
 */
public class OrderServlet {
    OrderService orderService;

    public OrderService getOrderService() {
        return orderService;
    }

    public void setOrderService(OrderService orderService) {
        this.orderService = orderService;
    }
}
4.通过类型自动装配
    <!--根据类型自动装配，会查找容器中是否有类型与属性一致的bean对象，如果有则自动注入-->
    <!--使用类型类自动装配的话，需要保证容器中只有一个同类型的bean对象-->
    <bean class="com.sxs.spring.dao.OrderDao" id="orderDao"/>
    <bean autowire="byType" class="com.sxs.spring.service.OrderService" id="orderService"/>
    <bean autowire="byType" class="com.sxs.spring.web.OrderServlet" id="orderServlet"/>
5.通过名字自动装配
    <!--根据名字自动装配，会查找容器中是否有与属性名字相同的id-->
    <bean class="com.sxs.spring.dao.OrderDao" id="orderDao"/>
    <bean autowire="byName" class="com.sxs.spring.service.OrderService" id="orderService"/>
    <bean autowire="byName" class="com.sxs.spring.web.OrderServlet" id="orderServlet"/>
6.测试
    //测试使用autowire自动装配
    @Test
    public void setBeanByAutowire() {
        ApplicationContext ioc = new ClassPathXmlApplicationContext("beans03.xml");
        OrderServlet bean = ioc.getBean(OrderServlet.class);
        //验证是否装配成功
        System.out.println(bean.getOrderService());
        System.out.println(bean.getOrderService().getOrderDao());
    }

image-20240219100908234

7.Spring El表达式（了解）

image-20240219101043961

image-20240219101619907

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

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

相关文章

多模态之BLIP—实现统一的视觉语言理解和生成，细节理解与论文详细阅读：Bootstrapping Language-Image Pre-training

多模态之BLIP—实现统一的视觉语言理解和生成，细节理解与论文详细阅读：Bootstrapping Language-Image Pre-training

BLIP: Bootstrapping Language-Image Pre-training for Unified Vision-Language Understanding and Generation BLIP&#xff1a;引导语言图像预训练&#xff0c;实现统一的视觉语言理解和生成 Paper: https://arxiv.org/pdf/2201.12086.pdf Github: https://github.com/sa…
阅读更多...
Ansys workbench连接器端子保持力仿真教程

Ansys workbench连接器端子保持力仿真教程

端子保持力&#xff08;Contact Retention Force&#xff09;是电子连接器机械特性中的常见参数&#xff0c;它表达的是电子连接器&#xff08;Connector&#xff09;端子&#xff08;Contact&#xff09;保持在正常位置的能力。EIA专门为连接器端子保持力的测试制定了标准&…
阅读更多...
输出100~200之间的质数（C语言）

输出100~200之间的质数（C语言）

一、N-S流程图&#xff1b; 二、运行结果&#xff1b; 三、源代码&#xff1b; # define _CRT_SECURE_NO_WARNINGS # include <stdio.h>int main() {//初始化变量值&#xff1b;int n 100;int i 0;int result 0;//嵌套循环判断100~200之间的质数&#xff1b;for (n …
阅读更多...
网络运输层之(3)GRE协议

网络运输层之(3)GRE协议

网络运输层之(3)GRE协议 Author: Once Day Date: 2024年4月8日 一位热衷于Linux学习和开发的菜鸟&#xff0c;试图谱写一场冒险之旅&#xff0c;也许终点只是一场白日梦… 漫漫长路&#xff0c;有人对你微笑过嘛… 全系列文档可参考专栏&#xff1a;通信网络技术_Once-Day的…
阅读更多...
316_C++_xml文件解析成map，可以放到QT表格上， 且 xml、xlsx文件可以互相解析

316_C++_xml文件解析成map，可以放到QT表格上， 且 xml、xlsx文件可以互相解析

xml文件例如&#xff1a; <?xml version"1.0" encoding"UTF-8" standalone"yes"?> <TrTable> <tr id"0" label"TR_PB_CH" text"CH%2"/> <tr id"4" label"TR_PB_CHN"…
阅读更多...
HZNUCTF第五届校赛实践赛初赛 Web方向 WriteUp

HZNUCTF第五届校赛实践赛初赛 Web方向 WriteUp

ezssti 很简单的ssti 源码给了&#xff0c;调用Eval即可执行命令 package mainimport ("fmt""net/http""os/exec""strings""text/template" )type User struct {Id intName stringPasswd string }func (u User) Ev…
阅读更多...
如何在阿里云主机上安装FreeBSD14系统

如何在阿里云主机上安装FreeBSD14系统

文章目录 在阿里云主机上安装FreeBSD14系统准备阿里云云主机识别目标磁盘下载 FreeBSD14解压缩 FreeBSD14系统镜像创建可启动的磁盘启动 FreeBSD14在阿里云主机上安装FreeBSD14系统 阿里云主机不支持 FreeBSD14 系统的镜像，因此需要手动进行安装。 准备阿里云云主机 在阿里云…
阅读更多...
解决Git 不相关的分支合并

解决Git 不相关的分支合并

可以直接调到解决方案,接下来是原因分析和每步的解决方式 问题原因: 我之前在自己本机创建了一个初始化了Git仓库,后来有在另一个电脑初始化仓库,并没有clone自己在本机Git远程仓库地址,导致Git历史版本不相关 错误信息 From https://gitee.com/to-uphold-justice-for-other…
阅读更多...
文字转语音工具：GPT-SoVITS

文字转语音工具：GPT-SoVITS

诸神缄默不语-个人CSDN博文目录 OpenAI官方的TTS模型我在这篇博文中给出了使用教程&#xff1a;ChatGPT 3.5 API的调用不全指南&#xff08;持续更新ing…&#xff09; - 知乎 但是OpenAI的TTS对中文支持不好&#xff0c;有一种老外说中文的美&#xff0c;所以本文介绍另一个…
阅读更多...
Amazon SES邮箱API发送邮件的步骤是什么？

Amazon SES邮箱API发送邮件的步骤是什么？

Amazon SES邮箱API发送邮件怎么配置&#xff1f;如何用邮箱API发送邮件&#xff1f; 在数字化时代&#xff0c;电子邮件已成为企业与个人之间沟通的重要桥梁。那么&#xff0c;使用Amazon SES邮箱API发送邮件的步骤究竟是怎样的呢&#xff1f;接下来&#xff0c;就让AokSend来…
阅读更多...
IDEA远程调试debug

IDEA远程调试debug

IDEA远程调试debug jar包启动脚本配置IDEA配置 通俗的说&#xff1a;本地有代码&#xff0c;服务器项目出现问题&#xff0c;环境的中间件配置不同&#xff0c;用idea远程调试&#xff0c;能快速定位问题&#xff0c;解决问题。 jar包启动脚本配置 jdk5-8写法 java -Xdebug -…
阅读更多...
ChatGPT在遥感领域中的应用

ChatGPT在遥感领域中的应用

遥感技术主要通过卫星和飞机从远处观察和测量我们的环境&#xff0c;是理解和监测地球物理、化学和生物系统的基石。ChatGPT是由OpenAI开发的最先进的语言模型&#xff0c;在理解和生成人类语言方面表现出了非凡的能力。本课程重点介绍ChatGPT在遥感中的应用&#xff0c;人工智…
阅读更多...
MCU的最佳存储方案CS创世 SD NAND

MCU的最佳存储方案CS创世 SD NAND

MCU的最佳存储方案CS创世 SD NAND 写在最前面MCU是什么CS创世 SD NAND 6大优势 写在最前面 转载自 雷龙官网 MCU是什么 大家都知道MCU是一种"麻雀"虽小&#xff0c;却"五脏俱全"的主控。它的应用领域非常广泛&#xff0c;小到手机手表&#xff0c;大到航空…
阅读更多...
【Kafka】Kafka Tool工具的使用

【Kafka】Kafka Tool工具的使用

抖音视频 https://www.douyin.com/user/self?modal_id7123007128150901256&showTablike CSDN文档 https://blog.csdn.net/qq_43961619/article/details/109381849
阅读更多...
Blind Image Super-Resolution: A Survey and Beyond

Blind Image Super-Resolution: A Survey and Beyond

TPAMI2023 问题定义 未知图像的退化过程&#xff08;和之前假定bicubic等一个固定且已知的退化过程相对比&#xff09;&#xff0c;由LR恢复HR&#xff1b;退化来源&#xff08;不同的图像采集设备&#xff0c;数字信号处理成可见图像的过程中图像处理算法引入的噪声&#xff…
阅读更多...
机器学习——模型融合：Stacking算法

机器学习——模型融合：Stacking算法

机器学习——模型融合&#xff1a;Stacking算法 在机器学习中&#xff0c;模型融合是一种常用的方法&#xff0c;它可以提高模型的泛化能力和预测性能。Stacking算法&#xff08;又称为堆叠泛化&#xff09;是一种强大的模型融合技术&#xff0c;它通过组合多个基本分类器的预…
阅读更多...
PyCharm连接数据库代码解析

PyCharm连接数据库代码解析

1.先导入pymysql模块 在PyCharm中用清华镜像快速安装包 依次把ip地址和账号名、密码、数据库名、端口、编码输入 2.创建游标 游标&#xff1a;是数据库中的一个概念&#xff0c;我们执行sql查询语句时&#xff0c;大部分情况都会得到很多条结果&#xff0c;我们取出这些返回结…
阅读更多...
python 无处不在的二分搜索

python 无处不在的二分搜索

我们知道二分查找算法。二分查找是最容易正确的算法。我提出了一些我在二分搜索中收集的有趣问题。有一些关于二分搜索的请求。我请求您遵守准则&#xff1a;“我真诚地尝试解决问题并确保不存在极端情况”。阅读完每个问题后&#xff0c;最小化浏览器并尝试解决它。 …
阅读更多...
数学建模--蒙特卡罗法MATLAB代码保姆式解析

数学建模--蒙特卡罗法MATLAB代码保姆式解析

1.简单介绍 2.思想的实际运用 我们利用蒙特卡罗法的思想求解圆周率π的值&#xff0c;这里求得的肯定是近似值&#xff0c;我们是通过大量的模拟实验&#xff0c;利用概率求解的&#xff0c;但是这个值和我们的精确值之间还是有一定的误差的&#xff1b; 我们的思想就是在半径为…
阅读更多...
【Lattice FPGA 开发】Diamond的使用

【Lattice FPGA 开发】Diamond的使用

文章目录 Diamond的使用教程界面器件查看与更改管脚分配RTL分析图查看 第三方工具关联Notepad 问题与解决管脚被分类到unconnected&#xff0c;导致无法分配管脚 Diamond的使用教程 【Lattice FPGA 开发】Diamond的工程建立、文件输入、ip核配置、管脚配置、综合及布线以及下载…
阅读更多...
最新文章

Copyright @ 2022~2023