当前位置： 首页 > news >正文

Spring框架（一）

news 来源：原创 2025/5/14 5:26:11

        Spring框架是Java开发中最为流行的框架之一，它以其强大的功能和灵活的设计，极大地简化了企业级应用的开发。本文将详细介绍Spring框架的核心概念、核心技术、依赖注入、多配置文件方式、开发程序的方式、IOC注解方式以及Spring与JUnit的整合。

目录

一、Spring框架概述

1.1 Spring框架的概述

1.2 Spring框架的优点

二、Spring的IOC核心技术

2.1 什么是IOC

2.2 IOC的程序入门

2.3 IOC技术总结

2.4 实例化Bean对象的三种方式

三、DI依赖注入

3.1 依赖注入的概述

3.2 DI的两种方式

3.3 复杂类型注入（数组，集合，Properties）

四、多配置文件管理

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

六、IOC注解开发

6.1 半注解方式（XML + 注解）

6.2 纯注解方式（零XML）

6.3 对比分析

七、Spring 框架整合 JUnit 单元测试

7.1 基于XML配置的Spring整合JUnit测试

7.2 纯注解方式的Spring整合JUnit测试

7.3 对比分析

总结

一、Spring框架概述

1.1 Spring框架的概述

        Spring是一个开源的Java平台，提供了一个轻量级的框架来解决企业应用开发的复杂性。Spring框架的核心优势在于其分层架构，允许开发者选择使用特定的组件，同时为J2EE应用程序开发提供集成的解决方案。

Spring框架的主要特点包括：

  • ​​控制反转（IoC）​​：将对象的创建和依赖关系的管理交给Spring容器。

  • ​​面向切面编程（AOP）​​：通过AOP实现权限拦截、运行监控等功能。

  • ​​声明式事务管理​​：通过配置文件实现事务管理，无需手动编写事务代码。

  • ​​方便程序测试​​：支持JUnit4，便于对Spring程序进行单元测试。

  • ​​集成优秀框架​​：如Struts2、Hibernate、MyBatis、Quartz等。

  • ​​降低JavaEE API的使用难度​​：对JDBC、JavaMail等复杂API进行了封装。

1.2 Spring框架的优点

  • ​​方便解耦，简化开发​​：Spring通过IoC容器管理对象的创建和依赖关系，开发者无需手动管理对象的生命周期和依赖关系。

  • ​​AOP编程的支持​​：Spring提供了AOP编程的支持，可以方便地实现权限拦截、运行监控等功能。

  • ​​声明式事务的支持​​：通过配置文件即可完成事务管理，无需手动编写事务管理代码。

  • ​​方便程序的测试​​：Spring对JUnit4提供了良好的支持，可以通过注解方便地测试Spring程序。

  • ​​方便集成各种优秀框架​​：Spring内部提供了对Struts2、Hibernate、MyBatis、Quartz等框架的直接支持。

  • ​​降低JavaEE API的使用难度​​：Spring对JDBC、JavaMail、远程调用等复杂API进行了封装，降低了使用难度。

二、Spring的IOC核心技术

2.1 什么是IOC

        IOC（Inverse of Control，控制反转）是一种设计原则，通过将对象的创建权反转给Spring框架，降低了代码之间的耦合度。Spring的工厂通过读取配置文件来管理对象的创建和依赖关系。

2.2 IOC的程序入门

以下是一个简单的Spring IOC入门示例：

1. 创建mavenJava项目，导入坐标依赖（pom.xml）

    <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>

2. 编写接口和实现类

package com.qcby.service;public interface UserService {public void hello();
}

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

3. 编写 Spring 核心的配置文件

在src/main/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/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd"><!--IOC 管理 bean--><bean id="userService" class="com.qcby.service.UserServiceImpl"/></beans>

4. 编写测试方法

import com.qcby.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 = newClassPathXmlApplicationContext("spring.xml");// 通过工厂获得类:UserService userService = (UserService)applicationContext.getBean("userService");userService.hello();}}

2.3 IOC技术总结

  • ​​ApplicationContext接口​​：工厂的接口，用于获取具体的Bean对象。常用的实现类有ClassPathXmlApplicationContext和FileSystemXmlApplicationContext。

  • ​​Bean管理​​：通过id、class、scope等属性配置Bean对象。

  • ​​Bean对象的创建和销毁​​：通过init-method和destroy-method属性配置Bean的生命周期方法。

2.4 实例化Bean对象的三种方式

1. ​​默认无参数构造方法​​

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

2. 静态工厂实例化方式

