Zeker! Hieronder vind je een voorbeeld van hoe je een aangepaste Java-annotatie `MijnLogging` kunt maken, inclusief de implementatie voor het loggen van de methode-uitvoeringstijd met Log4j. Ik geef ook enkele best practices voor effectief gebruik. --- ### Stap 1: Definieer de annotatie `MijnLogging` ```java import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; /** * Aangepaste annotatie voor logging van methode-uitvoeringstijd. */ @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.METHOD) public @interface MijnLogging { } ``` ### Stap 2: Maak een Aspect (Aspect-Oriented Programming) voor de logging Gebruik bijvoorbeeld AspectJ of Spring AOP om de annotatie te gebruiken voor automatisch logging. Hier is een voorbeeld met AspectJ: ```java import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.Logger; import org.aspectj.lang.ProceedingJoinPoint; import org.aspectj.lang.annotation.Around; import org.aspectj.lang.annotation.Aspect; import org.aspectj.lang.annotation.Pointcut; /** * Aspect dat methodes met @MijnLogging logt. */ @Aspect public class LoggingAspect { private static final Logger logger = LogManager.getLogger(LoggingAspect.class); @Pointcut("@annotation(MijnLogging)") public void methodWithMijnLogging() {} @Around("methodWithMijnLogging()") public Object logExecutionTime(ProceedingJoinPoint joinPoint) throws Throwable { long start = System.currentTimeMillis(); Object proceed = joinPoint.proceed(); long duration = System.currentTimeMillis() - start; String methodName = joinPoint.getSignature().toShortString(); logger.info("Uitvoering van {} duurde {} ms", methodName, duration); return proceed; } } ``` ### Stap 3: Gebruik de annotatie in je code ```java public class VoorbeeldKlasse { @MijnLogging public void doeIets() { // Simuleer werk try { Thread.sleep(500); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } } } ``` ### Best practices: - **Gebruik AOP**: Voor automatische logging van methodes met de annotatie, gebruik AspectJ of Spring AOP. - **Configureer Log4j correct**: Zorg dat je Log4j-configuratie correct is ingesteld voor het loggen (bijvoorbeeld in `log4j2.xml`). - **Beperk het gebruik**: Gebruik de annotatie vooral voor belangrijke methodes waar je prestatiegegevens wilt monitoren. - **Documenteer het gebruik**: Voeg javadoc toe aan je annotatie en aspect zodat andere ontwikkelaars weten wat het doet. - **Test je aspect**: Zorg dat je unit tests hebt om te bevestigen dat de logging correct plaatsvindt. --- Met deze aanpak kun je eenvoudig methodes markeren met `@MijnLogging` en wordt automatisch de uitvoeringstijd gelogd.

