springboot第17集：Spring我的春天

news2024/11/16 7:27:01

Spring是一个开源免费的框架和容器，具有轻量级和非侵入式的特点。它支持控制反转(IoC)和面向切面(AOP)，同时提供了对事务和其他框架的支持。因此，简单来说，Spring就是一个轻量级的IoC和AOP容器框架。

假设有一个应用程序需要使用数据库连接池进行数据存储操作，使用Spring框架可以将数据库连接池的创建和管理交由Spring容器来完成。这样，程序员只需要在需要使用数据库连接池的地方注入（IoC）一个数据源对象即可，而不用自己手动创建和管理连接池的实例。同时，通过AOP的支持，我们还可以在方法执行前后进行一些额外的处理，比如记录日志或者检查权限等。这样，开发人员就可以更加专注于业务逻辑代码的编写，而不必关心底层的技术细节。

a7d48c0554d6ea1518906c8c33ee8465.png
image.png

Spring 框架是一个分层架构，由 7 个定义良好的模块组成。Spring 模块构建在核心容器之上，核心容器定义了创建、配置和管理 bean 的方式 .

  1. Spring核心容器（Core Container）：提供了Spring框架最基本的功能，包括IoC和依赖注入（DI），以及AOP等技术支持。其中，其中最重要的组件为BeanFactory和ApplicationContext，它们负责创建和管理对象及其依赖关系。

  2. Spring AOP 模块：提供了面向切面编程（AOP）的支持，可以通过拦截器和切面来实现横向业务逻辑的统一处理，比如日志打印和事务管理等。

  3. Spring DAO / JDBC 模块：提供了对JDBC和ORM的支持，可以让开发人员更加方便地与数据库进行交互，包括数据访问对象（DAO）、JdbcTemplate、SimpleJdbcTemplate等API。

  4. Spring ORM 模块：提供了对流行的ORM框架的集成支持，包括Hibernate、MyBatis等。

  5. Spring Web 模块：提供了创建Web应用程序的支持，包括MVC框架、Web服务、Web安全等相关功能。

  6. Spring Test 模块：提供了对Spring应用程序的测试支持，包括基于JUnit和TestNG的测试框架、Mock对象等。

  7. Spring Integration 模块：提供了企业集成（EAI）和消息驱动的架构（MDA）的支持，可以与JMS、AMQP、FTP等进行集成。

总之，Spring框架提供了一种灵活、可扩展和易于使用的解决方案，可以帮助开发人员更加高效地完成企业级应用程序的开发工作。

fac47f3b5fd0987583c7c8a74e620358.png
image.png

Spring框架的每个模块（或组件）的详细内容：

  1. 核心容器

核心容器是Spring框架的基础，提供了IoC（控制反转）功能。在核心容器中，BeanFactory是最重要的组件之一，它负责管理应用程序中的所有对象。BeanFactory将应用程序的配置和依赖关系规范与实际的应用程序代码分离开来，从而使应用程序更加灵活和易于维护。

  1. Spring上下文

Spring上下文是一个配置文件，为Spring框架提供上下文信息，包括JNDI、EJB、电子邮件、国际化、校验和调度等企业服务。Spring上下文是应用程序中所有bean的集合，它们以及它们之间的依赖关系由Spring容器进行管理。

  1. Spring AOP

Spring AOP模块通过配置管理特性，直接将面向切面的编程功能集成到了Spring框架中。因此，可以很容易地使Spring框架管理任何支持AOP的对象。Spring AOP模块为基于Spring的应用程序中的对象提供了事务管理服务。通过使用Spring AOP，不用依赖组件，就可以将声明性事务管理集成到应用程序中。

  1. Spring DAO

Spring DAO是一组数据访问抽象层，包括JDBC DAO和ORM（对象关系映射） DAO。它提供了有意义的异常层次结构，可用该结构来管理异常处理和不同数据库供应商抛出的错误消息。异常层次结构简化了错误处理，并且极大地降低了需要编写的异常代码数量（例如打开和关闭连接）。Spring DAO的面向JDBC的异常遵从通用的DAO异常层次结构，从而使数据访问更加灵活和易于维护。

  1. Spring ORM

