Java的反射机制

煎蛋zai冒泡

已于 2023-03-25 13:26:07 修改

阅读量118

点赞数

文章标签： java jvm 开发语言

于 2023-03-24 08:37:09 首次发布

本文链接：https://blog.csdn.net/weixin_68266487/article/details/129743223

版权

概念：

Java的反射（reflection）机制是指在程序的运行状态中，可以构造任意一个类的对象，可以了解任意一个对象所属的类，可以了解任意一个类的成员变量和方法，可以调用任意一个对象的属性和方法。这种动态获取程序信息以及动态调用对象的功能称为Java语言的反射机制。反射被视为动态语言的关键，反射让Java成为一个准动态语言。缺点增加不安全性。

反射机制的作用：

1：反编译：.class-->.java；

2：通过反射机制访问java对象的属性，方法，构造方法等；

Java反射机制提供的功能

在运行时判断任意一个对象所属的类
在运行时构造任意一个类的对象
在运行时判断任意一个类所具有的成员变量和方法
在运行时获取泛型信息在运行时调用任意一个对象的成员变量和方法
在运行时处理注解生成动态代理

Java反射主要涉及到类和方法：

Class类：表示一个类的类型，可以获取类的各种信息。

表示正在运行的java应用程序中的类的实例

Class类：是描述类的一个类。Class类是在Java语言中定义一个特定类的实现。一个类的定义包含成员变量，成员方法，还有这个类实现的接口，以及这个类的父类。Class类的对象用于表示当前运行的Java应用程序中的类和接口。比如：每个数组均属于一个Class类对象，所有具有相同元素类型和维数的数组共享一个Class对象。基本的Java类型（boolean,、byte、char、short、int、long、float和double）和void类型也可表示为Class对象。

获取Class对象
Java中的每个类都有一个隐藏的静态字段class，它持有对表示该类的Class对象的引用。可以使用以下方式获取Class对象：

  // 方式一：通过类名获取Class对象
        Class clazz1 = BookDao.class;

        // 方式二：通过对象获取Class对象 BookDao是接口,BookDaoImpl是接口的实现类
        BookDao obj = new BookDaoImpl();
        Class clazz2 = obj.getClass();

        // 方式三：通过类的全限定名获取Class对象
        Class clazz3 = Class.forName("com.shi.dao.BookDao");

Constructor类：表示一个类的构造函数

提供有关类的构造方法得信息，以及对它的动态访问权限。它是一个封装反射类的构造方法的类

		//通过全类名加载类的Class对象
        Class cla = Class.forName("com.shi.sercice.impl.BookServiceImpl");
        //Class对象可以认为是类的手术刀，可以解刨类里面的东西--属性、构造器、方法

		// 获取该类所有公共的构造函数（即public修饰的构造函数）的数组。
        Constructor[] constructors = cla.getConstructors();
        for (Constructor constructor : constructors) {
            System.out.println(constructor);
        }
		// 获取指定参数类型的构造函数
		Constructor constructor = cla.getConstructor(String.class,Integer.class);
		for (Constructor constructor1 : constructors) {
            System.out.println(constructor1);
        }
        //获取所有的构造函数
		 Constructor[] constructors1 = cla.getDeclaredConstructors();
        for (Constructor constructor : constructors1) {
            System.out.println(constructor);
        }

Method类：表示一个类的方法

提供关于类的方法得信息，包括抽象方法。它是用来封装反射类方法的一个类

        //获取该类或接口中的public方法以及其父类中的public方法。
		Method[] methods = cla.getMethods();
        for (Method method : methods) {
            System.out.println(method);
        }
        System.out.println("-------------");
        //获取该类或接口声明的所有方法（包括public、protected、default和private等）
        Method[] methods1 = cla.getDeclaredMethods();
        for (Method method : methods1) {
            System.out.println(method);
        }

Field类：表示一个类的属性

提供有关的属性信息，以及对它的动态访问权限。它是一个封装反射类的属性的类

 		Field[] fields = cla.getFields(); //只能获取public修饰的属性
        for (Field field : fields) {
            System.out.println(field);
        }
        System.out.println("-------------");
        Field[] fields1 = cla.getDeclaredFields(); //获取所有属性
        for (Field field : fields1) {
            System.out.println(field);
        }
        // 获取指定属性名的属性
		Field field = cla.getField("add");
		  System.out.println(field );

有关反射案例：

先建BookDao接口

package com.shi.dao;

public interface BookDao {
    public void  add();
}

impl

package com.shi.dao.impl;

