AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

Spring杂谈 | 你真的了解泛型吗？从java的Type到Spring的ResolvableType(1)

2022-11-12 235
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： Spring杂谈 | 你真的了解泛型吗？从java的Type到Spring的ResolvableType(1)

Type


简介


Type是Java 编程语言中所有类型的公共高级接口（官方解释），也就是Java中所有类型的“爹”；其中，“所有类型”的描述尤为值得关注。它并不是我们平常工作中经常使用的 int、String、List、Map等数据类型，而是从Java语言角度来说，对基本类型、引用类型向上的抽象；


Type体系中类型的包括：原始类型(Class)、参数化类型(ParameterizedType)、数组类型(GenericArrayType)、类型变量(TypeVariable)、基本类型(Class);


原始类型，不仅仅包含我们平常所指的类，还包括枚举、数组、注解等；


参数化类型，就是我们平常所用到的泛型List、Map<String,Integer>这种；


数组类型，并不是我们工作中所使用的数组String[] 、byte[]，而是带有泛型的数组，即T[] ；


基本类型，也就是我们所说的java的基本类型，即int,float,double等

Type体系的出现主要是为了解决泛型的一系列问题。


接口定义


public interface Type {
   // 返回这个类型的名称
    default String getTypeName() {
        return toString();
    }
}

可以看到Type接口内只定义了一个方法，这个方法会返回该类型的名称


UML类图


微信图片_20221112213339.png

在上面的图中对于Class我相信大家都已经很了解了。我们主要对其余四个子接口进行测试分析


ParameterizedType


简介


参数化类型，也就是我们所说的泛型。像List就是一个参数化类型，但是List并不是，因为没有使用泛型。


接口定义

public interface ParameterizedType extends Type {
  // 对于一个参数化类型而言，必定是带有泛型的，所有这里是为了获取到其中的泛型的具体类型，也就是<>中的内容
    // 返回一个数组是因为，有时候会定义多个泛型，比如Map<String,String>
    Type[] getActualTypeArguments();
  // 获取原始类型，这里不带泛型，就是class
    Type getRawType();
  // 获取这个类所在类的类型，这里可能比较拗口，举个例子，假如当前这个ParameterizedType的类型为
    // O<T>.I<U>，那么调用这个方法所返回的就是一个O<T>类型
    Type getOwnerType();
}

使用示例

public class Main extends OwnerTypeDemo<String> {
    private List<String> stringList;
    private Map<String, String> stringStringMap;
    private Map.Entry<String, ?> entry;
    private OwnerTypeDemo<String>.Test<String> testOwnerType;
    private List list;
    private Map map;
    public void test(List<String> stringList, List list) {
    }
    public static void main(String[] args) {
        Class<Main> mainClass = Main.class;
        Field[] fields = mainClass.getDeclaredFields();
        for (Field field : fields) {
            Type genericType = field.getGenericType();
            String typeName = genericType.getTypeName();
            String name = field.getName();
            if (genericType instanceof ParameterizedType) {
                System.out.println(name + "是一个参数化类型,类型名称为：" + typeName);
                ParameterizedType parameterizedType = (ParameterizedType) genericType;
                Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
                System.out.println(name + "的actualTypeArguments：" + Arrays.toString(actualTypeArguments));
                Type ownerType = parameterizedType.getOwnerType();
                System.out.println(name + "的ownerType：" + ownerType);
                Type rawType = parameterizedType.getRawType();
                System.out.println(name + "的rawType：" + rawType);
            } else {
                System.out.println(name + "不是一个参数化类型,类型名称为：" + typeName);
            }
        }
        System.out.println("===================开始测试方法中的参数=========================");
        Method[] declaredMethods = mainClass.getDeclaredMethods();
        for (Method declaredMethod : declaredMethods) {
            String methodName = declaredMethod.getName();
            Type[] genericParameterTypes = declaredMethod.getGenericParameterTypes();
            for (int i = 0; i < genericParameterTypes.length; i++) {
                Type parameterType = genericParameterTypes[i];
                String typeName = parameterType.getTypeName();
                System.out.println("打印" + methodName + "方法的参数，" + "第" + (i + 1) + "个参数为：" + parameterType);
                if (parameterType instanceof ParameterizedType) {
                    System.out.println("第" + (i + 1) + "个参数是一个参数化类型, 类型名称为 ： " + typeName);
                } else {
                    System.out.println("第" + (i + 1) + "个参数不是一个参数化类型, 类型名称为 ： " + typeName);
                }
            }
        }
        System.out.println("===================开始测试父类中的泛型=========================");
        // 获取带有泛型的父类
        Type genericSuperclass = mainClass.getGenericSuperclass();
        if (genericSuperclass instanceof ParameterizedType) {
            System.out.println("父类是一个参数化类型，类型名称为：" + genericSuperclass.getTypeName());
        }
    }
}
class OwnerTypeDemo<T> {
    class Test<T> {
    }
}

