Reflection — основы

Reflection (Рефлексия) — основы

На мой взгляд, рефлексия для Java напоминает электричество в жизни обычного человека — все им очень активно пользуются, но как оно реально работает, мало кто знает досконально и это незнание совсем не мешает. Есть общее понимание — и достаточно.
Рефлексия как идея и инструмент крайне важна для понимания огромного количества технологий, пакетов и прочего.. Поэтому понимать, что это такое и знать основы крайне важно.
С другой стороны, использование непосредственно Reflection API (набор функций для рефлексии) в жизни обычного программиста, который занимается прикладными системами, встречается достаточно редко.
Т.е. знать, что это такое, понимать основы и держать в голове плюсы и минусы — это просто необходимо. Необходимо ли досконально помнить набор функций ? Вряд ли вы часто будете их использовать. На мой взгляд, лучше понимать рефлексию и знать куда идти за дополнительной информацией. Хотя конечно же многое зависит от вашего конкретного проекта — может именно ваш будет просто “завален” кодом с использованием Reflection API. и вы достигнете такого понимания этого вопроса, который редко встречается среди профессионалов. Кто знает.

Так что же такое рефлексия и какие задачи она позволяет решать ?
Если брать технические возможности, то в первую очередь можно выделить две группы действий:

Можно узнать всю информацию о классе — методы, поля, конструкторы, константы, суперклассы, реализуемые классом интерфейсы.
Можно работать с классом (объектом), а именно — создать объект класса, выполнить методы, получить или установить значения полей.

Если расширить список, то вот что позволяет выполнить рефлексия:

Узнать/определить класс объекта
Получить информацию о модификаторах класса, полях, методах, константах, конструкторах и суперклассах.
Выяснить, какие методы принадлежат реализуемому интерфейсу/интерфейсам.
Создать экземпляр класса, причем имя класса неизвестно до момента выполнения программы.
Получить и установить значение поля объекта по имени.
Вызвать метод объекта по имени.

И еще раз в короткой форме — рефлексия позволяет вам получить информацию о внутреннем строении класса — поля, методы и т.д. — и позволяет обратиться к полям, методам и другим артифактам через эту информацию.
Причем, что самое важное — ЭТО ВСЕ МОЖНО ДЕЛАТЬ УЖЕ ПРИ ИСПОЛНЕНИИ ПРОГРАММЫ — как часто говорят, в рантайме (runtime).
Если вы никогда не сталкивались с такого рода механизмами, то у вас может возникнуть вполне резонный вопрос — а зачем все это надо ? Ответ в этом случае достаточно простой, но в то же время очень неопределенный — вы кардинально повышаете ГИБКОСТЬ и возможность НАСТРАИВАТЬ ваше приложение.

Используя рефлексию программа может вызвать абсолютно неизвестный метод абсолютно неизвестного класса уже во время своего исполнения. В момент компиляции об этом классе и методе было совершенно ничего не известно. Рефлексия используется практически во всех современных технологиях Java. Сложно себе представить, могла бы Java как платформа достигнуть такого огромного распространения без рефлексии. Скорее всего не смогла бы.

Первое знакомство

Рассмотрим несложный вариант использования рефлексии. Ваше приложение по расписанию (или как-то иначе) должно выполнить определенный метод определенного класса. Например, вам необходимо загружать обновления финансовой информации.
До какого-то времени эта информация находилась в базе данных и метод класса умел эту информацию из этой базы получать.
Если проектирование велось с учетом возможной замены класса, то скорее всего был определен интерфейс и была сделана реализация в виде класса для базы данных. Что-то вроде такого варианта.

Сама структура, которую получаем из интерфейса может быть каким-то классом

public class FinanceInformation
{
    //  Здесь определяется набор полей, который описывает всю получаемую информацию
}

public class FinanceInformation

{

// Здесь определяется набор полей, который описывает всю получаемую информацию

}

Вот наш интерфейс

public interface FinanceInfoBuilder
{
    FinanceInformation buildFinacneInformation();
}

