Spring—依赖注入

news2024/11/13 3:38:36

一、Spring框架概念

1.什么是OCP?

OCP是软件七大开发原则当中最基本的一个原则:开闭原则

对什么开?对扩展开放。
对什么闭?对修改关闭。
OCP原则是最核心的,最基本的,其他的六个原则都是为这个原则服务的。

OCP开闭原则的核心是什么?
只要你在扩展系统功能的时候,没有修改以前写好的代码,那么你就足符合OCP原则的。
反之,如果在扩展系统功能的时候,你修改了之前的代码,那么这个设计是大败的,违背OCP原则。
进行系统功能扩展的时候,如果动了之前稳定的程序,修改了之前的程序,这前斯有程序都需要进行重新测试。这是不想看到的,因为非常麻烦。

2.依赖倒置原则(DIP原则)

什么是依赖倒置原则?
面向接口编程,面向抽象编程,不要面向具体编程。
依赖倒置原则的目的:降低程序的耦合度,提高扩展力。

什么叫做符合依赖倒置?
上不依赖 下,就是符合火 什么叫做违背依赖倒置?
上 依赖 下,就是违背。
只要“下”一改动,“上”就受到牵连。

3.当前程序的设计,显然既违背OCP,又违背DIP,怎么办?

以采用“控制反转”这种编程思想来解决这个问题。控制反转(IoC)

4.控制反转(IoC)

反转是什么呢?
反转的是两件事:
第一件事:我不在程序中采用硬编码的方式来new对象了。(new对象我不管了,new对象的权利交出去了。)
第二件事:我不在程序中采用硬编码的方式来维护对象的关系了。(对象之间关系的维护权,我也不管了,交出去了。)
控制反转: 是一种编程思想。或者叫做一种新型的设计模式。由于出现的比较新,没有被纳入GoF23种设计模式范围内。

5.Spring框架

Spring框架实现了控制反转IoC这种思想Spring框架可以帮你new对象。
Spring框架可以帮你维护对象和对象之间的关系。Spring是一个实现了IoC思想的容器。
控制反转的实现方式有多种,其中比较重要的叫做:依赖注入(Dependency Injection,简称DI)。
控制反转是思想。依赖注入是这种思想的具体实现。
依赖注入DI,又包括常见的两种方式:
第一种:set注入(执行set方法给属性赋值)
第二种:构造方法注入(执行构造方法给属性赋值)
依赖注入 中“依赖”是什么意思?“注入“是什么意思?依赖:A对象和B对象的关系。注入:是一种手段,通过这种手段,可以让A对象和B对象产生关系
Spring有两个核心部分:IOC 和Aop.
(1) IOC:控制反转,把创建对象过程交给 Spring 进行管理
(2) Aop:面向切面,不修改源代码进行功能增强

二、Spring入门程序

先在这个程序中pom.xml中引入依赖配置

<!--依赖-->
    <!--当你引入Spring Context 依赖之后,表示将Spring的基础依赖引入了-->
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>6.0.0-M2</version>
        </dependency>
        <!--junit依赖-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

在主程序(main)中引入一个类

package com.hei;

public class User {
}

在resources下创建Spring的配置文件,放在resources根目录下,相当于放到了类的根路径下。配置bean。这样spring才能帮助我们管理这个对象。

bean标签的两个重要属性:id:这个bean的身份证号,不能重复,唯一标识。class:必须填写类的全路径,全限定类名(带包名的类名)。

<bean id="Userbean" class="com.hei.User"/>
</beans>

在test下引入测试类,第一步:获取Spring容器对象。这段代码相当于启动了Spring容器,解析spring.xml文件,并实例化所用的bean对象,放在spring容器中。

第二步:根据bean的id从Spring容器获取这个对象。

package com.heit;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class springtest {
    @Test
   public void springtest() {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
        Object obj = applicationContext.getBean("Userbean");
        System.out.println(obj);
    }
}

三、Spring对IoC的实现

1.IoC控制反转

