spring（上）

news2025/1/17 6:16:29

spring是于2003年兴起的一款轻量级的，非侵入式的IOC和AOP的一站式的java开发框架，为简化企业级应用开发而生
轻量级的：指的是spring核心功能的jar包不大。
非侵入式的：业务代码不需要继承或实现spring中任何的类或接口
IOC：控制反转（Inverse of Control），以前项目都是在哪儿用到对象，在哪儿new，把生成对象的权利反转给spring框架（让spring把对象管理起来，在哪用在哪注入）
AOP：面向切面编程。AOP 是一种编程思想，是面向对象编程（OOP）的一种补充。面向对象编程将程序抽象成各个层次的对象，而面向切面编程是将程序抽象成各个切面。
一站式框架：

  • 提供核心功能，主要是IOC，创建管理对象；
  • 提供面向切面编程，增强程序扩展；
  • 对数据访问层进行了封装(重点在于事务管理)
  • 对web层进行封装，使得请求更加便捷

Spring Hello World搭建

1.Maven 导入 spring 核心基础 jar

<!-- spring-context -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.2.2.RELEASE</version>
</dependency>

2.编写一个Admin实体类

package com.ffyc.ssm.model;

public class Admin {
    private Integer id;
    private String account;

    public Admin() {
        System.out.println("admin无参构造");
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getAccount() {
        return account;
    }

    public void setAccount(String account) {
        this.account = account;
    }
}

3.编写 spring 配置文件，在resources/spring.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">
    <!--配置需要让spring进行管理的类-->
    <bean id="admin" class="com.ffyc.ssm.model.Admin"></bean>
</beans>

4.测试spring
读取spring配置文件，并对文件中配置的对象进行创建

package com.ffyc.ssm.test;

public class Test1 {
    public static void main(String[] args) {
        /*以前使用对象方式,在哪儿用,在哪儿new
        new Admin();
        spring思想是,由框架统一对项目中的类进行管理(创建对象,后期增强一些功能),在需要的地方注入即可*/
        //Map(admin,new Admin)
        //ClassPathXmlApplicationContext就是spring中的实际实现者
        ClassPathXmlApplicationContext app=new ClassPathXmlApplicationContext("spring.xml");
        //Object admin=app.getBean("admin");//不知道返回的类型,从Map中拿出new Admin对象
        Admin admin=app.getBean("admin",Admin.class);//明确类型
        System.out.println(admin);
    }
}

IOC(控制反转)

正控：若要使用某个对象，需要自己去负责对象的创建
反控：若要使用某个对象，只需要从 Spring 容器中获取需要使用的对象，不关心对象的创建过程，也就是把创建对象的控制权反转给了 Spring 框架
**底层实现方式：**解析 xml/扫描注解标签 + 工厂模式 + 反射机制

Spring Bean 管理

1、基于 xml 配置方式

配置需要让spring进行管理的类
id=“唯一的标识”
class=“让spring管理的类名”
bean对象？由spring框架创建并管理的对象

  • Scope=“singleton 默认值”，单例的，在整个应用程序中只创建一个对象，在spring框架启动时就创建好了
  • scope=“prototype”，原型的，每次获取时创建一个对象，可以创建多个
<?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">
    <!--配置需要让spring进行管理的类-->
    <bean id="admin" class="com.ffyc.ssm.model.Admin" scope="prototype"></bean>
</beans>

public class Test1 {
    public static void main(String[] args) {
        //读取spring配置文件,并对文件中配置的对象进行创建
        //ClassPathXmlApplicationContext就是spring中的实际实现者
        ClassPathXmlApplicationContext app=new ClassPathXmlApplicationContext("spring.xml");
        Admin admin=app.getBean("admin",Admin.class);
        Admin admin1=app.getBean("admin",Admin.class);
        System.out.println(admin);
        System.out.println(admin1);
    }
}
/*
admin无参构造
admin无参构造
com.ffyc.ssm.model.Admin@685cb137
com.ffyc.ssm.model.Admin@6a41eaa2
*/

spring框架创建对象（控制反转）时，为对象的属性进行赋值操作（这个赋值操作称为依赖注入）
1.属性赋值 getXXX、setXXX方法

<bean id="admin" class="com.ffyc.ssm.model.Admin" scope="prototype">
    <property name="id" value="10"></property>
    <property name="account" value="张三"></property>
</bean>

public class Test1 {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext app=new ClassPathXmlApplicationContext("spring.xml");
        Admin admin=app.getBean("admin",Admin.class);
        System.out.println(admin);
    }
}
/*
admin无参构造
Admin{id=10, account='张三'}
*/