程序会做如下输出：

stringList是一个参数化类型,类型名称为：java.util.List<java.lang.String>
stringList的actualTypeArguments：[class java.lang.String]
stringList的ownerType：null
stringList的rawType：interface java.util.List
stringStringMap是一个参数化类型,类型名称为：java.util.Map<java.lang.String, java.lang.String>
stringStringMap的actualTypeArguments：[class java.lang.String, class java.lang.String]
stringStringMap的ownerType：null
stringStringMap的rawType：interface java.util.Map
entry是一个参数化类型,类型名称为：java.util.Map$Entry<java.lang.String, ?>
entry的actualTypeArguments：[class java.lang.String, ?]
entry的ownerType：interface java.util.Map
entry的rawType：interface java.util.Map$Entry
testOwnerType是一个参数化类型,类型名称为：main.java.OwnerTypeDemo<java.lang.String>$Test<java.lang.String>
testOwnerType的actualTypeArguments：[class java.lang.String]
testOwnerType的ownerType：main.java.OwnerTypeDemo<java.lang.String>
testOwnerType的rawType：class main.java.OwnerTypeDemo$Test
list不是一个参数化类型,类型名称为：java.util.List
map不是一个参数化类型,类型名称为：java.util.Map
===================开始测试方法中的参数=========================
打印main方法的参数，第1个参数为：class [Ljava.lang.String;
第1个参数不是一个参数化类型, 类型名称为 ： java.lang.String[]
打印test方法的参数，第1个参数为：java.util.List<java.lang.String>
第1个参数是一个参数化类型, 类型名称为 ： java.util.List<java.lang.String>
打印test方法的参数，第2个参数为：interface java.util.List
第2个参数不是一个参数化类型, 类型名称为 ： java.util.List
===================开始测试父类中的泛型=========================
父类是一个参数化类型，类型名称为：main.java.OwnerTypeDemo<java.lang.String>

通过上面的例子可以看出，ParameterizedType可以让我们明确字段或者方法参数上是否使用了泛型，并获取到泛型的具体类型。那是不是依赖ParameterizedType就能解决所有的泛型问题了呢？答案显然是不是的，我们看一个特殊的例子：

public class SpecialDemo<T extends Type> {
    T t;
    public static void main(String[] args) {
        Class<SpecialDemo> specialDemoClass = SpecialDemo.class;
        Field[] declaredFields = specialDemoClass.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            Type genericType = declaredField.getGenericType();
            if (genericType instanceof ParameterizedType) {
                System.out.println("t是一个参数化类型");
            } else {
                System.out.println("t不是一个参数化类型");
            }
        }
    }
    // 程序输出：t不是一个参数化类型
}

运行上面的程序，会发现字段t不是一个参数化类型，这就意味着没办法通过ParameterizedType来解决这一类泛型问题。我们分析<T extends Type>，会发现其实T类似于一个变量，我们可以在使用时可以传入具体的类，比如我们可以这样：

SpecialDemo<ParameterizedType> specialDemo = new SpecialDemo<>();

同时这个基于这个<T extends Type>表达式，我们知道这个变量是具有属性的，最直观的就是T是有上界的，所有的T都继承了Type。基于这种情况，Java对其进行了抽象，得到了一个新的类型TypeVariable。


TypeVariable


简介


类型变量，或者也可以叫泛型变量。具体就是指我们在申明泛型时定义的T,K,U这种变量。在之前的例子中，SpecialDemo<T extends Type>，T就是一个类型变量。