控制反转是一种思想,依赖注入是实现方式。

2.依赖注入

 

1)set依赖注入

set依赖注入是基于set方法进行的,要用set依赖注入必须在配置文件中(spring.xml),配置<property name="" ref=""/>

先在主函数中写类与方法:

创建一个UserDao类:

package com.hei.dao;
public class UserDao {
    public  void  insert(){
        System.out.println("数据库正在保存信息");
    }
}

创建一个UserService类:

在UserService类中要调用UserDao方法,需创建UserDao的对象,还需要对UserDao进行set赋值。可以利用IDEA自动生成set方法,也可以自己书写。

package com.hei.servece;
import com.hei.dao.UserDao;
public class UserService {
    private UserDao ud;//创建引用数据类型
    //set注入的话,必须提供一个set方法
    public void setMysqlUser(UserDao u){//set方法
        this.ud=u;
    }
    public void Save(){//创建一个方法调用UserDao对象
        ud.insert();
    }
}

在配置文件(spring.xml)中进行配置bean和property:

<bean id="userdao" class="com.hei.dao.UserDao"/>
    <bean id="userservice" class="com.hei.servece.UserService">
        <!--要想让Spring调用set方法,必须要用property配置-->
        <!--name:为set方法的方法名 -->
        <!--ref:为引用,ref后面指定的是要注入的bean的id -->
<property name="mysqlUser" ref="userdao">
    </property>
    </bean>

在测试类中进行演示:

package com.hei;
import com.hei.servece.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {
    @org.junit.Test
    public  void TestDao() {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
        UserService us=applicationContext.getBean("userservice",UserService.class);
        us.Save();
        }
    }

 

2)构造注入

 利用构造方法进行。在配置文件(spring.xml)中有三种配置构造方法。

创建一个UserDao类:

package com.hei.dao;
public class UserDao {
    public  void  insert(){
        System.out.println("数据正在保存信息为构造注入");
    }
}

创建一个UserService类:

在UserService类中要调用UserDao方法,需创建UserDao的对象,还需进行构造方法赋值。

package com.hei.servece;
import com.hei.dao.UserDao;
public class UserService {
   //构造注入
    private UserDao userdao;//引用数据类型

    public UserService(UserDao userdao) {//构造方法
        this.userdao = userdao;
    }

    public void save(){
        userdao.insert();
    }
}

在配置文件(spring.xml)中进行配置bean和constructor-arg:

<bean id="userdao" class="com.hei.dao.UserDao"/>
    <bean id="userService1" class="com.hei.servece.UserService">
            <!--构造注入-->
        <!--
        index属性指定参数下标,第一个参数是0,第二个参数是1等等
        ref属性用来指定注入的bean的id
        -->
        <!--利用下标构造方式-->
        <constructor-arg index="0" ref="userdao"></constructor-arg>
    </bean>
    <bean id="userService2" class="com.hei.servece.UserService">
        <!--利用名字构造-->
        <constructor-arg name="userdao" ref="userdao">
        </constructor-arg>
    </bean>
    <bean id="userService3" class="com.hei.servece.UserService">
    <!--直接构造,让程序直接匹配对象类别-->
        <constructor-arg ref="userdao"></constructor-arg>
    </bean>

在主函数测试类中:

package com.hei;
import com.hei.servece.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {
    @org.junit.Test
    public  void TestDao() {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
       //第一种方法
        UserService use1= applicationContext.getBean("userService1",UserService.class);
        use1.save();
        System.out.println("------------");
        //第二种方法
        UserService use2= applicationContext.getBean("userService2",UserService.class);
        use2.save();
        System.out.println("---------------");
        //第三种方法
        UserService use3= applicationContext.getBean("userService3",UserService.class);
        use3.save();

3.set注入专题

1)内部bean与外部bean

在Dao包下:

package com.hei.dao;
public class Order {
    public void insert(){
        System.out.println("这是订购信息");
    }
}

在service包下:

package com.hei.service;
import com.hei.dao.Order;
public class OderService {
    private Order ord;//引用数据类型
    public void setOrd(Order ord) {
        this.ord = ord;
    }
    public void generate(){
        ord.insert();
    }
}

在配置文件(spring.xml)中: 

 <!--外部bean-->
    <bean id="order" class="com.hei.dao.Order"/>
    <bean id="orders1" class="com.hei.servece.OderService">
        <property name="ord" ref="order">
        </property>
    </bean>
    <!--内部bean-->
    <bean id="orders2" class="com.hei.servece.OderService">
        <property name="ord">
            <bean class="com.hei.dao.Order"></bean>
        </property>
    </bean>

2)简单注入

