Java 注解在 Android 中的使用场景

Java 元注解有 5 种,常用的是 @Target 和 @Retention 两个。

其中 @Retention 表示保留级别,有三种:

  • RetentionPolicy.SOURCE - 标记的注解仅保留在源码级别中,并被编译器忽略
  • RetentionPolicy.CLASS - 标记的注解在编译时由编译器保留,但 JVM 会忽略
  • RetentionPolicy.RUNTIME - 标记的注解由 JVM 保留,因此运行时环境可以使用它

这三个值表示的生命周期为 SOURCE < CLASS < RUNTIME,即 RUNTIME 生命周期最长,涵盖了 SOURCE 和 CLASS,其次是 CLASS 的生命周期涵盖了 SOURCE。

不同的保留级别有不同的应用场景:

enter description here

1、源码级别应用场景

1.1 APT

Annotation Processor Tools,即注解处理器。它在由源文件(.java)被 javac 编译成为字节码文件(.class)这个过程中,先采集到所有的注解信息并封装到 Element 对象中,然后再由 javac 自动调用注解处理器,无须手动调用。

接下来对使用方法做一个简介。

先创建一个保留级别为源码级别的注解:

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.SOURCE)
public @interface Frank {int value();String id();
}

然后创建一个 Java-Library 模块,来编写注解处理程序。模块的代码结构如下:

APT 模块结构

注册注解处理器

先注册注解处理器文件。只有注册后它才能被 javac 调用。注册方式有两种,一是按照上图的路径创建同名的文件夹和文件(路径名固定,不要自己发挥),然后在 javax.annotation.processing.Processor 文件中将注解处理器文件的全类名写在里面即可:

com.frank.compiler.MyProcessor

另一种方式就是使用 AutoService 自动生成。首先在模块 gradle 中加入依赖:

dependencies {implementation 'com.google.auto.service:auto-service:1.0-rc6'annotationProcessor 'com.google.auto.service:auto-service:1.0-rc6'
}

AutoService 与 gradle-5.4.1 以上版本有兼容性问题,必须要向上边那样把 annotationProcessor 的依赖也写上才能避免无法自动生成 Processor 文件的情况。在 gradle-6.1.1 上亲测可行。

然后在注解处理器文件的类加上 AutoService 的注解:

@AutoService(Processor.class)
public class MyProcessor extends AbstractProcessor {@Overridepublic boolean process(Set<? extends TypeElement> set, RoundEnvironment roundEnvironment) {return false;}
}

AutoService 的值固定为 Processor.class。编译后在 module/build/classes/java/main/META-INF/services/ 目录下就能找到 javax.annotation.processing.Processor 文件了,其内容与手动构建的是一样的。

注解处理器使用

注解处理类需要继承 AbstractProcessor 才具有处理注解的能力,通过重写 process() 可以对注解进行处理:

@AutoService(Processor.class)
public class MyProcessor extends AbstractProcessor {@Overridepublic boolean process(Set<? extends TypeElement> set, RoundEnvironment roundEnvironment) {Messager messager = processingEnv.getMessager();messager.printMessage(Diagnostic.Kind.NOTE, "注解处理器输出!");return false;}
}

以上只是简单的输出了一句 log,本节不会具体介绍注解处理器结合具体业务该如何编写,仅介绍一般的使用流程。

想要让这句 log 能打印出来,还需要在类名上边打上 @SupportedAnnotationTypes 注解,表示我们关心的注解类型,其值为我们要处理的注解的全类名,以我们前边的 @Frank 注解为例,就应该写成:

@AutoService(Processor.class)
@SupportedAnnotationTypes("com.example.myapplication.Frank")
public class MyProcessor extends AbstractProcessor {// .....
}

最后,在需要使用注解处理器的模块的 gradle 文件中,引入注解处理器模块 compiler:

dependencies {annotationProcessor project(':compiler')
}

这样在编译后就能看到 log 输出了:

注意输出是在执行 compileDebugJavaWithJavac 任务时输出的,再次说明了,注解处理器由 javac 自动调用并分析了其中的源码。也印证了 APT 是源码保留级别适用的技术。

1.2 IDE 语法检查

之所以叫 IDE 语法检查是因为,检测语法的是 IDE 工具(或其插件),并不是 Java 编译器。

在 Android 中我们需要设计接口以供使用者调用时,如出现需要对方法参数进行类型限定,如限定为资源 ID、布局 ID 等类型参数时,可以利用 Android 为我们提供的语法检查注解,来辅助进行更为直接的参数类型检查与提示。

在 androidx.annotation 包下有很多这样的注解,如 @DrawableRes、@IdRes、@LayoutRes 等等,想要使用它们需要先引入依赖:

    implementation 'androidx.annotation:annotation:1.2.0-alpha01'

使用时可以把它们加载方法类型之前:

    public final Drawable getDrawable(@DrawableRes int id) {return getResources().getDrawable(id, getTheme());}

这样在调用 getDrawable() 方法时,就必须传入一个 Drawable 的资源值,IDE 就会在实参位置有红色下划线提示,注意编译是不会报错的:

除了上述的注解之外,还有几个元注解 @IntDef、@LongDef、@StringDef,利用它们可以自定义类似于 @DrawableRes、@IdRes、@LayoutRes 这样的注解。典型应用就是用注解替代枚举以节省内存。

Java 中 Enum (枚举)的实质是特殊单例的静态成员变量,在运行期所有枚举类作为单例,全部加载到内存中。比常量多 5 到 10 倍的内存占用。每个枚举值,也就是枚举对象的构成为 12 个字节的对象头 + 所有成员变量,另外还有个 8 字节对齐。

@IntDef 的源码:

@Retention(SOURCE)
@Target({ANNOTATION_TYPE})
public @interface IntDef {/** Defines the allowed constants for this element */int[] value() default {};boolean flag() default false;boolean open() default false;
}

通过 value() 可以指定注解能包含哪些值。下面就利用这一点看看如何用注解替换枚举:

public class Gender {/*enum Gender {MALE, FEMALE}*/public static final int MALE = 0;public static final int FEMALE = 1;private int gender;@Retention(RetentionPolicy.SOURCE)@Target(ElementType.PARAMETER)@IntDef({MALE, FEMALE})@interface GenderInt {}public void setGender(@GenderInt int gender) {this.gender = gender;}
}

Gender 类表示性别,这里我们不用枚举,而是把男性和女性分别定义成两个整型常量 0 和 1。使用 @IntDef 注解自定义一个 @GenderInt 注解,用 @Target(ElementType.PARAMETER) 指定作用在参数上,用 @IntDef({MALE, FEMALE}) 规定可选值只有 MALE, FEMALE 两个。

在外部调用 setGender() 时,如果传入的值不在 MALE, FEMALE 之中,IDE 就会提醒:

使用源码级别注解的典型框架是 ARouter。关于 Android 组件化以及 ARouter 原理可以参考 Android 组件化基础(二)—— 仿 ARouter 实现一个路由框架。

2、字节码级别应用场景

字节码增强,也称为字节码插桩,说白了就是在字节码文件里写代码和修改。过程大概是:

.class 文件 -> 用 IO 流读写 class 文件 -> byte[] -> 按照 .class 文件格式进行修改。

这里仅举简单例子,不具体扩展。对字节码插桩感兴趣的可以去看 ASM 字节码插桩入门。

假如要统计每个方法的执行时间,并且不想在源代码的方法中加入时间统计代码,那就可以把需要统计的方法打上注解,编译之后在字节码的方法首末加入统计运行时间的代码:

添加 @InjectTime 注解

字节码文件插入统计时间代码

ARouter、ButterKnife 都是字节码保留级别的典型应用。

3、运行时级别应用场景

最典型的就是反射。

3.1 通过反射实现 findViewById()