接口定义

public interface TypeVariable<D extends GenericDeclaration> extends Type, AnnotatedElement {
    // 获取泛型的边界
    Type[] getBounds();
  // 获取申明所在的具体对象
    D getGenericDeclaration();
  // 获取具体类型变量的名称
    String getName();
  // 获取类型变量边界上添加的注解
    AnnotatedType[] getAnnotatedBounds();
}

可以看到，TypeVariable本身也使用了泛型，并且泛型的上界为GenericDeclaration。在了解TypeVariable之前，有必要先对GenericDeclaration做一个简单的说明。GenericDeclaration这个接口主要限定了哪些地方可以定义TypeVariable，换言之，也就是定义了哪些地方可以申明泛型。这个接口只有3个实现类（忽略Executable抽象类）。如下：

image.png

从这里我们也能看到，我们只能在方法（包括普通方法跟构造方法）以及类上申明泛型。


这里需要对接口定义的方法做进一步的说明：


getBounds()会返回泛型的边界，但是这里的边界跟我们在参数化类型中定义的边界不同，这里的边界只有上界。即我们不通通过super关键字来申明一个泛型，例如下面这种：

class A<T super classA>{}

在申明泛型时，我们要明确一点，申明是为了使用，而在上面的例子中，我们不能使用T来干任何事情，因为我们不能确定T中的任何方法（只能确定它是一个Object，但是这没有任何意义）。所以对于泛型变量来说，只存在上界，也就是只能使用extends关键字进行申明


  1. getGenericDeclaration()，返回泛型申明时所在的类或者方法
  2. 返回泛型变量的名称，也就是我们定义泛型时采用的T,K,U这一类的名称
  3. getAnnotatedBounds()，此方法返回一个AnnotatedType类型的数组，获取的是我们在类型变量的上界。不同于getBounds()方法的是，这个方法可以获取到边界上添加的注解


使用示例


public class TypeVariableMain<T, K extends @TypeAnnotation Integer & Type> {
    public <U extends Long, V> void testTypeVariable(Map<U, V> map) {
    }
    public static void main(String[] args) {
        Class<TypeVariableMain> typeVariableMainClass = TypeVariableMain.class;
        TypeVariable<Class<TypeVariableMain>>[] typeParameters = typeVariableMainClass.getTypeParameters();
        for (int i = 0; i < typeParameters.length; i++) {
            TypeVariable<Class<TypeVariableMain>> typeParameter = typeParameters[i];
            Type[] bounds = typeParameter.getBounds();
            String name = typeParameter.getName();
            AnnotatedType[] annotatedBounds = typeParameter.getAnnotatedBounds();
            Class<TypeVariableMain> genericDeclaration = typeParameter.getGenericDeclaration();
            System.out.println("第" + (i + 1) + "个类型变量的名称为：" + name);
            System.out.println("通过getBounds方法获取到，第" + (i + 1) + "个类型变量的边界为：" + Arrays.toString(bounds));
            System.out.println("第" + (i + 1) + "个类型变量的申明的位置为：" + genericDeclaration);
            System.out.println("通过getAnnotatedBounds方法获取到，第" + (i + 1) + "个类型变量的边界为："
                    + Arrays.stream(annotatedBounds).map(AnnotatedType::getType).collect(Collectors.toList()));
            for (AnnotatedType annotatedType : annotatedBounds) {
                Annotation[] annotations = annotatedType.getAnnotations();
                if (annotations.length > 0) {
                    System.out.println("第" + (i + 1) + "个类型变量的上界上添加了注解，注解为" + annotations[0]);
                }
            }
        }
        System.out.println("===================基于方法获取类型变量====================");
        Method[] declaredMethods = typeVariableMainClass.getDeclaredMethods();
        for (Method declaredMethod : declaredMethods) {
            String methodName = declaredMethod.getName();
            if (methodName.equals("main")) {
                // 为了方便，直接排除main函数了
                continue;
            }
            TypeVariable<Method>[] typeVariables = declaredMethod.getTypeParameters();
            int i = 1;
            for (TypeVariable<Method> typeVariable : typeVariables) {
                System.out.println("方法：\"" + methodName + "\"的第" + (i++) + "个类型变量为" + typeVariable.getName());
            }
        }
    }
}

