From: Gustavo Martin Morcuende <gu.martinm@gmail.com>
Date: Mon, 11 Apr 2016 00:43:19 +0000 (+0200)
Subject: Spring AOP and maven plugin
X-Git-Url: https://git.gumartinm.name/?a=commitdiff_plain;h=3dd8df2fd2ed6e7be978e7f01f8c2b1e17b4d705;p=JavaForFun

Spring AOP and maven plugin
---

diff --git a/SpringJava/AOP/SpringAOP20/pom.xml b/SpringJava/AOP/SpringAOP20/pom.xml
new file mode 100644
index 0000000..b43ac81
--- /dev/null
+++ b/SpringJava/AOP/SpringAOP20/pom.xml
@@ -0,0 +1,124 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<project
+	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"
+	xmlns="http://maven.apache.org/POM/4.0.0" 
+	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+	
+	<modelVersion>4.0.0</modelVersion>
+    <groupId>de.spring.example</groupId>
+	<artifactId>spring-aop-example</artifactId>
+    <version>2.0-SNAPSHOT</version>
+	<name>spring-aop-example</name>
+	<url>http://gumartinm.name</url>
+    <properties>
+      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+    </properties>
+
+	<dependencies> 
+       <dependency>
+           <groupId>org.springframework</groupId>
+           <artifactId>spring-context</artifactId>
+           <version>4.2.5.RELEASE</version>
+           <!-- 
+               Required dependency for getting rid of commons logging and use my own logging library
+               (in my case I decided to use log4j 2 under slf4j)
+           -->
+           <exclusions>
+               <exclusion>
+                   <groupId>commons-logging</groupId>
+                   <artifactId>commons-logging</artifactId>
+               </exclusion>
+           </exclusions>
+       </dependency>
+      <dependency>
+          <groupId>org.springframework</groupId>
+          <artifactId>spring-aspects</artifactId>
+          <version>4.2.5.RELEASE</version>
+          <!-- 
+              Required dependency for getting rid of commons logging and use my own logging library
+              (in my case I decided to use log4j 2 under slf4j)
+          -->
+          <exclusions>
+              <exclusion>
+                  <groupId>commons-logging</groupId>
+                  <artifactId>commons-logging</artifactId>
+              </exclusion>
+          </exclusions>
+      </dependency>
+      <dependency>
+          <groupId>org.springframework</groupId>
+          <artifactId>spring-aop</artifactId>
+          <version>4.2.5.RELEASE</version>
+          <!-- 
+              Required dependency for getting rid of commons logging and use my own logging library
+              (in my case I decided to use log4j 2 under slf4j)
+          -->
+          <exclusions>
+              <exclusion>
+                  <groupId>commons-logging</groupId>
+                  <artifactId>commons-logging</artifactId>
+              </exclusion>
+          </exclusions>
+      </dependency>
+
+      <dependency>
+        <groupId>cglib</groupId>
+        <artifactId>cglib</artifactId>
+        <version>3.2.1</version>
+      </dependency>
+
+      <!--
+          1/3 Required dependency for log4j 2 with slf4j: binding between log4j 2 and slf4j
+      -->
+      <dependency>
+          <groupId>org.apache.logging.log4j</groupId>
+          <artifactId>log4j-slf4j-impl</artifactId>
+          <version>2.3</version>
+      </dependency>
+      <!--
+          2/3 Required dependency for log4j 2 with slf4j: log4j 2 maven plugin (it is the log4j 2 implementation)
+      -->
+      <dependency>
+          <groupId>org.apache.logging.log4j</groupId>
+          <artifactId>log4j-core</artifactId>
+          <version>2.3</version>
+      </dependency>
+      <!-- 
+          3/3 Required dependency for getting rid of commons logging.
+          This is the BRIDGE (no binding) between Jakarta Commons Logging (used by Spring) and whatever
+          I am using for logging (in this case I am using log4j 2)
+          See: http://www.slf4j.org/legacy.html
+          
+          We need exclusions in every dependency using Jakarta Commons Logging (see Spring dependencies below)
+       -->
+      <dependency>
+          <groupId>org.slf4j</groupId>
+          <artifactId>jcl-over-slf4j</artifactId>
+          <version>1.7.12</version>
+      </dependency>
+
+	</dependencies>
+    <build>
+      <plugins>
+          <plugin>
+              <groupId>org.apache.maven.plugins</groupId>
+              <artifactId>maven-compiler-plugin</artifactId>
+              <version>3.3</version>
+              <configuration>
+                  <source>1.8</source>
+                  <target>1.8</target>
+                  <encoding>${project.build.sourceEncoding}</encoding>
+              </configuration>
+          </plugin>
+          <plugin>
+              <groupId>org.apache.maven.plugins</groupId>
+              <artifactId>maven-resources-plugin</artifactId>
+              <version>2.7</version>
+              <configuration>
+                  <encoding>${project.build.sourceEncoding}</encoding>
+              </configuration>
+          </plugin>
+      </plugins>
+    </build>
+</project>
diff --git a/SpringJava/AOP/SpringAOP20/src/main/java/de/spring/example/GeneralAccess.java b/SpringJava/AOP/SpringAOP20/src/main/java/de/spring/example/GeneralAccess.java
new file mode 100644
index 0000000..ce30630
--- /dev/null
+++ b/SpringJava/AOP/SpringAOP20/src/main/java/de/spring/example/GeneralAccess.java
@@ -0,0 +1,21 @@
+package de.spring.example;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * 
+ * This class is not using the AspectJ annotations, so we could use it on JDK 1.4 and below.
+ * If we want to use it as an Aspect we may JUST do it using a schema based declaration.
+ * What means, you can use this class as an Aspect JUST using an xml Spring declaration. 
+ *
+ */
+public class GeneralAccess {
+	private static final Logger LOGGER = LoggerFactory.getLogger(GeneralAccess.class);
+
+		
+	public void monitor()
+	{
+		LOGGER.info("I am the Advice monitor for TestB and I will be run before.");
+	}
+}
diff --git a/SpringJava/AOP/SpringAOP20/src/main/java/de/spring/example/SpringAdvice.java b/SpringJava/AOP/SpringAOP20/src/main/java/de/spring/example/SpringAdvice.java
new file mode 100644
index 0000000..1555575
--- /dev/null
+++ b/SpringJava/AOP/SpringAOP20/src/main/java/de/spring/example/SpringAdvice.java
@@ -0,0 +1,23 @@
+package de.spring.example;
+
+import java.lang.reflect.Method;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.aop.MethodBeforeAdvice;
+
+/**
+ * 
+ * We are using here an Advice of Spring 1.2
+ * See: http://static.springsource.org/spring/docs/3.1.0.RC1/spring-framework-reference/html/aop-api.html#aop-api-advice-types
+ *
+ */
+public class SpringAdvice implements MethodBeforeAdvice {
+	private static final Logger LOGGER = LoggerFactory.getLogger(SpringAdvice.class);
+
+
+	public void before(Method m, Object[] args, Object target) throws Throwable {
+		LOGGER.info("I am the SpringAdvice and I will be run before.");
+	}
+	
+}
diff --git a/SpringJava/AOP/SpringAOP20/src/main/java/de/spring/example/SpringContextLocator.java b/SpringJava/AOP/SpringAOP20/src/main/java/de/spring/example/SpringContextLocator.java
new file mode 100644
index 0000000..d599c8f
--- /dev/null
+++ b/SpringJava/AOP/SpringAOP20/src/main/java/de/spring/example/SpringContextLocator.java
@@ -0,0 +1,53 @@
+package de.spring.example;
+
+import org.springframework.context.ApplicationContext;
+import org.springframework.context.support.ClassPathXmlApplicationContext;
+
+
+/**
+ *
+ */
+public final class SpringContextLocator {
+
+        // Singleton Pattern
+        private static SpringContextLocator instance;
+
+        // Spring ApplicationContext
+        private static ApplicationContext context;
+
+        // Spring Context
+        private static final String SPRING_CONFIG_CONTEXT="spring-config.xml";
+
+
+        /**
+         * Private constructor. Singleton pattern.
+         */
+        private SpringContextLocator() {
+                String[] factoryFiles = null;
+                System.out.println("Loading context files: " + SpringContextLocator.SPRING_CONFIG_CONTEXT);
+
+                factoryFiles = new String[] { SPRING_CONFIG_CONTEXT };
+
+                SpringContextLocator.context = new ClassPathXmlApplicationContext(factoryFiles);
+
+                System.out.println("The context has been loaded successfully!! ");
+        }
+
+        /**
+         * Singleton pattern not thread safety. To use SingletoHolder pattern as the best approximation 
+         * otherwise to use an Enum class (see Effective Java Second Edition and ) if we need serialization.
+         */
+        public static SpringContextLocator getInstance() {
+                if (SpringContextLocator.instance == null) {
+                        SpringContextLocator.instance = new SpringContextLocator();
+                }
+                return SpringContextLocator.instance;
+        }
+
+        /**
+         * Return bean from application context.
+         */
+        public Object getBean(final String name) {
+                return SpringContextLocator.context.getBean(name);
+        }
+}
\ No newline at end of file
diff --git a/SpringJava/AOP/SpringAOP20/src/main/java/de/spring/example/SpringStart.java b/SpringJava/AOP/SpringAOP20/src/main/java/de/spring/example/SpringStart.java
new file mode 100644
index 0000000..c6ed090
--- /dev/null
+++ b/SpringJava/AOP/SpringAOP20/src/main/java/de/spring/example/SpringStart.java
@@ -0,0 +1,25 @@
+package de.spring.example;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import de.spring.example.service.TestB;
+import de.spring.example.web.TestA;
+
+public class SpringStart {
+	private static final Logger LOGGER = LoggerFactory.getLogger(SpringStart.class);
+
+	/**
+	 * @param args
+	 */
+	public static void main(String[] args) {
+		LOGGER.info("Starting application");
+		SpringContextLocator.getInstance();
+		
+		TestA testA = (TestA) SpringContextLocator.getInstance().getBean("testA");
+		testA.myMethod();
+		
+		TestB testB = (TestB) SpringContextLocator.getInstance().getBean("testB");
+		testB.myMethod();
+	}
+}
diff --git a/SpringJava/AOP/SpringAOP20/src/main/java/de/spring/example/SystemArchitecture.java b/SpringJava/AOP/SpringAOP20/src/main/java/de/spring/example/SystemArchitecture.java
new file mode 100644
index 0000000..822f240
--- /dev/null
+++ b/SpringJava/AOP/SpringAOP20/src/main/java/de/spring/example/SystemArchitecture.java
@@ -0,0 +1,43 @@
+package de.spring.example;
+
+import org.aspectj.lang.annotation.Pointcut;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * 
+ * Using the @Aspect annotation you could use this class as an Aspect without
+ * using a schema based declaration (without using <aop:aspect in the Spring xml file)
+ * What means, you could use this class as an Aspect without the xml Spring declaration.
+ *
+ */
+public class SystemArchitecture {
+	private static final Logger LOGGER = LoggerFactory.getLogger(SystemArchitecture.class);
+
+	
+	//Coonecting to the execution of any method defined in the 
+	//package: de.spring.example.web
+	//We are connecting the methods defined in that package with this
+	//Pointcut. So, when executing any of those methods defined in that
+	//package we will run the Advice related to this Pointcut (if there is an Advice)
+	//NOTICE:
+	//			WE ARE NOT USING THE @Aspect ANNOTATION, SO WE CAN USE THIS CLASS AS
+	//          AN ASPECT AND THIS METHOD AS A POINTCUT JUST USING A SCHEMA BASED DECLARATION
+	@Pointcut("execution(* de.spring.example.web.*.*(..))")
+	public void pointCutMethod() 
+	{
+		LOGGER.info("I am the Pointcut and you will never see me.");
+		//This is the PointCut. 
+		//You can write code here, but it will be useless because while running
+		//the methods connected to the Pointcut, this code will not be executed.
+		//Just the advice will run!!!! :/
+		//Is not this weird? We are here defining a method whose code 
+		//will never be run. When the hell should we write code here?
+		//This is a waste of time and code IMHO. Isn't it?
+	}
+	
+	public void monitor()
+	{
+		LOGGER.info("I am the Advice monitor for TestA and I will be run before.");
+	}
+}
\ No newline at end of file
diff --git a/SpringJava/AOP/SpringAOP20/src/main/java/de/spring/example/service/TestB.java b/SpringJava/AOP/SpringAOP20/src/main/java/de/spring/example/service/TestB.java
new file mode 100644
index 0000000..22f186d
--- /dev/null
+++ b/SpringJava/AOP/SpringAOP20/src/main/java/de/spring/example/service/TestB.java
@@ -0,0 +1,16 @@
+package de.spring.example.service;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class TestB {
+	private static final Logger LOGGER = LoggerFactory.getLogger(TestB.class);
+
+	public int myMethod()
+	{
+		LOGGER.info("TestB: The Advice should be run before.");
+		
+		//This value will be caught by the Advice with the @AfterReturning annotation.
+		return 999;
+	}
+}
diff --git a/SpringJava/AOP/SpringAOP20/src/main/java/de/spring/example/web/TestA.java b/SpringJava/AOP/SpringAOP20/src/main/java/de/spring/example/web/TestA.java
new file mode 100644
index 0000000..0b40603
--- /dev/null
+++ b/SpringJava/AOP/SpringAOP20/src/main/java/de/spring/example/web/TestA.java
@@ -0,0 +1,16 @@
+package de.spring.example.web;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class TestA {
+	private static final Logger LOGGER = LoggerFactory.getLogger(TestA.class);
+
+	public int myMethod()
+	{
+		LOGGER.info("TestA: The Advice should be run before.");
+		
+		//This value will be caught by the Advice with the @AfterReturning annotation.
+		return 666;
+	}
+}
diff --git a/SpringJava/AOP/SpringAOP20/src/main/resources/log4j2.xml b/SpringJava/AOP/SpringAOP20/src/main/resources/log4j2.xml
new file mode 100644
index 0000000..8b3fc3f
--- /dev/null
+++ b/SpringJava/AOP/SpringAOP20/src/main/resources/log4j2.xml
@@ -0,0 +1,43 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<!-- 
+	status: The level of internal Log4j events that should be logged to the console.
+	Valid values for this attribute are "trace", "debug", "info", "warn", "error" and "fatal".
+	
+	monitorInterval: The minimum amount of time, in seconds, that must elapse before the file configuration is checked for changes.
+	
+	
+	see https://logging.apache.org/log4j/2.x/manual/configuration.html
+ -->
+<Configuration status="error" strict="true" monitorInterval="30"
+                name="XMLConfigTest" packages="org.apache.logging.log4j.test">
+                
+	<!--
+		ALL > TRACE > DEBUG > INFO > WARN > ERROR > OFF
+		
+		ERROR by default.
+	-->
+                
+    <Appenders>
+        <Appender type="Console" name="STDOUT">
+            <PatternLayout pattern="%d{HH:mm:ss.SSS} %-5level %class{36} %L %M - %msg%xEx%n"/>
+        </Appender>
+    </Appenders>
+    <Loggers>
+    
+       	<!-- 
+    		General logging Spring.
+    	 -->
+        <Logger name="org.springframework" level="INFO" additivity="false">
+            <AppenderRef ref="STDOUT" />
+        </Logger>
+    
+
+		<!-- 
+			Anything else will be using TRACE logging level.
+		 -->        
+        <Root level="DEBUG">
+            <AppenderRef ref="STDOUT"/>
+        </Root>
+    </Loggers>
+</Configuration>
diff --git a/SpringJava/AOP/SpringAOP20/src/main/resources/spring-config.xml b/SpringJava/AOP/SpringAOP20/src/main/resources/spring-config.xml
new file mode 100644
index 0000000..bda1080
--- /dev/null
+++ b/SpringJava/AOP/SpringAOP20/src/main/resources/spring-config.xml
@@ -0,0 +1,80 @@
+<?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" 
+       xmlns:aop="http://www.springframework.org/schema/aop"
+       xsi:schemaLocation="http://www.springframework.org/schema/beans 
+  						   http://www.springframework.org/schema/beans/spring-beans.xsd
+  						   http://www.springframework.org/schema/aop 
+ 		 				   http://www.springframework.org/schema/aop/spring-aop.xsd
+  						   http://www.springframework.org/schema/context 
+  						   http://www.springframework.org/schema/context/spring-context.xsd
+  						   http://www.springframework.org/schema/tx 
+  						   http://www.springframework.org/schema/tx/spring-tx.xsd">
+  
+  	 <!-- 
+  		To force CGLIB proxying when using Spring AOP
+  		See: http://static.springsource.org/spring/docs/3.1.0.RC1/spring-framework-reference/html/aop.html#aop-proxying
+  	 -->
+     <aop:config proxy-target-class="true">
+     	<aop:aspect id="myAspectSchemaBased" ref="generalAccess">
+     		<aop:pointcut id="aspectOperation" 
+        				  expression="execution(* de.spring.example.service.*.*(..))"/>
+        	<aop:before pointcut-ref="aspectOperation" method="monitor"/>
+ 		</aop:aspect>
+     </aop:config>
+     
+	
+	<aop:config proxy-target-class="true">
+     	<aop:aspect id="myAspectwithAnnotations" ref="systemArchitecture">
+     		<!-- 
+     			See: http://static.springsource.org/spring/docs/3.1.0.RC1/spring-framework-reference/html/aop.html#aop-schema-pointcuts
+     			"Note that the pointcut expression itself is using the same AspectJ pointcut expression 
+     			language as described in Section 8.2, “@AspectJ support”. If you are using the schema 
+     			based declaration style with Java 5, you can refer to named pointcuts defined in types 
+     			(@Aspects) within the pointcut expression, but this feature is not available on JDK 1.4 and below 
+     			(it relies on the Java 5 specific AspectJ reflection APIs). On JDK 1.5 therefore, another way of 
+     			defining the above pointcut would be:
+     		 -->
+     		<aop:pointcut id="pointCutAspect" 
+        				  expression="de.spring.example.SystemArchitecture.pointCutMethod()"/>
+            <!-- This will be the Advice. You can use the same class for it or you can use the aop:advisor
+            	 xml Spring annotation. In that case you have to use an Advice class from AOP support of Spring 1.2
+            	 (below you can see an example of this)
+             -->
+        	<aop:before pointcut-ref="pointCutAspect" method="monitor"/>
+ 		</aop:aspect>
+    </aop:config>
+     
+     
+    <!-- 
+		We are using AOP support from Spring 1.2 :/ for this Advice
+		(we use Spring beans as advices and we can use the AOP support from Spring 1.2 for this)
+		We can use and mix whatever we want. Spring is powerful but at the same time it can be a complete mess.
+	 -->
+	<aop:config proxy-target-class="true">
+     	<aop:advisor pointcut="de.spring.example.SystemArchitecture.pointCutMethod()"
+     				 advice-ref="springAdvice" />
+    </aop:config>
+	
+	<bean id="testA" class="de.spring.example.web.TestA">
+    	
+    </bean>
+    
+    <bean id="testB" class="de.spring.example.service.TestB">
+    	
+    </bean>
+    
+    <bean id="generalAccess" class="de.spring.example.GeneralAccess">
+    	
+    </bean>
+    
+    <bean id="systemArchitecture" class="de.spring.example.SystemArchitecture">
+    	
+    </bean>
+    
+    <bean id="springAdvice" class="de.spring.example.SpringAdvice">
+    	
+    </bean>
+    
+</beans>
diff --git a/SpringJava/AOP/SpringAspectJ/pom.xml b/SpringJava/AOP/SpringAspectJ/pom.xml
new file mode 100644
index 0000000..be48cff
--- /dev/null
+++ b/SpringJava/AOP/SpringAspectJ/pom.xml
@@ -0,0 +1,124 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<project
+	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"
+	xmlns="http://maven.apache.org/POM/4.0.0" 
+	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+	
+	<modelVersion>4.0.0</modelVersion>
+    <groupId>de.spring.example</groupId>
+	<artifactId>spring-aspectj</artifactId>
+    <version>2.0-SNAPSHOT</version>
+	<name>spring-aspectj</name>
+	<url>http://gumartinm.name</url>
+    <properties>
+      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+    </properties>
+
+	<dependencies> 
+       <dependency>
+           <groupId>org.springframework</groupId>
+           <artifactId>spring-context</artifactId>
+           <version>4.2.5.RELEASE</version>
+           <!-- 
+               Required dependency for getting rid of commons logging and use my own logging library
+               (in my case I decided to use log4j 2 under slf4j)
+           -->
+           <exclusions>
+               <exclusion>
+                   <groupId>commons-logging</groupId>
+                   <artifactId>commons-logging</artifactId>
+               </exclusion>
+           </exclusions>
+       </dependency>
+      <dependency>
+          <groupId>org.springframework</groupId>
+          <artifactId>spring-aspects</artifactId>
+          <version>4.2.5.RELEASE</version>
+          <!-- 
+              Required dependency for getting rid of commons logging and use my own logging library
+              (in my case I decided to use log4j 2 under slf4j)
+          -->
+          <exclusions>
+              <exclusion>
+                  <groupId>commons-logging</groupId>
+                  <artifactId>commons-logging</artifactId>
+              </exclusion>
+          </exclusions>
+      </dependency>
+      <dependency>
+          <groupId>org.springframework</groupId>
+          <artifactId>spring-aop</artifactId>
+          <version>4.2.5.RELEASE</version>
+          <!-- 
+              Required dependency for getting rid of commons logging and use my own logging library
+              (in my case I decided to use log4j 2 under slf4j)
+          -->
+          <exclusions>
+              <exclusion>
+                  <groupId>commons-logging</groupId>
+                  <artifactId>commons-logging</artifactId>
+              </exclusion>
+          </exclusions>
+      </dependency>
+
+      <dependency>
+        <groupId>cglib</groupId>
+        <artifactId>cglib</artifactId>
+        <version>3.2.1</version>
+      </dependency>
+
+      <!--
+          1/3 Required dependency for log4j 2 with slf4j: binding between log4j 2 and slf4j
+      -->
+      <dependency>
+          <groupId>org.apache.logging.log4j</groupId>
+          <artifactId>log4j-slf4j-impl</artifactId>
+          <version>2.3</version>
+      </dependency>
+      <!--
+          2/3 Required dependency for log4j 2 with slf4j: log4j 2 maven plugin (it is the log4j 2 implementation)
+      -->
+      <dependency>
+          <groupId>org.apache.logging.log4j</groupId>
+          <artifactId>log4j-core</artifactId>
+          <version>2.3</version>
+      </dependency>
+      <!-- 
+          3/3 Required dependency for getting rid of commons logging.
+          This is the BRIDGE (no binding) between Jakarta Commons Logging (used by Spring) and whatever
+          I am using for logging (in this case I am using log4j 2)
+          See: http://www.slf4j.org/legacy.html
+          
+          We need exclusions in every dependency using Jakarta Commons Logging (see Spring dependencies below)
+       -->
+      <dependency>
+          <groupId>org.slf4j</groupId>
+          <artifactId>jcl-over-slf4j</artifactId>
+          <version>1.7.12</version>
+      </dependency>
+
+	</dependencies>
+    <build>
+      <plugins>
+          <plugin>
+              <groupId>org.apache.maven.plugins</groupId>
+              <artifactId>maven-compiler-plugin</artifactId>
+              <version>3.3</version>
+              <configuration>
+                  <source>1.8</source>
+                  <target>1.8</target>
+                  <encoding>${project.build.sourceEncoding}</encoding>
+              </configuration>
+          </plugin>
+          <plugin>
+              <groupId>org.apache.maven.plugins</groupId>
+              <artifactId>maven-resources-plugin</artifactId>
+              <version>2.7</version>
+              <configuration>
+                  <encoding>${project.build.sourceEncoding}</encoding>
+              </configuration>
+          </plugin>
+      </plugins>
+    </build>
+</project>
diff --git a/SpringJava/AOP/SpringAspectJ/src/main/java/de/spring/example/MyAdvice.java b/SpringJava/AOP/SpringAspectJ/src/main/java/de/spring/example/MyAdvice.java
new file mode 100644
index 0000000..5121bba
--- /dev/null
+++ b/SpringJava/AOP/SpringAspectJ/src/main/java/de/spring/example/MyAdvice.java
@@ -0,0 +1,44 @@
+package de.spring.example;
+
+import org.aspectj.lang.ProceedingJoinPoint;
+import org.aspectj.lang.annotation.Around;
+import org.aspectj.lang.annotation.Aspect;
+import org.aspectj.lang.annotation.Before;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+@Aspect
+public class MyAdvice {
+	private static final Logger LOGGER = LoggerFactory.getLogger(MyAdvice.class);
+
+	
+	//This advice is connected with the Pointcut defined in SystemArchitecture.
+	//So, every method connected to that Pointcut will be run after the
+	//method defined in this Advice.
+	@Before("de.spring.example.SystemArchitecture.pointCutMethod())")
+	public void doAccessCheck() {
+		LOGGER.info("I am the Advice and I will be run before.");
+	}
+	
+	
+	//NOTICE: YOU DO NOT NEED TO CREATE A SPECIAL CLASS FOR POINTCUTS
+	//        YOU COULD DEFINE AN ADVICE WITHOUT A POINTCUT
+	//This advice has a PointCut defined like execution(* de.spring.example.web.Test.anotherExample())
+	//right here without a special PointCut method. This advice has itself the PointCut
+	@Around("execution(* de.spring.example.web.Test.anotherExample())")
+	public Object doAround(ProceedingJoinPoint pjp) {
+		LOGGER.info("I am the Advice and I will be run before and after. BEFORE");
+		// start stopwatch
+		// This local variable will store the returned value from the method anotherExample()
+	    Object retVal=null;
+		try {
+			//Calling the real method
+			retVal = pjp.proceed();
+		} catch (Throwable e) {
+			LOGGER.info("Error", e);
+		}
+	    // stop stopwatch
+		LOGGER.info("I am the Advice and I will be run before and after. AFTER " + retVal);
+	    return retVal;
+	}
+}
diff --git a/SpringJava/AOP/SpringAspectJ/src/main/java/de/spring/example/SpringAdvice.java b/SpringJava/AOP/SpringAspectJ/src/main/java/de/spring/example/SpringAdvice.java
new file mode 100644
index 0000000..e5bdf66
--- /dev/null
+++ b/SpringJava/AOP/SpringAspectJ/src/main/java/de/spring/example/SpringAdvice.java
@@ -0,0 +1,22 @@
+package de.spring.example;
+
+import java.lang.reflect.Method;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.aop.MethodBeforeAdvice;
+
+/**
+ * 
+ * We are using here an Advice of Spring 1.2
+ * See: http://static.springsource.org/spring/docs/3.1.0.RC1/spring-framework-reference/html/aop-api.html#aop-api-advice-types
+ *
+ */
+public class SpringAdvice implements MethodBeforeAdvice {
+	private static final Logger LOGGER = LoggerFactory.getLogger(SpringAdvice.class);
+
+	public void before(Method m, Object[] args, Object target) throws Throwable {
+		LOGGER.info("I am the SpringAdvice and I will be run before.");
+	}
+	
+}
diff --git a/SpringJava/AOP/SpringAspectJ/src/main/java/de/spring/example/SpringContextLocator.java b/SpringJava/AOP/SpringAspectJ/src/main/java/de/spring/example/SpringContextLocator.java
new file mode 100644
index 0000000..ff58276
--- /dev/null
+++ b/SpringJava/AOP/SpringAspectJ/src/main/java/de/spring/example/SpringContextLocator.java
@@ -0,0 +1,57 @@
+package de.spring.example;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.context.ApplicationContext;
+import org.springframework.context.support.ClassPathXmlApplicationContext;
+
+
+/**
+ *
+ */
+public final class SpringContextLocator {
+	private static final Logger LOGGER = LoggerFactory.getLogger(SpringAdvice.class);
+
+
+        // Singleton Pattern
+        private static SpringContextLocator instance;
+
+        // Spring ApplicationContext
+        private static ApplicationContext context;
+
+        // Spring Context
+        private static final String SPRING_CONFIG_CONTEXT="spring-config.xml";
+
+
+        /**
+         * Private constructor. Singleton pattern.
+         */
+        private SpringContextLocator() {
+                String[] factoryFiles = null;
+                LOGGER.info("Loading context files: " + SpringContextLocator.SPRING_CONFIG_CONTEXT);
+
+                factoryFiles = new String[] { SPRING_CONFIG_CONTEXT };
+
+                SpringContextLocator.context = new ClassPathXmlApplicationContext(factoryFiles);
+
+                LOGGER.info("The context has been loaded successfully!! ");
+        }
+
+        /**
+         * Singleton pattern not thread safety. To use SingletoHolder pattern as the best approximation 
+         * otherwise to use an Enum class (see Effective Java Second Edition and ) if we need serialization.
+         */
+        public static SpringContextLocator getInstance() {
+                if (SpringContextLocator.instance == null) {
+                        SpringContextLocator.instance = new SpringContextLocator();
+                }
+                return SpringContextLocator.instance;
+        }
+
+        /**
+         * Return bean from application context.
+         */
+        public Object getBean(final String name) {
+                return SpringContextLocator.context.getBean(name);
+        }
+}
\ No newline at end of file
diff --git a/SpringJava/AOP/SpringAspectJ/src/main/java/de/spring/example/SpringStart.java b/SpringJava/AOP/SpringAspectJ/src/main/java/de/spring/example/SpringStart.java
new file mode 100644
index 0000000..f553341
--- /dev/null
+++ b/SpringJava/AOP/SpringAspectJ/src/main/java/de/spring/example/SpringStart.java
@@ -0,0 +1,22 @@
+package de.spring.example;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import de.spring.example.web.Test;
+
+public class SpringStart {
+	private static final Logger LOGGER = LoggerFactory.getLogger(SpringStart.class);
+
+	/**
+	 * @param args
+	 */
+	public static void main(String[] args) {
+		LOGGER.info("Starting application");
+		SpringContextLocator.getInstance();
+		
+		Test test = (Test) SpringContextLocator.getInstance().getBean("test");
+		test.myMethod();
+		test.anotherExample();
+	}
+}
diff --git a/SpringJava/AOP/SpringAspectJ/src/main/java/de/spring/example/SystemArchitecture.java b/SpringJava/AOP/SpringAspectJ/src/main/java/de/spring/example/SystemArchitecture.java
new file mode 100644
index 0000000..ef83b3d
--- /dev/null
+++ b/SpringJava/AOP/SpringAspectJ/src/main/java/de/spring/example/SystemArchitecture.java
@@ -0,0 +1,53 @@
+package de.spring.example;
+
+import org.aspectj.lang.annotation.AfterReturning;
+import org.aspectj.lang.annotation.Aspect;
+import org.aspectj.lang.annotation.Pointcut;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * 
+ * We are using here the @AspectJ annotations to declare 
+ * Proxies. If we want to use these kinds of proxies on the Spring framework
+ * we have to use the <aop:aspectj-autoproxy/> annotation on the Spring xml file
+ * (the Spring context file)
+ */
+@Aspect
+public class SystemArchitecture {
+	private static final Logger LOGGER = LoggerFactory.getLogger(SpringStart.class);
+
+	
+	//Coonecting to the execution of any method defined in the 
+	//package: de.spring.example.web
+	//We are connecting the methods defined in that package with this
+	//Pointcut. So, when executing any of those methods defined in that
+	//package we will run the Advice related to this Pointcut (if there is an Advice)
+	@Pointcut("execution(* de.spring.example.web.*.*(..))")
+	public void pointCutMethod() 
+	{
+		LOGGER.info("I am the Pointcut and you will never see me.");
+		//This is the PointCut. 
+		//You can write code here, but it will be useless because while running
+		//the methods connected to the Pointcut, this code will not be executed.
+		//Just the advice will run!!!! :/
+		//Is not this weird? We are here defining a method whose code 
+		//will never be run. When the hell should we write code here?
+		//This is a waste of time and code IMHO. Isn't it?
+	}
+	
+	//NOTICE: YOU DO NOT NEED TO CREATE A SPECIAL CLASS FOR THE ADVICE
+	//        YOU COULD USE THE SAME CLASS FOR THE POINTCUTS AND FOR THE
+	//		  ADVICES. IN THIS CASE FOR EXAMPLE WE HAVE THE @AfterReturning
+	//		  ADVICE IN THIS CLASS AND THE @Before ADVICE IN THE CLASS CALLED
+	//		  MyAdvice
+	//This advice is connected with the another Pointcut.
+	//The returning value of every method connected to that Pointcut
+	//will be caught by this method.
+	@AfterReturning(pointcut="de.spring.example.SystemArchitecture.pointCutMethod())",
+					returning="retVal")
+	public void doAccessCheck(final Object retVal) {
+		LOGGER.info("The returned value by the method " +
+											"connected to the Pointcut: " + retVal);
+	}
+}
\ No newline at end of file
diff --git a/SpringJava/AOP/SpringAspectJ/src/main/java/de/spring/example/web/Test.java b/SpringJava/AOP/SpringAspectJ/src/main/java/de/spring/example/web/Test.java
new file mode 100644
index 0000000..d01bd5d
--- /dev/null
+++ b/SpringJava/AOP/SpringAspectJ/src/main/java/de/spring/example/web/Test.java
@@ -0,0 +1,30 @@
+package de.spring.example.web;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class Test {
+	private static final Logger LOGGER = LoggerFactory.getLogger(Test.class);
+
+	public int myMethod()
+	{
+		LOGGER.info("The Advice should be run before.");
+		
+		//This value will be caught by the Advice with the @AfterReturning annotation.
+		return 666;
+	}
+	
+	public int anotherExample()
+	{
+		LOGGER.info("The Advice should be run before and after.");
+		return 666;
+		
+	}
+	
+    public class InnerTest {
+        public void innerMethod() {
+        	LOGGER.info("I am the inner class. The Advice should be run after."
+        			+ " NO NEED OF DECLARING Spring BEANS WHEN WEAVING!!!!");
+        }
+    }
+}
diff --git a/SpringJava/AOP/SpringAspectJ/src/main/resources/log4j2.xml b/SpringJava/AOP/SpringAspectJ/src/main/resources/log4j2.xml
new file mode 100644
index 0000000..8b3fc3f
--- /dev/null
+++ b/SpringJava/AOP/SpringAspectJ/src/main/resources/log4j2.xml
@@ -0,0 +1,43 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<!-- 
+	status: The level of internal Log4j events that should be logged to the console.
+	Valid values for this attribute are "trace", "debug", "info", "warn", "error" and "fatal".
+	
+	monitorInterval: The minimum amount of time, in seconds, that must elapse before the file configuration is checked for changes.
+	
+	
+	see https://logging.apache.org/log4j/2.x/manual/configuration.html
+ -->
+<Configuration status="error" strict="true" monitorInterval="30"
+                name="XMLConfigTest" packages="org.apache.logging.log4j.test">
+                
+	<!--
+		ALL > TRACE > DEBUG > INFO > WARN > ERROR > OFF
+		
+		ERROR by default.
+	-->
+                
+    <Appenders>
+        <Appender type="Console" name="STDOUT">
+            <PatternLayout pattern="%d{HH:mm:ss.SSS} %-5level %class{36} %L %M - %msg%xEx%n"/>
+        </Appender>
+    </Appenders>
+    <Loggers>
+    
+       	<!-- 
+    		General logging Spring.
+    	 -->
+        <Logger name="org.springframework" level="INFO" additivity="false">
+            <AppenderRef ref="STDOUT" />
+        </Logger>
+    
+
+		<!-- 
+			Anything else will be using TRACE logging level.
+		 -->        
+        <Root level="DEBUG">
+            <AppenderRef ref="STDOUT"/>
+        </Root>
+    </Loggers>
+</Configuration>
diff --git a/SpringJava/AOP/SpringAspectJ/src/main/resources/spring-config.xml b/SpringJava/AOP/SpringAspectJ/src/main/resources/spring-config.xml
new file mode 100644
index 0000000..6aa0317
--- /dev/null
+++ b/SpringJava/AOP/SpringAspectJ/src/main/resources/spring-config.xml
@@ -0,0 +1,59 @@
+<?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" 
+       xmlns:aop="http://www.springframework.org/schema/aop"
+       xsi:schemaLocation="http://www.springframework.org/schema/beans 
+  						   http://www.springframework.org/schema/beans/spring-beans.xsd
+  						   http://www.springframework.org/schema/aop 
+ 		 				   http://www.springframework.org/schema/aop/spring-aop.xsd
+  						   http://www.springframework.org/schema/context 
+  						   http://www.springframework.org/schema/context/spring-context.xsd
+  						   http://www.springframework.org/schema/tx 
+  						   http://www.springframework.org/schema/tx/spring-tx.xsd">
+	
+	<!-- 
+			         ************* WE HAVE TO ENABLE THE ASPECTJ SUPPORT!!!!!! ************* 
+			Otherwise the @Aspect annotation (defines @AspectJ aspects) will not work
+			It relies on the Java 5 specific AspectJ reflection APIs. You can not use it on
+			JDK 1.4 and below.
+			
+			
+			We could force here the use of CGLIB.
+			See: http://static.springsource.org/spring/docs/3.1.0.RC1/spring-framework-reference/html/aop.html#aop-proxying
+			Spring detects if the bean has an interface implementation. If it has one, Spring will use J2SE 
+			(J2SE needs classes with interfaces) in other case it will use CGLIB. 
+			In this example the "test" bean does not have an interface so Spring
+			will use CGLIB. We could force the use of CGLIB in classes with interfaces.
+	-->
+	<aop:aspectj-autoproxy/>
+	
+	<!-- 
+		We can mix aspect types. Without this AOP declaration this project would be SPRING ASPECTJ
+		but, because of this, we have a Spring Advice declaration so this project will be a SPRING AOP project
+		(or at least it is not just SPRING ASPECTJ based)
+		Besides we are using AOP support used in Spring 1.2 :/
+	 -->
+	<aop:config proxy-target-class="true">
+     	<aop:advisor pointcut="de.spring.example.SystemArchitecture.pointCutMethod()"
+     				 advice-ref="springAdvice" />
+    </aop:config>
+	
+	
+	<bean id="test" class="de.spring.example.web.Test">
+    	
+    </bean>
+	
+	<bean id="myAdvice" class="de.spring.example.MyAdvice">
+    	
+    </bean>
+    
+    <bean id="systemArchitecture" class="de.spring.example.SystemArchitecture">
+    	
+    </bean>
+    
+    <bean id="springAdvice" class="de.spring.example.SpringAdvice">
+    	
+    </bean>
+	
+</beans>
diff --git a/SpringJava/AOP/SpringLTW/README b/SpringJava/AOP/SpringLTW/README
new file mode 100644
index 0000000..9091fb8
--- /dev/null
+++ b/SpringJava/AOP/SpringLTW/README
@@ -0,0 +1,3 @@
+VM arguments:
+
+-javaagent:$HOME/.m2/repository/org/springframework/spring-instrument/4.2.5.RELEASE/spring-instrument-4.2.5.RELEASE.jar
diff --git a/SpringJava/AOP/SpringLTW/pom.xml b/SpringJava/AOP/SpringLTW/pom.xml
new file mode 100644
index 0000000..5ebc4a0
--- /dev/null
+++ b/SpringJava/AOP/SpringLTW/pom.xml
@@ -0,0 +1,190 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<project
+	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"
+	xmlns="http://maven.apache.org/POM/4.0.0" 
+	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+	
+	<modelVersion>4.0.0</modelVersion>
+    <groupId>de.spring.example</groupId>
+	<artifactId>spring-ltw</artifactId>
+    <version>2.0-SNAPSHOT</version>
+	<name>spring-ltw</name>
+	<url>http://gumartinm.name</url>
+    <properties>
+      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+    </properties>
+
+	<dependencies> 
+       <dependency>
+           <groupId>org.springframework</groupId>
+           <artifactId>spring-context</artifactId>
+           <version>4.2.5.RELEASE</version>
+           <!-- 
+               Required dependency for getting rid of commons logging and use my own logging library
+               (in my case I decided to use log4j 2 under slf4j)
+           -->
+           <exclusions>
+               <exclusion>
+                   <groupId>commons-logging</groupId>
+                   <artifactId>commons-logging</artifactId>
+               </exclusion>
+           </exclusions>
+       </dependency>
+      <dependency>
+          <groupId>org.springframework</groupId>
+          <artifactId>spring-aspects</artifactId>
+          <version>4.2.5.RELEASE</version>
+          <!-- 
+              Required dependency for getting rid of commons logging and use my own logging library
+              (in my case I decided to use log4j 2 under slf4j)
+          -->
+          <exclusions>
+              <exclusion>
+                  <groupId>commons-logging</groupId>
+                  <artifactId>commons-logging</artifactId>
+              </exclusion>
+          </exclusions>
+      </dependency>
+      <dependency>
+          <groupId>org.springframework</groupId>
+          <artifactId>spring-aop</artifactId>
+          <version>4.2.5.RELEASE</version>
+          <!-- 
+              Required dependency for getting rid of commons logging and use my own logging library
+              (in my case I decided to use log4j 2 under slf4j)
+          -->
+          <exclusions>
+              <exclusion>
+                  <groupId>commons-logging</groupId>
+                  <artifactId>commons-logging</artifactId>
+              </exclusion>
+          </exclusions>
+      </dependency>
+      <dependency>
+    		<groupId>org.springframework</groupId>
+    		<artifactId>spring-instrument</artifactId>
+    		<version>4.2.5.RELEASE</version>
+    		          <!-- 
+              Required dependency for getting rid of commons logging and use my own logging library
+              (in my case I decided to use log4j 2 under slf4j)
+          -->
+          <exclusions>
+              <exclusion>
+                  <groupId>commons-logging</groupId>
+                  <artifactId>commons-logging</artifactId>
+              </exclusion>
+          </exclusions>
+		</dependency>
+		<dependency>
+    		<groupId>javax.cache</groupId>
+    		<artifactId>cache-api</artifactId>
+    		<version>1.0.0-PFD</version>
+		</dependency>
+		<dependency>
+		    <groupId>javax.transaction</groupId>
+		    <artifactId>javax.transaction-api</artifactId>
+		    <version>1.2</version>
+		</dependency>
+		<dependency>
+    		<groupId>org.springframework</groupId>
+    		<artifactId>spring-context-support</artifactId>
+    		<version>4.2.5.RELEASE</version>
+    		          <!-- 
+              Required dependency for getting rid of commons logging and use my own logging library
+              (in my case I decided to use log4j 2 under slf4j)
+          -->
+          <exclusions>
+              <exclusion>
+                  <groupId>commons-logging</groupId>
+                  <artifactId>commons-logging</artifactId>
+              </exclusion>
+          </exclusions>
+		</dependency>
+      <dependency>
+          <groupId>org.springframework</groupId>
+          <artifactId>spring-jdbc</artifactId>
+          <version>4.2.5.RELEASE</version>
+          <!-- 
+              Required dependency for getting rid of commons logging and use my own logging library
+              (in my case I decided to use log4j 2 under slf4j)
+          -->
+          <exclusions>
+              <exclusion>
+                  <groupId>commons-logging</groupId>
+                  <artifactId>commons-logging</artifactId>
+              </exclusion>
+          </exclusions>
+      </dependency>
+
+      <dependency>
+        <groupId>cglib</groupId>
+        <artifactId>cglib</artifactId>
+        <version>3.2.1</version>
+      </dependency>
+
+		<dependency>
+			<groupId>com.mchange</groupId>
+			<artifactId>c3p0</artifactId>
+			<version>0.9.5.2</version>
+		</dependency>
+		<dependency>
+			<groupId>mysql</groupId>
+			<artifactId>mysql-connector-java</artifactId>
+			<version>5.1.38</version>
+		</dependency>
+
+      <!--
+          1/3 Required dependency for log4j 2 with slf4j: binding between log4j 2 and slf4j
+      -->
+      <dependency>
+          <groupId>org.apache.logging.log4j</groupId>
+          <artifactId>log4j-slf4j-impl</artifactId>
+          <version>2.3</version>
+      </dependency>
+      <!--
+          2/3 Required dependency for log4j 2 with slf4j: log4j 2 maven plugin (it is the log4j 2 implementation)
+      -->
+      <dependency>
+          <groupId>org.apache.logging.log4j</groupId>
+          <artifactId>log4j-core</artifactId>
+          <version>2.3</version>
+      </dependency>
+      <!-- 
+          3/3 Required dependency for getting rid of commons logging.
+          This is the BRIDGE (no binding) between Jakarta Commons Logging (used by Spring) and whatever
+          I am using for logging (in this case I am using log4j 2)
+          See: http://www.slf4j.org/legacy.html
+          
+          We need exclusions in every dependency using Jakarta Commons Logging (see Spring dependencies below)
+       -->
+      <dependency>
+          <groupId>org.slf4j</groupId>
+          <artifactId>jcl-over-slf4j</artifactId>
+          <version>1.7.12</version>
+      </dependency>
+
+	</dependencies>
+    <build>
+      <plugins>
+          <plugin>
+              <groupId>org.apache.maven.plugins</groupId>
+              <artifactId>maven-compiler-plugin</artifactId>
+              <version>3.3</version>
+              <configuration>
+                  <source>1.8</source>
+                  <target>1.8</target>
+                  <encoding>${project.build.sourceEncoding}</encoding>
+              </configuration>
+          </plugin>
+          <plugin>
+              <groupId>org.apache.maven.plugins</groupId>
+              <artifactId>maven-resources-plugin</artifactId>
+              <version>2.7</version>
+              <configuration>
+                  <encoding>${project.build.sourceEncoding}</encoding>
+              </configuration>
+          </plugin>
+      </plugins>
+    </build>
+</project>
diff --git a/SpringJava/AOP/SpringLTW/src/main/java/de/spring/example/MyAdvice.java b/SpringJava/AOP/SpringLTW/src/main/java/de/spring/example/MyAdvice.java
new file mode 100644
index 0000000..6e25974
--- /dev/null
+++ b/SpringJava/AOP/SpringLTW/src/main/java/de/spring/example/MyAdvice.java
@@ -0,0 +1,28 @@
+package de.spring.example;
+
+import org.aspectj.lang.annotation.After;
+import org.aspectj.lang.annotation.Aspect;
+import org.aspectj.lang.annotation.Before;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+@Aspect
+public class MyAdvice {
+	private static final Logger LOGGER = LoggerFactory.getLogger(MyAdvice.class);
+
+	// With execution we avoid double weaving (when call and when execution)
+    @Before("@annotation(de.spring.example.annotation.initTransactional) && execution(* *(..))")
+    public void initTransactional()
+    {
+    	LOGGER.info("I am the Advice initTransaction.");
+        TransactionManager.getInstance().initTransaction();
+    }
+
+
+	// With execution we avoid double weaving (when call and when execution)
+    @After("@annotation(de.spring.example.annotation.commitTransactional) && execution(* *(..))")
+    public void commitTransactional() {
+    	LOGGER.info("I am the Advice commitTransaction.");
+        TransactionManager.getInstance().commitTransaction();
+    }
+}
diff --git a/SpringJava/AOP/SpringLTW/src/main/java/de/spring/example/SpringContextLocator.java b/SpringJava/AOP/SpringLTW/src/main/java/de/spring/example/SpringContextLocator.java
new file mode 100644
index 0000000..8a82a3a
--- /dev/null
+++ b/SpringJava/AOP/SpringLTW/src/main/java/de/spring/example/SpringContextLocator.java
@@ -0,0 +1,57 @@
+package de.spring.example;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.context.ApplicationContext;
+import org.springframework.context.support.ClassPathXmlApplicationContext;
+
+
+/**
+ *
+ */
+public final class SpringContextLocator {
+	private static final Logger LOGGER = LoggerFactory.getLogger(SpringContextLocator.class);
+
+
+        // Singleton Pattern
+        private static SpringContextLocator instance;
+
+        // Spring ApplicationContext
+        private static ApplicationContext context;
+
+        // Spring Context
+        private static final String SPRING_CONFIG_CONTEXT="/spring-config.xml";
+
+
+        /**
+         * Private constructor. Singleton pattern.
+         */
+        private SpringContextLocator() {
+                String[] factoryFiles = null;
+                LOGGER.info("Loading context files: " + SpringContextLocator.SPRING_CONFIG_CONTEXT);
+
+                factoryFiles = new String[] { SPRING_CONFIG_CONTEXT };
+
+                SpringContextLocator.context = new ClassPathXmlApplicationContext(factoryFiles);
+
+                LOGGER.info("The context has been loaded successfully!! ");
+        }
+
+        /**
+         * Singleton pattern not thread safety. To use SingletoHolder pattern as the best approximation 
+         * otherwise to use an Enum class (see Effective Java Second Edition and ) if we need serialization.
+         */
+        public static SpringContextLocator getInstance() {
+                if (SpringContextLocator.instance == null) {
+                        SpringContextLocator.instance = new SpringContextLocator();
+                }
+                return SpringContextLocator.instance;
+        }
+
+        /**
+         * Return bean from application context.
+         */
+        public Object getBean(final String name) {
+                return SpringContextLocator.context.getBean(name);
+        }
+}
\ No newline at end of file
diff --git a/SpringJava/AOP/SpringLTW/src/main/java/de/spring/example/SpringStart.java b/SpringJava/AOP/SpringLTW/src/main/java/de/spring/example/SpringStart.java
new file mode 100644
index 0000000..2aba4c2
--- /dev/null
+++ b/SpringJava/AOP/SpringLTW/src/main/java/de/spring/example/SpringStart.java
@@ -0,0 +1,22 @@
+package de.spring.example;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import de.spring.example.web.Test;
+
+public class SpringStart {
+	private static final Logger LOGGER = LoggerFactory.getLogger(SpringStart.class);
+
+	
+	/**
+	 * @param args
+	 */
+	public static void main(String[] args) {
+		LOGGER.info("Starting application");
+		SpringContextLocator.getInstance();
+		
+		Test test = (Test) SpringContextLocator.getInstance().getBean("testOuter");
+		test.myMethod();
+	}
+}
diff --git a/SpringJava/AOP/SpringLTW/src/main/java/de/spring/example/TransactionManager.java b/SpringJava/AOP/SpringLTW/src/main/java/de/spring/example/TransactionManager.java
new file mode 100644
index 0000000..53f3c59
--- /dev/null
+++ b/SpringJava/AOP/SpringLTW/src/main/java/de/spring/example/TransactionManager.java
@@ -0,0 +1,48 @@
+package de.spring.example;
+
+import org.aspectj.lang.annotation.Aspect;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.jdbc.datasource.DataSourceTransactionManager;
+import org.springframework.transaction.TransactionStatus;
+
+@Aspect
+public class TransactionManager {
+	private static final Logger LOGGER = LoggerFactory.getLogger(TransactionManager.class);
+    private static TransactionManager instance = new TransactionManager();
+    private DataSourceTransactionManager transactionManager;
+    private TransactionStatus transactionStatus;
+
+    //Why could you want to extend this class?
+    private TransactionManager() {
+    }
+
+    public static TransactionManager getInstance() {
+        return instance;
+    }
+
+    public void initTransaction()
+    {
+    	LOGGER.info("initTRANSACTION");
+        // transactionStatus = this.transactionManager.getTransaction(null);
+    }
+
+    public void rollbackTransaction()
+    {
+        this.transactionManager.rollback(this.transactionStatus);
+    }
+
+
+    public void commitTransaction()
+    {
+    	LOGGER.info("commitTRANSACTION");
+        // this.transactionManager.commit(this.transactionStatus);
+    }
+
+
+    /************************* Setters and getters *******************************************/
+    public void setTransactionManager(final DataSourceTransactionManager  transactionManager)
+    {
+        this.transactionManager = transactionManager;
+    }
+}
diff --git a/SpringJava/AOP/SpringLTW/src/main/java/de/spring/example/annotation/commitTransactional.java b/SpringJava/AOP/SpringLTW/src/main/java/de/spring/example/annotation/commitTransactional.java
new file mode 100644
index 0000000..1fda03f
--- /dev/null
+++ b/SpringJava/AOP/SpringLTW/src/main/java/de/spring/example/annotation/commitTransactional.java
@@ -0,0 +1,14 @@
+package de.spring.example.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import org.springframework.stereotype.Component;
+
+@Target({ElementType.METHOD, ElementType.TYPE})
+@Retention(RetentionPolicy.RUNTIME)
+@Component
+public @interface commitTransactional {
+}
diff --git a/SpringJava/AOP/SpringLTW/src/main/java/de/spring/example/annotation/initTransactional.java b/SpringJava/AOP/SpringLTW/src/main/java/de/spring/example/annotation/initTransactional.java
new file mode 100644
index 0000000..dad0b3e
--- /dev/null
+++ b/SpringJava/AOP/SpringLTW/src/main/java/de/spring/example/annotation/initTransactional.java
@@ -0,0 +1,14 @@
+package de.spring.example.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import org.springframework.stereotype.Component;
+
+@Target({ElementType.METHOD, ElementType.TYPE})
+@Retention(RetentionPolicy.RUNTIME)
+@Component
+public @interface initTransactional {
+}
diff --git a/SpringJava/AOP/SpringLTW/src/main/java/de/spring/example/web/Test.java b/SpringJava/AOP/SpringLTW/src/main/java/de/spring/example/web/Test.java
new file mode 100644
index 0000000..5cd7d2a
--- /dev/null
+++ b/SpringJava/AOP/SpringLTW/src/main/java/de/spring/example/web/Test.java
@@ -0,0 +1,40 @@
+package de.spring.example.web;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import de.spring.example.annotation.commitTransactional;
+import de.spring.example.annotation.initTransactional;
+
+
+public class Test {
+	private static final Logger LOGGER = LoggerFactory.getLogger(Test.class);
+
+    @initTransactional
+    public int myMethod()
+    {
+    	LOGGER.info("The Advice should be run before.");
+
+    	annotatedPrivateMethod();
+    	
+    	InnerTest innerTest = new InnerTest();
+    	innerTest.innerMethod();
+    	
+        return 666;
+    }
+
+    public class InnerTest {
+        @commitTransactional
+        public void innerMethod() {
+        	LOGGER.info("I am the inner class. The Advice should be run after."
+        			+ " NO NEED OF DECLARING Spring BEANS WHEN WEAVING!!!!");
+        }
+    }
+    
+    // IT WORKS WHEN WEAVING!!!
+    @initTransactional
+    private void annotatedPrivateMethod() {
+    	LOGGER.info("The Advice should be run before even with private methods because I AM WEAVING."
+    			+ " IT WORKS EVEN CALLING FROM METHOD OF THE SAME CLASS. It doesn't when using proxies AOP.");
+    }
+}
diff --git a/SpringJava/AOP/SpringLTW/src/main/resources/META-INF/aop.xml b/SpringJava/AOP/SpringLTW/src/main/resources/META-INF/aop.xml
new file mode 100644
index 0000000..2345268
--- /dev/null
+++ b/SpringJava/AOP/SpringLTW/src/main/resources/META-INF/aop.xml
@@ -0,0 +1,23 @@
+<!DOCTYPE aspectj PUBLIC
+        "-//AspectJ//DTD//EN" "http://www.eclipse.org/aspectj/dtd/aspectj.dtd">
+
+<aspectj>
+	<!--
+		With or without logs
+	<weaver>
+	-->	
+	<weaver options="-verbose -showWeaveInfo">
+        <!-- only weave classes in our application-specific packages -->
+       	<include within="de.spring..*"/>
+		<!--
+			Dump all types within the "somepack" package before they are woven
+			to the "./_ajdump" folder on disk
+		-->
+		<dump within="de.spring..*"/>	
+    </weaver>
+    
+    <aspects>
+        <aspect name="de.spring.example.MyAdvice"/>        
+    </aspects>
+
+</aspectj>
diff --git a/SpringJava/AOP/SpringLTW/src/main/resources/log4j2.xml b/SpringJava/AOP/SpringLTW/src/main/resources/log4j2.xml
new file mode 100644
index 0000000..8b3fc3f
--- /dev/null
+++ b/SpringJava/AOP/SpringLTW/src/main/resources/log4j2.xml
@@ -0,0 +1,43 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<!-- 
+	status: The level of internal Log4j events that should be logged to the console.
+	Valid values for this attribute are "trace", "debug", "info", "warn", "error" and "fatal".
+	
+	monitorInterval: The minimum amount of time, in seconds, that must elapse before the file configuration is checked for changes.
+	
+	
+	see https://logging.apache.org/log4j/2.x/manual/configuration.html
+ -->
+<Configuration status="error" strict="true" monitorInterval="30"
+                name="XMLConfigTest" packages="org.apache.logging.log4j.test">
+                
+	<!--
+		ALL > TRACE > DEBUG > INFO > WARN > ERROR > OFF
+		
+		ERROR by default.
+	-->
+                
+    <Appenders>
+        <Appender type="Console" name="STDOUT">
+            <PatternLayout pattern="%d{HH:mm:ss.SSS} %-5level %class{36} %L %M - %msg%xEx%n"/>
+        </Appender>
+    </Appenders>
+    <Loggers>
+    
+       	<!-- 
+    		General logging Spring.
+    	 -->
+        <Logger name="org.springframework" level="INFO" additivity="false">
+            <AppenderRef ref="STDOUT" />
+        </Logger>
+    
+
+		<!-- 
+			Anything else will be using TRACE logging level.
+		 -->        
+        <Root level="DEBUG">
+            <AppenderRef ref="STDOUT"/>
+        </Root>
+    </Loggers>
+</Configuration>
diff --git a/SpringJava/AOP/SpringLTW/src/main/resources/spring-config.xml b/SpringJava/AOP/SpringLTW/src/main/resources/spring-config.xml
new file mode 100644
index 0000000..ffb978c
--- /dev/null
+++ b/SpringJava/AOP/SpringLTW/src/main/resources/spring-config.xml
@@ -0,0 +1,68 @@
+<?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:schemaLocation="http://www.springframework.org/schema/beans 
+  						   http://www.springframework.org/schema/beans/spring-beans.xsd
+  						   http://www.springframework.org/schema/context 
+  						   http://www.springframework.org/schema/context/spring-context.xsd">
+
+	<!-- 
+			We have to use SPRING ASPECTJ (no SPRING AOP 2.0/1.2) because we want to use
+		annotations with inner classes.
+			AspectJ under this configuration requires at least one 'META-INF/aop.xml' file
+		with the configuration about the Advices.
+			
+		This switches on the load-time weaving 
+	    See: http://static.springsource.org/spring/docs/3.1.0.M2/spring-framework-reference/html/aop.html#aop-aj-ltw-spring
+	-->
+    <context:load-time-weaver  weaver-class="org.springframework.instrument.classloading.InstrumentationLoadTimeWeaver"
+    						   aspectj-weaving="autodetect"/>
+    
+	
+	<bean id="myAdvice" class="de.spring.example.MyAdvice">
+    	
+    </bean>
+
+ 	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy-method="close">
+                <property name="user" value="root"/>
+                <property name="password" value=""/>
+                <property name="driverClass" value="com.mysql.jdbc.Driver"/>
+                <property name="jdbcUrl" value="jdbc:mysql://127.0.0.1:3306/example?autoReconnect=true"/>
+                <property name="initialPoolSize" value="5"/>
+                <property name="maxPoolSize" value="20"/>
+                <property name="minPoolSize" value="10"/>
+                <property name="acquireIncrement" value="1"/>
+                <property name="acquireRetryAttempts" value="5"/>
+                <property name="acquireRetryDelay" value="1000"/>
+                <property name="automaticTestTable" value="con_test"/>
+                <property name="checkoutTimeout" value="5000"/>
+    </bean>
+ 
+    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
+		<property name="dataSource" ref="dataSource"/>
+	</bean>
+	
+	<bean id="myTransactionManager"
+	       class="de.spring.example.TransactionManager"
+	       factory-method="getInstance">
+        <property name="transactionManager">
+            <ref bean="transactionManager" />
+        </property>
+    </bean>
+	
+	<!-- 
+    		In order to find annotations in inner classes we have to create Spring 
+    	beans of them. NO WHEN WEAVING!!! :)
+    -->
+    <bean id="testOuter" class="de.spring.example.web.Test"/>
+    
+    <!--
+    	WHEN WEAVING WE MAY ANNOTATE METHODS IN INNER CLASSES. SO, WE DO NOT NEED TO CREATE
+    	Spring BEANS OF THEM. WITH PROXY AOP WE HAVE TO, BUT WHEN WEAVING NO!!!  
+    <bean id="testInner" class="de.spring.example.web.Test$InnerTest">
+        <constructor-arg ref="testOuter"/>
+    </bean>
+    -->
+    
+</beans>
diff --git a/SpringJava/AOP/SpringMavenWeaver/pom.xml b/SpringJava/AOP/SpringMavenWeaver/pom.xml
new file mode 100644
index 0000000..79f8576
--- /dev/null
+++ b/SpringJava/AOP/SpringMavenWeaver/pom.xml
@@ -0,0 +1,256 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<project
+	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"
+	xmlns="http://maven.apache.org/POM/4.0.0" 
+	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+	
+	<modelVersion>4.0.0</modelVersion>
+    <groupId>de.spring.example</groupId>
+	<artifactId>spring-maven-weaver</artifactId>
+    <version>2.0-SNAPSHOT</version>
+	<name>spring-maven-weaver</name>
+	<url>http://gumartinm.name</url>
+    <properties>
+      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+    </properties>
+
+	<dependencies> 
+       <dependency>
+           <groupId>org.springframework</groupId>
+           <artifactId>spring-context</artifactId>
+           <version>4.2.5.RELEASE</version>
+           <!-- 
+               Required dependency for getting rid of commons logging and use my own logging library
+               (in my case I decided to use log4j 2 under slf4j)
+           -->
+           <exclusions>
+               <exclusion>
+                   <groupId>commons-logging</groupId>
+                   <artifactId>commons-logging</artifactId>
+               </exclusion>
+           </exclusions>
+       </dependency>
+      <dependency>
+          <groupId>org.springframework</groupId>
+          <artifactId>spring-aspects</artifactId>
+          <version>4.2.5.RELEASE</version>
+          <!-- 
+              Required dependency for getting rid of commons logging and use my own logging library
+              (in my case I decided to use log4j 2 under slf4j)
+          -->
+          <exclusions>
+              <exclusion>
+                  <groupId>commons-logging</groupId>
+                  <artifactId>commons-logging</artifactId>
+              </exclusion>
+          </exclusions>
+      </dependency>
+      <dependency>
+          <groupId>org.springframework</groupId>
+          <artifactId>spring-aop</artifactId>
+          <version>4.2.5.RELEASE</version>
+          <!-- 
+              Required dependency for getting rid of commons logging and use my own logging library
+              (in my case I decided to use log4j 2 under slf4j)
+          -->
+          <exclusions>
+              <exclusion>
+                  <groupId>commons-logging</groupId>
+                  <artifactId>commons-logging</artifactId>
+              </exclusion>
+          </exclusions>
+      </dependency>
+
+		<dependency>
+    		<groupId>javax.cache</groupId>
+    		<artifactId>cache-api</artifactId>
+    		<version>1.0.0-PFD</version>
+		</dependency>
+		<dependency>
+		    <groupId>javax.transaction</groupId>
+		    <artifactId>javax.transaction-api</artifactId>
+		    <version>1.2</version>
+		</dependency>
+		<dependency>
+    		<groupId>org.springframework</groupId>
+    		<artifactId>spring-context-support</artifactId>
+    		<version>4.2.5.RELEASE</version>
+    		          <!-- 
+              Required dependency for getting rid of commons logging and use my own logging library
+              (in my case I decided to use log4j 2 under slf4j)
+          -->
+          <exclusions>
+              <exclusion>
+                  <groupId>commons-logging</groupId>
+                  <artifactId>commons-logging</artifactId>
+              </exclusion>
+          </exclusions>
+		</dependency>
+      <dependency>
+          <groupId>org.springframework</groupId>
+          <artifactId>spring-jdbc</artifactId>
+          <version>4.2.5.RELEASE</version>
+          <!-- 
+              Required dependency for getting rid of commons logging and use my own logging library
+              (in my case I decided to use log4j 2 under slf4j)
+          -->
+          <exclusions>
+              <exclusion>
+                  <groupId>commons-logging</groupId>
+                  <artifactId>commons-logging</artifactId>
+              </exclusion>
+          </exclusions>
+      </dependency>
+
+		<!-- Using aspectj-maven-plugin with AJDT -->
+		<dependency>
+			<groupId>org.aspectj</groupId>
+			<artifactId>aspectjrt</artifactId>
+			<version>1.8.9</version>
+			<scope>compile</scope>
+		</dependency>
+
+      <dependency>
+        <groupId>cglib</groupId>
+        <artifactId>cglib</artifactId>
+        <version>3.2.1</version>
+      </dependency>
+
+		<dependency>
+			<groupId>com.mchange</groupId>
+			<artifactId>c3p0</artifactId>
+			<version>0.9.5.2</version>
+		</dependency>
+		<dependency>
+			<groupId>mysql</groupId>
+			<artifactId>mysql-connector-java</artifactId>
+			<version>5.1.38</version>
+		</dependency>
+
+      <!--
+          1/3 Required dependency for log4j 2 with slf4j: binding between log4j 2 and slf4j
+      -->
+      <dependency>
+          <groupId>org.apache.logging.log4j</groupId>
+          <artifactId>log4j-slf4j-impl</artifactId>
+          <version>2.3</version>
+      </dependency>
+      <!--
+          2/3 Required dependency for log4j 2 with slf4j: log4j 2 maven plugin (it is the log4j 2 implementation)
+      -->
+      <dependency>
+          <groupId>org.apache.logging.log4j</groupId>
+          <artifactId>log4j-core</artifactId>
+          <version>2.3</version>
+      </dependency>
+      <!-- 
+          3/3 Required dependency for getting rid of commons logging.
+          This is the BRIDGE (no binding) between Jakarta Commons Logging (used by Spring) and whatever
+          I am using for logging (in this case I am using log4j 2)
+          See: http://www.slf4j.org/legacy.html
+          
+          We need exclusions in every dependency using Jakarta Commons Logging (see Spring dependencies below)
+       -->
+      <dependency>
+          <groupId>org.slf4j</groupId>
+          <artifactId>jcl-over-slf4j</artifactId>
+          <version>1.7.12</version>
+      </dependency>
+
+	</dependencies>
+    <build>
+      <plugins>
+          <plugin>
+              <groupId>org.apache.maven.plugins</groupId>
+              <artifactId>maven-compiler-plugin</artifactId>
+              <version>3.3</version>
+              <configuration>
+                  <source>1.8</source>
+                  <target>1.8</target>
+                  <encoding>${project.build.sourceEncoding}</encoding>
+              </configuration>
+			  <executions>
+				  <execution>
+					  <!-- Modifying output directory of default compile because non-weaved 
+						  classes must be stored in separate folder to not confuse ajc by reweaving 
+						  already woven classes (which leads to to ajc error message like "bad weaverState.Kind: 
+						  -115") -->
+					  <id>default-compile</id>
+					  <configuration>
+						  <compilerArguments>
+							  <d>${project.build.directory}/unwoven-classes</d>
+						  </compilerArguments>
+					  </configuration>
+				  </execution>
+			  </executions>
+          </plugin>
+          <plugin>
+              <groupId>org.apache.maven.plugins</groupId>
+              <artifactId>maven-resources-plugin</artifactId>
+              <version>2.7</version>
+              <configuration>
+                  <encoding>${project.build.sourceEncoding}</encoding>
+              </configuration>
+          </plugin>
+
+		<plugin>
+			<groupId>org.codehaus.mojo</groupId>
+			<artifactId>aspectj-maven-plugin</artifactId>
+			<version>1.8</version>
+			<configuration>
+          		<ajdtBuildDefFile>build.ajproperties</ajdtBuildDefFile>
+				<weaveDirectories>
+            		<weaveDirectory>${project.build.directory}/unwoven-classes</weaveDirectory>
+          		</weaveDirectories>
+          		<showWeaveInfo>true</showWeaveInfo>
+				<sources>
+					<source>
+						<basedir>src/main/java</basedir>
+						<includes>
+							<include>de.spring.example.MyAdvice.java</include>
+						</includes>
+						<excludes>
+							<exclude>**/logging/*.aj</exclude>
+						</excludes>
+					</source>
+				</sources>
+			</configuration>
+	        <executions>
+	          <execution>
+	            <!-- Compile and weave aspects after all classes compiled by javac -->
+	            <phase>process-classes</phase>
+	            <goals>
+	              <goal>compile</goal>
+	            </goals>
+	          </execution>
+	        </executions>
+
+		</plugin>
+      </plugins>
+    </build>
+
+	<reporting>
+		<plugins>
+			<plugin>
+				<groupId>org.codehaus.mojo</groupId>
+				<artifactId>aspectj-maven-plugin</artifactId>
+				<version>1.8</version>
+				<configuration>
+					<verbose>true</verbose>
+					<privateScope>true</privateScope>
+					<complianceLevel>1.5</complianceLevel>
+					<ajdtBuildDefFile>build.ajproperties</ajdtBuildDefFile>
+				</configuration>
+				<reportSets>
+					<reportSet>
+						<reports>
+							<report>aspectj-report</report>
+						</reports>
+					</reportSet>
+				</reportSets>
+			</plugin>
+		</plugins>
+	</reporting>
+  
+</project>
diff --git a/SpringJava/AOP/SpringMavenWeaver/src/main/java/de/spring/example/MyAdvice.java b/SpringJava/AOP/SpringMavenWeaver/src/main/java/de/spring/example/MyAdvice.java
new file mode 100644
index 0000000..6e25974
--- /dev/null
+++ b/SpringJava/AOP/SpringMavenWeaver/src/main/java/de/spring/example/MyAdvice.java
@@ -0,0 +1,28 @@
+package de.spring.example;
+
+import org.aspectj.lang.annotation.After;
+import org.aspectj.lang.annotation.Aspect;
+import org.aspectj.lang.annotation.Before;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+@Aspect
+public class MyAdvice {
+	private static final Logger LOGGER = LoggerFactory.getLogger(MyAdvice.class);
+
+	// With execution we avoid double weaving (when call and when execution)
+    @Before("@annotation(de.spring.example.annotation.initTransactional) && execution(* *(..))")
+    public void initTransactional()
+    {
+    	LOGGER.info("I am the Advice initTransaction.");
+        TransactionManager.getInstance().initTransaction();
+    }
+
+
+	// With execution we avoid double weaving (when call and when execution)
+    @After("@annotation(de.spring.example.annotation.commitTransactional) && execution(* *(..))")
+    public void commitTransactional() {
+    	LOGGER.info("I am the Advice commitTransaction.");
+        TransactionManager.getInstance().commitTransaction();
+    }
+}
diff --git a/SpringJava/AOP/SpringMavenWeaver/src/main/java/de/spring/example/SpringContextLocator.java b/SpringJava/AOP/SpringMavenWeaver/src/main/java/de/spring/example/SpringContextLocator.java
new file mode 100644
index 0000000..8a82a3a
--- /dev/null
+++ b/SpringJava/AOP/SpringMavenWeaver/src/main/java/de/spring/example/SpringContextLocator.java
@@ -0,0 +1,57 @@
+package de.spring.example;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.context.ApplicationContext;
+import org.springframework.context.support.ClassPathXmlApplicationContext;
+
+
+/**
+ *
+ */
+public final class SpringContextLocator {
+	private static final Logger LOGGER = LoggerFactory.getLogger(SpringContextLocator.class);
+
+
+        // Singleton Pattern
+        private static SpringContextLocator instance;
+
+        // Spring ApplicationContext
+        private static ApplicationContext context;
+
+        // Spring Context
+        private static final String SPRING_CONFIG_CONTEXT="/spring-config.xml";
+
+
+        /**
+         * Private constructor. Singleton pattern.
+         */
+        private SpringContextLocator() {
+                String[] factoryFiles = null;
+                LOGGER.info("Loading context files: " + SpringContextLocator.SPRING_CONFIG_CONTEXT);
+
+                factoryFiles = new String[] { SPRING_CONFIG_CONTEXT };
+
+                SpringContextLocator.context = new ClassPathXmlApplicationContext(factoryFiles);
+
+                LOGGER.info("The context has been loaded successfully!! ");
+        }
+
+        /**
+         * Singleton pattern not thread safety. To use SingletoHolder pattern as the best approximation 
+         * otherwise to use an Enum class (see Effective Java Second Edition and ) if we need serialization.
+         */
+        public static SpringContextLocator getInstance() {
+                if (SpringContextLocator.instance == null) {
+                        SpringContextLocator.instance = new SpringContextLocator();
+                }
+                return SpringContextLocator.instance;
+        }
+
+        /**
+         * Return bean from application context.
+         */
+        public Object getBean(final String name) {
+                return SpringContextLocator.context.getBean(name);
+        }
+}
\ No newline at end of file
diff --git a/SpringJava/AOP/SpringMavenWeaver/src/main/java/de/spring/example/SpringStart.java b/SpringJava/AOP/SpringMavenWeaver/src/main/java/de/spring/example/SpringStart.java
new file mode 100644
index 0000000..2aba4c2
--- /dev/null
+++ b/SpringJava/AOP/SpringMavenWeaver/src/main/java/de/spring/example/SpringStart.java
@@ -0,0 +1,22 @@
+package de.spring.example;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import de.spring.example.web.Test;
+
+public class SpringStart {
+	private static final Logger LOGGER = LoggerFactory.getLogger(SpringStart.class);
+
+	
+	/**
+	 * @param args
+	 */
+	public static void main(String[] args) {
+		LOGGER.info("Starting application");
+		SpringContextLocator.getInstance();
+		
+		Test test = (Test) SpringContextLocator.getInstance().getBean("testOuter");
+		test.myMethod();
+	}
+}
diff --git a/SpringJava/AOP/SpringMavenWeaver/src/main/java/de/spring/example/TransactionManager.java b/SpringJava/AOP/SpringMavenWeaver/src/main/java/de/spring/example/TransactionManager.java
new file mode 100644
index 0000000..53f3c59
--- /dev/null
+++ b/SpringJava/AOP/SpringMavenWeaver/src/main/java/de/spring/example/TransactionManager.java
@@ -0,0 +1,48 @@
+package de.spring.example;
+
+import org.aspectj.lang.annotation.Aspect;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.jdbc.datasource.DataSourceTransactionManager;
+import org.springframework.transaction.TransactionStatus;
+
+@Aspect
+public class TransactionManager {
+	private static final Logger LOGGER = LoggerFactory.getLogger(TransactionManager.class);
+    private static TransactionManager instance = new TransactionManager();
+    private DataSourceTransactionManager transactionManager;
+    private TransactionStatus transactionStatus;
+
+    //Why could you want to extend this class?
+    private TransactionManager() {
+    }
+
+    public static TransactionManager getInstance() {
+        return instance;
+    }
+
+    public void initTransaction()
+    {
+    	LOGGER.info("initTRANSACTION");
+        // transactionStatus = this.transactionManager.getTransaction(null);
+    }
+
+    public void rollbackTransaction()
+    {
+        this.transactionManager.rollback(this.transactionStatus);
+    }
+
+
+    public void commitTransaction()
+    {
+    	LOGGER.info("commitTRANSACTION");
+        // this.transactionManager.commit(this.transactionStatus);
+    }
+
+
+    /************************* Setters and getters *******************************************/
+    public void setTransactionManager(final DataSourceTransactionManager  transactionManager)
+    {
+        this.transactionManager = transactionManager;
+    }
+}
diff --git a/SpringJava/AOP/SpringMavenWeaver/src/main/java/de/spring/example/annotation/commitTransactional.java b/SpringJava/AOP/SpringMavenWeaver/src/main/java/de/spring/example/annotation/commitTransactional.java
new file mode 100644
index 0000000..1fda03f
--- /dev/null
+++ b/SpringJava/AOP/SpringMavenWeaver/src/main/java/de/spring/example/annotation/commitTransactional.java
@@ -0,0 +1,14 @@
+package de.spring.example.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import org.springframework.stereotype.Component;
+
+@Target({ElementType.METHOD, ElementType.TYPE})
+@Retention(RetentionPolicy.RUNTIME)
+@Component
+public @interface commitTransactional {
+}
diff --git a/SpringJava/AOP/SpringMavenWeaver/src/main/java/de/spring/example/annotation/initTransactional.java b/SpringJava/AOP/SpringMavenWeaver/src/main/java/de/spring/example/annotation/initTransactional.java
new file mode 100644
index 0000000..dad0b3e
--- /dev/null
+++ b/SpringJava/AOP/SpringMavenWeaver/src/main/java/de/spring/example/annotation/initTransactional.java
@@ -0,0 +1,14 @@
+package de.spring.example.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import org.springframework.stereotype.Component;
+
+@Target({ElementType.METHOD, ElementType.TYPE})
+@Retention(RetentionPolicy.RUNTIME)
+@Component
+public @interface initTransactional {
+}
diff --git a/SpringJava/AOP/SpringMavenWeaver/src/main/java/de/spring/example/web/Test.java b/SpringJava/AOP/SpringMavenWeaver/src/main/java/de/spring/example/web/Test.java
new file mode 100644
index 0000000..5cd7d2a
--- /dev/null
+++ b/SpringJava/AOP/SpringMavenWeaver/src/main/java/de/spring/example/web/Test.java
@@ -0,0 +1,40 @@
+package de.spring.example.web;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import de.spring.example.annotation.commitTransactional;
+import de.spring.example.annotation.initTransactional;
+
+
+public class Test {
+	private static final Logger LOGGER = LoggerFactory.getLogger(Test.class);
+
+    @initTransactional
+    public int myMethod()
+    {
+    	LOGGER.info("The Advice should be run before.");
+
+    	annotatedPrivateMethod();
+    	
+    	InnerTest innerTest = new InnerTest();
+    	innerTest.innerMethod();
+    	
+        return 666;
+    }
+
+    public class InnerTest {
+        @commitTransactional
+        public void innerMethod() {
+        	LOGGER.info("I am the inner class. The Advice should be run after."
+        			+ " NO NEED OF DECLARING Spring BEANS WHEN WEAVING!!!!");
+        }
+    }
+    
+    // IT WORKS WHEN WEAVING!!!
+    @initTransactional
+    private void annotatedPrivateMethod() {
+    	LOGGER.info("The Advice should be run before even with private methods because I AM WEAVING."
+    			+ " IT WORKS EVEN CALLING FROM METHOD OF THE SAME CLASS. It doesn't when using proxies AOP.");
+    }
+}
diff --git a/SpringJava/AOP/SpringMavenWeaver/src/main/resources/log4j2.xml b/SpringJava/AOP/SpringMavenWeaver/src/main/resources/log4j2.xml
new file mode 100644
index 0000000..8b3fc3f
--- /dev/null
+++ b/SpringJava/AOP/SpringMavenWeaver/src/main/resources/log4j2.xml
@@ -0,0 +1,43 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<!-- 
+	status: The level of internal Log4j events that should be logged to the console.
+	Valid values for this attribute are "trace", "debug", "info", "warn", "error" and "fatal".
+	
+	monitorInterval: The minimum amount of time, in seconds, that must elapse before the file configuration is checked for changes.
+	
+	
+	see https://logging.apache.org/log4j/2.x/manual/configuration.html
+ -->
+<Configuration status="error" strict="true" monitorInterval="30"
+                name="XMLConfigTest" packages="org.apache.logging.log4j.test">
+                
+	<!--
+		ALL > TRACE > DEBUG > INFO > WARN > ERROR > OFF
+		
+		ERROR by default.
+	-->
+                
+    <Appenders>
+        <Appender type="Console" name="STDOUT">
+            <PatternLayout pattern="%d{HH:mm:ss.SSS} %-5level %class{36} %L %M - %msg%xEx%n"/>
+        </Appender>
+    </Appenders>
+    <Loggers>
+    
+       	<!-- 
+    		General logging Spring.
+    	 -->
+        <Logger name="org.springframework" level="INFO" additivity="false">
+            <AppenderRef ref="STDOUT" />
+        </Logger>
+    
+
+		<!-- 
+			Anything else will be using TRACE logging level.
+		 -->        
+        <Root level="DEBUG">
+            <AppenderRef ref="STDOUT"/>
+        </Root>
+    </Loggers>
+</Configuration>
diff --git a/SpringJava/AOP/SpringMavenWeaver/src/main/resources/spring-config.xml b/SpringJava/AOP/SpringMavenWeaver/src/main/resources/spring-config.xml
new file mode 100644
index 0000000..ffb978c
--- /dev/null
+++ b/SpringJava/AOP/SpringMavenWeaver/src/main/resources/spring-config.xml
@@ -0,0 +1,68 @@
+<?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:schemaLocation="http://www.springframework.org/schema/beans 
+  						   http://www.springframework.org/schema/beans/spring-beans.xsd
+  						   http://www.springframework.org/schema/context 
+  						   http://www.springframework.org/schema/context/spring-context.xsd">
+
+	<!-- 
+			We have to use SPRING ASPECTJ (no SPRING AOP 2.0/1.2) because we want to use
+		annotations with inner classes.
+			AspectJ under this configuration requires at least one 'META-INF/aop.xml' file
+		with the configuration about the Advices.
+			
+		This switches on the load-time weaving 
+	    See: http://static.springsource.org/spring/docs/3.1.0.M2/spring-framework-reference/html/aop.html#aop-aj-ltw-spring
+	-->
+    <context:load-time-weaver  weaver-class="org.springframework.instrument.classloading.InstrumentationLoadTimeWeaver"
+    						   aspectj-weaving="autodetect"/>
+    
+	
+	<bean id="myAdvice" class="de.spring.example.MyAdvice">
+    	
+    </bean>
+
+ 	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy-method="close">
+                <property name="user" value="root"/>
+                <property name="password" value=""/>
+                <property name="driverClass" value="com.mysql.jdbc.Driver"/>
+                <property name="jdbcUrl" value="jdbc:mysql://127.0.0.1:3306/example?autoReconnect=true"/>
+                <property name="initialPoolSize" value="5"/>
+                <property name="maxPoolSize" value="20"/>
+                <property name="minPoolSize" value="10"/>
+                <property name="acquireIncrement" value="1"/>
+                <property name="acquireRetryAttempts" value="5"/>
+                <property name="acquireRetryDelay" value="1000"/>
+                <property name="automaticTestTable" value="con_test"/>
+                <property name="checkoutTimeout" value="5000"/>
+    </bean>
+ 
+    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
+		<property name="dataSource" ref="dataSource"/>
+	</bean>
+	
+	<bean id="myTransactionManager"
+	       class="de.spring.example.TransactionManager"
+	       factory-method="getInstance">
+        <property name="transactionManager">
+            <ref bean="transactionManager" />
+        </property>
+    </bean>
+	
+	<!-- 
+    		In order to find annotations in inner classes we have to create Spring 
+    	beans of them. NO WHEN WEAVING!!! :)
+    -->
+    <bean id="testOuter" class="de.spring.example.web.Test"/>
+    
+    <!--
+    	WHEN WEAVING WE MAY ANNOTATE METHODS IN INNER CLASSES. SO, WE DO NOT NEED TO CREATE
+    	Spring BEANS OF THEM. WITH PROXY AOP WE HAVE TO, BUT WHEN WEAVING NO!!!  
+    <bean id="testInner" class="de.spring.example.web.Test$InnerTest">
+        <constructor-arg ref="testOuter"/>
+    </bean>
+    -->
+    
+</beans>
diff --git a/SpringJava/SpringAOP20/pom.xml b/SpringJava/SpringAOP20/pom.xml
deleted file mode 100644
index b43ac81..0000000
--- a/SpringJava/SpringAOP20/pom.xml
+++ /dev/null
@@ -1,124 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-
-<project
-	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"
-	xmlns="http://maven.apache.org/POM/4.0.0" 
-	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
-	
-	<modelVersion>4.0.0</modelVersion>
-    <groupId>de.spring.example</groupId>
-	<artifactId>spring-aop-example</artifactId>
-    <version>2.0-SNAPSHOT</version>
-	<name>spring-aop-example</name>
-	<url>http://gumartinm.name</url>
-    <properties>
-      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
-    </properties>
-
-	<dependencies> 
-       <dependency>
-           <groupId>org.springframework</groupId>
-           <artifactId>spring-context</artifactId>
-           <version>4.2.5.RELEASE</version>
-           <!-- 
-               Required dependency for getting rid of commons logging and use my own logging library
-               (in my case I decided to use log4j 2 under slf4j)
-           -->
-           <exclusions>
-               <exclusion>
-                   <groupId>commons-logging</groupId>
-                   <artifactId>commons-logging</artifactId>
-               </exclusion>
-           </exclusions>
-       </dependency>
-      <dependency>
-          <groupId>org.springframework</groupId>
-          <artifactId>spring-aspects</artifactId>
-          <version>4.2.5.RELEASE</version>
-          <!-- 
-              Required dependency for getting rid of commons logging and use my own logging library
-              (in my case I decided to use log4j 2 under slf4j)
-          -->
-          <exclusions>
-              <exclusion>
-                  <groupId>commons-logging</groupId>
-                  <artifactId>commons-logging</artifactId>
-              </exclusion>
-          </exclusions>
-      </dependency>
-      <dependency>
-          <groupId>org.springframework</groupId>
-          <artifactId>spring-aop</artifactId>
-          <version>4.2.5.RELEASE</version>
-          <!-- 
-              Required dependency for getting rid of commons logging and use my own logging library
-              (in my case I decided to use log4j 2 under slf4j)
-          -->
-          <exclusions>
-              <exclusion>
-                  <groupId>commons-logging</groupId>
-                  <artifactId>commons-logging</artifactId>
-              </exclusion>
-          </exclusions>
-      </dependency>
-
-      <dependency>
-        <groupId>cglib</groupId>
-        <artifactId>cglib</artifactId>
-        <version>3.2.1</version>
-      </dependency>
-
-      <!--
-          1/3 Required dependency for log4j 2 with slf4j: binding between log4j 2 and slf4j
-      -->
-      <dependency>
-          <groupId>org.apache.logging.log4j</groupId>
-          <artifactId>log4j-slf4j-impl</artifactId>
-          <version>2.3</version>
-      </dependency>
-      <!--
-          2/3 Required dependency for log4j 2 with slf4j: log4j 2 maven plugin (it is the log4j 2 implementation)
-      -->
-      <dependency>
-          <groupId>org.apache.logging.log4j</groupId>
-          <artifactId>log4j-core</artifactId>
-          <version>2.3</version>
-      </dependency>
-      <!-- 
-          3/3 Required dependency for getting rid of commons logging.
-          This is the BRIDGE (no binding) between Jakarta Commons Logging (used by Spring) and whatever
-          I am using for logging (in this case I am using log4j 2)
-          See: http://www.slf4j.org/legacy.html
-          
-          We need exclusions in every dependency using Jakarta Commons Logging (see Spring dependencies below)
-       -->
-      <dependency>
-          <groupId>org.slf4j</groupId>
-          <artifactId>jcl-over-slf4j</artifactId>
-          <version>1.7.12</version>
-      </dependency>
-
-	</dependencies>
-    <build>
-      <plugins>
-          <plugin>
-              <groupId>org.apache.maven.plugins</groupId>
-              <artifactId>maven-compiler-plugin</artifactId>
-              <version>3.3</version>
-              <configuration>
-                  <source>1.8</source>
-                  <target>1.8</target>
-                  <encoding>${project.build.sourceEncoding}</encoding>
-              </configuration>
-          </plugin>
-          <plugin>
-              <groupId>org.apache.maven.plugins</groupId>
-              <artifactId>maven-resources-plugin</artifactId>
-              <version>2.7</version>
-              <configuration>
-                  <encoding>${project.build.sourceEncoding}</encoding>
-              </configuration>
-          </plugin>
-      </plugins>
-    </build>
-</project>
diff --git a/SpringJava/SpringAOP20/src/main/java/de/spring/example/GeneralAccess.java b/SpringJava/SpringAOP20/src/main/java/de/spring/example/GeneralAccess.java
deleted file mode 100644
index ce30630..0000000
--- a/SpringJava/SpringAOP20/src/main/java/de/spring/example/GeneralAccess.java
+++ /dev/null
@@ -1,21 +0,0 @@
-package de.spring.example;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-/**
- * 
- * This class is not using the AspectJ annotations, so we could use it on JDK 1.4 and below.
- * If we want to use it as an Aspect we may JUST do it using a schema based declaration.
- * What means, you can use this class as an Aspect JUST using an xml Spring declaration. 
- *
- */
-public class GeneralAccess {
-	private static final Logger LOGGER = LoggerFactory.getLogger(GeneralAccess.class);
-
-		
-	public void monitor()
-	{
-		LOGGER.info("I am the Advice monitor for TestB and I will be run before.");
-	}
-}
diff --git a/SpringJava/SpringAOP20/src/main/java/de/spring/example/SpringAdvice.java b/SpringJava/SpringAOP20/src/main/java/de/spring/example/SpringAdvice.java
deleted file mode 100644
index 1555575..0000000
--- a/SpringJava/SpringAOP20/src/main/java/de/spring/example/SpringAdvice.java
+++ /dev/null
@@ -1,23 +0,0 @@
-package de.spring.example;
-
-import java.lang.reflect.Method;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import org.springframework.aop.MethodBeforeAdvice;
-
-/**
- * 
- * We are using here an Advice of Spring 1.2
- * See: http://static.springsource.org/spring/docs/3.1.0.RC1/spring-framework-reference/html/aop-api.html#aop-api-advice-types
- *
- */
-public class SpringAdvice implements MethodBeforeAdvice {
-	private static final Logger LOGGER = LoggerFactory.getLogger(SpringAdvice.class);
-
-
-	public void before(Method m, Object[] args, Object target) throws Throwable {
-		LOGGER.info("I am the SpringAdvice and I will be run before.");
-	}
-	
-}
diff --git a/SpringJava/SpringAOP20/src/main/java/de/spring/example/SpringContextLocator.java b/SpringJava/SpringAOP20/src/main/java/de/spring/example/SpringContextLocator.java
deleted file mode 100644
index d599c8f..0000000
--- a/SpringJava/SpringAOP20/src/main/java/de/spring/example/SpringContextLocator.java
+++ /dev/null
@@ -1,53 +0,0 @@
-package de.spring.example;
-
-import org.springframework.context.ApplicationContext;
-import org.springframework.context.support.ClassPathXmlApplicationContext;
-
-
-/**
- *
- */
-public final class SpringContextLocator {
-
-        // Singleton Pattern
-        private static SpringContextLocator instance;
-
-        // Spring ApplicationContext
-        private static ApplicationContext context;
-
-        // Spring Context
-        private static final String SPRING_CONFIG_CONTEXT="spring-config.xml";
-
-
-        /**
-         * Private constructor. Singleton pattern.
-         */
-        private SpringContextLocator() {
-                String[] factoryFiles = null;
-                System.out.println("Loading context files: " + SpringContextLocator.SPRING_CONFIG_CONTEXT);
-
-                factoryFiles = new String[] { SPRING_CONFIG_CONTEXT };
-
-                SpringContextLocator.context = new ClassPathXmlApplicationContext(factoryFiles);
-
-                System.out.println("The context has been loaded successfully!! ");
-        }
-
-        /**
-         * Singleton pattern not thread safety. To use SingletoHolder pattern as the best approximation 
-         * otherwise to use an Enum class (see Effective Java Second Edition and ) if we need serialization.
-         */
-        public static SpringContextLocator getInstance() {
-                if (SpringContextLocator.instance == null) {
-                        SpringContextLocator.instance = new SpringContextLocator();
-                }
-                return SpringContextLocator.instance;
-        }
-
-        /**
-         * Return bean from application context.
-         */
-        public Object getBean(final String name) {
-                return SpringContextLocator.context.getBean(name);
-        }
-}
\ No newline at end of file
diff --git a/SpringJava/SpringAOP20/src/main/java/de/spring/example/SpringStart.java b/SpringJava/SpringAOP20/src/main/java/de/spring/example/SpringStart.java
deleted file mode 100644
index c6ed090..0000000
--- a/SpringJava/SpringAOP20/src/main/java/de/spring/example/SpringStart.java
+++ /dev/null
@@ -1,25 +0,0 @@
-package de.spring.example;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import de.spring.example.service.TestB;
-import de.spring.example.web.TestA;
-
-public class SpringStart {
-	private static final Logger LOGGER = LoggerFactory.getLogger(SpringStart.class);
-
-	/**
-	 * @param args
-	 */
-	public static void main(String[] args) {
-		LOGGER.info("Starting application");
-		SpringContextLocator.getInstance();
-		
-		TestA testA = (TestA) SpringContextLocator.getInstance().getBean("testA");
-		testA.myMethod();
-		
-		TestB testB = (TestB) SpringContextLocator.getInstance().getBean("testB");
-		testB.myMethod();
-	}
-}
diff --git a/SpringJava/SpringAOP20/src/main/java/de/spring/example/SystemArchitecture.java b/SpringJava/SpringAOP20/src/main/java/de/spring/example/SystemArchitecture.java
deleted file mode 100644
index 822f240..0000000
--- a/SpringJava/SpringAOP20/src/main/java/de/spring/example/SystemArchitecture.java
+++ /dev/null
@@ -1,43 +0,0 @@
-package de.spring.example;
-
-import org.aspectj.lang.annotation.Pointcut;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-/**
- * 
- * Using the @Aspect annotation you could use this class as an Aspect without
- * using a schema based declaration (without using <aop:aspect in the Spring xml file)
- * What means, you could use this class as an Aspect without the xml Spring declaration.
- *
- */
-public class SystemArchitecture {
-	private static final Logger LOGGER = LoggerFactory.getLogger(SystemArchitecture.class);
-
-	
-	//Coonecting to the execution of any method defined in the 
-	//package: de.spring.example.web
-	//We are connecting the methods defined in that package with this
-	//Pointcut. So, when executing any of those methods defined in that
-	//package we will run the Advice related to this Pointcut (if there is an Advice)
-	//NOTICE:
-	//			WE ARE NOT USING THE @Aspect ANNOTATION, SO WE CAN USE THIS CLASS AS
-	//          AN ASPECT AND THIS METHOD AS A POINTCUT JUST USING A SCHEMA BASED DECLARATION
-	@Pointcut("execution(* de.spring.example.web.*.*(..))")
-	public void pointCutMethod() 
-	{
-		LOGGER.info("I am the Pointcut and you will never see me.");
-		//This is the PointCut. 
-		//You can write code here, but it will be useless because while running
-		//the methods connected to the Pointcut, this code will not be executed.
-		//Just the advice will run!!!! :/
-		//Is not this weird? We are here defining a method whose code 
-		//will never be run. When the hell should we write code here?
-		//This is a waste of time and code IMHO. Isn't it?
-	}
-	
-	public void monitor()
-	{
-		LOGGER.info("I am the Advice monitor for TestA and I will be run before.");
-	}
-}
\ No newline at end of file
diff --git a/SpringJava/SpringAOP20/src/main/java/de/spring/example/service/TestB.java b/SpringJava/SpringAOP20/src/main/java/de/spring/example/service/TestB.java
deleted file mode 100644
index 22f186d..0000000
--- a/SpringJava/SpringAOP20/src/main/java/de/spring/example/service/TestB.java
+++ /dev/null
@@ -1,16 +0,0 @@
-package de.spring.example.service;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-public class TestB {
-	private static final Logger LOGGER = LoggerFactory.getLogger(TestB.class);
-
-	public int myMethod()
-	{
-		LOGGER.info("TestB: The Advice should be run before.");
-		
-		//This value will be caught by the Advice with the @AfterReturning annotation.
-		return 999;
-	}
-}
diff --git a/SpringJava/SpringAOP20/src/main/java/de/spring/example/web/TestA.java b/SpringJava/SpringAOP20/src/main/java/de/spring/example/web/TestA.java
deleted file mode 100644
index 0b40603..0000000
--- a/SpringJava/SpringAOP20/src/main/java/de/spring/example/web/TestA.java
+++ /dev/null
@@ -1,16 +0,0 @@
-package de.spring.example.web;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-public class TestA {
-	private static final Logger LOGGER = LoggerFactory.getLogger(TestA.class);
-
-	public int myMethod()
-	{
-		LOGGER.info("TestA: The Advice should be run before.");
-		
-		//This value will be caught by the Advice with the @AfterReturning annotation.
-		return 666;
-	}
-}
diff --git a/SpringJava/SpringAOP20/src/main/resources/log4j2.xml b/SpringJava/SpringAOP20/src/main/resources/log4j2.xml
deleted file mode 100644
index 8b3fc3f..0000000
--- a/SpringJava/SpringAOP20/src/main/resources/log4j2.xml
+++ /dev/null
@@ -1,43 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-
-<!-- 
-	status: The level of internal Log4j events that should be logged to the console.
-	Valid values for this attribute are "trace", "debug", "info", "warn", "error" and "fatal".
-	
-	monitorInterval: The minimum amount of time, in seconds, that must elapse before the file configuration is checked for changes.
-	
-	
-	see https://logging.apache.org/log4j/2.x/manual/configuration.html
- -->
-<Configuration status="error" strict="true" monitorInterval="30"
-                name="XMLConfigTest" packages="org.apache.logging.log4j.test">
-                
-	<!--
-		ALL > TRACE > DEBUG > INFO > WARN > ERROR > OFF
-		
-		ERROR by default.
-	-->
-                
-    <Appenders>
-        <Appender type="Console" name="STDOUT">
-            <PatternLayout pattern="%d{HH:mm:ss.SSS} %-5level %class{36} %L %M - %msg%xEx%n"/>
-        </Appender>
-    </Appenders>
-    <Loggers>
-    
-       	<!-- 
-    		General logging Spring.
-    	 -->
-        <Logger name="org.springframework" level="INFO" additivity="false">
-            <AppenderRef ref="STDOUT" />
-        </Logger>
-    
-
-		<!-- 
-			Anything else will be using TRACE logging level.
-		 -->        
-        <Root level="DEBUG">
-            <AppenderRef ref="STDOUT"/>
-        </Root>
-    </Loggers>
-</Configuration>
diff --git a/SpringJava/SpringAOP20/src/main/resources/spring-config.xml b/SpringJava/SpringAOP20/src/main/resources/spring-config.xml
deleted file mode 100644
index bda1080..0000000
--- a/SpringJava/SpringAOP20/src/main/resources/spring-config.xml
+++ /dev/null
@@ -1,80 +0,0 @@
-<?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" 
-       xmlns:aop="http://www.springframework.org/schema/aop"
-       xsi:schemaLocation="http://www.springframework.org/schema/beans 
-  						   http://www.springframework.org/schema/beans/spring-beans.xsd
-  						   http://www.springframework.org/schema/aop 
- 		 				   http://www.springframework.org/schema/aop/spring-aop.xsd
-  						   http://www.springframework.org/schema/context 
-  						   http://www.springframework.org/schema/context/spring-context.xsd
-  						   http://www.springframework.org/schema/tx 
-  						   http://www.springframework.org/schema/tx/spring-tx.xsd">
-  
-  	 <!-- 
-  		To force CGLIB proxying when using Spring AOP
-  		See: http://static.springsource.org/spring/docs/3.1.0.RC1/spring-framework-reference/html/aop.html#aop-proxying
-  	 -->
-     <aop:config proxy-target-class="true">
-     	<aop:aspect id="myAspectSchemaBased" ref="generalAccess">
-     		<aop:pointcut id="aspectOperation" 
-        				  expression="execution(* de.spring.example.service.*.*(..))"/>
-        	<aop:before pointcut-ref="aspectOperation" method="monitor"/>
- 		</aop:aspect>
-     </aop:config>
-     
-	
-	<aop:config proxy-target-class="true">
-     	<aop:aspect id="myAspectwithAnnotations" ref="systemArchitecture">
-     		<!-- 
-     			See: http://static.springsource.org/spring/docs/3.1.0.RC1/spring-framework-reference/html/aop.html#aop-schema-pointcuts
-     			"Note that the pointcut expression itself is using the same AspectJ pointcut expression 
-     			language as described in Section 8.2, “@AspectJ support”. If you are using the schema 
-     			based declaration style with Java 5, you can refer to named pointcuts defined in types 
-     			(@Aspects) within the pointcut expression, but this feature is not available on JDK 1.4 and below 
-     			(it relies on the Java 5 specific AspectJ reflection APIs). On JDK 1.5 therefore, another way of 
-     			defining the above pointcut would be:
-     		 -->
-     		<aop:pointcut id="pointCutAspect" 
-        				  expression="de.spring.example.SystemArchitecture.pointCutMethod()"/>
-            <!-- This will be the Advice. You can use the same class for it or you can use the aop:advisor
-            	 xml Spring annotation. In that case you have to use an Advice class from AOP support of Spring 1.2
-            	 (below you can see an example of this)
-             -->
-        	<aop:before pointcut-ref="pointCutAspect" method="monitor"/>
- 		</aop:aspect>
-    </aop:config>
-     
-     
-    <!-- 
-		We are using AOP support from Spring 1.2 :/ for this Advice
-		(we use Spring beans as advices and we can use the AOP support from Spring 1.2 for this)
-		We can use and mix whatever we want. Spring is powerful but at the same time it can be a complete mess.
-	 -->
-	<aop:config proxy-target-class="true">
-     	<aop:advisor pointcut="de.spring.example.SystemArchitecture.pointCutMethod()"
-     				 advice-ref="springAdvice" />
-    </aop:config>
-	
-	<bean id="testA" class="de.spring.example.web.TestA">
-    	
-    </bean>
-    
-    <bean id="testB" class="de.spring.example.service.TestB">
-    	
-    </bean>
-    
-    <bean id="generalAccess" class="de.spring.example.GeneralAccess">
-    	
-    </bean>
-    
-    <bean id="systemArchitecture" class="de.spring.example.SystemArchitecture">
-    	
-    </bean>
-    
-    <bean id="springAdvice" class="de.spring.example.SpringAdvice">
-    	
-    </bean>
-    
-</beans>
diff --git a/SpringJava/SpringAspectJ/pom.xml b/SpringJava/SpringAspectJ/pom.xml
deleted file mode 100644
index be48cff..0000000
--- a/SpringJava/SpringAspectJ/pom.xml
+++ /dev/null
@@ -1,124 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-
-<project
-	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"
-	xmlns="http://maven.apache.org/POM/4.0.0" 
-	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
-	
-	<modelVersion>4.0.0</modelVersion>
-    <groupId>de.spring.example</groupId>
-	<artifactId>spring-aspectj</artifactId>
-    <version>2.0-SNAPSHOT</version>
-	<name>spring-aspectj</name>
-	<url>http://gumartinm.name</url>
-    <properties>
-      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
-    </properties>
-
-	<dependencies> 
-       <dependency>
-           <groupId>org.springframework</groupId>
-           <artifactId>spring-context</artifactId>
-           <version>4.2.5.RELEASE</version>
-           <!-- 
-               Required dependency for getting rid of commons logging and use my own logging library
-               (in my case I decided to use log4j 2 under slf4j)
-           -->
-           <exclusions>
-               <exclusion>
-                   <groupId>commons-logging</groupId>
-                   <artifactId>commons-logging</artifactId>
-               </exclusion>
-           </exclusions>
-       </dependency>
-      <dependency>
-          <groupId>org.springframework</groupId>
-          <artifactId>spring-aspects</artifactId>
-          <version>4.2.5.RELEASE</version>
-          <!-- 
-              Required dependency for getting rid of commons logging and use my own logging library
-              (in my case I decided to use log4j 2 under slf4j)
-          -->
-          <exclusions>
-              <exclusion>
-                  <groupId>commons-logging</groupId>
-                  <artifactId>commons-logging</artifactId>
-              </exclusion>
-          </exclusions>
-      </dependency>
-      <dependency>
-          <groupId>org.springframework</groupId>
-          <artifactId>spring-aop</artifactId>
-          <version>4.2.5.RELEASE</version>
-          <!-- 
-              Required dependency for getting rid of commons logging and use my own logging library
-              (in my case I decided to use log4j 2 under slf4j)
-          -->
-          <exclusions>
-              <exclusion>
-                  <groupId>commons-logging</groupId>
-                  <artifactId>commons-logging</artifactId>
-              </exclusion>
-          </exclusions>
-      </dependency>
-
-      <dependency>
-        <groupId>cglib</groupId>
-        <artifactId>cglib</artifactId>
-        <version>3.2.1</version>
-      </dependency>
-
-      <!--
-          1/3 Required dependency for log4j 2 with slf4j: binding between log4j 2 and slf4j
-      -->
-      <dependency>
-          <groupId>org.apache.logging.log4j</groupId>
-          <artifactId>log4j-slf4j-impl</artifactId>
-          <version>2.3</version>
-      </dependency>
-      <!--
-          2/3 Required dependency for log4j 2 with slf4j: log4j 2 maven plugin (it is the log4j 2 implementation)
-      -->
-      <dependency>
-          <groupId>org.apache.logging.log4j</groupId>
-          <artifactId>log4j-core</artifactId>
-          <version>2.3</version>
-      </dependency>
-      <!-- 
-          3/3 Required dependency for getting rid of commons logging.
-          This is the BRIDGE (no binding) between Jakarta Commons Logging (used by Spring) and whatever
-          I am using for logging (in this case I am using log4j 2)
-          See: http://www.slf4j.org/legacy.html
-          
-          We need exclusions in every dependency using Jakarta Commons Logging (see Spring dependencies below)
-       -->
-      <dependency>
-          <groupId>org.slf4j</groupId>
-          <artifactId>jcl-over-slf4j</artifactId>
-          <version>1.7.12</version>
-      </dependency>
-
-	</dependencies>
-    <build>
-      <plugins>
-          <plugin>
-              <groupId>org.apache.maven.plugins</groupId>
-              <artifactId>maven-compiler-plugin</artifactId>
-              <version>3.3</version>
-              <configuration>
-                  <source>1.8</source>
-                  <target>1.8</target>
-                  <encoding>${project.build.sourceEncoding}</encoding>
-              </configuration>
-          </plugin>
-          <plugin>
-              <groupId>org.apache.maven.plugins</groupId>
-              <artifactId>maven-resources-plugin</artifactId>
-              <version>2.7</version>
-              <configuration>
-                  <encoding>${project.build.sourceEncoding}</encoding>
-              </configuration>
-          </plugin>
-      </plugins>
-    </build>
-</project>
diff --git a/SpringJava/SpringAspectJ/src/main/java/de/spring/example/MyAdvice.java b/SpringJava/SpringAspectJ/src/main/java/de/spring/example/MyAdvice.java
deleted file mode 100644
index 5121bba..0000000
--- a/SpringJava/SpringAspectJ/src/main/java/de/spring/example/MyAdvice.java
+++ /dev/null
@@ -1,44 +0,0 @@
-package de.spring.example;
-
-import org.aspectj.lang.ProceedingJoinPoint;
-import org.aspectj.lang.annotation.Around;
-import org.aspectj.lang.annotation.Aspect;
-import org.aspectj.lang.annotation.Before;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-@Aspect
-public class MyAdvice {
-	private static final Logger LOGGER = LoggerFactory.getLogger(MyAdvice.class);
-
-	
-	//This advice is connected with the Pointcut defined in SystemArchitecture.
-	//So, every method connected to that Pointcut will be run after the
-	//method defined in this Advice.
-	@Before("de.spring.example.SystemArchitecture.pointCutMethod())")
-	public void doAccessCheck() {
-		LOGGER.info("I am the Advice and I will be run before.");
-	}
-	
-	
-	//NOTICE: YOU DO NOT NEED TO CREATE A SPECIAL CLASS FOR POINTCUTS
-	//        YOU COULD DEFINE AN ADVICE WITHOUT A POINTCUT
-	//This advice has a PointCut defined like execution(* de.spring.example.web.Test.anotherExample())
-	//right here without a special PointCut method. This advice has itself the PointCut
-	@Around("execution(* de.spring.example.web.Test.anotherExample())")
-	public Object doAround(ProceedingJoinPoint pjp) {
-		LOGGER.info("I am the Advice and I will be run before and after. BEFORE");
-		// start stopwatch
-		// This local variable will store the returned value from the method anotherExample()
-	    Object retVal=null;
-		try {
-			//Calling the real method
-			retVal = pjp.proceed();
-		} catch (Throwable e) {
-			LOGGER.info("Error", e);
-		}
-	    // stop stopwatch
-		LOGGER.info("I am the Advice and I will be run before and after. AFTER " + retVal);
-	    return retVal;
-	}
-}
diff --git a/SpringJava/SpringAspectJ/src/main/java/de/spring/example/SpringAdvice.java b/SpringJava/SpringAspectJ/src/main/java/de/spring/example/SpringAdvice.java
deleted file mode 100644
index e5bdf66..0000000
--- a/SpringJava/SpringAspectJ/src/main/java/de/spring/example/SpringAdvice.java
+++ /dev/null
@@ -1,22 +0,0 @@
-package de.spring.example;
-
-import java.lang.reflect.Method;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import org.springframework.aop.MethodBeforeAdvice;
-
-/**
- * 
- * We are using here an Advice of Spring 1.2
- * See: http://static.springsource.org/spring/docs/3.1.0.RC1/spring-framework-reference/html/aop-api.html#aop-api-advice-types
- *
- */
-public class SpringAdvice implements MethodBeforeAdvice {
-	private static final Logger LOGGER = LoggerFactory.getLogger(SpringAdvice.class);
-
-	public void before(Method m, Object[] args, Object target) throws Throwable {
-		LOGGER.info("I am the SpringAdvice and I will be run before.");
-	}
-	
-}
diff --git a/SpringJava/SpringAspectJ/src/main/java/de/spring/example/SpringContextLocator.java b/SpringJava/SpringAspectJ/src/main/java/de/spring/example/SpringContextLocator.java
deleted file mode 100644
index ff58276..0000000
--- a/SpringJava/SpringAspectJ/src/main/java/de/spring/example/SpringContextLocator.java
+++ /dev/null
@@ -1,57 +0,0 @@
-package de.spring.example;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import org.springframework.context.ApplicationContext;
-import org.springframework.context.support.ClassPathXmlApplicationContext;
-
-
-/**
- *
- */
-public final class SpringContextLocator {
-	private static final Logger LOGGER = LoggerFactory.getLogger(SpringAdvice.class);
-
-
-        // Singleton Pattern
-        private static SpringContextLocator instance;
-
-        // Spring ApplicationContext
-        private static ApplicationContext context;
-
-        // Spring Context
-        private static final String SPRING_CONFIG_CONTEXT="spring-config.xml";
-
-
-        /**
-         * Private constructor. Singleton pattern.
-         */
-        private SpringContextLocator() {
-                String[] factoryFiles = null;
-                LOGGER.info("Loading context files: " + SpringContextLocator.SPRING_CONFIG_CONTEXT);
-
-                factoryFiles = new String[] { SPRING_CONFIG_CONTEXT };
-
-                SpringContextLocator.context = new ClassPathXmlApplicationContext(factoryFiles);
-
-                LOGGER.info("The context has been loaded successfully!! ");
-        }
-
-        /**
-         * Singleton pattern not thread safety. To use SingletoHolder pattern as the best approximation 
-         * otherwise to use an Enum class (see Effective Java Second Edition and ) if we need serialization.
-         */
-        public static SpringContextLocator getInstance() {
-                if (SpringContextLocator.instance == null) {
-                        SpringContextLocator.instance = new SpringContextLocator();
-                }
-                return SpringContextLocator.instance;
-        }
-
-        /**
-         * Return bean from application context.
-         */
-        public Object getBean(final String name) {
-                return SpringContextLocator.context.getBean(name);
-        }
-}
\ No newline at end of file
diff --git a/SpringJava/SpringAspectJ/src/main/java/de/spring/example/SpringStart.java b/SpringJava/SpringAspectJ/src/main/java/de/spring/example/SpringStart.java
deleted file mode 100644
index f553341..0000000
--- a/SpringJava/SpringAspectJ/src/main/java/de/spring/example/SpringStart.java
+++ /dev/null
@@ -1,22 +0,0 @@
-package de.spring.example;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import de.spring.example.web.Test;
-
-public class SpringStart {
-	private static final Logger LOGGER = LoggerFactory.getLogger(SpringStart.class);
-
-	/**
-	 * @param args
-	 */
-	public static void main(String[] args) {
-		LOGGER.info("Starting application");
-		SpringContextLocator.getInstance();
-		
-		Test test = (Test) SpringContextLocator.getInstance().getBean("test");
-		test.myMethod();
-		test.anotherExample();
-	}
-}
diff --git a/SpringJava/SpringAspectJ/src/main/java/de/spring/example/SystemArchitecture.java b/SpringJava/SpringAspectJ/src/main/java/de/spring/example/SystemArchitecture.java
deleted file mode 100644
index ef83b3d..0000000
--- a/SpringJava/SpringAspectJ/src/main/java/de/spring/example/SystemArchitecture.java
+++ /dev/null
@@ -1,53 +0,0 @@
-package de.spring.example;
-
-import org.aspectj.lang.annotation.AfterReturning;
-import org.aspectj.lang.annotation.Aspect;
-import org.aspectj.lang.annotation.Pointcut;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-/**
- * 
- * We are using here the @AspectJ annotations to declare 
- * Proxies. If we want to use these kinds of proxies on the Spring framework
- * we have to use the <aop:aspectj-autoproxy/> annotation on the Spring xml file
- * (the Spring context file)
- */
-@Aspect
-public class SystemArchitecture {
-	private static final Logger LOGGER = LoggerFactory.getLogger(SpringStart.class);
-
-	
-	//Coonecting to the execution of any method defined in the 
-	//package: de.spring.example.web
-	//We are connecting the methods defined in that package with this
-	//Pointcut. So, when executing any of those methods defined in that
-	//package we will run the Advice related to this Pointcut (if there is an Advice)
-	@Pointcut("execution(* de.spring.example.web.*.*(..))")
-	public void pointCutMethod() 
-	{
-		LOGGER.info("I am the Pointcut and you will never see me.");
-		//This is the PointCut. 
-		//You can write code here, but it will be useless because while running
-		//the methods connected to the Pointcut, this code will not be executed.
-		//Just the advice will run!!!! :/
-		//Is not this weird? We are here defining a method whose code 
-		//will never be run. When the hell should we write code here?
-		//This is a waste of time and code IMHO. Isn't it?
-	}
-	
-	//NOTICE: YOU DO NOT NEED TO CREATE A SPECIAL CLASS FOR THE ADVICE
-	//        YOU COULD USE THE SAME CLASS FOR THE POINTCUTS AND FOR THE
-	//		  ADVICES. IN THIS CASE FOR EXAMPLE WE HAVE THE @AfterReturning
-	//		  ADVICE IN THIS CLASS AND THE @Before ADVICE IN THE CLASS CALLED
-	//		  MyAdvice
-	//This advice is connected with the another Pointcut.
-	//The returning value of every method connected to that Pointcut
-	//will be caught by this method.
-	@AfterReturning(pointcut="de.spring.example.SystemArchitecture.pointCutMethod())",
-					returning="retVal")
-	public void doAccessCheck(final Object retVal) {
-		LOGGER.info("The returned value by the method " +
-											"connected to the Pointcut: " + retVal);
-	}
-}
\ No newline at end of file
diff --git a/SpringJava/SpringAspectJ/src/main/java/de/spring/example/web/Test.java b/SpringJava/SpringAspectJ/src/main/java/de/spring/example/web/Test.java
deleted file mode 100644
index d01bd5d..0000000
--- a/SpringJava/SpringAspectJ/src/main/java/de/spring/example/web/Test.java
+++ /dev/null
@@ -1,30 +0,0 @@
-package de.spring.example.web;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-public class Test {
-	private static final Logger LOGGER = LoggerFactory.getLogger(Test.class);
-
-	public int myMethod()
-	{
-		LOGGER.info("The Advice should be run before.");
-		
-		//This value will be caught by the Advice with the @AfterReturning annotation.
-		return 666;
-	}
-	
-	public int anotherExample()
-	{
-		LOGGER.info("The Advice should be run before and after.");
-		return 666;
-		
-	}
-	
-    public class InnerTest {
-        public void innerMethod() {
-        	LOGGER.info("I am the inner class. The Advice should be run after."
-        			+ " NO NEED OF DECLARING Spring BEANS WHEN WEAVING!!!!");
-        }
-    }
-}
diff --git a/SpringJava/SpringAspectJ/src/main/resources/log4j2.xml b/SpringJava/SpringAspectJ/src/main/resources/log4j2.xml
deleted file mode 100644
index 8b3fc3f..0000000
--- a/SpringJava/SpringAspectJ/src/main/resources/log4j2.xml
+++ /dev/null
@@ -1,43 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-
-<!-- 
-	status: The level of internal Log4j events that should be logged to the console.
-	Valid values for this attribute are "trace", "debug", "info", "warn", "error" and "fatal".
-	
-	monitorInterval: The minimum amount of time, in seconds, that must elapse before the file configuration is checked for changes.
-	
-	
-	see https://logging.apache.org/log4j/2.x/manual/configuration.html
- -->
-<Configuration status="error" strict="true" monitorInterval="30"
-                name="XMLConfigTest" packages="org.apache.logging.log4j.test">
-                
-	<!--
-		ALL > TRACE > DEBUG > INFO > WARN > ERROR > OFF
-		
-		ERROR by default.
-	-->
-                
-    <Appenders>
-        <Appender type="Console" name="STDOUT">
-            <PatternLayout pattern="%d{HH:mm:ss.SSS} %-5level %class{36} %L %M - %msg%xEx%n"/>
-        </Appender>
-    </Appenders>
-    <Loggers>
-    
-       	<!-- 
-    		General logging Spring.
-    	 -->
-        <Logger name="org.springframework" level="INFO" additivity="false">
-            <AppenderRef ref="STDOUT" />
-        </Logger>
-    
-
-		<!-- 
-			Anything else will be using TRACE logging level.
-		 -->        
-        <Root level="DEBUG">
-            <AppenderRef ref="STDOUT"/>
-        </Root>
-    </Loggers>
-</Configuration>
diff --git a/SpringJava/SpringAspectJ/src/main/resources/spring-config.xml b/SpringJava/SpringAspectJ/src/main/resources/spring-config.xml
deleted file mode 100644
index 6aa0317..0000000
--- a/SpringJava/SpringAspectJ/src/main/resources/spring-config.xml
+++ /dev/null
@@ -1,59 +0,0 @@
-<?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" 
-       xmlns:aop="http://www.springframework.org/schema/aop"
-       xsi:schemaLocation="http://www.springframework.org/schema/beans 
-  						   http://www.springframework.org/schema/beans/spring-beans.xsd
-  						   http://www.springframework.org/schema/aop 
- 		 				   http://www.springframework.org/schema/aop/spring-aop.xsd
-  						   http://www.springframework.org/schema/context 
-  						   http://www.springframework.org/schema/context/spring-context.xsd
-  						   http://www.springframework.org/schema/tx 
-  						   http://www.springframework.org/schema/tx/spring-tx.xsd">
-	
-	<!-- 
-			         ************* WE HAVE TO ENABLE THE ASPECTJ SUPPORT!!!!!! ************* 
-			Otherwise the @Aspect annotation (defines @AspectJ aspects) will not work
-			It relies on the Java 5 specific AspectJ reflection APIs. You can not use it on
-			JDK 1.4 and below.
-			
-			
-			We could force here the use of CGLIB.
-			See: http://static.springsource.org/spring/docs/3.1.0.RC1/spring-framework-reference/html/aop.html#aop-proxying
-			Spring detects if the bean has an interface implementation. If it has one, Spring will use J2SE 
-			(J2SE needs classes with interfaces) in other case it will use CGLIB. 
-			In this example the "test" bean does not have an interface so Spring
-			will use CGLIB. We could force the use of CGLIB in classes with interfaces.
-	-->
-	<aop:aspectj-autoproxy/>
-	
-	<!-- 
-		We can mix aspect types. Without this AOP declaration this project would be SPRING ASPECTJ
-		but, because of this, we have a Spring Advice declaration so this project will be a SPRING AOP project
-		(or at least it is not just SPRING ASPECTJ based)
-		Besides we are using AOP support used in Spring 1.2 :/
-	 -->
-	<aop:config proxy-target-class="true">
-     	<aop:advisor pointcut="de.spring.example.SystemArchitecture.pointCutMethod()"
-     				 advice-ref="springAdvice" />
-    </aop:config>
-	
-	
-	<bean id="test" class="de.spring.example.web.Test">
-    	
-    </bean>
-	
-	<bean id="myAdvice" class="de.spring.example.MyAdvice">
-    	
-    </bean>
-    
-    <bean id="systemArchitecture" class="de.spring.example.SystemArchitecture">
-    	
-    </bean>
-    
-    <bean id="springAdvice" class="de.spring.example.SpringAdvice">
-    	
-    </bean>
-	
-</beans>
diff --git a/SpringJava/SpringLTW/README b/SpringJava/SpringLTW/README
deleted file mode 100644
index 9091fb8..0000000
--- a/SpringJava/SpringLTW/README
+++ /dev/null
@@ -1,3 +0,0 @@
-VM arguments:
-
--javaagent:$HOME/.m2/repository/org/springframework/spring-instrument/4.2.5.RELEASE/spring-instrument-4.2.5.RELEASE.jar
diff --git a/SpringJava/SpringLTW/pom.xml b/SpringJava/SpringLTW/pom.xml
deleted file mode 100644
index 5ebc4a0..0000000
--- a/SpringJava/SpringLTW/pom.xml
+++ /dev/null
@@ -1,190 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-
-<project
-	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"
-	xmlns="http://maven.apache.org/POM/4.0.0" 
-	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
-	
-	<modelVersion>4.0.0</modelVersion>
-    <groupId>de.spring.example</groupId>
-	<artifactId>spring-ltw</artifactId>
-    <version>2.0-SNAPSHOT</version>
-	<name>spring-ltw</name>
-	<url>http://gumartinm.name</url>
-    <properties>
-      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
-    </properties>
-
-	<dependencies> 
-       <dependency>
-           <groupId>org.springframework</groupId>
-           <artifactId>spring-context</artifactId>
-           <version>4.2.5.RELEASE</version>
-           <!-- 
-               Required dependency for getting rid of commons logging and use my own logging library
-               (in my case I decided to use log4j 2 under slf4j)
-           -->
-           <exclusions>
-               <exclusion>
-                   <groupId>commons-logging</groupId>
-                   <artifactId>commons-logging</artifactId>
-               </exclusion>
-           </exclusions>
-       </dependency>
-      <dependency>
-          <groupId>org.springframework</groupId>
-          <artifactId>spring-aspects</artifactId>
-          <version>4.2.5.RELEASE</version>
-          <!-- 
-              Required dependency for getting rid of commons logging and use my own logging library
-              (in my case I decided to use log4j 2 under slf4j)
-          -->
-          <exclusions>
-              <exclusion>
-                  <groupId>commons-logging</groupId>
-                  <artifactId>commons-logging</artifactId>
-              </exclusion>
-          </exclusions>
-      </dependency>
-      <dependency>
-          <groupId>org.springframework</groupId>
-          <artifactId>spring-aop</artifactId>
-          <version>4.2.5.RELEASE</version>
-          <!-- 
-              Required dependency for getting rid of commons logging and use my own logging library
-              (in my case I decided to use log4j 2 under slf4j)
-          -->
-          <exclusions>
-              <exclusion>
-                  <groupId>commons-logging</groupId>
-                  <artifactId>commons-logging</artifactId>
-              </exclusion>
-          </exclusions>
-      </dependency>
-      <dependency>
-    		<groupId>org.springframework</groupId>
-    		<artifactId>spring-instrument</artifactId>
-    		<version>4.2.5.RELEASE</version>
-    		          <!-- 
-              Required dependency for getting rid of commons logging and use my own logging library
-              (in my case I decided to use log4j 2 under slf4j)
-          -->
-          <exclusions>
-              <exclusion>
-                  <groupId>commons-logging</groupId>
-                  <artifactId>commons-logging</artifactId>
-              </exclusion>
-          </exclusions>
-		</dependency>
-		<dependency>
-    		<groupId>javax.cache</groupId>
-    		<artifactId>cache-api</artifactId>
-    		<version>1.0.0-PFD</version>
-		</dependency>
-		<dependency>
-		    <groupId>javax.transaction</groupId>
-		    <artifactId>javax.transaction-api</artifactId>
-		    <version>1.2</version>
-		</dependency>
-		<dependency>
-    		<groupId>org.springframework</groupId>
-    		<artifactId>spring-context-support</artifactId>
-    		<version>4.2.5.RELEASE</version>
-    		          <!-- 
-              Required dependency for getting rid of commons logging and use my own logging library
-              (in my case I decided to use log4j 2 under slf4j)
-          -->
-          <exclusions>
-              <exclusion>
-                  <groupId>commons-logging</groupId>
-                  <artifactId>commons-logging</artifactId>
-              </exclusion>
-          </exclusions>
-		</dependency>
-      <dependency>
-          <groupId>org.springframework</groupId>
-          <artifactId>spring-jdbc</artifactId>
-          <version>4.2.5.RELEASE</version>
-          <!-- 
-              Required dependency for getting rid of commons logging and use my own logging library
-              (in my case I decided to use log4j 2 under slf4j)
-          -->
-          <exclusions>
-              <exclusion>
-                  <groupId>commons-logging</groupId>
-                  <artifactId>commons-logging</artifactId>
-              </exclusion>
-          </exclusions>
-      </dependency>
-
-      <dependency>
-        <groupId>cglib</groupId>
-        <artifactId>cglib</artifactId>
-        <version>3.2.1</version>
-      </dependency>
-
-		<dependency>
-			<groupId>com.mchange</groupId>
-			<artifactId>c3p0</artifactId>
-			<version>0.9.5.2</version>
-		</dependency>
-		<dependency>
-			<groupId>mysql</groupId>
-			<artifactId>mysql-connector-java</artifactId>
-			<version>5.1.38</version>
-		</dependency>
-
-      <!--
-          1/3 Required dependency for log4j 2 with slf4j: binding between log4j 2 and slf4j
-      -->
-      <dependency>
-          <groupId>org.apache.logging.log4j</groupId>
-          <artifactId>log4j-slf4j-impl</artifactId>
-          <version>2.3</version>
-      </dependency>
-      <!--
-          2/3 Required dependency for log4j 2 with slf4j: log4j 2 maven plugin (it is the log4j 2 implementation)
-      -->
-      <dependency>
-          <groupId>org.apache.logging.log4j</groupId>
-          <artifactId>log4j-core</artifactId>
-          <version>2.3</version>
-      </dependency>
-      <!-- 
-          3/3 Required dependency for getting rid of commons logging.
-          This is the BRIDGE (no binding) between Jakarta Commons Logging (used by Spring) and whatever
-          I am using for logging (in this case I am using log4j 2)
-          See: http://www.slf4j.org/legacy.html
-          
-          We need exclusions in every dependency using Jakarta Commons Logging (see Spring dependencies below)
-       -->
-      <dependency>
-          <groupId>org.slf4j</groupId>
-          <artifactId>jcl-over-slf4j</artifactId>
-          <version>1.7.12</version>
-      </dependency>
-
-	</dependencies>
-    <build>
-      <plugins>
-          <plugin>
-              <groupId>org.apache.maven.plugins</groupId>
-              <artifactId>maven-compiler-plugin</artifactId>
-              <version>3.3</version>
-              <configuration>
-                  <source>1.8</source>
-                  <target>1.8</target>
-                  <encoding>${project.build.sourceEncoding}</encoding>
-              </configuration>
-          </plugin>
-          <plugin>
-              <groupId>org.apache.maven.plugins</groupId>
-              <artifactId>maven-resources-plugin</artifactId>
-              <version>2.7</version>
-              <configuration>
-                  <encoding>${project.build.sourceEncoding}</encoding>
-              </configuration>
-          </plugin>
-      </plugins>
-    </build>
-</project>
diff --git a/SpringJava/SpringLTW/src/main/java/de/spring/example/MyAdvice.java b/SpringJava/SpringLTW/src/main/java/de/spring/example/MyAdvice.java
deleted file mode 100644
index 6e25974..0000000
--- a/SpringJava/SpringLTW/src/main/java/de/spring/example/MyAdvice.java
+++ /dev/null
@@ -1,28 +0,0 @@
-package de.spring.example;
-
-import org.aspectj.lang.annotation.After;
-import org.aspectj.lang.annotation.Aspect;
-import org.aspectj.lang.annotation.Before;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-@Aspect
-public class MyAdvice {
-	private static final Logger LOGGER = LoggerFactory.getLogger(MyAdvice.class);
-
-	// With execution we avoid double weaving (when call and when execution)
-    @Before("@annotation(de.spring.example.annotation.initTransactional) && execution(* *(..))")
-    public void initTransactional()
-    {
-    	LOGGER.info("I am the Advice initTransaction.");
-        TransactionManager.getInstance().initTransaction();
-    }
-
-
-	// With execution we avoid double weaving (when call and when execution)
-    @After("@annotation(de.spring.example.annotation.commitTransactional) && execution(* *(..))")
-    public void commitTransactional() {
-    	LOGGER.info("I am the Advice commitTransaction.");
-        TransactionManager.getInstance().commitTransaction();
-    }
-}
diff --git a/SpringJava/SpringLTW/src/main/java/de/spring/example/SpringContextLocator.java b/SpringJava/SpringLTW/src/main/java/de/spring/example/SpringContextLocator.java
deleted file mode 100644
index 8a82a3a..0000000
--- a/SpringJava/SpringLTW/src/main/java/de/spring/example/SpringContextLocator.java
+++ /dev/null
@@ -1,57 +0,0 @@
-package de.spring.example;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import org.springframework.context.ApplicationContext;
-import org.springframework.context.support.ClassPathXmlApplicationContext;
-
-
-/**
- *
- */
-public final class SpringContextLocator {
-	private static final Logger LOGGER = LoggerFactory.getLogger(SpringContextLocator.class);
-
-
-        // Singleton Pattern
-        private static SpringContextLocator instance;
-
-        // Spring ApplicationContext
-        private static ApplicationContext context;
-
-        // Spring Context
-        private static final String SPRING_CONFIG_CONTEXT="/spring-config.xml";
-
-
-        /**
-         * Private constructor. Singleton pattern.
-         */
-        private SpringContextLocator() {
-                String[] factoryFiles = null;
-                LOGGER.info("Loading context files: " + SpringContextLocator.SPRING_CONFIG_CONTEXT);
-
-                factoryFiles = new String[] { SPRING_CONFIG_CONTEXT };
-
-                SpringContextLocator.context = new ClassPathXmlApplicationContext(factoryFiles);
-
-                LOGGER.info("The context has been loaded successfully!! ");
-        }
-
-        /**
-         * Singleton pattern not thread safety. To use SingletoHolder pattern as the best approximation 
-         * otherwise to use an Enum class (see Effective Java Second Edition and ) if we need serialization.
-         */
-        public static SpringContextLocator getInstance() {
-                if (SpringContextLocator.instance == null) {
-                        SpringContextLocator.instance = new SpringContextLocator();
-                }
-                return SpringContextLocator.instance;
-        }
-
-        /**
-         * Return bean from application context.
-         */
-        public Object getBean(final String name) {
-                return SpringContextLocator.context.getBean(name);
-        }
-}
\ No newline at end of file
diff --git a/SpringJava/SpringLTW/src/main/java/de/spring/example/SpringStart.java b/SpringJava/SpringLTW/src/main/java/de/spring/example/SpringStart.java
deleted file mode 100644
index 2aba4c2..0000000
--- a/SpringJava/SpringLTW/src/main/java/de/spring/example/SpringStart.java
+++ /dev/null
@@ -1,22 +0,0 @@
-package de.spring.example;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import de.spring.example.web.Test;
-
-public class SpringStart {
-	private static final Logger LOGGER = LoggerFactory.getLogger(SpringStart.class);
-
-	
-	/**
-	 * @param args
-	 */
-	public static void main(String[] args) {
-		LOGGER.info("Starting application");
-		SpringContextLocator.getInstance();
-		
-		Test test = (Test) SpringContextLocator.getInstance().getBean("testOuter");
-		test.myMethod();
-	}
-}
diff --git a/SpringJava/SpringLTW/src/main/java/de/spring/example/TransactionManager.java b/SpringJava/SpringLTW/src/main/java/de/spring/example/TransactionManager.java
deleted file mode 100644
index 53f3c59..0000000
--- a/SpringJava/SpringLTW/src/main/java/de/spring/example/TransactionManager.java
+++ /dev/null
@@ -1,48 +0,0 @@
-package de.spring.example;
-
-import org.aspectj.lang.annotation.Aspect;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import org.springframework.jdbc.datasource.DataSourceTransactionManager;
-import org.springframework.transaction.TransactionStatus;
-
-@Aspect
-public class TransactionManager {
-	private static final Logger LOGGER = LoggerFactory.getLogger(TransactionManager.class);
-    private static TransactionManager instance = new TransactionManager();
-    private DataSourceTransactionManager transactionManager;
-    private TransactionStatus transactionStatus;
-
-    //Why could you want to extend this class?
-    private TransactionManager() {
-    }
-
-    public static TransactionManager getInstance() {
-        return instance;
-    }
-
-    public void initTransaction()
-    {
-    	LOGGER.info("initTRANSACTION");
-        // transactionStatus = this.transactionManager.getTransaction(null);
-    }
-
-    public void rollbackTransaction()
-    {
-        this.transactionManager.rollback(this.transactionStatus);
-    }
-
-
-    public void commitTransaction()
-    {
-    	LOGGER.info("commitTRANSACTION");
-        // this.transactionManager.commit(this.transactionStatus);
-    }
-
-
-    /************************* Setters and getters *******************************************/
-    public void setTransactionManager(final DataSourceTransactionManager  transactionManager)
-    {
-        this.transactionManager = transactionManager;
-    }
-}
diff --git a/SpringJava/SpringLTW/src/main/java/de/spring/example/annotation/commitTransactional.java b/SpringJava/SpringLTW/src/main/java/de/spring/example/annotation/commitTransactional.java
deleted file mode 100644
index 1fda03f..0000000
--- a/SpringJava/SpringLTW/src/main/java/de/spring/example/annotation/commitTransactional.java
+++ /dev/null
@@ -1,14 +0,0 @@
-package de.spring.example.annotation;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-import org.springframework.stereotype.Component;
-
-@Target({ElementType.METHOD, ElementType.TYPE})
-@Retention(RetentionPolicy.RUNTIME)
-@Component
-public @interface commitTransactional {
-}
diff --git a/SpringJava/SpringLTW/src/main/java/de/spring/example/annotation/initTransactional.java b/SpringJava/SpringLTW/src/main/java/de/spring/example/annotation/initTransactional.java
deleted file mode 100644
index dad0b3e..0000000
--- a/SpringJava/SpringLTW/src/main/java/de/spring/example/annotation/initTransactional.java
+++ /dev/null
@@ -1,14 +0,0 @@
-package de.spring.example.annotation;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-import org.springframework.stereotype.Component;
-
-@Target({ElementType.METHOD, ElementType.TYPE})
-@Retention(RetentionPolicy.RUNTIME)
-@Component
-public @interface initTransactional {
-}
diff --git a/SpringJava/SpringLTW/src/main/java/de/spring/example/web/Test.java b/SpringJava/SpringLTW/src/main/java/de/spring/example/web/Test.java
deleted file mode 100644
index 5cd7d2a..0000000
--- a/SpringJava/SpringLTW/src/main/java/de/spring/example/web/Test.java
+++ /dev/null
@@ -1,40 +0,0 @@
-package de.spring.example.web;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import de.spring.example.annotation.commitTransactional;
-import de.spring.example.annotation.initTransactional;
-
-
-public class Test {
-	private static final Logger LOGGER = LoggerFactory.getLogger(Test.class);
-
-    @initTransactional
-    public int myMethod()
-    {
-    	LOGGER.info("The Advice should be run before.");
-
-    	annotatedPrivateMethod();
-    	
-    	InnerTest innerTest = new InnerTest();
-    	innerTest.innerMethod();
-    	
-        return 666;
-    }
-
-    public class InnerTest {
-        @commitTransactional
-        public void innerMethod() {
-        	LOGGER.info("I am the inner class. The Advice should be run after."
-        			+ " NO NEED OF DECLARING Spring BEANS WHEN WEAVING!!!!");
-        }
-    }
-    
-    // IT WORKS WHEN WEAVING!!!
-    @initTransactional
-    private void annotatedPrivateMethod() {
-    	LOGGER.info("The Advice should be run before even with private methods because I AM WEAVING."
-    			+ " IT WORKS EVEN CALLING FROM METHOD OF THE SAME CLASS. It doesn't when using proxies AOP.");
-    }
-}
diff --git a/SpringJava/SpringLTW/src/main/resources/META-INF/aop.xml b/SpringJava/SpringLTW/src/main/resources/META-INF/aop.xml
deleted file mode 100644
index 2345268..0000000
--- a/SpringJava/SpringLTW/src/main/resources/META-INF/aop.xml
+++ /dev/null
@@ -1,23 +0,0 @@
-<!DOCTYPE aspectj PUBLIC
-        "-//AspectJ//DTD//EN" "http://www.eclipse.org/aspectj/dtd/aspectj.dtd">
-
-<aspectj>
-	<!--
-		With or without logs
-	<weaver>
-	-->	
-	<weaver options="-verbose -showWeaveInfo">
-        <!-- only weave classes in our application-specific packages -->
-       	<include within="de.spring..*"/>
-		<!--
-			Dump all types within the "somepack" package before they are woven
-			to the "./_ajdump" folder on disk
-		-->
-		<dump within="de.spring..*"/>	
-    </weaver>
-    
-    <aspects>
-        <aspect name="de.spring.example.MyAdvice"/>        
-    </aspects>
-
-</aspectj>
diff --git a/SpringJava/SpringLTW/src/main/resources/log4j2.xml b/SpringJava/SpringLTW/src/main/resources/log4j2.xml
deleted file mode 100644
index 8b3fc3f..0000000
--- a/SpringJava/SpringLTW/src/main/resources/log4j2.xml
+++ /dev/null
@@ -1,43 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-
-<!-- 
-	status: The level of internal Log4j events that should be logged to the console.
-	Valid values for this attribute are "trace", "debug", "info", "warn", "error" and "fatal".
-	
-	monitorInterval: The minimum amount of time, in seconds, that must elapse before the file configuration is checked for changes.
-	
-	
-	see https://logging.apache.org/log4j/2.x/manual/configuration.html
- -->
-<Configuration status="error" strict="true" monitorInterval="30"
-                name="XMLConfigTest" packages="org.apache.logging.log4j.test">
-                
-	<!--
-		ALL > TRACE > DEBUG > INFO > WARN > ERROR > OFF
-		
-		ERROR by default.
-	-->
-                
-    <Appenders>
-        <Appender type="Console" name="STDOUT">
-            <PatternLayout pattern="%d{HH:mm:ss.SSS} %-5level %class{36} %L %M - %msg%xEx%n"/>
-        </Appender>
-    </Appenders>
-    <Loggers>
-    
-       	<!-- 
-    		General logging Spring.
-    	 -->
-        <Logger name="org.springframework" level="INFO" additivity="false">
-            <AppenderRef ref="STDOUT" />
-        </Logger>
-    
-
-		<!-- 
-			Anything else will be using TRACE logging level.
-		 -->        
-        <Root level="DEBUG">
-            <AppenderRef ref="STDOUT"/>
-        </Root>
-    </Loggers>
-</Configuration>
diff --git a/SpringJava/SpringLTW/src/main/resources/spring-config.xml b/SpringJava/SpringLTW/src/main/resources/spring-config.xml
deleted file mode 100644
index ffb978c..0000000
--- a/SpringJava/SpringLTW/src/main/resources/spring-config.xml
+++ /dev/null
@@ -1,68 +0,0 @@
-<?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:schemaLocation="http://www.springframework.org/schema/beans 
-  						   http://www.springframework.org/schema/beans/spring-beans.xsd
-  						   http://www.springframework.org/schema/context 
-  						   http://www.springframework.org/schema/context/spring-context.xsd">
-
-	<!-- 
-			We have to use SPRING ASPECTJ (no SPRING AOP 2.0/1.2) because we want to use
-		annotations with inner classes.
-			AspectJ under this configuration requires at least one 'META-INF/aop.xml' file
-		with the configuration about the Advices.
-			
-		This switches on the load-time weaving 
-	    See: http://static.springsource.org/spring/docs/3.1.0.M2/spring-framework-reference/html/aop.html#aop-aj-ltw-spring
-	-->
-    <context:load-time-weaver  weaver-class="org.springframework.instrument.classloading.InstrumentationLoadTimeWeaver"
-    						   aspectj-weaving="autodetect"/>
-    
-	
-	<bean id="myAdvice" class="de.spring.example.MyAdvice">
-    	
-    </bean>
-
- 	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy-method="close">
-                <property name="user" value="root"/>
-                <property name="password" value=""/>
-                <property name="driverClass" value="com.mysql.jdbc.Driver"/>
-                <property name="jdbcUrl" value="jdbc:mysql://127.0.0.1:3306/example?autoReconnect=true"/>
-                <property name="initialPoolSize" value="5"/>
-                <property name="maxPoolSize" value="20"/>
-                <property name="minPoolSize" value="10"/>
-                <property name="acquireIncrement" value="1"/>
-                <property name="acquireRetryAttempts" value="5"/>
-                <property name="acquireRetryDelay" value="1000"/>
-                <property name="automaticTestTable" value="con_test"/>
-                <property name="checkoutTimeout" value="5000"/>
-    </bean>
- 
-    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
-		<property name="dataSource" ref="dataSource"/>
-	</bean>
-	
-	<bean id="myTransactionManager"
-	       class="de.spring.example.TransactionManager"
-	       factory-method="getInstance">
-        <property name="transactionManager">
-            <ref bean="transactionManager" />
-        </property>
-    </bean>
-	
-	<!-- 
-    		In order to find annotations in inner classes we have to create Spring 
-    	beans of them. NO WHEN WEAVING!!! :)
-    -->
-    <bean id="testOuter" class="de.spring.example.web.Test"/>
-    
-    <!--
-    	WHEN WEAVING WE MAY ANNOTATE METHODS IN INNER CLASSES. SO, WE DO NOT NEED TO CREATE
-    	Spring BEANS OF THEM. WITH PROXY AOP WE HAVE TO, BUT WHEN WEAVING NO!!!  
-    <bean id="testInner" class="de.spring.example.web.Test$InnerTest">
-        <constructor-arg ref="testOuter"/>
-    </bean>
-    -->
-    
-</beans>