简单类:8种基本类型、8种包装类、枚举、Class、Date类型都是简单数据类型。在实际开发中,不会将Date类型看作是简单数据类型,虽然他本质上是简单数据类型,用ref进行赋值。

简单注入采用value进行赋值。

Dao包中的User类:

package com.hei.dao;
public class User {
    private String name;
    private int age;

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

在配置文件(spring.xml)中:

<!--简单注入-->
    <bean id="user" class="com.hei.dao.User">
        <property name="name" value="张三"/>
        <property name="age" value="23"></property>
    </bean>

测试类中:

package com.hei;

import com.hei.dao.User;
import com.hei.servece.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {
    @org.junit.Test
    public void TestDao() {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
        User u= applicationContext.getBean("user", User.class);
        System.out.println(u);
        }
    }

3)级联属性赋值

使用级联属性赋值:需要在使用的属性配置get方法

clazz班级类:

package com.hei.dao;
public class clazz {
    private String cname;
    public void setCname(String cname) {
        this.cname = cname;
    }
    @Override
    public String toString() {
        return "clazz{" +
                "cname='" + cname + '\'' +
                '}';
    }
}

Student学生类:

package com.hei.dao;
public class Student {
    private String name;
    private int age;
    private clazz c;//学生所在班级
    public void setC(clazz c) {
        this.c = c;
    }
    public clazz getC() {
        return c;
    }
    public void setName(String name) {
        this.name = name;
    }
    public void setAge(int age) {
        this.age = age;
    }
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", c=" + c +
                '}';
    }
}

配置文件(spring.xml):

<!--级联赋值-->
    <bean id="student" class="com.hei.dao.Student">
        <property name="name" value="张三"/>
        <property name="age" value="18"/>
        <property name="c" ref="clazz"/>
        <property name="c.cname" value="高一一班"></property>
    </bean>
    <bean id="clazz" class="com.hei.dao.clazz"></bean>

测试类:

public class Test {
    @org.junit.Test
    public void TestDao() {
      ApplicationContext applicationContext=new ClassPathXmlApplicationContext("spring.xml");
      Student s=applicationContext.getBean("student", Student.class);
      System.out.println(s);
        }
    }

4)数组注入

简单类型赋值时用value,复杂类型赋值时,用ref。

Student学生类:

package com.hei.dao;
import java.util.Arrays;
public class Student {
   private String[] hobby;

    public void setHobby(String[] hobby) {
        this.hobby = hobby;
    }

    @Override
    public String toString() {
        return "Student{" +
                "hobby=" + Arrays.toString(hobby) +
                '}';
    }
}

配置文件(spring.xml):

id:为标志,可以随意起,有唯一性。

class:为所在地址。

name:为set方法后面的方法名(setHobby  这位hobby)

<bean id="hobby" class="com.hei.dao.Student">
     <property name="hobby">
         <array>
             <value>打游戏</value>
             <value>学习</value>
             <value>睡觉</value>
         </array>
     </property>
 </bean>

测试类:

getbean中的字符串为:配置文件中的id号

public class Test {
    @org.junit.Test
    public void TestDao() {
      ApplicationContext applicationContext=new ClassPathXmlApplicationContext("spring.xml");
      Student s=applicationContext.getBean("hobby", Student.class);
      System.out.println(s);
        }
    }