一个最简单的示例就是通过反射 + 注解实现 findViewById()。

首先定义一个运行时级别的注解 @Inject:

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Inject {int value();
}

值是被 @Inject 修饰控件的资源 ID。

然后编写工具类,拿到控件 ID 后,调用 findViewById() 得到控件对象,最后通过反射把对象设置给控件:

public class InjectUtils {public static void inject(Activity activity) {Class<? extends Activity> aClass = activity.getClass();Field[] fields = aClass.getDeclaredFields();for (Field field : fields) {if (field.isAnnotationPresent(Inject.class)) {Inject annotation = field.getAnnotation(Inject.class);int id = annotation.value();View view = activity.findViewById(id);field.setAccessible(true);try {field.set(activity, view);} catch (IllegalAccessException e) {e.printStackTrace();}}}}
}

给控件打上注解并标明资源 ID,进行测试:

public class MainActivity extends AppCompatActivity {@Inject(R.id.button)private Button button;@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(R.layout.activity_main);InjectUtils.inject(this);button.setText("Inject Success");}
}

3.2 通过反射获取真实泛型类型

当我们对一个泛型类进行反射时,需要得到泛型中的真实数据类型,来完成如 Json 反序列化的操作。此时需要通过 Type 体系来完成。 Type 接口包含了一个实现类 Class 和四个实现接口,他们分别是:

  • TypeVariable 泛型类型变量,可以获取泛型上下限等信息
  • ParameterizedType 具体的泛型类型,可以获得元数据中泛型签名类型(泛型真实类型)
  • GenericArrayType 当需要描述的类型是泛型类的数组时,比如 List[]、Map[],此接口会作为 Type 的实现
  • WildcardType 通配符泛型,获得上下限信息

下面来介绍一个获取泛型真实类型的典型应用。

典型应用 —— Gson 反序列化

对从服务器接收的响应数据进行反序列化是项目中的常规操作。我们举个例子,假如使用 Gson 进行反序列化,用 Response 表示响应体,用 Data 表示 Response 中携带的真实数据:

public class Response<T> {private T data;private int code;private String message;public Response(T data, int code, String message) {this.data = data;this.code = code;this.message = message;}...
}public class Data {private String result;public Data(String result) {this.result = result;}@Overridepublic String toString() {return "Data{" +"result='" + result + '\'' +'}';}
}

模拟从服务器接收数据进行反序列化的过程:

public class Test {public static void main(String[] args) {// 构造一个 Response 对象模拟服务器返回的数据Response<Data> response = new Response<>(new Data("数据"),1,"成功");Gson gson = new Gson();String json = gson.toJson(response);System.out.println(json);// 反序列化,由于没有提供 Response 内 data 的真实类型,所以反序列化失败抛出异常Response<Data> responseData = gson.fromJson(json, Response.class);System.out.println(responseData.getData().getClass());}
}

执行上述代码会抛出异常:

Exception in thread "main" java.lang.ClassCastException: com.google.gson.internal.LinkedTreeMap cannot be cast to com.frank.reflect.Dataat com.frank.reflect.Test.main(Test.java:16)FAILURE: Build failed with an exception.

如果反序列化的 Bean 没有泛型,那么可以使用 public <T> T fromJson(String json, Class<T> classOfT) 方法进行反序列化,但如果像 Response 那样带有泛型,但是却没提供泛型的真实类型,就会抛出上面的异常。

解决方案是使用 TypeToken 提供 Response<Data> 的类型参数 Data 给 fromJson():

public class Test {public static void main(String[] args) {// 构造一个 Response 对象模拟服务器返回的数据Response<Data> response = new Response<>(new Data("数据"), 1, "成功");Gson gson = new Gson();String json = gson.toJson(response);System.out.println(json);// 反序列化,通过创建 TypeToken 的匿名子类获取到 Response 的真实类型,即 DataType type = new TypeToken<Response<Data>>() {}.getType();Response<Data> responseData = gson.fromJson(json, type);System.out.println(responseData.getData().getClass());}
}

这样就能正确输出反序列化结果了:

{"data":{"result":"数据"},"code":1,"message":"成功"}
class com.frank.reflect.Data

解决问题的原理

为何通过匿名子类对象获取到类型参数?原因有二:

  1. Java 泛型在编译期被擦除,因此运行时无法直接获取到 Response<Data> 上的类型参数
  2. 匿名子类会保存类型参数。因为编译器会生成一个合成类来表示匿名子类的类型,并且在合成类中会保留泛型信息。这样做的目的是为了在匿名子类中能够正确地访问和使用泛型类型

基于以上两点,我们来看 Gson 源码是如何通匿名子类获取类型参数的:

public class TypeToken<T> {final Class<? super T> rawType;final Type type;final int hashCode;/*** 客户端创建一个空的匿名子类。这样做可以将类型参数嵌入到匿名类的类型层次结构中,* 因此我们可以在运行时重新构造它,尽管它被删除了*/protected TypeToken() {// 1.对匿名子类调用 getSuperclassTypeParameter() 获取类型参数this.type = getSuperclassTypeParameter(getClass());this.rawType = (Class<? super T>) $Gson$Types.getRawType(type);this.hashCode = type.hashCode();}static Type getSuperclassTypeParameter(Class<?> subclass) {// 2.getGenericSuperclass() 会返回 subclass 所表示的实体(类、接口、原始类型或 void)的// 直接父类的类型,这个类型是带有泛型信息的Type superclass = subclass.getGenericSuperclass();if (superclass instanceof Class) {throw new RuntimeException("Missing type parameter.");}ParameterizedType parameterized = (ParameterizedType) superclass;// 3.取所有泛型类型的首个类型做规范化转换后返回return $Gson$Types.canonicalize(parameterized.getActualTypeArguments()[0]);}public final Type getType() {return type;}
}public final class $Gson$Types {public static Type canonicalize(Type type) {if (type instanceof Class) {Class<?> c = (Class<?>) type;return c.isArray() ? new GenericArrayTypeImpl(canonicalize(c.getComponentType())) : c;} else if (type instanceof ParameterizedType) {// 如果是一个参数化类型就返回一个 ParameterizedTypeImpl 的实例ParameterizedType p = (ParameterizedType) type;return new ParameterizedTypeImpl(p.getOwnerType(),p.getRawType(), p.getActualTypeArguments());} else if (type instanceof GenericArrayType) {GenericArrayType g = (GenericArrayType) type;return new GenericArrayTypeImpl(g.getGenericComponentType());} else if (type instanceof WildcardType) {WildcardType w = (WildcardType) type;return new WildcardTypeImpl(w.getUpperBounds(), w.getLowerBounds());} else {// type is either serializable as-is or unsupportedreturn type;}}
}

实际上 TypeToken 构造方法上,官方给的注释已经提示了使用匿名子类的原因。具体的实现步骤可以分三步:

  1. 将 TypeToken 的构造方法声明为 protected,也就是说,在 TypeToken 所在的 com.google.gson.reflect 包之外,想要拿到 TypeToken 或其子类对象,就无法通过 new TypeToken() 的方法,而只能使用创建匿名子类对象的方式,即 new TypeToken(){}。getClass() 拿到的就是这个匿名子类:class com.frank.reflect.Test$1(在 Test 内声明的匿名子类),然后对这个匿名子类调用 getSuperclassTypeParameter()
  2. 在 getSuperclassTypeParameter() 内先对匿名子类调用 getGenericSuperclass() 获取到带有泛型信息的父类,即 TypeToken<Response<Data>>
  3. 将父类对象转换为 ParameterizedType,并调用其 getActualTypeArguments() 获取到真实的类型参数数组,取数组的第 0 个(在这个例子中就是 Response<Data>)传入 G s o n Gson GsonTypes.canonicalize() 将结果进行规范化并返回

TypeToken 设计的巧妙之处就在于用 protected 的构造方法迫使你使用匿名子类才能构建其对象,然后在 getSuperclassTypeParameter() 方法中用这个匿名子类对象对应的 Class 去获取含有泛型的直接父类,就是 TypeToken<T>。使用匿名子类获取真实类型参数的做法也很值得借鉴。

4、练习

通过反射 + 注解实现被启动 Activity 自动获取 Intent 中携带的数据。详细点说,就是在 Activity1 通过 Intent 启动 Activity2 时,可能会给 Intent 通过 putXxxExtra() 的形式附带一些参数。在 Activity2 中拿到 Intent 对象之后需要一个一个地把数据从 Intent 中拿出来,过程繁琐。我们要优化的就是从 Intent 中手动拿数据这个过程。

首先在 MainActivity 中建立一些要传递的数据,包含多种类型:

public class MainActivity extends AppCompatActivity {// 需要作为 Intent 的参数被传递的变量要提出来做成员变量private String string;private String attr;private int[] array;private UserParcelable userParcelable;private UserParcelable[] userParcelables;private List<UserParcelable> userParcelableList;private UserSerializable userSerializable;@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(R.layout.activity_main);Intent intent = new Intent(MainActivity.this, SecondActivity.class);ArrayList<Parcelable> parcelables = new ArrayList<>();parcelables.add(new UserParcelable("user3"));intent.putExtra("StringKey", "testString").putExtra("attr", "attr").putExtra("array", new int[]{1, 2}).putExtra("userParcelable", new UserParcelable("cat")).putExtra("userParcelables", new UserParcelable[]{new UserParcelable("user1"),new UserParcelable("user2")}).putExtra("userParcelableList", parcelables).putExtra("userSerializable", new UserSerializable("user4"));startActivity(intent);}
}

其中 UserParcelable 与 UserSerializable 两个类型分别模拟实现了 Parcelable 和 Serializable 接口的 JavaBean 类型:

public class UserParcelable implements Parcelable {String name;public UserParcelable(String name) {this.name = name;}protected UserParcelable(Parcel in) {name = in.readString();}public static final Creator<UserParcelable> CREATOR = new Creator<UserParcelable>() {@Overridepublic UserParcelable createFromParcel(Parcel in) {return new UserParcelable(in);}@Overridepublic UserParcelable[] newArray(int size) {return new UserParcelable[size];}};@Overridepublic int describeContents() {return 0;}@Overridepublic void writeToParcel(Parcel dest, int flags) {dest.writeString(name);}
}
------------------------------------------------------------------
public class UserSerializable implements Serializable {String name;public UserSerializable(String name) {this.name = name;}
}

然后新建一个注解 @InjectExtras:

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface InjectExtras {String value() default "";
}

用法是标记接收 Intent 数据一方的成员变量,value() 默认为空,为空时说明 MainActivity 在存数据的时候,key 和变量名是一样的,如果不一样,就把 key 作为 value:

public class SecondActivity extends AppCompatActivity {@InjectExtras("StringKey")private String string;@InjectExtrasprivate String attr;@InjectExtrasprivate int[] array;@InjectExtrasprivate UserParcelable userParcelable;@InjectExtras("userParcelables")private UserParcelable[] userParcelables;@InjectExtrasprivate List<UserParcelable> userParcelableList;@InjectExtrasprivate UserSerializable userSerializable;@Overrideprotected void onCreate(@Nullable Bundle savedInstanceState) {super.onCreate(savedInstanceState);InjectUtils.injectExtra(this);}
}

最后实现工具方法:

	/*** 拿到 activity 后,遍历所有成员变量,筛选出被 @InjectExtras 注释的成员,* 获得其对应的属性 Key 值,然后通过 getIntent().getExtras() 获取到对方* 发送的参数 Bundle,然后根据 Key 从中取出 Value,最后通过反射的方式为接* 收方的成员变量赋值。** @param activity 接收参数的 Activity*/public static void injectExtra(Activity activity) {Class<? extends Activity> clazz = activity.getClass();Field[] fields = clazz.getDeclaredFields();Bundle extras = activity.getIntent().getExtras();for (Field field : fields) {if (field.isAnnotationPresent(InjectExtras.class)) {InjectExtras annotation = field.getAnnotation(InjectExtras.class);if (annotation == null) {Log.e(TAG, "Get annotation @InjectExtras failed.");return;}// 找到 field 在发送方存入参数的 key,并取出对应的 valueString key = TextUtils.isEmpty(annotation.value()) ? field.getName() : annotation.value();Object object = extras.get(key);// value 如果是 Parcelable[] 则不能直接赋值,其它类型可以,所以通过 getComponentType()// 获取数组元素类型,如果不是数组则返回 nullClass<?> componentType = field.getType().getComponentType();if (componentType != null && field.getType().isArray() && Parcelable.class.isAssignableFrom(componentType)) {// 确定了 object 是 Parcelable[],进行转换Object[] objArray = (Object[]) object;// 使用工具类将数组内元素转换成 field 对应的类型,即 UserParcelable// 第三个参数实际上要获取的是 UserParcelable[].class 这个类型,只能通过反射获取object = Arrays.copyOf(objArray, objArray.length, (Class<? extends Object[]>) field.getType());}field.setAccessible(true);try {field.set(activity, object);} catch (IllegalAccessException e) {e.printStackTrace();}}}}

获取 Extra 中 key 的规则是,如果 Field 被 @InjectExtras 注解指定了 value,那么就用指定的值,否则默认使用变量名。

拿到 key 之后获取对应的 value,如果 value 类型不是 Parcelable[] 的话就可以直接设置给对应的 Field 了;如果是的话,需要进行一个转化再赋值。这一步中需要注意,如果 field 是 UserParcelable[],那么 field.getType() 得到的是 class [Lxxx.xxx.UserParcelable,再调用 getComponentType() 就拿到了数组内的元素类型 class xxx.xxx.UserParcelable。由于不能将 object 直接做类型强转为 Parcelable[],所以借用 Arrays.copyOf() 做这个类型转换,第三个参数 field.getType() 的结果不能直接用,编译不过,需要将 class [Lxxx.xxx.UserParcelable 转换为 Class<? extends Object[]>,因为 field.getType() 返回的类型实际上是一个 Class<?>,强转成 Class<? extends UserParcelable[]> 会有 unchecked warning,但是转成 Class<? extends Object[]> 就不会。

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

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

相关文章

【C++高阶(五)】哈希思想--哈希表哈希桶

&#x1f493;博主CSDN主页:杭电码农-NEO&#x1f493;   ⏩专栏分类:C从入门到精通⏪   &#x1f69a;代码仓库:NEO的学习日记&#x1f69a;   &#x1f339;关注我&#x1faf5;带你学习C   &#x1f51d;&#x1f51d; 哈希结构 1. 前言2. unordered系列容器3. 哈希概…

EM32DX-C1【分布式io】

1设备类型&#xff1a; 电压&#xff1a;DC24V 输入16点 输出16点雷赛 EM32DX-C1 模块是一款基于 ASIC 技术的高性能、高可靠性的 CANopen 总线数字 量输入输出扩展模块&#xff0c;具有 16 路通用输入接口和 16 路通用输出接口。输入输出接口均采用光 电隔离和…

手机爬虫用Fiddler详细教程

如果你正在进行手机爬虫的工作&#xff0c;那么一款强大而又实用的网络调试工具Fiddler将会是你的好帮手。今天&#xff0c;我将和大家分享一份详细的Fiddler教程&#xff0c;教你如何使用它来轻松捕获和分析手机App的网络请求。让我们一起来探索Fiddler的功能和操作&#xff0…

visual Studio MFC 绘制单一颜色三角形、渐变颜色边框三角形、渐变填充三角形、边框渐变的正方形与填充渐变的正方形实例

MFC 绘制三角形 本文使用visual Studio MFC 平台实现绘制单一颜色三角形、渐变颜色边框三角形、渐变填充三角形、边框渐变的正方形与填充渐变的正方形. 关于基础工程的创建请参考Visual Studio 使用MFC 单文档工程绘制单一颜色直线和绘制渐变颜色的直线 文章目录 MFC 绘制三角形…

IO和NIO的区别 BIO,NIO,AIO 有什么区别? Files的常用方法都有哪些?

文章目录 IO和NIO的区别BIO,NIO,AIO 有什么区别?Files的常用方法都有哪些&#xff1f; 今天来对java中的io, nio, bio, aio进行了解&#xff0c;有何区别。 IO和NIO的区别 NIO与IO区别 IO是面向流的&#xff0c;NIO是面向缓冲区的Java IO面向流意味着每次从流中读一个或多个字…

《经济学人》深度解析之OpenAI董事会风波

上周全球最受瞩目的财经事件莫过于如日中天的OpenAI董事会风波所带来的反转之反转剧情。 故事的结局相信大家都已知悉&#xff1a;OpenAI在开除创始人山姆奥特曼&#xff08;Sam Altman&#xff09;几天后&#xff0c;重新任命他为首席执行官&#xff0c;并成立了一个新的董事…

linux LVM /dev/sdb mount dir /data【linux LVM 磁盘挂载目录】

添加磁盘 /dev/sdb rootregistry01 ~]# fdisk -lDisk /dev/sda: 53.7 GB, 53687091200 bytes, 104857600 sectors Units sectors of 1 * 512 512 bytes Sector size (logical/physical): 512 bytes / 512 bytes I/O size (minimum/optimal): 512 bytes / 512 bytes Disk lab…

机器学习(1)机器学习类型和机器学习的主要概念

0.前提 深度学习&#xff08;Deep Learing&#xff09;是机器学习&#xff08;Machine Learning&#xff09;领域中的一个新的研究方向&#xff0c;在如今的时代研究深度学习的大模型是十分热门的。我不知道有多少人有关注到最近openai的事件啊&#xff0c;说个比较让我惊讶的…

系列十八、Spring bean线程安全问题

一、概述 我们知道Spring中的bean&#xff0c;默认情况下是单例的&#xff0c;那么Spring中的bean是线程安全的吗&#xff1f;这个需要分情况考虑&#xff0c;bean中是否存在成员变量&#xff1f;bean中的成员变量是怎么处理的&#xff1f;...&#xff0c;针对bean的状态会有不…

FaceChain集成最强开源SDXL,生成人像质感拉满!

一、介绍 FaceChain&#xff0c;一款备受欢迎的AI写真开源项目&#xff0c;目前已与最强大的开源生图模型SDXL完美融合&#xff01;这将为用户带来前所未有的高质量AI写真体验。 FaceChain是一个可以用来打造个人数字形象的深度学习模型工具。用户仅需要提供最低一张照片即可获…

vue.js如何根据后台返回来的图片url进行图片下载

原创/朱季谦 最近在做一个前端vue.js对接的功能模块时&#xff0c;需要实现一个下载图片的功能&#xff0c;后台返回来的是一串图片url&#xff0c;试了很多种方法&#xff0c;发现点击下载时出来的效果&#xff0c;都是跳到一个新的图片网页&#xff0c;后来经过一番琢磨&…

『Linux升级路』基础开发工具——make/Makefile

&#x1f525;博客主页&#xff1a;小王又困了 &#x1f4da;系列专栏&#xff1a;Linux &#x1f31f;人之为学&#xff0c;不日近则日退 ❤️感谢大家点赞&#x1f44d;收藏⭐评论✍️ 目录 一、认识make/Makefile &#x1f4d2;1.1make/Makefile的优点 &#x1f4d2;…