import com.shi.dao.BookDao;

public class BookDaoImpl implements BookDao {
    @Override
    public void add() {
        System.out.println("BookDaoImpl...add");
    }
}

Service包
BookService接口

package com.shi.service;

public interface BookService {
public  void  add();
public  void  fun();
}

service.impl包
BookServiceImpl

package com.shi.service.impl;

import com.shi.dao.BookDao;
import com.shi.dao.impl.BookDaoImpl;
import com.shi.service.BookService;

public class BookServiceImpl  implements BookService {
    //类的属性---存储数据
    public String name;
    int age;
    protected String sex;
    private String address;

    //类的构造方法---用来构造对象
    public BookServiceImpl() {
    }

    public BookServiceImpl(String name) {
        this.name = name;
    }

    private BookServiceImpl(String name, int age, String sex, String address) {
        this.name = name;
        this.age = age;
        this.sex = sex;
        this.address = address;
    }


    BookDao bookDao=new BookDaoImpl();

    //功能方法---完成一些程序或者功能

    @Override
    public void add() {
        System.out.println("BookServiceImpl................add");
        bookDao.add();
    }

    @Override
    public void fun() {
        System.out.println("BookServiceImpl................fun");
    }
}

BookServiceVip

package com.shi.service.impl;

import com.shi.dao.BookDao;
import com.shi.dao.impl.BookDaoImpl;
import com.shi.service.BookService;

public class BookServiceVip implements BookService {
    BookDao bookDao=new BookDaoImpl();
    @Override
    public void add() {
        System.out.println("BooKServiceVip...add");
        bookDao.add();
    }

    public void fun(){
        System.out.println("BookServiceImpl...fun");
    }
}

BookServlet测试类

package com.shi.servlet;

import com.shi.service.BookService;
import com.shi.service.impl.BookServiceVip;
import org.junit.Test;

public class BookServlet {

    BookService bookService=new BookServiceVip();

    @Test
    public void add(){
        System.out.println("BookServlet...add");
        bookService.add();
    }

}

Test01类

package com.shi.servlet;

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

public class Test01 {
    public static void main(String[] args) throws Exception {
        //通过全类名加载类的Class对象
        Class cla = Class.forName("com.shi.service.impl.BookServiceImpl");
        //Class对象可以认为是类的手术刀，可以解刨类里面的东西--属性、构造器、方法
        Field[] fields = cla.getFields(); //只能获取public修饰的属性
        for (Field field : fields) {
            System.out.println(field);
        }
        System.out.println("-------------");
        Field[] fields1 = cla.getDeclaredFields(); //获取所有属性
        for (Field field : fields1) {
            System.out.println(field);
        }

        System.out.println("======================");

        Constructor[] constructors = cla.getConstructors();
        for (Constructor constructor : constructors) {
            System.out.println(constructor);
        }
        System.out.println("-------------");
        Constructor[] constructors1 = cla.getDeclaredConstructors();
        for (Constructor constructor : constructors1) {
            System.out.println(constructor);
        }

        System.out.println("======================");
        Method[] methods = cla.getMethods();
        for (Method method : methods) {
            System.out.println(method);
        }
        System.out.println("-------------");
        Method[] methods1 = cla.getDeclaredMethods();
        for (Method method : methods1) {
            System.out.println(method);
        }
    }
}

Test02类

package com.shi.servlet;

import com.shi.service.BookService;

import java.io.InputStream;
import java.lang.reflect.Constructor;
import java.util.Properties;

public class Test02 {

    public static void main(String[] args) throws Exception {
        //读取配置文件，获取内容
        InputStream stream = Test02.class.getClassLoader().getResourceAsStream("info.properties");
        Properties p=new Properties();
        p.load(stream);
        String className=p.getProperty("className");
        //1.通过全类名获取类的Class对象
        Class cla = Class.forName(className);
        //2.通过Class对象获取类的无参构造器
        Constructor constructor = cla.getDeclaredConstructor();
        //3.使用构造器创建对象
        BookService bookService = (BookService) constructor.newInstance();
        //4.使用对象调用方法
        bookService.add();
    }
    }

Test03 类

package com.shi.servlet;

import com.shi.service.BookService;

import java.io.InputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.util.Properties;

public class Test03 {

