127 lines
7.9 KiB
Markdown
127 lines
7.9 KiB
Markdown
# Delegering - Logger-oppgave
|
|
|
|
Denne oppgaven bruker delegeringsteknikken for å implementere en fleksibel måte å håndtere logging (av feil i programmer) på.
|
|
|
|
## Logging
|
|
|
|
Ved kjøring av programmer er det ofte behov for å logge hva som skjer underveis, slik at det blir lettere å drive feilsøking i etterkant. F.eks. kan en lagre feilmeldinger til fil, med tidspunkt og litt om programtilstanden og hvis programmet kræsjer ordentlig, så kan brukeren sende logg-fila som e-post til utviklerne. En enkel måte å støtte logging på er å lage en hjelpeklasse med én metode, f.eks. `log(String melding)`, og så er det hjelpeklassen som bestemmer om meldingen skal vises i statuslinja, skrives til fil, sendes som melding til en alarmsentral osv. Hjelpeklassen kan kanskje brukes av mange programmer, og siden behovene vil variere er det viktig å gjøre dette fleksibelt. Denne oppgaven bruker [grensesnitt](https://www.ntnu.no/wiki/pages/viewpage.action?pageId=65936813) og [delegeringsteknikken](https://www.ntnu.no/wiki/display/tdt4100/Delegeringsteknikken) for å implementere fleksibel logging, litt på samme måte som eksisterende loggingsrammeverk (se f.eks. [Java sin egen loggingsfunksjonalitet](http://docs.oracle.com/javase/6/docs/technotes/guides/logging/overview.html), Apache sitt [log4j-rammeverk](http://logging.apache.org/log4j/), Eclipse sin innebygde [loggingsmekanisme](http://www.vogella.com/tutorials/EclipseLogging/article.html#logging) eller Google ["Java logging framework"](https://www.google.no/search?q=java+logging+frameworks)).
|
|
|
|
### ILogger-grensesnittet
|
|
|
|
Logging gjøres ved å bruke ulike implementasjoner av **ILogger**, som er definert som følger:
|
|
|
|
```java
|
|
package delegation;
|
|
|
|
public interface ILogger {
|
|
public String ERROR = "error", WARNING = "warning", INFO = "info";
|
|
public void log(String severity, String message, Exception exception);
|
|
}
|
|
```
|
|
|
|
ILogger-grensesnittet definerer én log-metode som brukes til all logging:
|
|
|
|
- `severity`-argumentet angir alvorlighetsgraden, og må være en av **String**-verdiene **ERROR**, **WARNING** eller **INFO**, som er definert som konstanter i grensesnittet.
|
|
- `message`-argumentet er en melding om hva som var feil.
|
|
- `exception`-argumentet er et unntaksobjekt, som kan gi mer informasjon av hva som var feil, men kan være **null**.
|
|
|
|
En typisk bruk vil være i **catch**-delen av en **try/catch**:
|
|
|
|
```java
|
|
ILogger logger = ...
|
|
...
|
|
try {
|
|
...
|
|
} catch (IOException ioe) {
|
|
logger.log(ILogger.ERROR, "Feil ved lesing fra fil", ioe);
|
|
}
|
|
```
|
|
|
|
Akkurat hvordan logging utføres bestemmes av hvilken implementasjon av ILogger-grensesnittet en bruker, og i denne oppgaven skal du implementere følgende tre klasser:
|
|
|
|
- **DistributingLogger** - delegerer til andre loggere basert på *alvorlighetsgraden*
|
|
- **FilteringLogger** - delegerer til en annen logger, men kun for spesifikke alvorlighetsgrader
|
|
- **StreamLogger** - skriver logg-meldingen til en angitt strøm
|
|
|
|
Hver av disse utgjør én av deloppgavene beskrevet under.
|
|
|
|
## Del 1 - StreamLogger
|
|
|
|
En **StreamLogger** sørger for å skrive alle logg-meldinger til en angitt **OutputStream**, med én melding pr. linje (altså linjeskift mellom hver melding). **OutputStream**-objektet må gis inn i konstruktøren:
|
|
|
|
- `StreamLogger(OutputStream stream)` - initialiserer **StreamLogger**-objektet slik at logg-meldinger skrives til **stream**.
|
|
|
|
Eksempel på bruk:
|
|
|
|
```java
|
|
ILogger logger = new StreamLogger(System.out);
|
|
logger.log(ILogger.INFO, "Denne meldingen er til informasjon og skrives til System.out", null);
|
|
```
|
|
|
|
Husk å kalle **flush**-metoden til OutputStream etter at logg-meldingen er skrevet.
|
|
|
|
Det skal også være mulig å angi en såkalt *format*-string, dvs. en **String** som fungerer som en slags mal for hva som skrives, f.eks. `"%s: %s (%s)"`:
|
|
|
|
- `setFormatString(String formatString)` - setter format-string-en som brukes for å lage logg-meldingen som skrives
|
|
|
|
Effekten av skriving skal være som om man ga format-string-en som første argument til **String.format**-metoden etterfulgt av severity-, message- og exception-argumentene, og så skrev ut det denne metoden returnerer:
|
|
|
|
```java
|
|
String logMessage = String.format(formatString, severity, message, exception);
|
|
// skriv logMessage til OutputStream-en her
|
|
```
|
|
|
|
Merk at dersom format-string-en ikke er satt, så skal den ha en fornuftig start-verdi.
|
|
|
|
Testkode for oppgaven: [patterns/delegation/StreamLoggerTest.java](../../src/test/java/patterns/delegation/StreamLoggerTest.java).
|
|
|
|
## Del 2 - FilteringLogger
|
|
|
|
**FilteringLogger**-klassen implementerer **ILogger**-grensesnittet og delegerer til en annen **ILogger**-implementasjon, men bare hvis *alvorlighetsgraden* er en av et sett angitte verdier. Både loggeren det delegeres til og alvorlighetsgradene angis når **FilteringLogger**-objektet opprettes:
|
|
|
|
- `FilteringLogger(ILogger logger, String... severities)` - initialiserer **FilteringLogger**-objektet så det delegerer logging til **logger**-argumentet, men bare hvis *alvorlighetsgraden* som gis til **log**-metoden er en av verdiene angitt i **severities**-argumentet. **severities**-argumentet er et såkalt varargs-argument, som du kan lese mer om her: [Varargs - variabelt antall argumenter](https://www.ntnu.no/wiki/display/tdt4100/Varargs+-+variabelt+antall+argumenter).
|
|
|
|
Det skal også være mulig å sjekke om logging er på og slå logging av og på i etterkant:
|
|
|
|
- `boolean isLogging(String severity)` - returnerer **true** hvis logging er slått på for den angitte alvorlighetsgraden og **false** ellers.
|
|
- `void setIsLogging(String severity, boolean value)` - slår logging på (**value = true**) eller av (**value = false**) for den angitte *alvorlighetsgraden*
|
|
|
|
Eksempel på bruk:
|
|
|
|
```java
|
|
ILogger syserrLogger = new StreamLogger(System.err);
|
|
FilteringLogger logger = new FilteringLogger(syserrLogger, ILogger.ERROR);
|
|
logger.log(ILogger.ERROR, "Denne meldingen er alvorlig og skrives til System.err", null);
|
|
logger.log(ILogger.WARNING, "Denne meldingen er en advarsel og blir filtrert bort", null);
|
|
logger.log(ILogger.INFO, "Denne meldingen er til informasjon og blir filtrert bort", null);
|
|
logger.setIsLogging(ILogger.WARNING, true);
|
|
logger.log(ILogger.WARNING, "Denne meldingen er en advarsel og blir nå skrevet til System.err", null);
|
|
```
|
|
|
|
Testkode for oppgaven: [patterns/delegation/FilteringLoggerTest.java](../../src/test/java/patterns/delegation/FilteringLoggerTest.java).
|
|
|
|
## Del 3 - DistributingLogger
|
|
|
|
**DistributingLogger**-klassen brukes for å fordele logg-meldinger til en av tre andre loggere, avhengig av *alvorlighetsgraden* til en logg-melding. Den har én hjelpe-logger for meldinger med alvorlighetsgrad **ERROR**, én for meldinger av alvorlighetsgrad **WARNING** og en for meldinger av alvorlighetsgrad **INFO**. Alle disse angis til konstruktøren:
|
|
|
|
- `DistributingLogger(ILogger errorLogger, ILogger warningLogger, ILogger infoLogger)` - initialiserer objektet slik at den første loggeren brukes til alvorlighetsgraden **ERROR**, den andre til alvorlighetsgraden **WARNING** og den tredje til alvorlighetsgraden **INFO**.
|
|
|
|
I tillegg skal klassen ha en metode for å sette hver av dem individuelt:
|
|
|
|
- `void setLogger(String severity, ILogger logger)` - setter/endrer loggeren som brukes for den angitte alvorlighetsgraden.
|
|
|
|
Eksempel på bruk:
|
|
|
|
```java
|
|
ILogger syserrLogger = new StreamLogger(System.err);
|
|
ILogger sysoutLogger = new StreamLogger(System.out);
|
|
DistributingLogger logger = new DistributingLogger(syserrLogger, syserrLogger, sysoutLogger);
|
|
logger.log(ILogger.ERROR, "Denne meldingen er alvorlig og skrives til System.err", null);
|
|
logger.log(ILogger.WARNING, "Denne meldingen er en advarsel og skrives til System.err", null);
|
|
logger.log(ILogger.INFO, "Denne meldingen er til informasjon og skrives til System.out", null);
|
|
logger.setLogger(ILogger.WARNING, sysoutLogger);
|
|
logger.log(ILogger.WARNING, "Denne meldingen er en advarsel, men nå skrives den til System.out", null);
|
|
```
|
|
|
|
Testkode for oppgaven: [patterns/delegation/DistributingLoggerTest.java](../../src/test/java/patterns/delegation/DistributingLoggerTest.java).
|