程序打印如下：

第1个类型变量的名称为：T
通过getBounds方法获取到，第1个类型变量的边界为：[class java.lang.Object]
第1个类型变量的申明的位置为：class main.java.TypeVariableMain
通过getAnnotatedBounds方法获取到，第1个类型变量的边界为：[class java.lang.Object]
第2个类型变量的名称为：K
通过getBounds方法获取到，第2个类型变量的边界为：[class java.lang.Integer, interface java.lang.reflect.Type]
第2个类型变量的申明的位置为：class main.java.TypeVariableMain
通过getAnnotatedBounds方法获取到，第2个类型变量的边界为：[class java.lang.Integer, interface java.lang.reflect.Type]
第2个类型变量的上界上添加了注解，注解为@main.java.TypeAnnotation()
===================基于方法获取类型变量====================
方法："testTypeVariable"的第1个类型变量为U
方法："testTypeVariable"的第2个类型变量为V

为了让大家加深对ParameterizedType以及TypeVariable理解，这里我额外添加一个Demo

public class TypeVariableMain02<T, K extends @TypeAnnotation Integer & Type> {
    private K k;
    private List<T> list;
    public static void main(String[] args) {
        Class<TypeVariableMain02> typeVariableMain02Class = TypeVariableMain02.class;
        Field[] declaredFields = typeVariableMain02Class.getDeclaredFields();
        for (Field field : declaredFields) {
            Type genericType = field.getGenericType();
            String typeName = genericType.getTypeName();
            String name = field.getName();
            if (genericType instanceof ParameterizedType) {
                System.out.println(name + "是一个参数化类型,类型名称为：" + typeName);
                ParameterizedType parameterizedType = (ParameterizedType) genericType;
                Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
                System.out.println(name + "的actualTypeArguments：" + Arrays.toString(actualTypeArguments));
                Type ownerType = parameterizedType.getOwnerType();
                System.out.println(name + "的ownerType：" + ownerType);
                Type rawType = parameterizedType.getRawType();
                System.out.println(name + "的rawType：" + rawType);
                for (Type actualTypeArgument : actualTypeArguments) {
                    if (actualTypeArgument instanceof TypeVariable) {
                        System.out.println("字段：" + name + "中包含一个类型变量");
                        String name1 = ((TypeVariable) actualTypeArgument).getName();
                        AnnotatedType[] annotatedBounds = ((TypeVariable) actualTypeArgument).getAnnotatedBounds();
                        Type[] bounds = ((TypeVariable) actualTypeArgument).getBounds();
                        GenericDeclaration genericDeclaration = ((TypeVariable) actualTypeArgument).getGenericDeclaration();
                        System.out.println("类型变量的名称为：" + name1);
                        System.out.println("个类型变量的边界为：" + Arrays.toString(bounds));
                        System.out.println("类型变量的申明的位置为：" + genericDeclaration);
                        System.out.println("通过getAnnotatedBounds方法获取到，类型变量的边界为：" + annotatedBounds[0].getType());
                    }
                }
            } else if (genericType instanceof TypeVariable) {
                System.out.println(name + "是一个类型变量,类型名称为：" + typeName);
                TypeVariable typeVariable = (TypeVariable) genericType;
                Type[] bounds = typeVariable.getBounds();
                String name1 = typeVariable.getName();
                AnnotatedType[] annotatedBounds = typeVariable.getAnnotatedBounds();
                GenericDeclaration genericDeclaration = typeVariable.getGenericDeclaration();
                System.out.println("类型变量的名称为：" + name1);
                System.out.println("个类型变量的边界为：" + Arrays.toString(bounds));
                System.out.println("类型变量的申明的位置为：" + genericDeclaration);
                System.out.println("通过getAnnotatedBounds方法获取到，类型变量的边界为：" + annotatedBounds[0].getType() + "  " + annotatedBounds[1].getType());
            }
        }
    }
}

程序输出：

