1. Каков механизм отражения?
Проще говоря, механизм отражения означает, что программа может получать собственную информацию во время работы. В Java, если указано имя класса, всю информацию о классе можно получить с помощью механизма отражения.
2. Где используется механизм отражения?
Иногда мы использовали некоторые знания, но не знали, что такое профессиональная терминология. Когда мы только изучали jdbc, мы использовали строку кода Class.forName("com.mysql.jdbc.Driver.class"). newInstance() ; Но в то время я знал только, что эта строка кода генерирует экземпляр объекта драйвера, и не знал ее конкретного значения. Прослушав урок о механизме отражения, я понял, что это отражение. В настоящее время многие открытые фреймворки используют механизм отражения.
3. Преимущества и недостатки механизма отражения
Зачем использовать механизм отражения? Разве недостаточно создавать объекты напрямую? Здесь задействованы понятия динамики и статики.
Статическая компиляция: тип определяется во время компиляции, а объект привязывается, то есть передается.
Динамическая компиляция: определите тип и привяжите объект во время выполнения. Динамическая компиляция максимизирует гибкость Java, воплощает полиморфные приложения и уменьшает связь между классами.
Одним словом, преимущество механизма отражения состоит в том, что он может динамически создавать объекты и компилировать их, что демонстрирует большую гибкость. Особенно при разработке J2EE его гибкость очень очевидна. Например, для крупномасштабного программного обеспечения невозможно идеально спроектировать его за один раз. После того как программа скомпилирована и выпущена, когда обнаруживается, что определенные функции необходимо обновить, мы не можем попросить пользователя удалить предыдущие. один, а затем переустановите его. В этом случае это программное обеспечение определенно не будет использоваться многими людьми. Если он статический, всю программу необходимо один раз перекомпилировать для реализации обновления функции. Если он использует механизм отражения, его не нужно удалять. Для реализации функции его нужно только динамически создать и скомпилировать.
Его недостатком является влияние на производительность. Использование отражения — это, по сути, интерпретируемая операция, с помощью которой мы можем сообщить JVM, что мы хотим сделать, и это соответствует нашим требованиям. Такие операции всегда медленнее, чем простое выполнение той же операции напрямую.
4. Какую информацию можно получить, используя механизм отражения?
Одним словом, он может получить любую информацию, которая есть в классе, но обязательным условием является знание имени класса, иначе никакой дополнительной информации не будет. Во-первых, объект Class должен быть создан на основе полного имени класса. входящий класс.
Class c=Class.forName("className"); Примечание: className должно быть полным именем, то есть оно должно включать имя пакета, например, cn.netjava.pojo.UserInfo;
Object obj=c.newInstance();//Создаем экземпляр объекта
Хорошо, когда у вас есть объект, со всем легко обращаться. Вы можете получить любую информацию, какую захотите.
Как получить конструктор
Constructor getConstructor(Class[] params)//Получаем публичный конструктор по указанным параметрам
Constructor[] getConstructors()//Получить все общедоступные конструкторы
Конструктор getDeclardConstructor(Class[] params)//Получить общедоступные и закрытые конструкторы на основе указанных параметров
Constructor[] getDeclardConstructors()//Получить все общедоступные конструкторы
Получить метод метода класса
Метод getMethod(String name, Class[] params), получает метод на основе имени метода и типа параметра.
Method[] getMethods()//Получить все общедоступные методы
Метод getDeclaredMethod(String name, Class[] params)//В соответствии с именем метода и типом параметра получить общедоступные и закрытые методы
Method[] getDeclardMethods()//Получить все публичные и закрытые методы
Как получить атрибуты в классе
Поле getField(String name)//Получите соответствующую общедоступную переменную в соответствии с именем переменной
Field[] getFields()//Получить все общедоступные методы в классе
Поле getDeclardField(String name)//Получить общедоступные и закрытые переменные на основе имени метода
Field[] getDeclardFields()//Получаем все публичные и закрытые методы в классе
Это наиболее часто используемые. Если вы их знаете, со всем остальным будет легко справиться...
5. Что можно сделать с механизмом отражения?
Когда я впервые начал использовать jdbc, меня рвало, когда я писал для доступа к базе данных. Там было восемь таблиц, и в каждой таблице были операции добавления, удаления, изменения и поиска. В то время я не знал сути концепции. Механизм отражения, поэтому я написал про разные Создавать разные классы DAO в таблице, что не только ускоряет разработку, но и делает код избыточным. Самое ужасное, что они выглядят практически одинаково, а потом их напрямую копируют и модифицируют. поскольку легко допустить различные ошибки низкого уровня (верхний и нижний регистр, еще одна буква или одна буква отсутствует...), поиск одной ошибки может занять много времени.
С механизмом отражения Java все легко обрабатывается. Вам нужно всего лишь написать класс dao с четырьмя методами, добавлять, удалять, изменять и запрашивать, а также передавать разные объекты. Нет необходимости создавать. dao для каждой таблицы. Механизм отражения сделает все остальное за нас, в этом его преимущество. Грубо говоря, механизм отражения предназначен для того, чтобы помочь нам выполнять повторяющиеся и регулярные действия, поэтому многие программы, которые автоматически генерируют код, теперь используют механизм отражения для его завершения. Пока вы вводите соответствующие параметры в соответствии с правилами, это малоэффективно. программисты уровня медленные. Медленные были уничтожены, почему? Потому что код писать не нужно, его может разработать любой, так зачем же этим занимаются программисты? Так что у нас есть только один выход: работать усерднее и усерднее, стать старшим программистом, специализироваться на разработке глупого программного обеспечения и позволить другим программистам отойти в сторону и остыть, хаха~
6. Пример использования механизма отражения для добавления и проверки данных базы данных.
Основной принцип: при сохранении данных извлеките все значения атрибутов объектов, которые необходимо сохранить, а затем соберите оператор SQL для запроса и упакуйте все запрошенные данные в объект Java.
Правила игры: Как говорится, без правил нет ничего. Особенно программы: они не могут делать ничего без правил. Хорошо, сначала установим правила.
1) Каждый объект таблицы в базе данных имеет класс pojo, и каждое поле в таблице соответствует атрибуту класса pojo. Более того, имя класса pojo совпадает с именем таблицы, а имя атрибута и имя поля совпадают. Регистр не имеет значения, поскольку база данных обычно не учитывает регистр.
2) Добавьте стандартный набор и получите методы для каждого атрибута в классе pojo.
Ознакомившись с правилами игры, приступим к игре.
1. Во-первых, в базе данных есть таблица. Предположим, что имя базы данных: blogsystem, а имя таблицы в ней — userinfo. Как показано на рисунке:
2. Создайте соответствующий класс pojo:
Скопируйте код кода следующим образом:
пакет cn.netjava.pojo;
общественный класс UserInfo {
частный внутренний идентификатор;
частное имя строки;
частная строка pwd;
частный возраст;
@Override
публичная строка toString() {
вернуть "UserInfo [id=" + id + ", name=" + name + ", pwd=" + pwd + ", age="
+ возраст + "]";
}
общественный int getId() {
вернуть идентификатор;
}
общественный недействительный setId (int id) {
this.id = идентификатор;
}
публичная строка getName() {
вернуть имя;
}
public void setName (имя строки) {
это.имя = имя;
}
публичная строка getPwd() {
вернуть пароль;
}
public void setPwd(String pwd) {
this.pwd = pwd;
}
общественный int getAge() {
возвратный возраст;
}
public void setAge(int age) {
this.age = возраст;
}
}
2. Напишите фабричный класс для получения соединения с базой данных:
Скопируйте код кода следующим образом:
пакет cn.netjava.factory;
импортировать java.sql.Connection;
импортировать java.sql.DriverManager;
общественный класс Connect2DBFactory {
общедоступное статическое соединение getDBConnection() {
Соединение конн = ноль;
пытаться {
Class.forName("com.mysql.jdbc.Driver");
Строка URL = "jdbc:mysql://localhost:3306/blogsystem";
Строка пользователя = «корень»;
Строковый пароль = «netjava»;
conn = DriverManager.getConnection(url, пользователь, пароль);
} catch (Исключение е) {
е.printStackTrace();
}
возврат соединения;
}
}
3. Самое интересное начинается с написания класса dao, который управляет базой данных.
Скопируйте код кода следующим образом:
пакет cn.netjava.session;
импортировать java.lang.reflect.Field;
импортировать java.lang.reflect.Method;
импортировать java.sql.Connection;
импортировать java.sql.PreparedStatement;
импортировать java.sql.ResultSet;
импортировать java.sql.SQLException;
импортировать java.sql.Statement;
импортировать java.util.ArrayList;
импортировать java.util.List;
импортировать cn.netjava.factory.Connect2DBFactory;
импортировать cn.netjava.pojo.UserInfo;
общественный класс NetJavaSession {
/**
* Разберите оператор sql, который сохраняет объект
*
* объект @param
*: Объект, который необходимо сохранить.
* @return: оператор sql для сохранения объекта
*/
public static String getSaveObjectSql (объект объекта) {
//Определяем строку sql
Строка sql = «вставить в»;
// Получаем класс объекта
Класс c = object.getClass();
// Получаем все методы объекта
Метод [] методы = c.getMethods();
// Получаем все свойства объекта
Field[] поля = c.getFields();
// Получаем имя класса объекта
Строка cName = c.getName();
// Анализируем имя таблицы по имени класса
Строка tableName = cName.substring(cName.lastIndexOf(".") + 1,
cName.length());
sql += имя_таблицы + "(";
List<String> mList = новый ArrayList<String>();
Список vList = новый ArrayList();
for (Метод метода: методы) {
Строка mName = метод.getName();
if (mName.startsWith("get") && !mName.startsWith("getClass")) {
Строковое имя поля = mName.substring(3, mName.length());
mList.add(имя поля);
System.out.println("Имя поля ----->" + имя поля);
пытаться {
Значение объекта = метод.invoke(объект, ноль);
System.out.println("Значение, возвращаемое методом выполнения: " + value);
if (значение экземпляра строки) {
vList.add("/"" + значение + "/"");
System.out.println("Значение поля ------>" + значение);
} еще {
vList.add(значение);
}
} catch (Исключение е) {
е.printStackTrace();
}
}
}
for (int i = 0; i < mList.size(); i++) {
если (я < mList.size() - 1) {
sql += mList.get(i) + ",";
} еще {
sql += mList.get(i) + ")values(";
}
}
for (int i = 0; i <vList.size(); i++) {
если (я <vList.size() - 1) {
sql += vList.get(i) + ",";
} еще {
sql += vList.get(i) + ")";
}
}
вернуть SQL;
}
общедоступный статический список getDatasFromDB (String tableName, int Id) {
вернуть ноль;
}
/**
* Сохраняем объект в базу данных
*
* объект @param
*: Объект, который необходимо сохранить.
* @return: Результат выполнения метода 1: указывает на успех, 0: указывает на неудачу;
*/
public int saveObject (объект объекта) {
Соединение con = Connect2DBFactory.getDBConnection();
Строка sql = getSaveObjectSql (объект);
пытаться {
// Оператор оператор=(Оператор) con.createStatement();
ReadedStatement psmt = con.prepareStatement(sql);
psmt.executeUpdate();
возврат 1;
} catch (SQLException e) {
е.printStackTrace();
вернуть 0;
}
}
/**
* Получить объект из базы данных
*
* @параметр arg0
*: Класс, к которому принадлежит объект.
* @парам идентификатор
*: идентификатор объекта
* @return: объект, который нужно найти
*/
public Object getObject (String className, int Id) {
// Получаем имя таблицы
Строка tableName = className.substring(className.lastIndexOf(".") + 1,
ИмяКласса.Длина());
//Создаем объект класса на основе имени класса
Класс c = ноль;
пытаться {
c = Class.forName(имякласса);
} catch (ClassNotFoundException e1) {
e1.printStackTrace();
}
// Собираем воедино оператор SQL-запроса
String sql = "выбрать * из " + tableName + " где Id = = + Id;
System.out.println("Найти оператор sql: " + sql);
// Получаем ссылку на базу данных
Соединение con = Connect2DBFactory.getDBConnection();
//Создаем экземпляр класса
Объект объект = ноль;
пытаться {
Заявление stm = con.createStatement();
// Получаем возвращаемый набор результатов, выполнив оператор поиска
ResultSet set = stm.executeQuery(sql);
// Получаем массив методов объекта
Метод [] методы = c.getMethods();
// Обход набора результатов
в то время как (set.next()) {
объект = c.newInstance();
//Методы перемещения объектов
for (Метод метода: методы) {
Строка имя метода = метод.getName();
// Если метод объекта начинается с set
если (methodName.startsWith("set")) {
// Получаем имя поля в таблице данных на основе имени метода
Строка имя_столбца = Имя_метода.подстрока(3,
Имяметода.длина());
// Получаем тип параметра метода
Класс [] parmts = метод.getParameterTypes();
if (parmts[0] == String.class) {
// Если параметр имеет тип String, получаем соответствующее значение из набора результатов в соответствии с именем столбца и выполняем метод set
метод.invoke(obj, set.getString(имя столбца));
}
if (parmts[0] == int.class) {
метод.invoke(obj, set.getInt(имя столбца));
}
}
}
}
} catch (Исключение е) {
е.printStackTrace();
}
вернуть объект;
}
}
4. Как насчет эффекта от запуска теста:
Скопируйте код кода следующим образом:
пакет cn.netjava.tester;
импортировать cn.netjava.pojo.UserInfo;
импортировать cn.netjava.session.NetJavaSession;
Тестер публичного класса {
public static void main(String args[]) {
//Получаем объект NetJavaSession
Сеанс NetJavaSession = новый NetJavaSession();
//Создаем объект UserInfo
Пользователь UserInfo = новый UserInfo();
//Установим свойства объекта
user.setId(6988);
user.setAge(44);
user.setPwd("pwd");
user.setName("чемпион");
//Сохраняем объект в базу данных
Строка sql = session.getSaveObjectSql(пользователь);
System.out.println("Оператор SQL для сохранения объекта: " + sql);
//Найти объект
UserInfo userInfo = (UserInfo) session.getObject(
"cn.netjava.pojo.UserInfo", 6988);
System.out.println("Информация получена: " + userInfo);
}
}
5. Распечатанные результаты:
7. Подведем итоги
В целом механизм отражения в Java — очень полезная вещь. Он может решить множество мертвых вещей, поскольку механизм отражения очень гибкий. С его помощью нам не нужно тратить слишком много времени на написание операций вместо использования кода базы данных. метод тратит больше времени на логические функции проекта. Это может значительно сократить время разработки и сделать код более читабельным. Многие существующие платформы с открытым исходным кодом используют механизмы отражения. Им нужно только настроить файлы, а затем вызвать их методы в соответствии с правилами.