System setout java

Перенаправление/дублирование системного вывода в Java

Тут недавно в инете наткнулся на линк, где описывалось, как в Java перенаправить системный вывод в файл, имеется ввиду System.out и System.err. С помощью всего одного дополнительно класса + еще несколько строк кода, и мы можем получить неплохой логгер. Все настолько просто, что нет слов, однако не знал раньше… Смотрим!

Перенаправление в файлы (можно в один и тот же)

Main.java

public static void main( String [] args) throws FileNotFoundException <
PrintStream out = new PrintStream( new FileOutputStream( «out.log» ));
PrintStream err = new PrintStream( new FileOutputStream( «err.log» ));
System.setOut( out );
System.setErr(err);
System. out .println( «Hello!» );
String [] array = < "1" , "2" , "3" >;
System. out .println(array[5]); // тут специально вызываем исключение

* This source code was highlighted with Source Code Highlighter .

Exception in thread «main» java.lang.ArrayIndexOutOfBoundsException: 5
at systemout.Main.main(Main.java:38)

Перенаправление в файлы и в консоль IDE

Для перенаправления вывода и в консоль и в файл, нам понадобится класс, расширяющий PrintStream:

DualStream.java

public class DualStream extends PrintStream <

public DualStream(PrintStream out1, PrintStream out2) <
super(out1);
this . out = out2;
>

public void write( byte buf[], int off, int len) <
try <
super.write(buf, off, len);
out .write(buf, off, len);
> catch (Exception e) <
e.printStackTrace();
>
>

public void flush() <
super.flush();
out .flush();
>
>

* This source code was highlighted with Source Code Highlighter .

Тут мы расширили класс PrintStream, путем добавления еще одного поля типа PrintStream, а так же переопределили два метода.

Main.java

public static void main( String [] args) throws FileNotFoundException <

PrintStream out = new PrintStream( new FileOutputStream( «out.log» ));
PrintStream dual = new DualStream(System. out , out );
System.setOut(dual);

PrintStream err = new PrintStream( new FileOutputStream( «err.log» ));
dual= new DualStream(System.err, err);
System.setErr(dual);

System. out .println( «Hello!» );
String [] array = < "1" , "2" , "3" >;
System. out .println(array[5]);

* This source code was highlighted with Source Code Highlighter .

out.log

Exception in thread «main» java.lang.ArrayIndexOutOfBoundsException: 5
at systemout.Main.main(Main.java:38)

Hello!
Exception in thread «main» java.lang.ArrayIndexOutOfBoundsException: 5
at systemout.Main.main(Main.java:38)

Вот таким образом можно получить простой логгер, который подойдет для различных задач.

Перенаправление стандартного ввода/вывода

Дата добавления: 2015-06-12 ; просмотров: 1783 ; Нарушение авторских прав

Класс System позволяет вам перенаправить стандартный ввод, вывод и поток ошибок. Для этого предусмотрены простые статические методы: setIn(InputStream); setOut(PrintStream); setErr(PrintStream). Перенаправление стандартного вывода особенно полезно тогда, когда ваша программа выдает слишком много сообщений сразу и вы попросту не успеваете читать их, поскольку они заменяются новыми сообщениями. Перенаправление ввода удобно для программ, работающих с командной строкой, в которых необходимо поддержать некоторую последовательность введенных пользователем данных. Вот простой пример, показывающий, как использовать эти методы:

// Перенаправление стандартного ввода/вывода.

import java.io.*;

public class Redirecting <

public static void main(String[] args)

throws IOException <

PrintStream console = System.out;

BufferedInputStream in = new BufferedInputStream(

new FileInputStream(«Redirecting.java»));

PrintStream out = new PrintStream(

new BufferedOutputStream(

new FileOutputStream(«test.out»)));

System.setIn(in);

System.setOut(out);

System.setErr(out);

BufferedReader br = new BufferedReader(

new InputStreamReader(System.in));

String s;

while((s = br.readLine()) != null)

System.out.println(s);