public interface FinanceInfoBuilder

{

FinanceInformation buildFinacneInformation();

}

Ну и наконец какая-то реализация для базы данных

public class DbFinanceInfoBuilder implements FinanceInfoBuilder
{
    public FinanceInformation buildFinacneInformation() {
        // Тут мы ходим в базу данных - как-будто
    }
}

public class DbFinanceInfoBuilder implements FinanceInfoBuilder

{

public FinanceInformation buildFinacneInformation() {

// Тут мы ходим в базу данных - как-будто

}

Где-то внутри приложения был написан код, который создавал объект нужного класса и вызывал нужный метод. Вот достаточно простое приложение, которое демонстрирует нашу задумку уже в виде готовых интерфейсов и классов.

Класс FinanceInformation

/*
 * Класс, который содержит финансовую информацию
 *  По сути этот класс включает некоторый набор полей,
 *  который описывает структуру финансовой информации
 */
package edu.javacourse.reflection;

public class FinanceInformation
{
    // Какие-то важные поля
}

* Класс, который содержит финансовую информацию

* По сути этот класс включает некоторый набор полей,

* который описывает структуру финансовой информации

package edu.javacourse.reflection;

public class FinanceInformation

{

// Какие-то важные поля

}

Интерфейс FinanceInfoBuilder

/*
 * Интерфейс, который позволяет сделать менее жесткую связь
 * для вызова нужного метода
 */
package edu.javacourse.reflection;

public interface FinanceInfoBuilder
{
    FinanceInformation buildFinacneInformation();
}

* Интерфейс, который позволяет сделать менее жесткую связь

* для вызова нужного метода

package edu.javacourse.reflection;

public interface FinanceInfoBuilder

{

FinanceInformation buildFinacneInformation();

}

Класс DbFinanceInfoBuilder

/*
 * Реализация интерфейса FinanceInfoBuilder
 * которая работает с информацией из базы данных
 */
package edu.javacourse.reflection;

public class DbFinanceInfoBuilder implements FinanceInfoBuilder
{
    @Override
    public FinanceInformation buildFinacneInformation() {
        System.out.println("Вызов метода для объекта DbFinanceInfoBuilder");
        return new FinanceInformation();
    }
}

* Реализация интерфейса FinanceInfoBuilder

* которая работает с информацией из базы данных

package edu.javacourse.reflection;

public class DbFinanceInfoBuilder implements FinanceInfoBuilder

{

@Override

public FinanceInformation buildFinacneInformation() {

System.out.println("Вызов метода для объекта DbFinanceInfoBuilder");

return new FinanceInformation();

}

Класс FinanceInfoBuilderFactory

/*
 * Класс для создания экземпляра нужного класса
 */
package edu.javacourse.reflection;

public class FinanceInfoBuilderFactory
{
    public static FinanceInfoBuilder getFinanceInfoBuilder() {
        // Обратите внимание, что здесь мы ВЫНУЖДЕНЫ писать реальный класс
        // Хорошо, что это мы делаем только в одном месте, ане в каждой
        // строке, где нам потребуется обращение к FinanceInfoBuilder
        return new DbFinanceInfoBuilder();
    }
}

* Класс для создания экземпляра нужного класса

package edu.javacourse.reflection;

public class FinanceInfoBuilderFactory

{

public static FinanceInfoBuilder getFinanceInfoBuilder() {

// Обратите внимание, что здесь мы ВЫНУЖДЕНЫ писать реальный класс

// Хорошо, что это мы делаем только в одном месте, ане в каждой

// строке, где нам потребуется обращение к FinanceInfoBuilder

return new DbFinanceInfoBuilder();

}

И наконец вариант вызова — упрощенно

package edu.javacourse.reflection;

public class FininceExample
{
    public static void main(String[] args) {
        // Получаем нужный объект
        FinanceInfoBuilder fib = FinanceInfoBuilderFactory.getFinanceInfoBuilder();
        // Вызываем метод
        FinanceInformation info = fib.buildFinacneInformation();
        // Вызов getClass() позволяет получить описание класса у объекта
        System.out.println(“Имя класса:” + fib.getClass().getCanonicalName());
        // Дальше можем делать с полученной информацией все, что захотим
    }
}

package edu.javacourse.reflection;

public class FininceExample

{

public static void main(String[] args) {

// Получаем нужный объект

FinanceInfoBuilder fib = FinanceInfoBuilderFactory.getFinanceInfoBuilder();

// Вызываем метод

FinanceInformation info = fib.buildFinacneInformation();

// Вызов getClass() позволяет получить описание класса у объекта

System.out.println(“Имя класса:” + fib.getClass().getCanonicalName());

// Дальше можем делать с полученной информацией все, что захотим

}

В общем все достаточно симпатично — есть отдельный класс FinanceInfoBuilderFactory, который нам позволяет локализовать создание конкретной реализации интерфейса FinanceInfoBuilder. И все было хорошо, пока вдруг в связи с новыми веяниями эту информацию теперь надо получать с помощью веб-сервиса. Если вы не знаете, что такое веб-сервис — не страшно. Самое главное — вы уже догадываетесь, что метод и класс будут другими. Совсем другими. Т.е. мы должны написать новый класс

/*
 * Реализация интерфейса FinanceInfoBuilder
 * которая работает с информацией из веб-сервиса
 */
package edu.javacourse.reflection;

public class WebFinanceInfoBuilder implements FinanceInfoBuilder
{
    @Override
    public FinanceInformation buildFinacneInformation() {
        System.out.println("Вызов метода для объекта WebFinanceInfoBuilder");
        return new FinanceInformation();
    }
}

* Реализация интерфейса FinanceInfoBuilder

* которая работает с информацией из веб-сервиса

package edu.javacourse.reflection;

public class WebFinanceInfoBuilder implements FinanceInfoBuilder

{

@Override

public FinanceInformation buildFinacneInformation() {

System.out.println("Вызов метода для объекта WebFinanceInfoBuilder");

return new FinanceInformation();

}

И теперь (какие мы молодцы) нам надо сделать очень простое изменение внутри FinanceInfoBuilderFactory

/*
 * Класс для создания экземпляра нужного класса
 */
package edu.javacourse.reflection;

public class FinanceInfoBuilderFactory
{
    public static FinanceInfoBuilder getFinanceInfoBuilder() {
        // Теперь мы создаем объект другого класса WebFinanceInfoBuilder
        return new WebFinanceInfoBuilder();
    }
}

* Класс для создания экземпляра нужного класса

package edu.javacourse.reflection;

public class FinanceInfoBuilderFactory

{

public static FinanceInfoBuilder getFinanceInfoBuilder() {

// Теперь мы создаем объект другого класса WebFinanceInfoBuilder

return new WebFinanceInfoBuilder();

}

Мы написали новый класс — он работает. Наш класс реализует интерфейс FinanceInfoBuilder. Замечательно. Мы даже внесли изменения в класс FinanceInfoBuilderFactory для создания объекта теперь уже нового класса.
Здесь я использовал шаблон проектирования типа “Фабричный метод”, чтобы уменьшить и упростить изменения, но в любом случае надо брать исходный код, изменять, перекомпилировать и заново устанавливать. Как вы уже можете догадаться, это крайне неудобно. В условиях, когда система должна работать постоянно, не всегда просто переустановить систему и прочая, это совсем не радует.
Даже если учесть, что изменения самого кода в общем не такие уж и большие. Но их надо делать каждый раз, когда нам захочется поменять класс. Например, вернуть старый вариант. В идеале мы можем иметь несколько классов на выбор и устанавливать какой-то из них в определенной ситуации. Но каждый раз надо перекомпилировать, переустанавливать. Как-то корявенько получается.
Что же можно придумать в такой ситуации ? Напрашивается достаточно очевидное решение — надо где-то в виде строки хранить имя класса (например в той же базе данных, текстовом файле или еще в каком-то общедоступном месте) и в момент вызова считывать это имя, создавать объект указанного класса и, ЗНАЯ, ЧТО КЛАСС РЕАЛИЗУЕТ ОПРЕДЕЛЕННЫЙ ИНТЕРФЕЙС, привести этот класс к интерфейсу FinanceInfoBuilder и вызвать метод buildFinacneInformation.

Давайте воспользуемся Refleсtion API для решения нашей задачи. Имя класса пропишем в файле свойств — мы его разбирали в разделе Коллекции — продолжение

Создадим файл builder.properties в каталоге с нашими классами вот с таким содержимым

builder.class=edu.javacourse.reflection.WebFinanceInfoBuilder

1	builder.class=edu.javacourse.reflection.WebFinanceInfoBuilder

И теперь посмотрим на новый вариант FinanceInfoBuilderFactory. Комментарии по коду посмотрим после

/*
 * Класс для создания экземпляра нужного класса
 */
package edu.javacourse.reflection;

import java.util.PropertyResourceBundle;
import java.util.logging.Level;
import java.util.logging.Logger;

public class FinanceInfoBuilderFactory
{
    // Сделаем констуанту для имения нужного нам свойства
    private static final String BUILDER_CLASS = "builder.class";
    