2.构造方法赋值

<bean id="admin" class="com.ffyc.ssm.model.Admin" scope="prototype">
    <constructor-arg name="id" value="1"></constructor-arg>
    <constructor-arg name="account" value="1"></constructor-arg>
</bean>

public class Test1 {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext app=new ClassPathXmlApplicationContext("spring.xml");
        Admin admin=app.getBean("admin",Admin.class);
        System.out.println(admin);
    }
}
//Admin{id=1, account='1'}

在一个方法中注入另一个方法

<bean id="admin" class="com.ffyc.ssm.model.Admin" scope="prototype">
    <constructor-arg name="id" value="1"></constructor-arg>
    <constructor-arg name="account" value="1"></constructor-arg>
</bean>
<bean id="adminDao" class="com.ffyc.ssm.dao.AdminDao"></bean>
<bean id="adminService" class="com.ffyc.ssm.service.AdminService">
    <property name="adminDao" ref="adminDao"></property> <!--在adminService中注入adminDao-->
</bean>

public class Test2 {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext app=new ClassPathXmlApplicationContext("spring.xml");
        Admin admin=app.getBean("admin",Admin.class);
        AdminService adminService=app.getBean("adminService",AdminService.class);
        adminService.save(admin);
    }
}

2、注解方式实现（建议）

1、注解需要的jar包
注解功能封装在AOP包中，导入 Spring aop jar 包即可

<!-- spring-context -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.2.2.RELEASE</version>
</dependency>

2、开启注解扫描

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">

    <!--开启注解扫描,包名范围尽可能大一些-->
    <context:component-scan base-package="com.ffyc.ssm"> </context:component-scan>
</beans>

3、注解创建对象
有注解标签才是spring管理的对象，并创建对象
1.@Component(value = “admin”) 一般用于模型类，等同于
2.@Scope(value=“prototype”) 原型(多次)
@Scope(value=“singleton”) 单例(一次)

@Component(value = "admin")
@Scope(value = "singleton")

3.@Repository(value = “adminDao”)，用于dao层

@Repository(value = "adminDao")
public class AdminDao {
    public void saveAdmin(Admin admin){
        System.out.println("保存管理员"+admin);
    }
}

4.@Service(value = “adminService”)
5.@Autowired，spring框架提供的一种自动注入的注解标签，可以写在字段和 setter 方法上。如果写在字段上，那么就不需要再写 setter 方法。默认情况下它要求依赖对象必须存在，如果允许 null 值，可以设置它的 required 属性为 false。
有两种方式去查找对象:

  • byType，去spring容器中根据当前类型搜索，@Autowired
  • byName，通过名称查找，需要结合 @Qualifier(value=“adminDao”)，value值和@Repository(value = “adminDao”)里面的value对应
    6.@Resource，是jdk中提供的一个注解标签
  • byType，去spring器中根据当前类型搜索，@Resource
  • byName，通过名称查找,@Resource(name = “adminDao”)
    Autowired(required=true)，注入时，对象值不能为空，为空报错
@Service(value = "adminService")
public class AdminService {
    /*@Autowired
     @Qualifier(value = "adminDao")
    AdminDao adminDao;//依赖注入*/
    
    //@Resource
    @Resource(name = "adminDao")
    AdminDao adminDao;

    public void save(Admin admin){
        adminDao.saveAdmin(admin);
    }
}

public class Test3 {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext app=new ClassPathXmlApplicationContext("spring.xml");
        Admin admin=app.getBean("admin",Admin.class);
        AdminService adminService=app.getBean("adminService",AdminService.class);
        adminService.save(admin);
    }
}

3、注解与 XML 的对比

注解优点： 方便、直观、高效（代码少，没有配置文件的书写那么复杂）。
**注解缺点：**以硬编码的方式写入到 Java 代码中，修改是需要重新编译代码的（通过maven把项目重新编译compile一下）。
xml 优点是： 配置和代码是分离的，在 xml 中做修改，无需编译代码，只需重启服务器即可将新的配置加载。
**xml 缺点是：**编写麻烦，效率低，大型项目过于复杂