Spring ORM模块插入了多个ORM框架，包括JDO、Hibernate和iBatis SQL Map，从而提供了ORM的对象关系工具。所有这些都遵从Spring的通用事务和DAO异常层次结构，从而使数据访问更加灵活和易于维护。

  1. Spring Web模块

Spring Web模块建立在应用程序上下文模块之上，为基于Web的应用程序提供了上下文。因此，Spring框架支持与Jakarta Struts的集成。Web模块还简化了处理多部分请求以及将请求参数绑定到域对象的工作。

  1. Spring MVC框架

Spring MVC框架是一个全功能的MVC实现，用于构建Web应用程序。通过策略接口，MVC框架变成为高度可配置的，并且可以容纳大量视图技术，包括JSP、Velocity、Tiles、iText和POI等。Spring MVC框架还提供了处理请求和响应的机制以及执行处理器和适配器的机制，从而使Web开发更加简单和灵活。

Spring Boot和Spring Cloud是两个框架，它们都是由Spring开发的并且都是为了支持微服务架构而生的。

Spring Boot专注于快速、方便集成的单个微服务个体，它使用了约束优于配置的理念，这意味着很多集成方案已经帮你选择好了，默认配置非常合理，能不配置就不配置。Spring Boot可以帮助开发者快速搭建一个可运行的应用程序，并提供各种开箱即用的功能。例如，它可以自动配置数据源、事务管理器、Web框架等等，这些功能不需要开发者自己手动去配置。

Spring Cloud是基于Spring Boot实现的服务治理框架，它关注全局的服务治理，包括服务注册与发现、配置中心、负载均衡、断路器、分布式追踪等等。Spring Cloud为开发者提供了一系列的工具来简化微服务架构下的开发、部署和运维工作。通过Spring Cloud，开发者可以轻松地实现各种复杂的服务治理功能，而不必自己重新开发或者使用第三方库。

在实际项目开发中，Spring Boot通常被用来快速创建单个微服务，而Spring Cloud则被用来构建和管理整个微服务架构。Spring Boot和Spring Cloud可以一起使用，Spring Boot在Spring Cloud中起到了承上启下的作用。如果你要学习Spring Cloud，那么你必须要先学习Spring Boot，因为Spring Cloud很大的一部分是基于Spring Boot来实现的，同时Spring Cloud也依赖于Spring Boot。

bf2aee3ae26203dc9647483bb3c48ae0.png
image.png

IoC基础

// UserDao接口
public interface UserDao {
 public void getUser();
}

public class UserDaoImpl implements UserDao {
 @Override
 public void getUser() {
  System.out.println("获取用户数据");
 }
}

// UserService的接口
public interface UserService {
 public void getUser();
}

public class UserServiceImpl implements UserService {
 private UserDao userDao = new UserDaoImpl();
 
 @Override
 public void getUser() {
  userDao.getUser();
 }
}

@Test
public void test() {
 UserService service = new UserServiceImpl();
 service.getUser();
}
public class UserDaoMySqlImpl implements UserDao {
 @Override
 public void getUser() {
  System.out.println("MySql获取用户数据");
 }
}

public class UserServiceImpl implements UserService {
 private UserDao userDao = new UserDaoMySqlImpl();
 @Override
 public void getUser() {
  userDao.getUser();
 }
}

public class UserDaoOracleImpl implements UserDao {
    @Override
    public void getUser() {
        System.out.println("Oracle获取用户数据");
    }
}
public class UserServiceImpl implements UserService {
    private UserDao userDao;
    // 利用set实现
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }
    @Override
    public void getUser() {
        userDao.getUser();
    }
}

控制反转（IoC）是一种设计原则，它的本质在于将程序中对象的创建和对象之间的依赖关系从程序代码中解耦出来。换言之，IoC意味着程序不再控制对象的创建和依赖关系，而是将这些任务交给外部容器或框架处理。

具体来说，IoC的实现通常涉及到依赖注入（DI）技术。依赖注入是指通过构造函数、属性、方法等方式将一个对象所依赖的其他对象注入进去。通过依赖注入，我们可以轻松地替换依赖关系中的任何一个组件，而无需修改程序代码。