    public static FinanceInfoBuilder getFinanceInfoBuilder() {
        // Получаем имя класса из файла builder.properties
        PropertyResourceBundle pr = (PropertyResourceBundle)
                PropertyResourceBundle.getBundle("edu.javacourse.reflection.builder");
        String className = pr.getString(BUILDER_CLASS);
        
        try {
            // Загружаем класс по имени
            Class cl = Class.forName(className);
            // Т.к. наш класс должен имплементировать интерфейс FinanceInfoBuilder
            // то мы можем сделать приведение к интерфейсу
            FinanceInfoBuilder builder = (FinanceInfoBuilder)cl.newInstance();
            return builder;
        } catch (ClassNotFoundException | InstantiationException | IllegalAccessException ex) {
            ex.printStackTrace(System.out);
        }
        return null;
    }
}

* Класс для создания экземпляра нужного класса

package edu.javacourse.reflection;

import java.util.PropertyResourceBundle;

import java.util.logging.Level;

import java.util.logging.Logger;

public class FinanceInfoBuilderFactory

{

// Сделаем констуанту для имения нужного нам свойства

private static final String BUILDER_CLASS = "builder.class";

public static FinanceInfoBuilder getFinanceInfoBuilder() {

// Получаем имя класса из файла builder.properties

PropertyResourceBundle pr = (PropertyResourceBundle)

PropertyResourceBundle.getBundle("edu.javacourse.reflection.builder");

String className = pr.getString(BUILDER_CLASS);

try {

// Загружаем класс по имени

Class cl = Class.forName(className);

// Т.к. наш класс должен имплементировать интерфейс FinanceInfoBuilder

// то мы можем сделать приведение к интерфейсу

FinanceInfoBuilder builder = (FinanceInfoBuilder)cl.newInstance();

return builder;

} catch (ClassNotFoundException | InstantiationException | IllegalAccessException ex) {

ex.printStackTrace(System.out);

}

return null;

}

Первая часть в методе getFinanceInfoBuilder загружает файл свойств и получает свойство «builder.class», в котором мы храним ПОЛНОЕ ИМЯ КЛАССА (включая пакеты). В итоге в переменной className у нас есть строка с именем нужного нам класса.
Вторая часть нашего метода должна решить две задачи:

Загрузить класс по имени
Создать переменную нужного класса

Первую задачу решает вызов