Spring JDBC

spring框架中的JDBC功能

  1. jdbc封装: JdbcTemplate(了解即可 后面常用mybatis)，事务管理(重点)
  2. ioc实际的应用
    Spring 是个一站式框架：Spring 自身也提供了控制层的 SpringMVC 和 持久层的 Spring JdbcTemplate。
    1.下载 Spring JdbcTemplate 的 jar 包
    导入jdbc模块依赖
<!-- spring-jdbc -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.2.2.RELEASE</version>
</dependency>

导入mysql

<!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.16</version>
</dependency>

导入阿里巴巴提供的数据源管理组件，数据源组件封装了连接数据库，还有数据库连接池功能
druid(德鲁伊)，常用的数据库链接池组件：dbcp、c3p0

<!-- 阿里的数据源 -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.10</version>
</dependency>

2.config.properties

classDriverName=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://127.0.0.1:3306/ssmdb?serverTimezone=Asia/Shanghai
uname=root
pwd=123456

3.db.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"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">

    <!--配置jdbc功能-->
    <!--负责加载config.properties文件-->
    <context:property-placeholder location="classpath:config.properties"></context:property-placeholder>
    <!--spring统一管理数据库链接对象,创建对象并赋值-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${classDriverName}"></property>
        <property name="url" value="${url}"></property>
        <property name="username" value="${uname}"></property>
        <property name="password" value="${pwd}"></property>
        <property name="initialSize" value="5"></property>
        <property name="maxActive" value="10"></property>
    </bean>
    <!--创建spring框架封装的jdbc功能的实现类-->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"></property>  <!--注入数据源对象-->
    </bean>
    <!--以后引入mybatis，需要数据源对象，直接注入即可-->
</beans>

4.spring.xml注解db.xml

<import resource="classpath:db.xml"></import> <!--指的是target/classes下的-->

增删改用update

@Repository(value = "adminDao")
public class AdminDao {
    @Autowired
    JdbcTemplate jdbcTemplate;
    
   public void saveAdmin(Admin admin){
        //jdbcTemplate.update("insert into admin(account,password)value(?,?)","aaa","111");
        jdbcTemplate.update("delete from admin where id =?","5");
    }
}

查询，返回单个结果

public void saveAdmin(Admin admin){
    Admin admin2=jdbcTemplate.queryForObject("select * from admin where id=?",
            new RowMapper<Admin>() {
                @Override
                public Admin mapRow(ResultSet resultSet, int i) throws SQLException {
                    Admin admin1=new Admin();
                    admin1.setId(resultSet.getInt("id"));
                    admin1.setAccount(resultSet.getString("account"));
                    return admin1;
                }
            },1);
    System.out.println(admin2);
}

查询，返回多个结果

public void saveAdmin(Admin admin){
    List<Admin> adminList=jdbcTemplate.query("select * from admin",
            new RowMapper<Admin>() {
                @Override
                public Admin mapRow(ResultSet resultSet, int i) throws SQLException {
                    Admin admin1=new Admin();
                    admin1.setId(resultSet.getInt("id"));
                    admin1.setAccount(resultSet.getString("account"));
                    return admin1;
                }
            });
    System.out.println(adminList);
}

AOP

不使用 AOP 的开发方式

案例：
先定义好接口与一个实现类，该实现类中除了要实现接口中的方法外，还要写两个非业务方法。非业务方法也称为交叉业务逻辑：

  • doTransaction()：用于事务处理
  • doLog()：用于日志处理
    然后，再使接口方法调用它们。接口方法也称为主业务逻辑.
    在这里插入图片描述
    在方法中想要实现额外功能时,需要在业务代码中显示调用.
    在这里插入图片描述
    即使抽取一个工具类,将这些方法封装起来,依然还是需要显示调用.
    在这里插入图片描述

AOP概述