public class StaticFactory {public static UserService createUs() {System.out.println("通过静态工厂的方式创建 UserServiceImpl 对
象...");return new UserServiceImpl();}
}
<bean id="us" class="com.qcby.demo1.StaticFactory" factory-method="createUs"/>

3. 实例工厂实例化方式​​

public class Dfactory {public UserService createUs() {System.out.println("实例化工厂的方式...");return new UserServiceImpl();}
}
<bean id="dfactory" class="com.qcby.demo1.Dfactory" />
<bean id="us" factory-bean="dfactory" factory-method="createUs" />

三、DI依赖注入

3.1 依赖注入的概述

        DI（Dependency Injection，依赖注入）是Spring框架负责创建Bean对象时，动态地将依赖对象注入到Bean组件中的过程。

3.2 DI的两种方式

1. Setter方法注入

//OrderDao
package com.qcby.dao;public interface OrderDao {public void saveOrder();
}//OrderDaoImpl
package com.qcby.dao;public class OrderDaoImpl implements OrderDao{public void saveOrder() {System.out.println("持久层：保存订单...");}
}//OrderService
package com.qcby.service;public interface OrderService {public void saveOrder();
}//OrderServiceImpl
package com.qcby.service;import com.qcby.dao.OrderDao;public class OrderServiceImpl implements OrderService{//编写成员属性，一定需要提供该属性的 set 方法private OrderDao orderDao;//一定需要提供该属性的 set 方法，IOC 容器底层就通过属性的 set 方法方式注入值public void setOrderDao(OrderDao orderDao) {this.orderDao = orderDao;}//消息private String msg;//年龄private int age;public void setMsg(String msg) {this.msg = msg;}public void setAge(int age) {this.age = age;}public void saveOrder() {System.out.println("业务层：保存订单..."+msg+" - "+age);//调用orderDao.saveOrder();}
}

    <!--DI：依赖注入--><bean id="os" class="com.qcby.service.OrderServiceImpl"><property name="orderDao" ref="od" /><property name="msg" value="你好" /><property name="age" value="30" /></bean><bean id="od" class="com.qcby.dao.OrderDaoImpl"></bean>
import com.qcby.service.OrderService;
import com.qcby.service.UserService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;public class Demo1 {@Testpublic void run3(){ApplicationContext applicationContext = newClassPathXmlApplicationContext("spring.xml");OrderService orderService = (OrderService)applicationContext.getBean("os");orderService.saveOrder(); //业务层：保存订单...你好 - 30  持久层：保存订单...}}

2. 构造器注入

package com.qcby.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.qcby.demo2.Car"><constructor-arg name="cname" value="大奔" /><constructor-arg name="money" value="400000" /></bean>
    @Testpublic void run4(){ApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");Car car = (Car) context.getBean("car");System.out.println(car); //Car{cname='大奔', money=400000.0}}

3.3 复杂类型注入（数组，集合，Properties）

package com.qcby.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;}@Overridepublic String toString() {return "CollectionBean{" +"strs=" + Arrays.toString(strs) +", list=" + list +", map=" + map +", properties=" + properties +'}';}
}

    <!--给集合属性注入值--><bean id="collectionBean" class="com.qcby.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>
    @Testpublic void run5(){ApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");CollectionBean collectionBean = (CollectionBean) context.getBean("collectionBean");System.out.println(collectionBean);//CollectionBean{strs=[美美, 小凤], list=[熊大, 熊二], map={aaa=老王, bbb=小王}, properties={password=123456, username=root}}}

四、多配置文件管理

通过<import>标签或加载多个配置文件实现模块化配置：

<!-- 在主配置文件中配置 -->
<import resource="applicationContext2.xml" />
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml", "applicationContext2.xml"
);

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

Spring框架开发方式：

以下是一个使用Spring框架开发程序的完整示例：

1. 创建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.qcby</groupId><artifactId>spring02</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>5.1.47</version></dependency></dependencies></project>

2. 创建数据库，创建表结构

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);

3. 编写JavaBean的类

package com.qcby.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 +'}';}
}

4. 编写AccountDao的接口和实现类

package com.qcby.dao;import com.qcby.domain.Account;import java.util.List;public interface AccountDao {public List<Account> findAll();
}

package com.qcby.dao;import com.alibaba.druid.pool.DruidDataSource;
import com.qcby.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;}/*** 查询所有的数据* @return*/public List<Account> findAll() {/*DruidDataSource dataSource = new DruidDataSource();dataSource.setDriverClassName("com.mysql.jdbc.Driver");dataSource.setUrl("jdbc:mysql:///spring_db");dataSource.setUsername("root");dataSource.setPassword("12345");*/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;}
}

5. 编写AccountService的接口和实现类

package com.qcby.service;import com.qcby.domain.Account;import java.util.List;public interface AccountService {public List<Account> findAll();
}

package com.qcby.service;import com.qcby.dao.AccountDao;
import com.qcby.domain.Account;import java.util.List;public class AccountServiceImpl implements AccountService{// 依赖注入private AccountDao accountDao;public void setAccountDao(AccountDao accountDao) {this.accountDao = accountDao;}/*** 查询所有的数据* @return*/public List<Account> findAll() {return accountDao.findAll();}
}