总的来说，IoC 的本质在于通过将对象的创建和依赖关系管理转移到外部容器或框架中，使得程序变得更加灵活、可扩展和易于维护。

IoC是Spring框架的核心内容，Spring通过多种方式实现了IoC，其中比较常用的方式包括XML配置、注解和零配置。

在使用XML配置时，我们需要在配置文件中定义Bean（即对象）的创建方式和依赖关系。当程序需要使用这些Bean时，Spring容器会根据配置文件中的信息自动创建对象，并将依赖关系注入到相应的对象中。相对来说，XML配置方式实现IoC更加灵活，可以满足不同场景下的需求。

使用注解实现IoC，可以让代码更加简洁和易于维护。通过在类或方法上添加注解，我们可以告诉Spring容器如何创建并管理这些对象，同时也方便了其他开发人员阅读和理解代码。

而零配置实现IoC，则是指Spring可以根据类路径扫描机制，自动创建对象并管理依赖关系，从而省略了繁琐的配置步骤。这种方式可以提高开发效率，但可能会影响程序的可维护性，因为没有明确的配置信息。

总的来说，Spring框架通过多种方式完美地实现了IoC，使得程序变得更加灵活、可扩展和易于维护。开发人员可以根据不同的需求选择合适的方式实现IoC。

Spring容器在初始化时先读取配置文件，根据配置文件或元数据创建与组织对象存入容器中，程序使用时再从Ioc容器中取出需要的对象。

控制反转（Inversion of Control, IoC）是一种设计模式，它将程序中对象的依赖关系从程序代码中剥离出来，交给IoC容器进行管理。这样做的好处是，程序员不再需要手动创建和管理对象之间的依赖关系，让程序更加灵活、可扩展和易于维护。

在Spring框架中，控制反转是通过IoC容器实现的。IoC容器负责实例化Bean，并将Bean的依赖注入到其他Bean中。Spring支持两种方式配置Bean：XML方式和注解方式。

使用XML方式配置Bean时，需要在XML文件中定义Bean的配置信息，包括Bean的类名、属性等信息。这种方式需要程序员手动编写XML文件，并且需要遵循特定的XML结构。

而使用注解方式配置Bean时，则是在Bean的实现类中使用注解定义Bean的配置信息。通过在类上添加注解，告诉Spring容器该类是一个Bean，并指定其相关的属性、依赖等信息。这种方式相对于XML方式更加灵活，简洁易懂，并且能够减少重复的代码，提高开发效率。

控制反转的核心思想是将对象的创建和依赖注入交由IoC容器处理，Spring框架通过依赖注入实现了控制反转，可以更加灵活地管理Bean之间的依赖关系，提高了程序的可扩展性和维护性。

控制反转是一种通过描述（XML或注解）并通过第三方去生产或获取特定对象的方式。在Spring中实现控制反转的是IoC容器，其实现方法是依赖注入（Dependency Injection,DI）。

spring 需要导入commons-logging进行日志记录 . 我们利用maven , 他会自动下载对应的依赖项 .

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.1.10.RELEASE</version>
</dependency>
public class Hello {
    private String name;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public void show(){
        System.out.println("Hello,"+ name );
    }
}
<?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就是java对象 , 由Spring创建和管理-->
    <bean id="hello" class="com.da.pojo.Hello">
        <property name="name" value="Spring"/>
    </bean>
</beans>
public class User {
    private String name;
    public User() {
        System.out.println("user无参构造方法");
    }
    public void setName(String name) {
        this.name = name;
    }
    public void show(){
        System.out.println("name="+ name );
    }
}
<?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="user" class="com.da.pojo.User">
        <property name="name" value="da"/>
    </bean>
</beans>

alias 设置别名 , 为bean设置别名 , 可以设置多个别名

public class Address {
 private String address;
 
 public String getAddress() {
  return address;
 }
 
 public void setAddress(String address) {
  this.address = address;
 }
}
<bean id="student" class="com.da.pojo.Student">
    <property name="name" value="da"/>
</bean>
@Component  //将这个类标注为Spring的一个组件，放到容器中！
public class Dog {
    public String name = "dog";
}

