Dependency Injection and Aspect Oriented Programming presentation

Dependency Injection and
Aspect Oriented Programming

Steve Erdman
Senior Developer, Wharton Computing
steve.erdman77@gmail.com

What is a dependency?
Container of functionality defined outside the
current code used by that code to achieve its
central purpose

public class WoosterAlone {
private RedAstonMartin theCar;
public WoosterAlone(){
theCar = new RedAstonMartin();
}
public void trip(){
theCar.drive();
}
}

public class WoosterWithGarage {
private Garage garage;
public WoosterWithGarage(Garage garage){
this.garage = garage;
}
public void trip(){
garage.claimCar("Best Car").drive();
}
}

public class WoosterAssisted {
private Car theCar;
public WoosterAssisted(Car theCar){
this.theCar = theCar;
}
public void trip(){
theCar.drive();
}
}

Why is the better?
• Decouples your code
• Reduces/Removes glue
• Large number of occasions where Wooster
needs the car
• Red Aston Martin in the shop – Black Jaguar
instead
• Roads are icy – take all weather car instead

Decoupling code
• Objects should only be responsible for
themselves (Single Responsibility Principle)
• Design to interfaces
• Modularity
– Easy to debug
– Easy to test
– Easy to replace
– Easy to iterate

Glue
• The code that joins your objects together
• Gluing should not be part of an object’s
responsibilities
• All other things being equal, the less amount
of glue, the better

Inversion of control
• Pull from registry
• Dependency Injection

Dependency Injection process
• Register your objects (“beans”)
– System determines dependencies
• Wire in dependencies
• Instantiate your beans

Dependencies
• Property setter to interface
– Can use constructor, but won’t get into that
• Wiring
– Wired explicitly during bean registry
– Pulled from other bean/properties
– Autowired
• By name
• By type
– Controlled Autowiring

Registering Beans
<bean id=“theCar" name=“RedLightning BestCar” class=“RedAstonMartin“ />
<bean id=“trip” class=“WoosterAssisted”>
<property name=“theCar”>
<ref bean=“theCar” />
</property>
</bean>

Wiring by pulling
@Value(“#{theCar.licensePlateNumber}”)
private String garageTicket;

Autowiring
<bean id=“theCar" name=“RedLightning BestCar” class=“RedAstonMartin“ />
<bean id=“trip” class=“WoosterAssisted” autowire=“byType” />
OR
<bean id=“trip” class=“WoosterAssisted” autowire=“byName” />

Annotation Autowiring
@Autowired
private Car theCar;
private void setTheCar(Car theCar){
}
public WoosterAssisted(){
}
public void trip(){
theCar.drive();
}
}

Annotation Autowiring by Name
@Resource(name=“RedLightning”)
private Car theCar;
private void setTheCar(Car theCar){
}
public WoosterAssisted(){
}
public void trip(){
theCar.drive();
}
}

Autowiring Lists
@AutoWired
private Car[] cars;
private void setCars(Car[] cars){
this.cars = cars;
}

Component Scanning
<context:component-scan />
• Registers all the beans it can find
• Glue is completely hidden
• Can set starting package
• Can add include and exclude filters

Environment sets
• Can set beans based on environment
• e.g.
– Local environment -> embedded database
– Testing -> Mocked data connection
– Dev environment -> dev SQL Server
– Dev + NoSQL -> dev Cassandra Server
– Prod -> prod SQL Server

Bean scopes
• Singleton (default)
• Prototype (new instance every time)
• Request (new instance every request)
• Session (new instance every session)
• Thread (new instance every thread)

Basic Messaging
public class BasicHelloMain {
public static void main(String[] args) {
System.out.println("Hello World!");
}
}

Separate Pieces of Functionality
• Message content
• Message renderer
• Connecting content to renderer

Separate Messaging
public class SimpleMessageProvider {
public String getMessage() {
return "Hello World!";
}
}

Separate Messaging
public class StandardOutMessageRenderer {
private SimpleMessageProvider provider;
public StandardOutMessageRenderer(){
setMessageProvider(new SimpleMessageProvider());
}
public void setMessageProvider(SimpleMessageProvider provider) {
this.provider = provider;
}
public SimpleMessageProvider getMessageProvider() {
return provider;
}
public void render() {
System.out.println(getMessageProvider().getMessage());
}
}

Separate Messaging
public class HelloWorldMain {
StandardOutMessageRenderer renderer = new StandardOutMessageRenderer();
renderer.render();
}
}

Central Managed
public interface MessageProvider {
public String getMessage();
}
public interface MessageRenderer {
public void render();
public void setMessageProvider(MessageProvider provider);
public MessageProvider getMessageProvider();
}

Central Managed
public class SimpleMessageProvider implements MessageProvider {
}
}
public class RegistryMessageProvider implements MessageProvider {
return registry.lookup(“message.greeting");
}
}