            Class cl = Class.forName(className);

1	Class cl = Class.forName(className);

В этой строке есть несколько моментов, на которые надо обратить внимание (всего одна строка, а сколько интересного)
Во-первых, результатом вызова является переменная типа Class (даже звучит необычно класс Class). Но шутки в сторону — класс Class является важной частью Reflection API — именно этот класс позволяет “покопаться” внутри любого класса — посмотреть конструкторы, поля, методы. Позже мы посмотрим, как это можно сделать. А пока просто отметим — класс Class очень-очень важный.
Теперь обратим наши взоры к самому вызову Class.forName(). На данный момент я не хочу сильно углубляться в спецификации и документацию, постараюсь упрощенно описать, что происходит в момент вызова.
Так вот, когда приложение на Java стартует, это совсем не означает, что все классы, которые содержаться в вашем приложении (включая классы в JAR-файлах), будут загружены сразу. Т.е. если внутри вашего приложения нет обращения к классу DbFinanceInfoBuilder, то он даже не загрузиться внутрь JVM. Только в момент обращения к классу в коде, он будет загружаться специальным классом — ClassLoader. Тема ClassLoader любопытная, но оставим это на будущее — можете поискать информацию сами. Это достаточно познавательное чтение.
Второй вариант заставить ClassLoader загрузить нужный класс — сделать это явно через вышеупомянутый вызов Class.forName(). Этот вызов загрузит описание класса (если его еще нет в JVM) и вернет его описатель в виде объекта класса Class. Если класс загружен, то вызов просто вернет описатель. Метод forName имеет более интересный вариант вызова, который регулирует инициализацию класса и даже какой ClassLoader для этого использовать, но пока остановимся на простом варианте.
Что важно — мы указываем имя класса в виде строки. Это не код, который надо было компилировать — это просто строка. И получить ее можно откуда угодно.
Еще раз повторюсь — я упрощенно описал этот момент, но в принципе этого пока достаточно.
Итак, у нас есть описание класса. Второй вызов позволяет нам создать экземпляр (объект) класса