out.close(); // Remember this!

System.setOut(console);

Программа присоединяет стандартный ввод к файлу и перенаправляет, стандартный ввод и поток для ошибок в другие файлы. Обратите внимание на сохранение ссылки на исходный объект System.out в начале программы и его восстановление в конце. Перенаправление основано на байтовом, а не на символьном вводе/выводе, поэтому в примере используются InputStream и OutputStream, а не их символьно-ориентированные эквиваленты Reader и Writer.

Новый ввод/вывод (nio)

При создании библиотеки «нового ввода/вывода» Java, появившейся в JDK-1.4 в пакетах java.nio.*, ставилась единственная цель: скорость. Более того, «старые» пакеты ввода/вывода были переписаны с учетом достижений nio, с намерением использовать преимущества повышенного быстродействия, поэтому улучшения вы получите, даже если не будете писать явный nіо-код. Подъем производительности просматривается как в файловом вводе/выводе, который мы здесь рассматриваем, так и в сетевом вводе/выводе.

Увеличения скорости удалось достичь с помощью структур, близких к средствам самой операционной системы: каналов[30] (channels) и буферов (buffers). Канал можно сравнить с угольной шахтой, вырытой на угольном пласте (данные), а буфер — с вагонеткой, которую вы посылаете в шахту. Тележка возвращается доверху наполненная углем, который вы из нее выгружаете. Таким образом, прямого взаимодействия с каналом у вас нет, вы работаете с буфером и «посылаете» его в канал. Канал либо извлекает данные из буфера, либо помещает их в него.

Напрямую взаимодействует с каналом только буфер ByteBuffer, то есть буфер, хранящий простые байты. Если вы просмотрите документацию JDK для класса java.nio.ByteBuffer, то увидите что он достаточно прост: вы создаете его, указывая, сколько места надо выделить под данные. Класс содержит набор методов для получения и помещения данных в виде последовательности байтов или в виде примитивов. Однако возможности записать в него объект или даже простую строку нет. Буфер работает на достаточно низком уровне, поскольку обеспечивается более эффективная совместимость с большинством операционных систем.

Три класса из «старой» библиотеки ввода/вывода были изменены так, чтобы они позволяли получить канал FileChannel: это FileInputStream, FileOutputStream и RandomAccessFile. Заметьте, что эти классы манипулируют байтами, что согласуется с низкоуровневой направленностью nio. Классы для символьных данных Reader и Writer не образуют каналов, однако вспомогательный класс java.nio.channels.Channels имеет набор методов, позволяющих получить объекты Reader и Writer для каналов.

Простой пример использования всех трех типов потоков. Создаваемые каналы поддерживают запись, чтение/запись и только чтение:

// Получение каналов из потоков

import java.nio.*;

import java.nio.channels.*;

import java.io.*;

public class GetChannel <

private static final int BSIZE = 1024;

public static void main(String[] args) throws Exception <

FileChannel fc =

new FileOutputStream(«data.txt»).getChannel();

fc.write(ByteBuffer.wrap(«Some text «.getBytes()));

// Add to the end of the file:

new RandomAccessFile(«data.txt», «rw»).getChannel();

fc.position(fc.size()); // Move to the end

fc.write(ByteBuffer.wrap(«Some more».getBytes()));

fc = new FileInputStream(«data.txt»).getChannel();

ByteBuffer buff = ByteBuffer.allocate(BSIZE);

while(buff.hasRemaining())

System.out.print((char)buff.get());

Some text Some more

Для любого из рассмотренных выше классов потоков метод getChannel() выдает канал FileChannel. Канал довольно прост: ему передается байтовый буфер ByteBuffer для чтения и записи, и вы можете заблокировать некоторые участки файла для монопольного доступа (этот процесс будет описан чуть позже).