AOP 为 Aspect Oriented Programming 的缩写，意为：面向切面编程，AOP 可以**对业务逻辑和非业务逻辑进行隔离，从而使得各部分之间的耦合度降低，提高程序的可重用性，**同时提高了开发的效率。将程序中的一些非业务代码进行提取，在不需要修改原来代码的情况下，为程序添加额外的功能。
AOP思想不是spring框架特有的，只是spring框架引入使用了这一思想。
面向切面编程的好处就是: 减少重复,专注业务；
注意：面向切面编程只是面向对象编程的一种补充。
核心原理： 使用动态代理的方式在执行方法前后或者出现异常的时候做加入相关的逻辑.
非业务代码使用案例:

  • 事务处理：开启事务，关闭事务，出现异常后回滚事务
  • 验证权限：在执行方法前，判断是否具有权限
  • 打印日志：在执行前进行日志处
  • 统一异常处理
    在这里插入图片描述
    是怎么做到的？底层实现：使用的是动态代理模式。是通过一个代理对象来实现对非业务代码进行调用的。告诉代理对象，调用哪个方法时，让代理对象去帮助我们调用哪个方法
    代理对象(相当于4s 中介 手机店)

AOP的基本概念

**连接点（Joinpoint）：**类中可以被增强的方法
**切入点（pointcut）：**类中有很多方法可以被增强，但实际中只有 add 和 update被增了，那么 add 和 update 方法就被称为切入点（类中实际被增强的方法）
通知（Advice）： 指提取的非业务的功能。通知分为：前置通知、后置通知、异常通知、最终通知、环绕通知
**切面（Aspect）：**把通知添加到切入点的整个过程
目标（Target）： 代理的目标对象(连接点,切入点所在类AdminDao)
代理（Proxy）： 向目标对象应用通知时创建的代理对象

springAOP实现

有两种实现方式：1.xml配置方式 2.注解方式

1、xml配置方式

对于 AOP 这种编程思想，很多框架都进行了实现。Spring 就是其中之一，可以完成面向切面编程。
AspectJ 是一个基于 Java 语言的 AOP 框架，它提供了强大的 AOP 功能，且其实现方式更为简捷，使用更为方便， 而且还支持注解式开发。所以，spring中引入了一个AspectJ的aop框架.
下载 AOP 相关 jar

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aspects</artifactId>
    <version>5.2.2.RELEASE</version>
</dependency>

<!--spring.xml中-->
<import resource="classpath:aopDemo.xml"></import>

基于 aspectj 的 xml 配置方式实现。
先把类交给spring管理，这样spring生成的代理对象才可以调用

<!--aopDemo.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"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">

    <!--把非业务代码(通知) 交给spring框架管理,以后要用到这个类的方法,就把myutil注入-->
    <bean id="myutil" class="com.ffyc.ssm.util.MyUtil"></bean>

    <aop:config>
        <!--配置切入点-->
        <aop:pointcut id="saveAdmin" expression="execution(* com.ffyc.ssm.dao.AdminDao.saveAdmin(..))"/>
        <!--将通知与切入点进行配置,生成的代理对象就知道如何调用-->
        <aop:aspect ref="myutil">
            <!--前置通知：先输出通知在执行方法-->
            <aop:before method="printLog" pointcut-ref="saveAdmin"></aop:before>
        </aop:aspect>
    </aop:config>
</beans>

package com.ffyc.ssm.util;
   /* 提取的非业务的功能称为通知
    通知又分为5种: 前置通知、后置通知、异常通知、最终通知、环绕通知*/
public class MyUtil {
    public void printLog(){
        System.out.println("打印日志");
    }
    public void commit(){
        System.out.println("提取事务");
    }
    public void exceptionAdvice(Throwable e){
        System.out.println("异常通知"+e.getMessage());
    }
}

package com.ffyc.ssm.dao;

@Repository(value = "adminDao")
//目标类
public class AdminDao {
    @Autowired
    JdbcTemplate jdbcTemplate;

    /*连接点:类中可以被增强的方法,称为连接点
    切入点: 类中实际被增强的方法,横切面切入的方法*/

    public void saveAdmin(Admin admin){
        System.out.println("保存管理员");
    }

    public void updateAdmin(Admin admin){
        System.out.println("修改管理员");
    }
}

public class Test3 {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext app=new ClassPathXmlApplicationContext("spring.xml");
        Admin admin=app.getBean("admin",Admin.class);
        AdminService adminService=app.getBean("adminService",AdminService.class);
        adminService.save(admin);
    }
}

