java反射超詳細(xì)講解
Java反射超詳解✌
1.反射基礎(chǔ)
Java反射機(jī)制是在程序的運(yùn)行過程中，對于任何一個類，都能夠知道它的所有屬性和方法；對于任意一個對象，都能夠知道它的任意屬性和方法，這種動態(tài)獲取信息以及動態(tài)調(diào)用對象方法的功能稱為Java語言的反射機(jī)制。
Java反射機(jī)制主要提供以下這幾個功能：
- 在運(yùn)行時判斷任意一個對象所屬的類
- 在運(yùn)行時構(gòu)造任意一個類的對象
- 在運(yùn)行時判斷任意一個類所有的成員變量和方法
- 在運(yùn)行時調(diào)用任意一個對象的方法
1.1Class類
Class類，Class類也是一個實實在在的類，存在于JDK的java.lang包中。Class類的實例表示java應(yīng)用運(yùn)行時的類(class ans enum)或接口(interface and annotation)（每個java類運(yùn)行時都在JVM里表現(xiàn)為一個class對象，可通過類名.class、類型.getClass()、Class.forName("類名")等方法獲取class對象）。數(shù)組同樣也被映射為為class 對象的一個類，所有具有相同元素類型和維數(shù)的數(shù)組都共享該 Class 對象?；绢愋蚥oolean，byte，char，short，int，long，float，double和關(guān)鍵字void同樣表現(xiàn)為 class 對象。
到這我們也就可以得出以下幾點(diǎn)信息：
- Class類也是類的一種，與class關(guān)鍵字是不一樣的。
- 手動編寫的類被編譯后會產(chǎn)生一個Class對象，其表示的是創(chuàng)建的類的類型信息，而且這個Class對象保存在同名.class的文件中(字節(jié)碼文件)。
- 每個通過關(guān)鍵字class標(biāo)識的類，在內(nèi)存中有且只有一個與之對應(yīng)的Class對象來描述其類型信息，無論創(chuàng)建多少個實例對象，其依據(jù)的都是用一個Class對象。
- Class類只存私有構(gòu)造函數(shù)，因此對應(yīng)Class對象只能有JVM創(chuàng)建和加載。
- Class類的對象作用是運(yùn)行時提供或獲得某個對象的類型信息，這點(diǎn)對于反射技術(shù)很重要(關(guān)于反射稍后分析)。
1.2類加載
1.類加載機(jī)制流程
2.類的加載
注：詳細(xì)的類加載內(nèi)容，看JVM板塊。
2.反射的使用
2.1Class對象的獲取
在類加載的時候，jvm會創(chuàng)建一個class對象。class對象可以說是反射中最常見的。
獲取class對象的方式的主要三種：
- 根據(jù)類名：類名.class
- 根據(jù)對象：對象.getClass()
- 根據(jù)全限定類名：Class.forName(全限定類名)
public class demo1Main1 {
public static void main(String[] args) throws Exception {
//獲取Class對象的三種對象
System.out.println("根據(jù)類名：\t" + User.class);
System.out.println("根據(jù)對象：\t" + new User().getClass());
System.out.println("根據(jù)全限定類名：\t" + Class.forName("demo1.User"));
//常用的方法
Class<User> userClass = User.class;
System.out.println("獲取全限定類名：\t" + userClass.getName());
System.out.println("獲取類名：\t" + userClass.getSimpleName());
System.out.println("實例化：\t" + userClass.newInstance());
}
}
輸出結(jié)果：
根據(jù)類名： class demo1.User
根據(jù)對象： class demo1.User
根據(jù)全限定類名： class demo1.User
獲取全限定類名： demo1.User
獲取類名： User
實例化： User{name='init', age=0}
再來看看Class類的方法：
toSting()
public String toString() {
return (isInterface() ? "interface " : (isPrimitive() ? "" : "class "))
+ getName();
}
toString()方法能夠?qū)ο筠D(zhuǎn)換為字符串，toString()首先判斷Class類型是否是接口類型，也就是說普通類和接口都能用Class對象表示，然后在判斷是否是基本數(shù)據(jù)類型，這里判斷的都是基本數(shù)據(jù)類型和包裝類，還有void類型。
getName()
獲取類的全限定名稱。（包括包名）即類的完整名稱。
1.如果是引用類型。比如 String.class.getName()→java.lang.String
2.如果是基本數(shù)據(jù)類型。比如 byte.class.getName()→byte
3.如果是數(shù)組類型。比如 new Object[3].getClass().getName()→[Ljava.lang.Object;
getSimpleName()
獲取類名（不包括包名）。
getCanonicalName()
獲取全限定的類名(包括包名)。
toGenericString()
返回類的全限定名稱，而且包括類的修飾符和類型參數(shù)信息。
forName()
根據(jù)類名獲得一個Class對象的引用，這個方法會使類對象進(jìn)行初始化。
例如：Class t = Class.forName("java.lang.Thread")就能夠初始化一個Thread線程對象。
在Java中，一共有三種獲取類實例的方式：
1.Class.forName(java.lang.Thread)
2.Thread.class
3.thread.getClass()
newInstance()
創(chuàng)建一個類的實例，代表著這個類的對象。上面forName()方法對類進(jìn)行初始化，newInstance方法對類進(jìn)行實例化。使用該方法創(chuàng)建的類，必須帶有無參的構(gòu)造器。
getClassLoader()
獲取類加載器對象。
getInterfaces()
獲取當(dāng)前類實現(xiàn)的類或是接口，可能是多個，所以返回的是Class數(shù)組。
isInterface()
判斷Class對象是否是表示一個接口。
getFields()
獲得某個類的所有的公共（public）的字段，包括繼承自父類的所有公共字段。 類似的還有getMethods和getConstructors。
getDeclaredFields
獲得某個類的自己聲明的字段，即包括public、private和proteced，默認(rèn)但是不包括父類聲明的任何字段。類似的還有getDeclaredMethods和getDeclaredConstructors。
getName、getCanonicalName與getSimpleName的區(qū)別：
getSimpleName：只獲取類名.getName：類的全限定名，jvm中Class的表示，可以用于動態(tài)加載Class對象，例如Class.forName。getCanonicalName：返回更容易理解的表示，主要用于輸出（toString）或log打印，大多數(shù)情況下和getName一樣，但是在內(nèi)部類、數(shù)組等類型的表示形式就不同了。
例子：
package com.cry;
public class Test {
private class inner{
}
public static void main(String[] args) throws ClassNotFoundException {
//普通類
System.out.println(Test.class.getSimpleName()); //Test
System.out.println(Test.class.getName()); //com.cry.Test
System.out.println(Test.class.getCanonicalName()); //com.cry.Test
//內(nèi)部類
System.out.println(inner.class.getSimpleName()); //inner
System.out.println(inner.class.getName()); //com.cry.Test$inner
System.out.println(inner.class.getCanonicalName()); //com.cry.Test.inner
//數(shù)組
System.out.println(args.getClass().getSimpleName()); //String[]
System.out.println(args.getClass().getName()); //[Ljava.lang.String;
System.out.println(args.getClass().getCanonicalName()); //java.lang.String[]
//我們不能用getCanonicalName去加載類對象，必須用getName
//Class.forName(inner.class.getCanonicalName()); 報錯
Class.forName(inner.class.getName());
}
}
2.2Constructor類及其用法
Constructor類存在于反射包(java.lang.reflect)中，反映的是Class 對象所表示的類的構(gòu)造方法。
獲取Constructor對象是通過Class類中的方法獲取的，Class類與Constructor相關(guān)的主要方法如下：
| 方法返回值 | 方法名稱 | 方法說明 |
|---|---|---|
| Constructor | getConstructor(Class<?>… parameterTypes) | 返回指定參數(shù)類型、具有public訪問權(quán)限的構(gòu)造函數(shù)對象 |
| Constructor<?>[] | getConstructors() | 返回所有具有public訪問權(quán)限的構(gòu)造函數(shù)的Constructor對象數(shù)組 |
| Constructor | getDeclaredConstructor(Class<?>… parameterTypes) | 返回指定參數(shù)類型、所有聲明的（包括private）構(gòu)造函數(shù)對象 |
| Constructor<?>[] | getDeclaredConstructors() | 返回所有聲明的（包括private）構(gòu)造函數(shù)對象 |
| T | newInstance() | 調(diào)用無參構(gòu)造器創(chuàng)建此 Class 對象所表示的類的一個新實例。 |
栗子：
public class ConstructionTest implements Serializable {
public static void main(String[] args) throws Exception {
Class<?> clazz = null;
//獲取Class對象的引用
clazz = Class.forName("com.example.javabase.User");
//第一種方法，實例化默認(rèn)構(gòu)造方法，User必須無參構(gòu)造函數(shù),否則將拋異常
User user = (User) clazz.newInstance();
user.setAge(20);
user.setName("Jack");
System.out.println(user);
System.out.println("--------------------------------------------");
//獲取帶String參數(shù)的public構(gòu)造函數(shù)
Constructor cs1 =clazz.getConstructor(String.class);
//創(chuàng)建User
User user1= (User) cs1.newInstance("hiway");
user1.setAge(22);
System.out.println("user1:"+user1.toString());
System.out.println("--------------------------------------------");
//取得指定帶int和String參數(shù)構(gòu)造函數(shù),該方法是私有構(gòu)造private
Constructor cs2=clazz.getDeclaredConstructor(int.class,String.class);
//由于是private必須設(shè)置可訪問
cs2.setAccessible(true);
//創(chuàng)建user對象
User user2= (User) cs2.newInstance(25,"hiway2");
System.out.println("user2:"+user2.toString());
System.out.println("--------------------------------------------");
//獲取所有構(gòu)造包含private
Constructor<?> cons[] = clazz.getDeclaredConstructors();
// 查看每個構(gòu)造方法需要的參數(shù)
for (int i = 0; i < cons.length; i++) {
//獲取構(gòu)造函數(shù)參數(shù)類型
Class<?> clazzs[] = cons[i].getParameterTypes();
System.out.println("構(gòu)造函數(shù)["+i+"]:"+cons[i].toString() );
System.out.print("參數(shù)類型["+i+"]:(");
for (int j = 0; j < clazzs.length; j++) {
if (j == clazzs.length - 1)
System.out.print(clazzs[j].getName());
else
System.out.print(clazzs[j].getName() + ",");
}
System.out.println(")");
}
}
}
class User {
private int age;
private String name;
public User() {
super();
}
public User(String name) {
super();
this.name = name;
}
/**
* 私有構(gòu)造
* @param age
* @param name
*/
private User(int age, String name) {
super();
this.age = age;
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "User{" +
"age=" + age +
", name='" + name + '\'' +
'}';
}
}
輸出結(jié)果：
User{age=20, name='Jack'}
--------------------------------------------
user1:User{age=22, name='hiway'}
--------------------------------------------
user2:User{age=25, name='hiway2'}
--------------------------------------------
構(gòu)造函數(shù)[0]:private com.example.javabase.User(int,java.lang.String)
參數(shù)類型[0]:(int,java.lang.String)
構(gòu)造函數(shù)[1]:public com.example.javabase.User(java.lang.String)
參數(shù)類型[1]:(java.lang.String)
構(gòu)造函數(shù)[2]:public com.example.javabase.User()
參數(shù)類型[2]:()
關(guān)于Constructor類本身一些常用方法如下(僅部分，其他可查API)：
| 方法返回值 | 方法名稱 | 方法說明 |
|---|---|---|
| Class | getDeclaringClass() | 返回 Class 對象，該對象表示聲明由此 Constructor 對象表示的構(gòu)造方法的類,其實就是返回真實類型（不包含參數(shù)） |
| Type[] | getGenericParameterTypes() | 按照聲明順序返回一組 Type 對象，返回的就是 Constructor對象構(gòu)造函數(shù)的形參類型。 |
| String | getName() | 以字符串形式返回此構(gòu)造方法的名稱。 |
| Class<?>[] | getParameterTypes() | 按照聲明順序返回一組 Class 對象，即返回Constructor 對象所表示構(gòu)造方法的形參類型 |
| T | newInstance(Object… initargs) | 使用此 Constructor對象表示的構(gòu)造函數(shù)來創(chuàng)建新實例 |
| String | toGenericString() | 返回描述此 Constructor 的字符串，其中包括類型參數(shù)。 |
栗子：
Constructor cs3 = clazz.getDeclaredConstructor(int.class,String.class);
System.out.println("-----getDeclaringClass-----");
Class uclazz=cs3.getDeclaringClass();
//Constructor對象表示的構(gòu)造方法的類
System.out.println("構(gòu)造方法的類:"+uclazz.getName());
System.out.println("-----getGenericParameterTypes-----");
//對象表示此 Constructor 對象所表示的方法的形參類型
Type[] tps=cs3.getGenericParameterTypes();
for (Type tp:tps) {
System.out.println("參數(shù)名稱tp:"+tp);
}
System.out.println("-----getParameterTypes-----");
//獲取構(gòu)造函數(shù)參數(shù)類型
Class<?> clazzs[] = cs3.getParameterTypes();
for (Class claz:clazzs) {
System.out.println("參數(shù)名稱:"+claz.getName());
}
System.out.println("-----getName-----");
//以字符串形式返回此構(gòu)造方法的名稱
System.out.println("getName:"+cs3.getName());
System.out.println("-----getoGenericString-----");
//返回描述此 Constructor 的字符串，其中包括類型參數(shù)。
System.out.println("getoGenericString():"+cs3.toGenericString());
輸出結(jié)果：
-----getDeclaringClass----- 構(gòu)造方法的類:com.example.javabase.User -----getGenericParameterTypes----- 參數(shù)名稱tp:int 參數(shù)名稱tp:class java.lang.String -----getParameterTypes----- 參數(shù)名稱:int 參數(shù)名稱:java.lang.String -----getName----- getName:com.example.javabase.User -----getoGenericString----- getoGenericString():private com.example.javabase.User(int,java.lang.String)
2.3Field類及其用法
Field 提供有關(guān)類或接口的單個字段的信息，以及對它的動態(tài)訪問權(quán)限。反射的字段可能是一個類（靜態(tài)）字段或?qū)嵗侄巍?/p>
同樣的道理，我們可以通過Class類的提供的方法來獲取代表字段信息的Field對象，Class類與Field對象相關(guān)方法如下：
| 方法返回值 | 方法名稱 | 方法說明 |
|---|---|---|
| Field | getDeclaredField(String name) | 獲取指定name名稱的(包含private修飾的)字段，不包括繼承的字段 |
| Field[] | getDeclaredField() | 獲取Class對象所表示的類或接口的所有(包含private修飾的)字段,不包括繼承的字段 |
| Field | getField(String name) | 獲取指定name名稱、具有public修飾的字段，包含繼承字段 |
| Field[] | getField() | 獲取修飾符為public的字段，包含繼承字段 |
栗子：
public class ReflectField {
public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
Class<?> clazz = Class.forName("reflect.Student");
//獲取指定字段名稱的Field類,注意字段修飾符必須為public而且存在該字段,
// 否則拋NoSuchFieldException
Field field = clazz.getField("age");
System.out.println("field:"+field);
//獲取所有修飾符為public的字段,包含父類字段,注意修飾符為public才會獲取
Field fields[] = clazz.getFields();
for (Field f:fields) {
System.out.println("f:"+f.getDeclaringClass());
}
System.out.println("================getDeclaredFields====================");
//獲取當(dāng)前類所字段(包含private字段),注意不包含父類的字段
Field fields2[] = clazz.getDeclaredFields();
for (Field f:fields2) {
System.out.println("f2:"+f.getDeclaringClass());
}
//獲取指定字段名稱的Field類,可以是任意修飾符的自動,注意不包含父類的字段
Field field2 = clazz.getDeclaredField("desc");
System.out.println("field2:"+field2);
}
}
class Person{
public int age;
public String name;
//省略set和get方法
}
class Student extends Person{
public String desc;
private int score;
//省略set和get方法
}
輸出結(jié)果:
field:public int reflect.Person.age
f:public java.lang.String reflect.Student.desc
f:public int reflect.Person.age
f:public java.lang.String reflect.Person.name
================getDeclaredFields====================
f2:public java.lang.String reflect.Student.desc
f2:private int reflect.Student.score
field2:public java.lang.String reflect.Student.desc
上述方法需要注意的是，如果我們不期望獲取其父類的字段，則需使用Class類的getDeclaredField/getDeclaredFields方法來獲取字段即可，倘若需要連帶獲取到父類的字段，那么請使用Class類的getField/getFields，但是也只能獲取到public修飾的的字段，無法獲取父類的私有字段。下面將通過Field類本身的方法對指定類屬性賦值，代碼演示如下：
//獲取Class對象引用
Class<?> clazz = Class.forName("reflect.Student");
Student st= (Student) clazz.newInstance();
//獲取父類public字段并賦值
Field ageField = clazz.getField("age");
ageField.set(st,18);
Field nameField = clazz.getField("name");
nameField.set(st,"Lily");
//只獲取當(dāng)前類的字段,不獲取父類的字段
Field descField = clazz.getDeclaredField("desc");
descField.set(st,"I am student");
Field scoreField = clazz.getDeclaredField("score");
//設(shè)置可訪問，score是private的
scoreField.setAccessible(true);
scoreField.set(st,88);
System.out.println(st.toString());
//輸出結(jié)果：Student{age=18, name='Lily ,desc='I am student', score=88}
//獲取字段值
System.out.println(scoreField.get(st));
// 88
其中的set(Object obj, Object value) 方法是Field類本身的方法，用于設(shè)置字段的值，而get(Object obj)則是獲取字段的值，當(dāng)然關(guān)于Field類還有其他常用的方法如下：
| 方法返回值 | 方法名稱 | 方法說明 |
|---|---|---|
| void | set(Object obj, Object value) | 將指定對象變量上此 Field 對象表示的字段設(shè)置為指定的新值。 |
| Object | get(Object obj) | 返回指定對象上此 Field 表示的字段的值 |
| Class<?> | getType() | 返回一個 Class 對象，它標(biāo)識了此Field 對象所表示字段的聲明類型。 |
| boolean | isEnumConstant() | 如果此字段表示枚舉類型的元素則返回 true；否則返回 false |
| String | toGenericString() | 返回一個描述此 Field（包括其一般類型）的字符串 |
| String | getName() | 返回此 Field 對象表示的字段的名稱 |
| Class<?> | getDeclaringClass() | 返回表示類或接口的 Class 對象，該類或接口聲明由此 Field 對象表示的字段 |
| void | setAccessible(boolean flag) | 將此對象的 accessible 標(biāo)志設(shè)置為指示的布爾值,即設(shè)置其可訪問性 |
上述方法可能是較為常用的，事實上在設(shè)置值的方法上，F(xiàn)ield類還提供了專門針對基本數(shù)據(jù)類型的方法，如setInt()/getInt()、setBoolean()/getBoolean、setChar()/getChar()等等方法，這里就不全部列出了，需要時查API文檔即可。需要特別注意的是被final關(guān)鍵字修飾的Field字段是安全的，在運(yùn)行時可以接收任何修改，但最終其實際值是不會發(fā)生改變的。
2.4Method類及其用法
Method 提供關(guān)于類或接口上單獨(dú)某個方法（以及如何訪問該方法）的信息，所反映的方法可能是類方法或?qū)嵗椒ǎòǔ橄蠓椒ǎ?/p>
下面是Class類獲取Method對象相關(guān)的方法：
| 方法返回值 | 方法名稱 | 方法說明 |
|---|---|---|
| Method | getDeclaredMethod(String name, Class<?>… parameterTypes) | 返回一個指定參數(shù)的Method對象，該對象反映此 Class 對象所表示的類或接口的指定已聲明方法。 |
| Method[] | getDeclaredMethod | 返回 Method 對象的一個數(shù)組，這些對象反映此 Class 對象表示的類或接口聲明的所有方法，包括公共、保護(hù)、默認(rèn)（包）訪問和私有方法，但不包括繼承的方法。 |
| Method | getMethod(String name, Class<?>… parameterTypes) | 返回一個 Method 對象，它反映此 Class 對象所表示的類或接口的指定公共成員方法。 |
| Method[] | getMethods() | 返回一個包含某些 Method 對象的數(shù)組，這些對象反映此 Class 對象所表示的類或接口（包括那些由該類或接口聲明的以及從超類和超接口繼承的那些的類或接口）的公共成員方法。 |
在通過getMethods方法獲取Method對象時，會把父類的方法也獲取到，如上的輸出結(jié)果，把Object類的方法都打印出來了。而getDeclaredMethod/getDeclaredMethods方法都只能獲取當(dāng)前類的方法。我們在使用時根據(jù)情況選擇即可。下面將演示通過Method對象調(diào)用指定類的方法：
Class clazz = Class.forName("reflect.Circle");
//創(chuàng)建對象
Circle circle = (Circle) clazz.newInstance();
//獲取指定參數(shù)的方法對象Method
Method method = clazz.getMethod("draw",int.class,String.class);
//通過Method對象的invoke(Object obj,Object... args)方法調(diào)用
method.invoke(circle,15,"圈圈");
//對私有無參方法的操作
Method method1 = clazz.getDeclaredMethod("drawCircle");
//修改私有方法的訪問標(biāo)識
method1.setAccessible(true);
method1.invoke(circle);
//對有返回值得方法操作
Method method2 =clazz.getDeclaredMethod("getAllCount");
Integer count = (Integer) method2.invoke(circle);
System.out.println("count:"+count);
輸出結(jié)果：
draw 圈圈,count=15 drawCircle count:100
在上述代碼中調(diào)用方法，使用了Method類的invoke(Object obj,Object… args) 第一個參數(shù)代表調(diào)用的對象，第二個參數(shù)傳遞的調(diào)用方法的參數(shù)。這樣就完成了類方法的動態(tài)調(diào)用。
| 方法返回值 | 方法名稱 | 方法說明 |
|---|---|---|
| Object | invoke(Object obj, Object… args) | 對帶有指定參數(shù)的指定對象調(diào)用由此 Method 對象表示的底層方法。 |
| Class<?> | getReturnType() | 返回一個 Class 對象，該對象描述了此 Method 對象所表示的方法的正式返回類型，即方法的返回類型 |
| Type | getGenericReturnType() | 返回表示由此 Method 對象所表示方法的正式返回類型的 Type 對象，也是方法的返回類型。 |
| Class<?>[] | getParameterTypes() | 按照聲明順序返回 Class 對象的數(shù)組，這些對象描述了此 Method 對象所表示的方法的形參類型。即返回方法的參數(shù)類型組成的數(shù)組 |
| Type[] | getGenericParameterTypes() | 按照聲明順序返回 Type 對象的數(shù)組，這些對象描述了此 Method 對象所表示的方法的形參類型的，也是返回方法的參數(shù)類型 |
| String | getName() | 以 String 形式返回此 Method 對象表示的方法名稱，即返回方法的名稱 |
| boolean | isVarArgs() | 判斷方法是否帶可變參數(shù)，如果將此方法聲明為帶有可變數(shù)量的參數(shù)，則返回 true；否則，返回 false。 |
| String | toGenericString() | 返回描述此 Method 的字符串，包括類型參數(shù)。 |
getReturnType方法/getGenericReturnType方法都是獲取Method對象表示的方法的返回類型，只不過前者返回的Class類型后者返回的Type(前面已分析過)，Type就是一個接口而已，在Java8中新增一個默認(rèn)的方法實現(xiàn)，返回的就參數(shù)類型信息
public interface Type {
//1.8新增
default String getTypeName() {
return toString();
}
}
而getParameterTypes/getGenericParameterTypes也是同樣的道理，都是獲取Method對象所表示的方法的參數(shù)類型，其他方法與前面的Field和Constructor是類似的。
到此這篇關(guān)于java反射超詳細(xì)講解的文章就介紹到這了,更多相關(guān)java反射內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！
相關(guān)文章
在 Spring Security 中,路徑匹配是權(quán)限控制的核心部分,它決定了哪些請求可以訪問特定的資源,本文將詳細(xì)介紹 Spring Security 中的路徑匹配策略,并提供相應(yīng)的代碼示例,需要的朋友可以參考下2024-04-04
本文詳細(xì)介紹了Mybatis映射文件的結(jié)構(gòu)、標(biāo)簽和使用方法,包括mapper元素、標(biāo)簽的主要屬性如id、parameterType、resultType以及動態(tài)SQL和結(jié)果映射的使用,通過映射文件,可以將數(shù)據(jù)庫表與Java對象映射,支持查詢、插入、更新、刪除等操作,提高了SQL語句的靈活性和可重用性2024-09-09
MyBatis學(xué)習(xí)教程之開發(fā)Dao的方法教程
這篇文章主要給大家介紹了關(guān)于MyBatis開發(fā)Dao的相關(guān)資料，使用Mybatis開發(fā)Dao，通常有兩個方法，即原始Dao開發(fā)方法和Mapper接口開發(fā)方法。文中通過示例代碼介紹的非常詳細(xì)，需要的朋友們下面來一起看看吧。2017-07-07
這篇文章主要為大家詳細(xì)介紹了如何基于Java制作一個簡易的遠(yuǎn)控終端，文中的示例代碼講解詳細(xì)，具有一定的學(xué)習(xí)價值，感興趣的可以了解一下2023-04-04
這篇文章主要給大家介紹了關(guān)于java中取整與四舍五入的相關(guān)資料，文中通過示例代碼介紹的非常詳細(xì)，對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價值，需要的朋友們下面隨著小編來一起學(xué)習(xí)學(xué)習(xí)吧2021-01-01
這篇文章主要介紹了Spring Boot ActiveMQ連接池配置過程解析,文中通過示例代碼介紹的非常詳細(xì)，對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價值,需要的朋友可以參考下2020-07-07
Java中Springboot集成Kafka實現(xiàn)消息發(fā)送和接收功能
Kafka是一個高吞吐量的分布式發(fā)布-訂閱消息系統(tǒng),主要用于處理大規(guī)模數(shù)據(jù)流,它由生產(chǎn)者、消費(fèi)者、主題、分區(qū)和代理等組件構(gòu)成,Kafka可以實現(xiàn)消息隊列、數(shù)據(jù)存儲和流處理等功能,在Java中,可以使用Spring Boot集成Kafka實現(xiàn)消息的發(fā)送和接收,感興趣的朋友跟隨小編一起看看吧2025-01-01
Apache?Shiro是一個java安全（權(quán)限）框架，Shiro可以非常容易的開發(fā)出足夠好的應(yīng)用，其不僅可以用在javase環(huán)境，也可以用在javaee環(huán)境。本文介紹了SpringBoot整合Shiro的方法，需要的可以參考一下2022-05-05
本篇文章主要介紹了java多線程之定時器Timer的使用詳解，Time類主要負(fù)責(zé)完成定時計劃任務(wù)的功能,有興趣的可以了解一下。2017-04-04
JDBC如何訪問MySQL數(shù)據(jù)庫,并增刪查改
這篇文章主要介紹了JDBC如何訪問MySQL數(shù)據(jù)庫，幫助大家更好的理解和學(xué)習(xí)java與MySQL，感興趣的朋友可以了解下2020-08-08