Central Managed
public class StandardOutMessageRenderer implements MessageRenderer {
private MessageProvider provider;
public void setMessageProvider(MessageProvider provider) {
}
public MessageProvider getMessageProvider() {
return provider;
}
if (getMessageProvider()==null){
throw new RuntimeException("Missing MessageProvider");
}
}
}

Central Managed
MessageProvider provider = new SimpleMessageProvider();
MessageProvider provider = new RegistryMessageProvider();
MessageRenderer renderer = new StandardOutMessageRenderer();
renderer.setMessageProvider(provider);
renderer.render();
}
}

Dependency Injected
@Service("simpleMessageProvider")
public class SimpleMessageProvider implements MessageProvider {
}
}

Dependency Injected
@Service
public class StandardOutMessageRenderer implements MessageRenderer {
private MessageProvider provider;
public void setMessageProvider(MessageProvider provider) {
}
public MessageProvider getMessageProvider() {
return provider;
}
if (getMessageProvider()==null){
throw new RuntimeException("Missing MessageProvider");
}
}
}

Dependency Injected
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.2.xsd">
<context:annotation-config />
<context:component-scan base-package="edu.upenn.wharton.messaging.ioc.di.annotation" />
</beans>

Dependency Injected
GenericXmlApplicationContext ctx = new GenericXmlApplicationContext();
ctx.load("classpath:di-central-app-context.xml");
ctx.refresh();
MessageRenderer renderer = ctx.getBean("messageRenderer");
renderer.render();
}
}

Dependency Injected
@Service("injectedMessageProvider")
public class InjectedMessageProvider implements MessageProvider {
private String message;
public void setMessage(String message){
this.message = message;
}
return message;
}
}

Dependency Injected
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.2.xsd">
<context:annotation-config />
<bean id="messageProvider"
class="edu.upenn.wharton.messaging.ioc.di.annotation.InjectedMessageProvider">
<property name="message">
<value>Hello World!</value>
</property>
</bean>
<context:component-scan
base-package="edu.upenn.wharton.messaging.ioc.di.annotation"
include-classes="*Renderer"
/>
</beans>

Dependency Injection - injects registered
dependency objects into established Interface
properties
Aspect Oriented Programming - injects entirely
new functionality

What is not a dependency?
Functionality included in the flow of a request
that is not part of the central purpose of the
current object.
Good example of this is cross cutting concerns,
such as logging or security

Wooster wants to
• Keep track of all the things he does, for his
autobiography
• Keep track of the lies he tells his Aunt Agatha
• Keep his financial accounts in order
• Not intrude where he is not wanted
• Speak to foreign chaps without having to learn
their lingo

This involves
• Keep track of all the things he does, for his
autobiography - Logging
• Keep track of the lies he tells his Aunt Agatha -
Caching
• Keep his financial accounts in order -
Transactions
• Not intrude where he is not wanted - Security
• Speak to foreign chaps without having to learn
their lingo -Translation

@Logged
public class WoosterActions {
@Cached
public String generateLieForAuntAgatha(String situation, Date occurrence){
...
}
@Transactional
public void transferMoney(int amount, Account accountFrom, Account accountTo){
...
}
public enterClub(@Secured(“Wooster Approved”) Club club){
...
}
@Translate
public void talkTo(String message, Person listener){
...
}
@Translate
public String listenTo(Person talker){
...
}
}

Aspect components
• Join Point – a place in code that can be the
target for an aspect
• Point Cut – The query that selects the join
points that will the be targets for the aspect
• Advice – The code that will be run at the
selected Join Points

Join Point, Point Cuts, WTH???
• Very much like CSS/jQuery selectors
• A Join Point is anywhere that can be joined
– In selectors, this is any DOM element
• Selectors match on things like DOM hierarchy,
element type, id, attributes, etc.
• Point cuts match on things like Class, Package,
or Method names, Method signature,
Annotations, etc.

Why is there a formal name for Join
Points?
• Join points give us access to the runtime
values when advice is being run
– Current class
– Method name
– Argument names and values
– Annotations
– etc.

AspectJ Point Cut syntax
<match type>(<access> <return type>
<class>.<method>(<method parameters>))
e.g.
– execution(public String Wooster.*(..))
– execution(* @Logging*.*(..))
Don’t focus on this. I’m using fake syntax in my
examples.

Composite Point Cuts
• && = AND
• || = OR
• ! = NOT

Advice types
• Before
• After
• After Returning
• After Throwing
• Around

Before Advice
@Before(“joinMethod”)
public void doBefore(JoinPoint joinPoint){
beforeAction();
}
public void joinMethod(){
insideAction();
}
beforeAction();
insideAction();
}

After Advice
@After(“joinMethod”)
public void doBefore(JoinPoint joinPoint){
afterAction();
}
insideAction();
}
insideAction();
afterAction();
}

Around Advice
@Around(“joinMethod”)
public void doBefore(ProceedingJoinPoint joinPoint){
beforeAction();
joinPoint.proceed();
afterAction();
}
insideAction();
}