            FinanceInfoBuilder builder = (FinanceInfoBuilder)cl.newInstance();

1	FinanceInfoBuilder builder = (FinanceInfoBuilder)cl.newInstance();

Метод newInstance() позволяет создать объект указанного класса. Но что ВАЖНО отметить — такой вызов возможен только в случае, если класс имеет конструктор БЕЗ ПАРАМЕТРОВ. Если такого конструктора в вашем классе нет, то воспользоваться таким простым вызовом не получится — придется действовать сложнее. Так что иметь конструктор без параметров — это неплохая идея.
Как вы уже возможно догадались, вызов возвращает объект класса Object и нам надо вручную привести его к нужному типу. Т.к. мы полагаемся на “порядочность” нашего класса, которая выражается в поддержке интерфейса FinanceInfoBuilder, то мы к нему и приводим наш объект.
Теперь для смены класса для загрузки финансовых показателей достаточно просто отредактировать файл builder.properties. Ничего больше. Далее следуют бурные продолжительные аплодисменты.

Проект в NetBeans можно загрузить здесь: FinanceExample

Класс Class

Мы посмотрели вариант загрузки класса и создание объекта нужного нам класса. На самом деле такой вариант использования рефлексии весьма распространен. Так что очень рекомендую запомнить это решение. Теперь мы посмотрим, как можно не только создать объект нужного класса, но и как можно обратиться к полям или методам.
Определим простой класс для наших экспериментов

/*
 * Класс для демонстрации рефлексии
 */
package edu.javacourse.reflection;

public class SimpleClass
{
    private String first;

    public String getFirst() {
        return first;
    }
    
    public String simple() {
        return "Method1";
    }
    
    public String concat(String s1, String s2) {
        return s1 + s2;
    }
}

* Класс для демонстрации рефлексии

package edu.javacourse.reflection;

public class SimpleClass

{

private String first;

public String getFirst() {

return first;

}

public String simple() {

return "Method1";

}

public String concat(String s1, String s2) {

return s1 + s2;

}

И теперь “поиграем” с нашим классом — обратимся к его полю и методам через Reflection API

/*
 * Класс для демонстрации рефлексии
 */
package edu.javacourse.reflection;

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

public class SimpleReflectionExample
{
    public static void main(String[] args) {
        //Пример обращения к полям и методам класса
        try {
            demoReflection();
        } catch (Exception ex) {
            ex.printStackTrace(System.out);
        }
    }

