java 상승 무공 입문-반사

일단 마법 을 보 여 드릴 게 요.

public class Test {
    private static void changeStrValue(String str, char[] value) {
    	//                   
        //            
    }
    public static void main(String[] args) {
        changeStrValue("abc", new char[]{'d','e','f'});
        String abc = "abc";
        System.out.println("abc");
        System.out.println(abc);
        System.out.println("abc".equals(abc));
    }
}

둘째 주인 은 이 집행 결 과 를 처음 보고 매우 재 미 있 었 다.'abc'인 데 왜'def'가 됐 지?
반사 메커니즘 은 어떤 물건 입 니까?
자바 의 반사(reflection)메커니즘 은 프로그램의 운행 상태 에서 임의의 클래스 의 대상 을 구성 할 수 있 고 임의의 대상 이 속 한 클래스 를 이해 할 수 있 으 며 임의의 클래스 의 구성원 변수 와 방법 을 이해 할 수 있 으 며 임의의 대상 의 속성 과 방법 을 호출 할 수 있다.이러한 동적 취득 프로그램 정보 와 동적 호출 대상 의 기능 을 자바 언어의 반사 메커니즘 이 라 고 한다.반 사 는 동적 언어의 관건 으로 여 겨 진다.
이상 이 백과사전 의 해석 입 니 다.약간 추상 적일 수도 있 으 니,이어서 둘째 주인 이 너 에 게 보 여 주 는 것 을 보고 설명해 라.
임의의 유형의 대상 을 구성 하 다.
일반적인 상황 에서 우리 가 클래스 의 대상 을 만 들 려 면 new 키 워드 를 사용 해 야 합 니 다.그러나 spring 과 같은 프레임 워 크 는 클래스 이름 만 설정 하면 클래스 의 인 스 턴 스 를 얻 을 수 있 습 니 다.그 는 어떻게 했 습 니까?

import java.util.List;
public class Test {
    /**
     *          
     * @author         https://le-yi.blog.csdn.net/
     * @param className
     * @param <T>
     * @return
     * @throws InstantiationException
     * @throws IllegalAccessException
     * @throws ClassNotFoundException
     */
    public static <T> T getInstance(String className) throws InstantiationException, IllegalAccessException, ClassNotFoundException {
        Class<T> clazz = (Class<T>) Class.forName(className);
        return clazz.newInstance();
    }
    public static void main(String[] args) throws InstantiationException, IllegalAccessException, ClassNotFoundException {
        List<String> list = getInstance("java.util.ArrayList");
        list.add("abc");
        list.add("def");
        for (String v : list) {
            System.out.println(v);
        }
    }
}

클래스 이름 은 프로그램 실행 중 설정 파일,심지어 네트워크 에서 가 져 온 다음 에 동적 으로 클래스 의 인 스 턴 스 를 만 들 수 있 습 니 다.
임의의 대상 이 속 한 종 류 를 이해 하 다.

import java.util.ArrayList;
public class Test {
     /**
     *        
     * @author         https://le-yi.blog.csdn.net/
     * @param o
     */
    public static void printClass(Object o) {
        System.out.printf(o.getClass().getName());
    }
    public static void main(String[] args) {
        printClass(new ArrayList<>());
    }
}

임의의 종류의 구성원 변수 와 방법 을 이해 하 다
우 리 는 일반적으로 하나의 종 류 를 사용 해 야 한다.먼저 어떤 방법 과 속성 이 있 는 지 알 고 먼저 이해 한 후에 사용 해 야 한다.근 데 스프링 같은 프레임 이 왜 자동 으로 주입 되 는 거 죠?그 는 우리 한 대상 에 어떤 속성 이 있 는 지 어떻게 알 았 습 니까?