@Configuration  //代表这是一个配置类
public class MyConfig {
    @Bean //通过方法注册一个bean，这里的返回值就Bean的类型，方法名就是bean的id！
    public Dog dog(){
        return new Dog();
    }
}

AOP的底层机制就是动态代理！

代理模式：

  • 静态代理

  • 动态代理

d14291aa31a31fbdec1471ce576c807c.png
image.png

AOP（面向切面编程）的核心机制之一是动态代理。在Java应用程序中，代理模式是实现动态代理的一种常见方式。

代理模式是一种设计模式，它允许一个对象作为另一个对象的接口进行访问。代理对象可以充当客户端与目标对象之间的中介，从而控制对目标对象的访问。

静态代理与动态代理是代理模式的两种实现方式。静态代理需要手动编写代理类代码，而动态代理则在运行时生成代理类。动态代理可以更加灵活地适应不同的需求，并且可以减少冗余的代理类代码。

在Java中，动态代理通常使用Java反射来实现。通过动态代理，可以在不改变目标对象的代码的情况下，实现对目标对象的增强。例如，可以在方法执行前后添加日志记录、性能统计等功能。

总的来说，动态代理是实现AOP的一种重要机制，它可以帮助开发人员更加方便地实现对目标对象的增强和控制，从而提高代码可维护性和可扩展性。

//抽象角色：租房
public interface Rent {
    public void rent();
}
//真实角色: 房东，房东要出租房子
public class Host implements Rent{
    public void rent() {
        System.out.println("房屋出租");
    }
}
//代理角色：中介
public class Proxy implements Rent {
    private Host host;
    public Proxy() { }
    public Proxy(Host host) {
        this.host = host;
    }
    //租房
    public void rent(){
        seeHouse();
        host.rent();
        fare();
    }
    //看房
    public void seeHouse(){
        System.out.println("带房客看房");
    }
    //收中介费
    public void fare(){
        System.out.println("收中介费");
    }
}
//客户类，一般客户都会去找代理！
public class Client {
    public static void main(String[] args) {
        //房东要租房
        Host host = new Host();
        //中介帮助房东
        Proxy proxy = new Proxy(host);
        //你去找中介！
        proxy.rent();
    }
}
//抽象角色：增删改查业务
public interface UserService {
    void add();
    void delete();
    void update();
    void query();
}
//真实对象，完成增删改查操作的人
public class UserServiceImpl implements UserService {
    public void add() {
        System.out.println("增加了一个用户");
    }
    public void delete() {
        System.out.println("删除了一个用户");
    }
    public void update() {
        System.out.println("更新了一个用户");
    }
    public void query() {
        System.out.println("查询了一个用户");
    }
}
//代理角色，在这里面增加日志的实现
public class UserServiceProxy implements UserService {
    private UserServiceImpl userService;
    public void setUserService(UserServiceImpl userService) {
        this.userService = userService;
    }
    public void add() {
        log("add");
        userService.add();
    }
    public void delete() {
        log("delete");
        userService.delete();
    }
    public void update() {
        log("update");
        userService.update();
    }
    public void query() {
        log("query");
        userService.query();
    }
    public void log(String msg){
        System.out.println("执行了"+msg+"方法");
    }
}

总结：

  • 静态代理和动态代理的代理角色相同，都是为被代理对象提供额外的功能或限制

  • 静态代理的代理类是我们编写的，而动态代理的代理类是在运行时动态生成的

  • 动态代理分为基于接口的动态代理和基于类的动态代理

  • JDK动态代理是基于接口的动态代理，cglib是基于类的动态代理，javassist也可以用于生成动态代理

  • 在代码中应该体现静态代理和动态代理的异同点，比如注释说明或代码结构等

  • 对于不同的代理方式，应选择最适合的实现方式，例如：如果要代理的对象已实现接口，则可以使用JDK动态代理；如果要代理的对象没有实现接口，则可以使用cglib动态代理

  • 对于JDK动态代理，可以使用InvocationHandler接口和Proxy类来实现，这样可以避免引入第三方库，同时也能够更清楚地表达代理的特性和实现原理

  • 对于cglib动态代理，需要将cglib库添加到项目依赖中，并且被代理对象不能声明成final类型。此外，由于cglib是基于继承实现的，因此需要注意被代理对象中的final方法或private方法在代理类中无法被覆盖的问题。