k是一个类型变量,类型名称为：K
类型变量的名称为：K
个类型变量的边界为：[class java.lang.Integer, interface java.lang.reflect.Type]
类型变量的申明的位置为：class main.java.TypeVariableMain02
通过getAnnotatedBounds方法获取到，类型变量的边界为：class java.lang.Integer  interface java.lang.reflect.Type
list是一个参数化类型,类型名称为：java.util.List<T>
list的actualTypeArguments：[T]
list的ownerType：null
list的rawType：interface java.util.List
字段：list 中包含一个类型变量
类型变量的名称为：T
个类型变量的边界为：[class java.lang.Object]
类型变量的申明的位置为：class main.java.TypeVariableMain02
通过getAnnotatedBounds方法获取到，类型变量的边界为：class java.lang.Object

GenericArrayType


简介


GenericArrayType是Type的子接口，用于表示“泛型数组”，描述的是形如：A[]或T[]的类型。其实也就是描述ParameterizedType类型以及TypeVariable类型的数组，即形如：classA[][]、T[]等


接口定义


public interface GenericArrayType extends Type {
    // 返回数组中元素的类型，TypeVariable或者ParameterizedType
    Type getGenericComponentType();
}

使用示例


public class GenericArrayTypeMain<T> {
    T[] t1;
    T[][] t2;
    List<T> list;
    List<String>[] stringListArray;
    String[][] stringArray;
    public static void main(String[] args) {
        Class<GenericArrayTypeMain> genericArrayTypeMainClass = GenericArrayTypeMain.class;
        Field[] declaredFields = genericArrayTypeMainClass.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            String name = declaredField.getName();
            Type genericType = declaredField.getGenericType();
            if (genericType instanceof GenericArrayType) {
                System.out.println(name + "是一个泛型数组");
                Type genericComponentType = ((GenericArrayType) genericType).getGenericComponentType();
                System.out.println("数组的元素类型为：" + genericComponentType);
            } else {
                System.out.println(name + "不是一个泛型数组");
            }
        }
    }
}

程序输出：

t1是一个泛型数组
数组的元素类型为：T
t2是一个泛型数组
数组的元素类型为：T[]
list不是一个泛型数组
stringListArray是一个泛型数组
数组的元素类型为：java.util.List<java.lang.String>
stringArray不是一个泛型数组

通过上面的Demo我们会发现，无论从左向右有几个[]并列，这个方法仅仅脱去最右边的[]之后剩下的内容就作为这个方法的返回值。


另外，在上面的例子中，大家可以思考以下几个问题：


t1是一个泛型数组，数组的元素类型为：T，那么T是一个什么类型呢？

t2是一个泛型数组，数组的元素类型为：T[]，那么T[]又是什么类型？

上述问题留给大家自行思考


了解了ParameterizedType跟TypeVariable以及这两种类型的数组类型GenericArrayType之后，接着我们思考一个问题，我们在定义泛型时，经常会使用来通配符，形如下面这种形式{? extends Number}，这个时候即使我们获取到? extends Number也没有办法做进一步的处理。这个时候就要用到我们接下来要介绍的这个接口了，请往下看


WildcardType


简介


专门用来处理泛型中的通配符，需要注意的是，WildcardType并不是JAVA所有类型中的一种，表示的仅仅是类似 {? extends T}、{? super K}这样的通配符表达式。


接口定义


public interface WildcardType extends Type {
    // 获取通配符表达式的上界
    Type[] getUpperBounds();
    // 获取通配符表达式的下界
    Type[] getLowerBounds();
}

上面这两个方法之所以会返回数组是为了保持扩展性，实际上现在返回的数组的大小就是1，JDK8中至少是这样的吗，更高版本的没有去尝试。


使用示例