6. 编写配置文件

<?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/beanshttp://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.qcby.service.AccountServiceImpl"><property name="accountDao" ref="accountDao" /></bean><bean id="accountDao" class="com.qcby.dao.AccountDaoImpl"><property name="dataSource" ref="dataSource" /></bean></beans>

7. 编程测试程序

import com.qcby.domain.Account;
import com.qcby.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("spring.xml");AccountService accountService = (AccountService) ac.getBean("accountService");// 调用方法List<Account> list = accountService.findAll();for (Account account : list) {System.out.println(account);}}
}

六、IOC注解开发

6.1 半注解方式（XML + 注解）

1. 核心思想

        在XML配置文件中开启注解扫描，结合代码中的注解（如@Component、@Autowired）管理Bean，部分配置仍依赖XML文件。

2. 实现步骤

  1. 开启注解扫描：在XML中配置<context:component-scan>，指定扫描的包路径。

    <beans xmlns:context="http://www.springframework.org/schema/context"><context:component-scan base-package="com.qcby"/>
</beans>

  2. 定义Bean：在类上使用@Component及其衍生注解（@Service, @Repository, @Controller）。

    @Service("userService")
public class UserServiceImpl implements UserService {// ...
}

  3. 依赖注入：

    • 普通类型：使用@Value注入。

      @Value("Hello")
private String message;

    • 引用类型：使用@Autowired按类型注入，或@Qualifier按名称注入。

      @Autowired
@Qualifier("userDao")
private UserDao userDao;

3. 常用注解

注解作用
@Component通用Bean注解，标识类为Spring管理的组件。
@Service标识业务层组件。
@Repository标识持久层组件（自动处理DAO层异常）。
@Autowired按类型自动注入依赖（默认按类型，可配合@Qualifier按名称）。
@Scope定义Bean作用域（如singleton、prototype）。
@PostConstruct初始化方法注解，等同于init-method。
@PreDestroy销毁方法注解，等同于destroy-method。

4. 示例

@Service("accountService")
public class AccountServiceImpl implements AccountService {@Autowiredprivate AccountDao accountDao;@Value("1000")private int initialBalance;
}

6.2 纯注解方式（零XML）

1. 核心思想

        完全通过Java配置类（@Configuration）和注解替代XML文件，实现全注解驱动的开发。

2. 实现步骤

  1. 定义配置类：使用@Configuration标识配置类，@ComponentScan指定扫描包路径。

    @Configuration
@ComponentScan("com.qcby")
public class SpringConfig {}

  2. 注册Bean：

    • 自动扫描：通过@ComponentScan自动注册标记了@Component的类。

    • 手动注册：在配置类中使用@Bean方法显式定义Bean。

      @Bean
public DataSource dataSource() {DruidDataSource ds = new DruidDataSource();ds.setUrl("jdbc:mysql:///spring_db");return ds;
}

  3. 加载配置类：通过AnnotationConfigApplicationContext加载配置类。

    ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);

3. 常用注解

注解

作用

@Configuration

标识当前类为配置类，替代XML文件。

@ComponentScan

指定扫描包路径，自动注册Bean。

@Bean

在方法上定义Bean，方法返回值作为Bean实例（常用于第三方库的集成）。

@Import

引入其他配置类，实现模块化配置。

@PropertySource

加载外部配置文件（如.properties）。

4. 示例

@Configuration
@ComponentScan("com.qcby.demo4")
@Import(DataSourceConfig.class)
public class AppConfig {@Beanpublic DataSource dataSource() {DruidDataSource ds = new DruidDataSource();ds.setDriverClassName("com.mysql.jdbc.Driver");ds.setUrl("jdbc:mysql:///spring_db");return ds;}
}

6.3 对比分析

特性

半注解方式

纯注解方式

配置文件

需要XML文件（开启扫描）

完全无需XML，使用Java配置类

灵活性

适合遗留项目迁移或部分注解改造

适合新项目，完全面向注解开发

代码侵入性

较低（仅需少量注解）

较高（需编写配置类）

典型场景

逐步替换XML中的Bean定义

微服务、Spring Boot项目

依赖注入

支持@Autowired和XML混合配置

完全通过注解实现

七、Spring 框架整合 JUnit 单元测试

        在传统的单元测试中，每次测试都需要手动创建Spring容器、加载配置文件，这不仅增加了代码量，还降低了测试效率。Spring框架针对这一问题提供了整合JUnit的解决方案，使得单元测试更加简洁高效。

7.1 基于XML配置的Spring整合JUnit测试

1. 环境准备

首先确保项目中已导入JUnit和Spring-test依赖：

<dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>4.12</version><scope>test</scope>
</dependency>
<dependency><groupId>org.springframework</groupId><artifactId>spring-test</artifactId><version>5.0.2.RELEASE</version><scope>test</scope>
</dependency>

2. 编写类和方法，把该类交给 IOC 容器进行管理

package com.qcby.demo5;public class User {public void sayHello() {System.out.println("Hello....");}
}

3. 编写配置文件

<?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/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd"><!--整合单元测试--><bean id="user" class="com.qcby.demo5.User"/>
</beans>

4. 编写测试类

package com.qcby.test;import com.qcby.demo5.User;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;/*** Spring整合JUnit单元测试（XML配置方式）*/
@RunWith(SpringJUnit4ClassRunner.class) // 使用Spring的测试运行器
@ContextConfiguration(value = "classpath:spring.xml") // 加载Spring配置文件
public class Demo5 {@Autowired // 自动注入User对象private User user;@Testpublic void run1() {user.sayHello(); // 调用被测试方法}
}

关键点说明：​​

  • @RunWith(SpringJUnit4ClassRunner.class)：指定使用Spring的测试运行器

  • @ContextConfiguration：指定Spring配置文件位置

  • @Autowired：自动注入被测试对象

7.2 纯注解方式的Spring整合JUnit测试

1. 编写类和方法

package com.qcby.demo6;import org.springframework.stereotype.Component;@Component
public class Customer {public void save() {System.out.println("保存客户...");}
}

2. 编写配置类

package com.qcby.demo6;import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;/*** Spring配置类（替代XML配置）*/
//声明
@Configuration
@ComponentScan(value = "com.qcby.demo6") // 扫描指定包下的组件
public class SpringConfig6 {
}

3. 编写测试类

package com.qcby.test;import com.qcby.demo6.Customer;
import com.qcby.demo6.SpringConfig6;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;/*** Spring整合JUnit单元测试（纯注解方式）*/
@RunWith(SpringJUnit4ClassRunner.class)
//加载配置类
@ContextConfiguration(classes = SpringConfig6.class) // 指定配置类
public class Demo6 {//按类型注入@Autowiredprivate Customer customer;@Testpublic void run1() {customer.save(); // 调用被测试方法}
}

关键点说明：​​

  • 使用@Configuration和@ComponentScan替代XML配置

  • @ContextConfiguration(classes = ...)指定配置类

  • 其余部分与XML方式类似

7.3 对比分析

特性XML配置方式纯注解方式
配置方式使用XML文件使用Java配置类
灵活性较低，修改需修改XML文件较高，可直接修改Java代码
可读性结构清晰，适合复杂配置简洁，适合简单配置
维护性配置分散，维护成本较高配置集中，维护成本较低
适用场景大型项目，需要精细控制Bean创建中小型项目，快速开发和迭代

总结

        Spring框架通过IOC和AOP机制，彻底改变了Java企业级开发的方式。无论是基础的Bean管理，还是复杂的多数据源配置，Spring都提供了优雅的解决方案。掌握这些核心技术与高级特性，不仅能提升代码质量，还能大幅提高开发效率。在实际项目中，建议结合Spring Boot进一步简化配置，快速构建微服务应用。

相关文章：

  • OpenResty反向代理
  • 在Java项目中实现本地语音识别与热点检测，并集成阿里云智能语音服务(优化版)
  • 【Part 2安卓原生360°VR播放器开发实战】第四节｜安卓VR播放器性能优化与设备适配
  • Redis设计与实现——单机Redis实现
  • iVX 平台技术解析：图形化与组件化的融合创新
  • 信息系统项目管理师-软考高级（软考高项）​​​​​​​​​​​2025最新（十五）
  • 深入剖析缓存与数据库一致性：Java技术视角下的解决方案与实践
  • java的Stream流处理
  • MySql（进阶）
  • macOS 15 (Sequoia) 解除Gatekeeper限制
  • wget、curl 命令使用场景与命令实践
  • 第八讲 | stack和queue的使用及其模拟实现
  • MySQL 数据库故障排查指南
  • 浏览器的B/S架构和C/S架构
  • 什么是卷积神经网络
  • QtGUI模块功能详细说明，事件与输入处理（五）
  • 无人机飞控算法开发实战：从零到一构建企业级飞控系统
  • JDS-算法开发工程师-第9批
  • Linux | Uboot-Logo 修改文档(第十七天)
  • HTML5中的Microdata与历史记录管理详解
  • 内塔尼亚胡：以军将在未来几天“全力进入”加沙
  • 俄官员说将适时宣布与乌克兰谈判代表
  • 欧元区财长会讨论国际形势及应对美国关税政策
  • 网信部门曝光网络谣言典型案例，“AI预测彩票号码百分百中奖”等在列
  • 电影路演，虚幻狂欢？
  • 巴防空系统击落印度无人机，印称巴方违反停火协议