AOP（面向切面编程）是一种编程思想，旨在将应用程序的不同功能分离出来，从而提高程序的可重用性、灵活性和维护性。它通过在系统中定义横切关注点，将这些关注点与业务逻辑分开处理，从而实现了对系统各个部分的隔离和封装。

AOP 的实现方式主要有两种：静态代理和动态代理。在运行时，AOP 会根据预先设定的切入点，对目标对象进行拦截，并将相关的通知（Advice）插入到目标对象的指定位置，从而影响目标对象的行为。

在 Java 开发中，常见的 AOP 框架有 Spring AOP 和 AspectJ 等。Spring AOP 是基于 Java 动态代理和 CGLIB 动态代理机制实现的，它提供了基于方法拦截和基于注解拦截等多种实现方式，支持前置通知、后置通知、环绕通知、异常通知和最终通知等多种通知类型。AspectJ 则是基于 Java 编译器实现的，具有更强的表达能力和灵活性，可以实现更复杂的 AOP 功能。

总之，AOP 是一种非常有用的编程思想，在实际开发中可以用来实现日志记录、安全检查、性能监控等横切关注点，从而提高应用程序的质量和可维护性。

<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
</dependency>
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.5.2</version>
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.47</version>
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.47</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.1.10.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.1.10.RELEASE</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.4</version>
</dependency>
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis-spring</artifactId>
    <version>2.0.2</version>
</dependency>

MyBatis

编写pojo实体类

public class User {
    private int id;  //id
    private String name;   //姓名
    private String pwd;   //密码
}

ACID（原子性、一致性、隔离性、持久性）四个特性，这些特性是关系型数据库中事务的重要属性。每个字母代表一个特性：

  1. 原子性（Atomicity）：指一个事务中所有操作不可分割，要么全部完成，要么全部不完成。

  2. 一致性（Consistency）：指在事务开始之前和事务结束之后，数据库的完整性约束没有被破坏，即数据必须满足业务规则。

  3. 隔离性（Isolation）：指多个事务并发执行时，每个事务的执行应该与其他事务隔离开来，互不干扰，防止数据损坏。

  4. 持久性（Durability）：指当事务提交之后，其所做的修改会永久保存到数据库中，不会因为系统崩溃等异常情况而丢失。

加群联系作者vx：xiaoda0423

仓库地址：https://github.com/webVueBlog/JavaGuideInterview

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

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

相关文章

【Golang】多线程爬虫的实现

【Golang】多线程爬虫的实现

〇、前言 Golang 是一种并发友好的语言&#xff0c;使用 goroutines 和 channels 可以轻松地实现多线程爬虫。具体地说&#xff0c;实现的是多协程。协程是一种比线程更轻量化的最小逻辑可运行单位&#xff0c;它不受操作系统调度&#xff0c;由用户调度。因此对于协程并发的控…
阅读更多...
突发！ChatGPT王炸级更新！支持GPT-4联网 Code Interpreter！

突发！ChatGPT王炸级更新！支持GPT-4联网 Code Interpreter！

4月30日&#xff0c;OpenAI官方悄悄发布了联网版GPT-3.5。虽然名字变了&#xff0c;但使用体验却是换汤不换药&#xff0c;还是那套。 然而&#xff0c;万万没想到的是&#xff0c;刚过去没几天&#xff0c;昨天5月4日&#xff0c;鱼哥发现自己的Plus账号竟然多了一些能力&…
阅读更多...
AI 视频编辑革新：GEN-1 / GEN-2 引领新风潮

AI 视频编辑革新：GEN-1 / GEN-2 引领新风潮

在早先的一篇文章中《AI 学习心得速览&#xff08;3月&#xff09;》&#xff0c;提到过一家AI视频公司RunWay&#xff0c;公司专注于 AI 视频处理&#xff0c;在二月份发布了第一个人工智能视频编辑模型 Gen-1&#xff0c;对视频素材进行转换成相应的风格。 RunwayML 今天来聊…
阅读更多...
C#学习系列之throw new ApplicationException

C#学习系列之throw new ApplicationException