Для помещения байтов в буфер ByteBuffer используется один из нескольких методов для записи данных (put); данные записываются в виде одного или нескольких байтов или значений примитивов. Впрочем, как было показано в примере, можно «заворачивать» уже существующий байтовый массив в буфер ByteBuffer, используя метод wrap(). Когда вы так делаете, байтовый массив не копируется, а используется как хранилище для полученного буфера ByteBuffer. В таких случаях говорят, что буфер ByteBuffer создается на базе массива.

Файл data.txt заново открывается с помощью класса RandomAccessFile. Заметьте, что канал FileChannel может перемещаться внутри файла; в нашем примере он сдвигается в конец файла так, чтобы дополнительные записи присоединялись за существующим содержимым.

Чтобы доступ к файлу ограничивался только чтением, следует явно получить байтовый буфер ByteBuffer статическим методом allocate(). Предназначение nio — быстрое перемещение большого количества данных, поэтому размер буфера имеет значение: на самом деле установленный в примере размер в 1 килобайт меньше, чем обычно требуется (поэкспериментируйте с работающим приложением, чтобы найти оптимальное решение).

Можно получить еще большее быстродействие, используя вместо метода allocate() метод allocateDirect(). Он производит буфер «прямого доступа», еще теснее привязанный к низкоуровневой работе операционной системы. Однако такой буфер требует больше ресурсов, а реализация его различается в различных операционных системах. Опять же, поэкспериментируйте со своим приложением и выясните, дадут ли буферы прямого доступа лучшую производительность.

После вызова метода read() буфера FileChannel для сохранения байтов в буфере ByteBuffer также необходимо вызвать для буфера метод flip(), позволяющий впоследствии извлечь из буфера его данные (да, все это выглядит немного неудобно, но помните, что расчет делался на высокое быстродействие, поэтому все делается на низком уровне). И если затем нам снова понадобится буфер для чтения, придется вызывать перед каждым методом read() метод clear(). В этом нетрудно убедиться на примере простой программы копирования файлов:

// Копирование файла с использованием каналов и буферов

import java.nio.*;

import java.nio.channels.*;

import java.io.*;

public class ChannelCopy <

private static final int BSIZE = 1024;

public static void main(String[] args) throws Exception <

Java-приложение: заглянем внутрь

Несколько полезных классов Java позволят упростить процесс отладки.

Чтобы отладить приложение, можно поступить по-разному. Во-первых, можно воспользоваться штатным отладчиком из какого-либо программного пакета. Во-вторых, можно самостоятельно вычислить ошибку — логически, по внешним признакам. И в-третьих, можно «подглядеть», что же там такое творится внутри вашей программы. Для этого, последнего, способа и существуют всевозможные утилиты и библиотеки. Так, в библиотеке MFC из компилятора Visual C++ есть специальные макросы, которые во время запуска примера пересылают требуемую информацию в окно специальной утилиты-монитора (не правда ли, похоже на подглядывание в замочную скважину?). Подобный мониторинг данных стар, как само программирование, и очень прост: нужно выводить на экран дисплея значения переменных, расположенных в участках программы, вызывающих сомнения. Просматривая полученные данные, можно последовательно приблизиться к ошибочному участку.

Что касается Java-приложений, то и здесь мониторинг оказывается возможным, если воспользоваться выводом данных в стандартные потоки вывода и ошибок — System.out и System.err. Часто можно обнаружить в исходных текстах такую строку:

В результате выполнения данной команды в консольном окне приложения появится текстовая строка «Входим в конструктор класса» — знак того, что выполнение программы происходит в заданном месте.

Нельзя ли упростить мониторинг Java-приложений? Конечно же можно. Немного фантазии и понимание, как работают стандартные потоки out и err, нам помогут.

В исходных текстах в файле System.java есть описания стандартных потоков:

Из них следует, что стандартный поток ввода in является ссылкой типа InputStream, а потоки вывода и ошибок out и err — ссылками класса PrintStream. Виртуальная машина Java инициализирует эти ссылки с помощью «родного» кода, который, увы, нам неподконтролен.

