Cdiaop PDF

sytd htl krems - alauntalstrasse 29
Programmiertechniken in verteilten
Systemen
Dipl.-Ing. Paul Panhofer Bsc.
9. Dezember 2019
1 IOC - Inversion of Control

Library vs. Framework
Framework Hook
2 CDI - Context and Dependency Injection

Spring Container
Qualifier
Lifecycle Hooks
Bean Scope
3 AOP - Aspectoriented Programming

Aspekte
Aspektorientierte Programmierung
Pointcut Expression
Advice
Dipl.-Ing. Paul Panhofer Bsc. — Spring Boot — 9. Dezember 2019

2/76
IOC - Inversion of Control


3/76


4/76

Spring Framework

5/76
Inversion of Control beruht auf dem Prinzip das der User-

code vom Framework aufgerufen wird und nicht vice
versa.
Ein Framework stellt sogenannte Hooks zur Verfügung, die

der Programmierer verwenden kann, um seinen Code in
das Framework einzufügen.

6/76

Framework Hook

Spring Container
Qualifier
Lifecycle Hooks
Bean Scope

Aspekte
Pointcut Expression
Advice

7/76

Framework Hook

8/76

Framework Hook

9/76

Framework Hook
Das Spring Framework verwendet in erster Linie

Annotationen als Hooks.
Hinweis: Nicht jede Anotation darf als Framework Hook

verstanden werden.

10/76

