Spring Boot，Java反射原理

是木木啦

已于 2023-11-07 16:55:36 修改

阅读量343

点赞数 6

文章标签： 1024程序员节

于 2023-10-24 16:33:48 首次发布

本文链接：https://blog.csdn.net/2301_78652407/article/details/134012049

版权

一，Java反射概念以及原理

二，获取 Class 对象的四种方式

1. 知道具体类的情况下可以使用：

2. 通过 Class.forName()传入类的全路径获取：

3. 通过对象实例instance.getClass()获取：

三，编程实现java反射

1.创建一个我们要使用反射操作的类 TargetObject。

一，Java反射概念以及原理

Java反射机制的核心是在程序运行时动态加载类并获取类的详细信息，从而操作类或对象的属性和方法。本质是JVM得到class对象之后，再通过class对象进行反编译，从而获取对象的各种信息。

我们可以通过上图看到，JVM就像一面镜子，由person对象可以获取Person实体的属性、方法。

二，获取 Class 对象的四种方式

1. 知道具体类的情况下可以使用：

Class alunbarClass = TargetObject.class;

但是我们一般是不知道具体类的，基本都是通过遍历包下面的类来获取 Class 对象，通过此方式获取 Class 对象不会进行初始化

2. 通过 `Class.forName()`传入类的全路径获取：

Class alunbarClass1 = Class.forName("cn.javaguide.TargetObject");

3. 通过对象实例`instance.getClass()`获取：

TargetObject o = new TargetObject();
Class alunbarClass2 = o.getClass();

4. 通过类加载器xxxClassLoader.loadClass()传入类路径获取:

ClassLoader.getSystemClassLoader().loadClass("cn.javaguide.TargetObject");

通过类加载器获取 Class 对象不会进行初始化，意味着不进行包括初始化等一系列步骤，静态代码块和静态对象不会得到执行。

三，编程实现java反射

1.创建一个我们要使用反射操作的类 `TargetObject`。

package cn.javaguide;

public class TargetObject {
private String value;

public TargetObject() {
value = "JavaGuide";
}

public void publicMethod(String s) {
System.out.println("I love " + s);
}

private void privateMethod() {
System.out.println("value is " + value);
}
}

2.使用反射操作这个类的方法以及参数

package cn.javaguide;

import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class Main {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InstantiationException, InvocationTargetException, NoSuchFieldException {
/**
* 获取 TargetObject 类的 Class 对象并且创建 TargetObject 类实例
*/
Class<?> targetClass = Class.forName("cn.javaguide.TargetObject");
TargetObject targetObject = (TargetObject) targetClass.newInstance();
/**
* 获取 TargetObject 类中定义的所有方法
*/
Method[] methods = targetClass.getDeclaredMethods();
for (Method method : methods) {
System.out.println(method.getName());
}

/**
* 获取指定方法并调用
*/
Method publicMethod = targetClass.getDeclaredMethod("publicMethod",
String.class);

publicMethod.invoke(targetObject, "JavaGuide");

/**
* 获取指定参数并对参数进行修改
*/
Field field = targetClass.getDeclaredField("value");
//为了对类中的参数进行修改我们取消安全检查
field.setAccessible(true);
field.set(targetObject, "JavaGuide");

/**
* 调用 private 方法
*/
Method privateMethod = targetClass.getDeclaredMethod("privateMethod");
//为了调用private方法我们取消安全检查
privateMethod.setAccessible(true);
privateMethod.invoke(targetObject);
}
}

输出：

publicMethod
privateMethod
I love JavaGuide
value is JavaGuide

注意 : 有读者提到上面代码运行会抛出 ClassNotFoundException 异常,具体原因是你没有下面把这段代码的包名替换成自己创建的 TargetObject 所在的包。

Class<?> targetClass = Class.forName("cn.javaguide.TargetObject");

四，反射的应用以及优缺点

反射最常见的应用是注册数据库驱动Class.forName("com.mysql.jdbc.Driver");，mybatis、rocketmq等也有用到反射。

那么反射有什么优点吗？大概有如下优点：

1）获取任意类的名称、package信息、所有属性、方法、注解、类型、类加载器等。
2）反射提高了程序的灵活性和扩展性。
3）通过反射我们可以实现动态装配，降低代码的耦合度,动态代理，提高自适应能力等。
反射有优点也有缺点，它的缺点大概如下：
1) 性能问题。Java反射机制中包含了一些动态类型，所以Java虚拟机不能够对这些动态代码进行优化。因此，反射操作的效率要比正常操作效率低很多。
2) 安全限制。使用反射通常需要程序的运行没有安全方面的限制。
3) 程序健壮性。反射允许代码执行一些通常不被允许的操作，所以使用反射有可能会导致意想不到的后果。反射代码破坏了Java程序结构的抽象性，所以当程序运行的平台发生变化的时候，由于抽象的逻辑结构不能被识别，代码产生的效果与之前会产生差异。

五，拓展知识

ORM+JPA实现

1.在maven中导入相关依赖

<dependencies>
   <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-data-jpa</artifactId>
   </dependency>
   
   <dependency>
      <groupId>com.mysql</groupId>
      <artifactId>mysql-connector-j</artifactId>
      <scope>runtime</scope>
   </dependency>
   <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-test</artifactId>
      <scope>test</scope>
   </dependency>

   <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
      <version>2.0.1.RELEASE</version>
   </dependency>

   
   <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-data-redis</artifactId>
   </dependency>

   
   <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-data-jpa</artifactId>
   </dependency>

   
   <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>druid-spring-boot-starter</artifactId>
      <version>1.1.10</version>
   </dependency>

   <dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
   </dependency>
</dependencies>

2.创建OrmUser实体类

@Data
@Entity(name="ormuser")
public class OrmUser {
   @Id
   @GeneratedValue(strategy = GenerationType.IDENTITY)
   private Long id;
   private Integer age;
   private String username;
}

3.创建Repersitory接口

public interface OrmUseRepersitory extends JpaRepository<OrmUser,Integer> {

   @Query("select o from ormuser o where o.username = ?1")
   public List<OrmUser> getOrmUser(String username);

   @Transactional
   @Modifying
   @Query("UPDATE ormuser c SET c.age = ?1 WHERE c.username = ?2")
   public int updateOrmUser(int age,String username);

   @Transactional
   @Modifying
   @Query("DELETE ormuser c WHERE c.username = ?1")
   public int deleteOrmUser(String username);

}

4.yml配置

spring:
datasource:
   username: root
   password: root123
   url: jdbc:mysql://localhost:3306/webstore
   driverClassName: com.mysql.cj.jdbc.Driver

5.测试程序

@Resource
OrmUseRepersitory ormUseRepersitory;
@Test
void contextLoads() {
}

@Test
void add(){
   OrmUser ormUser = new OrmUser();
   ormUser.setAge(30);
   ormUser.setUsername("Jack");
   ormUseRepersitory.save(ormUser);
}

@Test
void updateOrm(){
   ormUseRepersitory.updateOrmUser(32,"Jack");
}

@Test
void queryOrm(){
   System.out.println("ormuse = " + ormUseRepersitory.getOrmUser("Jack"));
}

@Test
void deleteOrm(){
   ormUseRepersitory.deleteOrmUser("Jack");
}