import java.lang.reflect.Field;
import java.lang.reflect.Method;
public class Test {
    /**
     *       
     * @author         https://le-yi.blog.csdn.net/
     * @param clazz
     */
    public static void printFields(Class clazz) {
        System.out.println(clazz.getName() + "      ：");
        for (Field f : clazz.getDeclaredFields()) {
            System.out.println(f);
        }
    }
    /**
     *       
     * @author         https://le-yi.blog.csdn.net/
     * @param clazz
     */
    public static void printMethods(Class clazz) {
        System.out.println(clazz.getName() + "      ：");
        for (Method m : clazz.getDeclaredMethods()) {
            System.out.println(m);
        }
    }
    public static void main(String[] args) {
        printFields(MyClass.class);
        printMethods(MyClass.class);
    }
}
class MyClass {
    private String name;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

임의의 대상 의 속성 과 방법 을 호출 합 니 다.
spring 과 같은 프레임 워 크 는 하나의 속성 이 개인 속성 이 고 set 방법 이 없 더 라 도 주입 할 수 있 습 니 다.

import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class Test {
    /**
     *          
     * @author         https://le-yi.blog.csdn.net/
     * @param o
     * @param methodName
     * @throws NoSuchMethodException
     * @throws InvocationTargetException
     * @throws IllegalAccessException
     */
    public static void callMethod(Object o, String methodName) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        Method m = o.getClass().getDeclaredMethod(methodName);
        m.setAccessible(true);
        m.invoke(o);
    }
    /**
     *          
     * @author         https://le-yi.blog.csdn.net/
     * @param o
     * @param fieldName
     * @param value
     * @throws IllegalAccessException
     */
    public static void changeFieldValue(Object o, String fieldName, Object value) throws NoSuchFieldException, IllegalAccessException {
        Field f = o.getClass().getDeclaredField(fieldName);
        f.setAccessible(true);
        f.set(o, value);
    }
    public static void main(String[] args) throws InvocationTargetException, NoSuchMethodException, IllegalAccessException, NoSuchFieldException {
        MyClass o = new MyClass();
        //       ，      
        changeFieldValue(o, "name", "       ");
        //       ，      
        callMethod(o, "printName");
    }
}
class MyClass {
	//     ，     set    
    private String name;
    private void printName() {
        //     ，             
        System.out.println("My name is " + name);
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

마법 의 비밀 폭로
마법 의 정 체 를 밝 힐 때 가 됐어 요.맞아요.반 사 를 이 용 했 어 요.

import java.lang.reflect.Field;
public class Test {
    /**
     *          
     * @author         https://le-yi.blog.csdn.net/
     * @param str
     * @param value
     */
    private static void changeStrValue(String str, char[] value) {
        try {
            Field f = str.getClass().getDeclaredField("value");
            f.setAccessible(true);
            f.set(str, value);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    public static void main(String[] args) {
        changeStrValue("abc", new char[]{'d','e','f'});
        //    "abc"        changeStrValue   "abc"        
        String abc = "abc";
        System.out.println("abc");
        System.out.println(abc);
        System.out.println("abc".equals(abc));
    }
}

이 코드 를 이해 하려 면 반사 메커니즘 외 에 자바 가 문자열 에 대한 처 리 를 알 아야 합 니 다."문자열 상수 탱크 는 본 고의 범 위 를 넘 어 섰 고 다른 화제 이 므 로 본 고 는 더 이상 말 하지 않 겠 습 니 다.
원래 문자열 의 내용 은"abc"입 니 다.String 은 변 하지 않 는 클래스 이기 때문에 이 내용 을 수정 할 수 없습니다.그러나 반사 대 법 은 모든 금 기 를 깨 뜨 릴 수 있다.
총결산
일반적인 프로그램 은 반사 코드 를 쓰 지 못 할 수도 있다.하지만 스프링 과 같은 프레임 이 반사 되 지 않 으 면 어떻게 실현 해 야 할 지 정말 생각 이 나 지 않 는 다.설령 영원히 반사 할 필요 가 없다 하 더 라 도,메커니즘 을 이해 하 는 것 은 우리 에 게 막대 한 이점 을 가지 고 있다.
이 글 은 여기까지 입 니 다.당신 에 게 도움 을 줄 수 있 기 를 바 랍 니 다.또한 당신 이 우리 의 더 많은 내용 에 관심 을 가 져 주 실 수 있 기 를 바 랍 니 다!