Spring框架（1）

Spring框架是Java企业级开发中最受欢迎的框架之一，它通过简化开发流程、降低耦合度，让开发者能够更专注于业务逻辑的实现。本文将带你了解Spring框架的核心概念和基本用法。

一、Spring框架简介

Spring是一个轻量级的开源Java开发框架，由Rod Johnson在2003年创建。它的核心思想是通过控制反转(IOC)和面向切面编程(AOP)来实现松耦合的应用程序设计。

Spring框架的主要优点

  1. 解耦简化开发：Spring就像一个大工厂，管理所有对象的创建和依赖关系

  2. AOP编程支持：方便实现权限拦截、运行监控等功能

  3. 声明式事务管理：通过配置即可完成事务管理，无需手动编程

  4. 易于测试：与Junit良好集成，支持注解测试

  5. 集成优秀框架：支持Struts2、Hibernate、MyBatis等主流框架

  6. 简化JavaEE API：对JDBC、JavaMail等复杂API进行了封装

二、IOC(控制反转)核心概念

IOC(Inversion of Control)是Spring的核心，它将对象的创建权从程序员手中反转给Spring框架管理。

IOC快速入门

添加依赖：在pom.xml中添加Spring核心依赖

<dependencies><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>5.0.2.RELEASE</version></dependency><dependency><groupId>commons-logging</groupId><artifactId>commons-logging</artifactId><version>1.2</version></dependency><dependency><groupId>log4j</groupId><artifactId>log4j</artifactId><version>1.2.12</version></dependency><dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>4.12</version><scope>test</scope></dependency></dependencies>

创建接口和实现类

package com.qcbyjy.service;public interface UserService {public void hello();
}package com.qcbyjy.service;public class UserServiceImpl implements UserService {public void hello(){System.out.println("Hello IOC");}
}