在这里插入图片描述
通知又分为5种:
前置通知：业务方法执行前调用
后置通知(after-returning)：业务方法执行后调用，当方法出现异常不执行
异常通知 (after-throwing)：业务方法出现异常时调用
最终通知(after)：业务方法执行后调用，当方法出现异常也会执行
环绕通知，环绕通知包含前四种通知

package com.ffyc.ssm.util;

public class MyUtil {
    /*ProceedingJoinPoint需要调用的方法*/
    public void aroundAdvice(ProceedingJoinPoint point){
        try {
            System.out.println("前置通知");
            point.proceed();//调用我们自己的业务方法
            System.out.println("后置通知");
        } catch (Throwable throwable) {
            throwable.printStackTrace();
            System.out.println("异常通知"+throwable.getMessage());
        }
        System.out.println("最终通知");
    }
}

<aop:config>
    <!--配置切入点-->
    <aop:pointcut id="saveAdmin" expression="execution(* com.ffyc.ssm.dao.AdminDao.saveAdmin(..))"/>
    <!--将通知与切入点进行配置,生成的代理对象就知道如何调用-->
    <aop:aspect ref="myutil">
        <aop:around method="aroundAdvice" pointcut-ref="saveAdmin"></aop:around>
    </aop:aspect>
</aop:config>
2、注解方式的实现

1.开启自动代理

<!--spring.xml中开启自动代理-->
<aop:aspectj-autoproxy />

2.@Component //让spring管理生成对象
@Aspect //表明装有通知的类/切面

package com.ffyc.ssm.util;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

@Component //让spring管理生成对象
@Aspect  //表明装有通知的类/切面
public class MyUtil {
    //@Before("execution(* com.ffyc.ssm.dao.AdminDao.saveAdmin(..))")
    //@AfterReturning("execution(* com.ffyc.ssm.dao.AdminDao.saveAdmin(..))")
    //@After("execution(* com.ffyc.ssm.dao.AdminDao.saveAdmin(..))")
    public void printLog(){
        System.out.println("打印日志");
    }
    public void commit(){
        System.out.println("提取事务");
    }
    //@AfterThrowing(value = "execution(* com.ffyc.ssm.dao.AdminDao.saveAdmin(..))",throwing = "e")
    public void exceptionAdvice(Throwable e){
        System.out.println("异常通知"+e.getMessage());
    }
    
    /*ProceedingJoinPoint需要调用的方法*/
    @Around("execution(* com.ffyc.ssm.dao.AdminDao.saveAdmin(..))")
    public void aroundAdvice(ProceedingJoinPoint point){
        try {
            System.out.println("前置通知");
            point.proceed();//调用我们自己的业务方法
            System.out.println("后置通知");
        } catch (Throwable throwable) {
            throwable.printStackTrace();
            System.out.println("异常通知"+throwable.getMessage());
        }
        System.out.println("最终通知");
    }
}

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

利用Python隧道爬虫ip轻松构建全局爬虫网络

利用Python隧道爬虫ip轻松构建全局爬虫网络

嘿&#xff0c;爬虫程序员们&#xff01;你们有没有碰到过需要大规模数据爬取的情况&#xff1f;也许你们之前遇到过网站的反爬措施&#xff0c;卡住你们的进度。别担心&#xff0c;今天我来分享一个利用Python隧道爬虫ip实现的方法&#xff0c;帮助你们轻松搭建全局爬虫ip网络…
阅读更多...
Socks5代理在多线程爬虫中的应用

Socks5代理在多线程爬虫中的应用

在进行爬虫开发过程中&#xff0c;我们常常需要处理大量的数据&#xff0c;并执行多任务并发操作。然而&#xff0c;频繁的请求可能会引起目标网站的反爬机制&#xff0c;导致IP封禁或限制访问。为了规避这些限制&#xff0c;我们可以借助Socks5代理的强大功能&#xff0c;通过…
阅读更多...
【正点原子STM32连载】第六章 认识Geehy标准库 摘自【正点原子】APM32F407最小系统板使用指南

【正点原子STM32连载】第六章 认识Geehy标准库 摘自【正点原子】APM32F407最小系统板使用指南

1&#xff09;实验平台&#xff1a;正点原子stm32f103战舰开发板V4 2&#xff09;平台购买地址&#xff1a;https://detail.tmall.com/item.htm?id609294757420 3&#xff09;全套实验源码手册视频下载地址&#xff1a; http://www.openedv.com/thread-340252-1-1.html# 第六…
阅读更多...
tk切换到mac的code分享