public class WildcardTypeDemo<T> {
    Map<? super String, ? extends List<T>> map;
    public static void main(String[] args) {
        Class<WildcardTypeDemo> wildcardTypeDemoClass = WildcardTypeDemo.class;
        Field[] declaredFields = wildcardTypeDemoClass.getDeclaredFields();
        for (Field field : declaredFields) {
            Type genericType = field.getGenericType();
            if (genericType instanceof ParameterizedType) {
                // 使用了通配符表达泛型的，必定是一个参数化类型
                // 获取泛型的实际类型，就是获取<>中的内容,这里获取到的是<? super String, ? extends List<T>>
                Type[] actualTypeArguments = ((ParameterizedType) genericType).getActualTypeArguments();
                for (Type actualTypeArgument : actualTypeArguments) {
                    // 两个泛型都使用了通配符，都会进入这个判断
                    if (actualTypeArgument instanceof WildcardType) {
                        // 分別获取上界跟下界
                        // ? super String，这个表达式的下界为String,上界为Object
                        // ? extends List<T>，这个表达式的下界为Object,上界为List<T>，
                        // 同时List<T>又是一个参数化类型，而T又是一个类型变量
                        Type[] lowerBounds = ((WildcardType) actualTypeArgument).getLowerBounds();
                        Type[] upperBounds = ((WildcardType) actualTypeArgument).getUpperBounds();
                        // 这里我主要处理? extends List<T>
                        for (Type upperBound : upperBounds) {
                            if (upperBound instanceof ParameterizedType) {
                                System.out.println("参数化类型的名称为：" + upperBound.getTypeName());
                                Type[] actualTypeArguments1 = ((ParameterizedType) upperBound).getActualTypeArguments();
                                for (Type type : actualTypeArguments1) {
                                    if (type instanceof TypeVariable) {
                                        String name = ((TypeVariable) type).getName();
                                        System.out.println("类型变量名称为：" + name);
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    // 程序输出：
    // 参数化类型的名称为：java.util.List<T>
  // 类型变量名称为：T

我相信如果你对Java中的类型已经完全理解了，上面的代码配合注释应该不难看懂

文章标签：
Java
Spring
uml
关键词：
Spring java
Java Spring
Java泛型
Java type
泛型Java
程序员DMZ
目录
相关文章
途途途途
|
6天前
|
Java 应用服务中间件 数据库连接
Java 新手入门：Spring Boot 启动揭秘，小白也能秒懂的超详细指南
Java 新手入门：Spring Boot 启动揭秘，小白也能秒懂的超详细指南
途途途途
22 2
热爱技术的小郑
|
5天前
|
安全 Java 数据库
一天十道Java面试题----第四天（线程池复用的原理------＞spring事务的实现方式原理以及隔离级别）
这篇文章是关于Java面试题的笔记，涵盖了线程池复用原理、Spring框架基础、AOP和IOC概念、Bean生命周期和作用域、单例Bean的线程安全性、Spring中使用的设计模式、以及Spring事务的实现方式和隔离级别等知识点。
热爱技术的小郑
30 3
服务端技术栈
|
3天前
|
人工智能 自然语言处理 Java
Spring AI，Spring团队开发的新组件，Java工程师快来一起体验吧
文章介绍了Spring AI，这是Spring团队开发的新组件，旨在为Java开发者提供易于集成的人工智能API，包括机器学习、自然语言处理和图像识别等功能，并通过实际代码示例展示了如何快速集成和使用这些AI技术。
服务端技术栈
13 3
Spring AI，Spring团队开发的新组件，Java工程师快来一起体验吧
热爱技术的小郑
|
5天前
|
前端开发 Java 数据库连接
一天十道Java面试题----第五天（spring的事务传播机制------＞mybatis的优缺点）
这篇文章总结了Java面试中的十个问题，包括Spring事务传播机制、Spring事务失效条件、Bean自动装配方式、Spring、Spring MVC和Spring Boot的区别、Spring MVC的工作流程和主要组件、Spring Boot的自动配置原理和Starter概念、嵌入式服务器的使用原因，以及MyBatis的优缺点。
热爱技术的小郑
10 2
萝卜丝丸子
|
4天前
|
缓存 Java Spring
Java本地高性能缓存实践问题之的Spring Boot中启用缓存支持问题如何解决
Java本地高性能缓存实践问题之的Spring Boot中启用缓存支持问题如何解决
萝卜丝丸子
7 0
睡觉待开机
|
5天前
|
Java
【Java】内部类、枚举、泛型
【Java】内部类、枚举、泛型
睡觉待开机
4 0
服务端技术栈
|
6天前
|
设计模式 前端开发 Java
Spring，作为Java程序员的你能想到什么呢？
该文章主要介绍了Spring框架对于Java程序员的意义，包括Spring框架的一些核心能力和为什么它是如此重要。
服务端技术栈
17 0
ktee5tyrczvty
|
6天前
|
JavaScript 前端开发 网络协议
WebSocket在Java Spring Boot+Vue框架中实现消息推送功能
在现代Web应用中，实时消息提醒是一项非常重要的功能，能够极大地提升用户体验。WebSocket作为一种在单个TCP连接上进行全双工通信的协议，为实现实时消息提醒提供了高效且低延迟的解决方案。本文将详细介绍如何在Java Spring Boot后端和Vue前端框架中利用WebSocket实现消息提醒功能。
ktee5tyrczvty
19 0
途途途途
|
6天前
|
前端开发 Java Spring
Java 新手入门：Spring Boot 轻松整合 Spring 和 Spring MVC！
Java 新手入门：Spring Boot 轻松整合 Spring 和 Spring MVC！
途途途途
18 0
理想shi做条咸鱼
|
21天前
|
Java 测试技术 数据库
Spring Boot中的项目属性配置
本节课主要讲解了 Spring Boot 中如何在业务代码中读取相关配置，包括单一配置和多个配置项，在微服务中，这种情况非常常见，往往会有很多其他微服务需要调用，所以封装一个配置类来接收这些配置是个很好的处理方式。除此之外，例如数据库相关的连接参数等等，也可以放到一个配置类中，其他遇到类似的场景，都可以这么处理。最后介绍了开发环境和生产环境配置的快速切换方式，省去了项目部署时，诸多配置信息的修改。
理想shi做条咸鱼
47 0

热门文章

最新文章

  • 1
    Java 基础【03】序列化和反序列化
  • 2
    Windows2003 配置 tomcat+jdk（java）+JDBC+SQL2000
  • 3
    java转义符和正则表达式转义符
  • 4
    Eclipse 中java跨工程调用类
  • 5
    Java语言实现简单FTP软件------&gt;本地文件管理模块的实现(九)
  • 6
    java: 警告: 源发行版 11 需要目标发行版 11”错误解决(解决方案整合)
  • 7
    Java基本数据类型与位运算
  • 8
    C#与Java对比学习：类型判断、类与接口继承、代码规范与编码习惯、常量定义
  • 9
    黑马程序员java笔记之十-----银行管理系统
  • 10
    用Java实现按字节长度截取字符串的方法
  • 1
    Springboot框架整合Spring JDBC操作数据
    40
  • 2
    Springboot框架整合Spring Data JPA操作数据
    45
  • 3
    Spring事务与分布式事务
    38
  • 4
    Spring Boot单元测试报错java.lang.IllegalStateException: Could not load TestContextBootstrapper [null]
    76
  • 5
    Spring Cloud Feign 使用Apache的HTTP Client替换Feign原生httpclient
    148
  • 6
    如何在Spring框架中实现横切关注点的集中管理和重用？
    32
  • 7
    在Spring框架中，IoC和AOP是如何实现的？
    49
  • 8
    Spring IoC容器通过依赖注入机制实现控制反转
    40
  • 9
    在Spring Bean中，如何通过Java配置类定义Bean?
    42
  • 10
    【初学者慎入】Spring源码中的16种设计模式实现
    119

    • 相关课程

    更多
  • Java Web开发系列课程 - Spring框架入门
  • Java面向对象开发
  • Java高级开发
  • Java零基础入门
  • Spring Boot 2.5.x开发实战
  • Spring Cloud微服务架构设计与开发实战

    • 相关电子书

    更多
  • 云栖社区特邀专家徐雷Java Spring Boot开发实战系列课程（第20讲）：经典面试题与阿里等名企内部招聘求职面试技巧
  • 微服务架构模式与原理Spring Cloud开发实战
  • 阿里特邀专家徐雷Java Spring Boot开发实战系列课程（第18讲）：制作Java Docker镜像与推送到DockerHub和阿里云Docker仓库

    • 相关实验场景

    更多
  • 基于ECS搭建Java Web开发环境
  • 使用Aliyun Java Intializr进行项目开发
  • 从零搭建Spring Boot的Hello World
  • 搭建Java Web开发环境
  • 部署基于Dragonwell的Java运行环境
  • 阿里云平台上进行Java程序的编译与运行
    • 下一篇
    通义千问API入门教程