Итак, наш план прост: создав альтернативные стандартные потоки, упакуем их поудобнее и придумаем комфортабельный интерфейс доступа к ним, что, собственно говоря, и является главной целью всей этой работы. Начать, разумеется, нужно с создания класса, инкапсулирующего стандартные потоки ввода, вывода и ошибок. Назовем его StdStreams и поместим его исходный текст в файл StdStreams.java (см. Листинг 1).

Листинг 1. Создание класса Stdstreams

Поскольку созданный нами класс не нуждается в наследовании, он реализован как final. Внутри него располагаются три поля, хранящие ссылки на используемые нами потоки (отмечены модификаторами доступа private и static). Почему они сделаны закрытыми для доступа (privat), вполне понятно: незачем изменять их напрямую. А вот добавление static требует пояснения. Дело в том, что в Java статические поля инициализируются сразу же после создания экземпляра класса. Таким образом, ссылки на потоки гарантированно инициализируются перед использованием и, что более важно, эти поля становятся уникальными для всех экземпляров класса StdStream. Из этого следует, что изменение ссылок на потоки — глобально, и все классы, обращающиеся за сервисом к StdStream, обращаются к одному и тому же полю. Обратите внимание, что ссылка на стандартный поток in считается зарезервированной (нам она не нужна, но чем черт не шутит, а вдруг впоследствии пригодится. ). Поскольку все ссылки выполнены как static, то их инициализацию мы производим в статическом блоке.

Чтобы иметь возможность читать и изменять ссылки на потоки (а это нам нужно), у нас имеется тройка методов для чтения ссылок и тройка методов для установки новых ссылок. Все читающие методы начинаются с приставки get, а устанавливающие — с приставки set. Внимательный читатель заметит, что в качестве типа параметров методов setOut() и setErr() выступает класс OutputStream, хотя, как раньше отмечалось, потоки System.out и System.err имеют тип PrintStream. Это объясняется очень просто: абстрактный класс OutputStream является предком всех потоковых классов, и поэтому в качестве параметра можно подставить ссылку на любой класс-наследник от OutputStream, что удобно. Захотели вывести данные в файл, а не на консоль — пожалуйста!

Пользовательский интерфейс для мониторинговых классов должен быть удобным. Пришлось немного повозиться и придумать такие классы, которые было бы легко запомнить и еще легче использовать, например класс SetIn (см. Листинг 2), записанный в файле SetIn.java ниже.

Листинг 2. Создание класса SetIn

Он включает в себя описание самого класса и нескольких его методов. На пустой закрытый конструктор не стоит обращать внимания — он служит лишь для того, чтобы какой-нибудь «умелец» не смог создать экземпляр класса SetIn оператором new (попытавшись, он получит от компилятора отказ). Чтобы экземпляр класса создавался автоматически, его методы должны быть статическими. Тогда при обращении к одному из них виртуальная машина Java сама загрузит объект класса SetIn и выполнит вызванный метод. Вторая цель, которая преследовалась при описании методов как static, — заставить пользователя всегда употреблять имена методов вместе с именем класса, а, если вы помните, ссылка на статические поля и методы класса возможна лишь при использовании полного имени, включающего имя класса, которому поля и методы принадлежат. Так что, если мы хотим переопределить поток in в другое место, то директива будет выглядеть примерно так:

Как видите, переназначение потока ввода читается как естественная фраза на английском языке, чего мы, собственно, и хотели добиться. Сам метод реализован элементарно: он обращается к классу StdStreams, о котором мы уже говорили, и устанавливает поток ввода вызовом метода StdStreams.setIn(). Теперь вы наверняка поняли, зачем мы объявили класс StdStreams с областью видимости package — он виден лишь для классов, которые расположены внутри того же самого пакета.

Но вернемся к классу SetIn. Второй метод сбрасывает последнее выполненное переназначение и устанавливает поток ввода в начальное положение на System.in. Вызов этого метода тоже похож на естественный английский язык:

Аналогичным образом реализованы и классы перенаправления стандартного потока вывода (см. Листинг 3) и стандартного потока ошибок (см. Листинг 4)