C#学习系列之throw new ApplicationException 啰嗦问题解决总结 啰嗦 在项目的解码过程中使用到throw new ApplicationException语句&#xff0c;之前一致没有意识到这句话会带来很多问题。项目中使用这句话来捕捉解码过程中的解码异常问题。 问题 在使用throw new Applicati…
阅读更多...
（二）【平衡小车制作】电机驱动（超详解）

（二）【平衡小车制作】电机驱动（超详解）

一、硬件设计 1.直流减速电机   直流减速电机&#xff0c;即齿轮减速电机&#xff0c;是在普通直流电机的基础上&#xff0c;加上配套齿轮减速箱。齿轮减速箱的作用是&#xff0c;提供较低的转速&#xff0c;较大的力矩。  简单的来说&#xff0c;STM32分配两个IO口给一个…
阅读更多...
LeetCoed 2, 23, 25, 112, 113

LeetCoed 2, 23, 25, 112, 113

文章目录 1. 两数相加2. K 个一组翻转链表3. 合并 K 个升序链表4. 路径总和I5. 路径总和II 1. 两数相加 题目详情见: LeetCode2. 两数相加 题目描述相对来说比较绕, 我们可以直接理解为两个多位的整数相加, 只不过整数的每一位都是通过链表进行存储; 比如, 整数 342, 通过链表…
阅读更多...
使用Webpack搭建项目（vue篇）

使用Webpack搭建项目（vue篇）

本篇承接使用Webpack搭建项目&#xff08;react篇&#xff09; 由于大部分配置一样&#xff0c;我们从上一篇react项目中&#xff0c;复制webpack.dev.js以及webpack.prod.js 开发模式 1.删除ReactRefreshWebpackPlugin 2.自动补充拓展名修改为.vue文件&#xff0c;同时处理…
阅读更多...
每天一道算法练习题--Day21 第一章 --算法专题 --- ----------位运算

每天一道算法练习题--Day21 第一章 --算法专题 --- ----------位运算

我这里总结了几道位运算的题目分享给大家&#xff0c;分别是 136 和 137&#xff0c; 260 和 645&#xff0c; 总共加起来四道题。 四道题全部都是位运算的套路&#xff0c;如果你想练习位运算的话&#xff0c;不要错过哦&#xff5e;&#xff5e; 前菜 开始之前我们先了解下…
阅读更多...
【linux的学习与软件安装】

【linux的学习与软件安装】

文章目录 linux的学习一、工具安装与联网&#xff1f;二、Linux软件安装1.安装jdk2.安装MySQL安装redis linux的学习 一、工具安装与联网&#xff1f; 1.1安装好VM后 进入vi /etc/sysconfig/network-scripts/ifcfg-ens33 然后ip addr 查看ip 1.2打开IDEA的tools 二、Linux软…
阅读更多...
网络编程 | 多进程多线程并发服务器代码实现

网络编程 | 多进程多线程并发服务器代码实现

欢迎关注博主 Mindtechnist 或加入【Linux C/C/Python社区】一起学习和分享Linux、C、C、Python、Matlab&#xff0c;机器人运动控制、多机器人协作&#xff0c;智能优化算法&#xff0c;滤波估计、多传感器信息融合&#xff0c;机器学习&#xff0c;人工智能等相关领域的知识和…
阅读更多...
5.5 Mybatis Update标签实战，返回值是什么? 教你通常处理做法

5.5 Mybatis Update标签实战，返回值是什么? 教你通常处理做法

本文目录 前言一、update标签实战① 在UserMapper接口中新增update方法② MybatisX插件生成update标签③ 写update SQL 语句 二、update sql返回值是什么?三、Mybatis update标签返回值是什么?四、实现简易的修改密码API1. dal层2. service层3. web层自测通过 五、Git提交最后…
阅读更多...
vue - 常见的移动端rem适配方案

vue - 常见的移动端rem适配方案

移动端rem适配方案 rem适配原理方案1&#xff1a;rem媒体查询方案2&#xff1a;jsrem方案3&#xff1a;vwrem&#xff08;不用查询屏幕宽度&#xff09; 移动端适配经常使用的就是 rem; 主要有以下几种方案&#xff1a; 1&#xff1a;rem 媒体查询&#xff08;media&#xff0…
阅读更多...
蓝桥杯最后一战