当数组不是简单类型,例如:

其中w1等等为bean中的id号。

5)List集合和Set集合注入

User类:

package com.hei.dao;
import java.util.List;
import java.util.Set;
public class User {
 private List<String> list;
 private Set<String> set;
    public void setList(List<String> list) {
        this.list = list;
    }
    public void setSet(Set<String> set) {
        this.set = set;
    }
    @Override
    public String toString() {
        return "User{" +
                "list=" + list +
                ", set=" + set +
                '}';
    }
}
<bean id="u1" class="com.hei.dao.User">
     <property name="list">
         <list>
             <value>张三</value>
             <value>李四</value>
         </list>
     </property>
     <property name="set">
         <set>
             <value>王五</value>
             <value>赵六</value>
         </set>
     </property>
 </bean>
public class Test {
    @org.junit.Test
    public void TestDao() {
      ApplicationContext applicationContext=new ClassPathXmlApplicationContext("spring.xml");
      User u=applicationContext.getBean("u1", User.class);
      System.out.println(u);
        }
    }

6)Map集合注入和propertise注入

propertise是一个属性类,本质上是一个map集合,它的键值对的属性只能是String类型。

User类:

package com.hei.dao;
import java.util.Map;
import java.util.Properties;
public class User {
 private Map<String,Integer> s;
 private Properties p;
    public void setS(Map<String, Integer> s) {
        this.s = s;
    }
    public void setP(Properties p) {
        this.p = p;
    }
    @Override
    public String toString() {
        return "User{" +
                "s=" + s +
                ", p=" + p +
                '}';
    }
}

spring.xml:

<bean id="u1" class="com.hei.dao.User">
   <property name="s">
       <map>
           <entry key="张三" value="23"/>
           <entry key="李四" value="24"/>
       </map>
   </property>
     <property name="p">
         <props>
             <prop key="wangwu">root</prop>
             <prop key="hostall">lib</prop>
         </props>
     </property>
 </bean>

测试类:

public class Test {
    @org.junit.Test
    public void TestDao() {
      ApplicationContext applicationContext=new ClassPathXmlApplicationContext("spring.xml");
      User u=applicationContext.getBean("u1", User.class);
      System.out.println(u);
        }
    }

7)注入null和空字符串

注入null:不给属性赋值,属性默认值就是null。

Cat类:

package com.hei.dao;
public class Cat {
    private String name;
    private int age;
    public void setName(String name) {
        this.name = name;
    }
    public void setAge(int age) {
        this.age = age;
    }
    @Override
    public String toString() {
        return "Cat{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

spring.xml:

注入null:不给属性赋值,属性默认值就是null。

手动注入null:<null/>

注入空字符串:<value/>

<bean id="mao" class="com.hei.dao.Cat">
     <!--注入null-->
<!--     <property name="name" value="蓝金渐层"></property>-->
     <!--手动注入null-->
<!--     <property name="name">-->
<!--         <null/>-->
<!--     </property>-->
<!--     注入空字符串-->
<!--     <property name="name" value=""></property>-->
<!--     手动注入空字符串-->
     <property name="name">
         <value/>
     </property>
     <property name="age" value="5"></property>
 </bean>

测试类:

public class Test {
    @org.junit.Test
    public void TestDao() {
      ApplicationContext applicationContext=new ClassPathXmlApplicationContext("spring.xml");
      Cat c=applicationContext.getBean("mao",Cat.class);
      System.out.println(c);
        }
    }

8)注入特殊符号

 

package com.hei.dao;
public class Clazz {
   private String result;
    public void setResult(String result) {
        this.result = result;
    }
    @Override
    public String toString() {
        return "clazz{" +
                "result='" + result + '\'' +
                '}';
    }
}
<bean id="r" class="com.hei.dao.Clazz">
  <property name="result" value="2 &lt;3"></property>
 </bean>
public class Test {
    @org.junit.Test
    public void TestDao() {
      ApplicationContext applicationContext=new ClassPathXmlApplicationContext("spring.xml");
        Clazz c =applicationContext.getBean("r",Clazz.class);
      System.out.println(c);
        }
    }

4.p命名空间注入

简化set注入的一种方式,底层仍是set注入。在Spring配置头部添加p命名空间,使用p:属性名=“属性值”

package com.hei.dao;
import java.util.Date;
public class Cat {
    private String name;
    private int age;
    private Date birth;
    public void setName(String name) {
        this.name = name;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public void setBirth(Date birth) {
        this.birth = birth;
    }
    @Override
    public String toString() {
        return "Cat{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", birth=" + birth +
                '}';
    }
}
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<!-- 在Spring配置头部添加p命名空间-->
<!--    使用p:属性名=“属性值”-->
    <bean id="mao" class="com.hei.dao.Cat" p:name="小猫猫" p:age="3" p:birth-ref="birthday"></bean>
    <bean id="birthday" class="java.util.Date"></bean>

</beans>
public class Test {
    @org.junit.Test
    public void TestDao() {
      ApplicationContext applicationContext=new ClassPathXmlApplicationContext("spring.xml");
        Cat c =applicationContext.getBean("mao",Cat.class);
      System.out.println(c);
        }
    }

5.c命名空间注入

简化构造方法的一种注入方法。

 

package com.hei.dao;
public class Dog {
    private String name;
    private int age;
    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:c="http://www.springframework.org/schema/c"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="d" class="com.hei.dao.Dog" c:_0="柯基" c:_1="2"></bean>

</beans>
public class Test {
    @org.junit.Test
    public void TestDao() {
      ApplicationContext applicationContext=new ClassPathXmlApplicationContext("spring.xml");
        Dog dog =applicationContext.getBean("d",Dog.class);
      System.out.println(dog);
        }
    }

6.基于XML自动装配

自动化注入也叫做自动化装配,底层仍是set方法,分两种类型,一种是:通过名字,一种是:通过类型。

通过名字byName

Order类:

package com.hei.dao;
public class Order {
    public void insert(){
        System.out.println("这是订购信息");
    }
}

OrderSerivice类:

package com.hei.servece;
import com.hei.dao.Order;
public class OderService {
    private Order ord;
    public void setOrd(Order ord) {
        this.ord = ord;
    }
    public void generate(){
        ord.insert();
    }
}

spring.xml:

 <bean id="select" class="com.hei.servece.OderService" autowire="byName"></bean>
<!--    这个ID的名字不能乱写,应为set方法的名字(取掉set方法名和第一个大写字母变小写-->
    <bean id="ord" class="com.hei.dao.Order"></bean>

测试类:

public class Test {
    @org.junit.Test
    public void TestDao() {
      ApplicationContext applicationContext=new ClassPathXmlApplicationContext("spring.xml");
      OderService o =applicationContext.getBean("select",OderService.class);
      o.generate();
        }
    }

通过类型byType

UserDao类:

package com.hei.dao;
public class UserDao {
    public  void  insert(){
        System.out.println("数据正在保存信息");
    }
}

UserService类:

package com.hei.servece;
import com.hei.dao.UserDao;
public class UserService {
    private UserDao user;

    public void setUser(UserDao user) {
        this.user = user;
    }
    public void save(){
       user.insert();
   }
}

spring.xml:

  <bean class="com.hei.dao.UserDao"></bean>
    <bean id="user" class="com.hei.servece.UserService" autowire="byType"></bean>

测试类:

public class Test {
    @org.junit.Test
    public void TestDao() {
      ApplicationContext applicationContext=new ClassPathXmlApplicationContext("spring.xml");
      UserService u =applicationContext.getBean("user",UserService.class);
      u.save();
        }
    }

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

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

相关文章

HTML5+CSS3小实例:粘性文字的滚动效果

实例:粘性文字的滚动效果 技术栈:HTML+CSS 效果: 源码: 【HTML】 <!DOCTYPE html> <html lang="zh-CN"><head><meta charset="UTF-8"><meta name="viewport" content="width=device-width, initial-sca…

二叉树oj联习

判断是否为平衡二叉树 定义 oj题目 采用递归的思想 在gaodu函数中算出左子树的高度和右子树的高度 相减进行比较 再用递归遍历左右子树 依次算出每个结点的左右子树高度比较&#xff0c;只要有一个不符合条件则不为平衡二叉树 代码展示 int gaodu(struct TreeNode* a) {i…

PHP项目跨大版本升级,兼容性检测

项目中&#xff0c;经常因为各种原因&#xff0c;需要对老旧的项目进行跨大版本升级&#xff0c;比如从7.1升级到8.1 跨大版本升级会导致项目不可控&#xff0c;运行报错&#xff0c;出BUG等等问题&#xff0c;我们介绍一款工具用来解决此问题 php-compatibility检查PHP跨版本兼…

MySQL -- 锁机制

1. 表级锁和行级锁 表级锁&#xff08;Table-level Lock&#xff09; 表级锁是对整张表进行锁定&#xff0c;通常用于需要修改大量数据的操作。表级锁的优点是开销小&#xff0c;锁定快&#xff0c;但缺点是并发性能较差&#xff0c;因为一个表一旦被锁定&#xff0c;其他事务…

从0到100:找搭子小程序开发笔记(一)

背景调查 “找搭子”小程序&#xff1a;能够解决人们在社交、休闲和约会方面的需求&#xff0c;提供方便快捷的方式来找到合适的伴侣或活动伙伴。许多人在社交场合中感到焦虑或不安&#xff0c;因此他们更倾向于使用在线平台来认识新的朋友或搭子。有些人可能生活在一个较小或…

鸿蒙开发:应用组件跨设备交互(流转)【跨端迁移】

跨端迁移 概述 在用户使用设备的过程中&#xff0c;当使用情境发生变化时&#xff08;例如从室内走到户外或者周围有更适合的设备等&#xff09;&#xff0c;之前使用的设备可能已经不适合继续当前的任务&#xff0c;此时&#xff0c;用户可以选择新的设备来继续当前的任务&a…

刷代码随想录有感(100):动态规划——不同路径

题干&#xff1a; 代码&#xff1a; class Solution { public:int uniquePaths(int m, int n) {vector<vector<int>>dp(m,vector<int>(n, 0));for(int i 0; i < m; i) dp[i][0] 1;for(int j 0; j < n; j) dp[0][j] 1;for(int i 1; i < m; i){…

程序员日志之DNF手游6月5日罗特斯入门团本

目录 传送门正文日志1、概要1、散件装备过渡2、世界领主攻略和爬塔攻略3、团本攻略4、DNF剧情收集5、新版本预告6、合成冥域天空套&#xff08;天一&#xff09;7、额外重磅消息 传送门 SpringMVC的源码解析&#xff08;精品&#xff09; Spring6的源码解析&#xff08;精品&a…

UE4_后期_ben_模糊和锐化滤镜

学习笔记&#xff0c;不喜勿喷&#xff0c;侵权立删&#xff0c;祝愿生活越来越好&#xff01; 本篇教程主要介绍后期处理的简单模糊和锐化滤镜效果&#xff0c;学习之前首先要回顾下上节课介绍的屏幕扭曲效果&#xff1a; 这是全屏效果&#xff0c;然后又介绍了几种蒙版&#…

Java操作数据库 —— JDBC ① 基础篇

我走我的路&#xff0c;有人拦也走&#xff0c;没人陪也走 —— 24.6.7 JDBC JDBC就是使用Java语言操作关系型数据库的一套API 一、JDBC简介 JDBC 概念 JDBC 就是使用Java语言操作关系型数据库的一套API 全称:(Java DataBase Connectivity)意为Java 数据库连接 JDBC 本质: ①…

OCP前景咋样,工资高吗?

Oracle数据库作为企业级应用的基石&#xff0c;其专业人才一直是市场上的热门需求。 OCP认证&#xff0c;作为Oracle公司颁发的专业证书&#xff0c;OCP认证的持有者通常被视为具备了高级数据库管理、配置、备份、恢复、调优以及SQL编程等关键技能的专业人士。 这些技能在当今…

python生成excel数据并实现隔行变色

代码 from openpyxl import Workbook from datetime import date from openpyxl.styles import PatternFilldef create_excel():wb Workbook()sh wb.activerows [[Date, Batch 1, Batch 2, Batch 3],[date(2024, 2, 1), 40, 30, 25],[date(2024, 2, 2), 40, 25, 30],[date(…

如何低成本、高效搭建线上3D艺术展?

随着数字技术的日新月异&#xff0c;艺术展览领域正迎来一场革新。未来的艺术展览将不再是单一的线下体验&#xff0c;而是线上线下相互融合&#xff0c;其中&#xff0c;3D线上展览将成为线下展览的重要延伸与拓展&#xff0c;为广大观众提供更多元化的选择。 对于艺术家和策…

单机多卡分布式训练策略——MirroredStrategy

前言 分布式训练是一种用于在多个设备或机器上同时训练深度学习模型的技术&#xff0c;它有助于减少训练时间&#xff0c;允许使用更多数据更快训练大模型。分布式训练重点关注数据并行性&#xff0c;本次试验使用的是单机多卡的分布式训练策略&#xff0c;也就是 MirroredStr…

2023 hnust 湖科大 嵌入式 实验报告+代码及复习资料等

2023 hnust 湖科大 嵌入式 实验报告代码及复习资料等 目录 流水灯 1 8位数码管动态扫描 3 按键输入 5 温度与关照 7 看门狗 9 内容 报告 代码 下载链接 https://pan.baidu.com/s/1LIN8rm42yrukXliI3XyZ1g?pwd1111

iOS——KVO底层学习

前情回顾 什么是KVO&#xff1f;在之前的博客里我们已经学过&#xff1a; KVO全称Key Value Observing。KVO传值允许对象监听另一个对象的特定属性&#xff0c;当该属性改变的时候&#xff0c;会触发事件。 KVO不仅可以监听单个属性的变化&#xff0c;也可以监听集合对象的变…

进口电动温度调节阀的原理-美国品牌

进口电动温度调节阀的原理可以清晰地分为以下几个部分进行描述&#xff1a; 1. 温度感应与信号转换 温度传感器&#xff1a;负责感应介质&#xff08;如液体、气体等&#xff09;的温度&#xff0c;并将其转化为相应的电信号。这个电信号反映了介质当前的实际温度。 2. 信号…

数据结构——bitset(位图)模拟实现

从一个题目引出位图 给40亿个不重复的无符号整数&#xff0c;没排过序。给一个无符号整数&#xff0c;如何快速判断一个数是否在这40亿个数中&#xff1f; 这里有两种大家容易想到的解法&#xff1a; 1.遍历搜索&#xff0c;时间复杂度为O(N) 2.先排序&#xff08;O(NlogN)&a…

【DBA早下班系列】—— 并行SQL/慢SQL 问题该如何高效收集诊断信息

1. 前言 OceanBase论坛问答区或者提交工单支持的时候大部分时间都浪费在了诊断信息的获取交互上&#xff0c;今天我就其中大家比较头疼的SQL问题&#xff0c;给大家讲解一下如何一键收集并行SQL/慢SQL所需要的诊断信息&#xff0c;减少沟通成本&#xff0c;让大家早下班。 2. …

Linux安装——初入linux

前言&#xff1a;linux是雷纳斯托瓦斯在1991年接触到学校机房的装配unix操作系统的电脑后&#xff0c; 立志并且力行大学四年创建出来的操作系统。 在大佬创建linux后就将它的源代码公开——开源。 同时&#xff0c; 大佬给linux取得全名是&#xff1a; Linux is not unix。lin…