Как в общем определить сериализуемый Список
Вы хотите сказать, что хотите отслеживать ход выполнения долгосрочного заявления UPDATE? Нет, я не знаю простого способа сделать это. Ни один сеанс за пределами сеанса, в котором выполняется оператор обновления, не сможет увидеть изменения в таблице, пока вы не подтвердите их.
То, что вы могли бы сделать, - это написать программу на PL / SQL, которая делает это порционно и между ними выдает оператор COMMIT. Таким образом, другой сеанс может наблюдать за таблицей и видеть ее как обновленную часть.
7 ответов
Необходимо объявить тип переменной как Result<? extends List<Integer>>.
Проверка типа знает это List не serializable, но подтип List может быть serializable.
Вот некоторый пример кода. Интерфейсная реализация была просто сделана с анонимными внутренними классами. Вы видите что getResult возвратит a List<Integer> на 2-м объекте
Result<Integer> res = new Result<Integer>() {
Integer myInteger;
private static final long serialVersionUID = 1L;
@Override
public Integer getResult() {
return myInteger;
}
@Override
public void addResult(Integer input) {
this.myInteger = input;
}
};
Integer check = res.getResult();
Result<? extends List<Integer>> res2 = new Result<ArrayList<Integer>>() {
ArrayList<Integer> myList;
private static final long serialVersionUID = 1L;
@Override
public ArrayList<Integer> getResult() {
return myList;
}
@Override
public void addResult(ArrayList<Integer> input) {
this.myList = input;
}
};
List<Integer> check2 = res2.getResult();
Править: Сделанный примером больше завершенное путем реализации a void addResult(T input) метод интерфейса
Вы могли просто объявить переменную как Result<ArrayList<Integer>>. Пока Вы все еще программа к List интерфейс, Вы действительно не пожертвовали заменимостью.
Я собирался также предложить создать новый интерфейс ListResult:
public interface ListResult<T extends Serializable & List<E extends Serializable>>
implements Result<T> {
T getResult();
}
но затем необходимо было бы все еще объявить переменную как ListResult<ArrayList<Integer>>. Таким образом, я пошел бы более простым путем.
Если Ваше намерение состоит в том, чтобы использовать тип Результата для списков в целом, и что Вы хотите, должен удостовериться, что элементы списка являются сериализуемыми, Вы могли определить его как это:
public interface Result<T extends List<? extends Serializable>> {}
Тем путем Вы могли определить что-то как:
Result<List<Integer>> r;
Но что-то вроде этого не скомпилировало бы:
Result<List<List>> r;
Теперь, если Вы хотите использовать результат и для, скажем, Целого числа, и для Списка, затем тип не требуется, чтобы быть сериализуемым, правильно? В этом случае я действительно не понимаю, какова Ваша цель.
Хотя интерфейс List не реализует сериализуемый, все встроенные реализации Набора делают. Это обсуждено в учебном руководстве по Реализациям Наборов.
FAQ Дизайна Наборов имеет вопрос, "Почему Набор не расширяет Cloneable и сериализуемый?" который говорит о том, почему Sun разработал его, не расширяясь сериализуемый.
Вы отчасти можете, я думать:
public class Thing<T extends Serializable> implements Serializable {
private static class Holder<V extends Serializable> {
private final V value;
private Holder(V value) {
this.value = value;
}
}
private Holder<? extends List<T>> holder;
private <V extends List<T> & Serializable> void set(V value) {
holder = new Holder<V>(value);
}
}
Это выглядит достаточно ужасным для Вас?
Я могу предложить, чтобы Вы не пытались осуществить реализацию Serializable использование Java статическая система типов? Это - только интерфейс, потому что аннотации не были о тогда. Это просто не практично для осуществления его. OTOH, Вы могли осуществить его с помощью средства проверки типа, которое делает статический анализ в закрытой системе.
Путем я закончил тем, что решил эту проблему, должен использовать это в качестве интерфейса:
public interface Result<T> extends Serializable{
T getResult();
}
Затем создайте реализацию для каждых из различных типов наборов, а также один для любого объекта.
Так, например, вот то, на что был бы похож класс ListResult:
public class ListResult<T> implements Result<List<T>>{
public List<T> getResult(){
//return result
}
public <V extends List<T> & Serializable> void setResult(V result){
//store result
}
}
Начальная буква думала. Если Вы - планирование использования сериализации для какого-либо вида долгосрочного хранения данных, не делать. Сериализация, как гарантируют, не будет работать между вызовами JVM.
Вы, вероятно, не должны расширяться сериализуемый, если Вы не добавляете функциональность, связанную с Сериализацией объекта. Вместо этого Ваш класс, который реализует Результат, должен также реализовать сериализуемый.