Around Advice (continued)
beforeAction();
insideAction();
afterAction();
}

Inter Type Definitions (ITD)
• Adds code at compile time to matching Join
Points
• Enables the Mixin behavior of many advices
• Can set up a dependency injection

@Logged
public class WoosterActions {
@Cached
lieGeneratingCode(situation, occurrence);
}
@Transactional
transferFromAccount(accountFrom, amount);
transferToAccount(accountTo, amount);
}
enterClubCode(club);
}
@TranslateIncoming
talkToCode(message, listener);
}
@TranslateReturn
return listenToCode(talker);
}
}

Logging Aspect
@Aspect
public class LoggingAspect {
private Log4JLogger log = new Log4JLogger("Jeeves");
@Before("@within(Logging) && execution(public * *.*(..)")
public void logExecution(JoinPoint joinPoint){
log.info(joinPoint.getSignature().toString());
}
}

Caching Aspect
@Aspect
public class CachingAspect {
@Autowired
private Cache cache;
@Around("@annotation(Cacheable)")
public Object checkCache(ProceedingJoinPoint joinPoint) throws Throwable{
Object result = cache.get(joinPoint.getTarget().hashCode());
if (result != null){
return result;
}
result = joinPoint.proceed();
cache.put(joinPoint.getTarget().hashCode(), result);
return result;
}
}

Generate Lies
@Cached
return lieGeneratingCode(situation, occurrence);
}

Add Logging Aspect
@Cached
return lieGeneratingCode();
}

Add Cached Aspect
@Cached
Object result = cache.get(joinPoint.getTarget().hashCode());
if (result != null){
return result;
}
result = lieGeneratingCode();
cache.put(joinPoint.getTarget().hashCode(), result);
return result;
}

Transactional Aspect
@Aspect
public class TransactionalAspect {
@Autowired
private TransactionService transactionService;
@Around("@annotation(Transactional)")
public Object doTransaction(ProceedingJoinPoint joinPoint){
transactionService.startTransaction();
try{
Object result = joinPoint.proceed();
transactionService.commitTransaction();
return result;
} catch (Throwable e) {
transactionService.rollbackTransaction();
throw e;
}
}
}

Transferring Money
@Transactional
withdrawFromAccount(accountFrom, amount);
depositToAccount(accountTo, amount);
}

Add Transaction Aspect
@Transactional
transactionService.startTransaction();
try{
withdrawFromAccount(accountFrom, amount);
depositToAccount(accountTo, amount);
transactionService.commitTransaction();
return result;
} catch (Throwable e) {
transactionService.rollbackTransaction();
throw e;
}
}

Secured Aspect
@Aspect
public class SecuredAspect {
@Autowired
private SecurityService securityService;
@Before("* *.*(@annotation(Secured) Club club)")
public void checkSecured(JoinPoint joinPoint){
Annotation[][] annotations = ((MethodSignature)
joinPoint.getSignature()).getMethod().getParameterAnnotations();
if (!securityService.checkAccess(joinPoint.getArgs()[0],
annotations[0][0])){
throw new SecurityException();
}
}
}

Enter Club
}

Add Secured Aspect
Annotation[][] annotations = ((MethodSignature)
joinPoint.getSignature()).getMethod().getParameterAnnotations();
if (!securityService.checkAccess(joinPoint.getArgs()[0],
annotations[0][0])){
throw new SecurityException();
}
}

Translation Aspect
@Aspect
public class TranslationAspect {
@Autowired
private TranslationService translationService;
@Around("@annotation(TranslateIncoming)")
public void translateIncoming(ProceedingJoinPoint joinPoint) {
Object[] args = joinPoint.getArgs();
args[0] = translationService.translateMessage((String) args[0]);
joinPoint.proceed(args);
}
@AfterReturning(value = "@annotation(TranslateReturn)", returning = "message")
public String translateReturn(Object message){
return translationService.translateMessage((String) message);
}
}

Talking to foreign jobbie
@TranslateIncoming
public void talkTo(Person listener, String message){
talkToCode(listener, message);
}
@TranslateReturn
return listenToCode(talker);
}

Add Translate Aspect
@TranslateIncoming
Object[] args = joinPoint.getArgs();
args[0] = translationService.translateMessage((String) args[0]);
talkToCode(args[0], args[1]);
}
@TranslateReturn
message = listenToCode(talker);
return translationService.translateMessage(message);
}

Dependency Injection and Aspect Oriented Programming presentation

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Was ist angesagt?

Was ist angesagt? (20)

Andere mochten auch

Andere mochten auch (6)

Ähnlich wie Dependency Injection and Aspect Oriented Programming presentation

Ähnlich wie Dependency Injection and Aspect Oriented Programming presentation (20)

Kürzlich hochgeladen

Kürzlich hochgeladen (20)

Dependency Injection and Aspect Oriented Programming presentation