Framework Hook: Rest Resource
@RequestMapping(path="/branches")
@RestController // <-- Framework Hook
public class BranchResource implements Serializable{
@GetMapping(path="/{id}")
public ABranch read(@PathVariable Long id){
...
}
...

11/76

Framework Hook: Exception Handling
public UserService implements Serializable{

...
public void unmarshal(String jsonMessage){
ObjectMapper mapper = new ObjectMapper();
try{
mapper.readValue(jsonMessage, User.class);
}catch(JsonProcessingException ex){
ex.printStackTrace();
log.error("invalid data");
}
}
}

12/76

public UserService implements Serializable{

...
public void unmarshal(String jsonMessage) throws
JsonProcessingException{
ObjectMapper mapper = new ObjectMapper();

User user = mapper.readValue(jsonMessage,
User.class);
...
}
}

13/76

@ControllerAdvice // <-- Framework Hook

public class JsonProcessingAdvice {
@ExceptionHandler(JsonProcessingException.class)
@ResponseBody
@ResponseStatus(HttpStatus.NOT_FOUND)
public String
jsonProcessingFailed(JsonProcessingException ex){
...
}

14/76

Framework Hook: Service
@Service // <-- Framework Hook

public class DirectRabbitMQConsumer {
@RabbitListener(queues="htl.sytd")
public void listen(String message) throws
JsonProcessingException {
...
}

15/76

Framework Hook

Spring Container
Qualifier
Lifecycle Hooks
Bean Scope

Aspekte
Pointcut Expression
Advice

16/76
CDI - Context and Dependency

Injection
CDI: Outsourcing the construction and management of

objects.
Pattern: Factory

17/76

Injection
Spring Container
Zur Implementierung von CDI greifen Spring Boot Anwen-

dungen auf den Spring Container - ApplicationContext -
zurück.
Der Spring Container ist für die Verwaltung von CDI Beans
verantwortlich.

18/76

Injection
Spring Container - CDI Bean
CDI Beans sind im Grunde gewöhnliche Java Objekte.
Im Gegensatz zu anderen Java Objekten ist der Spring

Container für die Instanzierung und die Verwaltung von
CDI Beans verantwortlich.

19/76

Injection
CDI Beans sind Objekte die mit einer der folgenden Anno-
tationen deklariert wurden.
Hinweis: Die folgende Liste ist nur ein kleiner Auszug der
möglichen Annotationen.
@ControllerAdvise
@RestController
@Configuration
@Component
@Service
@Bean

20/76

Injection
Der Spring Container ist für die Instanzierung von CDI

Beans verantwortlich.
Abhängigkeiten zu anderen Objekten müssen in CDI

Beans nicht definiert werden. Der Spring Container wurde
mit der Motivation entwickelt Abhängigkeiten selbst
aufzulösen.

21/76

Injection
@Service // 1.) CDI Bean

public class UserService implements Serializable {
@Autowired // 2.) Abhaengigkeit

public User user;
...

22/76

Injection
Spring Container
Der Spring Container versucht die bei der Instanzierung

auftretenden Abhaengigkeiten aufzuloesen, in dem er
unter den von ihm verwalteten CDI Beans nach jenem
Bean sucht, das dieselbe Schnittstelle implementiert bzw.
dieselbe Klasse hat wie die Abhängigkeit.

23/76
CDI - Dependency Injection

24/76

Injection
@Service // Declare Object as CDI Bean

public class UserService implements Serializable{
@Autowired // Resolve Dependency

public User user;
...

25/76

Injection
/*
* Search Codebase for a @Component or @Bean with same
* class or interface
*/
@Component
@Data
public class User implements Serializable{
private String firstName;

...
}

26/76

Injection
/*
* Search Codebase for a @Component or @Bean with same
* class or interface
*/
@Configuration
public class UserFactory{
@Bean("user")
public User createUser(){
return new User();
}

27/76

Injection
Spring Container
Findet der Spring Container keine Klasse bzw. zuviele

Klassen die der externen bzw. internen Schnittstelle der
Abhängigkeit entsprechen wird ein entsprechender
Fehler geworfen.

28/76

Framework Hook

Spring Container
Qualifier
Lifecycle Hooks
Bean Scope

Aspekte
Pointcut Expression
Advice

29/76

Injection
Dependency Injection Failed
@Qualifier("admin")
@Component
@Data
public class Admin extends User{...}
@Qualifier("guest")
@Component
@Data
public class Guest extends User{...}

30/76

Injection
@Service
@Qualifier("admin")
@Autowired
public User admin;
@Qualifier("guest")
@Autowired
public User guest;

31/76

Injection
Declare own Qualifiers
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target({ElementType.FIELD, ElementType.METHOD,
ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
@Qualifier
public @interface User {
String value();
}

32/76

Injection
Dependency Injection - Qualifier
@User("admin")
@Component
@Data
public class Admin extends User{...}
@User("guest")
@Component
@Data
public class Guest extends User{...}

33/76

Injection
@Service
@User("admin")
@Autowired
public User admin;
@User("guest")
@Autowired
public User guest;

34/76

Injection
@Configuration
public class UserFactory {
@Bean("admin") @User("admin")
public User createAdmin(){
return new Admin();
}
@Bean("user") @User("guest")
public User createGuest(){
return new Guest();
}

35/76

Framework Hook

Spring Container
Qualifier
Lifecycle Hooks
Bean Scope

Aspekte
Pointcut Expression
Advice

36/76

Injection

37/76

Injection
@Component
@Data
public class User implements Serializable{
private String firstName;
@PostConstruct
public void init(){ ... }
@PreDestroy
public void dispose(){ ... }

38/76

Framework Hook

Spring Container
Qualifier
Lifecycle Hooks
Bean Scope

Aspekte
Pointcut Expression
Advice

39/76

Injection
Bean Scope
Der Bean Scope bestimmt für CDI Beans die folgenden

Eigenschaften:
• Lebensdauer.
• Anzahl der Instanzen.
• Art des Zugriffs auf das Bean.

40/76

Injection
Bean Scope
Für CDI Beans können 2 Arten von Scopes definiert

werden. Defaultmäßig werden CDI Beans als Singletons
erzeugt.
• Singleton: Es wird nur eine Instanz des CDI Beans in

der gesamten Anwendung verwaltet.
• Protoype: Für jede Abhängigkeit wird eine neue
Instanz des CDI Beans generiert.

41/76

Injection
@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
//@Scope(ConfigurableBeanFactory.SCOPE_SINGLETON)
//@Scope("singleton")
//@Scope("prototype")
@Component
public class User implements Serializable {
...
}

42/76

Injection
@RunWith(SpringRunner.class)
class CDITest{
@Autowired
private ApplicationContext applicationContext;
public void testBeanScope(){

User user = applicationContext.getBean(User.class);
...
}
}

43/76

Framework Hook

Spring Container
Qualifier
Lifecycle Hooks
Bean Scope

Aspekte
Pointcut Expression
Advice

44/76
AOP - Aspectoriented Programming

45/76

@Service
public class BankService {
...
public BigDecimal checkAccount(Long accountId){
// Transaction tr = appContext.getTransaction();
// tr.start();
BigDecimal value =
accountRepository.check(accountId);
// log.info("checked account {}", accountId);

// tr.commit();
return value;
}
}

46/76
Die Bestandteile von Software können grob in 2 Kate-

gorien unterteilt werden.
• Komponenten, welche die funktionale Anforderun-

gen des Programms umsetzen.
• logische Aspekte, welche technische Anforderungen
wie Validierung oder Logging abbilden.

47/76

Aspekte
Komponenten lassen sich in der Regel relativ leicht

modular gestalten.
Aspekte hingegen sind mit dem herkömmlichen,

objektorientieren Ansatz schwer zu isolieren.

48/76

Aspekte
• Transaction Management
• Logging
• Performance Monitor
• Ecxeption Handling
• Security
• Audit Log Management

49/76

Aspekte
Die Zielsetzung der aspektorientierten Programmierung ist

die klare Trennung von Komponenten und Aspekten.
Ohne AOP liegt Code redundant vor. Wir sprechen in die-

sem Fall von Code Scattering. Die Kohäsion des Systems
leidet.

50/76

Aspekte
Die Idee der Apektorientierten Programmierung ist es

Aspkete zu kapseln um sie anschließend in transparenter
Weise in den Anwendungscode zu integrieren.

51/76

Framework Hook

Spring Container
Qualifier
Lifecycle Hooks
Bean Scope

Aspekte
Pointcut Expression
Advice

52/76
AOP wird verwendet um verteilt vorkommende Aspekte

modular zu gestalten. AOP stützt sich dabei auf 2 Ent-
wurfsmuster: Proxy, Dekorator

53/76

AOP Implementierung - BankService
package at.htl.krems.service;
public class BankService {

...
public Double checkAccount(Long accountId){
// Transaction tr = appContext.getTransaction();
// tr.start();
Double value = accountRep.check(accountId);
// log.info("checked account {}", accountId);

// tr.commit();
return value;
}
}

54/76

public interface IBankService extends Serializable {
Double checkAccount(Long accountId);

55/76

public class BankService implements IBankService{

...
Double value = accountRep.check(accountId);
return value;
}
}

56/76

public class TransactionAspect implements IBankService{
private IBankService bankService;

Transaction tr = AppContext.getTransaction();
tr.start();
Double value = bankService.checkAccount(accountId);
tr.commit();
}
}

57/76

public class LoggingAspect implements IBankService{
private IBankService bankService;
private Logger logger = ...;

Double value = bankService.checkAccount(accountId);
logger.info("...");
}
}

58/76

AOP - Begriffe
• Target: Zielklasse, in der die Verwendung von

Aspekten benötigt wird.
• JointPoint: Ein Punkt der Programmausführung an
dem man eine bestimmte Methode eines Aspekts
ausführen möchte.
• Advice: Methode in einem Aspekt, die an einem
oder mehreren Join Points in den Programmablauf
eingebunden werden.
• Pointcut Expression: Ein Ausdruck zur Auswahl von
JoinPoints.

59/76

@Component
@Aspect
public class TransactionAspect {
@Around("execution(* * checkAccount(..))")
public Object execute(ProceedingJointPoint jp){
Transaction tr = AppContext.getTransaction();
tr.start();
Object result = null;

try{
Object result = jp.proceed();
}catch(Exception e){tr.rollback();}
tr.commit();
return result;
}
}
60/76
@Component
@Aspect // Definition eines Aspekts
// Definition eines Advice

@Around("execution(..)"// PointCut Expression)
...
}

61/76

Framework Hook

Spring Container
Qualifier
Lifecycle Hooks
Bean Scope

Aspekte
Pointcut Expression
Advice

62/76

Pointcut Expression
Eine Pointcut Expression ist ein Ausdruck zur Auswahl von

JoinPoints.
Sie bestimmt für welche Methoden in welchen Klassen

der Advice des Aspekts angewandt werden soll.

63/76

64/76

Syntax: Pointcut Expression
expression(
modifiers-pattern? // optional
return-type-pattern
declaring-type-pattern? // optional
method-name-pattern(param-pattern)
thorws-pattern? // optional
)

65/76

/*
* checkAccount Methode der BankService Klasse
*/
expression(
public
Double
at.htl.krems.service.BankService.checkAccount(..)
)

66/76

/*
* checkAccount Methode einer beliebigen Klasse
*/
expression(
public
Double
checkAccount(..)
)

67/76

/*
* beliebige Methode deren Name mit check beginnt
*/
expression(
*
*
check*(..)
)

68/76

/*
* checkAccount Methode aller Klassen in einem bestimmten
* Package
*/
expression(
*
*
at.htl.krems.service.*.*(..)
)

69/76

// keine Parameter
expression( public double checkAccount() )
// ein Parameter beliebigen Typs

expression( public double checkAccount(*) )
// beliebige Zahl von Parametern beliebigen Typs

expression( public double checkAccount(..) )

70/76

Framework Hook

Spring Container
Qualifier
Lifecycle Hooks
Bean Scope

Aspekte
Pointcut Expression
Advice

71/76

Advice
Advice sind Methoden in einem Aspekt, die an einem

oder mehreren Join Points in den Programmablauf
eingebunden werden.

72/76

@Component
@Aspect
public class LoggingAspect{
@Before("execution(* * checkAccount(..))")
public void logCall(JointPoint jp){
...
MethodSignature ms = (MethodSignature)
jp.getSignature();
log.info(ms);
..
Object[] args = jp.getArg();
...
}

73/76
@Component
@Aspect
@AfterReturning(
pointcut="execution(* * checkAccount(..))",
returning="value")
public void logCall(JointPoint jp, double value){
...
}

74/76
@Component
@Aspect
@AfterThrowing(
pointcut="execution(* * checkAccount(..))",
throwing="ex")
public void logCall(JointPoint jp, Throwable ex){
...
}
}

75/76

@Component
@Aspect
@Around("execution(* * checkAccount(..))")
...
Object result = null;
try{
result = jp.proceed();
}catch(Exception e)
{ ... }
return result;
}
}

76/76

Sprache

Cdiaop PDF

Hochgeladen von

Dokumentinformationen

Originaltitel

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Cdiaop PDF

Hochgeladen von

Copyright:

Verfügbare Formate

sytd htl krems - alauntalstrasse 29

1 IOC - Inversion of Control

2 CDI - Context and Dependency Injection

3 AOP - Aspectoriented Programming

Dipl.-Ing. Paul Panhofer Bsc. — Spring Boot — 9. Dezember 2019

IOC - Inversion of Control

Dipl.-Ing. Paul Panhofer Bsc. — Spring Boot — 9. Dezember 2019

IOC - Inversion of Control

Dipl.-Ing. Paul Panhofer Bsc. — Spring Boot — 9. Dezember 2019

IOC - Inversion of Control

Dipl.-Ing. Paul Panhofer Bsc. — Spring Boot — 9. Dezember 2019

IOC - Inversion of Control

Inversion of Control beruht auf dem Prinzip das der User-

Ein Framework stellt sogenannte Hooks zur Verfügung, die

Dipl.-Ing. Paul Panhofer Bsc. — Spring Boot — 9. Dezember 2019

1 IOC - Inversion of Control

2 CDI - Context and Dependency Injection

3 AOP - Aspectoriented Programming

Dipl.-Ing. Paul Panhofer Bsc. — Spring Boot — 9. Dezember 2019

IOC - Inversion of Control

Dipl.-Ing. Paul Panhofer Bsc. — Spring Boot — 9. Dezember 2019

IOC - Inversion of Control

Dipl.-Ing. Paul Panhofer Bsc. — Spring Boot — 9. Dezember 2019

IOC - Inversion of Control

Das Spring Framework verwendet in erster Linie

Hinweis: Nicht jede Anotation darf als Framework Hook

Dipl.-Ing. Paul Panhofer Bsc. — Spring Boot — 9. Dezember 2019

IOC - Inversion of Control

Dipl.-Ing. Paul Panhofer Bsc. — Spring Boot — 9. Dezember 2019

IOC - Inversion of Control

public UserService implements Serializable{

Dipl.-Ing. Paul Panhofer Bsc. — Spring Boot — 9. Dezember 2019

IOC - Inversion of Control

public UserService implements Serializable{

ObjectMapper mapper = new ObjectMapper();

Dipl.-Ing. Paul Panhofer Bsc. — Spring Boot — 9. Dezember 2019

IOC - Inversion of Control

@ControllerAdvice // <-- Framework Hook

Dipl.-Ing. Paul Panhofer Bsc. — Spring Boot — 9. Dezember 2019

IOC - Inversion of Control

@Service // <-- Framework Hook

Dipl.-Ing. Paul Panhofer Bsc. — Spring Boot — 9. Dezember 2019

1 IOC - Inversion of Control

2 CDI - Context and Dependency Injection

3 AOP - Aspectoriented Programming

Dipl.-Ing. Paul Panhofer Bsc. — Spring Boot — 9. Dezember 2019

CDI - Context and Dependency

CDI: Outsourcing the construction and management of

Dipl.-Ing. Paul Panhofer Bsc. — Spring Boot — 9. Dezember 2019

CDI - Context and Dependency

Zur Implementierung von CDI greifen Spring Boot Anwen-

Dipl.-Ing. Paul Panhofer Bsc. — Spring Boot — 9. Dezember 2019

CDI - Context and Dependency

CDI Beans sind im Grunde gewöhnliche Java Objekte.

Im Gegensatz zu anderen Java Objekten ist der Spring

Dipl.-Ing. Paul Panhofer Bsc. — Spring Boot — 9. Dezember 2019

CDI - Context and Dependency

Dipl.-Ing. Paul Panhofer Bsc. — Spring Boot — 9. Dezember 2019

CDI - Context and Dependency

Der Spring Container ist für die Instanzierung von CDI

Abhängigkeiten zu anderen Objekten müssen in CDI

Dipl.-Ing. Paul Panhofer Bsc. — Spring Boot — 9. Dezember 2019