Листинг 3. Создание класса перенаправления стандартного потока вывода

Листинг 4. Создание класса стандартного потока ошибок

Еще один важный для нас класс — Debug. Он выполняет роль рубильника, которым мы либо включаем, либо выключаем мониторинг. Как это делается, вы поймете из листинга 5. Конструкция

включает возможность мониторинга, а

ее выключает. Проверить текущее состояние можно, вставив выражение, подобное

Так же как и предыдущие классы, Debug не допускает создания своих экземпляров оператором new, и все его методы описаны как static, чтобы их нельзя было употреблять в отрыве от имени класса (см. Листинг 5).

Листинг 5. Создание класса Debug

package Mitrich.utils; /** * Данный класс играет роль флага разрешения * или запрещения мониторинга */ public final >И вот мы вплотную подошли к основному классу нашей маленькой библиотеки, который, собственно, и выполняет мониторинг. Два его метода — err() и out() — пересылают данные соответственно в поток ошибок и поток вывода. Но, как показывает исходный текст (см. Листинг 6), эти операторы перегружены, благодаря чему они могут выводить в поток данные любого типа.

Листинг 6. Создание основного класса, выполняющего мониторинг

Методы устроены элементарно. Все, что они делают, так это проверяют, включена ли отладка (мы уже акцентировали внимание на этом), и если так, то выводят данные методом println() класса PrintStream. Получается, что методы err() и out() — просто оболочки вокруг уже имеющихся перегруженных методов. Исключение составляют методы, выводящие данные типов String и Object. Для данных типа String применяется вывод методом print(), который не переводит курсор на следующую строку. Это удобно, если необходимо склеить несколько строк в одну или поместить вывод данных переменной непосредственно за текстовым комментарием. Если же хотите сделать перевод каретки, просто добавьте в конец строки символ «n». Для данных типа Object ситуация иная. Чтобы сделать информацию о выводимых данных полезной, ссылку на класс-аргумент следует привести к типу String. Для большинства классов это означает последовательную печать значений всех внутренних полей в виде строки.

Использование класса Trace ничем не отличается от использования уже описанных классов:

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

Java.lang.System класс в Java

В число средств, предоставляемых классом System, входят стандартные потоки ввода, стандартного вывода и вывода ошибок; доступ к внешним свойствам и переменным среды; средство загрузки файлов и библиотек; и служебный метод для быстрого копирования части массива. Это расширяет класс Object.
Поля:

1. public static final InputStream in: «стандартный» поток ввода. Этот поток уже открыт и готов предоставить входные данные. Обычно этот поток соответствует вводу с клавиатуры или другому источнику ввода, указанному хост-средой или пользователем.
2. public static final PrintStream out: «стандартный» поток вывода. Этот поток уже открыт и готов принять выходные данные. Обычно этот поток соответствует выводу на экран или другому выводу, указанному хост-средой или пользователем.
3. public static final PrintStream err: «стандартный» поток вывода ошибок. Этот поток уже открыт и готов принять выходные данные.
   Обычно этот поток соответствует выводу на экран или другому выводу, указанному хост-средой или пользователем. По соглашению, этот выходной поток используется для отображения сообщений об ошибках или другой информации, которая должна быть незамедлительно предоставлена пользователю, даже если основной выходной поток, значение переменной out, было перенаправлено в файл или другое место назначения, которое обычно не контролируется непрерывно.

Методы:

static void arraycopy (Object source, int sourceStart, Object Target, int targetStart, int size): копирует массив. Копируемый массив передается в источнике, а индекс, с которого начинается копия в источнике, передается в sourceStart. Массив, который получит копию, передается в target, а индекс, с которого начинается копия в пределах цели, передается в targetStart. Размер — это количество копируемых элементов.

// Java-код, иллюстрирующий метод arraycopy ()

public static void main(String args[])

System.arraycopy(a, 0 , b, 2 , 2 );

// массив b после операции arraycopy