    public static void main(String[] args) throws Exception {
        //读取配置文件，获取内容
        InputStream stream = Test03.class.getClassLoader().getResourceAsStream("info.properties");
        Properties p=new Properties();
        p.load(stream);
        String className=p.getProperty("className");
        String methodName=p.getProperty("methodName");
        //1.通过全类名获取类的Class对象
        Class cla = Class.forName(className);
        //2.通过Class对象获取类的无参构造器
        Constructor constructor = cla.getDeclaredConstructor();
        //3.使用构造器创建对象
        BookService bookService = (BookService) constructor.newInstance();
        //4.获取方法名
        Method method = cla.getDeclaredMethod(methodName);
        //5.执行方法
        method.invoke(bookService);
    }
}

Spring框架

Spring框架
是由于软件开发的复杂性而创建的。Spring使用的是基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅仅限于服务器端的开发。从简单性、可测试性和松耦合性角度而言，绝大部分Java应用都可以从Spring中受益。

Spring IoC（控制反转）
是Spring框架的核心特性之一，它通过将对象的创建和依赖关系的管理交给容器来实现应用程序的松耦合。IoC容器负责实例化、配置和装配对象，使得开发人员可以更加专注于业务逻辑的编写，而不必关心对象的创建和管理。

在Spring中，IoC容器通过读取XML文件或注解配置信息来了解如何创建和组装对象。容器在启动时会自动扫描指定的路径下的所有类，并将这些类实例化并存储到容器中。当需要使用某个对象时，容器会根据对象的定义信息创建一个新的实例，并自动注入该对象所依赖的其他对象。

项目结构

首先创建Dao接口

package com.shi.dao;

public interface BookDao {
    public void insert();
}

实现dao接口的实现类

package com.shi.dao.impl;

import com.shi.dao.BookDao;

public class BookDaoImpl implements BookDao {
    @Override
    public void insert() {
        System.out.println("BookDaoImpl...save");
    }
}

service层

BookService 接口

package com.shi.service;

public interface BookService {
 public void  save();
}

实现BookService 的两个类

package com.shi.service.impl;

import com.shi.dao.BookDao;
import com.shi.service.BookService;
import org.springframework.beans.factory.annotation.Autowired;

public class BookServiceImpl implements BookService {


    public   String name;

    public     int age;

    private BookDao bookDao;

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

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

    public void setAge(int age) {
        this.age = age;
    }
    @Autowired
    public void setBookDao(BookDao bookDao) {
        this.bookDao = bookDao;
    }
    public BookServiceImpl(BookDao bookDao) {
        this.bookDao = bookDao;
    }

    public BookServiceImpl() {
        // 默认构造函数体
    }

    @Override
    public void save() {
        System.out.println("BookServiceImpl.......save");
        bookDao.insert();
    }
}

package com.shi.service.impl;

import com.shi.service.BookService;

public class BookServiceVip implements BookService {
    @Override
    public void save() {
        System.out.println("BookServiceVip..............save");
    }
}

xml文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--告诉spring框架，创建管理哪些对象
        id:给创建出来的对象起个名字
        class:要创建对象对应类的全类名
    -->

    <bean id="bookDao" class="com.shi.dao.impl.BookDaoImpl"/>
    <bean id="bookService" class="com.shi.service.impl.BookServiceImpl">
        <property name="age" value="19"/>
        <property name="name" value="小美"/>
        <property name="bookDao" ref="bookDao"/>
    </bean>
</beans>

测试层
BookServlet

package com.shi.servlet;

import com.shi.service.BookService;
import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class BookServlet {
    BookService bookService;

    @Test
    public void add() {
        System.out.println("BookServlet...add");
//1.获得IOC容器
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");
//2.根据名字从容器中获取对象
        bookService = (BookService) context.getBean("bookService");
        bookService.save();
    }

}

Test01

package com.shi.servlet;

import com.shi.service.BookService;
import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test01 {
    BookService bookService;
    @Test
    public  void  test01(){
        ClassPathXmlApplicationContext pathXmlApplicationContext =new ClassPathXmlApplicationContext("spring.xml");
        bookService = (BookService) pathXmlApplicationContext.getBean("bookService");
        bookService.save();
    }



}

煎蛋zai冒泡

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java的反射机制

Java的反射（reflection）机制是指在程序的运行状态中，可以构造任意一个类的对象，可以了解任意一个对象所属的类，可以了解任意一个类的成员变量和方法，可以调用任意一个对象的属性和方法。这种动态获取程序信息以及动态调用对象的功能称为Java语言的反射机制。反射被视为动态语言的关键，反射让Java成为一个准动态语言。缺点增加不安全性。1：反编译：.class-->.java；2：通过反射机制访问java对象的属性，方法，构造方法等；
复制链接

扫一扫