配置Spring核心文件(applicationContext.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"><!--IOC管理bean--><bean id="userService" class="com.qcbyjy.service.UserServiceImpl"/></beans>

把log4j.properties的配置文件拷贝到resources目录下，做为log4j的日志配置 文件。

log4j.rootLogger=INFO, stdout
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %-5p %c{1}:%L - %m%n

测试代码

package com.qcbyjy.test;import com.qcbyjy.service.UserService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;public class Demo1 {@Testpublic void run1(){//使用Spring的工厂ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml","applicationContext2.xml");//通过工厂获得类UserService userService=(UserService) applicationContext.getBean("userService");userService.hello();}
}

ApplicationContext接口，工厂的接口，使用该接口可以获取到具体的Bean对 象。该接口下有两个具体的实现类。

springCould配置中心

ClassPathXmlApplicationContext，加载类路径下的Spring配置文件。 FileSystemXmlApplicationContext，加载本地磁盘下的Spring配置文件。

三、Spring框架的Bean管理的配置文件方式

id属性，Bean起个名字，在约束中采用ID的约束，唯一，取值要求：必须以字 母开始，可以使用字母、数字、连字符、下划线、句话、冒号id:不能出现特殊 字符。

class 属性，Bean 对象的全路径。

scope 属性，scope属性代表Bean的作用范围。

Bean的作用范围

  • singleton：单例(默认)，整个应用只创建一个实例

  • prototype：多例，每次请求都创建一个新实例

  • request：Web应用中，每个HTTP请求创建一个实例

  • session：Web应用中，同一个HTTP Session共享一个实例

Bean 对象的创建和销毁的两个属性配置

说明：Spring初始化bean或销毁bean时，有时需要作一些处理工作，因此spring 可以在创建和拆卸bean的时候调用bean的两个生命周期方法

init-method，当 bean 被载入到容器的时候调用init-method属性指定的方法  

destroy-method，当 bean 从容器中删除的时候调用destroy-method属性指定 的方法

实例化Bean对象的三种方式

默认是无参数的构造方法（默认方式，基本上使用）

<bean id="us" class="com.qcbyjy.service.UserServiceImpl" />

 静态工厂实例化方式

package com.qcbyjy.demo1;import com.qcbyjy.service.UserService;
import com.qcbyjy.service.UserServiceImpl;public class StaticFactory {//静态工厂方式public static UserService createUs(){System.out.println("\"通过静态工厂的方式创建UserServiceImpl对\n" +"象...");//编写很多业务逻辑，权限校验return  new UserServiceImpl();}
}

 <bean id="us" class="com.qcbyjy.demo1.StaticFactory" factory-method="createUs"/>

 实例工厂实例化方式

package com.qcbyjy.demo1;import com.qcbyjy.service.UserService;
import com.qcbyjy.service.UserServiceImpl;public class Dfactory {public UserService createUs(){//动态工厂方式System.out.println("实例化工厂的方式....");return new UserServiceImpl();}
}

 <bean id="dfactory" class="com.qcbyjy.demo1.Dfactory"/><bean id="us" factory-bean="dfactory" factory-method="createUs"/>

四、DI(依赖注入)

DI(Dependency Injection)是IOC的具体实现方式，Spring在创建Bean时，动态地将依赖对象注入到组件中。

三种依赖注入方式

set方法注入（最常用）

package com.qcbyjy.service;public interface OrderService {void saveOrder();
}package com.qcbyjy.service;import com.qcbyjy.dao.OrderDao;public class OrderServiceImpl implements OrderService {private OrderDao orderDao;public void setOrderDao(OrderDao orderDao){this.orderDao=orderDao;}private String msg;private int age;public OrderDao getOrderDao() {return orderDao;}public void setMsg(String msg) {this.msg = msg;}public void saveOrder(){System.out.println("业务层：保存订单..."+msg+"-"+age);//调用orderDao.saveOrder();}public void setAge(int age) {this.age = age;}
}package com.qcbyjy.dao;public interface OrderDao {void  saveOrder();
}

<!--DI：依赖注入--><bean id="os" class="com.qcbyjy.service.OrderServiceImpl"><property name="orderDao" ref="od"/><property name="msg" value="你好"/><property name="age" value="30"/></bean><bean id="od" class="com.qcbyjy.dao.OrderDaoImpl"></bean>

构造方法注入

package com.qcbyjy.demo2;public class Car {private  String cname;private Double money;public  Car(String cname,Double money){this.cname=cname;this.money=money;}@Overridepublic String toString() {return "Car{" +"cname='" + cname + '\'' +", money=" + money +'}';}
}

 <bean id="car" class="com.qcbyjy.demo2.Car"><constructor-arg name="cname" value="大奔"/><constructor-arg name="money" value="400000"/></bean>

数组、集合(List,Set,Map)，Properties 等的注入

package com.qcbyjy.demo3;import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Properties;public class CollectionBean {//数组private String[] strs;public void setStrs(String[] strs){this.strs=strs;}private List<String> list;public void setList(List<String> list){this.list=list;}private Map<String ,String> map;public void setMap(Map<String,String> map){this.map=map;}private Properties properties;public void setProperties(Properties properties){this.properties=properties;}public String toString(){return"CollectionBean{"+"strs="+ Arrays.toString(strs)+",list="+list+",map="+map+",properties="+properties+'}';}
}

 <bean id="collectionBean" class="com.qcbyjy.demo3.CollectionBean"><property name="strs"><array><value>美美</value><value>小凤</value></array></property><property name="list"><list><value>熊大</value><value>熊二</value></list></property><property name="map"><map><entry key="aaa" value="老王"/><entry key="bbb" value="小王"/></map></property><property name="properties"><props><prop key="username">root</prop><prop key="password">123456</prop></props></property></bean>

五、多配置文件方式

在src的目录下又多创建了一个配置文件，现在是两个核心的配置文件，那么加 载这两个配置文件的方式有两种！

//主配置文件中包含其他的配置文件:<import resource="applicationContext2.xml"/>​

//工厂创建的时候直接加载多个配置文件:ApplicationContext applicationContext=new ClassPathXmlApplicationContext( "applicationContext.xml","applicationContext2.xml");

 六、Spring框架开发程序的方式

1.需求：编写service和dao的类，演示代码

2.技术选择：持久层使用原始的JDBC的程序，连接池选择的是Druid连接池。创 建maven工程，导入开发的jar包

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"><modelVersion>4.0.0</modelVersion><groupId>com.qcbyjy</groupId><artifactId>springDemo22</artifactId><version>1.0-SNAPSHOT</version><dependencies><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>5.0.2.RELEASE</version></dependency><dependency><groupId>commons-logging</groupId><artifactId>commons-logging</artifactId><version>1.2</version></dependency><dependency><groupId>log4j</groupId><artifactId>log4j</artifactId><version>1.2.12</version></dependency><dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>4.12</version><scope>test</scope></dependency><!--连接池--><dependency><groupId>com.alibaba</groupId><artifactId>druid</artifactId><version>1.1.10</version></dependency><!--mysql驱动包--><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>8.0.28</version></dependency></dependencies></project>

 创建数据库，创建表结构

create database spring_db;use spring_db;create table account(id int primary key auto_increment,name varchar(40),money double)character set utf8 collate utf8_general_ci;​insert into account(name,money) values('aaa',1000);insert into account(name,money) values('bbb',1000);insert into account(name,money) values('ccc',1000);

 编写JavaBean的类

package com.qcbyjy.domain;import java.io.Serializable;public class Account implements Serializable {private static final long serialVersionUID =7355810572012650248L;private Integer id;private  String name;private  Double money;public Integer getId() {return id;}public void setId(Integer id) {this.id = id;}public String getName() {return name;}public void setName(String name) {this.name = name;}public Double getMoney() {return money;}public void setMoney(Double money) {this.money = money;}@Overridepublic String toString() {return "Account{" +"id=" + id +", name='" + name + '\'' +", money=" + money +'}';}
}

 编写AccountDao的接口和实现类

package com.qcbyjy.dao;import com.qcbyjy.domain.Account;import java.util.List;public interface AccountDao {public List<Account> findAll();
}package com.qcbyjy.dao;import com.qcbyjy.domain.Account;import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;public class AccountDaoImpl implements AccountDao {//注入连接池对象private DataSource dataSource;public  void setDataSource(DataSource dataSource){this.dataSource=dataSource;}
//查询所有数据public List<Account> findAll(){/*DruidDataSourcedataSource=newDruidDataSource();dataSource.setDriverClassName("com.mysql.jdbc.Driver");dataSource.setUrl("jdbc:mysql:///spring_db");dataSource.setUsername("root");dataSource.setPassword("root");*/List<Account> list=new ArrayList<Account>();Connection connection=null;PreparedStatement stmt=null;ResultSet rs=null;try{//获取连接connection=dataSource.getConnection();//编写sql语句String sql="select * from account";//预编译stmt = connection.prepareStatement(sql);//查询rs=stmt.executeQuery();//遍历，封装数据while(rs.next()){Account account=new Account();account.setId(rs.getInt("id"));account.setName(rs.getString("name"));account.setMoney(rs.getDouble("money"));list.add(account);}}catch(SQLException e){e.printStackTrace();}finally{try{connection.close();}catch(SQLException e){e.printStackTrace();}try{stmt.close();}catch(SQLException e){e.printStackTrace();}try{rs.close();}catch(SQLException e){e.printStackTrace();}}return list;}}package com.qcbyjy.service;import com.qcbyjy.domain.Account;import java.util.List;public interface AccountService {public List<Account> findAll();
}package com.qcbyjy.service;import com.qcbyjy.dao.AccountDao;
import com.qcbyjy.domain.Account;import java.util.List;public class AccountServiceImpl implements AccountService {//依赖注入private AccountDao accountDao;public void setAccountDao(AccountDao accountDao){this.accountDao=accountDao;}//查询所有数据public List<Account> findAll() {return accountDao.findAll();}
}

 编写配置文件

<?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 id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"><property name="driverClassName" value="com.mysql.jdbc.Driver"/><property name="url" value="jdbc:mysql:///spring_db"/><property name="username" value="root"/><property name="password" value="12345"/></bean><!--管理bean--><bean id="accountService" class="com.qcbyjy.service.AccountServiceImpl"><property name="accountDao" ref="accountDao"/></bean><bean id="accountDao" class="com.qcbyjy.dao.AccountDaoImpl"><property name="dataSource" ref="dataSource"/></bean>
</beans>

 编程测试程序

package com.qcbyjy.test;import com.qcbyjy.domain.Account;
import com.qcbyjy.service.AccountService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;import java.util.List;public class Demo1 {@Testpublic void run1(){ApplicationContext ac =new ClassPathXmlApplicationContext("applicationContext.xml");AccountService accountService=(AccountService) ac.getBean("accountService");//调用方法List<Account> list=accountService.findAll();for (Account account:list){System.out.println(account);}}
}

七、注解开发

随着Spring的发展，注解方式逐渐取代了XML配置，成为主流开发方式。

快速入门

IOC注解的方式依赖没有变化

编写接口和实现类

package com.qcbyjy.demo1;public interface UserService {public void hello();
}package com.qcbyjy.demo1;import org.springframework.stereotype.Component;/***<beanid="us"class="com.qcbyjy.demo2.UserServiceImpl"/>*/
//组件，作用：把当前类使用IOC容器进行管理，如果没有指定名称，默认使用类名，
//首字母是小写。userServiceImpl。或者自己指定名称
@Component(value="us")
public class UserServiceImpl implements UserService{public void hello(){System.out.println("Hello IOC注解....");}
}

 在需要管理的类上添加@Component注解

@Component(value="us")
public class UserServiceImpl implements UserService{public void hello(){System.out.println("Hello IOC注解....");}
}

 编写配置文件，重点是开启注解扫描。

<?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 http://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-scanbase-package="com.qcbyjy.demo2"/>--><!--开启注解扫描com.qcbyjy.所有的包中的所有的类--><context:component-scan base-package="com.qcbyjy"/>
</beans>

编写测试方法

package com.qcbyjy.test;import com.qcbyjy.demo1.UserService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;public class Demo1 {/***IOC注解方式的入门*/@Testpublic void run1(){//工厂ApplicationContext ac=new ClassPathXmlApplicationContext("applicationContext.xml");UserService userService=(UserService) ac.getBean("us");userService.hello();}}

常用注解

  1. 组件注解（作用相同，推荐分层使用）

    • @Component：普通组件

    • @Controller：表现层

    • @Service：业务层

    • @Repository：持久层

  2. 依赖注入注解

    • @Autowired：按类型自动装配

    • @Qualifier：按名称装配（需与@Autowired配合使用）

    • @Resource：Java原生注解，按名称装配

    • @Value：注入基本类型值

    • @Autowired默认按类型进行自动装配（引用类型）

    • @Qualifier和@Autowired一起使用，强制使用名称注入

    • @ResourceJava提供的注解，也被支持。使用name属性，按名称注入 对象生命周期（作用范围）注解

  3. 作用范围注解

   @Scope：指定作用范围（singleton/prototype等） 

 具体的代码如下

package com.qcbyjy.demo2;import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;import javax.annotation.PostConstruct;//默认当前类名就是ID名称，首字母小写
@Component(value="c")
//@Controller
//@Service(value="c")
//@Repository(value="c")
//@Scope(value="singleton") //默认值，单例的
//@Scope(value="prototype") //多例的
public class Car {//注释注入值，属性set方法是可以省略不写的。//只有一个属性，属性的名称是value，value是可以省略不写的@Value("大奔2")private String cname;@Value(value = "400000")private Double money;//也不用提供set方法//按类型自动装配的注解，和id名称没有关系@Autowired//按id的名称注入，Qualifier不能单独使用，需要Autowired一起使用。//@Qualifier(value="person")//@ResourceJava提供的注解，按名称注入对象，属性名称是name//\@Resource(name="person")private  Person person;/***Car对象创建完成后，调用init方法进行初始化操作*/@PostConstructpublic void init(){System.out.println("操作...");}/*publicStringgetCname(){returncname;}​publicvoidsetCname(Stringcname){this.cname=cname;}​publicDoublegetMoney(){returnmoney;}​publicvoidsetMoney(Doublemoney){this.money=money;}
*/@Overridepublic String toString() {return "Car{" +"cname='" + cname + '\'' +", money=" + money +", person=" + person +'}';}
}package com.qcbyjy.demo2;import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;@Component(value="person")
public class Person {@Value("张三")private String pname;public String toString(){return"Person{"+"pname='"+pname+'\''+'}';}
}package com.qcbyjy.test;import com.qcbyjy.demo2.Car;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;public class Demo2 {@Testpublic void run1(){ApplicationContext ac=new ClassPathXmlApplicationContext("applicationContext.xml");Car car=(Car) ac.getBean("c");System.out.println(car);}
}

纯注解开发示例

纯注解的方式是微服务架构开发的主要方式，所以也是非常的重要。纯注解的目 的是替换掉所有的配置文件。但是需要编写配置类。

编写实体类

package com.qcbyjy.demo3;import org.springframework.stereotype.Component;@Component
public class Order {@Value("北京")private String address;@Overridepublic String toString() {return "Order{" +"address='" + address + '\'' +'}';}
}

编写配置类，替换掉applicationContext.xml配置文件

packagecom.qcbyjy.demo4;​import org.springframework.context.annotation.ComponentScan;import org.springframework.context.annotation.Configuration;​/***Spring的配置类，替换掉applicationContext.xml**///声明当前类是配置类
@Configuration//扫描指定的包结构
@ComponentScan(value="com.qcbyjy.demo4")public class SpringConfig{​}

测试方法的编写

package com.qcbyjy.test;import com.qcbyjy.demo3.Order;
import com.qcbyjy.demo3.SpringConfig;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;public class Demo3 {/***编写程序，需要加载配置类*/@Testpublic void run1(){//创建工厂，加载配置类ApplicationContext ac=new AnnotationConfigApplicationContext(SpringConfig.class);
//获取到对象Order order=(Order) ac.getBean("order");System.out.println(order);}
}

常用的注解总结

@Configuration声明是配置类

@ComponentScan扫描具体包结构的

@Import注解Spring的配置文件可以分成多个配置的，编写多个配置类。用于 导入其他配置类 

package com.qcbyjy.demo3;import org.springframework.context.annotation.Configuration;@Configuration
public class SpringConfig2 {
}package com.qcbyjy.demo3;//声明当前类是配置类
@Configuration
//扫描指定包结构
@ComponentScan(value = "com.qcbyjy.demo3")
//@ComponentScan(value={"com.qcbyjy.demo4","com.qcbyjy.demo3"})
//引入新的配置类
@Import(value={SpringConfig2.class})
public class SpringConfig {}

 @Bean注解只能写在方法上，表明使用此方法创建一个对象，对象创建完成保 存到IOC容器中

package com.qcbyjy.demo3;import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;import javax.sql.DataSource;//声明当前类是配置类
@Configuration
//扫描指定包结构
@ComponentScan(value = "com.qcbyjy.demo3")
//@ComponentScan(value={"com.qcbyjy.demo4","com.qcbyjy.demo3"})
//引入新的配置类
@Import(value={SpringConfig2.class})
public class SpringConfig {/***创建连接池对象，返回对象，把该方法创建后的对象存入到连接池中，使用@Bean注解解决​<!--配置连接池对象--><beanid="dataSource"class="com.alibaba.druid.pool.DruidDataSource"><propertyname="driverClassName"value="com.mysql.jdbc.Driver"/><propertyname="url"value="jdbc:mysql:///spring_db"/><propertyname="username"value="root"/><propertyname="password"value="root"/></bean>**@return*/@Bean(name="dataSource")public DataSource createDataSource(){DruidDataSource dataSource=new DruidDataSource();dataSource.setDriverClassName("com.mysql.jdbc.Driver");dataSource.setUrl("jdbc:mysql:///spring_db");dataSource.setUsername("root");dataSource.setPassword("123456");return dataSource;}}

总结

Spring框架通过IOC和AOP两大核心思想，极大地简化了Java企业级开发。从最初的XML配置到现在的注解驱动开发，Spring不断演进，为开发者提供了更加便捷的开发体验。掌握Spring的基本概念和使用方法，是Java开发者必备的技能。

希望通过本文的介绍，你能对Spring框架有一个清晰的认识，并能够开始在实际项目中使用它。随着实践的深入，你会发现Spring还有更多强大的特性和技巧等待你去探索。

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

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

相关文章

QWindowkit 实现无边框，阴影支持系统边栏缩放等功能

QWindowkit 实现无边框，阴影支持系统边栏缩放等功能

一.感谢作者，QWindowkit 源码地址: GitHub - stdware/qwindowkit: Cross-platform frameless window framework for Qt. Support Windows, macOS, Linux. 二.集成pro工程： QT += core gui greaterThan(QT_MAJOR_VERSION, 4): QT += widgets CONFIG += c++17 # Yo…
阅读更多...
-bash: /usr/local/mysql/bin/mysqld: No such file or directory

-bash: /usr/local/mysql/bin/mysqld: No such file or directory

-bash: /usr/local/mysql/bin/mysqld: No such file or directory 1.Mysql安装常见的报错信息1.1.报错信息1.2.分析问题1.3.解决问题 endl 1.Mysql安装常见的报错信息 1.1.报错信息 [rootRocky9-12 ~]#echo $PATH /root/.local/bin:/root/bin:/usr/local/mysql/bin:/usr/loca…
阅读更多...
【愚公系列】《Manus极简入门》027-数据故事讲述师：“数据叙事魔法师”

【愚公系列】《Manus极简入门》027-数据故事讲述师：“数据叙事魔法师”

&#x1f31f;【技术大咖愚公搬代码&#xff1a;全栈专家的成长之路&#xff0c;你关注的宝藏博主在这里&#xff01;】&#x1f31f; &#x1f4e3;开发者圈持续输出高质量干货的"愚公精神"践行者——全网百万开发者都在追更的顶级技术博主&#xff01; &#x1f…
阅读更多...
PostgreSQL可见性映射VM

PostgreSQL可见性映射VM

1.可见性映射 清理过程的代价高昂&#xff0c;为了减小清理的开销&#xff0c;在PostgreSQL 8.4版中引入了VM。 VM的基本概念很简单。 每个表都拥有各自的可见性映射&#xff0c;用于保存表文件中每个页面的可见性。 页面的可见性确定了每个页面是否包含死元组。清理过程可以…
阅读更多...
LeapVAD：通过认知感知和 Dual-Process 思维实现自动驾驶飞跃——论文阅读

LeapVAD：通过认知感知和 Dual-Process 思维实现自动驾驶飞跃——论文阅读

《LeapVAD: A Leap in Autonomous Driving via Cognitive Perception and Dual-Process Thinking》2025年1月发表&#xff0c;来自浙江大学、上海AI实验室、慕尼黑工大、同济大学和中科大的论文。 尽管自动驾驶技术取得了显著进步&#xff0c;但由于推理能力有限&#xff0c;数…
阅读更多...
二分系列题

二分系列题

1. 搜索插入位置 /*** 查找插入的位置&#xff1a;返回第一个大于等于 target 的索引&#xff1b;* 如果 target 大于所有元素&#xff0c;则返回数组长度&#xff08;即插入到末尾&#xff09;*/ class Solution {public int searchInsert(int[] nums, int target) {int left …
阅读更多...
Octave 简介：一款强大的开源科学计算工具

Octave 简介：一款强大的开源科学计算工具

引言 在科学计算、数据分析和数值模拟的领域&#xff0c;选择合适的工具对于提升工作效率和性能至关重要。虽然市面上有许多选择&#xff0c;但 GNU Octave 作为一款功能强大、开源免费的软件&#xff0c;它在科学计算中脱颖而出。如果你是学生、研究人员或开发者&#xff0c;…
阅读更多...
TI Code Composer Studio编译时SDK报错问题解决

TI Code Composer Studio编译时SDK报错问题解决

1. 我们使用TI的CCS&#xff08;Code Composer Studio&#xff09;编译环境编译工程时&#xff0c;首次安装很可能会遇到编译器找不到SDK的问题。 2. 当CCS编程工具找不到SDK路径时&#xff0c;会有如下报错&#xff1a; Problems窗口提示&#xff1a; Product com.ti.SIMPL…
阅读更多...
MySQL大数据量查询优化

MySQL大数据量查询优化

1.在回表数据量不大的情况下考虑增加索引&#xff0c;如果有多个筛选条件的情况下可以考虑添加联合索引&#xff0c;并且满足最佳左前缀的原则。 2.避免全表查询返回不需要的字段&#xff0c;增加磁盘io的压力 3.大表的分页查询&#xff0c;limit越大效率越低&#xff0c;可以先…
阅读更多...
【Linux网络#5】（UDP的简单应用）DictServer（中译英字典）| ChatServer（简单聊天室）

【Linux网络#5】（UDP的简单应用）DictServer（中译英字典）| ChatServer（简单聊天室）

1.中译英字典 -- DictServer 我们这里先中途插入一个趣味的翻译显示实验&#xff0c;在 EchoServer 的基础上来实现&#xff0c;大部分代码基本都没变&#xff0c;修改了一少部分代码&#xff0c;大家可以仔细看看 先给定一些等会我们要翻译的单词数据 dict.txt apple: 苹果…
阅读更多...
DeepSeek实战--微调

DeepSeek实战--微调

1.为什么是微调 &#xff1f; 微调LLM&#xff08;Fine-tuning Large Language Models&#xff09; 是指基于预训练好的大型语言模型&#xff08;如GPT、LLaMA、PaLM等&#xff09;&#xff0c;通过特定领域或任务的数据进一步训练&#xff0c;使其适应具体需求的过程。它是将…
阅读更多...
FTP/TFTP/SSH/Telnet

FTP/TFTP/SSH/Telnet

目录 一、FTP&#xff08;文件传输协议&#xff09; 定义 工作原理 特点 应用场景 二、TFTP&#xff08;简单文件传输协议&#xff09; 定义 工作原理 特点 应用场景 三、SSH&#xff08;安全外壳协议&#xff09; 定义 工作原理 特点 应用场景 四、Telnet&…
阅读更多...
K8S常见问题汇总

K8S常见问题汇总

一、 驱逐 master 节点上的所有 Pod 这会“清空”一个节点&#xff08;包括 master&#xff09;上的所有可驱逐的 Pod&#xff1a; kubectl drain <master-node-name> --ignore-daemonsets --delete-emptydir-data--ignore-daemonsets&#xff1a;保留 DaemonSet 类型的…
阅读更多...
【银河麒麟高级服务器操作系统】服务器外挂存储ioerror分析及处理分享

【银河麒麟高级服务器操作系统】服务器外挂存储ioerror分析及处理分享

更多银河麒麟操作系统产品及技术讨论&#xff0c;欢迎加入银河麒麟操作系统官方论坛 forum.kylinos.cn 了解更多银河麒麟操作系统全新产品&#xff0c;请点击访问 麒麟软件产品专区&#xff1a;product.kylinos.cn 开发者专区&#xff1a;developer.kylinos.cn 文档中心&a…
阅读更多...
C++命名空间、内联与捕获

C++命名空间、内联与捕获

命名空间namespace 最常见的命名空间是std，你一定非常熟悉，也就是： using namespace std;命名空间的基本格式 注意，要在头文件里面定义！ namespace namespace_name{data_type function_name(data_type parameter){data_type result;//function contentreturn result;}…
阅读更多...
软件测试名词科普：驱动模块、桩模块

软件测试名词科普：驱动模块、桩模块

目录 1. 驱动模块 2. 桩模块​ 3. 驱动模块 vs 桩模块 对比表 4. 示例代码 在软件测试中&#xff0c;​驱动模块&#xff08;Driver Module&#xff09;​和桩模块&#xff08;Stub Module&#xff09;​是两种用于单元测试的关键组件&#xff0c;主要用于模拟测试环境中的…
阅读更多...
线程池的核心参数和线程创建方式，线程和进程

线程池的核心参数和线程创建方式，线程和进程

Java线程池的核心参数 Java线程池通过ThreadPoolExecutor类进行配置&#xff0c;其核心参数如下&#xff1a; corePoolSize&#xff08;核心线程数&#xff09; 作用&#xff1a;线程池中保持活动的最小线程数&#xff0c;即使这些线程处于空闲状态。 行为&#xff1a;默认情…
阅读更多...
【报错】view size is not compatible with input tensor‘s size and stride

【报错】view size is not compatible with input tensor‘s size and stride

完整报错 Traceback (most recent call last): File "D:\360MoveData\Users\HONOR\whu\TwoStageTraining.py", line 590, in <module> criterionseg_criterion, save_dir./models, writerwriter_first_stage) File "D:\360MoveData\Users\HONOR\whu\TwoS…
阅读更多...
汽车免拆诊断案例｜车辆行驶中急加速车身抖动故障排除 2 例

汽车免拆诊断案例｜车辆行驶中急加速车身抖动故障排除 2 例

案例1　2017款丰田卡罗拉车行驶中急加速车身偶尔抖动 故障现象　 一辆 2017款丰田卡罗拉车&#xff0c;搭载9NR 发动机&#xff0c;累计行驶里程约为9.6万km。车主进厂反映&#xff0c;该车行驶中急加速时&#xff0c;车身偶尔抖动。 故障诊断　 接车后试车&#xff0c;发动机…
阅读更多...
vue3 computed方法使用详细讲解

vue3 computed方法使用详细讲解

Computed方法用于创建计算属性&#xff0c;它的值由其他响应式数据计算得出&#xff0c;并且会在依赖数据发生改变时自动更新。因为vue3兼容vue2的选项式api,所以习惯用vue2的小伙伴可以直接用vue2的方法写是没有问题的。但我这里介绍的是computed在vue3中的新语法&#xff1a;…
阅读更多...
最新文章

Copyright @ 2022~2023