    private static void demoReflection() throws Exception {
        // Заружаем описание класса
        Class example = Class.forName("edu.javacourse.reflection.SimpleClass");
        SimpleClass sc = (SimpleClass) example.newInstance();
 
        // Обращение к полю
        demoReflectionField(example, sc);
        
        // Обращение к методу
        demoReflectionMethod(example, sc);
    }

    private static void demoReflectionField(Class example, SimpleClass sc) throws Exception {
        // Получить обхект типа Field - обратите внимание, что поле private
        Field f = example.getDeclaredField("first");
        // Выставить разрешение для доступа к полю
        f.setAccessible(true);
        // Получить значение поля - оно у нас пока NULL
        String test = (String)f.get(sc);
        System.out.println("Field before SET:" + sc.getFirst());
        // Установить значение поля
        f.set(sc, "Test");
        System.out.println("Field after SET:" + sc.getFirst());
    }

    private static void demoReflectionMethod(Class example, SimpleClass sc) throws Exception {
        // Вызов метода без параметров
        // Получить обхект типа Method по имени
        Method method1 = example.getMethod("simple");
        // Вызвать метод с помощью invoke - передать туда только объект
        String simple = (String)method1.invoke(sc);
        System.out.println("Simple:" + simple);
        
        // Вызов метода с параметрами
        // Сначала надо определить список параметров - вспоминаем overloading
        // У нас это две строки - String
        Class[] paramTypes = new Class[] {String.class, String.class};
        // Получить обхект типа Method по имени и по списку параметров
        Method concat = example.getMethod("concat", paramTypes);
        // Вызвать метод - передать туда объект и два параметра типа строка
        String answer = (String)concat.invoke(sc, "1", "2");
        System.out.println("Concat:" + answer);
    }
}

* Класс для демонстрации рефлексии

package edu.javacourse.reflection;

import java.lang.reflect.Field;

import java.lang.reflect.Method;

public class SimpleReflectionExample

{

public static void main(String[] args) {

//Пример обращения к полям и методам класса

try {

demoReflection();

} catch (Exception ex) {

ex.printStackTrace(System.out);

}

private static void demoReflection() throws Exception {

// Заружаем описание класса

Class example = Class.forName("edu.javacourse.reflection.SimpleClass");

SimpleClass sc = (SimpleClass) example.newInstance();

// Обращение к полю

demoReflectionField(example, sc);

// Обращение к методу

demoReflectionMethod(example, sc);

}

private static void demoReflectionField(Class example, SimpleClass sc) throws Exception {

// Получить обхект типа Field - обратите внимание, что поле private

Field f = example.getDeclaredField("first");

// Выставить разрешение для доступа к полю

f.setAccessible(true);

// Получить значение поля - оно у нас пока NULL

String test = (String)f.get(sc);

System.out.println("Field before SET:" + sc.getFirst());

// Установить значение поля

f.set(sc, "Test");

System.out.println("Field after SET:" + sc.getFirst());

}

private static void demoReflectionMethod(Class example, SimpleClass sc) throws Exception {

// Вызов метода без параметров

// Получить обхект типа Method по имени

Method method1 = example.getMethod("simple");

// Вызвать метод с помощью invoke - передать туда только объект

String simple = (String)method1.invoke(sc);

System.out.println("Simple:" + simple);

// Вызов метода с параметрами

// Сначала надо определить список параметров - вспоминаем overloading

// У нас это две строки - String

Class[] paramTypes = new Class[] {String.class, String.class};

// Получить обхект типа Method по имени и по списку параметров

Method concat = example.getMethod("concat", paramTypes);

// Вызвать метод - передать туда объект и два параметра типа строка

String answer = (String)concat.invoke(sc, "1", "2");

System.out.println("Concat:" + answer);

}

Итак, давайте разбираться. Метод demoReflcetion уже знакомым нам способом создает объект типа SimpleClass. В принципе этот момент был не обязателен и выглядит достаточно натянуто — смысл загружать класс и следующей строкой его же и использовать, но для демонстрации подойдет. Дальше начинаются гораздо более интересные вещи.
Метод demoReflectionField показывает способ обращения к полю (причем к приватному полю). Самое главное — это получение обхекта типа Field по имени, с помощью которого можно уже работать с конкретным полем. Дальше код демонстрирует такие возможности.
Особо хочу отметить вызов setAccessible(true), который позволяет работать с приватным полем.
Метод demoReflectionMethod демонстрирует вариант получения метода по имени и по имени и параметрам — вспоминаем, что такое overloading. Здесь уже используется другой тип — Method — с помощью которого можно вызвать конкретный метод объекта. Дальше я предлагаю вам самим запустить пример а также прочитать код и комментарии к нему.

Проект в NetBeans можно загрузить здесь: SimpleReflection

Аннотации

В версии Java 1.5 появился очень интересный и очень мощный инструмент — аннотации. По сути аннотация — это именованный блок информации, который содержит набор именованных параметров и этот блок можно “прикрепить” к классу, методу, полю и даже параметру в методе. Другими словами — у аннотации есть имя и у нее есть список параметров с именами, которые можно выставить в определенные значения.
И теперь еще раз подумайте — вы можете прикрепить к основным артефактам кода (класс, метод, поле) блок с информацией и ЭТОТ БЛОК ДОСТУПЕН через рефлексию.
И что в этом таког, можете спросить вы ? Дело в том, что теперь есть возможность написать библиотеку (набор классов), которая может обрабатывать классы с определенными аннотациями. Например, именно так работает система ORM (Object Relation Mapping) — система сохранения объектов в базу данных (если честно, то не только так). С появлением аннотаций это теперь очень несложно сделать — вы аннотируете класс, который надо сохранить в базу данных специальным набором аннотаций и все. Дальше библиотека смотрит по аннотациям в какую таблицу и какое поле этого объекта к какую колонку записывается. Там еще можно “навесить” дополнительные условия, связи и много чего еще. Скорость разработки возрастает, написание системы упрощается, становится более лаконичной.
Точно также можно делать EJB, сервлеты. JUnit работает по этому принципу. Системы автоматического создания набора нужных объектов (IoC/DI — Inversion of Control/Dependency Injection) с нужными значениями полей использует аннотации. Веб-сервисы строятся на основе аннотаций, работа с XML и много чего еще.
По сути, библиотека просто говорит вам: “если у твоего класса есть такие-то аннотации, то я смогу произвести над ним нужную тебе работу. Просто напиши нужные аннотации с нужными параметрами”.
Аннотации настолько “вросли” в различные технологии Java, что на сегодня без них работать гораздо сложнее.
Для примера я создал свою аннотацию (хотя прикладной программист чаще всего использует уже готовые) для расширения нашего примера с финансовой информацией.
Вот как выглядит аннотация (это файл .java)

package edu.javacourse.reflection;

import java.lang.annotation.Retention;

// Мы собираемся использовать аннотацию во время исполнения
@Retention(java.lang.annotation.RetentionPolicy.RUNTIME)
@interface FinanceAnnotation
{
    // Объявляем параметр для имени класса со значением по умолчанию
    String financeBuilder() default "edu.javacourse.reflection.DbFinanceInfoBuilder";
}

package edu.javacourse.reflection;

import java.lang.annotation.Retention;

// Мы собираемся использовать аннотацию во время исполнения

@Retention(java.lang.annotation.RetentionPolicy.RUNTIME)

@interface FinanceAnnotation

{

// Объявляем параметр для имени класса со значением по умолчанию

String financeBuilder() default "edu.javacourse.reflection.DbFinanceInfoBuilder";

}

И теперь мы можем через аннотацию установить имя класса

/*
 * Класс для создания экземпляра нужного класса
 */
package edu.javacourse.reflection;

import java.lang.annotation.Annotation;

// Объявление аннотации для класса
@FinanceAnnotation(financeBuilder = "edu.javacourse.reflection.WebFinanceInfoBuilder")
public class FinanceInfoBuilderFactory
{
    public static FinanceInfoBuilder getFinanceInfoBuilder() {
        try {
            // Получаем аннотацию к классу. Т.к. это наш класс, то можно его приводить
            Annotation ann =
                    FinanceInfoBuilderFactory.class.getAnnotation(FinanceAnnotation.class);
            FinanceAnnotation fa = (FinanceAnnotation)ann;
            
            // Загружаем класс по имени
            Class cl = Class.forName(fa.financeBuilder());
            // Т.к. наш класс должен имплементировать интерфейс FinanceInfoBuilder
            // то мы можем сделать приведение к интерфейсу
            FinanceInfoBuilder builder = (FinanceInfoBuilder)cl.newInstance();
            return builder;
        } catch (ClassNotFoundException | InstantiationException | IllegalAccessException ex) {
            ex.printStackTrace(System.out);
        }
        return null;
    }
}

* Класс для создания экземпляра нужного класса

package edu.javacourse.reflection;

import java.lang.annotation.Annotation;

// Объявление аннотации для класса

@FinanceAnnotation(financeBuilder = "edu.javacourse.reflection.WebFinanceInfoBuilder")

public class FinanceInfoBuilderFactory

{

public static FinanceInfoBuilder getFinanceInfoBuilder() {

try {

// Получаем аннотацию к классу. Т.к. это наш класс, то можно его приводить

Annotation ann =

FinanceInfoBuilderFactory.class.getAnnotation(FinanceAnnotation.class);

FinanceAnnotation fa = (FinanceAnnotation)ann;

// Загружаем класс по имени

Class cl = Class.forName(fa.financeBuilder());

// Т.к. наш класс должен имплементировать интерфейс FinanceInfoBuilder

// то мы можем сделать приведение к интерфейсу

FinanceInfoBuilder builder = (FinanceInfoBuilder)cl.newInstance();

return builder;

} catch (ClassNotFoundException | InstantiationException | IllegalAccessException ex) {

ex.printStackTrace(System.out);

}

return null;

}

Конечно же, в нашем случае такое использование аннотации имеет сомнительную эффективность, но здесь важно увидеть принцип — я создал аннотацию и теперь я могу с над аннотированным классом произвести нужные мне действия, используя информацию из этой аннотации.

Проект в NetBeans можно загрузить здесь: FinanceExampleAnnotation

Выводы

Как вы могли видеть, рефлексия является очень мощным инструментом, который повышает гибкость системы. Но за это приходится платить немалую цену — скорость вызова методов (или обращение к полю) через рефлексию значительно замедляет работу системы — в разы и даже в десятки и сотни раз. Будьте очень внимательны при решении использовать рефлексию.
В интернете существует немало интересных статей, посвященных сторонним реализациям рефлексии, возможностям повысить производительность. В некоторых случаях они настолько успешно работают, что по скорости немногим уступают прямым вызовам, но все-таки увлекаться этим не стоит — в конце концов, если настройка вашей системы будет сложнее самой системы, то зачем она такая нужна.
Разумеется, что в данной статье мы не затронули дстаточно большое количество моментов, которые решает Reflection API. Но мне хотелось, чтобы вы увидели основы рефлексии, которые позволят вам понять, что многие “чудесные” возможности Java решаются именно с помощью рефлексии и основные моменты для этого мы рассмотрели. Надеюсь, что дальше вам будет гораздо проще находить тонкости при работе с рефлексией.

И теперь нас ждет следующая статья: Установка СУБД PostgreSQL.

Name *
Email *
URL (include http://)
Subject *
Question *	Notify Me On Answer:

Reflection (Рефлексия) — основы

Первое знакомство

Класс Class

Аннотации

Выводы

Отправить запрос

Your question has been sent!