蓝桥杯最后一战

目录 分巧克力_二分 题目描述 输入格式 输出格式 输入输出样例 说明/提示 代码&#xff1a; 巧克力 - 优先队列 题目描述 输入格式 输出格式 输入输出样例 说明/提示 代码&#xff1a; 思路分析&#xff1a; 秘密行动_dp 蓝桥杯算法提高-秘密行动 题目描述 …
阅读更多...
Unity之OpenXR+XR Interaction Toolkit 安装和配置

Unity之OpenXR+XR Interaction Toolkit 安装和配置

前言 XR Interaction Toolkit 是Unity基于OpenXR标准&#xff0c;发布的一套XR工具&#xff0c;目的是方便我们快速接入XR相关的SDK&#xff0c;并且做到兼容不同VR设备的目的&#xff0c;目前流行的VR设备如Oculus&#xff0c;Metal&#xff0c;HTC Vive&#xff0c;Pico等统…
阅读更多...
改进YOLOv8 | 主干网络篇 | YOLOv8 更换骨干网络之 MobileNetV3 | 《搜寻 MobileNetV3》

改进YOLOv8 | 主干网络篇 | YOLOv8 更换骨干网络之 MobileNetV3 | 《搜寻 MobileNetV3》

论文地址：https://arxiv.org/abs/1905.02244 代码地址：https://github.com/xiaolai-sqlai/mobilenetv3 我们展示了基于互补搜索技术和新颖架构设计相结合的下一代 MobileNets。MobileNetV3通过结合硬件感知网络架构搜索（NAS）和 NetAdapt算法对移动设计如何协同工作，利用互…
阅读更多...
【天秤座区块链】元宇宙知识普以及简单解读清华研究报告

【天秤座区块链】元宇宙知识普以及简单解读清华研究报告

本节目录 温馨提示关于分栏【天秤座区块链】由来提前感受元宇宙区块链的两个注意点区块链革命简单认识清华大学报告解读&#xff08;元宇宙&#xff09;前传《雪崩》元宇宙具体是什么&#xff1f;元宇宙不是什么&#xff1f;那为什么要冲击元宇宙呢&#xff1f; 小补充及感谢 温…
阅读更多...
前端搭建打字通游戏（内附源码）

前端搭建打字通游戏（内附源码）

The sand accumulates to form a pagoda ✨ 写在前面✨ 打字通功能介绍✨ 页面搭建✨ 样式代码✨ 功能实现 ✨ 写在前面 上周我们实通过前端基础实现了名言生成器&#xff0c;当然很多伙伴再评论区提出了想法&#xff0c;后续我们会考虑实现的&#xff0c;今天还是继续按照我们…
阅读更多...
java基础入门-06-【面向对象进阶（多态包final权限修饰符代码块）】

java基础入门-06-【面向对象进阶（多态包final权限修饰符代码块）】

Java基础入门-06-【面向对象进阶&#xff08;多态&包&final&权限修饰符&代码块&#xff09;】 14、面向对象进阶&#xff08;多态&包&final&权限修饰符&代码块&#xff09;1.1 多态的形式1.2 多态的使用场景1.3 多态的定义和前提1.4 多态的运行…
阅读更多...
嵌入式设备逆向所需的工具链

嵌入式设备逆向所需的工具链

导语&#xff1a;本文介绍了嵌入式设备逆向所需的工具链。 相关的应用程序或工具有&#xff1a; UART(Universal Asynchronous Receiver Transmitter&#xff0c;通用异步收发器)&#xff1a; UBoot&#xff1b; Depthcharge&#xff1b; SPI (Serial Peripheral Interface…
阅读更多...
利用文本描述替换万物（Inpaint-Anything-Description）

利用文本描述替换万物（Inpaint-Anything-Description）

文章目录 引言安装Demo github&#xff1a; https://github.com/Atlas-wuu/Inpaint-Anything-Description 引言 前段时间看了万物分割SAM、文生图Stable Diffusion、开集检测Grounding DINO&#xff0c;它们之间可以互相补充&#xff0c;AIGC变得更加可控。Inpaint Anything将…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023