Hier is een complete implementatie voor je aangepaste `@MijnLogging` annotatie met Log4j integratie: ## 1. De Annotatie Definiëren ```java package com.jouw.package.logging; import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; @Target(ElementType.METHOD) @Retention(RetentionPolicy.RUNTIME) public @interface MijnLogging { String niveau() default "INFO"; boolean logParameters() default true; boolean logReturnWaarde() default false; String customBericht() default ""; } ``` ## 2. Aspect voor Logging Functionaliteit ```java package com.jouw.package.aspect; import com.jouw.package.logging.MijnLogging; import org.apache.log4j.Logger; import org.aspectj.lang.ProceedingJoinPoint; import org.aspectj.lang.annotation.Around; import org.aspectj.lang.annotation.Aspect; import org.aspectj.lang.reflect.MethodSignature; import org.springframework.stereotype.Component; import java.util.Arrays; @Aspect @Component public class LoggingAspect { private static final Logger logger = Logger.getLogger(LoggingAspect.class); @Around("@annotation(mijnLogging)") public Object logMethodUitvoering(ProceedingJoinPoint joinPoint, MijnLogging mijnLogging) throws Throwable { MethodSignature signature = (MethodSignature) joinPoint.getSignature(); String methodNaam = signature.getMethod().getName(); String klasseNaam = joinPoint.getTarget().getClass().getSimpleName(); long startTijd = System.currentTimeMillis(); // Log methode start logBericht(mijnLogging.niveau(), String.format("Methode %s.%s gestart%s", klasseNaam, methodNaam, mijnLogging.logParameters() ? " met parameters: " + Arrays.toString(joinPoint.getArgs()) : "")); try { Object resultaat = joinPoint.proceed(); long uitvoeringTijd = System.currentTimeMillis() - startTijd; // Log methode succesvol afgerond String returnLog = mijnLogging.logReturnWaarde() ? (resultaat != null ? " met return: " + resultaat.toString() : " met return: null") : ""; String customMsg = mijnLogging.customBericht().isEmpty() ? "" : " - " + mijnLogging.customBericht(); logBericht(mijnLogging.niveau(), String.format("Methode %s.%s voltooid in %d ms%s%s%s", klasseNaam, methodNaam, uitvoeringTijd, returnLog, customMsg, mijnLogging.customBericht())); return resultaat; } catch (Exception e) { long uitvoeringTijd = System.currentTimeMillis() - startTijd; // Log fout logBericht("ERROR", String.format("Methode %s.%s gefaald na %d ms met fout: %s", klasseNaam, methodNaam, uitvoeringTijd, e.getMessage())); throw e; } } private void logBericht(String niveau, String bericht) { switch (niveau.toUpperCase()) { case "DEBUG": logger.debug(bericht); break; case "WARN": logger.warn(bericht); break; case "ERROR": logger.error(bericht); break; case "TRACE": logger.trace(bericht); break; default: logger.info(bericht); break; } } } ``` ## 3. Gebruiksvoorbeelden ```java package com.jouw.package.service; import com.jouw.package.logging.MijnLogging; import org.springframework.stereotype.Service; @Service public class GebruikerService { // Basis gebruik - alleen uitvoertijd @MijnLogging public List<Gebruiker> alleGebruikersOphalen() { // implementatie return gebruikerRepository.findAll(); } // Met aangepast niveau en parameter logging @MijnLogging(niveau = "DEBUG", logParameters = true) public Gebruiker gebruikerZoekenOpId(Long id) { // implementatie return gebruikerRepository.findById(id); } // Met return waarde logging en custom bericht @MijnLogging(niveau = "INFO", logReturnWaarde = true, customBericht = "Gebruiker authenticatie") public boolean authenticeren(String gebruikersnaam, String wachtwoord) { // implementatie return authService.authenticeer(gebruikersnaam, wachtwoord); } // Alleen foutlogging @MijnLogging(niveau = "ERROR", logParameters = false) public void gebruikerVerwijderen(Long id) { // implementatie gebruikerRepository.deleteById(id); } } ``` ## 4. Configuratie ### Spring XML Configuratie: ```xml <!-- in applicationContext.xml --> <aop:aspectj-autoproxy/> <context:component-scan base-package="com.jouw.package"/> ``` ### Spring Boot Configuratie: ```java @Configuration @EnableAspectJAutoProxy public class AopConfig { // Automatisch gedetecteerd door component scanning } ``` ### Log4j Configuratie (log4j.properties): ```properties log4j.rootLogger=INFO, stdout log4j.appender.stdout=org.apache.log4j.ConsoleAppender log4j.appender.stdout.Target=System.out log4j.appender.stdout.layout=org.apache.log4j.PatternLayout log4j.appender.stdout.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %-5p %c{1}:%L - %m%n # Specifieke logging voor jouw aspect log4j.logger.com.jouw.package.aspect=DEBUG ``` ## 5. Best Practices ### 1. **Selectief Gebruik** ```java // Alleen gebruiken bij kritieke of trage methodes @MijnLogging public void kritiekeOperatie() { // complexe logica } // Niet gebruiken bij triviale methodes public String eenvoudigeGetter() { return this.naam; } ``` ### 2. **Performance Overwegingen** ```java // Gebruik logReturnWaarde alleen wanneer nodig @MijnLogging(logReturnWaarde = true) // Alleen als return waarde belangrijk is public BigDecimal berekenComplexResultaat() { // zware berekening } // Vermijd bij grote collecties @MijnLogging(logReturnWaarde = false) // Beter voor grote datasets public List<Data> groteDatasetOphalen() { return database.haalAlleDataOp(); } ``` ### 3. **Security Bewustzijn** ```java // Nooit gevoelige data loggen @MijnLogging(logParameters = false) // Geen wachtwoorden loggen! public void wijzigWachtwoord(String gebruikersnaam, String nieuwWachtwoord) { // implementatie } ``` ### 4. **Consistente Toepassing** ```java @Service public class ConsistentService { @MijnLogging(niveau = "INFO") public void methode1() { /* ... */ } @MijnLogging(niveau = "INFO") // Zelfde niveau voor vergelijkbare methodes public void methode2() { /* ... */ } } ``` ## 6. Afhankelijkheden (Maven) ```xml <dependencies> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-aop</artifactId> <version>5.3.21</version> </dependency> <dependency> <groupId>org.aspectj</groupId> <artifactId>aspectjweaver</artifactId> <version>1.9.7</version> </dependency> <dependency> <groupId>log4j</groupId> <artifactId>log4j</artifactId> <version>1.2.17</version> </dependency> </dependencies> ``` Deze implementatie geeft je een flexibele en krachtige logging oplossing die methode-uitvoertijden logt en integreert naadloos met Log4j. Pas de configuratie aan naar je specifieke behoeften!