tk切换到mac的code分享

文章目录 前言一、基础环境配置二、开发软件与扩展1.用到的开发软件与平替、扩展情况 总结 前言 最近换上了coding人生的第一台mac&#xff0c;以前一直偏好tk&#xff0c;近来身边的朋友越来越多的用mac了&#xff0c;win的自动更新越来越占磁盘了&#xff0c;而且win11抛弃了…
阅读更多...
c语言每日一练(8)

c语言每日一练(8)

前言&#xff1a;每日一练系列&#xff0c;每一期都包含5道选择题&#xff0c;2道编程题&#xff0c;博主会尽可能详细地进行讲解&#xff0c;令初学者也能听的清晰。每日一练系列会持续更新&#xff0c;暑假时三天之内必有一更&#xff0c;到了开学之后&#xff0c;将看学业情…
阅读更多...
Stream流之reduce操作用法

Stream流之reduce操作用法

Stream流之reduce操作用法 三种用法 1 Optional<T> reduce(BinaryOperator<T> accumulator);2 T reduce(T identity, BinaryOperator<T> accumulator);3 <U> U reduce(U identity,BiFunction<U, ? super T, U> accumulator,BinaryOperator<…
阅读更多...
怎么提取人声消除背景音乐？教你提取人声方法

怎么提取人声消除背景音乐？教你提取人声方法

音频文件中通常会包含大量的背景音乐或噪音&#xff0c;这些噪音会影响人们对于音频内容的理解和感受。因此&#xff0c;提取出音频中的人声对于音频后期处理和相关应用非常重要。提取出音频中的人声可以用于进一步的音频处理&#xff0c;例如进行混音&#xff0c;让人声更加突…
阅读更多...
UE4 Cesium 制作指定形状水域

UE4 Cesium 制作指定形状水域

找到该文件&#xff0c;复制它到项目目录中 找到该文件&#xff0c;同时也复制到项目目录中 如图所示 加这几个变量可以控制水体流动以及流速 加上Cesium Cartographic Polygon 拖动图中四个点&#xff0c;按住Alt&#xff0c;可以新增白色节点 在Cesium3DTileset内&#xff0…
阅读更多...
拒绝摆烂！C语言练习打卡第二天

拒绝摆烂！C语言练习打卡第二天

&#x1f525;博客主页&#xff1a;小王又困了 &#x1f4da;系列专栏&#xff1a;每日一练 &#x1f31f;人之为学&#xff0c;不日近则日退 ❤️感谢大家点赞&#x1f44d;收藏⭐评论✍️ 目录 一、选择题 &#x1f4dd;1.第一题 &#x1f4dd;2.第二题 &#x1f4dd;…
阅读更多...
【OFDM系列】DFT为什么能求频率幅度谱？DFT后的X[k]与x(n)幅度的关系？DFT/IDFT底层数学原理？

【OFDM系列】DFT为什么能求频率幅度谱？DFT后的X[k]与x(n)幅度的关系？DFT/IDFT底层数学原理？

文章目录 问题引入铺垫一些小公式DFT公式证明DFT公式分解为4部分先考虑k10的情况:再考虑k1≠0的情况: DFT计算后&#xff0c;X(k)与x(n)的关系&#xff1a; Matlab FFT示例代码IDFT公式证明Matlab调用FFT/IFFT并绘图 问题引入 上面是DFT和IDFT的公式&#xff0c;IDFT先不谈。在…
阅读更多...
使用原生小程序组件Picker自定义日期时间选择器

使用原生小程序组件Picker自定义日期时间选择器

使用原生小程序组件Picker自定义日期时间选择器 1、 Picker简单介绍 可以看到Picker类型有5种&#xff0c; 具体可以查看微信开放文档 picker。 Picker&#xff08;选择器&#xff09;是一种常见的用户界面控件&#xff0c;用于从多个选项中选择一个或多个选项。在小程序中&…
阅读更多...
2023开学季买什么电容笔好？推荐好用不贵的电容笔

2023开学季买什么电容笔好？推荐好用不贵的电容笔

眼见开学季马上就要来了&#xff0c;那么该选哪款电容笔比较好呢&#xff1f;一款苹果原装pencil的售价&#xff0c;已经达到了近千元&#xff0c;这个价格&#xff0c;在许多人看来&#xff0c;实在是太高了。其实&#xff0c;因为平替电容笔价格很实惠&#xff0c;只需一两百…
阅读更多...
flutter 中的动画详解 全网最全 动画一篇搞定 一万四千字

flutter 中的动画详解 全网最全 动画一篇搞定 一万四千字

flutter 中的动画详解 全网最全 动画一篇搞定 前言一、 基础概念二、 隐式动画三、 显示动画四、 过渡五、 手势动画六、 复杂动画七、 自定义动画八、 物理动画九、 Flutter 动画库十、 动画性能和优化十一、 第三方动画库总结 前言 学习 Flutter 中的动画和过渡是构建流畅用户…
阅读更多...
问道管理：2018年以来最低水平，A股质押风险大幅缓解

问道管理：2018年以来最低水平，A股质押风险大幅缓解

2018年A股质押巅峰期之后&#xff0c;金融监管“组合拳”继续发力&#xff0c;多地政府及金融安排活跃参加纾困&#xff0c;上市公司股票质押危险化解取得本质成效。A股上市公司现在质押股数量、质押市值、质押份额均降至2018年以来最低水平。 股权质押融资是出质人将股权作为质…
阅读更多...
CentOS系统环境搭建（十四）——CentOS7.9安装elasticsearch-head

CentOS系统环境搭建（十四）——CentOS7.9安装elasticsearch-head

centos系统环境搭建专栏&#x1f517;点击跳转 关于node的安装请看上一篇CentOS系统环境搭建&#xff08;十三&#xff09;——CentOS7安装nvm&#xff0c;&#x1f517;点击跳转。 CentOS7.9安装elasticsearch-head 文章目录 CentOS7.9安装elasticsearch-head1.下载2.解压3.修…
阅读更多...
0基础学习VR全景平台篇 第85篇：智慧眼-如何分配角色的权限？

0基础学习VR全景平台篇 第85篇：智慧眼-如何分配角色的权限？

一、功能说明 角色权限&#xff0c;是指给智慧眼的所有角色成员分配具体的操作权限。 二、后台编辑界面 1、点击“添加权限”&#xff0c;选择其可操作的“权限”。注意权限只能逐项选择&#xff0c;所以如果某个角色拥有多项权限的话&#xff0c;那么需要进行多次添加。“快…
阅读更多...
Threejs学习02——使用dat.gui实现主动控制立方体相关操作

Threejs学习02——使用dat.gui实现主动控制立方体相关操作

使用dat.gui实现主动控制立方体相关操作 这是一个非常简单基础的threejs的学习应用&#xff01;在上一章学习threesj中我们实现立方体在坐标轴中来回移动&#xff0c;那都是通过我们的代码写死的效果&#xff0c;然后立方体的颜色都是通过代码写死的&#xff0c;这一章我们来给…
阅读更多...
从零开始学习 Java：简单易懂的入门指南之MAth、System（十二）

从零开始学习 Java：简单易懂的入门指南之MAth、System（十二）

常见API&#xff0c;MAth、System 1 Math类1.1 概述1.2 常见方法1.3 算法小题(质数)1.4 算法小题(自幂数) 2 System类2.1 概述2.2 常见方法 1 Math类 1.1 概述 tips&#xff1a;了解内容 查看API文档&#xff0c;我们可以看到API文档中关于Math类的定义如下&#xff1a; Math类…
阅读更多...
大数据大数据架构发展史

大数据大数据架构发展史

1.背景 随着数据量的暴增和数据实时性要求越来越高&#xff0c;以及大数据技术的发展驱动企业不断升级迭代&#xff0c;传统数仓经历了以下发展过程&#xff1a;传统数仓架构 -> 离线大数据架构 -> Lambda架构 -> Kappa架构 -> 新一代实时数仓。&#xff08;大部分…
阅读更多...
Vitis高层次综合学习——FPGA

Vitis高层次综合学习——FPGA

高层次综合 什么是高层次综合&#xff1f;就是使用高级语言&#xff08;如C/C&#xff09;来编写FPGA算法程序。 在高层次综合上并不需要制定微架构决策&#xff0c;如创建状态机、数据路径、寄存器流水线等。这些细节可以留给 HLS 工具&#xff0c;通过提供输入约束&#xff…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023